jsdoctypeparser - npm Package Compare versions

Comparing version 2.0.0-alpha-5 to 2.0.0-alpha-6

lib/NodeType.js

@@ -21,2 +21,4 @@ var NodeType = {
   EXTERNAL: 'EXTERNAL',
+  FILE_PATH: 'FILE_PATH',
+  PARENTHESIS: 'PARENTHESIS',
 };
@@ -23,0 +25,0 @@

lib/publishing.js

 'use strict';
 
 
-var lodash = require('lodash');
 var format = require('util').format;
@@ -23,7 +22,7 @@
       return format('%s.%s', concretePublish(memberNode.owner),
-                         memberNode.name);
+                    memberNode.name);
     },
     UNION: function(unionNode, concretePublish) {
-      return format('(%s|%s)', concretePublish(unionNode.left),
-                         concretePublish(unionNode.right));
+      return format('%s|%s', concretePublish(unionNode.left),
+                    concretePublish(unionNode.right));
     },
@@ -34,3 +33,3 @@ VARIADIC: function(variadicNode, concretePublish) {
     RECORD: function(recordNode, concretePublish) {
-      var concretePublishedEntries = lodash.map(recordNode.entries, concretePublish);
+      var concretePublishedEntries = recordNode.entries.map(concretePublish);
       return format('{%s}', concretePublishedEntries.join(', '));
@@ -43,9 +42,12 @@ },
     GENERIC: function(genericNode, concretePublish) {
-      var concretePublishedObjects = lodash.map(genericNode.objects, concretePublish);
+      var concretePublishedObjects = genericNode.objects.map(concretePublish);
       return format('%s<%s>', concretePublish(genericNode.subject),
-                         concretePublishedObjects.join(', '));
+                    concretePublishedObjects.join(', '));
     },
-    MODULE: function(moduleNode) {
-      return format('module:%s', moduleNode.path);
+    MODULE: function(moduleNode, concretePublish) {
+      return format('module:%s', concretePublish(moduleNode.value));
     },
+    FILE_PATH: function(filePathNode) {
+      return filePathNode.path;
+    },
     OPTIONAL: function(optionalNode, concretePublish) {
@@ -61,3 +63,3 @@ return format('%s=', concretePublish(optionalNode.value));
     FUNCTION: function(functionNode, concretePublish) {
-      var publidshedParams = lodash.map(functionNode.params, concretePublish);
+      var publidshedParams = functionNode.params.map(concretePublish);
 
@@ -102,2 +104,5 @@ if (functionNode.new) {
     },
+    PARENTHESIS: function(parenthesizedNode, concretePublish) {
+      return format('(%s)', concretePublish(parenthesizedNode.value));
+    },
   };
@@ -104,0 +109,0 @@ }

lib/SyntaxType.js

@@ -57,5 +57,29 @@ /**
   SUFFIX_DOTS: 'SUFFIX_DOTS',
+
+  /**
+   * From Closure Library.
+   * Example: {@code ...}
+   */
+  ONLY_DOTS: 'ONLY_DOTS',
 };
 
 
+var OptionalTypeSyntax = {
+  PREFIX_EQUALS_SIGN: 'PREFIX_EQUALS_SIGN',
+  SUFFIX_EQUALS_SIGN: 'SUFFIX_EQUALS_SIGN',
+};
+
+
+var NullableTypeSyntax = {
+  PREFIX_QUESTION_MARK: 'PREFIX_QUESTION_MARK',
+  SUFFIX_QUESTION_MARK: 'SUFFIX_QUESTION_MARK',
+};
+
+
+var NotNullableTypeSyntax = {
+  PREFIX_BANG: 'PREFIX_BANG',
+  SUFFIX_BANG: 'SUFFIX_BANG',
+};
+
+
 module.exports = {
@@ -65,2 +89,5 @@ GenericTypeSyntax: GenericTypeSyntax,
   VariadicTypeSyntax: VariadicTypeSyntax,
+  OptionalTypeSyntax: OptionalTypeSyntax,
+  NullableTypeSyntax: NullableTypeSyntax,
+  NotNullableTypeSyntax: NotNullableTypeSyntax,
 };

