goodguide-gibbon 0.1.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org/'
+gemspec
+
+gem 'minitest', '~> 4.0'
+gem 'wrong'
+gem 'pry'
+
+gem 'rake'

data/goodguide-gibbon.gemspec

@@ -0,0 +1,24 @@
+require './lib/goodguide/gibbon/version'
+require 'rake'
+
+Gem::Specification.new do |s|
+  s.name = "goodguide-gibbon"
+  s.version = GoodGuide::Gibbon.version
+  s.authors = ["Jay Adkisson"]
+  s.email = ["jjmadkisson@gmail.com"]
+  s.summary = "Ruby bindings for the gibbon data language"
+  s.description = <<-desc.strip.gsub(/\s+/, ' ')
+    Run and analyze gibbon code from ruby or a browser (via a ruby app).
+  desc
+  s.homepage = "http://github.com/GoodGuide/goodguide-gibbon"
+  s.rubyforge_project = "goodguide-gibbon"
+  s.files = FileList[
+    'Gemfile',
+    'goodguide-gibbon.gemspec',
+    'lib/**/*.rb',
+    'vendor/gibbon/package.json',
+    'vendor/gibbon/lib/gibbon.browser.js'
+  ]
+
+  s.add_dependency 'therubyracer'
+end

data/lib/goodguide/gibbon/version.rb

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

data/lib/goodguide/gibbon.rb

@@ -0,0 +1,189 @@
+require 'v8' # therubyracer
+
+require 'pathname'
+
+module GoodGuide
+  module Gibbon
+    def self.root
+      Pathname.new(__FILE__).dirname.parent.parent
+    end
+
+    def self.js_lib
+      root.join('vendor/gibbon/lib/gibbon.browser.js')
+    end
+
+    def self.js_source
+      @js_source ||= File.read(js_lib)
+    end
+
+    class SemanticError < StandardError
+      def initialize(errors)
+        @errors = errors
+      end
+    end
+
+    class RuntimeError < StandardError; end
+
+    class Program
+      attr_reader :source
+      def initialize(global, context, source)
+        @global = global
+        @context = context
+        @source = source
+      end
+
+      def syntax
+        @syntax ||= @context.parse(@source)
+      end
+
+      def semantics
+        @semantics ||= begin
+          semantics, errors = @context.analyze(self.syntax, @global)
+          raise SemanticError.new(errors) if errors
+          semantics
+        end
+      end
+
+      def call(entity_id)
+        values, error = @context.eval_gibbon(
+          self.semantics, @global, entity_id
+        )
+
+        raise RuntimeError.new(error) if error
+        values
+      end
+    end
+
+    class Client
+      def self.parse(global, source)
+        self.new.parse(global, source)
+      end
+
+      def parse(global, source)
+        Program.new(global, context, source)
+      end
+
+      def context
+        @context ||= Context.new(self)
+      end
+
+      def lookup_type(id, name)
+        raise 'abstract'
+      end
+
+      def lookup_value(id, annotations)
+        raise 'abstract'
+      end
+
+      def proc_for(method)
+        lambda do |this, *args|
+          cb = args.pop
+          err, val = begin
+            [nil, send(method, *args)]
+          rescue => e
+            [e.to_s, nil]
+          end
+
+          cb.call(err, val)
+        end
+      end
+
+      def to_js
+        {
+          getType: proc_for(:lookup_type),
+          getValue: proc_for(:lookup_value),
+        }
+      end
+    end
+
+    class Context < V8::Context
+      class Console
+        def log(*a)
+          puts a.map(&:to_s).join(' ')
+        end
+      end
+
+      attr_reader :client
+      def initialize(client)
+        super()
+        @client = client.to_js
+        self[:console] = Console.new
+        load GoodGuide::Gibbon.js_lib
+      end
+
+      def gibbon
+        self[:Gibbon]
+      end
+
+      def parse(str)
+        obj_to_ruby gibbon.parse(str).asJSON
+      end
+
+      def analyze(syntax, global_table)
+        semantics, error = capture do |&callback|
+          gibbon.analyze(syntax, global_table, self.client, callback)
+        end
+
+        [hash_to_ruby(semantics), obj_to_ruby(error)]
+      end
+
+      def eval_gibbon(semantics, global_table, id)
+        semantics = hash_to_js(semantics)
+        values, error = capture do |&callback|
+          gibbon.eval(semantics, global_table, id, self.client, callback)
+        end
+
+        [hash_to_ruby(values), obj_to_ruby(error)]
+      end
+
+    private
+      def capture(&b)
+        output = nil
+        error = nil
+        b.call do |this, error_, output_|
+          output, error = output_, error_
+        end
+
+        [output, error]
+      end
+
+      def hash_to_ruby(js_hash)
+        return nil unless js_hash
+
+        ruby_hash = {}
+        iterator = lambda { |this, k, v|
+          ruby_hash[k] = obj_to_ruby(v)
+        }
+
+        js_hash[:each].methodcall js_hash, iterator
+
+        ruby_hash
+      end
+
+      def hash_to_js(ruby_hash)
+        js_hash = gibbon[:Hash].new
+        ruby_hash.each do |k, v|
+          js_hash.set(k, v)
+        end
+        js_hash
+      end
+
+      def obj_to_ruby(o)
+        case o
+        when V8::Array
+          o.map { |x| obj_to_ruby(x) }
+        when V8::Object
+          o = o.asJSON if o.respond_to? :asJSON
+
+          out = {}
+          o.each do |k, v|
+            out[k] = obj_to_ruby(v)
+          end
+          out
+        else
+          o
+        end
+      end
+    end
+  end
+end