goodguide-gibbon 0.1.0 → 0.2.0

data/lib/goodguide/gibbon/version.rb

@@ -1,7 +1,7 @@
 module GoodGuide
   module Gibbon
     def self.version
-      '0.1.0'
+      '0.2.0'
     end
   end
 end

data/vendor/gibbon/lib/gibbon.browser.js

@@ -858,8 +858,7 @@ Gibbon.AST = AST = (function(_super) {
     flow: ['head', 'tail'],
     metadata: ['key', 'text'],
     definition: ['metadata', 'name', 'frame'],
-    frame: ['definitions', 'flow'],
-    program: ['definitions']
+    frame: ['definitions', 'flow']
   });
 
   inspectDefinitions = function(defs) {
@@ -956,9 +955,6 @@ Gibbon.AST = AST = (function(_super) {
         out.push(flow.inspect());
         out.push(")");
         return out.join('');
-      },
-      program: function(definitions) {
-        return inspectDefinitions(definitions);
       }
     });
   };
@@ -992,7 +988,7 @@ Gibbon.TypeAST = TypeAST = (function(_super) {
 })(Union);
 
 parse = Gibbon.parse = (function() {
-  var accessor, accessorExpr, arrow, arrowType, assertString, bang, blockExpr, blockType, comma, comment, component, concrete, decimal, decimalExpr, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullSignature, func, funcPlaceholder, identifier, ignore, integer, integerExpr, isString, label, labelVal, lbrace, lbrack, lexeme, listExpr, listType, lparen, metadata, name, nativeId, nativeType, nonPairedFlow, numericExpr, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, rbrace, rbrack, regex, rparen, signature, simpleType, singletonFlow, str, string, stringExpr, substExpr, succeed, tassign, type, typeVar, variable, whitespace, wildType, wildcard;
+  var accessor, accessorExpr, arrow, arrowType, assertString, bang, blockExpr, blockType, comma, comment, component, concrete, decimal, decimalExpr, define, definition, expr, fail, flow, fraction, fractionExpr, frame, freeFrame, fullSignature, func, funcPlaceholder, identifier, ignore, innerFrame, integer, integerExpr, isString, label, labelVal, lbrace, lbrack, lexeme, listExpr, listType, lparen, metadata, name, nativeId, nativeType, nonPairedFlow, numericExpr, pair, parenFlow, parenFrame, parenType, percent, percentExpr, program, rbrace, rbrack, regex, rparen, signature, simpleType, singletonFlow, str, string, stringExpr, substExpr, succeed, tassign, type, typeVar, variable, whitespace, wildType, wildcard;
   string = Parsimmon.string, regex = Parsimmon.regex, succeed = Parsimmon.succeed, fail = Parsimmon.fail;
   Parsimmon.Parser.prototype.expected = function(message) {
     var _this = this;
@@ -1114,23 +1110,22 @@ parse = Gibbon.parse = (function() {
   });
   definition = metadata.many().then(function(md) {
     return name.then(function(n) {
-      return define.expected().then(frame.expected()).map(function(fl) {
+      return define.then(innerFrame.expected()).map(function(fl) {
         return AST.definition(md, n, fl);
       });
     });
   });
-  parenFrame = lparen.then(definition.many()).then(function(defs) {
-    return flow.expected().skip(rparen.expected()).map(function(fl) {
+  frame = definition.many().then(function(defs) {
+    return flow.expected().map(function(fl) {
       return AST.frame(defs, fl);
     });
   });
+  parenFrame = lparen.then(frame).skip(rparen.expected());
   freeFrame = flow.map(function(fl) {
     return AST.frame([], fl);
   });
-  frame = parenFrame.or(freeFrame);
-  program = ignore.then(definition.many().map(function(defs) {
-    return AST.program(defs);
-  }));
+  innerFrame = parenFrame.or(freeFrame);
+  program = ignore.then(frame);
   tassign = lexeme(string('='));
   bang = lexeme(string('!'));
   nativeId = lexeme(regex(/^\w+/));
@@ -1763,20 +1758,22 @@ analyze = Gibbon.analyze = (function() {
 
     })();
     Scope = (function() {
-      Scope.global = function(context, definitions) {
-        return new Scope(null, [], definitions, context);
+      var makeKey;
+
+      Scope.global = function(context, frame) {
+        return new Scope(null, [], frame, context);
       };
 
-      function Scope(parent, breadcrumbs, definitions, context) {
+      function Scope(parent, breadcrumbs, frame, context) {
         this.parent = parent;
         this.breadcrumbs = breadcrumbs;
-        this.definitions = definitions;
+        this.frame = frame;
         this.context = context;
         this.bindings = new Hash;
       }
 
-      Scope.prototype.extend = function(name, definitions) {
-        return new Scope(this, this.breadcrumbs.concat([name]), definitions, this.context);
+      Scope.prototype.extend = function(name, frame) {
+        return new Scope(this, this.breadcrumbs.concat([name]), frame, this.context);
       };
 
       Scope.prototype.lookup = function(nativeId, name, cb) {
@@ -1811,31 +1808,33 @@ analyze = Gibbon.analyze = (function() {
         return TypeLookup.local(this.keyFor(name));
       };
 
+      makeKey = function(crumbs) {
+        return '/' + crumbs.join('/');
+      };
+
+      Scope.prototype.key = function() {
+        return makeKey(this.breadcrumbs);
+      };
+
       Scope.prototype.keyFor = function(name) {
-        return this.breadcrumbs.concat([name]).join('/');
+        return makeKey(this.breadcrumbs.concat([name]));
       };
 
-      Scope.prototype.analyzeDefinitions = function(push) {
-        var def, frameScope, global, _i, _len, _ref4, _results,
-          _this = this;
-        global = TypeExpr["native"](this.context.globalID);
-        _ref4 = this.definitions;
-        _results = [];
+      Scope.prototype.analyze = function(push) {
+        var def, frame, frameScope, global, key, _i, _len, _ref4;
+        _ref4 = this.frame.definitions;
         for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
           def = _ref4[_i];
-          this.bindings.set(def.name, def);
-          frameScope = this.extend(def.name, def.frame.definitions);
-          frameScope.analyzeDefinitions(push);
-          _results.push((function(def) {
-            var key, pusher;
-            key = _this.keyFor(def.name);
-            pusher = function(lhs, rhs) {
-              return push(key, def, [lhs, rhs]);
-            };
-            return frameScope.analyzeFlow(def.frame.flow, global, pusher);
-          })(def));
+          frameScope = this.extend(def.name, def.frame);
+          frameScope.analyze(push);
+          this.bindings.set(def.name, frameScope);
         }
-        return _results;
+        key = this.key();
+        global = TypeExpr["native"](this.context.globalID);
+        frame = this.frame;
+        return this.analyzeFlow(this.frame.flow, global, function(lhs, rhs) {
+          return push(key, frame, [lhs, rhs]);
+        });
       };
 
       Scope.prototype.analyzeFlow = function(flow, global, push) {
@@ -1919,13 +1918,13 @@ analyze = Gibbon.analyze = (function() {
     return function(globalID, externalLookup, program) {
       var constraintMap, context, scope;
       context = new NativeContext(globalID, externalLookup);
-      scope = Scope.global(context, program.definitions);
+      scope = Scope.global(context, program);
       constraintMap = new Hash;
-      scope.analyzeDefinitions(function(key, def, constraint) {
+      scope.analyze(function(key, frame, constraint) {
         var entry;
         entry = constraintMap.cache(key, function() {
           return {
-            definition: def,
+            frame: frame,
             constraints: []
           };
         });
@@ -1949,7 +1948,7 @@ analyze = Gibbon.analyze = (function() {
         infinite: ['type'],
         destructure: ['type'],
         access: ['type'],
-        circular: ['definition']
+        circular: ['crumbs']
       });
 
       return TypeError;
@@ -1974,21 +1973,24 @@ analyze = Gibbon.analyze = (function() {
       return loop_();
     };
     return function(constraintMap, finish) {
-      var definitionTypes, errors, semantics, solutions, solveEntry;
+      var errors, frameTypes, initialCrumbs, k, locks, semantics, solutions, solveEntry;
       errors = [];
       solutions = new CompMap(function(x, y) {
         return x.equals(y);
       });
       semantics = new Hash;
-      definitionTypes = new Hash;
-      solveEntry = function(key, solved) {
-        var constraints, definition, dependencies, done, error, fullSubstitute, lhs, rhs, semanticAccessors, simplify, substitute, _i, _len, _ref5, _ref6;
+      frameTypes = new Hash;
+      locks = new Hash;
+      solveEntry = function(crumbs, solved) {
+        var constraints, dependencies, done, error, frame, fullSubstitute, key, lhs, nextCrumbs, rhs, semanticAccessors, simplify, substitute, _i, _len, _ref5, _ref6;
+        key = crumbs[crumbs.length - 1];
         if (semantics.has(key)) {
           return solved();
         }
-        _ref5 = constraintMap.get(key), definition = _ref5.definition, constraints = _ref5.constraints;
-        console.log('locking', definition.inspect());
-        definition.lock = true;
+        nextCrumbs = crumbs.concat([key]);
+        _ref5 = constraintMap.get(key), frame = _ref5.frame, constraints = _ref5.constraints;
+        console.log('locking', key);
+        locks.set(key, true);
         semanticAccessors = new CompMap;
         dependencies = [];
         for (_i = 0, _len = constraints.length; _i < _len; _i++) {
@@ -2049,16 +2051,16 @@ analyze = Gibbon.analyze = (function() {
                           return cb(TypeExpr.fromAST(Gibbon.parse.unitType(response.type)));
                         },
                         local: function(key) {
-                          var localDef;
+                          var localFrame;
+                          nextCrumbs = crumbs.concat([key]);
                           semanticAccessors.set(accessor, Semantic.localAccessor(key));
-                          localDef = constraintMap.get(key).definition;
-                          if ('lock' in localDef) {
-                            return cb(error('circular', localDef));
-                          } else {
-                            return solveEntry(key, function() {
-                              return cb(definitionTypes.get(key));
-                            });
+                          if (locks.get(key)) {
+                            return cb(error('circular', nextCrumbs));
                           }
+                          localFrame = constraintMap.get(key).frame;
+                          return solveEntry(nextCrumbs, function() {
+                            return cb(frameTypes.get(key));
+                          });
                         }
                       });
                     });
@@ -2078,15 +2080,14 @@ analyze = Gibbon.analyze = (function() {
           var flowType, toSemanticTree;
           flowType = function(expr) {
             if (!solutions.has(TypeExpr.expr(expr))) {
-              solutions.get(TypeExpr.expr(expr));
               throw 'unsolved!';
             }
             return solutions.get(TypeExpr.expr(expr)).realize();
           };
           toSemanticTree = function(expr) {
             return expr.cases({
-              definition: function(name, metadata, frame) {
-                return Semantic.definition(dependencies, toSemanticTree(frame.flow));
+              frame: function(_, flow) {
+                return Semantic.definition(dependencies, toSemanticTree(flow));
               },
               flow: function(head, tail) {
                 return Semantic.flow(flowType(this), toSemanticTree(head), tail && toSemanticTree(tail));
@@ -2148,10 +2149,10 @@ analyze = Gibbon.analyze = (function() {
             return logConstraint('=> ', k, v);
           });
           console.log('setting key: ' + key);
-          semantics.set(key, toSemanticTree(definition));
-          definitionTypes.set(key, solutions.get(TypeExpr.expr(definition.frame.flow)));
-          console.log('unlocking', definition);
-          delete definition.lock;
+          semantics.set(key, toSemanticTree(frame));
+          frameTypes.set(key, solutions.get(TypeExpr.expr(frame.flow)));
+          console.log('unlocking', key);
+          locks.set(key, false);
           return solved();
         };
         return consume(constraints.reverse(), done, function(lhs, rhs, push, next) {
@@ -2252,7 +2253,18 @@ analyze = Gibbon.analyze = (function() {
           });
         });
       };
-      return contMap(constraintMap.keys(), solveEntry, function() {
+      initialCrumbs = (function() {
+        var _i, _len, _ref5, _results;
+        _ref5 = constraintMap.keys();
+        _results = [];
+        for (_i = 0, _len = _ref5.length; _i < _len; _i++) {
+          k = _ref5[_i];
+          _results.push([k]);
+        }
+        return _results;
+      })();
+      console.log('initial crumbs', initialCrumbs);
+      return contMap(initialCrumbs, solveEntry, function() {
         if (errors.length === 0) {
           errors = null;
         }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: goodguide-gibbon
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-03 00:00:00.000000000 Z
+date: 2013-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :runtime