dentaku 0.2.12 → 0.2.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc04ff45c34b77ede3ebb41f6ed34a94413925ac
+  data.tar.gz: 19906fc893a540448be14ed1374cc1cb89b7c999
+SHA512:
+  metadata.gz: b8ef9498e64f6050bc7fd587b5c3cae3c0489bc050810601c70820d233a03bd586ed37567b186a423a397c1571e0cb02828ed17126627b1764e7c089abe36dfd
+  data.tar.gz: a5d0ee82db757582c697bfb721b27a9670cf46b790b17839967fd40fc52bdaf0e91a9839be73504da6bd026fbcb750edd7235c53d23f7930aec89da77b4f839a

data/.gitignore

@@ -5,3 +5,6 @@ Gemfile.lock
 bin/*
 pkg/*
 vendor/*
+
+/.ruby-gemset
+/.ruby-version

data/README.md

@@ -48,22 +48,23 @@ to ensure proper evaluation:
     calculator.evaluate('(5 + 3) * 2')
     => 16
 
-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:
+A number of functions are also supported.  Okay, the number is currently five,
+but more will be added soon.  The current functions are
+`if`, `not`, `round`, `rounddown`, and `roundup`, 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:
+`round`, `rounddown`, and `roundup` 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
 
+`round` and `rounddown` round down, while `roundup` rounds up.
 
 If you're too lazy to be building calculator objects, there's a shortcut just
 for you:
@@ -72,12 +73,44 @@ for you:
     => 3.0
 
 
-SUPPORTED OPERATORS AND FUNCTIONS
+BUILT-IN OPERATORS AND FUNCTIONS
 ---------------------------------
 
-Math: `+ - * /`  
-Logic: `< > <= >= <> != = AND OR NOT`  
-Functions: `IF ROUND`
+Math: `+ - * / %`
+Logic: `< > <= >= <> != = AND OR`
+Functions: `IF NOT ROUND ROUNDDOWN ROUNDUP`
+
+
+EXTERNAL FUNCTIONS
+------------------
+
+See `spec/external_function_spec.rb` for examples of how to add your own functions.
+
+The short, dense version:
+
+Each rule for an external function consists of three parts: the function's name,
+a list of tokens describing its signature (parameters), and a lambda representing the
+function's body.
+
+The function name should be passed as a symbol (for example, `:func`).
+
+The token list should consist of `:numeric` or `:string` if a single value of the named
+type should be passed; `:non_group` or `:non_group_star` for grouped expressions.
+
+> (what's the difference? when would you use one instead of the other?)
+
+The function body should accept a list of parameters. Each function body will be passed
+a sequence of tokens, in order:
+
+1. The function's name
+2. A token representing the opening parenthesis
+3. Tokens representing the parameter values, separated by tokens representing the commas between parameters
+4. A token representing the closing parenthesis
+
+It should return a token (either `:numeric` or `:string`) representing the return value.
+
+Rules can be set individually using Calculator#add_rule, or en masse using Calculator#add_rules.
+
 
 THANKS
 ------

data/dentaku.gemspec

@@ -12,7 +12,6 @@ Gem::Specification.new do |s|
   s.description = <<-DESC
     Dentaku is a parser and evaluator for mathematical formulas
   DESC
-  s.license     = 'MIT'
 
   s.rubyforge_project = "dentaku"
 

data/lib/dentaku/binary_operation.rb

@@ -18,6 +18,8 @@ module Dentaku
       [:numeric, left.to_f / right.to_f]
     end
 
+    def mod;      [:numeric, left % right]; end
+
     def le;       [:logical, left <= right]; end
     def ge;       [:logical, left >= right]; end
     def lt;       [:logical, left <  right]; end

data/lib/dentaku/calculator.rb

@@ -1,4 +1,5 @@
 require 'dentaku/evaluator'
+require 'dentaku/rules'
 require 'dentaku/token'
 require 'dentaku/tokenizer'
 
@@ -10,6 +11,16 @@ module Dentaku
       clear
     end
 
+    def add_rule(new_rule)
+      Rules.add_rule new_rule
+      self
+    end
+
+    def add_rules(new_rules)
+      new_rules.each { | r | Rules.add_rule r }
+      self
+    end
+
     def evaluate(expression, data={})
       @tokenizer ||= Tokenizer.new
       @tokens = @tokenizer.tokenize(expression)

data/lib/dentaku/evaluator.rb

@@ -55,7 +55,13 @@ module Dentaku
 
     def evaluate_step(token_stream, start, length, evaluator)
       expr = token_stream.slice!(start, length)
-      token_stream.insert start, *self.send(evaluator, *expr)
+      if self.respond_to?(evaluator)
+        token_stream.insert start, *self.send(evaluator, *expr)
+      else
+        func = Rules.func(evaluator)
+        raise "unknown evaluator '#{evaluator.to_s}'" if func.nil?
+        token_stream.insert start, *(func.call(*expr))
+      end
     end
 
     def evaluate_group(*args)
@@ -68,6 +74,10 @@ module Dentaku
       Token.new(*operation.send(operator.value))
     end
 
+    def negate(_, token)
+      Token.new(token.category,token.value * -1)
+    end
+
     def expand_range(left, oper1, middle, oper2, right)
       [left, oper1, middle, Token.new(:combinator, :and), middle, oper2, right]
     end

data/lib/dentaku/rules.rb

@@ -3,8 +3,8 @@ require 'dentaku/token_matcher'
 
 module Dentaku
   class Rules
-    def self.each
-      @rules ||= [
+    def self.core_rules
+      [
         [ p(:if),         :if             ],
         [ p(:round_one),  :round          ],
         [ p(:round_two),  :round          ],
@@ -14,21 +14,49 @@ module Dentaku
 
         [ p(:group),      :evaluate_group ],
         [ p(:math_pow),   :apply          ],
+        [ p(:math_mod),   :apply          ],
         [ p(:math_mul),   :apply          ],
         [ p(:math_add),   :apply          ],
+        [ p(:negation),   :negate         ],
         [ p(:range_asc),  :expand_range   ],
         [ p(:range_desc), :expand_range   ],
         [ p(:num_comp),   :apply          ],
         [ p(:str_comp),   :apply          ],
         [ p(:combine),    :apply          ]
       ]
+    end
 
+    def self.each
+      @rules ||= core_rules
       @rules.each { |r| yield r }
     end
 
+    def self.add_rule(new_rule)
+      @rules ||= core_rules
+      @funcs ||= {}
+      name = new_rule[:name].to_sym
+
+      ## rules need to be added to the beginning of @rules; for precedence?
+      @rules.unshift [
+        [
+          TokenMatcher.send(name),
+          t(:open),
+          *pattern(*new_rule[:tokens]),
+          t(:close),
+        ],
+        name
+      ]
+      @funcs[name] = new_rule[:body]
+    end
+
+    def self.func(name)
+      @funcs ||= {}
+      @funcs[name]
+    end
+
     def self.t(name)
       @matchers ||= [
-        :numeric, :string, :addsub, :muldiv, :pow,
+        :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
         :comparator, :comp_gt, :comp_lt,
         :open, :close, :comma,
         :non_group, :non_group_star,
@@ -47,6 +75,8 @@ module Dentaku
         math_add:   pattern(:numeric, :addsub,         :numeric),
         math_mul:   pattern(:numeric, :muldiv,         :numeric),
         math_pow:   pattern(:numeric, :pow,            :numeric),
+        math_mod:   pattern(:numeric, :mod,            :numeric),
+        negation:   pattern(:subtract, :numeric),
         range_asc:  pattern(:numeric, :comp_lt,        :numeric,  :comp_lt, :numeric),
         range_desc: pattern(:numeric, :comp_gt,        :numeric,  :comp_gt, :numeric),
         num_comp:   pattern(:numeric, :comparator,     :numeric),

data/lib/dentaku/token_matcher.rb

@@ -61,8 +61,10 @@ module Dentaku
     def self.numeric;        new(:numeric);                        end
     def self.string;         new(:string);                         end
     def self.addsub;         new(:operator, [:add, :subtract]);    end
+    def self.subtract;       new(:operator, :subtract);            end
     def self.muldiv;         new(:operator, [:multiply, :divide]); end
     def self.pow;            new(:operator, :pow);                 end
+    def self.mod;            new(:operator, :mod);                 end
     def self.comparator;     new(:comparator);                     end
     def self.comp_gt;        new(:comparator, [:gt, :ge]);         end
     def self.comp_lt;        new(:comparator, [:lt, :le]);         end
@@ -78,6 +80,16 @@ module Dentaku
     def self.not;            new(:function, :not);                 end
     def self.non_group;      new(:grouping).invert;                end
     def self.non_group_star; new(:grouping).invert.star;           end
+
+
+    def self.method_missing(name, *args, &block)
+      new(:function, name)
+    end
+
+    def self.respond_to_missing?(name, include_priv)
+      true
+    end
+
   end
 end
 

data/lib/dentaku/token_scanner.rb

@@ -52,8 +52,8 @@ module Dentaku
       end
 
       def operator
-        names = { pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/' }.invert
-        new(:operator, '\^|\+|-|\*|\/', lambda { |raw| names[raw] })
+        names = { pow: '^', add: '+', subtract: '-', multiply: '*', divide: '/', mod: '%' }.invert
+        new(:operator, '\^|\+|-|\*|\/|%', lambda { |raw| names[raw] })
       end
 
       def grouping
@@ -72,7 +72,7 @@ module Dentaku
       end
 
       def function
-        new(:function, '(if|round(up|down)?|not)\b', lambda {|raw| raw.strip.downcase.to_sym })
+        new(:function, '(\w+\s*(?=\())', lambda {|raw| raw.strip.downcase.to_sym })
       end
 
       def identifier

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "0.2.12"
+  VERSION = "0.2.13"
 end

data/spec/binary_operation_spec.rb

@@ -38,4 +38,8 @@ describe Dentaku::BinaryOperation do
     logical.and.should eq [:logical, false]
     logical.or.should  eq [:logical, true]
   end
+
+  it 'mods two numbers' do
+    operation.mod.should eq [:numeric, 2%3]
+  end
 end

data/spec/calculator_spec.rb

@@ -72,10 +72,17 @@ describe Dentaku::Calculator do
     calculator.evaluate('some_boolean AND 7 > 5', :some_boolean => true).should be_true
     calculator.evaluate('some_boolean AND 7 < 5', :some_boolean => true).should be_false
     calculator.evaluate('some_boolean AND 7 > 5', :some_boolean => false).should be_false
+
+    calculator.evaluate('some_boolean OR 7 > 5', :some_boolean => true).should be_true
+    calculator.evaluate('some_boolean OR 7 < 5', :some_boolean => true).should be_true
+    calculator.evaluate('some_boolean OR 7 < 5', :some_boolean => false).should be_false
+
   end
 
   describe 'functions' do
     it 'should include IF' do
+      calculator.evaluate('if(foo < 8, 10, 20)', :foo => 2).should eq(10)
+      calculator.evaluate('if(foo < 8, 10, 20)', :foo => 9).should eq(20)
       calculator.evaluate('if (foo < 8, 10, 20)', :foo => 2).should eq(10)
       calculator.evaluate('if (foo < 8, 10, 20)', :foo => 9).should eq(20)
     end
@@ -87,5 +94,13 @@ describe Dentaku::Calculator do
 
       calculator.evaluate('ROUND(apples * 0.93)', { :apples => 10 }).should eq(9)
     end
+
+    it 'should include NOT' do
+      calculator.evaluate('NOT(some_boolean)', :some_boolean => true).should be_false
+      calculator.evaluate('NOT(some_boolean)', :some_boolean => false).should be_true
+
+      calculator.evaluate('NOT(some_boolean) AND 7 > 5', :some_boolean => true).should be_false
+      calculator.evaluate('NOT(some_boolean) OR 7 < 5', :some_boolean => false).should be_true
+    end
   end
 end

data/spec/evaluator_spec.rb

@@ -41,6 +41,11 @@ describe Dentaku::Evaluator do
       evaluator.evaluate_step(stream, 0, 5, :evaluate_group).should eq(expected)
     end
 
+    it 'supports unary minus' do
+      evaluator.evaluate(token_stream(:subtract, 1)).should eq(-1)
+      evaluator.evaluate(token_stream(1, :subtract, :subtract, 1)).should eq(2)
+    end
+
     describe 'maths' do
       it 'should perform addition' do
         evaluator.evaluate(token_stream(1, :add, 1)).should eq(2)
@@ -48,6 +53,7 @@ describe Dentaku::Evaluator do
 
       it 'should respect order of precedence' do
         evaluator.evaluate(token_stream(1, :add, 1, :multiply, 5)).should eq(6)
+        evaluator.evaluate(token_stream(2, :add, 10, :mod, 2)).should eq(2)
       end
 
       it 'should respect explicit grouping' do

data/spec/external_function_spec.rb

@@ -0,0 +1,44 @@
+require 'dentaku/calculator'
+
+describe Dentaku::Calculator do
+  describe 'functions' do
+    describe 'external functions' do
+
+      let(:with_external_funcs) do
+        c = described_class.new
+
+        rule = { :name => :now, :tokens => [], :body => ->(*args) { Dentaku::Token.new(:string, Time.now.to_s) } }
+        c.add_rule rule
+
+        new_rules = [
+          {
+            :name => :exp,
+            :tokens => [ :non_group_star, :comma, :non_group_star ],
+            :body => ->(*args) do
+              ## first one is function name
+              ## second one is open parenthesis
+              ## last one is close parenthesis
+              ## all others are commas
+              _, _, mantissa, _, exponent, _ = args
+              Dentaku::Token.new(:numeric, (mantissa.value ** exponent.value))
+            end
+          },
+        ]
+
+        c.add_rules new_rules
+      end
+
+      it 'should include NOW' do
+        now = with_external_funcs.evaluate('NOW()')
+        now.should_not be_nil
+        now.should_not be_empty
+      end
+
+      it 'should include EXP' do
+        with_external_funcs.evaluate('EXP(2,3)').should eq(8)
+        with_external_funcs.evaluate('EXP(3,2)').should eq(9)
+        with_external_funcs.evaluate('EXP(mantissa,exponent)', :mantissa => 2, :exponent => 4).should eq(16)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ def type_for(value)
   case value
   when Numeric
     :numeric
-  when :add, :subtract, :multiply, :divide
+  when :add, :subtract, :multiply, :divide, :mod
     :operator
   when :open, :close, :comma
     :grouping

metadata

@@ -1,51 +1,45 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 0.2.12
-  prerelease: 
+  version: 0.2.13
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-25 00:00:00.000000000 Z
+date: 2014-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! '    Dentaku is a parser and evaluator for mathematical formulas
-
-'
+description: |2
+      Dentaku is a parser and evaluator for mathematical formulas
 email:
 - rubysolo@gmail.com
 executables: []
@@ -55,7 +49,6 @@ files:
 - .gitignore
 - .travis.yml
 - Gemfile
-- MIT-LICENSE.txt
 - README.md
 - Rakefile
 - dentaku.gemspec
@@ -73,41 +66,41 @@ files:
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb
+- spec/external_function_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:
-- MIT
+licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: dentaku
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A formula language parser and evaluator
 test_files:
 - spec/binary_operation_spec.rb
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb
+- spec/external_function_spec.rb
 - spec/spec_helper.rb
 - spec/token_matcher_spec.rb
 - spec/token_scanner_spec.rb

data/MIT-LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2012 Solomon White
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.