dentaku 1.2.4 → 1.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b6c2a647d615b07bb92995438da601259cb87f3
-  data.tar.gz: 75c685525c0eb619726c0d03ded7401573eaaf33
+  metadata.gz: cca185ca8ad75d5c0c0cd13241ad8356a6d046f0
+  data.tar.gz: 469a8af2de92efdb3b75297ec7de268e6b066492
 SHA512:
-  metadata.gz: 7035e118512d9c98dbcc31cb510358e8ca5fee3b98b9bb2242671a7ede8c8ae0c1e4028869367615b9c91a9ff82cece3c13e70032547ef432539c9d0b8986be1
-  data.tar.gz: fb40309c2d88b7036462a4acb372753350b6655a519fa165a0f534a5464a50088cd53aa908c33e59c06bb957e69305190bd33361805d6346961c8a04126a39a7
+  metadata.gz: b0348e2c7b06c318ab67f88bfddc5f6c6e5ac44efdaeacd53d35a23764f3d961530524c7929673ce3737375f0b93671dedadccb7ab5d0d363f4916b218ce0b30
+  data.tar.gz: 36043cafe22a9f2dd60f926a13832dc3175e3f7000c6eac081925d234501f287c6289adeed51b45334d9c7353a4a29a5458b7414cd612ecbb05039e852590914

data/.travis.yml

@@ -4,5 +4,8 @@ rvm:
   - 2.0.0
   - 2.1.0
   - 2.1.1
+  - 2.2.0
+  - 2.2.1
+  - 2.2.2
   - jruby-19mode
   - rbx-2

data/lib/dentaku/calculator.rb

@@ -1,25 +1,26 @@
 require 'dentaku/evaluator'
 require 'dentaku/exceptions'
 require 'dentaku/expression'
-require 'dentaku/rules'
+require 'dentaku/rule_set'
 require 'dentaku/token'
 require 'dentaku/dependency_resolver'
 
 module Dentaku
   class Calculator
-    attr_reader :result
+    attr_reader :result, :rule_set
 
     def initialize
       clear
+      @rule_set = RuleSet.new
     end
 
     def add_function(fn)
-      Rules.add_function(fn)
+      rule_set.add_function(fn)
       self
     end
 
     def add_functions(fns)
-      fns.each { |fn| Rules.add_function(fn) }
+      fns.each { |fn| add_function(fn) }
       self
     end
 
@@ -33,7 +34,7 @@ module Dentaku
       store(data) do
         expr = Expression.new(expression, @memory)
         raise UnboundVariableError.new(expr.identifiers) if expr.unbound?
-        @evaluator ||= Evaluator.new
+        @evaluator ||= Evaluator.new(rule_set)
         @result = @evaluator.evaluate(expr.tokens)
       end
     end

data/lib/dentaku/dependency_resolver.rb

@@ -18,7 +18,7 @@ module Dentaku
     end
 
     def tsort_each_child(node, &block)
-      @vars_to_deps[node.to_s].each(&block)
+      @vars_to_deps.fetch(node.to_s, []).each(&block)
     end
   end
 end

data/lib/dentaku/evaluator.rb

@@ -1,8 +1,14 @@
-require 'dentaku/rules'
+require 'dentaku/rule_set'
 require 'dentaku/binary_operation'
 
 module Dentaku
   class Evaluator
+    attr_reader :rule_set
+
+    def initialize(rule_set)
+      @rule_set = rule_set
+    end
+
     def evaluate(tokens)
       evaluate_token_stream(tokens).value
     end
@@ -24,7 +30,8 @@ module Dentaku
 
     def match_rule_pattern(tokens)
       matched = false
-      Rules.each do |pattern, evaluator|
+
+      rule_set.filter(tokens).each do |pattern, evaluator|
         pos, match = find_rule_match(pattern, tokens)
 
         if pos
@@ -71,7 +78,7 @@ module Dentaku
     end
 
     def user_defined_function(evaluator, tokens)
-      function = Rules.func(evaluator)
+      function = rule_set.function(evaluator)
       raise "unknown function '#{ evaluator }'" unless function
 
       arguments = extract_arguments_from_function_call(tokens).map { |t| t.value }

data/lib/dentaku/rule_set.rb

