goodguide-gibbon 0.5.1 → 0.6.0

data/lib/goodguide/gibbon/version.rb

@@ -1,7 +1,7 @@
 module GoodGuide
   module Gibbon
     def self.version
-      '0.5.1'
+      '0.6.0'
     end
   end
 end

data/lib/goodguide/gibbon.rb

@@ -23,18 +23,18 @@ module GoodGuide
         when Array
           o.map { |x| obj_to_js(x) }
         when Hash
-          if o['__isHash__'] or o[:__isHash__]
+          if o['__isHash__']
             js_hash = gibbon[:Hash].new
             o.each do |k, v|
               next if k.to_s == '__isHash__'
               js_hash.set(k, obj_to_js(v))
             end
             js_hash
-          elsif o['_union'] or o[:_union]
-            union = o['_union'] or o[:_union]
-            tag = o['_tag'] or o[:_tag]
-            constructor = gibbon[union]
-            raise "unknown union #{union}" unless constructor && constructor.tags
+          elsif o['__isVariant__']
+            type = o['_type']
+            tag = o['_tag']
+            constructor = gibbon[type]
+            raise "unknown union #{type}" unless constructor && constructor.tags
             names = constructor.tags[tag]
             raise "unknown tag #{tag}" unless names.is_a? V8::Array
 
@@ -58,9 +58,20 @@ module GoodGuide
         when V8::Object
           if o[:__isHash__]
             hash_to_ruby(o)
-          else
-            o = o.asJSON if o.respond_to? :asJSON
+          elsif o[:__isVariant__]
+            out = {
+              '__isVariant__' => true,
+              '_names' => obj_to_ruby(o[:_names]),
+              '_type' => o[:_type],
+              '_tag' => o[:_tag]
+            }
+
+            o._names.each do |name|
+              out[name] = obj_to_ruby o[name]
+            end
 
+            out
+          else
             out = {}
             o.each do |k, v|
               out[k] = obj_to_ruby(v)
@@ -90,6 +101,8 @@ module GoodGuide
     end
 
     class SemanticError < StandardError
+      include Util
+
       def initialize(errors)
         @errors = errors
       end
@@ -99,14 +112,15 @@ module GoodGuide
       end
 
     private
-      def inspect_js(type, js)
-        obj = JS.default.gibbon[type].fromJSON(js)
-        inspect = obj[:inspect]
-        inspect.methodcall(obj)
+      # needed for obj_to_js
+      def gibbon
+        JS.default.gibbon
       end
 
       def inspect_expr(expr)
-        inspect_js :TypeExpr, expr
+        obj = obj_to_js(expr)
+        inspect = obj[:inspect]
+        inspect.methodcall(obj)
       end
 
       def semantic_error_message(e)
@@ -121,7 +135,7 @@ module GoodGuide
           type = inspect_expr e['type']
           "could not destructure #{type}"
         when 'lookup'
-          query = inspect_js :AST, e['query']
+          query = inspect_expr e['query']
           id = e['id']
           error = e['error']
           "error analyzing #{query} on #{id}: #{error}"
@@ -168,31 +182,43 @@ module GoodGuide
 
         raise SemanticError.new(errors) if errors
 
+        compiled = context.compile(semantics)
+
         Program.new(
           :syntax => syntax,
-          :semantics => semantics,
+          :compiled => compiled,
           :context => context,
         )
       end
 
-      attr_reader :syntax, :semantics
+      attr_reader :syntax, :compiled
+      def semantics
+        as_json['compiled']['semantics']
+      end
+
       def initialize(info={})
-        @syntax = info[:syntax]
-        @semantics = info[:semantics]
+        @syntax = info[:syntax] or raise 'please pass syntax'
+        @compiled = info[:compiled] or raise 'please pass a compiled program'
         @context = info[:context] || Context.new
       end
 
       def as_json
-        {
-          syntax: @syntax,
-          semantics: @semantics,
+        @as_json ||= {
+          'syntax' => @context.send(:obj_to_ruby, @syntax),
+          'compiled' => @context.send(:obj_to_ruby, @compiled),
         }
       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)
+      end
+
       def call(runtime_client, entity_id)
-        values, error = @context.eval_gibbon(
-          self.semantics, entity_id, runtime_client.to_js
-        )
+        values, error = @context.run_compiled(@compiled, entity_id, runtime_client.to_js)
 
         raise error if error
         values
@@ -268,7 +294,7 @@ module GoodGuide
 
     class RuntimeClient < AbstractClient
       include Util
-      def perform_query(id, annotations, v)
+      def perform_query(id, annotations)
         annotations = obj_to_ruby(annotations)
 
         query_type = annotations.delete('_query_type')
@@ -279,7 +305,7 @@ module GoodGuide
         @last_id = id
 
         query = get_query(query_type)
-        instance_exec(id, annotations, v, &query)
+        instance_exec(id, annotations, &query)
       end
 
       def missing_data!
@@ -305,25 +331,26 @@ module GoodGuide
       end
 
       def parse(str)
-        obj_to_ruby self.gibbon.parse(str).asJSON
+        obj_to_ruby self.gibbon.parse(str)
       rescue V8::Error => e
         raise SemanticError.new([{'_tag' => 'parse', 'message' => e.value}])
       end
 
+      def compile(semantics)
+        gibbon.compile(obj_to_js(semantics))
+      end
+
       def analyze(syntax, global_table, static_client)
         syntax = obj_to_js(syntax)
 
-        semantics, error = capture do |&callback|
+        capture do |&callback|
           gibbon.analyze(syntax, global_table, static_client, callback)
         end
-
-        [hash_to_ruby(semantics), obj_to_ruby(error)]
       end
 
-      def eval_gibbon(semantics, id, runtime_client)
-        semantics = obj_to_js(semantics)
+      def run_compiled(compiled, entity_id, runtime_client)
         values, error = capture do |&callback|
-          gibbon.eval(semantics, 0, id, runtime_client, callback)
+          compiled.run('/', entity_id, runtime_client, callback)
         end
 
         [hash_to_ruby(values), obj_to_ruby(error)]