dentaku 0.2.2 → 0.2.3

data/README.md

@@ -44,15 +44,23 @@ to ensure proper evaluation:
     calculator.evaluate('(5 + 3) * 2')
     => 16
 
-A number of functions are also supported.  Okay, the number is currently one,
-but more will be added soon.  The current function is `if`, which works like
-Excel's `if`:
+A number of functions are also supported.  Okay, the number is currently two,
+but more will be added soon.  The current functions are `round` and `if`, and
+they work like their counterparts in Excel:
 
     calculator.evaluate('if (pears < 10, 10, 20)', :pears => 5)
     => 10
     calculator.evaluate('if (pears < 10, 10, 20)', :pears => 15)
     => 20
 
+`Round` can be called with or without the number of decimal places:
+
+    calculator.evaluate('round(8.2)')
+    => 8
+    calculator.evaluate('round(8.2759, 2)')
+    => 8.28
+
+
 If you're too lazy to be building calculator objects, there's a shortcut just
 for you:
 
@@ -65,7 +73,7 @@ SUPPORTED OPERATORS AND FUNCTIONS
 
 Math: `+ - * /`  
 Logic: `< > <= >= <> != = AND OR`  
-Functions: `IF`
+Functions: `IF ROUND`
 
 THANKS
 ------

data/dentaku.gemspec

@@ -15,6 +15,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "dentaku"
 
+  s.add_development_dependency('rake')
   s.add_development_dependency('rspec')
 
   s.files         = `git ls-files`.split("\n")

data/lib/dentaku/evaluator.rb

@@ -18,13 +18,15 @@ module Dentaku
     T_IF         = TokenMatcher.new(:function, :if)
     T_ROUND      = TokenMatcher.new(:function, :round)
 
+    T_NON_GROUP_STAR = TokenMatcher.new(:grouping).invert.star
+
     # patterns
-    P_GROUP      = [T_OPEN,    T_NON_GROUP,  T_CLOSE]
-    P_MATH_ADD   = [T_NUMERIC, T_ADDSUB,     T_NUMERIC]
-    P_MATH_MUL   = [T_NUMERIC, T_MULDIV,     T_NUMERIC]
-    P_NUM_COMP   = [T_NUMERIC, T_COMPARATOR, T_NUMERIC]
-    P_STR_COMP   = [T_STRING,  T_COMPARATOR, T_STRING]
-    P_COMBINE    = [T_LOGICAL, T_COMBINATOR, T_LOGICAL]
+    P_GROUP      = [T_OPEN,    T_NON_GROUP_STAR, T_CLOSE]
+    P_MATH_ADD   = [T_NUMERIC, T_ADDSUB,         T_NUMERIC]
+    P_MATH_MUL   = [T_NUMERIC, T_MULDIV,         T_NUMERIC]
+    P_NUM_COMP   = [T_NUMERIC, T_COMPARATOR,     T_NUMERIC]
+    P_STR_COMP   = [T_STRING,  T_COMPARATOR,     T_STRING]
+    P_COMBINE    = [T_LOGICAL, T_COMBINATOR,     T_LOGICAL]
 
     P_IF         = [T_IF, T_OPEN, T_NON_GROUP, T_COMMA, T_NON_GROUP, T_COMMA, T_NON_GROUP, T_CLOSE]
     P_ROUND_ONE  = [T_ROUND, T_OPEN, T_NUMERIC, T_CLOSE]
@@ -51,8 +53,10 @@ module Dentaku
       while tokens.length > 1
         matched = false
         RULES.each do |pattern, evaluator|
-          if pos = find_rule_match(pattern, tokens)
-            tokens = evaluate_step(tokens, pos, pattern.length, evaluator)
+          pos, match = find_rule_match(pattern, tokens)
+
+          if pos
+            tokens = evaluate_step(tokens, pos, match.length, evaluator)
             matched = true
             break
           end
@@ -73,11 +77,21 @@ module Dentaku
 
     def find_rule_match(pattern, token_stream)
       position = 0
-      while position <= token_stream.length - pattern.length
-        substream = token_stream.slice(position, pattern.length)
-        return position if pattern == substream
+
+      while position <= token_stream.length
+        matches = []
+        matched = true
+
+        pattern.each do |matcher|
+          match = matcher.match(token_stream, position + matches.length)
+          matched &&= match.matched?
+          matches += match
+        end
+
+        return position, matches if matched
         position += 1
       end
+
       nil
     end
 