@@ -0,0 +1,153 @@
+require 'dentaku/external_function'
+
+module Dentaku
+  class RuleSet
+    def initialize
+      self.custom_rules = []
+      self.custom_functions = {}
+    end
+
+    def rules
+      custom_rules + core_rules
+    end
+
+    def each
+      rules.each { |r| yield r }
+    end
+
+    def add_function(function)
+      fn = ExternalFunction.new(function[:name], function[:type], function[:signature], function[:body])
+
+      custom_rules.push [
+        function_token_matchers(fn.name, *fn.tokens),
+        fn.name
+      ]
+
+      custom_functions[fn.name] = fn
+      clear_cache
+    end
+
+    def filter(tokens)
+      categories = tokens.map(&:category).uniq
+      values     = tokens.map { |token| token.value.is_a?(Numeric) ? 0 : token.value }
+                         .reject { |token| [:fopen, :close].include?(token) }
+      select(categories, values)
+    end
+
+    def select(categories, values)
+      @cache ||= {}
+      return @cache[categories + values] if @cache.has_key?(categories + values)
+
+      @cache[categories + values] = rules.select do |pattern, _|
+        categories_intersection = matcher_categories[pattern] & categories
+        values_intersection     = matcher_values[pattern] & values
+        categories_intersection.length > 0 && (values_intersection.length > 0 || matcher_values[pattern].empty?)
+      end
+    end
+
+    def function(name)
+      custom_functions.fetch(name)
+    end
+
+    private
+    attr_accessor :custom_rules, :custom_functions
+
+    def matcher_categories
+      @matcher_categories ||= rules.each_with_object({}) do |(pattern, _), h|
+        h[pattern] = pattern.map(&:categories).reduce { |a,b| a.merge(b) }.keys
+      end
+    end
+
+    def matcher_values
+      @matcher_values ||= rules.each_with_object({}) do |(pattern, _), h|
+        h[pattern] = pattern.map(&:values).reduce { |a,b| a.merge(b) }.keys
+      end
+    end
+
+    def clear_cache
+      @cache = nil
+      @matcher_categories = nil
+      @matcher_values = nil
+    end
+
+    def core_rules
+      @core_rules ||= [
+        [ pattern(:if),           :if             ],
+        [ pattern(:round),        :round          ],
+        [ pattern(:roundup),      :round_int      ],
+        [ pattern(:rounddown),    :round_int      ],
+        [ pattern(:not),          :not            ],
+
+        [ pattern(:group),        :evaluate_group ],
+        [ pattern(:start_neg),    :negate         ],
+        [ pattern(:math_pow),     :apply          ],
+        [ pattern(:math_neg_pow), :pow_negate     ],
+        [ pattern(:math_mod),     :apply          ],
+        [ pattern(:math_mul),     :apply          ],
+        [ pattern(:math_neg_mul), :mul_negate     ],
+        [ pattern(:math_add),     :apply          ],
+        [ pattern(:percentage),   :percentage     ],
+        [ pattern(:negation),     :negate         ],
+        [ pattern(:range_asc),    :expand_range   ],
+        [ pattern(:range_desc),   :expand_range   ],
+        [ pattern(:num_comp),     :apply          ],
+        [ pattern(:str_comp),     :apply          ],
+        [ pattern(:combine),      :apply          ]
+      ]
+    end
+
+    def pattern(name)
+      @patterns ||= {
+        group:        token_matchers(:open,     :non_group_star, :close),
+        math_add:     token_matchers(:numeric,  :addsub,         :numeric),
+        math_mul:     token_matchers(:numeric,  :muldiv,         :numeric),
+        math_neg_mul: token_matchers(:numeric,  :muldiv,         :subtract, :numeric),
+        math_pow:     token_matchers(:numeric,  :pow,            :numeric),
+        math_neg_pow: token_matchers(:numeric,  :pow,            :subtract, :numeric),
+        math_mod:     token_matchers(:numeric,  :mod,            :numeric),
+        negation:     token_matchers(:subtract, :numeric),
+        start_neg:    token_matchers(:anchored_minus, :numeric),
+        percentage:   token_matchers(:numeric,  :mod),
+        range_asc:    token_matchers(:numeric,  :comp_lt,        :numeric,  :comp_lt, :numeric),
+        range_desc:   token_matchers(:numeric,  :comp_gt,        :numeric,  :comp_gt, :numeric),
+        num_comp:     token_matchers(:numeric,  :comparator,     :numeric),
+        str_comp:     token_matchers(:string,   :comparator,     :string),
+        combine:      token_matchers(:logical,  :combinator,     :logical),
+
+        if:           function_token_matchers(:if,        :non_group,      :comma, :non_group, :comma, :non_group),
+        round:        function_token_matchers(:round,     :arguments),
+        roundup:      function_token_matchers(:roundup,   :arguments),
+        rounddown:    function_token_matchers(:rounddown, :arguments),
+        not:          function_token_matchers(:not,       :arguments)
+      }
+
+      @patterns[name]
+    end
+
+    def token_matchers(*symbols)
+      symbols.map { |s| matcher(s) }
+    end
+
+    def function_token_matchers(function_name, *symbols)
+      token_matchers(:fopen, *symbols, :close).unshift(
+        TokenMatcher.send(function_name)
+      )
+    end
+
+    def matcher(symbol)
+      @matchers ||= [
+        :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
+        :comparator, :comp_gt, :comp_lt, :fopen, :open, :close, :comma,
+        :non_close_plus, :non_group, :non_group_star, :arguments,
+        :logical, :combinator, :if, :round, :roundup, :rounddown, :not,
+        :anchored_minus, :math_neg_pow, :math_neg_mul
+      ].each_with_object({}) do |name, matchers|
+        matchers[name] = TokenMatcher.send(name)
+      end
+
+      @matchers.fetch(symbol) do
+        raise "Unknown token symbol #{ symbol }"
+      end
+    end
+  end
+end

