@naanlang/naan 1.0.0

package/plugins/gitClient/minimatch_license.txt

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/plugins/gitClient/minimatch_readme.md

@@ -0,0 +1,208 @@
+# minimatch
+
+A minimal matching utility.
+
+
+
+This is the matching library used internally by npm.
+
+It works by converting glob expressions into JavaScript `RegExp`
+objects.
+
+## Usage
+
+```javascript
+var minimatch = require("minimatch")
+
+minimatch("bar.foo", "*.foo") // true!
+minimatch("bar.foo", "*.bar") // false!
+minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
+```
+
+## Features
+
+Supports these glob features:
+
+* Brace Expansion
+* Extended glob matching
+* "Globstar" `**` matching
+
+See:
+
+* `man sh`
+* `man bash`
+* `man 3 fnmatch`
+* `man 5 gitignore`
+
+## Minimatch Class
+
+Create a minimatch object by instantiating the `minimatch.Minimatch` class.
+
+```javascript
+var Minimatch = require("minimatch").Minimatch
+var mm = new Minimatch(pattern, options)
+```
+
+### Properties
+
+* `pattern` The original pattern the minimatch object represents.
+* `options` The options supplied to the constructor.
+* `set` A 2-dimensional array of regexp or string expressions.
+  Each row in the
+  array corresponds to a brace-expanded pattern.  Each item in the row
+  corresponds to a single path-part.  For example, the pattern
+  `{a,b/c}/d` would expand to a set of patterns like:
+
+        [ [ a, d ]
+        , [ b, c, d ] ]
+
+    If a portion of the pattern doesn't have any "magic" in it
+    (that is, it's something like `"foo"` rather than `fo*o?`), then it
+    will be left as a string rather than converted to a regular
+    expression.
+
+* `regexp` Created by the `makeRe` method.  A single regular expression
+  expressing the entire pattern.  This is useful in cases where you wish
+  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
+* `negate` True if the pattern is negated.
+* `comment` True if the pattern is a comment.
+* `empty` True if the pattern is `""`.
+
+### Methods
+
+* `makeRe` Generate the `regexp` member if necessary, and return it.
+  Will return `false` if the pattern is invalid.
+* `match(fname)` Return true if the filename matches the pattern, or
+  false otherwise.
+* `matchOne(fileArray, patternArray, partial)` Take a `/`-split
+  filename, and match it against a single row in the `regExpSet`.  This
+  method is mainly for internal use, but is exposed so that it can be
+  used by a glob-walker that needs to avoid excessive filesystem calls.
+
+All other methods are internal, and will be called as necessary.
+
+### minimatch(path, pattern, options)
+
+Main export.  Tests a path against the pattern using the options.
+
+```javascript
+var isJS = minimatch(file, "*.js", { matchBase: true })
+```
+
+### minimatch.filter(pattern, options)
+
+Returns a function that tests its
+supplied argument, suitable for use with `Array.filter`.  Example:
+
+```javascript
+var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
+```
+
+### minimatch.match(list, pattern, options)
+
+Match against the list of
+files, in the style of fnmatch or glob.  If nothing is matched, and
+options.nonull is set, then return a list containing the pattern itself.
+
+```javascript
+var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
+```
+
+### minimatch.makeRe(pattern, options)
+
+Make a regular expression object from the pattern.
+
+## Options
+
+All options are `false` by default.
+
+### debug
+
+Dump a ton of stuff to stderr.
+
+### nobrace
+
+Do not expand `{a,b}` and `{1..3}` brace sets.
+
+### noglobstar
+
+Disable `**` matching against multiple folder names.
+
+### dot
+
+Allow patterns to match filenames starting with a period, even if
+the pattern does not explicitly have a period in that spot.
+
+Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
+is set.
+
+### noext
+
+Disable "extglob" style patterns like `+(a|b)`.
+
+### nocase
+
+Perform a case-insensitive match.
+
+### nonull
+
+When a match is not found by `minimatch.match`, return a list containing
+the pattern itself if this option is set.  When not set, an empty list
+is returned if there are no matches.
+
+### matchBase
+
+If set, then patterns without slashes will be matched
+against the basename of the path if it contains slashes.  For example,
+`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+
+### nocomment
+
+Suppress the behavior of treating `#` at the start of a pattern as a
+comment.
+
+### nonegate
+
+Suppress the behavior of treating a leading `!` character as negation.
+
+### flipNegate
+
+Returns from negate expressions the same as if they were not negated.
+(Ie, true on a hit, false on a miss.)
+
+
+## Comparisons to other fnmatch/glob implementations
+
+While strict compliance with the existing standards is a worthwhile
+goal, some discrepancies exist between minimatch and other
+implementations, and are intentional.
+
+If the pattern starts with a `!` character, then it is negated.  Set the
+`nonegate` flag to suppress this behavior, and treat leading `!`
+characters normally.  This is perhaps relevant if you wish to start the
+pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
+characters at the start of a pattern will negate the pattern multiple
+times.
+
+If a pattern starts with `#`, then it is treated as a comment, and
+will not match anything.  Use `\#` to match a literal `#` at the
+start of a line, or set the `nocomment` flag to suppress this behavior.
+
+The double-star character `**` is supported by default, unless the
+`noglobstar` flag is set.  This is supported in the manner of bsdglob
+and bash 4.1, where `**` only has special significance if it is the only
+thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
+`a/**b` will not.
+
+If an escaped pattern has no matches, and the `nonull` flag is set,
+then minimatch.match returns the pattern as-provided, rather than
+interpreting the character escapes.  For example,
+`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
+`"*a?"`.  This is akin to setting the `nullglob` option in bash, except
+that it does not resolve escaped pattern characters.
+
+If brace expansion is not disabled, then it is performed before any
+other interpretation of the glob pattern.  Thus, a pattern like
+`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
+**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
+checked for validity.  Since those two are valid, matching proceeds.

package/plugins/nodeLib/nodeLib.nlg

@@ -0,0 +1,26 @@
+/*
+ * nodeLib.nlg
+ *
+ * Support library for running with NodeJS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2021-2022 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * nodeLibInit
+ *
+ *     Initialize NodeJS utilities.
+ *
+ */
+
+function nodeLibInit(local manifest) {
+    manifest = `(nodeLibInit)
+
+    Naan.module.build(module.id, "nodeLib", function(modobj, compobj) {
+        compobj.manifest = manifest
+    })
+}();

package/plugins/nodeLib/node_cp.nlg

@@ -0,0 +1,65 @@
+/*
+ * node_cp.nlg
+ *
+ *     Child Process operations for NodeJS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2021-2022 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * CatVideo
+ *
+ * Concatenate a list of videos.
+ *
+ */
+
+closure CatVideo(filepaths, outfile, local fileslist, listfile, error, pending, child) {
+    fileslist = []
+    for file in filepaths
+        fileslist.push("file ".concat(nodePath.resolve("/tmp", file)))
+    fileslist = fileslist.join("\n")
+    listfile = nodePath.resolve("/tmp", "catVideoFiles")
+    `(error, data) = WriteFile(listfile, fileslist, "text")
+    if error
+        return (list(Error("CatVideo: can't write filelist:", error)))
+    outfile = nodePath.resolve("/tmp", outfile)
+    pending = new(nonce)
+    child = nodeCp.execFile("ffmpeg",
+        ["-f", "concat", "-safe", "0", "-i", listfile, "-c", "copy", outfile],
+        function(err, stdout, stderr) {
+            debuglog("CatVideo completed ffmpeg", err, "||", stderr, "||", stdout)
+            if err
+                pending.signal(list(Error("ffmpeg failed", err, stderr)))
+            else
+                pending.signal(list(false, stdout))
+        }
+    )
+    child.stdin.on("error", function(err) {
+        // make sure error isn't unhandled, so that a failed uglifyjs doesn't
+        // kill our process when the stdin write occurs after the pipe closes.
+    })
+    child.stdin.end(input)
+    pending.wait()
+};
+
+
+/*
+ * nodeCpInit
+ *
+ * Initialize NodeJS FS operations.
+ *
+ */
+
+function nodeCpInit(local manifest) {
+    manifest = `(CatVideo, nodeCpInit)
+
+    Naan.module.build(module.id, "node_cp", function(modobj, compobj) {
+        require("node_util.nlg")
+        compobj.manifest = manifest
+        modobj.exports.CatVideo = CatVideo
+    })
+}();

package/plugins/nodeLib/node_fs.nlg

@@ -0,0 +1,137 @@
+/*
+ * node_fs.nlg
+ *
+ *     File system operations for NodeJS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2021-2022 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * ReadFile
+ *
+ * Read an entire file from the specified path and return the contents.
+ *
+ * Encodings are:
+ *  "text"      - default
+ *  "json"      - perform JSON decoding on result
+ *  "binary"    - return file as buffer
+ *
+ */
+
+function ReadFile(filepath, encoding, local options, error, data) {
+    filepath = nodePath.resolve("/tmp", filepath)
+    options = { }
+    if !encoding || encoding == "text" || encoding == "json"
+        options.encoding = "utf8"
+    else if encoding != "binary"
+        error = Error("ReadFile: invalid encoding", encoding)
+    if !error {
+        `(error, data) = await(nodeFs.promises.readFile(filepath, options))
+        if !error && encoding == "json"
+            `(error, data) = JsonParse(data)
+        if error
+            error = Error("ReadFile failed:", filepath, error)
+    }
+    if error
+        ErrorDebuglog(error)
+    list(error, data)
+};
+
+
+/*
+ * WriteFile
+ *
+ * Write the specified contents to a file at the path.
+ *
+ * Encodings are:
+ *  "text"      - default
+ *  "json"      - perform JSON decoding on result
+ *  "binary"    - return file as buffer
+ *
+ */
+
+function WriteFile(filepath, data, encoding, local options, error) {
+    filepath = nodePath.resolve("/tmp", filepath)
+    options = { }
+    if !encoding || encoding == "text"
+        options.encoding = "utf8"
+    else if encoding == "json" {
+        `(error, data) = JsonStringify(data)
+        options.encoding = "utf8"
+    }
+    else if encoding != "binary"
+        error = Error("WriteFile: invalid encoding", encoding)
+    if !error {
+        `(error, data) = await(nodeFs.promises.writeFile(filepath, data, options))
+        if error
+            error = Error("WriteFile failed:", filepath, error)
+    }
+    if error
+        ErrorDebuglog(error)
+    list(error, data)
+};
+
+
+/*
+ * ReadStream
+ *
+ * Make a read stream.
+ *
+ * Encodings are:
+ *  "text"      - default
+ *  "json"      - perform JSON decoding on result
+ *  "binary"    - return file as buffer
+ *
+ */
+
+function ReadStream(filepath, encoding, local options, error, data) {
+    filepath = nodePath.resolve("/tmp", filepath)
+    options = { }
+    if !encoding || encoding == "text" || encoding == "json"
+        options.encoding = "utf8"
+    else if encoding != "binary"
+        error = Error("ReadStream: invalid encoding", encoding)
+    if !error
+        data = nodeFs.createReadStream(filepath, options)
+    if error
+        ErrorDebuglog(error)
+    list(error, data)
+};
+
+
+/*
+ * DeleteDir
+ *
+ * Delete the directory at the specified path.
+ *
+ */
+
+function DeleteDir(dirpath, local error, data) {
+    dirpath = nodePath.resolve("/tmp", dirpath)
+    `(error, data) = await(nodeFs.promises.rmdir(dirpath, { recursive: true }))
+}
+
+
+/*
+ * nodeFsInit
+ *
+ * Initialize NodeJS FS operations.
+ *
+ */
+
+function nodeFsInit(local manifest) {
+    manifest = `(ReadFile, WriteFile, DeleteDir, nodeFsInit)
+
+    Naan.module.build(module.id, "node_fs", function(modobj, compobj) {
+        require("node_util.nlg")
+        compobj.manifest = manifest
+        modobj.exports.ReadFile = ReadFile
+        modobj.exports.WriteFile = WriteFile
+        modobj.exports.ReadStream = ReadStream
+        modobj.exports.DeleteDir = DeleteDir
+    })
+}();

package/plugins/nodeLib/node_https.nlg

@@ -0,0 +1,172 @@
+/*
+ * node_https.nlg
+ *
+ *     Https operations for NodeJS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2021-2022 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * HttpsGetJson
+ *
+ *     Perform an HTTPS get on a host with JSON decoding.
+ *
+ */
+
+closure HttpsGetJson(hostname, pathname, query, local https, options, pending, req) {
+    if query
+        pathname = EncodeQuery(pathname.concat("?"), query)
+    debuglog("HttpsGetJson", hostname, pathname)
+    options = {
+        hostname: hostname
+        port: 443
+        path: pathname
+        method: "GET"
+    }
+    pending = new(nonce)
+    req = nodeHttps.request(options, function (res) {
+        res.on("data", function (data, local error) {
+            `(error, data) = JsonParse(data)
+            if error
+                error = Error("HttpsGetJson:", hostname, pathname, error)
+            pending.signal(list(error, data))
+        })
+    })
+    req.on("error", function(error) {
+        error = Error("HttpsGetJson failed:", hostname, pathname, error)
+        pending.signal(list(error))
+    })
+    req.end()
+    pending.wait()
+};
+
+
+/*
+ * HttpsDownloadFile
+ *
+ * column positioning:                          //                          //                      !
+ *     Download a file from an HTTPS endpoint using the GET method and store it on the local
+ * filesystem. This returns a standard result tuple.
+ *
+ */
+
+closure HttpsDownloadFile(hostname, pathname, query, filepath,
+    local dirpath, error, pending, writeStream, options, req)
+{
+    filepath = nodePath.resolve("/tmp", filepath)
+    if query
+        pathname = EncodeQuery(pathname.concat("?"), query)
+    debuglog("HttpsDownloadFile", hostname, pathname, filepath)
+    options = {
+        hostname: hostname
+        port: 443
+        path: pathname
+        method: "GET"
+    }
+    pending = new(nonce)
+    req = nodeHttps.request(options, function(resp) {
+        if resp.statusCode != 200
+            return (pending.signal(list(Error("HttpsDownloadFile cannot read:", resp.statusCode))))
+        `(error) = await(nodeFs.promises.mkdir(nodePath.dirname(filepath), { recursive: true }))
+        if error
+            return (pending.signal(list(Error("HttpsDownloadFile cannot create directory:", nodePath.dirname(filepath), error))))
+        writeStream = nodeFs.createWriteStream(filepath)
+        writeStream.on("error", function(error) {
+            error = Error("HttpsDownloadFile cannot write file:", filepath, error)
+            pending.signal(list(error))
+        })
+        resp.on("close", function() {
+            pending.signal(list(false, { ok: true }))
+        })
+        resp.pipe(writeStream)
+    })
+    req.on("error", function(error) {
+        error = Error("HttpsDownloadFile request failed:", hostname, pathname, error)
+        pending.signal(list(error))
+    })
+    req.end()
+    pending.wait()
+};
+
+
+/*
+ * HttpsUploadFile
+ *
+ *     Upload a local filesystem file to an HTTPS endpoint using POST, returning a standard result tuple.
+ *
+ */
+
+closure HttpsUploadFile(hostname, pathname, query, fieldname, filepath,
+    local error, buffer, form, fields, multipart, readStream, pending, options, req)
+{
+    if query
+        pathname = EncodeQuery(pathname.concat("?"), query)
+    debuglog("HttpsUploadFile", hostname, pathname, filepath)
+    `(error, buffer) = ReadFile(filepath, "binary")
+    if error
+        return (list(Error("HttpsUploadFile cannot read file:", filepath, error)))
+    form = {}
+    form[fieldname] = buffer
+    fields = {}
+    fields[fieldname] = nodePath.basename(filepath)
+    multipart = MultipartBody(form, fields)
+    readStream = nodeStream.Readable.from(multipart.body)
+    options = {
+        hostname: hostname
+        port: 443
+        path: pathname
+        method: "POST"
+        headers: multipart.headers
+    }
+    pending = new(nonce)
+    req = nodeHttps.request(options, function(resp) {
+        resp.on("data", function (data, local error) {
+            `(error, data) = JsonParse(data)
+            if error || data.error_code {
+                if error
+                    error = Error("HttpsUploadFile unexpected response:", hostname, pathname, error)
+                else
+                    error = Error("HttpsUploadFile rejected:", hostname, pathname, data)
+                data = false
+            }
+            pending.signal(list(error, data))
+        })
+        resp.on("close", function(local error) {
+            error = Error("HttpsUploadFile no response:", hostname, pathname, resp.statusCode)
+            pending.signal(list(error))
+        })
+    })
+    req.on("error", function(error) {
+        error = Error("HttpsUploadFile request failed:", hostname, pathname, error)
+        pending.signal(list(error))
+    })
+    readStream.pipe(req)
+    readStream.on("close", function() {
+        req.end()
+    })
+    pending.wait()
+};
+
+
+/*
+ * nodeHttpsInit
+ *
+ * Initialize NodeJS HTTPS operations.
+ *
+ */
+
+function nodeHttpsInit(local manifest) {
+    manifest = `(HttpsGetJson, HttpsDownloadFile, HttpsUploadFile, nodeHttpsInit)
+
+    Naan.module.build(module.id, "node_https", function(modobj, compobj) {
+        require("node_util.nlg")
+        compobj.manifest = manifest
+        modobj.exports.HttpsGetJson = HttpsGetJson
+        modobj.exports.HttpsDownloadFile = HttpsDownloadFile
+        modobj.exports.HttpsUploadFile = HttpsUploadFile
+    })
+}();