@readme/httpsnippet 4.0.1 → 4.0.2

package/dist/src/targets/ruby/native/client.js

@@ -0,0 +1,69 @@
+"use strict";
+exports.__esModule = true;
+exports.native = void 0;
+var code_builder_1 = require("../../../helpers/code-builder");
+exports.native = {
+    info: {
+        key: 'native',
+        title: 'net::http',
+        link: 'http://ruby-doc.org/stdlib-2.2.1/libdoc/net/http/rdoc/Net/HTTP.html',
+        description: 'Ruby HTTP client'
+    },
+    convert: function (_a) {
+        var uriObj = _a.uriObj, rawMethod = _a.method, fullUrl = _a.fullUrl, postData = _a.postData, allHeaders = _a.allHeaders;
+        var _b = new code_builder_1.CodeBuilder(), push = _b.push, blank = _b.blank, join = _b.join;
+        push("require 'uri'");
+        push("require 'net/http'");
+        if (uriObj.protocol === 'https:') {
+            push("require 'openssl'");
+        }
+        blank();
+        // To support custom methods we check for the supported methods
+        // and if doesn't exist then we build a custom class for it
+        var method = rawMethod.toUpperCase();
+        var methods = [
+            'GET',
+            'POST',
+            'HEAD',
+            'DELETE',
+            'PATCH',
+            'PUT',
+            'OPTIONS',
+            'COPY',
+            'LOCK',
+            'UNLOCK',
+            'MOVE',
+            'TRACE',
+        ];
+        var capMethod = method.charAt(0) + method.substring(1).toLowerCase();
+        if (!methods.includes(method)) {
+            push("class Net::HTTP::".concat(capMethod, " < Net::HTTPRequest"));
+            push("  METHOD = '".concat(method.toUpperCase(), "'"));
+            push("  REQUEST_HAS_BODY = '".concat(postData.text ? 'true' : 'false', "'"));
+            push('  RESPONSE_HAS_BODY = true');
+            push('end');
+            blank();
+        }
+        push("url = URI(\"".concat(fullUrl, "\")"));
+        blank();
+        push('http = Net::HTTP.new(url.host, url.port)');
+        if (uriObj.protocol === 'https:') {
+            push('http.use_ssl = true');
+        }
+        blank();
+        push("request = Net::HTTP::".concat(capMethod, ".new(url)"));
+        var headers = Object.keys(allHeaders);
+        if (headers.length) {
+            headers.forEach(function (key) {
+                push("request[\"".concat(key, "\"] = '").concat(allHeaders[key], "'"));
+            });
+        }
+        if (postData.text) {
+            push("request.body = ".concat(JSON.stringify(postData.text)));
+        }
+        blank();
+        push('response = http.request(request)');
+        push('puts response.read_body');
+        return join();
+    }
+};

package/dist/src/targets/ruby/target.js

@@ -0,0 +1,15 @@
+"use strict";
+exports.__esModule = true;
+exports.ruby = void 0;
+var client_1 = require("./native/client");
+exports.ruby = {
+    info: {
+        key: 'ruby',
+        title: 'Ruby',
+        extname: '.rb',
+        "default": 'native'
+    },
+    clientsById: {
+        native: client_1.native
+    }
+};

package/dist/src/targets/shell/curl/client.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * @description
+ *
+ * HTTP code snippet generator for the Shell using cURL.
+ *
+ * @author
+ * @AhmadNassri
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.curl = void 0;
+var code_builder_1 = require("../../../helpers/code-builder");
+var headers_1 = require("../../../helpers/headers");
+var shell_1 = require("../../../helpers/shell");
+/**
+ * This is a const record with keys that correspond to the long names and values that correspond to the short names for cURL arguments.
+ */
+var params = {
+    globoff: 'g',
+    request: 'X',
+    'url ': '',
+    'http1.0': '0',
+    header: 'H',
+    cookie: 'b',
+    form: 'F',
+    data: 'd'
+};
+var getArg = function (short) { return function (longName) {
+    if (short) {
+        var shortName = params[longName];
+        if (!shortName) {
+            return '';
+        }
+        return "-".concat(shortName);
+    }
+    return "--".concat(longName);
+}; };
+exports.curl = {
+    info: {
+        key: 'curl',
+        title: 'cURL',
+        link: 'http://curl.haxx.se/',
+        description: 'cURL is a command line tool and library for transferring data with URL syntax'
+    },
+    convert: function (_a, options) {
+        var _b;
+        var fullUrl = _a.fullUrl, method = _a.method, httpVersion = _a.httpVersion, headersObj = _a.headersObj, allHeaders = _a.allHeaders, postData = _a.postData;
+        if (options === void 0) { options = {}; }
+        var _c = options.indent, indent = _c === void 0 ? '  ' : _c, _d = options.short, short = _d === void 0 ? false : _d, _e = options.binary, binary = _e === void 0 ? false : _e, _f = options.globOff, globOff = _f === void 0 ? false : _f, _g = options.escapeBrackets, escapeBrackets = _g === void 0 ? false : _g;
+        var _h = new code_builder_1.CodeBuilder(__assign(__assign({}, (typeof indent === 'string' ? { indent: indent } : {})), { join: indent !== false ? " \\\n".concat(indent) : ' ' })), push = _h.push, join = _h.join;
+        var arg = getArg(short);
+        var formattedUrl = (0, shell_1.quote)(fullUrl);
+        if (escapeBrackets) {
+            formattedUrl = formattedUrl.replace(/\[/g, '\\[').replace(/\]/g, '\\]');
+        }
+        push("curl ".concat(arg('request'), " ").concat(method));
+        if (globOff) {
+            formattedUrl = unescape(formattedUrl);
+            push(arg('globoff'));
+        }
+        push("".concat(arg('url ')).concat(formattedUrl));
+        if (httpVersion === 'HTTP/1.0') {
+            push(arg('http1.0'));
+        }
+        // if multipart form data, we want to remove the boundary
+        if (postData.mimeType === 'multipart/form-data') {
+            var contentTypeHeaderName = (0, headers_1.getHeaderName)(headersObj, 'content-type');
+            if (contentTypeHeaderName) {
+                var contentTypeHeader = headersObj[contentTypeHeaderName];
+                if (contentTypeHeaderName && contentTypeHeader) {
+                    // remove the leading semi colon and boundary
+                    // up to the next semi colon or the end of string
+                    var noBoundary = String(contentTypeHeader).replace(/; boundary.+?(?=(;|$))/, '');
+                    // replace the content-type header with no boundary in both headersObj and allHeaders
+                    headersObj[contentTypeHeaderName] = noBoundary;
+                    allHeaders[contentTypeHeaderName] = noBoundary;
+                }
+            }
+        }
+        // construct headers
+        Object.keys(headersObj)
+            .sort()
+            .forEach(function (key) {
+            var header = "".concat(key, ": ").concat(headersObj[key]);
+            push("".concat(arg('header'), " ").concat((0, shell_1.quote)(header)));
+        });
+        if (allHeaders.cookie) {
+            push("".concat(arg('cookie'), " ").concat((0, shell_1.quote)(allHeaders.cookie)));
+        }
+        // construct post params
+        switch (postData.mimeType) {
+            case 'multipart/form-data':
+                (_b = postData.params) === null || _b === void 0 ? void 0 : _b.forEach(function (param) {
+                    var post = '';
+                    if (param.fileName) {
+                        post = "".concat(param.name, "=@").concat(param.fileName);
+                    }
+                    else {
+                        post = "".concat(param.name, "=").concat(param.value);
+                    }
+                    push("".concat(arg('form'), " ").concat((0, shell_1.quote)(post)));
+                });
+                break;
+            case 'application/x-www-form-urlencoded':
+                if (postData.params) {
+                    postData.params.forEach(function (param) {
+                        var unencoded = param.name;
+                        var encoded = encodeURIComponent(param.name);
+                        var needsEncoding = encoded !== unencoded;
+                        var name = needsEncoding ? encoded : unencoded;
+                        var flag = binary ? '--data-binary' : "--data".concat(needsEncoding ? '-urlencode' : '');
+                        push("".concat(flag, " ").concat((0, shell_1.quote)("".concat(name, "=").concat(param.value))));
+                    });
+                }
+                else {
+                    push("".concat(binary ? '--data-binary' : arg('data'), " ").concat((0, shell_1.quote)(postData.text)));
+                }
+                break;
+            default:
+                // raw request body
+                if (!postData.text) {
+                    break;
+                }
+                // eslint-disable-next-line no-case-declarations -- builtPayload is only used here.
+                var builtPayload = false;
+                // If we're dealing with a JSON variant, and our payload is JSON let's make it look a little
+                // nicer.
+                if ((0, headers_1.isMimeTypeJSON)(postData.mimeType)) {
+                    // If our postData is less than 20 characters, let's keep it all on one line so as to not
+                    // make the snippet overly lengthy
+                    if (postData.text.length > 20) {
+                        try {
+                            var jsonPayload = JSON.parse(postData.text);
+                            // If the JSON object has a single quote we should prepare it inside of a HEREDOC
+                            // because the single quote in something like `string's` can't be escaped when used
+                            // with `--data`.
+                            //
+                            // Basically this boils down to `--data @- <<EOF...EOF` vs `--data '...'`.
+                            builtPayload = true;
+                            if (postData.text.indexOf("'") > 0) {
+                                push("".concat(binary ? '--data-binary' : arg('data'), " @- <<EOF\n").concat(JSON.stringify(jsonPayload, null, indent || ' '), "\nEOF"));
+                            }
+                            else {
+                                push("".concat(binary ? '--data-binary' : arg('data'), " '\n").concat(JSON.stringify(jsonPayload, null, indent || ' '), "\n'"));
+                            }
+                        }
+                        catch (err) {
+                            // no-op
+                        }
+                    }
+                }
+                if (!builtPayload) {
+                    push("".concat(binary ? '--data-binary' : arg('data'), " ").concat((0, shell_1.quote)(postData.text)));
+                }
+        }
+        return join();
+    }
+};

package/dist/src/targets/shell/httpie/client.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * @description
+ * HTTP code snippet generator for the Shell using HTTPie.
+ *
+ * @author
+ * @AhmadNassri
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.httpie = void 0;
+var code_builder_1 = require("../../../helpers/code-builder");
+var shell_1 = require("../../../helpers/shell");
+exports.httpie = {
+    info: {
+        key: 'httpie',
+        title: 'HTTPie',
+        link: 'http://httpie.org/',
+        description: 'a CLI, cURL-like tool for humans'
+    },
+    convert: function (_a, options) {
+        var allHeaders = _a.allHeaders, postData = _a.postData, queryObj = _a.queryObj, fullUrl = _a.fullUrl, method = _a.method, url = _a.url;
+        var opts = __assign({ body: false, cert: false, headers: false, indent: '  ', pretty: false, print: false, queryParams: false, short: false, style: false, timeout: false, verbose: false, verify: false }, options);
+        var _b = new code_builder_1.CodeBuilder({
+            indent: opts.indent,
+            // @ts-expect-error SEEMS LEGIT
+            join: opts.indent !== false ? " \\\n".concat(opts.indent) : ' '
+        }), push = _b.push, join = _b.join, unshift = _b.unshift;
+        var raw = false;
+        var flags = [];
+        if (opts.headers) {
+            flags.push(opts.short ? '-h' : '--headers');
+        }
+        if (opts.body) {
+            flags.push(opts.short ? '-b' : '--body');
+        }
+        if (opts.verbose) {
+            flags.push(opts.short ? '-v' : '--verbose');
+        }
+        if (opts.print) {
+            flags.push("".concat(opts.short ? '-p' : '--print', "=").concat(opts.print));
+        }
+        if (opts.verify) {
+            flags.push("--verify=".concat(opts.verify));
+        }
+        if (opts.cert) {
+            flags.push("--cert=".concat(opts.cert));
+        }
+        if (opts.pretty) {
+            flags.push("--pretty=".concat(opts.pretty));
+        }
+        if (opts.style) {
+            flags.push("--style=".concat(opts.style));
+        }
+        if (opts.timeout) {
+            flags.push("--timeout=".concat(opts.timeout));
+        }
+        // construct query params
+        if (opts.queryParams) {
+            Object.keys(queryObj).forEach(function (name) {
+                var value = queryObj[name];
+                if (Array.isArray(value)) {
+                    value.forEach(function (val) {
+                        push("".concat(name, "==").concat((0, shell_1.quote)(val)));
+                    });
+                }
+                else {
+                    push("".concat(name, "==").concat((0, shell_1.quote)(value)));
+                }
+            });
+        }
+        // construct headers
+        Object.keys(allHeaders)
+            .sort()
+            .forEach(function (key) {
+            push("".concat(key, ":").concat((0, shell_1.quote)(allHeaders[key])));
+        });
+        if (postData.mimeType === 'application/x-www-form-urlencoded') {
+            // construct post params
+            if (postData.params && postData.params.length) {
+                flags.push(opts.short ? '-f' : '--form');
+                postData.params.forEach(function (param) {
+                    push("".concat(param.name, "=").concat((0, shell_1.quote)(param.value)));
+                });
+            }
+        }
+        else {
+            raw = true;
+        }
+        var cliFlags = flags.length ? "".concat(flags.join(' '), " ") : '';
+        url = (0, shell_1.quote)(opts.queryParams ? url : fullUrl);
+        unshift("http ".concat(cliFlags).concat(method, " ").concat(url));
+        if (raw && postData.text) {
+            var postDataText = (0, shell_1.quote)(postData.text);
+            unshift("echo ".concat(postDataText, " | "));
+        }
+        return join();
+    }
+};

package/dist/src/targets/shell/target.js

@@ -0,0 +1,20 @@
+"use strict";
+exports.__esModule = true;
+exports.shell = void 0;
+var client_1 = require("./curl/client");
+var client_2 = require("./httpie/client");
+var client_3 = require("./wget/client");
+exports.shell = {
+    info: {
+        key: 'shell',
+        title: 'Shell',
+        extname: '.sh',
+        "default": 'curl',
+        cli: '%s'
+    },
+    clientsById: {
+        curl: client_1.curl,
+        httpie: client_2.httpie,
+        wget: client_3.wget
+    }
+};

package/dist/src/targets/shell/wget/client.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * @description
+ * HTTP code snippet generator for the Shell using Wget.
+ *
+ * @author
+ * @AhmadNassri
+ *
+ * for any questions or issues regarding the generated code snippet, please open an issue mentioning the author.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.wget = void 0;
+var code_builder_1 = require("../../../helpers/code-builder");
+var shell_1 = require("../../../helpers/shell");
+exports.wget = {
+    info: {
+        key: 'wget',
+        title: 'Wget',
+        link: 'https://www.gnu.org/software/wget/',
+        description: 'a free software package for retrieving files using HTTP, HTTPS'
+    },
+    convert: function (_a, options) {
+        var method = _a.method, postData = _a.postData, allHeaders = _a.allHeaders, fullUrl = _a.fullUrl;
+        var opts = __assign({ indent: '  ', short: false, verbose: false }, options);
+        var _b = new code_builder_1.CodeBuilder(__assign(__assign({}, (typeof opts.indent === 'string' ? { indent: opts.indent } : {})), { join: opts.indent !== false ? " \\\n".concat(opts.indent) : ' ' })), push = _b.push, join = _b.join;
+        if (opts.verbose) {
+            push("wget ".concat(opts.short ? '-v' : '--verbose'));
+        }
+        else {
+            push("wget ".concat(opts.short ? '-q' : '--quiet'));
+        }
+        push("--method ".concat((0, shell_1.quote)(method)));
+        Object.keys(allHeaders).forEach(function (key) {
+            var header = "".concat(key, ": ").concat(allHeaders[key]);
+            push("--header ".concat((0, shell_1.quote)(header)));
+        });
+        if (postData.text) {
+            push("--body-data ".concat((0, shell_1.escape)((0, shell_1.quote)(postData.text))));
+        }
+        push(opts.short ? '-O' : '--output-document');
+        push("- ".concat((0, shell_1.quote)(fullUrl)));
+        return join();
+    }
+};

package/dist/src/targets/swift/helpers.js

@@ -0,0 +1,80 @@
+"use strict";
+exports.__esModule = true;
+exports.literalRepresentation = exports.literalDeclaration = void 0;
+/**
+ * Create an string of given length filled with blank spaces
+ *
+ * @param length Length of the array to return
+ * @param str String to pad out with
+ */
+var buildString = function (length, str) { return str.repeat(length); };
+/**
+ * Create a string corresponding to a Dictionary or Array literal representation with pretty option and indentation.
+ */
+var concatArray = function (arr, pretty, indentation, indentLevel) {
+    var currentIndent = buildString(indentLevel, indentation);
+    var closingBraceIndent = buildString(indentLevel - 1, indentation);
+    var join = pretty ? ",\n".concat(currentIndent) : ', ';
+    if (pretty) {
+        return "[\n".concat(currentIndent).concat(arr.join(join), "\n").concat(closingBraceIndent, "]");
+    }
+    return "[".concat(arr.join(join), "]");
+};
+/**
+ * Create a string corresponding to a valid declaration and initialization of a Swift array or dictionary literal
+ *
+ * @param name Desired name of the instance
+ * @param parameters Key-value object of parameters to translate to a Swift object litearal
+ * @param opts Target options
+ * @return {string}
+ */
+var literalDeclaration = function (name, parameters, opts) {
+    return "let ".concat(name, " = ").concat((0, exports.literalRepresentation)(parameters, opts));
+};
+exports.literalDeclaration = literalDeclaration;
+/**
+ * Create a valid Swift string of a literal value according to its type.
+ *
+ * @param value Any JavaScript literal
+ * @param opts Target options
+ */
+var literalRepresentation = function (value, opts, indentLevel) {
+    indentLevel = indentLevel === undefined ? 1 : indentLevel + 1;
+    switch (Object.prototype.toString.call(value)) {
+        case '[object Number]':
+            return value;
+        case '[object Array]': {
+            // Don't prettify arrays nto not take too much space
+            var pretty_1 = false;
+            var valuesRepresentation = value.map(function (v) {
+                // Switch to prettify if the value is a dictionary with multiple keys
+                if (Object.prototype.toString.call(v) === '[object Object]') {
+                    pretty_1 = Object.keys(v).length > 1;
+                }
+                return (0, exports.literalRepresentation)(v, opts, indentLevel);
+            });
+            // @ts-expect-error needs better types
+            return concatArray(valuesRepresentation, pretty_1, opts.indent, indentLevel);
+        }
+        case '[object Object]': {
+            var keyValuePairs = [];
+            // eslint-disable-next-line guard-for-in, no-restricted-syntax
+            for (var key in value) {
+                keyValuePairs.push("\"".concat(key, "\": ").concat((0, exports.literalRepresentation)(value[key], opts, indentLevel)));
+            }
+            return concatArray(keyValuePairs, 
+            // @ts-expect-error needs better types
+            opts.pretty && keyValuePairs.length > 1, 
+            // @ts-expect-error needs better types
+            opts.indent, indentLevel);
+        }
+        case '[object Boolean]':
+            return value.toString();
+        default:
+            if (value === null || value === undefined) {
+                return '';
+            }
+            return "\"".concat(value.toString().replace(/"/g, '\\"'), "\"");
+    }
+};
+exports.literalRepresentation = literalRepresentation;