goodguide-gibbon 0.12.3 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 123b573261502c31910bcbf24a9c1c7047fdaecb
-  data.tar.gz: 3f6b3987ed29cb47a30b5e6c3b55ffd20c68a073
+  metadata.gz: 94e167f036800da8152def1c3b2495b95f1781ef
+  data.tar.gz: 1746c2c2070bcf91c4e1df017c6f9cb9af7c4d94
 SHA512:
-  metadata.gz: 62c07def8c57478407aaed8e0ed4932553426cd9c73924434a8dff40cb19b6c78382186a510b197d2d137df41c7df8ade25849bd0a450d3dd5de095d17bb0452
-  data.tar.gz: b3024104e4b3e2bcd5cb627813cc0da2e2e2035091e4471cb5aef8ab404dda18c5c47d16feffbd97d184f1374bf3b34e1718a8e7042e55a6c18fc885973ef2fe
+  metadata.gz: 238529f54e900f1e87a17bec31246d3cbb0fba7b61340f69d66dfc932274e33f3368237f4444fc77dcf084f9885f5c05f310bf42c547236d00782c00b2f7f374
+  data.tar.gz: d2fcff687cbe7a9f6d2d0e81ceb44226d61c5d0950f92ae1743c7f8b74504c8a8b53e4fab75abd244a76630e55e2aabca45d0d6da054f1c86fedd8ba7a10a3e2

data/lib/goodguide/gibbon.rb

@@ -188,43 +188,26 @@ module GoodGuide
     class RuntimeError < GibbonError
     end
 
-    class MissingData < RuntimeError
-      attr_reader :query_type, :id, :annotations
-      attr_accessor :annotations
-      def initialize(type, id, annotations)
-        @query_type, @id, @annotations = type, id, annotations
-      end
-
-      def to_js(gibbon)
-        gibbon['Failure'].query(@id, @annotations)
-      end
+    class Runner < BasicObject
+      E = ::GoodGuide::Gibbon::RuntimeError
 
-      def as_json(*)
-        {
-          'status' => 'missing_data',
-          'query_type' => query_type,
-          'entity_id' => id,
-          'annotations' => annotations,
-        }
-      end
-    end
+      # expose Kernel::raise
+      define_method(:raise, &::Kernel.method(:raise))
 
-    class QueryError < RuntimeError
-      attr_reader :message
-      def initialize(message)
-        @message = message
-      end
+      attr_reader :source
+      def initialize(source)
+        @source = source
 
-      def to_js(gibbon)
-        gibbon['Failure'].message(@message)
+        (class << self; self; end).class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          private
+          def __compiled_run!(__client, __global)
+            #{source}
+          end
+        RUBY
       end
 
-      def as_json(*)
-        {
-          'status' => 'failure',
-          'message' => message,
-          'annotations' => annotations
-        }
+      def run!(client, global_id)
+        __compiled_run!(client, global_id)
       end
     end
 
@@ -240,46 +223,68 @@ module GoodGuide
 
         raise SemanticError.new(errors, context) if errors
 
-        compiled = context.compile(semantics)
+        ruby_code = context.compile_ruby(semantics)
 
         Program.new(
-          :syntax => syntax,
-          :compiled => compiled,
-          :context => context,
+          syntax: syntax,
+          semantics: semantics,
+          ruby: ruby_code
         )
       end
 
-      attr_reader :syntax, :compiled
-      def semantics
-        as_json['compiled']['semantics']
-      end
+      attr_reader :syntax, :semantics, :ruby_code
 
-      def initialize(info={})
+      def initialize(info)
         @syntax = info[:syntax] or raise 'please pass syntax'
-        @compiled = info[:compiled] or raise 'please pass a compiled program'
-        @context = info[:context] || Context.new
+        @semantics = info[:semantics] or raise 'please pass semantics'
+        @ruby_code = info[:ruby] or raise 'please pass ruby code'
       end
 
       def as_json
         @as_json ||= {
-          'syntax' => @context.send(:obj_to_ruby, @syntax),
-          'compiled' => {
-            'semantics' => @context.send(:obj_to_ruby, @compiled.semantics),
-            'blocks' => @context.send(:obj_to_ruby, @compiled.blocks)
-          }
+          'syntax' => @syntax,
+          'semantics' => @semantics,
+          'ruby' => @ruby_code,
         }
       end
 
-      def self.from_json(hash, context)
-        syntax = context.send(:obj_to_js, hash['syntax'])
-        semantics = context.send(:obj_to_js, hash['compiled']['semantics'])
-        blocks = context.send(:obj_to_js, hash['compiled']['blocks'])
-        compiled = context.gibbon[:CompiledCode].new(semantics, blocks)
-        new(syntax: syntax, compiled: compiled, context: context)
+      def self.from_json(hash)
+        new(
+          :syntax => hash['syntax'],
+          :semantics => hash['semantics'],
+          :ruby => hash['ruby'],
+        )
+      end
+
+      def runner
+        @runner ||= Runner.new(ruby_code)
       end
 
       def call(runtime_client, entity_id)
