matthewtodd-doily 0.1.0

data/lib/doily/parser.y

@@ -0,0 +1,157 @@
+class Doily::Parser
+
+  token FUNCTION IF ELSE FOR VAR BOOLEAN_LITERAL IDENTIFIER STRING_LITERAL INTEGER_LITERAL BINARY_OPERATOR
+
+rule
+  target
+    : function_definition
+    ;
+
+  function_definition
+    : FUNCTION '(' argument_name_list ')' block { result = Function.new(val[2], val[4]) }
+    ;
+
+  argument_name_list
+    :                                   { result = [] }
+    | IDENTIFIER                        { result = [val[0]] }
+    | IDENTIFIER ',' argument_name_list { result = [val[0]] + val[2] }
+    ;
+
+  block
+    : '{' '}'                { result = Block.new([]) }
+    | '{' statement_list '}' { result = Block.new(val[1]) }
+    ;
+
+  statement_list
+    : statement                { result = [val[0]] }
+    | statement statement_list { result = [val[0]] + val[1] }
+    ;
+
+  statement
+    : if_statement
+    | for_loop
+    | expression ';'
+    ;
+
+  if_statement
+    : IF '(' expression ')' block            { result = Conditional.new(val[2], val[4]) }
+    | IF '(' expression ')' block ELSE block { result = Conditional.new(val[2], val[4], val[6]) }
+    ;
+
+  for_loop
+    : FOR '(' expression ';' expression ';' expression ')' block { result = Loop.new(val[2], val[4], val[6], val[8]) }
+    ;
+
+  expression
+    : reference
+    | declaration
+    | assignment
+    | binary_expression
+    | increment
+    ;
+
+  reference
+    : variable
+    | INTEGER_LITERAL                  { result = Literal.new(val[0].to_i) }
+    | BOOLEAN_LITERAL                  { result = Literal.new(eval(val[0])) }
+    | string_literal
+    | '{' key_value_list '}'           { result = Object.new(val[1]) }
+    | reference '.' IDENTIFIER         { result = Access.new(val[0], Literal.new(val[2])) }
+    | reference '[' reference ']'      { result = Access.new(val[0], val[2]) }
+    | reference '(' argument_list ')'  { result = Call.new(val[0], val[2]) }
+    ;
+
+  variable
+    : IDENTIFIER { result = Reference.new(val[0]) }
+    ;
+
+  string_literal
+    : STRING_LITERAL { result = Literal.new(eval(val[0])) }
+    ;
+
+  key_value_list
+    :                              { result = {} }
+    | key_value                    { result = val[0] }
+    | key_value ',' key_value_list { result = val[0].merge(val[2]) }
+    ;
+
+  key_value
+    : string_literal ':' reference { result = { val[0] => val[2] }}
+    ;
+
+  argument_list
+    :                              { result = [] }
+    | expression                   { result = [val[0]] }
+    | expression ',' argument_list { result = [val[0]] + val[2] }
+    ;
+
+  assignment
+    : expression '=' reference { result = Assignment.new(val[0], val[2]) }
+    ;
+
+  declaration
+    : VAR IDENTIFIER { result = Declaration.new(val[1]) }
+    ;
+
+  binary_expression
+    : reference BINARY_OPERATOR reference { result = Call.new(Access.new(val[0], Literal.new(val[1])), [val[2]]) }
+    ;
+
+  increment
+    : variable '++' { result = Assignment.new(val[0], Call.new(Access.new(val[0], Literal.new('+')), [Literal.new(1)])) }
+    ;
+
+---- header ----
+require 'strscan'
+---- inner ----
+
+  def self.function(string)
+    new.parse(string)
+  end
+
+  def parse(string)
+    @tokens = []
+    scanner = StringScanner.new(string)
+
+    until scanner.empty?
+      case
+			when scanner.scan(/\s+/)
+				# ignore space
+      when m = scanner.scan(/function/)
+        @tokens.push [:FUNCTION, m]
+      when m = scanner.scan(/if/)
+        @tokens.push [:IF, m]
+      when m = scanner.scan(/else/)
+        @tokens.push [:ELSE, m]
+      when m = scanner.scan(/for/)
+        @tokens.push [:FOR, m]
+      when m = scanner.scan(/var/)
+        @tokens.push [:VAR, m]
+      when m = scanner.scan(/true|false/)
+        @tokens.push [:BOOLEAN_LITERAL, m]
+      when m = scanner.scan(/==|</)
+        @tokens.push [:BINARY_OPERATOR, m]
+      when m = scanner.scan(/\+\+/)
+        @tokens.push [m, m]
+      when m = scanner.scan(/[(){}\[\],\.:;=]/)
+        @tokens.push [m, m]
+      when m = scanner.scan(/[a-zA-Z_]+/)
+        @tokens.push [:IDENTIFIER, m]
+      when m = scanner.scan(/"([^"])*"/)
+        @tokens.push [:STRING_LITERAL, m]
+      when m = scanner.scan(/'([^'])*'/)
+        @tokens.push [:STRING_LITERAL, m]
+      when m = scanner.scan(/\d+/)
+        @tokens.push [:INTEGER_LITERAL, m]
+      else
+        raise ParseError.new(scanner)
+      end
+    end
+
+    @tokens.push [false, false]
+    do_parse
+  end
+
+  def next_token
+    @tokens.shift
+  end