lib/traversing.js

 'use strict';
 
 
-var lodash = require('lodash');
-
-
 /**
@@ -17,3 +14,3 @@ * Traverse the specified AST.
   var childNodes = _collectChildNodes(node);
-  lodash.forEach(childNodes, function(childNode) {
+  childNodes.forEach(function(childNode) {
     traverse(childNode, opt_onEnter, opt_onLeave);
@@ -35,3 +32,3 @@ });
   NODE_LIST: function(fn, nodes) {
-    lodash.forEach(nodes, function(node) {
+    nodes.forEach(function(node) {
       fn(node);
@@ -69,3 +66,5 @@ });
   },
-  MODULE: {},
+  MODULE: {
+    value: _PropertyAccessor.NODE,
+  },
   OPTIONAL: {
@@ -99,2 +98,6 @@ value: _PropertyAccessor.NODE,
   },
+  FILE_PATH: {},
+  PARENTHESIS: {
+    value: _PropertyAccessor.NODE,
+  },
 };
@@ -108,3 +111,4 @@
 
-  lodash.forEach(propAccessorMap, function(propAccessor, propName) {
+  Object.keys(propAccessorMap).forEach(function(propName) {
+    var propAccessor = propAccessorMap[propName];
     propAccessor(childNodes.push.bind(childNodes), node[propName]);
@@ -111,0 +115,0 @@ });

package.json

 {
   "name": "jsdoctypeparser",
   "description": "Strict JsDoc type expression parser.",
-  "version": "2.0.0-alpha-5",
+  "version": "2.0.0-alpha-6",
   "author": "Kuniwak <[e-mail]>",
@@ -24,7 +24,10 @@ "keywords": [
   "scripts": {
-    "prepublidh": "npm run build",
-    "pretest": "npm run lint",
+    "prepublidh": "npm-run-all build",
+    "pretest": "npm-run-all lint build",
     "test": "mocha tests",
-    "lint": "eslint lib tests && jscs lib tests",
-    "build": "gulp build"
+    "lint": "eslint lib tests",
+    "clean": "rimraf ./peg_lib",
+    "postclean": "mkdirp ./peg_lib",
+    "prebuild": "npm-run-all clean",
+    "build": "pegjs --cache ./peg_src/jsdoctype.pegjs ./peg_lib/jsdoctype.js"
   },
@@ -35,15 +38,10 @@ "readmeFilename": "README.md",
     "eslint": "^0.20.0",
-    "gulp": "^3.8.11",
-    "gulp-debug": "^2.0.1",
-    "gulp-peg": "^0.1.2",
-    "gulp-plumber": "^0.6.6",
-    "gulp-util": "^3.0.6",
-    "gulp-watch": "^4.3.5",
-    "jscs": "^1.13.1",
-    "mocha": "^2.2.4"
+    "mkdirp": "^0.5.1",
+    "mocha": "^2.2.4",
+    "npm-run-all": "^2.1.0",
+    "pegjs": "^0.9.0",
+    "rimraf": "^2.5.2"
   },
   "license": "MIT",
-  "dependencies": {
-    "lodash": "^3.7.0"
-  }
+  "dependencies": {}
 }

README.md

@@ -394,3 +394,6 @@ jsdoctypeparser
   "type": "OPTIONAL",
-  "value": node
+  "value": node,
+  "meta": {
+    "syntax": ("PREFIX_EQUALS_SIGN" or "SUFFIX_EQUALS_SIGN")
+  }
 }
@@ -415,3 +418,6 @@ ```
   "type": "NULLABLE",
-  "value": node
+  "value": node,
+  "meta": {
+    "syntax": ("PREFIX_QUESTION_MARK" or "SUFFIX_QUESTION_MARK")
+  }
 }
@@ -436,3 +442,6 @@ ```
   "type": "NOT_NULLABLE",
-  "value": node
+  "value": node,
+  "meta": {
+    "syntax": ("PREFIX_BANG" or "SUFFIX_BANG")
+  }
 }
@@ -450,2 +459,3 @@ ```
  * @type {Variadic...}
+ * @type {...}
  */