data/lib/dentaku/token_matcher.rb

@@ -6,6 +6,9 @@ module Dentaku
       @categories = [categories].compact.flatten
       @values     = [values].compact.flatten
       @invert     = false
+
+      @min = 1
+      @max = 1
     end
 
     def invert
@@ -14,9 +17,37 @@ module Dentaku
     end
 
     def ==(token)
+      return false if token.nil?
       (category_match(token.category) && value_match(token.value)) ^ @invert
     end
 
+    def match(token_stream, offset=0)
+      matched_tokens = []
+
+      while self == token_stream[matched_tokens.length + offset] && matched_tokens.length < @max
+        matched_tokens << token_stream[matched_tokens.length + offset]
+      end
+
+      if (@min..@max).include? matched_tokens.length
+        def matched_tokens.matched?() true end
+      else
+        def matched_tokens.matched?() false end
+      end
+
+      matched_tokens
+    end
+
+    def star
+      @min = 0
+      @max = 1.0/0
+      self
+    end
+
+    def plus
+      @max = 1.0/0
+      self
+    end
+
     private
 
     def category_match(category)

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/spec/calculator_spec.rb

@@ -28,6 +28,7 @@ describe Dentaku::Calculator do
 
   it 'should evaluate a statement with no variables' do
     calculator.evaluate('5+3').should eq(8)
+    calculator.evaluate('(1+1+1)/3*100').should eq(100)
   end
 
   it 'should fail to evaluate unbound statements' do

data/spec/evaluator_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'dentaku/evaluator'
 
 describe Dentaku::Evaluator do
@@ -5,9 +6,10 @@ describe Dentaku::Evaluator do
 
   describe 'rule scanning' do
     it 'should find a matching rule' do
-      rule   = [Dentaku::Token.new(:numeric, nil)]
+      rule   = [Dentaku::TokenMatcher.new(:numeric, nil)]
       stream = [Dentaku::Token.new(:numeric, 1), Dentaku::Token.new(:operator, :add), Dentaku::Token.new(:numeric, 1)]
-      evaluator.find_rule_match(rule, stream).should eq(0)
+      position, match = evaluator.find_rule_match(rule, stream)
+      position.should eq(0)
     end
   end
 
@@ -26,72 +28,42 @@ describe Dentaku::Evaluator do
     end
 
     it 'should evaluate one apply step' do
-      stream   = ts(1, :add, 1, :add, 1)
-      expected = ts(2, :add, 1)
+      stream   = token_stream(1, :add, 1, :add, 1)
+      expected = token_stream(2, :add, 1)
 
       evaluator.evaluate_step(stream, 0, 3, :apply).should eq(expected)
     end
 
     it 'should evaluate one grouping step' do
-      stream   = ts(:open, 1, :add, 1, :close, :multiply, 5)
-      expected = ts(2, :multiply, 5)
+      stream   = token_stream(:open, 1, :add, 1, :close, :multiply, 5)
+      expected = token_stream(2, :multiply, 5)
 
       evaluator.evaluate_step(stream, 0, 5, :evaluate_group).should eq(expected)
     end
 
     describe 'maths' do
       it 'should perform addition' do
-        evaluator.evaluate(ts(1, :add, 1)).should eq(2)
+        evaluator.evaluate(token_stream(1, :add, 1)).should eq(2)
       end
 
       it 'should respect order of precedence' do
-        evaluator.evaluate(ts(1, :add, 1, :multiply, 5)).should eq(6)
+        evaluator.evaluate(token_stream(1, :add, 1, :multiply, 5)).should eq(6)
       end
 
       it 'should respect explicit grouping' do
-        evaluator.evaluate(ts(:open, 1, :add, 1, :close, :multiply, 5)).should eq(10)
+        evaluator.evaluate(token_stream(:open, 1, :add, 1, :close, :multiply, 5)).should eq(10)
       end
     end
 
     describe 'logic' do
       it 'should evaluate conditional' do
-        evaluator.evaluate(ts(5, :gt, 1)).should be_true
+        evaluator.evaluate(token_stream(5, :gt, 1)).should be_true
       end
 
       it 'should evaluate combined conditionals' do
-        evaluator.evaluate(ts(5, :gt, 1, :or, :false)).should be_true
-        evaluator.evaluate(ts(5, :gt, 1, :and, :false)).should be_false
+        evaluator.evaluate(token_stream(5, :gt, 1, :or, :false)).should be_true
+        evaluator.evaluate(token_stream(5, :gt, 1, :and, :false)).should be_false
       end
     end
   end
