omghax-einstein 0.1.1 → 0.2.0

data/lib/einstein/pretty_printer.rb

@@ -0,0 +1,98 @@
+require 'einstein/processor'
+
+module Einstein
+  # This processor walks the AST and builds a "pretty print" of the values. 
+  # This means that it returns an unambiguous string representation of the
+  # tree.  All binary expressions are wrapped in parentheses.
+  class PrettyPrinter < Processor
+    # Example: 4
+    def process_lit(exp)
+      exp[1].to_s
+    end
+
+    # Example: +4
+    def process_unary_plus(exp)
+      unary_op("+", exp)
+    end
+
+    # Example: -4
+    def process_unary_minus(exp)
+      unary_op("-", exp)
+    end
+
+    # Example: ~4
+    def process_bitwise_not(exp)
+      unary_op("~", exp)
+    end
+
+    # Example: (2 ** 3)
+    def process_exponent(exp)
+      binary_op("**", exp)
+    end
+
+    # Example: (2 * 3)
+    def process_multiply(exp)
+      binary_op("*", exp)
+    end
+
+    # Example: (6 / 3)
+    def process_divide(exp)
+      binary_op("/", exp)
+    end
+
+    # Example: (7 % 3)
+    def process_modulus(exp)
+      binary_op("%", exp)
+    end
+
+    # Example: (5 + 8)
+    def process_add(exp)
+      binary_op("+", exp)
+    end
+
+    # Example: (6 - 3)
+    def process_subtract(exp)
+      binary_op("-", exp)
+    end
+
+    # Example: (8 << 2)
+    def process_lshift(exp)
+      binary_op("<<", exp)
+    end
+
+    # Example: (8 >> 2)
+    def process_rshift(exp)
+      binary_op(">>", exp)
+    end
+
+    # Example: (4 & 16)
+    def process_bitwise_and(exp)
+      binary_op("&", exp)
+    end
+
+    # Example: (4 ^ 6)
+    def process_bitwise_xor(exp)
+      binary_op("^", exp)
+    end
+
+    # Example: (4 | 6)
+    def process_bitwise_or(exp)
+      binary_op("|", exp)
+    end
+
+    # Example: x
+    def process_resolve(exp)
+      exp[1]
+    end
+
+    private
+
+    def unary_op(operation, exp)
+      "#{operation}#{process(exp[1])}"
+    end
+
+    def binary_op(operation, exp)
+      "(#{process(exp[1])} #{operation} #{process(exp[2])})"
+    end
+  end
+end

data/lib/einstein/processor.rb

@@ -0,0 +1,12 @@
+module Einstein
+  class Processor
+    def process(node)
+      node ||= []
+      if respond_to?(method = "process_#{node.first}")
+        send(method, node)
+      else
+        raise "No process method for sexp: #{node.inspect}"
+      end
+    end
+  end
+end

data/lib/einstein/version.rb

@@ -1,8 +1,8 @@
-module Einstein #:nodoc:
+module Einstein
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 1
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/tasks/benchmark.rake

@@ -0,0 +1,28 @@
+task :benchmark => :parser do
+  require 'benchmark'
+  runs = (ENV['RUNS'] || 10_000).to_i
+
+  puts "Benchmarking #{runs} run(s) of Einstein.parse"
+  Benchmark.bm(23) do |b|
+    b.report('1') { runs.times { Einstein.parse('1') } }
+    b.report('2 + 5') { runs.times { Einstein.parse('2 + 5') } }
+    b.report('x * y') { runs.times { Einstein.parse('x * y') } }
+    b.report('(x ** 2) / 8 - (y << z)') { runs.times { Einstein.parse('(x ** 2) / 8 - (y << z)') } }
+  end
+
+  puts "Benchmarking #{runs} run(s) of Einstein.evaluate"
+  Benchmark.bm(23) do |b|
+    b.report('1') { runs.times { Einstein.evaluate('1') } }
+    b.report('2 + 5') { runs.times { Einstein.evaluate('2 + 5') } }
+    b.report('x * y') { runs.times { Einstein.evaluate('x * y', :x => 1, :y => 2) } }
+    b.report('(x ** 2) / 8 - (y << z)') { runs.times { Einstein.evaluate('(x ** 2) / 8 - (y << z)', :x => 4, :y => 2, :z => 2) } }
+  end
+
+  puts "Benchmarking #{runs} run(s) of evaluate on a pre-parsed expression"
+  Benchmark.bm(23) do |b|
+    b.report('1') { e = Einstein.parse('1'); runs.times { e.evaluate } }
+    b.report('2 + 5') { e = Einstein.parse('2 + 5'); runs.times { e.evaluate } }
+    b.report('x * y') { e = Einstein.parse('x * y'); runs.times { e.evaluate(:x => 1, :y => 2) } }
+    b.report('(x ** 2) / 8 - (y << z)') { e = Einstein.parse('(x ** 2) / 8 - (y << z)'); runs.times { e.evaluate(:x => 4, :y => 2, :z => 2) } }
+  end
+end

