@naanlang/naan 1.0.2 → 1.0.5

package/frameworks/client/psm_client.nlg

@@ -22,6 +22,50 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     view = new(object, this)
     view.api = api
     view.rootpath = rootpath
+    
+    // data
+    //
+    // Return the filesystem data, i.e. the tree data field. The minimum information is:
+    //      platform    -- e.g. "darwin" or "win32"
+    //      semantics   -- e.g. "win32" or "posix"
+    //      pathsep     -- e.g. / or \
+
+    view.data = closure data(callback) {
+        if !callback
+            return (syncAdapter(data))
+        params = {
+            path: ""
+            op: "tree"
+            depthlimit: 0
+        }
+        api.psmRemote(params, false, function(error, tree) {
+            if error
+                debuglog("psmcFsView.data: can't get initial filesystem data:", ErrorString(error))
+            else {
+                view.fsdata = tree.data
+                if rootpath == ""
+                    rootpath = tree.data.pathsep
+            }
+            callback(error, tree.data)
+        })
+    }
+    
+    // pathInit
+    //
+    // Initialize our path module for the applicable path type.
+    
+    closure pathInit(local result) {
+        result = view.data()
+        if result.0
+            pathmod = false
+        else {
+            if view.fsdata.pathsep == "\\"
+                pathmod = JSpath.win32
+            else
+                pathmod = JSpath.posix
+            false
+        }
+    }
 
     // psmRemote
     //