data/lib/doily/types.rb

@@ -0,0 +1,5 @@
+Dir.chdir(File.join(File.dirname(__FILE__), '..')) do
+  Dir['doily/types/*.rb'].each do |filename|
+    require filename
+  end
+end

data/lib/doily/types/access.rb

@@ -0,0 +1,35 @@
+module Doily
+  class Access
+    def initialize(target, name)
+      @target = target
+      @name   = name
+    end
+
+    def assign(reference, binding)
+      ruby_target    = @target.to_ruby(binding)
+      ruby_name      = @name.to_ruby(binding)
+      ruby_reference = reference.to_ruby(binding)
+
+      if ruby_target.respond_to?(:has_key?)
+        ruby_target.store(ruby_name, ruby_reference)
+      else
+        ruby_target.send("#{ruby_name}=", ruby_reference)
+      end
+    end
+
+    def to_ruby(binding)
+      ruby_target = @target.to_ruby(binding)
+      ruby_name   = @name.to_ruby(binding)
+
+      if ruby_target.respond_to?(ruby_name.to_s)
+        if ruby_name == 'length'
+          ruby_target.length
+        else
+          ruby_target.method(ruby_name)
+        end
+      else
+        ruby_target[ruby_name]
+      end
+    end
+  end
+end

data/lib/doily/types/assignment.rb

@@ -0,0 +1,12 @@
+module Doily
+  class Assignment
+    def initialize(target, reference)
+      @target    = target
+      @reference = reference
+    end
+
+    def to_ruby(binding)
+      @target.assign(@reference, binding)
+    end
+  end
+end

data/lib/doily/types/binding.rb

@@ -0,0 +1,41 @@
+module Doily
+  class DelegateBinding
+    def initialize(delegate)
+      @delegate = delegate
+    end
+
+    def fetch(name)
+      @delegate.method(name)
+    end
+  end
+
+  class Binding
+    def initialize(parent, contents={})
+      @parent   = parent
+      @contents = contents
+    end
+
+    def fetch(name)
+      if @contents.has_key?(name)
+        @contents[name]
+      else
+        @parent.fetch(name)
+      end
+    end
+  end
+
+  class ArgumentBinding < Binding
+    def initialize(parent, names, values)
+      raise ArgumentError.new(names, values) unless names.length == values.length
+      contents = {}
+      names.zip(values).each { |key, value| contents[key] = value }
+      super parent, contents
+    end
+  end
+
+  class LocalBinding < Binding
+    def store(name, value)
+      @contents[name] = value
+    end
+  end
+end

data/lib/doily/types/block.rb

@@ -0,0 +1,17 @@
+module Doily
+  class Block
+    def initialize(statements = [])
+      @statements = statements
+    end
+
+    def to_ruby(binding)
+      binding = LocalBinding.new(binding)
+
+      result = nil
+      @statements.each do |statement|
+        result = statement.to_ruby(binding)
+      end
+      result
+    end
+  end
+end

