Create a code generator | Paw Documentation

36 captures

13 Aug 2017 - 18 Aug 2025

May	JUN	Jul
	25
2019	2020	2021

success

fail

About this capture

COLLECTED BY

Collection: Arquivo.pt: the Portuguese web-archive

Arquivo.pt - The Portuguese web-archive (PWA) is the national Web archive of Portugal. Its mission is to periodically archive contents of national interest available on the Web, storing and preserving for future generations information of historical relevance. It is a service of the Foundation for Science and Technology (FCT).

TIMESTAMPS

The Wayback Machine - http://web.archive.org/web/20200625084649/https://paw.cloud/docs/extensions/create-code-generator

Documentation ●Create a code generator●Create your extension●Choose an extension identifier●Create files and folders●Structure the JavaScript file●Methods●Static properties●Example●Define user inputs●Implement generate()●Use a template library (example with mustache.js)●Share your Code Generator●Use ES6 & webpack●Use CoffeeScriptCreate a code generator¶ ●Extensions●Create a code generator●API Reference●Context object●Request object●Code generatorYou can make Paw generate custom code for making HTTP requests in any language or framework; it can be also used to export data to 3rd party file formats. ../../_images/export-code-gen.png

../../_images/export-code-gen.png

You can export generated code to a file: File ‣ Export SelectionorFile ‣ Export All. Also, generated code will be previewed in the Code Inspector (⇧⌘C to show/hide).Create your extension¶ Choose an extension identifierChoose an extension identifier¶ The extension identifier should be a reverse domain name and have a unique and meaningful name (e.g. com.mycompany.MyImporter). Create files and foldersCreate files and folders¶ Open the Extensions Directory: you can find it in the Preferences ‣ Extensions ‣ Open Extensions Directory. ../../_images/open-extensions-dir.png

../../_images/open-extensions-dir.png

(一)Create a new folder and name it after your extension identifier.(二)Create a .js JavaScript file named after the last component of the identifier (e.g. MyCodeGenerator.js).(三)Additionally you can have a README file, or anything else.Your file tree should look like:Extensions/com.mycompany.MyCodeGenerator/●MyCodeGenerator.js●README.md Structure the JavaScript fileStructure the JavaScript file¶ An Extension is represented as a JavaScript class.Methods¶ Code Generators must have one method:generate(context, requests, options) Required: generates the codecontext: a Context instancerequests: an array of Request itemsoptions:inputs: the dictionary with all user inputsfile:●name: file name, if exported to file●path: file path, if exported to filehideCredentials whether user opted to obfuscate credentialsStatic properties¶ Also, the class object have these properties:●identifier Required: the extension identifier●title Required: the extension display name●fileExtension Optional: a file extension (excluding the dot .) for the output file●languageHighlighter Optional: a keyword identifying the language highlighter for the output (bash, coffeescript, css, go, http, java, javascript, json, markdown, objectivec, perl, php, python, ruby, scala, swift, xml, yaml)●inputs Optional: the inputs the extension will have (if any)●help Optional: a URI pointing to the dynamic value documentation (if any)Example¶

// Extensions are implemented as JavaScript classes
var MyCodeGenerator = function() {

   // implement the generate() method to generate code
   this.generate = function(context, requests, options) {
       var client_code = ""; // generate the code
       return client_code;
   }
}

// set the extension identifier (must be same as the directory name)
MyCodeGenerator.identifier = "com.mycompany.MyCodeGenerator";

// give a display name to your Code Generator
MyCodeGenerator.title = "My Code Generator";

// call to register function is required
registerCodeGenerator(MyCodeGenerator)

Define user inputsDefine user inputs¶ You can let the users of your Exporter enter inputs that you’ll get the value during the generate() call.Learn how to add input fields to your extension. ../../_images/all-exporter-inputs.png

../../_images/all-exporter-inputs.png

Implement generate()Implement generate()¶ Implement the generate(context, requests, options) method and return the code you want to generate. It gets:context: a Context instancerequests: an array of Request itemsoptions:inputs: the dictionary with all user inputsfile:●name: file name, if exported to file●path: file path, if exported to filehideCredentials whether user opted to obfuscate credentialsAlso, all available classes and functions are in the Reference.Here’s an example:

this.generate = function(context, requests, options) {
     var generated = "";

     // iterate requests (`Request` objects)
     for (var i in requests) {
         var request = requests[i];

         // iterate on request headers
         var headers = request.headers;
         for (var header_name in headers) {
             var header_value = headers[header_name];
             // do something
         }

         // get the latest response status code
         var status_code = request.getLastExchange().responseStatusCode;

         // get the latest response body
         var body = request.getLastExchange().responseBody;

         generated += status_code + "\n" + body + "\n\n";
     }

     // return the generated string
     return generated;
}

Use a template library (example with mustache.js)Use a template library (example with mustache.js)¶ While you don’t have to, it’s easier to use a template library to generate the client code. Here’s an example with mustache.js.(一)First of all, you need to add the mustache.js script into your extension directory. It’s available on GitHub.(二)Use require()orloadScript() functions to import ./mustache.(三)Create a mustache template file.(四)Import the template file in your JavaScript code, using the readFile() function.(五)Render template.Here’s an example JavaScript file:

var mustache = require('./mustache')
// legacy, import the mustache.js script (to Paw 2.2.2)
// require("mustache.js");

var MyCodeGenerator = function() {

 this.generate = function(context, requests, options) {
         var generated = "";

        // import the mustache template
        var template = readFile("my-template.mustache");

        // iterate requests (`Request` objects)
        for (var i in requests) {
             var request = requests[i];

             // define your view
             var view = {
                "request": request,
                "content_type": request.getHeaderByName('Content-Type'),
             };

             // render the template
             generated += Mustache.render(template, view) + "\n\n";
         }

         return generated;
    }
}

MyCodeGenerator.identifier = "com.mycompany.MyCodeGenerator";
MyCodeGenerator.title = "My Code Generator";
registerCodeGenerator(MyCodeGenerator)

And an example of mustache template file:

var send_request = function() {
    var url = "{{{request.url}}}";
    var content_type = "{{{content_type}}}";
}

Share your Code Generator¶ If you think your Code Generator may be helpful for others, feel free to share it on GitHub, and let us know so we will add it to the Extension list.Here’s an example of extension on GitHub: cURL code generator for Paw.Use ES6 & webpack¶ We encourage you to write your extensions in ES6, using Babel to convert to the version of EcmaScript the JavaScript Code engine (same as Safari) supports. See the cURL importer available on GitHub as an example of extension written in ES6, compiled with Babel, and using webpack as builder. It also have unit tests if you’re interested in making your extension rock solid!Use CoffeeScript¶ That’s a matter of personal preference, but if you prefer to write your extension using CoffeeScript, it’s possible.(一)Write your extension code in a .coffee file (e.g. MyCodeGenerator.coffee)(二)Add a Cakefile that compiles your code into JavaScript (here’s an example: Cakefile)(三)Share/commit the compiled JavaScript file along with the other files. (We’re in the process of using GitHub Releases to live compile files). ●Blog●Updates●Twitter●Press●Purchase●Account●Terms●Privacy Policy ●© 2020 Paw Cloud