-        @context.run_compiled(@compiled, entity_id, runtime_client.to_js(@context.gibbon))
+        deps, results = runtime_client.with_dependencies do
+          runner.run!(runtime_client, entity_id)
+        end
+
+        out = {}
+        results.each do |key, result|
+          out[key] = { 'dependencies' => deps[key] || [] }
+
+          case result[:status]
+          when :success
+            out[key].merge! 'status' => 'success', 'value' => result[:value]
+          when :failure
+            out[key].merge! 'status' => 'failure'
+          end
+        end
+
+        out
+      end
+
+    private
+      def stringify_keys(hash)
+        out = {}
+        hash.each { |k, v| out[k.to_s] = v }
+        out
       end
     end
 
@@ -350,23 +355,100 @@ module GoodGuide
       end
     end
 
+    class Dependency
+      class Missing < Dependency
+        attr_reader :query_type, :id, :annotations
+        def initialize(query_type, id, annotations)
+          @query_type, @id, @annotations = query_type, id, annotations
+        end
+
+        def as_json
+          {
+            '_tag' => 'missing',
+            'query_type' => query_type,
+            'id' => id,
+            'annotations' => annotations
+          }
+        end
+      end
+
+      class Query < Dependency
+        attr_reader :query_type, :annotations, :type, :id, :value
+        def initialize(info={})
+          @query_type = info.fetch(:query_type) { raise "no query type" }
+          @annotations = info.fetch(:annotations) { raise "no annotations" }
+          @type = info.fetch(:type) { raise "no type" }
+          @id = info.fetch(:id) { raise "no id" }
+          @value = info.fetch(:value) { raise "no value" }
+        end
+
+        def as_json
+          {
+            '_tag' => 'query',
+            'query_type' => query_type,
+            'annotations' => annotations,
+            'type' => type,
+            'id' => id,
+            'value' => value
+          }
+        end
+      end
+
+      class Local < Dependency
+        attr_reader :key
+        def initialize(key)
+          @key = key
+        end
+
+        def as_json
+          { '_tag' => 'local', 'key' => key }
+        end
+      end
+    end
+
     class RuntimeClient < AbstractClient
       include Util
-      def perform_query(id, annotations)
-        annotations = obj_to_ruby(annotations)
+      def query!(current_key, annotations, type, id)
         query_type = annotations.delete('_query_type')
 
         # stash this data in case missing_data! is called
+        @last_key = current_key
         @last_query_type = query_type
         @last_annotations = annotations
         @last_id = id
 
         query = get_query(query_type) or raise "invalid query type in compiled code: #{query_type.inspect} with annotations #{annotations.inspect}"
-        instance_exec(id, annotations, &query)
+        value = instance_exec(id, annotations, &query)
+
+        add_dependency! current_key, Dependency::Query.new(
+          query_type: query_type,
+          annotations: annotations,
+          type: type,
+          id: id,
+          value: value
+        )
+
+        value
+      end
+
+      def with_dependencies(&b)
+        @dependencies = {}
+        value = yield
+        [@dependencies, value]
       end
 
       def missing_data!
-        raise MissingData.new(@last_query_type, @last_id, @last_annotations)
+        add_dependency! @last_key, Dependency::Missing.new(@last_query_type, @last_id, @last_annotations)
+
+        raise RuntimeError
+      end
+
+      def local_dependency!(current_key, dependence_key)
+        add_dependency! current_key, Dependency::Local.new(dependence_key)
+      end
+
+      def add_dependency!(key, dep)
+        (@dependencies[key] ||= []) << dep
       end
 
       def to_js(gibbon)
@@ -403,20 +485,18 @@ module GoodGuide
         gibbon.compile(obj_to_js(semantics))
       end
 
+      def compile_ruby(semantics)
+        obj_to_ruby(gibbon.compileRuby(obj_to_js(semantics)))
+      end
+
       def analyze(syntax, global_table, static_client)
         syntax = obj_to_js(syntax)
 
-        capture do |&callback|
+        out = capture do |&callback|
           gibbon.analyze(syntax, global_table, static_client, callback)
         end
-      end
-
-      def run_compiled(compiled, entity_id, runtime_client)
-        results, _ = capture do |&callback|
-          compiled.run(entity_id, runtime_client, callback)
-        end
 
-        obj_to_ruby(results)
+        obj_to_ruby(out)
       end
 
     private

data/vendor/gibbon/gibbon.browser.dev.js

@@ -469,7 +469,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   return Parsimmon;
 })()
 // Generated by CoffeeScript 1.6.3
-var AST, CompiledCode, Core, DEBUG, Dependency, Failure, Gibbon, Hash, JS, List, Map, ObjHash, RVal, Result, Semantic, Step, Thunk, Trace, Type, TypeAST, TypeExpr, TypeLookup, Value, VarTrace, Variant, analyze, applyOp1, applyOp2, asyncMap, contIter, contMap, equalArrays, eval_, inspectNative, isArray, nameGen, parse, stdlib, uniq, _ref, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
+var AST, CompiledCode, Core, DEBUG, Dependency, Failure, Gibbon, Hash, JS, List, Map, ObjHash, RVal, Result, Ruby, Semantic, Step, Thunk, Trace, Type, TypeAST, TypeExpr, TypeLookup, Value, VarTrace, Variant, analyze, applyOp1, applyOp2, asyncMap, contIter, contMap, equalArrays, eval_, inspectNative, isArray, nameGen, parse, stdlib, uniq, _ref, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref19, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
   __slice = [].slice,
   __hasProp = {}.hasOwnProperty,
   __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