data/lib/doily/types/call.rb

@@ -0,0 +1,12 @@
+module Doily
+  class Call
+    def initialize(target, args)
+      @target = target
+      @args   = args
+    end
+
+    def to_ruby(binding)
+      @target.to_ruby(binding).call(*@args.map { |arg| arg.to_ruby(binding) })
+    end
+  end
+end

data/lib/doily/types/conditional.rb

@@ -0,0 +1,17 @@
+module Doily
+  class Conditional
+    def initialize(conditional, true_block, false_block = Block.new)
+      @conditional = conditional
+      @true_block  = true_block
+      @false_block = false_block
+    end
+
+    def to_ruby(binding)
+      if @conditional.to_ruby(binding)
+        @true_block.to_ruby(binding)
+      else
+        @false_block.to_ruby(binding)
+      end
+    end
+  end
+end

data/lib/doily/types/declaration.rb

@@ -0,0 +1,15 @@
+module Doily
+  class Declaration
+    def initialize(name)
+      @name = name
+    end
+
+    def assign(reference, binding)
+      binding.store(@name, reference.to_ruby(binding))
+    end
+
+    def to_ruby(binding)
+      binding.store(@name, nil)
+    end
+  end
+end

data/lib/doily/types/function.rb

@@ -0,0 +1,32 @@
+module Doily
+  class Function
+    def initialize(parameters, block)
+      @parameters = parameters
+      @block      = block
+    end
+
+    def bind(binding)
+      BoundFunction.new(@parameters, @block, binding)
+    end
+
+    def call(*args)
+      bind(nil).call(*args)
+    end
+
+    def delegate(delegate)
+      bind(DelegateBinding.new(delegate))
+    end
+
+    class BoundFunction
+      def initialize(parameters, block, binding)
+        @parameters = parameters
+        @block      = block
+        @binding    = binding
+      end
+
+      def call(*args)
+        @block.to_ruby(ArgumentBinding.new(@binding, @parameters, args))
+      end
+    end
+  end
+end

data/lib/doily/types/literal.rb

@@ -0,0 +1,11 @@
+module Doily
+  class Literal
+    def initialize(value)
+      @value = value
+    end
+
+    def to_ruby(binding)
+      @value
+    end
+  end
+end

data/lib/doily/types/loop.rb

@@ -0,0 +1,20 @@
+module Doily
+  class Loop
+    def initialize(before_all, before_each, after_each, block)
+      @before_all  = before_all
+      @before_each = before_each
+      @after_each  = after_each
+      @block       = block
+    end
+
+    def to_ruby(binding)
+      binding = LocalBinding.new(binding)
+      @before_all.to_ruby(binding)
+      loop do
+        break unless @before_each.to_ruby(binding)
+        @block.to_ruby(binding)
+        @after_each.to_ruby(binding)
+      end
+    end
+  end
+end

data/lib/doily/types/object.rb

@@ -0,0 +1,15 @@
+module Doily
+  class Object
+    def initialize(properties)
+      @properties = properties
+    end
+
+    def to_ruby(binding)
+      result = {}
+      @properties.each do |key, value|
+        result[key.to_ruby(binding)] = value.to_ruby(binding)
+      end
+      result
+    end
+  end
+end

data/lib/doily/types/reference.rb

@@ -0,0 +1,15 @@
+module Doily
+  class Reference
+    def initialize(name)
+      @name = name
+    end
+
+    def assign(reference, binding)
+      binding.store(@name, reference.to_ruby(binding))
+    end
+
+    def to_ruby(binding)
+      binding.fetch(@name)
+    end
+  end
+end

