omghax-einstein 0.1.1 → 0.2.0

data/Benchmarks.txt

@@ -0,0 +1,48 @@
+== Version 0.1.1
+
+First version to include benchmarking. Each type of node in the AST had its
+own Einstein::Node subclass.
+
+  Benchmarking 10000 run(s) of Einstein.parse
+                               user     system      total        real
+  1                        1.020000   0.020000   1.040000 (  1.053689)
+  2 + 5                    3.150000   0.010000   3.160000 (  3.182302)
+  x * y                    2.690000   0.010000   2.700000 (  2.712514)
+  (x ** 2) / 8 - (y << z) 10.770000   0.040000  10.810000 ( 10.866615)
+  Benchmarking 10000 run(s) of Einstein.evaluate
+                               user     system      total        real
+  1                        1.710000   0.000000   1.710000 (  1.719042)
+  2 + 5                    4.110000   0.020000   4.130000 (  4.148186)
+  x * y                    3.920000   0.010000   3.930000 (  3.949004)
+  (x ** 2) / 8 - (y << z) 13.440000   0.040000  13.480000 ( 13.548173)
+  Benchmarking 10000 run(s) of evaluate on a pre-parsed expression
+                               user     system      total        real
+  1                        0.530000   0.000000   0.530000 (  0.538565)
+  2 + 5                    1.000000   0.000000   1.000000 (  1.003800)
+  x * y                    1.080000   0.010000   1.090000 (  1.090432)
+  (x ** 2) / 8 - (y << z)  2.490000   0.010000   2.500000 (  2.518389)
+
+== Version 0.2.0
+
+All node classes were removed, and Einstein was re-implemented using only
+s-expressions. The custom Einstein::Tokenizer class was removed as well, and
+replaced with one generated by rex.
+
+  Benchmarking 10000 run(s) of Einstein.parse
+                               user     system      total        real
+  1                        0.600000   0.030000   0.630000 (  0.629743)
+  2 + 5                    1.300000   0.000000   1.300000 (  1.310801)
+  x * y                    1.280000   0.010000   1.290000 (  1.298743)
+  (x ** 2) / 8 - (y << z)  4.570000   0.020000   4.590000 (  4.611955)
+  Benchmarking 10000 run(s) of Einstein.evaluate
+                               user     system      total        real
+  1                        0.780000   0.000000   0.780000 (  0.794553)
+  2 + 5                    1.580000   0.010000   1.590000 (  1.595382)
+  x * y                    1.600000   0.000000   1.600000 (  1.613572)
+  (x ** 2) / 8 - (y << z)  5.380000   0.020000   5.400000 (  5.436614)
+  Benchmarking 10000 run(s) of evaluate on a pre-parsed expression
+                               user     system      total        real
+  1                        0.080000   0.000000   0.080000 (  0.077623)
+  2 + 5                    0.230000   0.000000   0.230000 (  0.232722)
+  x * y                    0.320000   0.000000   0.320000 (  0.326163)
+  (x ** 2) / 8 - (y << z)  0.670000   0.000000   0.670000 (  0.682789)

data/History.txt

@@ -1,3 +1,12 @@
+== 0.2.0 2008-05-10
+
+* 2 major enhancements:
+  * Removed the custom tokenizer in favor of using a rex-based one instead.
+  * Huge changes to the internal structure of Einstein. Eliminated the node
+    classes in favor of modeling the syntax tree as an s-expression. This
+    makes the code much simpler, and I have a feeling it will be faster as
+    well, but I need to run some benchmarks to be sure.
+
 == 0.1.1 2008-05-08
 
 * 1 major bugfix:

data/Manifest.txt

@@ -1,31 +1,24 @@
+Benchmarks.txt
 History.txt
 License.txt
 Manifest.txt
 README.txt
 Rakefile
-config/hoe.rb
-config/requirements.rb
+einstein.gemspec
 lib/einstein.rb
-lib/einstein/generated_parser.rb
-lib/einstein/nodes.rb
-lib/einstein/parser.rb
-lib/einstein/tokenizer.rb
+lib/einstein/evaluator.rb
+lib/einstein/expression.rb
+lib/einstein/parser.racc
+lib/einstein/parser.racc.rb
+lib/einstein/parser.rex
+lib/einstein/parser.rex.rb
+lib/einstein/pretty_printer.rb
+lib/einstein/processor.rb
 lib/einstein/version.rb
-lib/einstein/visitors.rb
-lib/parser.y
-script/destroy
-script/generate
-script/txt2html
 setup.rb
