@naanlang/naan 1.0.13 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@naanlang/naan",
-    "version": "1.0.13",
+    "version": "1.0.14",
     "author": "Richard C. Zulch",
     "description": "Naan™ software platform",
     "main": "./lib/core/naanlib.js",

package/plugins/openSearch/openSearch.nlg

@@ -32,6 +32,10 @@
  *      `number                                 -- float or integer
  *      `url                                    -- URL
  *
+ * Although the currency type is only treated as a text field for now, the intent is that these will
+ * match the RegEx /([A-Z]{3})(-?[0-9]+(?:[,.][0-9]+)?)/ so that the currency type and amount can be
+ * differentiated. Please see ISO 4217 for valid currency types.
+ *
  * Current options are:
  *  {
  *      languages: [
@@ -183,15 +187,15 @@ closure openSearchIndex(prosc, indexName, ioptions, local osin) {
                 //
                 // date
                 //
-                date: quote(
-                    textRawMF()
-                )
+                date: quote({
+                    type: "date"
+                })
                 //
                 // boolean
                 //
-                boolean: quote(
-                    textRawMF()
-                )
+                boolean: quote({
+                    type: "boolean"
+                })
                 //
                 // currency
                 //
@@ -213,15 +217,15 @@ closure openSearchIndex(prosc, indexName, ioptions, local osin) {
                 //
                 // integer
                 //
-                integer: quote(
-                    textRawMF()
-                )
+                integer: quote({
+                    type: "long"
+                })
                 //
                 // number
                 //
-                number: quote(
-                    textRawMF()
-                )
+                number: quote({
+                    type: "float"
+                })
                 //
                 // url
                 //
@@ -303,7 +307,6 @@ closure openSearchIndex(prosc, indexName, ioptions, local osin) {
                 properties: makeMapping(fields)
             }
         })
-        // printline("OpenSearchClient.create:\n${Dialect.print(params)}")
         prosc.request(indexName, {
             method: "PUT"
             putdata: params
@@ -500,7 +503,6 @@ closure OpenSearchClient(goptions, local oscl, prosc) {
             query.multi_match.fields = ["*"].concat(soptions.boost.fields.map(function (item) {
                 item.concat("^${soptions.boost.level}")
             }))
-        printline(Dialect.print(soptions.boost))
         if dictionary(soptions.qopts)
             query.multi_match = merge(query.multi_match, soptions.qopts)
         if dictionary(soptions.filter) {

package/plugins/serviceAws/aws_dynamo.nlg

@@ -357,7 +357,7 @@ closure DynaConverter(local conv) {
     //
     // condition dictionary:
     //  {
-    //      key:        <keyname, e.g. partition key name>                  // required
+    //      key:        <keyname, e.g. partition key name or path tuple>    // required
     //      "=":        <expression>                                        // exclusive of other comparisons
     //      ">":        <expression>                                        // exclusive of other comparisons
     //      "<":        <expression>                                        // exclusive of other comparisons
@@ -365,11 +365,12 @@ closure DynaConverter(local conv) {
     //      beginsWith: <string-expression>                                 // exclusive of other comparisons
     //      ">=":       <expression>                                        // with <= or alone
     //      "<=":       <expression>                                        // with >= or alone
+    //      exists:     <boolean>                                           // keyname existence matches boolean
     //  }
     //
 
     conv.createKeyExpression = function createKeyExpression(params, conds
-        local attval, rangename, range, keyname, op, expr, rangex, arg1, arg2) {
+        local attval, attname, rangename, range, keyname, op, expr, rangex, arg1, arg2) {
 
         // dupeop
         //
@@ -382,14 +383,24 @@ closure DynaConverter(local conv) {
         // build the expression
         //
         attval = genAttributeValueAdder(params)
+        attname = genAttributeNameAdder(params)
         for `(rangename, ranges) in conds {
             if !array(ranges)
                 ranges = [ranges]
             for range in ranges {
                 rangex = false
-                keyname = tostring(range.key)
+                if tuple(range.key) {
+                    keyname = []
+                    expr = range.key
+                    while expr
+                        keyname.push(attname(pop(expr)))
+                    keyname = keyname.join(".")
+                }
+                else
+                    keyname = tostring(range.key)
                 if !keyname
                     return (list(Error("key expression requires key name")))
+                keyname = attname(keyname)
                 for `(op, expr) in range {
                     if op == "key"
                         continue
@@ -417,10 +428,16 @@ closure DynaConverter(local conv) {
                     arg1 = rangex.1
                     if rangex.0 == "between" {
                         arg2 = rangex.2
-                        expr = keyname.concat(" between ", arg1, " and ", arg2)
+                        expr = "${keyname} between ${arg1} and ${arg2}"
                     }
                     else if rangex.0 == "beginsWith"
-                        expr = "begins_with(".concat(keyname, ", ", arg1, ")")
+                        expr = "begins_with(${keyname}, ${arg1})"
+                    else if rangex.0 == "exists" {
+                        if arg1
+                            expr = "attribute_exists(${keyname})"
+                        else
+                            expr = "attribute_not_exists(${keyname})"
+                    }
                     else
                         expr = keyname.concat(space, rangex.0, space, arg1)
                     if params[rangename]
@@ -674,14 +691,26 @@ closure DynaTable(dyna, tablename, local table) {
 
     // getRecord
     //
-    // Get a record from the table with the specified hash value, and optional range value.
+    // Get a record from the table with the specified hash value. The optional second argument can be
+    // the rangeValue of the item, or an options dictionary. Dictionary options include:
+    //  {
+    //      rangeValue:     <range-key>         // record's range key
+    //      consistentRead: <boolean>           // true to use consistent read
+    //  }
+    // The result is a standard result tuple `(error, record).
+
     //
-    table.getRecord = closure getRecord(hashValue, rangeValue, local params, pending) {
+    table.getRecord = closure getRecord(hashValue, options, local params, rangeValue, pending) {
         if preflightError(this)
             return
         params = {
             TableName: tablename
         }
+        if dictionary(options) {
+            rangeValue = options.rangeValue
+            params.ConsistentRead = options.consistentRead
+        } else
+            rangeValue = options
         params.Key = makeDynKey(list(hashValue, rangeValue))
         pending = new(nonce)
         dyna.aws.getItem(params, function(error, data) {
@@ -856,6 +885,7 @@ closure DynaTable(dyna, tablename, local table) {
     //      reverse:        <boolean>                                       // reverse order
     //      project:        <array>                                         // project only specified attributes
     //      paging:         <exclusive start key>                           // for paging; updated each call
+    //      consistentRead: <boolean>                                       // true to use consistent read
     //      limit:          <number>                                        // maximum count of results
     //  }
     //
@@ -902,6 +932,8 @@ closure DynaTable(dyna, tablename, local table) {
             params.ProjectionExpression = options.project.join(", ")
         if options.paging
             params.ExclusiveStartKey = options.paging
+        if options.consistentRead
+            params.ConsistentRead = options.consistentRead
         output = []
         `(error) = dynQueryPager(`query, params, options.limit, function(data) {
             if data.Count > 0
@@ -921,12 +953,13 @@ closure DynaTable(dyna, tablename, local table) {
     //
     // Options:
     //  {
-    //      index:      <string>                                            // index name in table
-    //      filter:     <key-expression>                                    // conditions for items to return
-    //      attmap:     <dictionary>                                        // map attribute names to #shortcuts
-    //      project:    <array>                                             // project only specified attributes
-    //      paging:     <exclusive start key>                               // for paging; updated each call
-    //      limit:      <number>                                            // maximum count of results
+    //      index:          <string>                                        // index name in table
+    //      filter:         <key-expression>                                // conditions for items to return
+    //      attmap:         <dictionary>                                    // map attribute names to #shortcuts
+    //      project:        <array>                                         // project only specified attributes
+    //      paging:         <exclusive start key>                           // for paging; updated each call
+    //      consistentRead: <boolean>                                       // true to use consistent read
+    //      limit:          <number>                                        // maximum count of results
     //  }
     //
 
@@ -953,6 +986,8 @@ closure DynaTable(dyna, tablename, local table) {
             params.ProjectionExpression = options.project.join(", ")
         if options.paging
             params.ExclusiveStartKey = options.paging
+        if options.consistentRead
+            params.ConsistentRead = options.consistentRead
         output = []
         `(error) = dynQueryPager(`scan, params, options.limit, function(data) {
             if data.Count >= 0

package/test/test_01_core.nlg

@@ -319,10 +319,13 @@ RegisterTestCategory("core", [
     [ "eval(`(+ 4 3));", "7" ],
     
     [ "apply(`+, `(4 3));", "7" ],
-    
+    [ "apply(getproc(`+), `(4, 3));", "7" ],                            // ensures that call takes a builtin as function
+    [ "apply(Number.parseInt, list('42'));", "42" ],
+
     [ "call(car(`+), 4, 3);", "7" ],
     [ "call(getproc(`+), 4, 3);", "7" ],                                // ensures that call takes a builtin as function
-    
+    [ "call(Number.parseInt, '42');", "42" ],
+
     [ "list();>", "false" ],
     [ "list(3, 4, 5, `(6 7));>", "(3 4 5 (6 7))" ],
 
@@ -424,7 +427,7 @@ RegisterTestCategory("core", [
     [ "temp(2, `(1 2 3));>", "(2 3)|(2 3)" ],
     [ "function (ex1, lex1) { ex1+pop(lex1), print(lex1), lex1 }(2, `(1 2 3));>", "(2 3)|(2 3)" ],
     [ "quote(function (a)\n { f(b)-\ng(c) * h(d)\n });>", "(function lambda (a) (- (f b) (* (g c) (h d))))" ],
-    [ "quote(function (a)\n { f(b)\n-g(c) * h(d)\n });>", "(function lambda (a) (- (f b) (* (g c) (h d))))" ],
+    [ "quote(function (a)\n { f(b)\\\n-g(c) * h(d)\n });>", "(function lambda (a) (- (f b) (* (g c) (h d))))" ],
     
     [ "tempo = temp.proc;>", "(function temp (ex1 lex1) (+ ex1 (pop lex1)) (print lex1) lex1)" ],
     [ "function temp(ex1) { ex1 * 2 };", "==> redefined: temp|temp" ],
@@ -589,7 +592,21 @@ RegisterTestCategory("core", [
     [ "bobby.sue(44);", "(44)(sue billy)/Dictionary{2}|(sam nevil bill)/(sue billy)|(\"sue\", \"billy\")" ],
     [ "keys(bobby);>", "(\"sue\" \"billy\")" ],
     
-    
+    ["merge();", "{ }"],
+    ["merge({a:3});", "{ a: 3 }"],
+    ["merge({a:3,b:4});", "{ a: 3, b: 4 }"],
+    ["merge({a:3,b:4,c:5});", "{ a: 3, b: 4, c: 5 }"],
+    ["merge(`(a));", "{ }"],
+    ["merge({a:3}, `(a));", "{ }"],
+    ["merge({a:3,b:4}, `(a), {c:5});", "{ b: 4, c: 5 }"],
+    ["merge({a:3,b:4}, `(c), {c:5});", "{ a: 3, b: 4, c: 5 }"],
+    ["merge({a:3,b:4}, `(g), {c:5});", "{ a: 3, b: 4, c: 5 }"],
+    ["merge({true:a,false:b});", "{ true: a, false: a }"],
+    ["merge({true:a,false:b}, `(true));", "{ false: a }"],
+    ["oo={true:a}; oo[1.0/3]=`b; oo;", "{ true: a }|b|{ true: a, 0.3333333333333333: b }"],
+    ["merge(oo, list(1.0/3), {false:c});", "{ true: a, false: c }"],
+    ["oo;", "{ true: a, 0.3333333333333333: b }"],
+
     //
     // object getters
     //
@@ -796,6 +813,9 @@ RegisterTestCategory("core", [
     [ "cons(`a);>", "(a)" ],
     [ "cons(`a,`b);>", "(a . b)" ],
     [ "cons(`a,`b,`c);>", "(a b . c)" ],
+
+    [ "unintern(true) === true", "false"],
+
     [ "length(stacktrace());", "55" ],
     
     //

package/test/test_03_jsinterop.nlg

@@ -63,6 +63,15 @@ RegisterTestCategory("JSinterop", [
 
     [ "xnew(js.g.Promise, function() {});", "[object Promise]" ],
     
+    //
+    // Arrays
+    //
+    
+    ["Array(3,4,5);", "[Array 3,4,5]"],
+    ["Array([3]);", "[Array [3]]"],
+    ["Array([3]).0;", "[Array 3]"],
+    ["Array([3]).0.0;", "3"],
+
     
     //
     // child processes

package/test/test_05_strings.nlg

@@ -71,6 +71,6 @@ RegisterTestCategory("strings", [
     [ "\"abc\".toString();", "\"abc\"" ],
     [ "xapply(String, toString, list(\"abc\"));", "\"abc\"" ],
     [ "xcall(String, toString, \"abc\");", "\"abc\"" ],
-    [ "function(local match) { \"abc\".match(RegExp(\"abc\")) }();", "[Array abc]" ]
+    [ "function(local match) { \"abc\".match(RegExp(\"abc\")) }();", '[Array "abc"]' ]
 
 ]);

package/test/test_06_lingoparse.nlg

@@ -61,7 +61,7 @@ RegisterTestCategory("Lingo parse", [
     //
     
     [ "4&&3;", { exprs: "(&& 4 3)" } ],
-    [ "4\n&&3;", { exprs: "(&& 4 3)" } ],
+    [ "4\\\n&&3;", { exprs: "(&& 4 3)" } ],
     [ "4&&\n3;", { exprs: "(&& 4 3)" } ],
     [ "function test0(x, y) { \n y = 3\n x  \n };", { exprs: "(defproc function test0 (x y) (= y 3) x)" } ],
 
@@ -468,7 +468,7 @@ RegisterTestCategory("Lingo parse", [
     //
     
     [ "function() {test()[3]};>", "(function lambda false (deref (test) 3))"],
-    [ "function() {test()\n[3]};>", "(function lambda false (deref (test) 3))"],
+    [ "function() {test()\\\n[3]};>", "(function lambda false (deref (test) 3))"],
     [ "function() {test(),\n[3]};>", "(function lambda false (test) Array[1])"],
     [ "function() {test(),\n[3]};", "function () {\n"
         "    test(),\n"                                                     // need comma before array
@@ -497,6 +497,28 @@ RegisterTestCategory("Lingo parse", [
         "    else {\n"
         "        { a: 3 } }\n"                                              // need braces around dictionary
         "}" ],
+    [ "function() {if 1, -2 };", "function () {\n"
+        "    if 1\n"
+        "        -2\n"
+        "}" ],
+    [ "function() {if 1,\n"
+                    "-2 };", "function () {\n"
+        "    if 1\n"
+        "        -2\n"
+        "}" ],
+    [ "function() {if 1\n"
+                    "-2 };",
+        { errors: "ambiguous newline (use \\ or ,) at (2, 1) found -" } ],
+    [ "function() {if 1\\\n"
+                    "-2 3 };", "function () {\n"
+        "    if 1 - 2\n"
+        "        3\n"
+        "}" ],
+    [ "function() { else };",
+        { errors: "stray keyword at (1, 14) found else" } ],
+    [ "function() { if 1 else 3 };",
+        { errors: "stray keyword at (1, 19) found else"
+            "|mismatched delimiter at (1, 24) found 3 expected } starting with { at (1, 12)" } ],
 
     //
     // semantic validity

package/test/test_07_lingo.nlg

@@ -159,15 +159,25 @@ RegisterTestCategory("Lingo", [
 //      "        map           : [(0, 23), 0, 9, 2, 7],\n" -- maps currently omitted
         "        comments      : [] } }" ],
     [ "testat@jim(true);", "\"you are annotated with true!\"" ],
+    [ "copyann(testat, a);", "testat" ],
+    [ "testat@*;", '("joe", "jim", ".sourcemap")' ],
+    [ "copyann(testat, a, true);", "testat" ],
+    [ "testat@*;", '("joe")' ],
+    [ "copyann(3, a);", { errors: "attempt to modify constant 3" } ],
+    [ "copyann(a, 3);", "false" ],
 
 
     //
-    // lists, objects & arrays
+    // lists, dictionaries, objects, and arrays
     //
     
     [ "divide(71, 3);", "(23 . 2)" ],
     [ "[3,4+5];", "[3, 9]" ],
     [ "{a:3,b:4+5};", "{ a: 3, b: 9 }" ],
+    [ "function(g) { { a: 3+g } }(5);", "{ a: 8 }" ],
+    [ "function(g) { { a: false || undefined } }(6);", "{ }" ],
+    [ "function(g) { { a: false && g || undefined } }(7);", "{ }" ],
+    [ "function(g) { { a: true && g || undefined } }(8);", "{ a: 8 }" ],
 
     [ "`(1, 2, {a:3,b:4}, 5);", "(1, 2, { a: 3, b: 4 }, 5)" ],
     [ "`(1, 2, {a:3,b:4}, 5);>", "(1 2 Dictionary{2} 5)" ],