@@ -459,5 +469,5 @@ ```
   "type": "VARIADIC",
-  "value": node,
+  "value": node (or null),
   "meta": {
-    "syntax": ("PREFIX_DOTS" or "SUFFIX_DOTS")
+    "syntax": ("PREFIX_DOTS" or "SUFFIX_DOTS" or "ONLY_DOTS")
   }
@@ -474,3 +484,3 @@ }
 /**
- * @type {module:path/to/file.js}
+ * @type {module:path/to/file.Module}
  */
@@ -484,2 +494,23 @@ ```
   "type": "MODULE",
+  "value": node
+}
+```
+
+
+### `FILE_PATH`
+
+Example:
+
+```javascript
+/**
+ * @type {module:path/to/file.Module}
+ *               ^^^^^^^^^^^^
+ */
+```
+
+Structure:
+
+```javascript
+{
+  "type": "FILE_PATH",
   "path": string
@@ -592,2 +623,23 @@ }
 
+### `PARENTHESIS`
+
+Example:
+
+```javascript
+/**
+ * @type {(Foo)}
+ */
+```
+
+Structure:
+
+```javascript
+{
+  "type": "PARENTHESIS",
+  "value": node
+}
+```
+
+
+
 ### Others
@@ -594,0 +646,0 @@

tests/test_index.js

@@ -5,3 +5,2 @@ 'use strict';
 var expect = chai.expect;
-var lodash = require('lodash');
 var jsdoctypeparser = require('../index.js');
@@ -22,3 +21,4 @@
 