data/lib/dentaku/token_matcher.rb

@@ -2,7 +2,7 @@ require 'dentaku/token'
 
 module Dentaku
   class TokenMatcher
-    attr_reader :children
+    attr_reader :children, :categories, :values
 
     def initialize(categories=nil, values=nil, children=[])
       # store categories and values as hash to optimize key lookup, h/t @jan-mangs

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "1.2.4"
+  VERSION = "1.2.5"
 end

data/spec/benchmark.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'dentaku'
+require 'allocation_stats'
+require 'benchmark'
+
+puts "Dentaku version #{Dentaku::VERSION}"
+puts "Ruby version #{RUBY_VERSION}"
+
+with_duplicate_variables = [
+  "R1+R2+R3+R4+R5+R6",
+  {"R1"=>100000, "R2"=>0, "R3"=>200000, "R4"=>0, "R5"=>500000, "R6"=>0, "r1"=>100000, "r2"=>0, "r3"=>200000, "r4"=>0, "r5"=>500000, "r6"=>0}
+]
+
+without_duplicate_variables = [
+  "R1+R2+R3+R4+R5+R6",
+  {"R1"=>100000, "R2"=>0, "R3"=>200000, "R4"=>0, "R5"=>500000, "R6"=>0}
+]
+
+def test(args, custom_function: true)
+  calls = [ args ] * 100
+
+  10.times do |i|
+
+    stats = nil
+    bm = Benchmark.measure do
+      stats = AllocationStats.trace do
+
+        calls.each do |formule, bound|
+
+          calculator = Dentaku::Calculator.new
+
+          if custom_function
+            calculator.add_function(
+              name:      :sum,
+              type:      :numeric,
+              signature: [:arguments],
+              body:      ->(numbers) { numbers.inject(:+) },
+            )
+          end
+
+          calculator.evaluate(formule, bound)
+        end
+      end
+    end
+
+    puts "  run #{i}: #{bm.total}"
+    puts stats.allocations(alias_paths: true).group_by(:sourcefile, :class).to_text
+  end
+end
+
+case ARGV[0]
+when '1'
+  puts "with duplicate (downcased) variables, with a custom function:"
+  test(with_duplicate_variables, custom_function: true)
+
+when '2'
+  puts "with duplicate (downcased) variables, without a custom function:"
+  test(with_duplicate_variables, custom_function: false)
+
+when '3'
+  puts "without duplicate (downcased) variables, with a custom function:"
+  test(without_duplicate_variables, custom_function: true)
+
+when '4'
+  puts "with duplicate (downcased) variables, without a custom function:"
+  test(without_duplicate_variables, custom_function: false)
+
+else
+  puts "select a run option (1-4)"
+end

data/spec/calculator_spec.rb

@@ -2,7 +2,7 @@ require 'dentaku/calculator'
 
 describe Dentaku::Calculator do
   let(:calculator)  { described_class.new }