-
-  private
-
-  def ts(*args)
-    args.map do |arg|
-      category = (arg.is_a? Fixnum) ? :numeric : category_for(arg)
-      arg = (arg == :true) if category == :logical
-      Dentaku::Token.new(category, arg)
-    end
-  end
-
-  def category_for(value)
-    case value
-    when Numeric
-      :numeric
-    when :add, :subtract, :multiply, :divide
-      :operator
-    when :open, :close
-      :grouping
-    when :le, :ge, :ne, :ne, :lt, :gt, :eq
-      :comparator
-    when :and, :or
-      :combinator
-    when :true, :false
-      :logical
-    else
-      :identifier
-    end
-  end
 end
-

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# automatically create a token stream from bare values
+def token_stream(*args)
+  args.map do |value|
+    type = type_for(value)
+    value = (value == :true) if type == :logical
+    Dentaku::Token.new(type, value)
+  end
+end
+
+# make a (hopefully intelligent) guess about type
+def type_for(value)
+  case value
+  when Numeric
+    :numeric
+  when :add, :subtract, :multiply, :divide
+    :operator
+  when :open, :close
+    :grouping
+  when :le, :ge, :ne, :ne, :lt, :gt, :eq
+    :comparator
+  when :and, :or
+    :combinator
+  when :true, :false
+    :logical
+  else
+    :identifier
+  end
+end
+

data/spec/token_matcher_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'dentaku/token_matcher'
 
 describe Dentaku::TokenMatcher do
@@ -51,5 +52,54 @@ describe Dentaku::TokenMatcher do
     matcher.should == mul
     matcher.should == cmp
   end
+
+  describe 'stream matching' do
+    let(:stream) { token_stream(5, 11, 9, 24, :hello, 8) }
+
+    describe :standard do
+      let(:standard) { described_class.new(:numeric) }
+
+      it 'should match zero or more occurrences in a token stream' do
+        substream = standard.match(stream)
+        substream.should be_matched
+        substream.length.should eq 1
+        substream.map(&:value).should eq [5]
+
+        substream = standard.match(stream, 4)
+        substream.should be_empty
+        substream.should_not be_matched
+      end
+    end
+
+    describe :star do
+      let(:star) { described_class.new(:numeric).star }
+
+      it 'should match zero or more occurrences in a token stream' do
+        substream = star.match(stream)
+        substream.should be_matched
+        substream.length.should eq 4
+        substream.map(&:value).should eq [5, 11, 9, 24]
+
+        substream = star.match(stream, 4)
+        substream.should be_empty
+        substream.should be_matched
+      end
+    end
+
+    describe :plus do
+      let(:plus) { described_class.new(:numeric).plus }
+
+      it 'should match one or more occurrences in a token stream' do
+        substream = plus.match(stream)
+        substream.should be_matched
+        substream.length.should eq 4
+        substream.map(&:value).should eq [5, 11, 9, 24]
+
+        substream = plus.match(stream, 4)
+        substream.should be_empty
+        substream.should_not be_matched
+      end
+    end
+  end
 end
 

metadata

@@ -1,46 +1,47 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: dentaku
-version: !ruby/object:Gem::Version 
-  hash: 19
+version: !ruby/object:Gem::Version
+  version: 0.2.3
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 2
-  version: 0.2.2
 platform: ruby
-authors: 
+authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-02-22 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rspec
+date: 2012-02-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70181931083120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *70181931083120
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70181931082440 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
-description: "    Dentaku is a parser and evaluator for mathematical formulas\n"
-email: 
+  prerelease: false
+  version_requirements: *70181931082440
+description: ! '    Dentaku is a parser and evaluator for mathematical formulas
+
+'
+email:
 - rubysolo@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - README.md
@@ -57,47 +58,46 @@ files:
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb
+- spec/spec_helper.rb
 - spec/token_matcher_spec.rb
 - spec/token_scanner_spec.rb
 - spec/token_spec.rb
 - spec/tokenizer_spec.rb
 homepage: http://github.com/rubysolo/dentaku
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: -2425877477882422646
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: -2425877477882422646
 requirements: []
-
 rubyforge_project: dentaku
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: A formula language parser and evaluator
-test_files: 
+test_files:
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb
+- spec/spec_helper.rb
 - spec/token_matcher_spec.rb
 - spec/token_scanner_spec.rb
 - spec/token_spec.rb