@@ -30,10 +74,14 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     closure psmRemote(path, op, options, putdata, callback, local params, item) {
         if !callback
             return (syncAdapter(psmRemote, path, op, options, putdata))
+        if !pathmod && pathInit()
+            return                                                          // failed to initialize path module
         if !string(path)
             return (asyncResult(callback, Error("invalid path:", typeof(path))))
+        if rootpath != ""
+            path = pathmod.resolve(rootpath, path)
         params = {
-            path: JSpath.resolve(rootpath, path)
+            path: path
             op: op
         }
         for item in options
@@ -59,38 +107,30 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
 
     // path
     //
-    // The path sub-object remotes calls to the NodeJS path module.
+    // Redirect path calls to module chosen for filesystem semantics. It is possible for this to fail
+    // on first connection to the filesystem, in which case we return false for the path result.
+    // Throwing an error would complicate our callers and testing. This way there's a small chance
+    // that a transient error will give a bad path, but that will be detected downstream.
 
     view.path = new(object, this)
-    view.path[".undefined"] = closure path args {
-        closure (selector, arglist, local error, info) {
-            if !pathmod {
-                `(error, data) = view.data()
-                if error
-                    return (list(error))
-                if info.pathsep == "\\"
-                    pathmod = JSpath.win32
-                else
-                    pathmod = JSpath.posix
-            }
-            xapply(pathmod, selector, arglist)
-        } (args.0, args.-1)
+    view.path[".undefined"] = function path args {
+        if !pathmod
+            pathInit()
+        xapply(pathmod, args.0, args.-1)
     }
     
-    // data
+    // folderPath
     //
-    // Return the filesystem data, i.e. the tree data field. The minimum information is:
-    //      platform    -- e.g. "darwin" or "win32"
-    //      semantics   -- e.g. "win32" or "posix"
-    //      pathsep     -- e.g. / or \
-
-    view.data = closure data(callback) {
-        if !callback
-            return (syncAdapter(data))
-        psmRemote("", "tree", { depthlimit: 0 }, false, function(error, tree) {
-            view.fsdata = tree.data
-            callback(error, tree.data)
-        })
+    // Return the path of the specified special folder:
+    //      "HomeDir"
+    //      "TempDir"
+    //      "PackageDir"
+    // The returned path is relative to our root if within it, or absolute otherwise.
+    
+    view.folderPath = function folderPath(folderID, callback) {
+        psmRemote("", "folderPath", {
+            folderid: folderID
+        }, false, callback)
     }
                
     // readLines
@@ -123,7 +163,28 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     view.writeFile = function writeFile(path, data, options, callback) {
         psmRemote(path, "writeFile", options, data, callback)
     }
-            
+      
+    // readlink
+    //
+    // Read the contents of a symbolic link at the specified path
+    
+    view.readlink = function readlink(path, callback) {
+        psmRemote(path, "readlink", { }, false, callback)
+    }
+
+    // symlink
+    //
+    // Create a symbolic link path pointing to (containing the string) target
+    
+    view.symlink = function symlink(target, path, options, callback) {
+        if options
+            options = new(options)
+        else
+            options = { }
+        options.target = target
+        psmRemote(path, "symlink", options, false, callback)
+    }
+      
     // delete
     //
     // Delete a file or directory at the specified path
@@ -134,12 +195,45 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
 
     // info
     //
-    // Get file info at the specified path
+    // Get file or directory info at the specified path
+    
+    view.info = function info(path, options, callback) {
+        if !options
+            options = { }
+        psmRemote(path, "info", options, false, callback)
+    }
+          
+    // setInfo
+    //
+    // Set file or directory info obtained from info() call.
     
-    view.info = function info(path, callback) {
-        psmRemote(path, "info", { }, false, callback)
+    view.setInfo = function setInfo(path, info, callback) {
+        psmRemote(path, "setInfo", {
+            encoding: "json"
+        }, info, callback)
     }
      
+    // setOwnerGroup
+    //
+    // Set file or directory owner or group at the specified path
+    
+    view.setOwnerGroup = function setOwnerGroup(path, uid, gid, callback) {
+        psmRemote(path, "setOwnerGroup", {
+            uid: uid
+            gid: gid
+        }, false, callback)
+    }
+     
+    // setMode
+    //
+    // Set file or directory mode at the specified path
+    
+    view.setMode = function setMode(path, mode, callback) {
+        psmRemote(path, "setMode", {
+            mode: mode
+        }, false, callback)
+    }
+
     // setTimes
     //
     // Set file modify and access times at the specified path
@@ -157,7 +251,7 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     
     view.dirList = function dirList(path, options, callback) {
         psmRemote(path, "dirList", {
-            head: options.head
+            stat: options.stat
         }, false, callback)
     }
 
@@ -167,7 +261,7 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     
     view.readir = function readir(path, callback) {
         psmRemote(path, "dirList", {
-            head: true
+            stat: true
         }, false, callback)
     }
 
@@ -209,7 +303,9 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     // delete the source after the copy.
     
     view.copy = closure copy(srcpath, dest, options, callback, local parameters) {
-        if !options
+        if options
+            options = new(options)
+        else
             options = { }
         options.destination = JSpath.resolve(rootpath, dest)
         psmRemote(srcpath, "copy", options, false, callback)
@@ -325,7 +421,7 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
     connector.psm = psm
     connector.api = nicc.api
     connector.vault = psm.vault(connClassID)
-    connector.label = "Naan IDE Server"
+    connector.label = "Naan-Server"
     watch = psm.watchable(connector)
 
     // uifields
@@ -337,57 +433,44 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
             placeholder:    "http://host.com/endpoint"
             key:            "urlName" },
         {
-            label:          "Auth Name"
-            placeholder:    "account name"
-            key:            "authName" },
-        {
-            label:          "Auth Password"
-            placeholder:    "account password"
-            key:            "authPW"
-            type:           "password" },
+            label:          "Auth Secret"
+            placeholder:    "guid"
+            key:            "authSecret" }
         ]
     }
-        
-    // hashResourceID
-    //
-    // Make a stable hash based on the resource credentials that we can persist or share between
-    // different domains accessing the same resource.
-    connector.hashResourceID = function hashResourceID(resource, local ident) {
-        ident = resource.urlName
-        if resource.label
-            ident = ident.concat(resource.label)
-        HashSHA256(ident)
-    }
 
     // findResource
     //
-    // Find a resource with the specified contents, returning the resID or false. The loose criteria
-    // is: if added, would the specified contents be redundant to an existing resource?
+    // Find a resource with the specified contents, returning the resID or false.
     connector.findResource = function findResource(resource, local resID, creds) {
         for resID in listResources().1 {
             creds = access(resID).1
-            if resource.urlName == creds.urlName
-                && (!resource.label || resource.label == creds.label)
-                && resource.authName == creds.authName
+            if ((!resource.urlName || resource.urlName == creds.urlName)
+                && (!resource.label || resource.label == creds.label))
                 return (resID)
         }
         false
     }
 
-    // addResource
+
+    // writeResource
     //
-    // Add credentials for a named resource. The resource is a dictionary comprising these keys:
+    // Add or update credentials for a named resource. If no resID is specified this adds a new
+    // resource; otherwise it updates an existing one. The resource is a dictionary comprising these
+    // keys:
     //      label       - [optional] label we use for this resource
     //      urlName     - URL (e.g. "http://host.com/node/fsapi")
-    //      authName    - [optional] the authentication name for a URL
-    //      authPW      - [optional] the autentication password, required if authname is provided
+    //      authSecret  - access-control token for this URL
     //      hidden      - [optional] don't enumerate to user
     //      locked      - [optional] don't allow user delete
     //
-    // The return value is (error, resID) tuple. Error, if non-false, is a dictionary of field
+    // The return value is an (error, resID) tuple. Error, if non-false, is a dictionary of field
     // keys and error diagnostic strings.
-    connector.addResource = function addResource(resource, local creds, errors, error, resID, data) {
+    connector.writeResource = function writeResource(resource, resID,
+        local creds, errors, error, data, change) {
+        // badField - test for a bad string
         function badField(str) { !string(str) || str.trim().length == 0 }
+
         creds = { urlName: resource.urlName }
         errors = { }
         if resource.label
@@ -396,13 +479,13 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
             creds.label = resource.urlName
         if badField(creds.label)
             errors.label = "invalid label"
+        else if !resID && findResource({ label: creds.label })
+            errors.label = "duplicate name"
         if badField(resource.urlName)
             errors.urlName = "required field"
-        if !badField(resource.authName) {
-            creds.authName = resource.authName
-            creds.authPW = resource.authPW
-            if badField(resource.authPW)
-                errors.authPW = "required if Auth Name specified" }
+        if badField(resource.authSecret)
+            errors.authSecret = "required field"
+        creds.authSecret = resource.authSecret
         if length(errors) > 0
             error = errors
         else {
@@ -410,14 +493,36 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
                 creds.hidden = resource.hidden
             if resource.locked
                 creds.locked = resource.locked
-            resID = hashResourceID(resource)
-            `(error, data) = connector.vault.addResource(resID, creds)
+            if resID {
+                `(error, data) = connector.vault.updateResource(resID, creds)
+                change = { changed: [resID] }
+            } else {
+                resID = UUID()
+                `(error, data) = connector.vault.addResource(resID, creds)
+                change = { added: [resID] }
+            }
             if data {
-                watch.notify(connClassID, { added: [resID] })
-                data = resID } }
+                watch.notify(connClassID, change)
+                data = resID
+            }
+        }
         list(error, data)
     }
