sandboxed-api/contrib/jsonnet/jsonnet.patch

--- jsonnet.cpp	2020-09-09 12:15:33.687539042 +0000
+++ write_helper.cpp	2020-09-25 15:38:37.317147682 +0000
@@ -14,559 +14,125 @@
 limitations under the License.
 */
 
-#include <cassert>
-#include <cstdlib>
-#include <cstring>
+// We need two functions defined in jsonnet.cpp file, used for writing output
+// (multiple files and yaml streams) -- with minor changes (e.x. return type).
 
-#include <exception>
 #include <fstream>
 #include <iostream>
-#include <list>
 #include <map>
-#include <sstream>
-#include <string>
 #include <vector>
 
-#include "utils.h"
+#include "contrib/jsonnet/jsonnet_helper.h"
 
-extern "C" {
-#include <libjsonnet.h>
-}
-
-#ifdef _WIN32
-const char PATH_SEP = ';';
-#else
-const char PATH_SEP = ':';
-#endif
-
-void version(std::ostream &o)
-{
-    o << "Jsonnet commandline interpreter " << jsonnet_version() << std::endl;
-}
-
-void usage(std::ostream &o)
-{
-    version(o);
-    o << "\n";
-    o << "jsonnet {<option>} <filename>\n";
-    o << "\n";
-    o << "Available options:\n";
-    o << "  -h / --help             This message\n";
-    o << "  -e / --exec             Treat filename as code\n";
-    o << "  -J / --jpath <dir>      Specify an additional library search dir (right-most wins)\n";
-    o << "  -o / --output-file <file> Write to the output file rather than stdout\n";
-    o << "  -m / --multi <dir>      Write multiple files to the directory, list files on stdout\n";
-    o << "  -y / --yaml-stream      Write output as a YAML stream of JSON documents\n";
-    o << "  -S / --string           Expect a string, manifest as plain text\n";
-    o << "  -s / --max-stack <n>    Number of allowed stack frames\n";
-    o << "  -t / --max-trace <n>    Max length of stack trace before cropping\n";
-    o << "  --gc-min-objects <n>    Do not run garbage collector until this many\n";
-    o << "  --gc-growth-trigger <n> Run garbage collector after this amount of object growth\n";
-    o << "  --version               Print version\n";
-    o << "Available options for specifying values of 'external' variables:\n";
-    o << "Provide the value as a string:\n";
-    o << "  -V / --ext-str <var>[=<val>]     If <val> is omitted, get from environment var <var>\n";
-    o << "       --ext-str-file <var>=<file> Read the string from the file\n";
-    o << "Provide a value as Jsonnet code:\n";
-    o << "  --ext-code <var>[=<code>]    If <code> is omitted, get from environment var <var>\n";
-    o << "  --ext-code-file <var>=<file> Read the code from the file\n";
-    o << "Available options for specifying values of 'top-level arguments':\n";
-    o << "Provide the value as a string:\n";
-    o << "  -A / --tla-str <var>[=<val>]     If <val> is omitted, get from environment var <var>\n";
-    o << "       --tla-str-file <var>=<file> Read the string from the file\n";
-    o << "Provide a value as Jsonnet code:\n";
-    o << "  --tla-code <var>[=<code>]    If <code> is omitted, get from environment var <var>\n";
-    o << "  --tla-code-file <var>=<file> Read the code from the file\n";
-    o << "Environment variables:\n";
-    o << "JSONNET_PATH is a colon (semicolon on Windows) separated list of directories added\n";
-    o << "in reverse order before the paths specified by --jpath (i.e. left-most wins)\n";
-    o << "E.g. JSONNET_PATH=a:b jsonnet -J c -J d is equivalent to:\n";
-    o << "JSONNET_PATH=d:c:a:b jsonnet\n";
-    o << "jsonnet -J b -J a -J c -J d\n";
-    o << "\n";
-    o << "In all cases:\n";
-    o << "<filename> can be - (stdin)\n";
-    o << "Multichar options are expanded e.g. -abc becomes -a -b -c.\n";
-    o << "The -- option suppresses option processing for subsequent arguments.\n";
-    o << "Note that since filenames and jsonnet programs can begin with -, it is advised to\n";
-    o << "use -- if the argument is unknown, e.g. jsonnet -- \"$FILENAME\".";
-    o << std::endl;
-}
-
-/** Class for representing configuration read from command line flags.  */
-struct JsonnetConfig {
-    std::vector<std::string> inputFiles;
-    std::string outputFile;
-    bool filenameIsCode;
-
-    // EVAL flags
-    bool evalMulti;
-    bool evalStream;
-    std::string evalMultiOutputDir;
-
-    JsonnetConfig()
-        : filenameIsCode(false),
-          evalMulti(false),
-          evalStream(false)
-    {
-    }
-};
-
-bool get_var_val(const std::string &var_val, std::string &var, std::string &val)
-{
-    size_t eq_pos = var_val.find_first_of('=', 0);
-    if (eq_pos == std::string::npos) {
-        var = var_val;
-        const char *val_cstr = ::getenv(var.c_str());
-        if (val_cstr == nullptr) {
-            std::cerr << "ERROR: environment variable " << var << " was undefined." << std::endl;
-            return false;
-        }
-        val = val_cstr;
-    } else {
-        var = var_val.substr(0, eq_pos);
-        val = var_val.substr(eq_pos + 1, std::string::npos);
-    }
-    return true;
-}
-
-bool get_var_file(const std::string &var_file, const std::string &imp, std::string &var, std::string &val)
-{
-    size_t eq_pos = var_file.find_first_of('=', 0);
-    if (eq_pos == std::string::npos) {
-        std::cerr << "ERROR: argument not in form <var>=<file> \"" << var_file << "\"."
-                  << std::endl;
-        return false;
-    }
-    var = var_file.substr(0, eq_pos);
-    const std::string path = var_file.substr(eq_pos + 1, std::string::npos);
-
-    size_t b, e;
-    val.erase().append(imp).append(" @'");
-    // duplicate all the single quotes in @path to make a quoted string
-    for (b = 0; (e = path.find("'", b)) != std::string::npos; b = e + 1) {
-        val.append(path.substr(b, e - b + 1)).push_back('\'');
+/** Writes output files for multiple file output */
+bool write_multi_output_files(char *output, const std::string &output_dir, bool show_output_file_names) {
+  // If multiple file output is used, then iterate over each string from
+  // the sequence of strings returned by jsonnet_evaluate_snippet_multi,
+  // construct pairs of filename and content, and write each output file.
+  std::map<std::string, std::string> r;
+  for (const char *c = output; *c != '\0';) {
+    const char *filename = c;
+    const char *c2 = c;
+    while (*c2 != '\0') ++c2;
+    ++c2;
+    const char *json = c2;
+    while (*c2 != '\0') ++c2;
+    ++c2;
+    c = c2;
+    r[filename] = json;
+  }
+
+  std::ostream *o;
+  std::ofstream f;
+
+  o = &std::cout;
+
+  for (const auto &pair : r) {
+    const std::string &new_content = pair.second;
+    const std::string &filename = output_dir + pair.first;
+    if (show_output_file_names) {
+      (*o) << filename << std::endl;
     }
-    val.append(path.substr(b)).push_back('\'');
-
-    return true;
-}
-
-enum ArgStatus {
-    ARG_CONTINUE,
-    ARG_SUCCESS,
-    ARG_FAILURE,
-};
-
-/** Parse the command line arguments, configuring the Jsonnet VM context and
- * populating the JsonnetConfig.
- */
-static ArgStatus process_args(int argc, const char **argv, JsonnetConfig *config, JsonnetVm *vm)
-{
-    auto args = simplify_args(argc, argv);
-    std::vector<std::string> remaining_args;
-
-    unsigned i = 0;
-
-    for (; i < args.size(); ++i) {
-        const std::string &arg = args[i];
-        if (arg == "-h" || arg == "--help") {
-            usage(std::cout);
-            return ARG_SUCCESS;
-        } else if (arg == "-v" || arg == "--version") {
-            version(std::cout);
-            return ARG_SUCCESS;
-        } else if (arg == "-e" || arg == "--exec") {
-            config->filenameIsCode = true;
-        } else if (arg == "-o" || arg == "--output-file") {
-            std::string output_file = next_arg(i, args);
-            if (output_file.length() == 0) {
-                std::cerr << "ERROR: -o argument was empty string" << std::endl;
-                return ARG_FAILURE;
-            }
-            config->outputFile = output_file;
-        } else if (arg == "--") {
-            // All subsequent args are not options.
-            while ((++i) < args.size())
-                remaining_args.push_back(args[i]);
-            break;
-        } else if (arg == "-s" || arg == "--max-stack") {
-            long l = strtol_check(next_arg(i, args));
-            if (l < 1) {
-                std::cerr << "ERROR: invalid --max-stack value: " << l << std::endl;
-                return ARG_FAILURE;
-            }
-            jsonnet_max_stack(vm, l);
-        } else if (arg == "-J" || arg == "--jpath") {
-            std::string dir = next_arg(i, args);
-            if (dir.length() == 0) {
-                std::cerr << "ERROR: -J argument was empty string" << std::endl;
-                return ARG_FAILURE;
-            }
-            if (dir[dir.length() - 1] != '/') {
-                dir += '/';
-            }
-            jsonnet_jpath_add(vm, dir.c_str());
-        } else if (arg == "-V" || arg == "--ext-str") {
-            std::string var, val;
-            if (!get_var_val(next_arg(i, args), var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_var(vm, var.c_str(), val.c_str());
-        } else if (arg == "-E" || arg == "--var" || arg == "--env") {
-            // TODO(dcunnin): Delete this in a future release.
-            std::cerr << "WARNING: jsonnet eval -E, --var and --env are deprecated,"
-                        << " please use -V or --ext-str." << std::endl;
-            std::string var, val;
-            if (!get_var_val(next_arg(i, args), var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_var(vm, var.c_str(), val.c_str());
-        } else if (arg == "--ext-str-file") {
-            std::string var, val;
-            if (!get_var_file(next_arg(i, args), "importstr", var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "-F" || arg == "--file") {
-            // TODO(dcunnin): Delete this in a future release.
-            std::cerr << "WARNING: jsonnet eval -F and --file are deprecated,"
-                        << " please use --ext-str-file." << std::endl;
-            std::string var, val;
-            if (!get_var_file(next_arg(i, args), "importstr", var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "--ext-code") {
-            std::string var, val;
-            if (!get_var_val(next_arg(i, args), var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "--code-var" || arg == "--code-env") {
-            // TODO(dcunnin): Delete this in a future release.
-            std::cerr << "WARNING: jsonnet eval --code-var and --code-env are deprecated,"
-                        << " please use --ext-code." << std::endl;
-            std::string var, val;
-            if (!get_var_val(next_arg(i, args), var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "--ext-code-file") {
-            std::string var, val;
-            if (!get_var_file(next_arg(i, args), "import", var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "--code-file") {
-            // TODO(dcunnin): Delete this in a future release.
-            std::cerr << "WARNING: jsonnet eval --code-file is deprecated,"
-                        << " please use --ext-code-file." << std::endl;
-            std::string var, val;
-            if (!get_var_file(next_arg(i, args), "import", var, val))
-                return ARG_FAILURE;
-            jsonnet_ext_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "-A" || arg == "--tla-str") {
-            std::string var, val;
-            if (!get_var_val(next_arg(i, args), var, val))
-                return ARG_FAILURE;
-            jsonnet_tla_var(vm, var.c_str(), val.c_str());
-        } else if (arg == "--tla-str-file") {
-            std::string var, val;
-            if (!get_var_file(next_arg(i, args), "importstr", var, val))
-                return ARG_FAILURE;
-            jsonnet_tla_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "--tla-code") {
-            std::string var, val;
-            if (!get_var_val(next_arg(i, args), var, val))
-                return ARG_FAILURE;
-            jsonnet_tla_code(vm, var.c_str(), val.c_str());
-        } else if (arg == "--tla-code-file") {
-            std::string var, val;
-            if (!get_var_file(next_arg(i, args), "import", var, val))
-                return ARG_FAILURE;
-            jsonnet_tla_code(vm, var.c_str(), val.c_str());
-
-        } else if (arg == "--gc-min-objects") {
-            long l = strtol_check(next_arg(i, args));
-            if (l < 0) {
-                std::cerr << "ERROR: invalid --gc-min-objects value: " << l << std::endl;
-                return ARG_FAILURE;
-            }
-            jsonnet_gc_min_objects(vm, l);
-        } else if (arg == "-t" || arg == "--max-trace") {
-            long l = strtol_check(next_arg(i, args));
-            if (l < 0) {
-                std::cerr << "ERROR: invalid --max-trace value: " << l << std::endl;
-                return ARG_FAILURE;
-            }
-            jsonnet_max_trace(vm, l);
-        } else if (arg == "--gc-growth-trigger") {
-            std::string num = next_arg(i, args);
-            char *ep;
-            double v = std::strtod(num.c_str(), &ep);
-            if (*ep != '\0' || num.length() == 0) {
-                std::cerr << "ERROR: invalid number \"" << num << "\"" << std::endl;
-                return ARG_FAILURE;
-            }
-            if (v < 0) {
-                std::cerr << "ERROR: invalid --gc-growth-trigger \"" << num << "\""
-                            << std::endl;
-                return ARG_FAILURE;
-            }
-            jsonnet_gc_growth_trigger(vm, v);
-        } else if (arg == "-m" || arg == "--multi") {
-            config->evalMulti = true;
-            std::string output_dir = next_arg(i, args);
-            if (output_dir.length() == 0) {
-                std::cerr << "ERROR: -m argument was empty string" << std::endl;
-                return ARG_FAILURE;
-            }
-            if (output_dir[output_dir.length() - 1] != '/') {
-                output_dir += '/';
-            }
-            config->evalMultiOutputDir = output_dir;
-        } else if (arg == "-y" || arg == "--yaml-stream") {
-            config->evalStream = true;
-        } else if (arg == "-S" || arg == "--string") {
-            jsonnet_string_output(vm, 1);
-        } else if (arg.length() > 1 && arg[0] == '-') {
-            std::cerr << "ERROR: unrecognized argument: " << arg << std::endl;
-            return ARG_FAILURE;
-        } else {
-            remaining_args.push_back(args[i]);
+    {
+      std::ifstream exists(filename.c_str());
+      if (exists.good()) {
+        std::string existing_content;
+        existing_content.assign(std::istreambuf_iterator<char>(exists),
+                                std::istreambuf_iterator<char>());
+        if (existing_content == new_content) {
+          // Do not bump the timestamp on the file if its content is
+          // the same. This may trigger other tools (e.g. make) to do
+          // unnecessary work.
+          continue;
         }
+      }
     }
-
-    const char *want = config->filenameIsCode ? "code" : "filename";
-    if (remaining_args.size() == 0) {
-        std::cerr << "ERROR: must give " << want << "\n" << std::endl;
-        usage(std::cerr);
-        return ARG_FAILURE;
-    }
-
-    if (remaining_args.size() > 1) {
-        std::string filename = remaining_args[0];
-        std::cerr << "ERROR: only one " << want << " is allowed\n" << std::endl;
-        return ARG_FAILURE;
-    }
-    config->inputFiles = remaining_args;
-    return ARG_CONTINUE;
-}
-
-/** Writes output files for multiple file output */
-static bool write_multi_output_files(JsonnetVm *vm, char *output, const std::string &output_dir,
-                                     const std::string &output_file)
-{
-    // If multiple file output is used, then iterate over each string from
-    // the sequence of strings returned by jsonnet_evaluate_snippet_multi,
-    // construct pairs of filename and content, and write each output file.
-    std::map<std::string, std::string> r;
-    for (const char *c = output; *c != '\0';) {
-        const char *filename = c;
-        const char *c2 = c;
-        while (*c2 != '\0')
-            ++c2;
-        ++c2;
-        const char *json = c2;
-        while (*c2 != '\0')
-            ++c2;
-        ++c2;
-        c = c2;
-        r[filename] = json;
-    }
-    jsonnet_realloc(vm, output, 0);
-
-    std::ostream *o;
     std::ofstream f;
-
-    if (output_file.empty()) {
-        o = &std::cout;
-    } else {
-        f.open(output_file.c_str());
-        if (!f.good()) {
-            std::string msg = "Writing to output file: " + output_file;
-            perror(msg.c_str());
-            return false;
-        }
-        o = &f;
+    f.open(filename.c_str());
+    if (!f.good()) {
+      std::string msg = "Opening output file: " + filename;
+      perror(msg.c_str());
+      return false;
+    }
+    f << new_content;
+    f.close();
+    if (!f.good()) {
+      std::string msg = "Writing to output file: " + filename;
+      perror(msg.c_str());
+      return false;
     }
+  }
 
-    for (const auto &pair : r) {
-        const std::string &new_content = pair.second;
-        const std::string &filename = output_dir + pair.first;
-        (*o) << filename << std::endl;
-        {
-            std::ifstream exists(filename.c_str());
-            if (exists.good()) {
-                std::string existing_content;
-                existing_content.assign(std::istreambuf_iterator<char>(exists),
-                                        std::istreambuf_iterator<char>());
-                if (existing_content == new_content) {
-                    // Do not bump the timestamp on the file if its content is
-                    // the same. This may trigger other tools (e.g. make) to do
-                    // unnecessary work.
-                    continue;
-                }
-            }
-        }
-        std::ofstream f;
-        f.open(filename.c_str());
-        if (!f.good()) {
-            std::string msg = "Opening output file: " + filename;
-            perror(msg.c_str());
-            return false;
-        }
-        f << new_content;
-        f.close();
-        if (!f.good()) {
-            std::string msg = "Writing to output file: " + filename;
-            perror(msg.c_str());
-            return false;
-        }
-    }
+  std::cout.flush();
 
-    if (output_file.empty()) {
-        std::cout.flush();
-    } else {
-        f.close();
-        if (!f.good()) {
-            std::string msg = "Writing to output file: " + output_file;
-            perror(msg.c_str());
-            return false;
-        }
-    }
-    return true;
+  return true;
 }
 
 /** Writes output files for YAML stream output */
-static bool write_output_stream(JsonnetVm *vm, char *output, const std::string &output_file)
-{
-    std::ostream *o;
-    std::ofstream f;
-
-    if (output_file.empty()) {
-        o = &std::cout;
-    } else {
-        f.open(output_file.c_str());
-        if (!f.good()) {
-            std::string msg = "Writing to output file: " + output_file;
-            perror(msg.c_str());
-            return false;
-        }
-        o = &f;
-    }
-
-    // If YAML stream output is used, then iterate over each string from
-    // the sequence of strings returned by jsonnet_evaluate_snippet_stream,
-    // and add the --- and ... as defined by the YAML spec.
-    std::vector<std::string> r;
-    for (const char *c = output; *c != '\0';) {
-        const char *json = c;
-        while (*c != '\0')
-            ++c;
-        ++c;
-        r.emplace_back(json);
-    }
-    jsonnet_realloc(vm, output, 0);
-    for (const auto &str : r) {
-        (*o) << "---\n";
-        (*o) << str;
-    }
-    if (r.size() > 0)
-        (*o) << "...\n";
-    o->flush();
-
-    if (output_file.empty()) {
-        std::cout.flush();
-    } else {
-        f.close();
-        if (!f.good()) {
-            std::string msg = "Writing to output file: " + output_file;
-            perror(msg.c_str());
-            return false;
-        }
+bool write_output_stream(char *output, const std::string &output_file) {
+  std::ostream *o;
+  std::ofstream f;
+
+  if (output_file.empty()) {
+    o = &std::cout;
+  } else {
+    f.open(output_file.c_str());
+    if (!f.good()) {
+      std::string msg = "Writing to output file: " + output_file;
+      perror(msg.c_str());
+      return false;
+    }
+    o = &f;
+  }
+
+  // If YAML stream output is used, then iterate over each string from
+  // the sequence of strings returned by jsonnet_evaluate_snippet_stream,
+  // and add the --- and ... as defined by the YAML spec.
+  std::vector<std::string> r;
+  for (const char *c = output; *c != '\0';) {
+    const char *json = c;
+    while (*c != '\0') ++c;
+    ++c;
+    r.emplace_back(json);
+  }
+
+  for (const auto &str : r) {
+    (*o) << "---\n";
+    (*o) << str;
+  }
+  if (r.size() > 0) (*o) << "...\n";
+  o->flush();
+
+  if (output_file.empty()) {
+    std::cout.flush();
+  } else {
+    f.close();
+    if (!f.good()) {
+      std::string msg = "Writing to output file: " + output_file;
+      perror(msg.c_str());
+      return false;
     }
+  }
 
-    return true;
-}
-
-int main(int argc, const char **argv)
-{
-    try {
-        JsonnetVm *vm = jsonnet_make();
-        JsonnetConfig config;
-        if (const char *jsonnet_path_env = getenv("JSONNET_PATH")) {
-            std::list<std::string> jpath;
-            std::istringstream iss(jsonnet_path_env);
-            std::string path;
-            while (std::getline(iss, path, PATH_SEP)) {
-                jpath.push_front(path);
-            }
-            for (const std::string &path : jpath) {
-                jsonnet_jpath_add(vm, path.c_str());
-            }
-        }
-        ArgStatus arg_status = process_args(argc, argv, &config, vm);
-        if (arg_status != ARG_CONTINUE) {
-            jsonnet_destroy(vm);
-            return arg_status == ARG_SUCCESS ? EXIT_SUCCESS : EXIT_FAILURE;
-        }
-
-        // Evaluate input Jsonnet and handle any errors from Jsonnet VM.
-        int error;
-        char *output;
-        assert(config.inputFiles.size() == 1);
-
-        // Read input file.
-        std::string input;
-        if (!read_input(config.filenameIsCode, &config.inputFiles[0], &input)) {
-            jsonnet_destroy(vm);
-            return EXIT_FAILURE;
-        }
-
-        if (config.evalMulti) {
-            output = jsonnet_evaluate_snippet_multi(
-                vm, config.inputFiles[0].c_str(), input.c_str(), &error);
-        } else if (config.evalStream) {
-            output = jsonnet_evaluate_snippet_stream(
-                vm, config.inputFiles[0].c_str(), input.c_str(), &error);
-        } else {
-            output = jsonnet_evaluate_snippet(
-                vm, config.inputFiles[0].c_str(), input.c_str(), &error);
-        }
-
-        if (error) {
-            std::cerr << output;
-            jsonnet_realloc(vm, output, 0);
-            jsonnet_destroy(vm);
-            return EXIT_FAILURE;
-        }
-
-        // Write output JSON.
-        if (config.evalMulti) {
-            if (!write_multi_output_files(
-                    vm, output, config.evalMultiOutputDir, config.outputFile)) {
-                jsonnet_destroy(vm);
-                return EXIT_FAILURE;
-            }
-        } else if (config.evalStream) {
-            if (!write_output_stream(vm, output, config.outputFile)) {
-                jsonnet_destroy(vm);
-                return EXIT_FAILURE;
-            }
-        } else {
-            bool successful = write_output_file(output, config.outputFile);
-            jsonnet_realloc(vm, output, 0);
-            if (!successful) {
-                jsonnet_destroy(vm);
-                return EXIT_FAILURE;
-            }
-        }
-
-        jsonnet_destroy(vm);
-        return EXIT_SUCCESS;
-
-    } catch (const std::bad_alloc &) {
-        // Avoid further allocation attempts
-        fputs("Internal out-of-memory error (please report this)\n", stderr);
-    } catch (const std::exception &e) {
-        std::cerr << "Internal error (please report this): " << e.what() << std::endl;
-    } catch (...) {
-        std::cerr << "An unknown exception occurred (please report this)." << std::endl;
-    }
-    return EXIT_FAILURE;
+  return true;
 }