-tasks/deployment.rake
-tasks/environment.rake
-tasks/website.rake
-test/test_evaluate.rb
+tasks/benchmark.rake
 test/helper.rb
+test/test_einstein.rb
+test/test_evaluator.rb
 test/test_parser.rb
-test/test_pretty_print.rb
-website/index.html
-website/index.txt
-website/javascripts/rounded_corners_lite.inc.js
-website/stylesheets/screen.css
-website/template.rhtml
+test/test_pretty_printer.rb

data/README.txt

@@ -40,19 +40,12 @@ You can then evaluate this tree for different values of x:
 Or you can return an s-expression representation of the tree:
 
   >> ast.to_sexp
-  => [:raise, [:resolve, "x"], [:lit, 2]]
+  => [:exponent, [:resolve, "x"], [:lit, 2]]
 
 == Authors
 
 Copyright (c) 2008 by Dray Lacy
 
-== Acknowledgements
-
-Large portions of the parser were taken from the RKelly project by Aaron
-Patterson, which was itself derived from rbnarcissus by Paul Sowden.
-
-Thanks Aaron and Paul!
-
 == License
 
 Einstein is licensed under the MIT License.

data/Rakefile

@@ -1,20 +1,33 @@
-require 'config/requirements'
-require 'config/hoe' # setup Hoe + all gem configuration
+require 'rubygems'
+require 'hoe'
+require './lib/einstein.rb'
 
+# Load all tasks from /tasks.
 Dir['tasks/**/*.rake'].each { |rake| load rake }
 
-GENERATED_PARSER = "lib/einstein/generated_parser.rb"
+Hoe.new('einstein', Einstein::VERSION::STRING) do |p|
+  p.developer 'Dray Lacy', 'dray@izea.com'
+  p.description = p.summary = 'Safe arithmetic parser for Ruby apps'
+  p.url = 'http://github.com/omghax/einstein'
+  p.test_globs = ['test/**/test_*.rb']
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+GENERATED_PARSER = 'lib/einstein/parser.racc.rb'
+GENERATED_LEXER = 'lib/einstein/parser.rex.rb'
 
-file GENERATED_PARSER => "lib/parser.y" do |t|
-  if ENV['DEBUG']
-    sh "racc -g -v -o #{t.name} #{t.prerequisites.first}"
-  else
-    sh "racc -o #{t.name} #{t.prerequisites.first}"
-  end
+file GENERATED_LEXER => 'lib/einstein/parser.rex' do |t|
+  sh "rex -o #{t.name} #{t.prerequisites.first}"
 end
 
-task :parser => GENERATED_PARSER
+file GENERATED_PARSER => 'lib/einstein/parser.racc' do |t|
+  sh "racc -o #{t.name} #{t.prerequisites.first}"
+end
+
+task :parser => [GENERATED_LEXER, GENERATED_PARSER]
+
+# Make sure the parser's up-to-date when we test.
+Rake::Task["test"].prerequisites << :parser
 
-# make sure the parser's up-to-date when we test
-Rake::Task[:test].prerequisites << :parser
-Rake::Task[:check_manifest].prerequisites << :parser
+# Make sure the generated parser gets included in the manifest.
+Rake::Task["check_manifest"].prerequisites << :parser