-    
+
+    // addResource
+    //
+    // Add a new resource, returning a standard error tuple per writeResource.
+    connector.addResource = function addResource(resource) {
+        writeResource(resource)
+    }
+
+    // updateResource
+    //
+    // Update an existing resource, returning a standard error tuple per writeResource.
+    connector.updateResource = function updateResource(resID, resource) {
+        writeResource(resource, resID)
+    }
+
     // getResource
     //
     // Get credentials for a named resource, matching the dictionary semantics of addResource. The
@@ -432,10 +537,8 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
         }
         if string(creds.urlName)
             resource.urlName = creds.urlName
-        if string(creds.authName)
-            resource.authName = creds.authName
-        if string(creds.authPW)
-            resource.authPW = creds.authPW
+        if string(creds.authSecret)
+            resource.authSecret = creds.authSecret
         list(false, resource)
     }
     
@@ -510,7 +613,7 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
             if creds == "HostFS"
                 api = connector.api
             else
-                api = MakeNideAPIclient(creds.urlName)                      // API to remote NodeJS filesystem
+                api = MakeNideAPIclient(creds.urlName, creds.authSecret)    // API to remote NodeJS filesystem
         }
         if error
             list(error)

package/frameworks/common/common.nlg

@@ -30,6 +30,49 @@ function EncodeQuery(prefix, items, local result, item) {
 };
 
 