-  let(:with_memory) { described_class.new.store(:apples => 3) }
+  let(:with_memory) { described_class.new.store(apples: 3) }
 
   it 'evaluates an expression' do
     expect(calculator.evaluate('7+3')).to eq(10)
@@ -20,8 +20,8 @@ describe Dentaku::Calculator do
     expect(calculator.evaluate('(-2 + 3) - 1')).to eq(0)
     expect(calculator.evaluate('(-2 - 3) - 1')).to eq(-6)
     expect(calculator.evaluate('1 + -2 ^ 2')).to eq(-3)
-    expect(calculator.evaluate('3 + -num', :num => 2)).to eq(1)
-    expect(calculator.evaluate('-num + 3', :num => 2)).to eq(1)
+    expect(calculator.evaluate('3 + -num', num: 2)).to eq(1)
+    expect(calculator.evaluate('-num + 3', num: 2)).to eq(1)
     expect(calculator.evaluate('10 ^ 2')).to eq(100)
     expect(calculator.evaluate('0 * 10 ^ -5')).to eq(0)
     expect(calculator.evaluate('3 + 0 * -3')).to eq(3)
@@ -34,7 +34,7 @@ describe Dentaku::Calculator do
     it { expect(with_memory.clear).to be_empty }
 
     it 'discards local values' do
-      expect(calculator.evaluate('pears * 2', :pears => 5)).to eq(10)
+      expect(calculator.evaluate('pears * 2', pears: 5)).to eq(10)
       expect(calculator).to be_empty
     end
 
@@ -54,6 +54,7 @@ describe Dentaku::Calculator do
     it "finds dependencies in a generic statement" do
       expect(calculator.dependencies("bob + dole / 3")).to eq(['bob', 'dole'])
     end
+
     it "doesn't consider variables in memory as dependencies" do
       expect(with_memory.dependencies("apples + oranges")).to eq(['oranges'])
     end
@@ -81,6 +82,11 @@ describe Dentaku::Calculator do
         calculator.solve!(health: "happiness", happiness: "health")
       end.to raise_error (TSort::Cyclic)
     end
+
+    it 'is case-insensitive' do
+      result = with_memory.solve!(total_fruit: "Apples + pears", pears: 10)
+      expect(result[:total_fruit]).to eq 13
+    end
   end
 
   it 'evaluates a statement with no variables' do
@@ -100,54 +106,54 @@ describe Dentaku::Calculator do
   end
 
   it 'evaluates unbound statements given a binding in memory' do
-    expect(calculator.evaluate('foo * 1.5', :foo => 2)).to eq(3)
-    expect(calculator.bind(:monkeys => 3).evaluate('monkeys < 7')).to be_truthy
+    expect(calculator.evaluate('foo * 1.5', foo: 2)).to eq(3)
+    expect(calculator.bind(monkeys: 3).evaluate('monkeys < 7')).to be_truthy
     expect(calculator.evaluate('monkeys / 1.5')).to eq(2)
   end
 
   it 'rebinds for each evaluation' do
-    expect(calculator.evaluate('foo * 2', :foo => 2)).to eq(4)
-    expect(calculator.evaluate('foo * 2', :foo => 4)).to eq(8)
+    expect(calculator.evaluate('foo * 2', foo: 2)).to eq(4)
+    expect(calculator.evaluate('foo * 2', foo: 4)).to eq(8)
   end
 
   it 'accepts strings or symbols for binding keys' do
-    expect(calculator.evaluate('foo * 2', :foo => 2)).to eq(4)
+    expect(calculator.evaluate('foo * 2', foo: 2)).to eq(4)
     expect(calculator.evaluate('foo * 2', 'foo' => 4)).to eq(8)
   end
 
   it 'accepts digits in identifiers' do
-    expect(calculator.evaluate('foo1 * 2', :foo1 => 2)).to eq(4)
+    expect(calculator.evaluate('foo1 * 2', foo1: 2)).to eq(4)
     expect(calculator.evaluate('foo1 * 2', 'foo1' => 4)).to eq(8)
     expect(calculator.evaluate('1foo * 2', '1foo' => 2)).to eq(4)
-    expect(calculator.evaluate('fo1o * 2', :fo1o => 4)).to eq(8)
+    expect(calculator.evaluate('fo1o * 2', fo1o: 4)).to eq(8)
   end
 
   it 'compares string literals with string variables' do
-    expect(calculator.evaluate('fruit = "apple"', :fruit => 'apple')).to be_truthy
-    expect(calculator.evaluate('fruit = "apple"', :fruit => 'pear')).to be_falsey
+    expect(calculator.evaluate('fruit = "apple"', fruit: 'apple')).to be_truthy
+    expect(calculator.evaluate('fruit = "apple"', fruit: 'pear')).to be_falsey
   end
 
   it 'performs case-sensitive comparison' do
-    expect(calculator.evaluate('fruit = "Apple"', :fruit => 'apple')).to be_falsey
-    expect(calculator.evaluate('fruit = "Apple"', :fruit => 'Apple')).to be_truthy
+    expect(calculator.evaluate('fruit = "Apple"', fruit: 'apple')).to be_falsey
+    expect(calculator.evaluate('fruit = "Apple"', fruit: 'Apple')).to be_truthy
   end
 
   it 'allows binding logical values' do
-    expect(calculator.evaluate('some_boolean AND 7 > 5', :some_boolean => true)).to be_truthy
-    expect(calculator.evaluate('some_boolean AND 7 < 5', :some_boolean => true)).to be_falsey
-    expect(calculator.evaluate('some_boolean AND 7 > 5', :some_boolean => false)).to be_falsey
+    expect(calculator.evaluate('some_boolean AND 7 > 5', some_boolean: true)).to be_truthy
+    expect(calculator.evaluate('some_boolean AND 7 < 5', some_boolean: true)).to be_falsey
+    expect(calculator.evaluate('some_boolean AND 7 > 5', some_boolean: false)).to be_falsey
 
-    expect(calculator.evaluate('some_boolean OR 7 > 5', :some_boolean => true)).to be_truthy
-    expect(calculator.evaluate('some_boolean OR 7 < 5', :some_boolean => true)).to be_truthy
-    expect(calculator.evaluate('some_boolean OR 7 < 5', :some_boolean => false)).to be_falsey
+    expect(calculator.evaluate('some_boolean OR 7 > 5', some_boolean: true)).to be_truthy
+    expect(calculator.evaluate('some_boolean OR 7 < 5', some_boolean: true)).to be_truthy
+    expect(calculator.evaluate('some_boolean OR 7 < 5', some_boolean: false)).to be_falsey
   end
 
   describe 'functions' do
     it 'include IF' do
-      expect(calculator.evaluate('if(foo < 8, 10, 20)', :foo => 2)).to eq(10)
-      expect(calculator.evaluate('if(foo < 8, 10, 20)', :foo => 9)).to eq(20)
-      expect(calculator.evaluate('if (foo < 8, 10, 20)', :foo => 2)).to eq(10)
-      expect(calculator.evaluate('if (foo < 8, 10, 20)', :foo => 9)).to eq(20)
+      expect(calculator.evaluate('if(foo < 8, 10, 20)', foo: 2)).to eq(10)
+      expect(calculator.evaluate('if(foo < 8, 10, 20)', foo: 9)).to eq(20)
+      expect(calculator.evaluate('if (foo < 8, 10, 20)', foo: 2)).to eq(10)
+      expect(calculator.evaluate('if (foo < 8, 10, 20)', foo: 9)).to eq(20)
     end
 
     it 'include ROUND' do
@@ -155,22 +161,22 @@ describe Dentaku::Calculator do
       expect(calculator.evaluate('round(8.8)')).to eq(9)
       expect(calculator.evaluate('round(8.75, 1)')).to eq(BigDecimal.new('8.8'))
 
-      expect(calculator.evaluate('ROUND(apples * 0.93)', { :apples => 10 })).to eq(9)
+      expect(calculator.evaluate('ROUND(apples * 0.93)', { apples: 10 })).to eq(9)
     end
 
     it 'include NOT' do
-      expect(calculator.evaluate('NOT(some_boolean)', :some_boolean => true)).to be_falsey
-      expect(calculator.evaluate('NOT(some_boolean)', :some_boolean => false)).to be_truthy
+      expect(calculator.evaluate('NOT(some_boolean)', some_boolean: true)).to be_falsey
+      expect(calculator.evaluate('NOT(some_boolean)', some_boolean: false)).to be_truthy
 