data/test/helper.rb

@@ -1,2 +1,3 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'einstein'
 require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/einstein'

data/test/test_einstein.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestEinstein < Test::Unit::TestCase
+  def test_evaluate
+    assert_equal(1, Einstein.evaluate('1'))
+    assert_equal(35, Einstein.evaluate('(5 + 2) * (10 - 5)'))
+  end
+
+  def test_parse
+    exp = Einstein.parse('1')
+    assert_equal [:lit, 1], exp.to_sexp
+    assert_equal 1, exp.evaluate
+    assert_equal '1', exp.to_s
+
+    exp = Einstein.parse('2 + 5')
+    assert_equal [:add, [:lit, 2], [:lit, 5]], exp.to_sexp
+    assert_equal 7, exp.evaluate
+    assert_equal '(2 + 5)', exp.to_s
+  end
+end

data/test/test_evaluator.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestEvaluator < Test::Unit::TestCase
+  def test_resolve_should_raise_on_undefined_variable
+    assert_raises(Einstein::ResolveError) { process([:resolve, "x"]) }
+  end
+
+  def test_resolve
+    assert_equal(10, process([:resolve, "x"], "x" => 10))
+    assert_equal(10, process([:resolve, "x"], :x => 10))
+  end
+
+  def test_bitwise_or
+    assert_equal(10 | 5, process([:bitwise_or, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_bitwise_xor
+    assert_equal(10 ^ 5, process([:bitwise_xor, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_bitwise_and
+    assert_equal(10 & 5, process([:bitwise_and, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_rshift
+    assert_equal(10 >> 5, process([:rshift, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_lshift
+    assert_equal(10 << 5, process([:lshift, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_subtract
+    assert_equal(10 - 5, process([:subtract, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_add
+    assert_equal(10 + 5, process([:add, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_modulus
+    assert_equal(10 % 5, process([:modulus, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_divide_should_raise_on_divide_by_zero
+    assert_raises(ZeroDivisionError) { process([:divide, [:lit, 10], [:lit, 0]]) }
+  end
+
+  def test_divide
+    assert_equal(10 / 5, process([:divide, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_multiply
+    assert_equal(10 * 5, process([:multiply, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_exponent
+    assert_equal(10 ** 5, process([:exponent, [:lit, 10], [:lit, 5]]))
+  end
+
+  def test_bitwise_not
+    assert_equal(~10, process([:bitwise_not, [:lit, 10]]))
+  end
+
+  def test_unary_minus
+    assert_equal(-10, process([:unary_minus, [:lit, 10]]))
+  end
+
+  def test_unary_plus
+    assert_equal(+10, process([:unary_plus, [:lit, 10]]))
+  end
+
+  def test_lit
+    assert_equal(0, process([:lit, 0]))
+    assert_equal(1, process([:lit, 1]))
+    assert_equal(10, process([:lit, 10]))
+
+    assert_equal(10.1, process([:lit, 10.1]))
+  end
+
+  private
+
+  def process(exp, scope = {})
+    Einstein::Evaluator.new(scope).process(exp)
+  end
+end

data/test/test_parser.rb

@@ -1,10 +1,8 @@
-require File.dirname(__FILE__) + "/helper"
-require "logger"
+require File.dirname(__FILE__) + '/helper'
 
 class TestParser < Test::Unit::TestCase
   def setup
     @parser = Einstein::Parser.new
-    @parser.logger = Logger.new(STDERR)
   end
 
   def test_parentheses
@@ -13,7 +11,7 @@ class TestParser < Test::Unit::TestCase
         [:add, [:lit, 5], [:lit, 2]],
         [:subtract, [:lit, 10], [:lit, 5]]
       ],
-      parse("(5 + 2) * (10 - 5)").to_sexp
+      parse('(5 + 2) * (10 - 5)')
   end
 
   def test_order_of_operations
@@ -24,99 +22,106 @@ class TestParser < Test::Unit::TestCase
           [:multiply, [:lit, 4], [:lit, 2]]],
         [:lit, 5]
       ],
-      parse("6 / 3 + 4 * 2 - 5").to_sexp
+      parse('6 / 3 + 4 * 2 - 5')
   end
 
   def test_resolve
-    assert_equal [:resolve, "x"], parse("x").to_sexp
+    assert_equal [:resolve, 'x'], parse('x')
+    assert_equal [:resolve, 'with_underscores'], parse('with_underscores')
+    assert_equal [:resolve, '_leading_underscore'], parse('_leading_underscore')
+    assert_equal [:resolve, 'trailing_underscore_'], parse('trailing_underscore_')
   end
 
   def test_bitwise_or
-    assert_equal [:bitwise_or, [:lit, 5], [:lit, 10]], parse("5 | 10").to_sexp
+    assert_equal [:bitwise_or, [:lit, 5], [:lit, 10]], parse('5 | 10')
   end
 
   def test_bitwise_xor
-    assert_equal [:bitwise_xor, [:lit, 5], [:lit, 10]], parse("5 ^ 10").to_sexp
+    assert_equal [:bitwise_xor, [:lit, 5], [:lit, 10]], parse('5 ^ 10')
   end
 
   def test_bitwise_and
-    assert_equal [:bitwise_and, [:lit, 5], [:lit, 10]], parse("5 & 10").to_sexp
+    assert_equal [:bitwise_and, [:lit, 5], [:lit, 10]], parse('5 & 10')
   end
 
   def test_rshift
-    assert_equal [:rshift, [:lit, 2], [:lit, 3]], parse("2 >> 3").to_sexp
+    assert_equal [:rshift, [:lit, 2], [:lit, 3]], parse('2 >> 3')
   end
 
   def test_lshift
-    assert_equal [:lshift, [:lit, 2], [:lit, 3]], parse("2 << 3").to_sexp
+    assert_equal [:lshift, [:lit, 2], [:lit, 3]], parse('2 << 3')
   end
 
   def test_subtraction
-    assert_equal [:subtract, [:lit, 2], [:lit, 1]], parse("2 - 1").to_sexp
+    assert_equal [:subtract, [:lit, 2], [:lit, 1]], parse('2 - 1')
   end
 
   def test_addition
-    assert_equal [:add, [:lit, 1], [:lit, 2]], parse("1 + 2").to_sexp
+    assert_equal [:add, [:lit, 1], [:lit, 2]], parse('1 + 2')
   end
 
   def test_modulus
-    assert_equal [:modulus, [:lit, 10], [:lit, 5]], parse("10 % 5").to_sexp
+    assert_equal [:modulus, [:lit, 10], [:lit, 5]], parse('10 % 5')
   end
 
   def test_division
-    assert_equal [:divide, [:lit, 10], [:lit, 5]], parse("10 / 5").to_sexp
+    assert_equal [:divide, [:lit, 10], [:lit, 5]], parse('10 / 5')
   end
 
   def test_multiplication
-    assert_equal [:multiply, [:lit, 5], [:lit, 10]], parse("5 * 10").to_sexp
+    assert_equal [:multiply, [:lit, 5], [:lit, 10]], parse('5 * 10')
   end
 
   def test_exponent
-    assert_equal [:raise, [:lit, 5], [:lit, 2]], parse("5 ** 2").to_sexp
-    assert_equal [:raise, [:lit, 3], [:u_minus, [:lit, 6]]], parse("3 ** -6").to_sexp
-    assert_equal [:raise, [:lit, 18], [:bitwise_not, [:lit, 4]]], parse("18 ** ~4").to_sexp
+    assert_equal [:exponent, [:lit, 5], [:lit, 2]], parse('5 ** 2')
+    assert_equal [:exponent, [:lit, 3], [:unary_minus, [:lit, 6]]], parse('3 ** -6')
+    assert_equal [:exponent, [:lit, 18], [:bitwise_not, [:lit, 4]]], parse('18 ** ~4')
   end
 
   def test_unary_bitwise_not
-    assert_equal [:bitwise_not, [:lit, 10]], parse("~10").to_sexp
+    assert_equal [:bitwise_not, [:lit, 10]], parse('~10')
   end
 
   def test_unary_minus
-    assert_equal [:u_minus, [:lit, 10]], parse("-10").to_sexp
+    assert_equal [:unary_minus, [:lit, 10]], parse('-10')
   end
 
   def test_unary_plus
-    assert_equal [:u_plus, [:lit, 10]], parse("+10").to_sexp
+    assert_equal [:unary_plus, [:lit, 10]], parse('+10')
   end
 
   def test_float_scientific
-    assert_equal [:lit, 10.10e-3], parse("10.10e-3").to_sexp
+    assert_equal [:lit, 10.10e-3], parse('10.10e-3')
+    assert_equal [:lit, 12.34E+4], parse('12.34E+4')
   end
 
   def test_float
-    assert_equal [:lit, 10.10], parse("10.10").to_sexp
+    assert_equal [:lit, 10.10], parse('10.10')
   end
 
   def test_number_base2
-    assert_equal [:lit, 0b1010], parse("0b1010").to_sexp
+    assert_equal [:lit, 0b1010], parse('0b1010')
+    assert_equal [:lit, 0B0101], parse('0B0101')
   end
 
   def test_number_base8
-    assert_equal [:lit, 011], parse("011").to_sexp
+    assert_equal [:lit, 011], parse('011')
   end
 
   def test_number_base16
-    assert_equal [:lit, 0xdeadbeef], parse("0xdeadbeef").to_sexp
-    assert_equal [:lit, 0xCAFEBABE], parse("0xCAFEBABE").to_sexp
+    assert_equal [:lit, 0xdeadbeef], parse('0xdeadbeef')
+    assert_equal [:lit, 0Xdeadbeef], parse('0Xdeadbeef')
+    assert_equal [:lit, 0xCAFEBABE], parse('0xCAFEBABE')
+    assert_equal [:lit, 0XCAFEBABE], parse('0XCAFEBABE')
   end
 
   def test_number_base10
-    assert_equal [:lit, 15], parse("15").to_sexp
+    assert_equal [:lit, 15], parse('15')
   end
 
   private
 
   def parse(stmt)
-    @parser.parse(stmt)
+    @parser.scan_str(stmt)
   end
 end

data/test/test_pretty_printer.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/helper'
+
+class TestPrettyPrintProcessor < Test::Unit::TestCase
+  def setup
+    @printer = Einstein::PrettyPrinter.new
+  end
+
+  def test_resolve
+    assert_equal 'x', process([:resolve, 'x'])
+  end
+
+  def test_bitwise_or
+    assert_equal '(10 | 5)', process([:bitwise_or, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_bitwise_xor
+    assert_equal '(10 ^ 5)', process([:bitwise_xor, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_bitwise_and
+    assert_equal '(10 & 5)', process([:bitwise_and, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_rshift
+    assert_equal '(10 >> 5)', process([:rshift, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_lshift
+    assert_equal '(10 << 5)', process([:lshift, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_subtract
+    assert_equal '(10 - 5)', process([:subtract, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_add
+    assert_equal '(10 + 5)', process([:add, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_modulus
+    assert_equal '(10 % 5)', process([:modulus, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_divide
+    assert_equal '(10 / 5)', process([:divide, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_multiply
+    assert_equal '(10 * 5)', process([:multiply, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_exponent
+    assert_equal '(10 ** 5)', process([:exponent, [:lit, 10], [:lit, 5]])
+  end
+
+  def test_bitwise_not
+    assert_equal '~10', process([:bitwise_not, [:lit, 10]])
+  end
+
+  def test_unary_minus
+    assert_equal '-10', process([:unary_minus, [:lit, 10]])
+  end
+
+  def test_unary_plus
+    assert_equal '+10', process([:unary_plus, [:lit, 10]])
+  end
+
+  def test_lit
+    assert_equal '0', process([:lit, 0])
+    assert_equal '1', process([:lit, 1])
+    assert_equal '10', process([:lit, 10])
+
+    assert_equal '10.1', process([:lit, 10.1])
+  end
+
+  private
+
+  def process(exp)
+    @printer.process(exp)
+  end
+end