-  lodash.forEach(expectedTypeMap, function(expectedType, key) {
+  Object.keys(expectedTypeMap).forEach(function(key) {
+    var expectedType = expectedTypeMap[key];
     describe('.' + key, function() {
@@ -25,0 +25,0 @@ it('should be exported', function() {

tests/test_parsing.js

@@ -11,2 +11,5 @@ 'use strict';
 var VariadicTypeSyntax = SyntaxType.VariadicTypeSyntax;
+var OptionalTypeSyntax = SyntaxType.OptionalTypeSyntax;
+var NullableTypeSyntax = SyntaxType.NullableTypeSyntax;
+var NotNullableTypeSyntax = SyntaxType.NotNullableTypeSyntax;
 var Parser = require('../lib/parsing.js');
@@ -70,7 +73,10 @@
 
-  it('should return a module name node when "module:path/to/file.js" arrived', function() {
-    var typeExprStr = 'module:path/to/file.js';
+  it('should return an optional unknown type node when "?=" arrived', function() {
+    var typeExprStr = '?=';
     var node = Parser.parse(typeExprStr);
 
-    var expectedNode = createModuleNameNode('path/to/file.js');
+    var expectedNode = createOptionalTypeNode(
+      createUnknownTypeNode(),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
+    );
     expect(node).to.deep.equal(expectedNode);
@@ -80,7 +86,7 @@ });
 
-  it('should return a module name node when "module : path/to/file.js" arrived', function() {
-    var typeExprStr = 'module : path/to/file.js';
+  it('should return a module name node when "module:path/to/file" arrived', function() {
+    var typeExprStr = 'module:path/to/file';
     var node = Parser.parse(typeExprStr);
 
-    var expectedNode = createModuleNameNode('path/to/file.js');
+    var expectedNode = createModuleNameNode(createFilePathNode('path/to/file'));
     expect(node).to.deep.equal(expectedNode);
@@ -90,8 +96,19 @@ });
 
-  it('should return a member node when "(module:path/to/file.js).member" arrived', function() {
-    var typeExprStr = '(module:path/to/file.js).member';
+  it('should return a module name node when "module : path/to/file" arrived', function() {
+    var typeExprStr = 'module : path/to/file';
     var node = Parser.parse(typeExprStr);
 
+    var expectedNode = createModuleNameNode(createFilePathNode('path/to/file'));
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should return a member node when "(module:path/to/file).member" arrived', function() {
+    var typeExprStr = '(module:path/to/file).member';
+    var node = Parser.parse(typeExprStr);
+
     var expectedNode = createMemberTypeNode(
-      createModuleNameNode('path/to/file.js'),
+      createParenthesizedNode(
+        createModuleNameNode(createFilePathNode('path/to/file'))
+      ),
       'member'
@@ -103,2 +120,13 @@ );
 
+  it('should return a member node when "module:path/to/file.member" arrived', function() {
+    var typeExprStr = 'module:path/to/file.member';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createModuleNameNode(
+      createMemberTypeNode(createFilePathNode('path/to/file'), 'member')
+    );
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
   it('should return a module name node when "external:string" arrived', function() {
@@ -169,3 +197,4 @@ var typeExprStr = 'external:string';
         'owner'),
-      'Member')
+      'Member'),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
     );
@@ -225,3 +254,4 @@
         'owner'),
-      'innerMember')
+      'innerMember'),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
     );
@@ -282,3 +312,4 @@
         'owner'),
-      'instanceMember')
+      'instanceMember'),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
     );
@@ -324,5 +355,7 @@
 
-    var expectedNode = createUnionTypeNode(
-      createTypeNameNode('LeftType'),
-      createTypeNameNode('RightType')
+    var expectedNode = createParenthesizedNode(
+      createUnionTypeNode(
+        createTypeNameNode('LeftType'),
+        createTypeNameNode('RightType')
+      )
     );
@@ -338,5 +371,7 @@
 
-    var expectedNode = createUnionTypeNode(
-      createTypeNameNode('LeftType'),
-      createTypeNameNode('RightType')
+    var expectedNode = createParenthesizedNode(
+      createUnionTypeNode(
+        createTypeNameNode('LeftType'),
+        createTypeNameNode('RightType')
+      )
     );
@@ -367,3 +402,5 @@
     var expectedNode = createVariadicTypeNode(
-      createTypeNameNode('variadicType'));
+      createTypeNameNode('variadicType'),
+      VariadicTypeSyntax.PREFIX_DOTS
+    );
 
@@ -450,2 +487,15 @@ expect(node).to.deep.equal(expectedNode);
 
+  it('should return a record type node when "{\'quoted-key\':ValueType}"' +
+     ' arrived', function() {
+    var typeExprStr = '{\'quoted-key\':ValueType}';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createRecordTypeNode([
+      createRecordEntryNode('quoted-key', createTypeNameNode('ValueType')),
+    ]);
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
   it('should return a generic type node when "Generic<ParamType>" arrived', function() {
@@ -581,2 +631,18 @@ var typeExprStr = 'Generic<ParamType>';
 
+  it('should return a generic type node when "ParamType [ ] [ ]" arrived', function() {
+    var typeExprStr = 'ParamType [ ] [ ]';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createGenericTypeNode(
+      createTypeNameNode('Array'), [
+        createGenericTypeNode(
+          createTypeNameNode('Array'), [
+            createTypeNameNode('ParamType'),
+        ], GenericTypeSyntax.SQUARE_BRACKET),
+      ], GenericTypeSyntax.SQUARE_BRACKET);
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
   it('should return an optional type node when "string=" arrived', function() {
@@ -587,3 +653,4 @@ var typeExprStr = 'string=';
     var expectedNode = createOptionalTypeNode(
-      createTypeNameNode('string')
+      createTypeNameNode('string'),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
     );
@@ -600,3 +667,4 @@
     var expectedNode = createOptionalTypeNode(
-      createTypeNameNode('string')
+      createTypeNameNode('string'),
+      OptionalTypeSyntax.PREFIX_EQUALS_SIGN
     );
@@ -613,3 +681,4 @@
     var expectedNode = createNullableTypeNode(
-      createTypeNameNode('string')
+      createTypeNameNode('string'),
+      NullableTypeSyntax.PREFIX_QUESTION_MARK
     );
@@ -626,3 +695,4 @@
     var expectedNode = createNullableTypeNode(
-      createTypeNameNode('string')
+      createTypeNameNode('string'),
+      NullableTypeSyntax.SUFFIX_QUESTION_MARK
     );
@@ -634,2 +704,54 @@
 
+  it('should return an optional type node when "string =" arrived', function() {
+    var typeExprStr = 'string =';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createOptionalTypeNode(
+      createTypeNameNode('string'),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should return an optional type node when "= string" arrived (deprecated)', function() {
+    var typeExprStr = '= string';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createOptionalTypeNode(
+      createTypeNameNode('string'),
+      OptionalTypeSyntax.PREFIX_EQUALS_SIGN
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should return a nullable type node when "? string" arrived', function() {
+    var typeExprStr = '? string';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createNullableTypeNode(
+      createTypeNameNode('string'),
+      NullableTypeSyntax.PREFIX_QUESTION_MARK
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should return a nullable type node when "string ?" arrived (deprecated)', function() {
+    var typeExprStr = 'string ?';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createNullableTypeNode(
+      createTypeNameNode('string'),
+      NullableTypeSyntax.SUFFIX_QUESTION_MARK
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
   it('should return an optional type node when "?string=" arrived', function() {
@@ -639,4 +761,8 @@ var typeExprStr = '?string=';
 
-    var expectedNode = createNullableTypeNode(
-      createOptionalTypeNode(createTypeNameNode('string'))
+    var expectedNode = createOptionalTypeNode(
+      createNullableTypeNode(
+        createTypeNameNode('string'),
+        NullableTypeSyntax.PREFIX_QUESTION_MARK
+      ),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
     );
@@ -648,2 +774,36 @@
 
+  it('should return an optional type node when "string?=" arrived', function() {
+    var typeExprStr = 'string?=';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createOptionalTypeNode(
+      createNullableTypeNode(
+        createTypeNameNode('string'),
+        NullableTypeSyntax.SUFFIX_QUESTION_MARK
+      ),
+      OptionalTypeSyntax.SUFFIX_EQUALS_SIGN
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should throw an error when "?!string" arrived', function() {
+    var typeExprStr = '?!string';
+
+    expect(function() {
+      Parser.parse(typeExprStr);
+    }).to.throw(Parser.SyntaxError);
+  });
+
+
+  it('should throw an error when "!?string" arrived', function() {
+    var typeExprStr = '!?string';
+
+    expect(function() {
+      Parser.parse(typeExprStr);
+    }).to.throw(Parser.SyntaxError);
+  });
+
+
   it('should return a variadic type node when "...PrefixVariadic" arrived', function() {
@@ -654,3 +814,5 @@ var typeExprStr = '...PrefixVariadic';
     var expectedNode = createVariadicTypeNode(
-      createTypeNameNode('PrefixVariadic'), VariadicTypeSyntax.PREFIX_DOTS);
+      createTypeNameNode('PrefixVariadic'),
+      VariadicTypeSyntax.PREFIX_DOTS
+    );
 
@@ -666,3 +828,5 @@ expect(node).to.deep.equal(expectedNode);
     var expectedNode = createVariadicTypeNode(
-      createTypeNameNode('SuffixVariadic'), VariadicTypeSyntax.SUFFIX_DOTS);
+      createTypeNameNode('SuffixVariadic'),
+      VariadicTypeSyntax.SUFFIX_DOTS
+    );
 
@@ -678,3 +842,7 @@ expect(node).to.deep.equal(expectedNode);
     var expectedNode = createVariadicTypeNode(
-      createNotNullableTypeNode(createTypeNameNode('Object'))
+      createNotNullableTypeNode(
+        createTypeNameNode('Object'),
+        NotNullableTypeSyntax.PREFIX_BANG
+      ),
+      VariadicTypeSyntax.PREFIX_DOTS
     );
@@ -690,3 +858,6 @@
 
-    var expectedNode = createVariadicTypeNode(createUnknownTypeNode());
+    var expectedNode = createVariadicTypeNode(
+      createUnknownTypeNode(),
+      VariadicTypeSyntax.PREFIX_DOTS
+    );
 
@@ -702,3 +873,4 @@ expect(node).to.deep.equal(expectedNode);
     var expectedNode = createNotNullableTypeNode(
-      createTypeNameNode('Object')
+      createTypeNameNode('Object'),
+      NotNullableTypeSyntax.PREFIX_BANG
     );
@@ -710,2 +882,41 @@
 
+  it('should return a not nullable type node when "Object!" arrived', function() {
+    var typeExprStr = 'Object!';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createNotNullableTypeNode(
+      createTypeNameNode('Object'),
+      NotNullableTypeSyntax.SUFFIX_BANG
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should return a not nullable type node when "! Object" arrived', function() {
+    var typeExprStr = '! Object';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createNotNullableTypeNode(
+      createTypeNameNode('Object'),
+      NotNullableTypeSyntax.PREFIX_BANG
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should return a not nullable type node when "Object !" arrived', function() {
+    var typeExprStr = 'Object !';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createNotNullableTypeNode(
+      createTypeNameNode('Object'),
+      NotNullableTypeSyntax.SUFFIX_BANG
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
   it('should return a function type node when "function()" arrived', function() {
@@ -751,2 +962,51 @@ var typeExprStr = 'function()';
 
+  it('should return a function type node with variadic params when "function(...VariadicParam)"' +
+     ' arrived', function() {
+    var typeExprStr = 'function(...VariadicParam)';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createFunctionTypeNode(
+      [
+        createVariadicTypeNode(
+          createTypeNameNode('VariadicParam'),
+          VariadicTypeSyntax.PREFIX_DOTS
+        ),
+      ],
+      null, { 'this': null, 'new': null }
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should return a function type node with variadic params when "function(Param,...VariadicParam)"' +
+     ' arrived', function() {
+    var typeExprStr = 'function(Param,...VariadicParam)';
+    var node = Parser.parse(typeExprStr);
+
+    var expectedNode = createFunctionTypeNode(
+      [
+        createTypeNameNode('Param'),
+        createVariadicTypeNode(
+          createTypeNameNode('VariadicParam'),
+          VariadicTypeSyntax.PREFIX_DOTS
+        ),
+      ],
+      null, { 'this': null, 'new': null }
+    );
+
+    expect(node).to.deep.equal(expectedNode);
+  });
+
+
+  it('should throw an error when "function(...VariadicParam, UnexpectedLastParam)"' +
+     ' arrived', function() {
+    var typeExprStr = 'function(...VariadicParam, UnexpectedLastParam)';
+
+    expect(function() {
+      Parser.parse(typeExprStr);
+    }).to.throw(Parser.SyntaxError);
+  });
+
+
   it('should return a function type node with returns when "function():Returned"' +
@@ -824,16 +1084,19 @@ ' arrived', function() {
 
-  it('should return a function type node as a constructor when ' +
-     '"function(new:NewObject, this:ThisObject, param1)" arrived', function() {
-    var typeExprStr = 'function(new:NewObject, this:ThisObject, param1)';
-    var node = Parser.parse(typeExprStr);
+  it('should throw an error when "function(new:NewObject, this:ThisObject)" ' +
+     'arrived', function() {
+    var typeExprStr = 'function(new:NewObject, this:ThisObject)';
 
-    var expectedNode = createFunctionTypeNode(
-      [ createTypeNameNode('param1') ], null,
-      {
-        'this': createTypeNameNode('ThisObject'),
-        'new': createTypeNameNode('NewObject'),
-      }
-    );
+    expect(function() {
+      Parser.parse(typeExprStr);
+    }).to.throw(Parser.SyntaxError);
+  });
 
-    expect(node).to.deep.equal(expectedNode);
+
+  it('should throw an error when "function(this:ThisObject, new:NewObject)" ' +
+     'arrived', function() {
+    var typeExprStr = 'function(this:ThisObject, new:NewObject)';
+
+    expect(function() {
+      Parser.parse(typeExprStr);
+    }).to.throw(Parser.SyntaxError);
   });
@@ -983,3 +1246,2 @@
 
-
   it('should throw a syntax error when "..." arrived', function() {
@@ -992,2 +1254,27 @@ var typeExprStr = '...';
   });
+
+
+  describe('operator precedence', function() {
+    context('when "Foo|function():Returned?" arrived', function() {
+      it('should parse as "Foo|((function():Returned)?)"', function() {
+        var typeExprStr = 'Foo|function():Returned?';
+        var node = Parser.parse(typeExprStr);
+
+        var expectedNode = createUnionTypeNode(
+          createTypeNameNode('Foo'),
+          createNullableTypeNode(
+            createFunctionTypeNode(
+              [],
+              createTypeNameNode('Returned'),
+            { 'this': null, 'new': null }
+            ),
+            NullableTypeSyntax.SUFFIX_QUESTION_MARK
+          ),
+          UnionTypeSyntax.PIPE
+        );
+
+        expect(node).to.deep.equal(expectedNode);
+      });
+    });
+  });
 });
@@ -1015,6 +1302,6 @@
 
-function createModuleNameNode(moduleName) {
+function createModuleNameNode(value) {
   return {
     type: NodeType.MODULE,
-    path: moduleName,
+    value: value,
   };
@@ -1030,20 +1317,23 @@ }
 
-function createOptionalTypeNode(optionalTypeExpr) {
+function createOptionalTypeNode(optionalTypeExpr, syntax) {
   return {
     type: NodeType.OPTIONAL,
     value: optionalTypeExpr,
+    meta: { syntax: syntax },
   };
 }
 
-function createNullableTypeNode(nullableTypeExpr) {
+function createNullableTypeNode(nullableTypeExpr, syntax) {
   return {
     type: NodeType.NULLABLE,
     value: nullableTypeExpr,
+    meta: { syntax: syntax },
   };
 }
 
-function createNotNullableTypeNode(nullableTypeExpr) {
+function createNotNullableTypeNode(nullableTypeExpr, syntax) {
   return {
     type: NodeType.NOT_NULLABLE,
     value: nullableTypeExpr,
+    meta: { syntax: syntax },
   };
@@ -1089,3 +1379,3 @@ }
     value: variadicTypeExpr,
-    meta: { syntax: syntax || VariadicTypeSyntax.PREFIX_DOTS },
+    meta: { syntax: syntax },
   };
@@ -1141,1 +1431,15 @@ }
 }
+
+function createFilePathNode(filePath) {
+  return {
+    type: NodeType.FILE_PATH,
+    path: filePath,
+  };
+}
+
+function createParenthesizedNode(value) {
+  return {
+    type: NodeType.PARENTHESIS,
+    value: value,
+  };
+}

tests/test_publishing.js

@@ -54,3 +54,3 @@ 'use strict';
     var node = parse('number|boolean');
-    expect(publish(node)).to.equal('(number|boolean)');
+    expect(publish(node)).to.equal('number|boolean');
   });
@@ -57,0 +57,0 @@

tests/test_traversing.js

@@ -7,3 +7,2 @@ 'use strict';
 var traverse = require('../lib/traversing.js').traverse;
-var lodash = require('lodash');
 
@@ -158,6 +157,8 @@
         type: NodeType.MODULE,
-        name: 'module',
+        value: createFilePathNode('module'),
       },
       then: [
         ['enter', NodeType.MODULE],
+        ['enter', NodeType.FILE_PATH],
+        ['leave', NodeType.FILE_PATH],
         ['leave', NodeType.MODULE],
@@ -340,3 +341,5 @@ ],
 
-  lodash.forEach(testCases, function(testCaseInfo, testCaseName) {
+  Object.keys(testCases).forEach(function(testCaseName) {
+    var testCaseInfo = testCases[testCaseName];
+
     it(testCaseName, function() {
@@ -407,1 +410,8 @@ var visitedOrder = [];
 }
+
+function createFilePathNode(filePath) {
+  return {
+    type: NodeType.FILE_PATH,
+    path: filePath,
+  };
+}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 6 instances in 1 package

AI-detected potential code anomaly

Supply chain risk

AI has identified unusual behaviors that may pose a security risk.

Found 1 instance in 1 package

Mixed license

License

(Experimental) Package contains multiple licenses.

Found 1 instance in 1 package

Improved metrics

Dependency count

0

decreased by-100%

Dev dependency count

7

decreased by-30%

Number of low license alerts

0

decreased by-100%

Number of lines in readme file

652

increased by8.67%

Number of low supply chain risk alerts

1

decreased by-91.67%

Worsened metrics

Total package byte prevSize

338091

decreased by-85.31%

Number of package files

48

decreased by-83.51%

Lines of code

6833

decreased by-81.56%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• - Removedlodash@^3.7.0

• - Removedlodash@3.10.1(transitive)