-      expect(calculator.evaluate('NOT(some_boolean) AND 7 > 5', :some_boolean => true)).to be_falsey
-      expect(calculator.evaluate('NOT(some_boolean) OR 7 < 5', :some_boolean => false)).to be_truthy
+      expect(calculator.evaluate('NOT(some_boolean) AND 7 > 5', some_boolean: true)).to be_falsey
+      expect(calculator.evaluate('NOT(some_boolean) OR 7 < 5', some_boolean: false)).to be_truthy
     end
 
     it 'evaluates functions with negative numbers' do
       expect(calculator.evaluate('if (-1 < 5, -1, 5)')).to eq(-1)
       expect(calculator.evaluate('if (-1 = -1, -1, 5)')).to eq(-1)
       expect(calculator.evaluate('round(-1.23, 1)')).to eq(BigDecimal.new('-1.2'))
-      expect(calculator.evaluate('NOT(some_boolean) AND -1 > 3', :some_boolean => true)).to be_falsey
+      expect(calculator.evaluate('NOT(some_boolean) AND -1 > 3', some_boolean: true)).to be_falsey
     end
   end
 end

data/spec/dentaku_spec.rb

@@ -6,7 +6,7 @@ describe Dentaku do
   end
 
   it 'binds values to variables' do
-    expect(Dentaku('oranges > 7', {:oranges => 10})).to be_truthy
+    expect(Dentaku('oranges > 7', oranges: 10)).to be_truthy
   end
 
   it 'evaulates a nested function' do

data/spec/evaluator_spec.rb

@@ -2,7 +2,8 @@ require 'spec_helper'
 require 'dentaku/evaluator'
 
 describe Dentaku::Evaluator do
-  let(:evaluator) { Dentaku::Evaluator.new }
+  let(:rule_set)  { Dentaku::RuleSet.new }
+  let(:evaluator) { Dentaku::Evaluator.new(rule_set) }
 
   describe 'rule scanning' do
     it 'finds a matching rule' do
@@ -81,7 +82,7 @@ describe Dentaku::Evaluator do
 
     describe 'find_rule_match' do
       it 'matches a function call' do
-        if_pattern, _ = *Dentaku::Rules.core_rules.first
+        if_pattern, _ = *rule_set.rules.first
         position, tokens = evaluator.find_rule_match(if_pattern, token_stream(:if, :fopen, true, :comma, 1, :comma, 2, :close))
         expect(position).to eq 0
         expect(tokens.length).to eq 8

data/spec/rule_set_spec.rb

@@ -0,0 +1,43 @@
+require 'dentaku/rule_set'
+
+describe Dentaku::RuleSet do
+  subject { described_class.new }
+
+  it 'yields core rules' do
+    functions = []
+    subject.each { |pattern, function| functions << function }
+    expect(functions).to eq [:if,
+                             :round,
+                             :round_int,
+                             :round_int,
+                             :not,
+                             :evaluate_group,
+                             :negate,
+                             :apply,
+                             :pow_negate,
+                             :apply,
+                             :apply,
+                             :mul_negate,
+                             :apply,
+                             :percentage,
+                             :negate,
+                             :expand_range,
+                             :expand_range,
+                             :apply,
+                             :apply,
+                             :apply,
+                            ]
+  end
+
+  it 'adds custom function patterns' do
+    functions = []
+    subject.add_function(
+      name:      :min,
+      type:      :numeric,
+      signature: [ :arguments ],
+      body:      ->(*args) { args.min }
+    )
+    subject.each { |pattern, function| functions << function }
+    expect(functions).to include('min')
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 1.2.4
+  version: 1.2.5
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -60,18 +60,20 @@ files:
 - lib/dentaku/exceptions.rb
 - lib/dentaku/expression.rb
 - lib/dentaku/external_function.rb
-- lib/dentaku/rules.rb
+- lib/dentaku/rule_set.rb
 - lib/dentaku/token.rb
 - lib/dentaku/token_matcher.rb
 - lib/dentaku/token_scanner.rb
 - lib/dentaku/tokenizer.rb
 - lib/dentaku/version.rb
+- spec/benchmark.rb
 - spec/binary_operation_spec.rb
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb
 - spec/expression_spec.rb
 - spec/external_function_spec.rb
+- spec/rule_set_spec.rb
 - spec/spec_helper.rb
 - spec/token_matcher_spec.rb
 - spec/token_scanner_spec.rb