data/test/doily_test.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class DoilyTest < Test::Unit::TestCase
+  should 'handle nothing' do
+    Doily('function() {}').call.should == nil
+  end
+
+  context 'delegation to a ruby object' do
+    setup do
+      @delegate = Class.new do
+        def echo(*args); args; end
+      end.new
+    end
+
+    should 'handle calling a function' do
+      Doily('function() { echo(); }').delegate(@delegate).call.should == []
+    end
+
+    should 'handle calling a function with one literal argument' do
+      Doily('function() { echo("foo"); }').delegate(@delegate).call.should == ['foo']
+    end
+
+    should 'handle calling a function with many literal arguments' do
+      Doily('function() { echo("foo", 42); }').delegate(@delegate).call.should == ['foo', 42]
+    end
+
+    should 'handle calling a function with a value from the binding' do
+      Doily('function(document) { echo(document); }').delegate(@delegate).call('key' => 'value').should == [{'key' => 'value'}]
+    end
+
+    should 'handle calling a function with a property access on a variable in the binding' do
+      Doily('function(document) { echo(document.key); }').delegate(@delegate).call('key' => 'value').should == ['value']
+    end
+
+    should 'handle calling a function with an invocation on a variable in the binding' do
+      Doily('function(document) { echo(document.keys()); }').delegate(@delegate).call('key' => 'value').should == [['key']]
+    end
+  end
+
+  should 'handle a boolean comparison of integers' do
+    Doily('function() { 1 == 1; }').call.should == true
+  end
+
+  should 'handle a boolean comparison of strings' do
+    Doily('function() { "foo" == "foo"; }').call.should == true
+  end
+
+  should 'handle a boolean comparison with calls' do
+    Doily('function() { "foo".reverse() == "oof"; }').call.should == true
+  end
+
+  should 'handle a false boolean comparison' do
+    Doily('function() { "foo" == "bar"; }').call.should == false
+  end
+
+  should 'handle a negative boolean comparison' do
+    Doily('function() { 1 < 2; }').call.should == true
+  end
+
+  should 'handle an if statement' do
+    Doily('function() { if (1 == 1) { 42; } }').call.should == 42
+  end
+
+  should 'handle a negative if statement' do
+    Doily('function() { if (1 == 2) { 42; } }').call.should == nil
+  end
+
+  should 'handle an else statement' do
+    Doily('function() { if (1 == 2) { 42; } else { "foo"; } }').call.should == 'foo'
+  end
+
+  should 'handle variable declaration' do
+    Doily('function() { var foo = "42"; }').call.should == '42'
+  end
+
+  should 'handle variable declaration with continuing statements' do
+    Doily('function() { var foo = "42"; foo; }').call.should == '42'
+  end
+
+  should 'handle hash literals' do
+    Doily('function() { {"name":"Bob", "age":42 }; }').call.should == { 'name' => 'Bob', 'age' => 42 }
+  end
+
+  should 'handle square-bracket hash access with literal' do
+    Doily('function(document) { document["key"]; }').call('key' => 'value').should == 'value'
+  end
+
+  should 'handle square-bracket hash access with expression' do
+    Doily('function(document) { var key = "key"; document[key]; }').call('key' => 'value').should == 'value'
+  end
+
+  should 'handle hash assignment' do
+    Doily('function() { var doc = {}; doc["key"] = "value"; doc; }').call.should == { 'key' => 'value' }
+  end
+
+  should 'handle literal true' do
+    Doily('function() { true; }').call.should == true
+  end
+
+  should 'handle literal false' do
+    Doily('function() { false; }').call.should == false
+  end
+
+  should 'handle single-quoted strings' do
+    Doily("function() { 'foo'; }").call.should == 'foo'
+  end
+
+  should 'handle increment operator' do
+    Doily('function() { var i = 0; i++; i; }').call.should == 1
+  end
+
+  context 'for loop' do
+    setup do
+      @counter = Class.new do
+        attr_reader :count
+
+        def initialize
+          @count = 0
+        end
+
+        def tick
+          @count = @count + 1
+        end
+      end.new
+    end
+
+    should 'work' do
+      Doily('function() { for (var i=0; i < 3; i++) { tick(); } }').delegate(@counter).call
+      @counter.count.should == 3
+    end
+  end
+
+  should 'special-case property access for length (no parens necessary to call)' do
+    Doily('function() { "foo".length; }').call.should == 3
+  end
+
+  should 'index arrays' do
+    Doily('function(array) { array[0]; }').call(['a', 'b']).should == 'a'
+  end
+end