+/*
+ * ContentTypeFromFileExt
+ *
+ *     Given a filename with extension, return a tuple of the recommended contentType and encoding
+ * for that type of data: `(contentType, encoding). Currently the encoding is false for text and
+ * "binary" for everything else.
+ *
+ */
+
+function ContentTypeFromFileExt(filepath, local mimeType, encoding) {
+    mimeType = {
+        "css":  "text/css",
+        "csv":  "text/csv",
+        "gif":  "image/gif",
+        "htm":  "text/html",
+        "html": "text/html",
+        "ico":  "image/x-icon",
+        "ics":  "application/octet-stream",
+        "jpeg": "image/jpeg",
+        "jpg":  "image/jpeg",
+        "js":   "text/javascript",
+        "json": "application/json",
+        "mov":  "video/mp4",
+        "mp3":  "audio/mpeg",
+        "mp4":  "video/mp4",
+        "nlg":  "text/plain",
+        "npk":  "application/json",
+        "ogg":  "video/ogg",
+        "svg":  "image/svg+xml",
+        "text": "text/plain",
+        "txt":  "text/plain",
+        "zip":  "application/octet-stream"
+    }[JSpath.extname(filepath).substring(1)]
+    if !mimeType
+        mimeType = "application/octet-stream"
+    if mimeType.startsWith("text/")
+        mimeType = mimeType.concat("; charset=UTF-8")
+    else
+        encoding = "binary"
+    list(mimeType, encoding)
+};
+
+
 /*
  * UUID
  *
@@ -66,7 +109,7 @@ function JsonParse(data) {
         list(false, data)
     } catch {
         if true
-             list(exception)
+            list(exception)
     }
 };
 
@@ -84,7 +127,7 @@ function JsonStringify(data) {
         list(false, data)
     } catch {
         if true
-             list(exception)
+            list(exception)
     }
 };
 
@@ -125,11 +168,8 @@ function JsLoadScript(libpath, globalID, local scriptTag, fpath) {
         }
         js.w.document.body.appendChild(scriptTag)
         pending.wait()
-    } else if js.g {
-        if !libpath.startsWith("/")
-            fpath = "./".concat(libpath)
-        jsScripts[libpath] = js.r(fpath)                                    // load in NodeJS context
-    }
+    } else if js.g
+        jsScripts[libpath] = js.r(libpath)                                  // load in NodeJS context
     jsScripts[libpath]
 };
 
@@ -256,15 +296,19 @@ TextEncoder = false;
 TextDecoder = false;
 EncodeURIComponent = false;
 DecodeURIComponent = false;
+EncodeBase64 = false;
+DecodeBase64 = false;
 JSONstringify = false;
 JSONparse = false;
+Uint8ArrayFromString = false;
 
 function comrInit(local manifest) {
-    manifest = `(EncodeQuery, UUID, JsLoadScript, LoadComponentOnDemand, LiveExport, comrInit)
+    manifest = `(EncodeQuery, ContentTypeFromFileExt, UUID, JsLoadScript, LoadComponentOnDemand, LiveExport, comrInit)
 
-    Naan.module.build(module.id, "nideCommon", closure(modobj, compobj) {
+    Naan.module.build(module.id, "common", closure(modobj, compobj) {
         compobj.manifest = manifest
         modobj.exports.EncodeQuery = EncodeQuery
+        modobj.exports.ContentTypeFromFileExt = ContentTypeFromFileExt
         modobj.exports.UUID = UUID
         modobj.exports.JsLoadScript = JsLoadScript
         modobj.exports.LoadComponentOnDemand = LoadComponentOnDemand
@@ -293,6 +337,14 @@ function comrInit(local manifest) {
             JSONstringify = wsg.JSON.stringify
             JSONparse = wsg.JSON.parse
             //
+            // everywhere: Uint8ArrayFromString
+            //
+            Uint8ArrayFromString = function uint8ArrayFromString(data) {
+                wsg.Uint8Array.from(Array.from(data).map(function(letter) {
+                    letter.charCodeAt(0)
+                }))
+            }
+            //
             // binaryFrom - convert arbitrary item to binary buffer or text.
             //
             function binaryFrom(data) {
@@ -321,29 +373,42 @@ function comrInit(local manifest) {
                     result
             }
             //
-            // base64Format - create base 64 string from binary array
-            //
-            function base64Format(data, local blob, reader, pending, result) {
-                blob = xnew(wsg.Blob, [data])
-                reader = xnew(wsg.FileReader)
-                pending = new(nonce)
-                reader.onload = function(event) { pending.signal(event.target.result) }
-                reader.readAsDataURL(blob)
-                result = pending.wait()
-                result.slice(37)
-            }
-            //
             // DecodeBase64url - decode base64url to original string
             // See https://en.wikipedia.org/wiki/Base64 for details on variants
             //
             DecodeBase64url = function decodeBase64url(base64url, local padding) {
                 base64url = base64url.replace(RegExp("-", "g"), '+').replace(RegExp("_", "g"), '/')
-                wsg.atob(base64url)
+                DecodeBase64(base64url)
             }
             //
             // For browser windows and web workers
             //
             if js.w || js.s {
+                //
+                // base64Format - create base 64 string from binary array
+                //
+                function browserBase64Format(data, local blob, reader, pending, result) {
+                    blob = xnew(wsg.Blob, [data])
+                    reader = xnew(wsg.FileReader)
+                    pending = new(nonce)
+                    reader.onload = function(event) { pending.signal(event.target.result) }
+                    reader.readAsDataURL(blob)
+                    result = pending.wait()
+                    result.slice(37)
+                }
+                //
+                // binary to Base64
+                EncodeBase64 = function browserEncodeBase64(data) {
+                    if xobject(data)
+                        browserBase64Format(data)
+                    else
+                        wsg.btoa(data)
+                }
+                //
+                // Base64 to binary
+                DecodeBase64 = function browserDecodeBase64(data) {
+                    wsg.atob(data)
+                }
                 //
                 // MD5 functions
                 JsLoadScript("frameworks/browser/spark-md5/spark-md5.min.js", "SparkMD5")
@@ -358,7 +423,7 @@ function comrInit(local manifest) {
                 //
                 // HashMD5 in base64
                 HashMD5_base64 = function browserMD5_base64(data) {
-                    wsg.btoa(browserMD5(data, true)) }
+                    EncodeBase64(browserMD5(data, true)) }
                 //
                 // browserDigest - only in secure contexts (localhost and HTTPS)
                 //
@@ -367,7 +432,7 @@ function comrInit(local manifest) {
                         throw(Error("crypto functions unavailable"))
                     data = binaryFrom(data)
                     if string(data)
-                        data = xnew(TextEncoder).encode(data)
+                        data = Uint8ArrayFromString(data)
                     `(error, result) = await(wsg.crypto.subtle.digest(algo, data))
                     if error
                         throw(Error("crypto digest failed", error))
@@ -386,7 +451,7 @@ function comrInit(local manifest) {
                 //
                 // HashSHA-256 in base64
                 HashSHA256_base64 = function browserSHA256_base64(data) {
-                    base64Format(browserDigest(data, "SHA-256"))
+                    browserBase64Format(browserDigest(data, "SHA-256"))
                 }
                //
                 // random bytes as UInt8Array - use toint() for integer
@@ -399,6 +464,16 @@ function comrInit(local manifest) {
             // For NodeJS
             //
             if js.g {
+                //
+                // binary to Base64
+                EncodeBase64 = function nodejsEncodeBase64(data) {
+                    wsg.Buffer.from(data, "binary").toString("base64")
+                }
+                //
+                // Base64 to binary
+                DecodeBase64 = function nodejsDecodeBase64(data) {
+                    wsg.Buffer.from(data, "base64").toString("binary")
+                }
                 if !crypto
                     crypto = js.r("crypto")
                 if crypto {
@@ -431,6 +506,8 @@ function comrInit(local manifest) {
                     HashMD5 =
                     HashMD5_base64 =
                     HashSHA1 =
+                    HashSHA256 =
+                    HashSHA256_base64 =
                     RandomBytes = function() { throw(Error("crypto functions unavailable")) }
                 }
             }
@@ -442,10 +519,13 @@ function comrInit(local manifest) {
             modobj.exports.TextDecoder = TextDecoder
             modobj.exports.EncodeURIComponent = EncodeURIComponent
             modobj.exports.DecodeURIComponent = DecodeURIComponent
+            modobj.exports.EncodeBase64 = EncodeBase64
+            modobj.exports.DecodeBase64 = DecodeBase64
             modobj.exports.JSONstringify = JSONstringify
             modobj.exports.JSONparse = JSONparse
             modobj.exports.JsonStringify = JsonStringify
             modobj.exports.JsonParse = JsonParse
+            modobj.exports.Uint8ArrayFromString = Uint8ArrayFromString
             modobj.exports.DecodeBase64url = DecodeBase64url
             modobj.exports.HashMD5 = HashMD5
             modobj.exports.HashMD5_base64 = HashMD5_base64

package/frameworks/common/preferences.nlg

@@ -125,6 +125,7 @@ function prefsInit(local manifest) {
     Naan.module.build(module.id, "preferences", function(modobj, compobj) {
         require("../common/common.nlg")
         compobj.manifest = manifest
+        updateExports()
     })
 
     module.exports.Preferences = Preferences

package/frameworks/common/watching.nlg

@@ -93,5 +93,6 @@ function wachInit(local manifest) {
         require("./common.nlg")
         compobj.manifest = manifest
         module.exports.Watchable = Watchable
+        updateExports()
     })
 } ();