@@ -97,19 +99,22 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: dentaku
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A formula language parser and evaluator
 test_files:
+- spec/benchmark.rb
 - spec/binary_operation_spec.rb
 - spec/calculator_spec.rb
 - spec/dentaku_spec.rb
 - spec/evaluator_spec.rb
 - spec/expression_spec.rb
 - spec/external_function_spec.rb
+- spec/rule_set_spec.rb
 - spec/spec_helper.rb
 - spec/token_matcher_spec.rb
 - spec/token_scanner_spec.rb
 - spec/token_spec.rb
 - spec/tokenizer_spec.rb
+has_rdoc: 

data/lib/dentaku/rules.rb

@@ -1,115 +0,0 @@
-require 'dentaku/external_function'
-require 'dentaku/token'
-require 'dentaku/token_matcher'
-
-module Dentaku
-  class Rules
-    def self.core_rules
-      [
-        [ p(:if),           :if             ],
-        [ p(:round),        :round          ],
-        [ p(:roundup),      :round_int      ],
-        [ p(:rounddown),    :round_int      ],
-        [ p(:not),          :not            ],
-
-        [ p(:group),        :evaluate_group ],
-        [ p(:start_neg),    :negate         ],
-        [ p(:math_pow),     :apply          ],
-        [ p(:math_neg_pow), :pow_negate     ],
-        [ p(:math_mod),     :apply          ],
-        [ p(:math_mul),     :apply          ],
-        [ p(:math_neg_mul), :mul_negate     ],
-        [ p(:math_add),     :apply          ],
-        [ p(:percentage),   :percentage     ],
-        [ 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_function(f)
-      ext = ExternalFunction.new(f[:name], f[:type], f[:signature], f[:body])
-
-      @rules ||= core_rules
-      @funcs ||= {}
-
-      ## rules need to be added to the beginning of @rules for precedence
-      @rules.unshift [
-        [
-          TokenMatcher.send(ext.name),
-          t(:fopen),
-          *pattern(*ext.tokens),
-          t(:close)
-        ],
-        ext.name
-      ]
-      @funcs[ext.name] = ext
-    end
-
-    def self.func(name)
-      @funcs ||= {}
-      @funcs.fetch(name)
-    end
-
-    def self.t(name)
-      @matchers ||= generate_matchers
-      @matchers.fetch(name)
-    end
-
-    def self.generate_matchers
-      [
-        :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
-        :comparator, :comp_gt, :comp_lt, :fopen, :open, :close, :comma,
-        :non_close_plus, :non_group, :non_group_star, :arguments,
-        :logical, :combinator, :if, :round, :roundup, :rounddown, :not,
-        :anchored_minus, :math_neg_pow, :math_neg_mul
-      ].each_with_object({}) do |name, matchers|
-        matchers[name] = TokenMatcher.send(name)
-      end
-    end
-
-    def self.p(name)
-      @patterns ||= {
-        group:        pattern(:open,     :non_group_star, :close),
-        math_add:     pattern(:numeric,  :addsub,         :numeric),
-        math_mul:     pattern(:numeric,  :muldiv,         :numeric),
-        math_neg_mul: pattern(:numeric,  :muldiv,         :subtract, :numeric),
-        math_pow:     pattern(:numeric,  :pow,            :numeric),
-        math_neg_pow: pattern(:numeric,  :pow,            :subtract, :numeric),
-        math_mod:     pattern(:numeric,  :mod,            :numeric),
-        negation:     pattern(:subtract, :numeric),
-        start_neg:    pattern(:anchored_minus, :numeric),
-        percentage:   pattern(:numeric,  :mod),
-        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),
-        str_comp:     pattern(:string,   :comparator,     :string),
-        combine:      pattern(:logical,  :combinator,     :logical),
-
-        if:           func_pattern(:if,        :non_group,      :comma, :non_group, :comma, :non_group),
-        round:        func_pattern(:round,     :arguments),
-        roundup:      func_pattern(:roundup,   :arguments),
-        rounddown:    func_pattern(:rounddown, :arguments),
-        not:          func_pattern(:not,       :arguments)
-      }
-
-      @patterns[name]
-    end
-
-    def self.pattern(*symbols)
-      symbols.map { |s| t(s) }
-    end
-
-    def self.func_pattern(func, *tokens)
-      pattern(func, :fopen, *tokens, :close)
-    end
-  end
-end