data/einstein.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name = %q{einstein}
+  s.version = "0.2.0"
+
+  s.specification_version = 2 if s.respond_to? :specification_version=
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dray Lacy"]
+  s.date = %q{2008-05-15}
+  s.description = %q{Safe arithmetic parser for Ruby apps}
+  s.email = ["dray@izea.com"]
+  s.extra_rdoc_files = ["Benchmarks.txt", "History.txt", "License.txt", "Manifest.txt", "README.txt"]
+  s.files = ["Benchmarks.txt", "History.txt", "License.txt", "Manifest.txt", "README.txt", "Rakefile", "einstein.gemspec", "lib/einstein.rb", "lib/einstein/evaluator.rb", "lib/einstein/expression.rb", "lib/einstein/parser.racc", "lib/einstein/parser.racc.rb", "lib/einstein/parser.rex", "lib/einstein/parser.rex.rb", "lib/einstein/pretty_printer.rb", "lib/einstein/processor.rb", "lib/einstein/version.rb", "setup.rb", "tasks/benchmark.rake", "test/helper.rb", "test/test_einstein.rb", "test/test_evaluator.rb", "test/test_parser.rb", "test/test_pretty_printer.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/omghax/einstein}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{einstein}
+  s.rubygems_version = %q{1.1.1}
+  s.summary = %q{Safe arithmetic parser for Ruby apps}
+  s.test_files = ["test/test_einstein.rb", "test/test_evaluator.rb", "test/test_parser.rb", "test/test_pretty_printer.rb"]
+
+  s.add_dependency(%q<hoe>, [">= 1.5.1"])
+end

data/lib/einstein.rb

@@ -1,50 +1,19 @@
+# Add ./lib to the load path.
 $:.unshift File.dirname(__FILE__)
+require 'einstein/parser.racc.rb'
+require 'einstein/parser.rex.rb'
+require 'einstein/expression'
+require 'einstein/version'
 
-require "einstein/parser"
-
-# == Basic Usage
-# 
-# If you're only interested in evaluating expressions, you can simply call
-# Einstein.evaluate:
-# 
-#   Einstein.evaluate("1 + 2 + 3") # => 6
-# 
-# You can use variables as well, but you must supply their values:
-# 
-#   Einstein.evaluate("x * 4", :x => 5) # => 20
-#   Einstein.evaluate("x + y + z", :x => 3, :y => 4, :z => 5) # => 12
-# 
-# == Prepared Statements
-# 
-# If you're going to be performing the same operation over a large set of
-# different values, and performance is a concern, you can have Einstein parse
-# the expression once beforehand, and return a statement object (technically,
-# an instance of Einstein::Nodes::StatementNode).  You can then pass your
-# values directly to this statement for much faster processing, rather than
-# making Einstein parse the same formula over and over again each time.
-# 
-#   # This will return a prepared statement.
-#   stmt = Einstein.parse("x + y")
-# 
-#   # You can then evaluate this statement against different inputs.
-#   stmt.evaluate(:x => 1, :y => 2) # => 3
-#   stmt.evaluate(:x => 25, :y => 30) # => 55
 module Einstein
-  # Base class for all Einstein errors.
-  class Error < StandardError
-  end
-
-  # Raised when a variable's name cannot be resolved.
-  class ResolveError < Error
-  end
-
-  # Raised when division by zero occurs.
-  class ZeroDivisionError < Error
+  # Raised when an undefined variable is referenced.
+  class ResolveError < StandardError # :nodoc:
   end
 
-  # Parse the given +expression+ and return the AST as
+  # Parse the given +expression+ and return the AST as an instance of
+  # Einstein::Expression.
   def self.parse(expression)
-    Parser.new.parse(expression)
+    Expression.new(Parser.new.scan_str(expression))
   end
 
   # Evaluate the given +expression+ with the given +scope+.  Any variables

data/lib/einstein/evaluator.rb

@@ -0,0 +1,102 @@
+require 'einstein/processor'
+
+module Einstein
+  # This processor walks the AST and evaluates the values of the nodes.
+  class Evaluator < Processor
+    # Initialize a new instance of this processor with the given +scope+, as a
+    # hash.  This +scope+ should provide a mapping of variable names to
+    # values.
+    def initialize(scope = {})
+      # Convert symbol keys into strings.
+      @scope = scope.inject({}) do |hash, (key, value)|
+        hash[key.to_s] = value
+        hash
+      end
+    end
+
+    # Returns the value of +exp+.
+    def process_lit(exp)
+      exp[1]
+    end
+
+    # Returns the value of +exp+.
+    def process_unary_plus(exp)
+      process(exp[1])
+    end
+
+    # Returns the negated value of +exp+.
+    def process_unary_minus(exp)
+      -process(exp[1])
+    end
+
+    # Performs a bitwise NOT operation on the value of +exp+.
+    def process_bitwise_not(exp)
+      ~process(exp[1])
+    end
+
+    # Raises the left value of +exp+ by the right value of +exp+.
+    def process_exponent(exp)
+      process(exp[1]) ** process(exp[2])
+    end
+
+    # Multiplies the left and right values of +exp+.
+    def process_multiply(exp)
+      process(exp[1]) * process(exp[2])
+    end
+
+    # Divides the left value of +exp+ by the right value of +exp+.  Will raise
+    # ZeroDivisionError if the right value of +exp+ evaluates to 0.
+    def process_divide(exp)
+      process(exp[1]) / process(exp[2])
+    end
+
+    # Performs a modulus operation for the left and right values of +exp+.
+    def process_modulus(exp)
+      process(exp[1]) % process(exp[2])
+    end
+
+    # Adds the left and right values of +exp+.
+    def process_add(exp)
+      process(exp[1]) + process(exp[2])
+    end
+
+    # Subtracts the right value of +exp+ by the left value of +exp+.
+    def process_subtract(exp)
+      process(exp[1]) - process(exp[2])
+    end
+
+    # Performs a bitwise left shift of the left value of +exp+ by the number
+    # of bits specified in the right value of +exp+.
+    def process_lshift(exp)
+      process(exp[1]) << process(exp[2])
+    end
+
+    # Performs a bitwise right shift of the left value of +exp+ by the number
+    # of bits specified in the right value of +exp+.
+    def process_rshift(exp)
+      process(exp[1]) >> process(exp[2])
+    end
+
+    # Performs a bitwise AND with the left and right values of +exp+.
+    def process_bitwise_and(exp)
+      process(exp[1]) & process(exp[2])
+    end
+
+    # Performs a bitwise XOR with the left and right values of +exp+.
+    def process_bitwise_xor(exp)
+      process(exp[1]) ^ process(exp[2])
+    end
+
+    # Performs a bitwise OR with the left and right values of +exp+.
+    def process_bitwise_or(exp)
+      process(exp[1]) | process(exp[2])
+    end
+
+    # Performs a lookup for the value of +exp+ inside this processor's scope.
+    # Raises ResolveError if the variable is not in scope.
+    def process_resolve(exp)
+      raise ResolveError, "Undefined variable: #{exp[1]}" unless @scope.has_key?(exp[1])
+      @scope[exp[1]]
+    end
+  end
+end

data/lib/einstein/expression.rb

@@ -0,0 +1,37 @@
+require 'einstein/evaluator'
+require 'einstein/pretty_printer'
+
+module Einstein
+  # Node representing an entire Einstein statement.  This is the root-level
+  # node of the parser.  This node's +exp+ is the tree of expressions that
+  # make up a single logical statement.
+  class Expression
+    # Initialize a new expression wrapping the given +sexp+, which is expected
+    # to be an s-expression represented as a set of nested arrays.
+    # 
+    # Example:
+    #   Expression.new([:lit, 10]) # => 10
+    #   Expression.new([:multiply, [:lit, 10], [:lit, 5]]) # => (10 * 5)
+    def initialize(sexp)
+      @sexp = sexp
+    end
+
+    # The s-expression given to this Expression's constructor.
+    attr_reader :sexp
+    alias_method :to_sexp, :sexp
+
+    # Evaluate this node against the given +scope+. Returns a numeric value
+    # calculated by walking the AST with an instance of EvaluateProcessor.
+    def evaluate(scope = {})
+      Evaluator.new(scope).process(to_sexp)
+    end
+
+    # Performs a "pretty print" of this expression.
+    def to_s
+      PrettyPrinter.new.process(to_sexp)
+    end
+
+    # Also use #to_s for inspecting a node in IRB.
+    alias_method :inspect, :to_s
+  end
+end

data/lib/einstein/parser.racc

@@ -0,0 +1,41 @@
+class Einstein::Parser
+
+rule
+  exp             : bitwise_or
+
+  literal         : IDENT { result = [:resolve, val.first] }
+                  | NUMBER { result = [:lit, val.first] }
+
+  primary         : '(' exp ')' { result = val[1] }
+                  | literal
+
+  unary           : primary
+                  | '+' unary { result = [:unary_plus, val[1]] }
+                  | '-' unary { result = [:unary_minus, val[1]] }
+                  | '~' unary { result = [:bitwise_not, val[1]] }
+
+  exponent        : unary
+                  | exponent MULT2 unary { result = [:exponent, val[0], val[2]] }
+
+  multiplicative  : exponent
+                  | multiplicative '*' exponent { result = [:multiply, val[0], val[2]] }
+                  | multiplicative '/' exponent { result = [:divide, val[0], val[2]] }
+                  | multiplicative '%' exponent { result = [:modulus, val[0], val[2]] }
+
+  additive        : multiplicative
+                  | additive '+' multiplicative { result = [:add, val[0], val[2]] }
+                  | additive '-' multiplicative { result = [:subtract, val[0], val[2]] }
+
+  shift           : additive
+                  | shift LSHIFT additive { result = [:lshift, val[0], val[2]] }
+                  | shift RSHIFT additive { result = [:rshift, val[0], val[2]] }
+
+  bitwise_and     : shift
+                  | bitwise_and '&' shift { result = [:bitwise_and, val[0], val[2]] }
+
+  bitwise_or      : bitwise_and
+                  | bitwise_or '|' bitwise_and { result = [:bitwise_or, val[0], val[2]] }
+                  | bitwise_or '^' bitwise_and { result = [:bitwise_xor, val[0], val[2]] }
+
+---- header ----
+require 'einstein/parser.rex.rb'