@@ -6529,6 +6529,469 @@ Gibbon.compile = function(semantics) {
   return new CompiledCode(semantics, compiled);
 };
 
+Ruby = (function(_super) {
+  var inspectLiteral;
+
+  __extends(Ruby, _super);
+
+  function Ruby() {
+    _ref19 = Ruby.__super__.constructor.apply(this, arguments);
+    return _ref19;
+  }
+
+  Ruby.variants({
+    branch: ['cond', 'ifTrue', 'ifFalse'],
+    guard: ['cond', 'expr'],
+    rescue: ['expr', 'default'],
+    ident: ['name'],
+    brackets: ['expr', 'arg'],
+    array: ['elements'],
+    group: ['statements'],
+    op1: ['op', 'arg'],
+    op2: ['op', 'lhs', 'rhs'],
+    assign: ['lval', 'rval'],
+    paren: ['elements'],
+    literal: ['value'],
+    symbol: ['name'],
+    mcall: ['target', 'name', 'args', 'blockArgs', 'block']
+  });
+
+  Ruby.raise = function(args) {
+    return this.mcall(null, 'raise', args, [], null);
+  };
+
+  Ruby.breakUnless = function(cond) {
+    return cond.op2('||', this.ident('break'));
+  };
+
+  Ruby.prototype.branch = function(t, f) {
+    return Ruby.branch(this, t, f);
+  };
+
+  Ruby.prototype.rescue = function(d) {
+    return Ruby.rescue(this, d);
+  };
+
+  Ruby.prototype.bracket = function(a) {
+    return Ruby.brackets(this, a);
+  };
+
+  Ruby.prototype.op1 = function(o) {
+    return Ruby.op1(o, this);
+  };
+
+  Ruby.prototype.op2 = function(o, e) {
+    return Ruby.op2(o, this, e);
+  };
+
+  Ruby.prototype.assign = function(rval) {
+    return Ruby.assign(this, rval);
+  };
+
+  Ruby.prototype.mcall = function(name, args, blockArgs, block) {
+    if (args == null) {
+      args = [];
+    }
+    if (blockArgs == null) {
+      blockArgs = [];
+    }
+    if (block == null) {
+      block = null;
+    }
+    return Ruby.mcall(this, name, args, blockArgs, block);
+  };
+
+  Ruby.prototype.guard = function(expr) {
+    return Ruby.branch(this, expr, null);
+  };
+
+  inspectLiteral = function(o) {
+    var e, k, v;
+    if (isArray(o)) {
+      return '[' + ((function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = o.length; _i < _len; _i++) {
+          e = o[_i];
+          _results.push(inspectLiteral(e));
+        }
+        return _results;
+      })()) + ']';
+    }
+    switch (typeof o) {
+      case 'string':
+        return "'" + o.replace("'", "\\\\'") + "'";
+      case 'boolean':
+        return "" + o;
+      case 'number':
+        if (isNaN(o)) {
+          throw "literal NaN not supported!";
+        }
+        if (o === Infinity) {
+          return '(1.0/0)';
+        } else if (o === -Infinity) {
+          return '(-1.0/0)';
+        } else {
+          return "" + o;
+        }
+        break;
+      case 'object':
+        return '{' + ((function() {
+          var _results;
+          _results = [];
+          for (k in o) {
+            if (!__hasProp.call(o, k)) continue;
+            v = o[k];
+            _results.push(inspectLiteral(k) + '=>' + inspectLiteral(v));
+          }
+          return _results;
+        })()).join(',') + '}';
+      default:
+        throw new Error("unknown literal " + o);
+    }
+  };
+
+  Ruby.prototype.toRuby = function() {
+    return this.cases({
+      rescue: function(e, d) {
+        return "begin;" + (e.toRuby()) + ";rescue E;" + (d.toRuby()) + ";end";
+      },
+      ident: function(name) {
+        return name;
+      },
+      brackets: function(expr, arg) {
+        return "" + (expr.toRuby()) + "[" + (arg.toRuby()) + "]";
+      },
+      array: function(elements) {
+        var e;
+        return "[" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(e.toRuby());
+          }
+          return _results;
+        })()).join(',')) + "]";
+      },
+      group: function(statements) {
+        var s;
+        return "(" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = statements.length; _i < _len; _i++) {
+            s = statements[_i];
+            _results.push(s.toRuby());
+          }
+          return _results;
+        })()).join(';')) + ")";
+      },
+      op1: function(op, arg) {
+        return "(" + op + " " + (arg.toRuby()) + ")";
+      },
+      op2: function(op, lhs, rhs) {
+        return "(" + (lhs.toRuby()) + " " + op + " " + (rhs.toRuby()) + ")";
+      },
+      assign: function(lval, rval) {
+        return "(" + (lval.toRuby()) + "=" + (rval.toRuby()) + ")";
+      },
+      paren: function(elements) {
+        var e;
+        return "(" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(e.toRuby());
+          }
+          return _results;
+        })()).join(',')) + ")";
+      },
+      literal: function(value) {
+        return inspectLiteral(value);
+      },
+      symbol: function(name) {
+        return ":" + name;
+      },
+      branch: function(cond, ifTrue, ifFalse) {
+        if (ifFalse != null) {
+          return "if " + (cond.toRuby()) + " then " + (ifTrue.toRuby()) + " else " + (ifFalse.toRuby()) + " end";
+        } else {
+          return "if " + (cond.toRuby()) + " then " + (ifTrue.toRuby()) + " end";
+        }
+      },
+      mcall: function(target, name, args, blockArgs, block) {
+        var a, l, out;
+        out = [];
+        if (target != null) {
+          out.push("" + (target.toRuby()) + ".");
+        }
+        out.push(name);
+        if (args.length) {
+          out.push("(" + (((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = args.length; _i < _len; _i++) {
+              a = args[_i];
+              _results.push(a.toRuby());
+            }
+            return _results;
+          })()).join(',')) + ")");
+        }
+        if (block) {
+          out.push('{');
+        }
+        if (blockArgs.length) {
+          out.push("|" + (((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = blockArgs.length; _i < _len; _i++) {
+              a = blockArgs[_i];
+              _results.push(a.toRuby());
+            }
+            return _results;
+          })()).join(',')) + "|");
+        }
+        if (block) {
+          out.push(((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = block.length; _i < _len; _i++) {
+              l = block[_i];
+              _results.push(l.toRuby());
+            }
+            return _results;
+          })()).join(';'));
+        }
+        if (block) {
+          out.push('}');
+        }
+        return out.join('');
+      }
+    });
+  };
+
+  return Ruby;
+
+})(Variant);
+
+Gibbon.compileRuby = (function() {
+  var compileCore, id, idForLocal, lit, nextSym, nil;
+  id = Ruby.ident;
+  lit = Ruby.literal;
+  nextSym = Ruby.symbol('next');
+  nil = id('nil');
+  idForLocal = function(key) {
+    return '_local' + key.length + key.replace(/\//g, '_slash_').replace(/-/g, '_dash_');
+  };
+  compileCore = function(core, nextVar, currentKey) {
+    var localOrElse, r;
+    if (nextVar == null) {
+      nextVar = null;
+    }
+    if (currentKey == null) {
+      currentKey = '/';
+    }
+    r = function(c, n, k) {
+      if (n == null) {
+        n = nextVar;
+      }
+      if (k == null) {
+        k = currentKey;
+      }
+      return compileCore(c, n, k);
+    };
+    localOrElse = function(key, errorCase, nonErrorFn) {
+      var localId;
+      localId = id(idForLocal(key));
+      if (errorCase === void 0) {
+        errorCase = Ruby.raise([localId.bracket(Ruby.symbol('error'))]);
+      }
+      nonErrorFn || (nonErrorFn = function(val) {
+        return val;
+      });
+      return Ruby.group([id('__client').mcall('local_dependency!', [lit(currentKey), lit(key)]), localId.bracket(Ruby.symbol('status')).op2('==', Ruby.symbol('success')).branch(nonErrorFn(localId.bracket(Ruby.symbol('value'))), errorCase)]);
+    };
+    return core.cases({
+      global: function() {
+        return id('__global');
+      },
+      constant: function(value) {
+        return lit(value);
+      },
+      variable: function(name) {
+        if (nextVar === name) {
+          return nextSym;
+        } else {
+          return id(name);
+        }
+      },
+      branch: function(cond, t, f) {
+        return r(cond).branch(r(t), r(f));
+      },
+      delist: function(expr, index) {
+        return r(expr).bracket(r(index));
+      },
+      depair: function(expr, index) {
+        index = index === 'first' ? 0 : 1;
+        return r(expr).bracket(lit(index));
+      },
+      pair: function(first, second) {
+        return Ruby.array([r(first), r(second)]);
+      },
+      list: function(elements) {
+        var e;
+        return Ruby.array((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(r(e));
+          }
+          return _results;
+        })());
+      },
+      foldList: function(list, out, arg, accumArg, idxArg, body) {
+        var iterArgs, iterBody, reversed;
+        if (body.containsInNonTailPosition(Core.variable(accumArg))) {
+          reversed = r(list).mcall('each_with_index').mcall('to_a').mcall('reverse');
+          iterArgs = [id(accumArg), Ruby.paren([id(arg), id(idxArg)])];
+          iterBody = [r(body)];
+          return reversed.mcall('inject', [r(out)], iterArgs, iterBody);
+        } else {
+          body = [id(accumArg).assign(r(body, accumArg)), Ruby.breakUnless(id(accumArg).op2('==', nextSym))];
+          return Ruby.group([id(accumArg).assign(nextSym), r(list).mcall('each_with_index', [], [id(arg), id(idxArg)], body), id(accumArg).op2('==', nextSym).branch(r(out), id(accumArg))]);
+        }
+      },
+      mapList: function(list, arg, idxArg, body) {
+        var blockArgs, target, _ref20;
+        _ref20 = body.contains(Core.variable(idxArg)) ? [r(list).mcall('each_with_index'), [id(arg), id(idxArg)]] : [r(list), [id(arg)]], target = _ref20[0], blockArgs = _ref20[1];
+        return target.mcall('map', [], blockArgs, [r(body)]);
+      },
+      filterList: function(list, arg, body) {
+        return r(list).mcall('select', [], [id(arg)], [r(body)]);
+      },
+      squishList: function(list) {
+        return list.cases({
+          list: function(elements) {
+            var e, out, statements, yielder, _i, _len;
+            yielder = id(nameGen('y'));
+            out = id(nameGen('out'));
+            statements = [];
+            statements.push(out.assign(Ruby.array([])));
+            for (_i = 0, _len = elements.length; _i < _len; _i++) {
+              e = elements[_i];
+              if (e.alwaysSucceeds()) {
+                statements.push(out.mcall('push', [r(e)]));
+              } else {
+                statements.push(e.cases({
+                  localQuery: function(key) {
+                    return localOrElse(key, null, function(value) {
+                      return out.mcall('push', [value]);
+                    });
+                  },
+                  other: function() {
+                    return out.mcall('push', [r(e)]).rescue(nil);
+                  }
+                }));
+              }
+            }
+            statements.push(out);
+            return Ruby.group(statements);
+          },
+          other: function() {
+            throw "can't squish a non-list node";
+          }
+        });
+      },
+      zipLists: function(first, second) {
+        return r(first).mcall('zip', [r(second)]);
+      },
+      len: function(list) {
+        return r(list).mcall('size');
+      },
+      block: function(name, body) {
+        return Ruby.mcall(null, 'lambda', [], [id(name)], [r(body)]);
+      },
+      app: function(block, arg) {
+        return r(block).mcall('call', r(arg));
+      },
+      query: function(expr, annotations) {
+        var type, _ref20;
+        _ref20 = annotations, annotations = _ref20.annotations, type = _ref20.type;
+        return id('__client').mcall('query!', [lit(currentKey), lit(annotations), lit(type), r(expr)]);
+      },
+      localQuery: function(key) {
+        return localOrElse(key);
+      },
+      fail: function(message) {
+        return Ruby.raise([id('E'), lit(message)]);
+      },
+      rescue: function(expr, def) {
+        return expr.cases({
+          local: function(key) {
+            return localOrElse(key, r(def));
+          },
+          other: function() {
+            return r(expr).rescue(r(def));
+          }
+        });
+      },
+      op1: function(o, expr) {
+        return r(expr).op1(o);
+      },
+      op2: function(o, lhs, rhs) {
+        if (o === '===') {
+          o = '==';
+        }
+        return r(lhs).op2(o, r(rhs));
+      },
+      bind: function(name, value, expr) {
+        return Ruby.group([id(name).assign(r(value)), r(expr)]);
+      }
+    });
+  };
+  return function(semantics) {
+    var key, keys, optimize, out, processKey, seen, translate, _i, _len;
+    optimize = Gibbon.optimize, translate = Gibbon.translate;
+    keys = semantics.keys();
+    seen = new Hash;
+    out = [];
+    processKey = function(key) {
+      var compiledRuby, dep, _i, _len, _ref20;
+      if (seen.has(key)) {
+        return;
+      }
+      seen.set(key, true);
+      _ref20 = semantics.get(key).dependencies;
+      for (_i = 0, _len = _ref20.length; _i < _len; _i++) {
+        dep = _ref20[_i];
+        if (dep._tag === 'local') {
+          processKey(dep.name);
+        }
+      }
+      compiledRuby = compileCore(optimize(translate(semantics.get(key))), null, key).toRuby();
+      return out.push("" + (idForLocal(key)) + " = begin\n  {:status=>:success,:value=>(" + compiledRuby + ")}\nrescue E => e\n  {:status=>:failure,:error=>e}\nend");
+    };
+    for (_i = 0, _len = keys.length; _i < _len; _i++) {
+      key = keys[_i];
+      processKey(key);
+    }
+    out.push('{');
+    out.push(((function() {
+      var _j, _len1, _results;
+      _results = [];
+      for (_j = 0, _len1 = keys.length; _j < _len1; _j++) {
+        key = keys[_j];
+        _results.push("" + (lit(key).toRuby()) + " => " + (idForLocal(key)));
+      }
+      return _results;
+    })()).join(','));
+    out.push('}');
+    return out.join("\n");
+  };
+})();
+
 Gibbon.jsonConsumer = (function() {
   return function(tables) {
     var analyzeList, getType, getValue, listLookup, lists;

data/vendor/gibbon/gibbon.browser.js

@@ -469,7 +469,7 @@ Parsimmon.Parser = P(function(_, _super, Parser) {
   return Parsimmon;
 })()
 // Generated by CoffeeScript 1.6.3
-var AST, CompiledCode, Core, DEBUG, Dependency, Failure, Gibbon, Hash, JS, List, Map, ObjHash, RVal, Result, Semantic, Step, Thunk, Trace, Type, TypeAST, TypeExpr, TypeLookup, Value, VarTrace, Variant, analyze, applyOp1, applyOp2, asyncMap, contIter, contMap, equalArrays, eval_, inspectNative, isArray, nameGen, parse, stdlib, uniq, _ref, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
+var AST, CompiledCode, Core, DEBUG, Dependency, Failure, Gibbon, Hash, JS, List, Map, ObjHash, RVal, Result, Ruby, Semantic, Step, Thunk, Trace, Type, TypeAST, TypeExpr, TypeLookup, Value, VarTrace, Variant, analyze, applyOp1, applyOp2, asyncMap, contIter, contMap, equalArrays, eval_, inspectNative, isArray, nameGen, parse, stdlib, uniq, _ref, _ref1, _ref10, _ref11, _ref12, _ref13, _ref14, _ref15, _ref16, _ref17, _ref18, _ref19, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7, _ref8, _ref9,
   __slice = [].slice,
   __hasProp = {}.hasOwnProperty,
   __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
@@ -6466,6 +6466,469 @@ Gibbon.compile = function(semantics) {
   return new CompiledCode(semantics, compiled);
 };
 
+Ruby = (function(_super) {
+  var inspectLiteral;
+
+  __extends(Ruby, _super);
+
+  function Ruby() {
+    _ref19 = Ruby.__super__.constructor.apply(this, arguments);
+    return _ref19;
+  }
+
+  Ruby.variants({
+    branch: ['cond', 'ifTrue', 'ifFalse'],
+    guard: ['cond', 'expr'],
+    rescue: ['expr', 'default'],
+    ident: ['name'],
+    brackets: ['expr', 'arg'],
+    array: ['elements'],
+    group: ['statements'],
+    op1: ['op', 'arg'],
+    op2: ['op', 'lhs', 'rhs'],
+    assign: ['lval', 'rval'],
+    paren: ['elements'],
+    literal: ['value'],
+    symbol: ['name'],
+    mcall: ['target', 'name', 'args', 'blockArgs', 'block']
+  });
+
+  Ruby.raise = function(args) {
+    return this.mcall(null, 'raise', args, [], null);
+  };
+
+  Ruby.breakUnless = function(cond) {
+    return cond.op2('||', this.ident('break'));
+  };
+
+  Ruby.prototype.branch = function(t, f) {
+    return Ruby.branch(this, t, f);
+  };
+
+  Ruby.prototype.rescue = function(d) {
+    return Ruby.rescue(this, d);
+  };
+
+  Ruby.prototype.bracket = function(a) {
+    return Ruby.brackets(this, a);
+  };
+
+  Ruby.prototype.op1 = function(o) {
+    return Ruby.op1(o, this);
+  };
+
+  Ruby.prototype.op2 = function(o, e) {
+    return Ruby.op2(o, this, e);
+  };
+
+  Ruby.prototype.assign = function(rval) {
+    return Ruby.assign(this, rval);
+  };
+
+  Ruby.prototype.mcall = function(name, args, blockArgs, block) {
+    if (args == null) {
+      args = [];
+    }
+    if (blockArgs == null) {
+      blockArgs = [];
+    }
+    if (block == null) {
+      block = null;
+    }
+    return Ruby.mcall(this, name, args, blockArgs, block);
+  };
+
+  Ruby.prototype.guard = function(expr) {
+    return Ruby.branch(this, expr, null);
+  };
+
+  inspectLiteral = function(o) {
+    var e, k, v;
+    if (isArray(o)) {
+      return '[' + ((function() {
+        var _i, _len, _results;
+        _results = [];
+        for (_i = 0, _len = o.length; _i < _len; _i++) {
+          e = o[_i];
+          _results.push(inspectLiteral(e));
+        }
+        return _results;
+      })()) + ']';
+    }
+    switch (typeof o) {
+      case 'string':
+        return "'" + o.replace("'", "\\\\'") + "'";
+      case 'boolean':
+        return "" + o;
+      case 'number':
+        if (isNaN(o)) {
+          throw "literal NaN not supported!";
+        }
+        if (o === Infinity) {
+          return '(1.0/0)';
+        } else if (o === -Infinity) {
+          return '(-1.0/0)';
+        } else {
+          return "" + o;
+        }
+        break;
+      case 'object':
+        return '{' + ((function() {
+          var _results;
+          _results = [];
+          for (k in o) {
+            if (!__hasProp.call(o, k)) continue;
+            v = o[k];
+            _results.push(inspectLiteral(k) + '=>' + inspectLiteral(v));
+          }
+          return _results;
+        })()).join(',') + '}';
+      default:
+        throw new Error("unknown literal " + o);
+    }
+  };
+
+  Ruby.prototype.toRuby = function() {
+    return this.cases({
+      rescue: function(e, d) {
+        return "begin;" + (e.toRuby()) + ";rescue E;" + (d.toRuby()) + ";end";
+      },
+      ident: function(name) {
+        return name;
+      },
+      brackets: function(expr, arg) {
+        return "" + (expr.toRuby()) + "[" + (arg.toRuby()) + "]";
+      },
+      array: function(elements) {
+        var e;
+        return "[" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(e.toRuby());
+          }
+          return _results;
+        })()).join(',')) + "]";
+      },
+      group: function(statements) {
+        var s;
+        return "(" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = statements.length; _i < _len; _i++) {
+            s = statements[_i];
+            _results.push(s.toRuby());
+          }
+          return _results;
+        })()).join(';')) + ")";
+      },
+      op1: function(op, arg) {
+        return "(" + op + " " + (arg.toRuby()) + ")";
+      },
+      op2: function(op, lhs, rhs) {
+        return "(" + (lhs.toRuby()) + " " + op + " " + (rhs.toRuby()) + ")";
+      },
+      assign: function(lval, rval) {
+        return "(" + (lval.toRuby()) + "=" + (rval.toRuby()) + ")";
+      },
+      paren: function(elements) {
+        var e;
+        return "(" + (((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(e.toRuby());
+          }
+          return _results;
+        })()).join(',')) + ")";
+      },
+      literal: function(value) {
+        return inspectLiteral(value);
+      },
+      symbol: function(name) {
+        return ":" + name;
+      },
+      branch: function(cond, ifTrue, ifFalse) {
+        if (ifFalse != null) {
+          return "if " + (cond.toRuby()) + " then " + (ifTrue.toRuby()) + " else " + (ifFalse.toRuby()) + " end";
+        } else {
+          return "if " + (cond.toRuby()) + " then " + (ifTrue.toRuby()) + " end";
+        }
+      },
+      mcall: function(target, name, args, blockArgs, block) {
+        var a, l, out;
+        out = [];
+        if (target != null) {
+          out.push("" + (target.toRuby()) + ".");
+        }
+        out.push(name);
+        if (args.length) {
+          out.push("(" + (((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = args.length; _i < _len; _i++) {
+              a = args[_i];
+              _results.push(a.toRuby());
+            }
+            return _results;
+          })()).join(',')) + ")");
+        }
+        if (block) {
+          out.push('{');
+        }
+        if (blockArgs.length) {
+          out.push("|" + (((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = blockArgs.length; _i < _len; _i++) {
+              a = blockArgs[_i];
+              _results.push(a.toRuby());
+            }
+            return _results;
+          })()).join(',')) + "|");
+        }
+        if (block) {
+          out.push(((function() {
+            var _i, _len, _results;
+            _results = [];
+            for (_i = 0, _len = block.length; _i < _len; _i++) {
+              l = block[_i];
+              _results.push(l.toRuby());
+            }
+            return _results;
+          })()).join(';'));
+        }
+        if (block) {
+          out.push('}');
+        }
+        return out.join('');
+      }
+    });
+  };
+
+  return Ruby;
+
+})(Variant);
+
+Gibbon.compileRuby = (function() {
+  var compileCore, id, idForLocal, lit, nextSym, nil;
+  id = Ruby.ident;
+  lit = Ruby.literal;
+  nextSym = Ruby.symbol('next');
+  nil = id('nil');
+  idForLocal = function(key) {
+    return '_local' + key.length + key.replace(/\//g, '_slash_').replace(/-/g, '_dash_');
+  };
+  compileCore = function(core, nextVar, currentKey) {
+    var localOrElse, r;
+    if (nextVar == null) {
+      nextVar = null;
+    }
+    if (currentKey == null) {
+      currentKey = '/';
+    }
+    r = function(c, n, k) {
+      if (n == null) {
+        n = nextVar;
+      }
+      if (k == null) {
+        k = currentKey;
+      }
+      return compileCore(c, n, k);
+    };
+    localOrElse = function(key, errorCase, nonErrorFn) {
+      var localId;
+      localId = id(idForLocal(key));
+      if (errorCase === void 0) {
+        errorCase = Ruby.raise([localId.bracket(Ruby.symbol('error'))]);
+      }
+      nonErrorFn || (nonErrorFn = function(val) {
+        return val;
+      });
+      return Ruby.group([id('__client').mcall('local_dependency!', [lit(currentKey), lit(key)]), localId.bracket(Ruby.symbol('status')).op2('==', Ruby.symbol('success')).branch(nonErrorFn(localId.bracket(Ruby.symbol('value'))), errorCase)]);
+    };
+    return core.cases({
+      global: function() {
+        return id('__global');
+      },
+      constant: function(value) {
+        return lit(value);
+      },
+      variable: function(name) {
+        if (nextVar === name) {
+          return nextSym;
+        } else {
+          return id(name);
+        }
+      },
+      branch: function(cond, t, f) {
+        return r(cond).branch(r(t), r(f));
+      },
+      delist: function(expr, index) {
+        return r(expr).bracket(r(index));
+      },
+      depair: function(expr, index) {
+        index = index === 'first' ? 0 : 1;
+        return r(expr).bracket(lit(index));
+      },
+      pair: function(first, second) {
+        return Ruby.array([r(first), r(second)]);
+      },
+      list: function(elements) {
+        var e;
+        return Ruby.array((function() {
+          var _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = elements.length; _i < _len; _i++) {
+            e = elements[_i];
+            _results.push(r(e));
+          }
+          return _results;
+        })());
+      },
+      foldList: function(list, out, arg, accumArg, idxArg, body) {
+        var iterArgs, iterBody, reversed;
+        if (body.containsInNonTailPosition(Core.variable(accumArg))) {
+          reversed = r(list).mcall('each_with_index').mcall('to_a').mcall('reverse');
+          iterArgs = [id(accumArg), Ruby.paren([id(arg), id(idxArg)])];
+          iterBody = [r(body)];
+          return reversed.mcall('inject', [r(out)], iterArgs, iterBody);
+        } else {
+          body = [id(accumArg).assign(r(body, accumArg)), Ruby.breakUnless(id(accumArg).op2('==', nextSym))];
+          return Ruby.group([id(accumArg).assign(nextSym), r(list).mcall('each_with_index', [], [id(arg), id(idxArg)], body), id(accumArg).op2('==', nextSym).branch(r(out), id(accumArg))]);
+        }
+      },
+      mapList: function(list, arg, idxArg, body) {
+        var blockArgs, target, _ref20;
+        _ref20 = body.contains(Core.variable(idxArg)) ? [r(list).mcall('each_with_index'), [id(arg), id(idxArg)]] : [r(list), [id(arg)]], target = _ref20[0], blockArgs = _ref20[1];
+        return target.mcall('map', [], blockArgs, [r(body)]);
+      },
+      filterList: function(list, arg, body) {
+        return r(list).mcall('select', [], [id(arg)], [r(body)]);
+      },
+      squishList: function(list) {
+        return list.cases({
+          list: function(elements) {
+            var e, out, statements, yielder, _i, _len;
+            yielder = id(nameGen('y'));
+            out = id(nameGen('out'));
+            statements = [];
+            statements.push(out.assign(Ruby.array([])));
+            for (_i = 0, _len = elements.length; _i < _len; _i++) {
+              e = elements[_i];
+              if (e.alwaysSucceeds()) {
+                statements.push(out.mcall('push', [r(e)]));
+              } else {
+                statements.push(e.cases({
+                  localQuery: function(key) {
+                    return localOrElse(key, null, function(value) {
+                      return out.mcall('push', [value]);
+                    });
+                  },
+                  other: function() {
+                    return out.mcall('push', [r(e)]).rescue(nil);
+                  }
+                }));
+              }
+            }
+            statements.push(out);
+            return Ruby.group(statements);
+          },
+          other: function() {
+            throw "can't squish a non-list node";
+          }
+        });
+      },
+      zipLists: function(first, second) {
+        return r(first).mcall('zip', [r(second)]);
+      },
+      len: function(list) {
+        return r(list).mcall('size');
+      },
+      block: function(name, body) {
+        return Ruby.mcall(null, 'lambda', [], [id(name)], [r(body)]);
+      },
+      app: function(block, arg) {
+        return r(block).mcall('call', r(arg));
+      },
+      query: function(expr, annotations) {
+        var type, _ref20;
+        _ref20 = annotations, annotations = _ref20.annotations, type = _ref20.type;
+        return id('__client').mcall('query!', [lit(currentKey), lit(annotations), lit(type), r(expr)]);
+      },
+      localQuery: function(key) {
+        return localOrElse(key);
+      },
+      fail: function(message) {
+        return Ruby.raise([id('E'), lit(message)]);
+      },
+      rescue: function(expr, def) {
+        return expr.cases({
+          local: function(key) {
+            return localOrElse(key, r(def));
+          },
+          other: function() {
+            return r(expr).rescue(r(def));
+          }
+        });
+      },
+      op1: function(o, expr) {
+        return r(expr).op1(o);
+      },
+      op2: function(o, lhs, rhs) {
+        if (o === '===') {
+          o = '==';
+        }
+        return r(lhs).op2(o, r(rhs));
+      },
+      bind: function(name, value, expr) {
+        return Ruby.group([id(name).assign(r(value)), r(expr)]);
+      }
+    });
+  };
+  return function(semantics) {
+    var key, keys, optimize, out, processKey, seen, translate, _i, _len;
+    optimize = Gibbon.optimize, translate = Gibbon.translate;
+    keys = semantics.keys();
+    seen = new Hash;
+    out = [];
+    processKey = function(key) {
+      var compiledRuby, dep, _i, _len, _ref20;
+      if (seen.has(key)) {
+        return;
+      }
+      seen.set(key, true);
+      _ref20 = semantics.get(key).dependencies;
+      for (_i = 0, _len = _ref20.length; _i < _len; _i++) {
+        dep = _ref20[_i];
+        if (dep._tag === 'local') {
+          processKey(dep.name);
+        }
+      }
+      compiledRuby = compileCore(optimize(translate(semantics.get(key))), null, key).toRuby();
+      return out.push("" + (idForLocal(key)) + " = begin\n  {:status=>:success,:value=>(" + compiledRuby + ")}\nrescue E => e\n  {:status=>:failure,:error=>e}\nend");
+    };
+    for (_i = 0, _len = keys.length; _i < _len; _i++) {
+      key = keys[_i];
+      processKey(key);
+    }
+    out.push('{');
+    out.push(((function() {
+      var _j, _len1, _results;
+      _results = [];
+      for (_j = 0, _len1 = keys.length; _j < _len1; _j++) {
+        key = keys[_j];
+        _results.push("" + (lit(key).toRuby()) + " => " + (idForLocal(key)));
+      }
+      return _results;
+    })()).join(','));
+    out.push('}');
+    return out.join("\n");
+  };
+})();
+
 Gibbon.jsonConsumer = (function() {
   return function(tables) {
     var analyzeList, getType, getValue, listLookup, lists;

data/vendor/gibbon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gibbon",
-  "version": "0.12.3",
+  "version": "0.13.0",
   "description": "A data language",
   "keywords": ["language"],
   "author": "Jeanine Adkisson <jjmadkisson at gmail dot com>",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goodguide-gibbon
 version: !ruby/object:Gem::Version
-  version: 0.12.3
+  version: 0.13.0
 platform: ruby
 authors:
 - Jay Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2014-11-12 00:00:00.000000000 Z
 dependencies: []
 description: Run and analyze gibbon code from ruby or a browser (via a ruby app).
 email: