dentaku 1.2.1 → 1.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c588f75b508adbbda4b56b6b3286144aff133c01
+  data.tar.gz: b444936b8e75de4aa64af4a39b0d2e9d667b85f3
+SHA512:
+  metadata.gz: 33f894376d9098500762e3a5aab7e6be70ce95a3da9fb0c7dd09186bbb30db0471b8bcc750dd906bb3dfdc585f37f5bfe59002dbe4f93a4a65f5784b7e9b2d02
+  data.tar.gz: 0fbf3567fd3b9b5e8e5db7df0647ddc687842f9e6b2bdce9e685d1c2a45fdfa2b1ad9ca80c7c5a1ac4fc2e5a910faf167205520d7f52a40ae1ea4de7c573c32e

data/README.md

@@ -255,6 +255,7 @@ contributors:
 * [jasonhutchens](https://github.com/jasonhutchens)
 * [jmangs](https://github.com/jmangs)
 * [mvbrocato](https://github.com/mvbrocato)
+* [schneidmaster](https://github.com/schneidmaster)
 * [thbar](https://github.com/thbar) / [BoxCar](https://www.boxcar.io)
 
 

data/lib/dentaku/calculator.rb

@@ -39,20 +39,24 @@ module Dentaku
     end
 
     def solve!(expression_hash)
+      expressions = Hash[expression_hash.map { |k,v| [k.to_s, v] }]
+
       # expression_hash: { variable_name: "string expression" }
       # TSort thru the expressions' dependencies, then evaluate all
-      expression_dependencies = Hash[expression_hash.map do |var, expr|
+      expression_dependencies = Hash[expressions.map do |var, expr|
         [var, dependencies(expr)]
       end]
+
       variables_in_resolve_order = DependencyResolver::find_resolve_order(
         expression_dependencies)
 
-      results = {}
-      variables_in_resolve_order.each do |var_name|
-        results[var_name] = evaluate!(expression_hash[var_name], results)
+      results = variables_in_resolve_order.each_with_object({}) do |var_name, r|
+        r[var_name] = evaluate!(expressions[var_name], r)
       end
 
-      results
+      expression_hash.each_with_object({}) do |(k, _), r|
+        r[k] = results[k.to_s]
+      end
     end
 
     def dependencies(expression)
@@ -62,12 +66,12 @@ module Dentaku
     def store(key_or_hash, value=nil)
       restore = @memory.dup
 
-      if !value.nil?
-        @memory[key_or_hash.to_sym] = value
-      else
-        key_or_hash.each do |key, value|
-          @memory[key.to_sym] = value
+      if value.nil?
+        key_or_hash.each do |key, val|
+          @memory[key.downcase.to_s] = val
         end
+      else
+        @memory[key_or_hash.to_s] = value
       end
 
       if block_given?

data/lib/dentaku/dependency_resolver.rb

@@ -9,8 +9,8 @@ module Dentaku
     end
 
     def initialize(vars_to_dependencies_hash)
-      # ensure variables are symbols
-      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.to_sym, v]}]
+      # ensure variables are strings
+      @vars_to_deps = Hash[vars_to_dependencies_hash.map { |k, v| [k.to_s, v]}]
     end
 
     def tsort_each_node(&block)
@@ -18,7 +18,7 @@ module Dentaku
     end
 
     def tsort_each_child(node, &block)
-      @vars_to_deps[node.to_sym].each(&block)
+      @vars_to_deps[node.to_s].each(&block)
     end
   end
 end

data/lib/dentaku/evaluator.rb

@@ -47,10 +47,12 @@ module Dentaku
         pattern.each do |matcher|
           _matched, match = matcher.match(token_stream, position + matches.length)
           matched &&= _matched
+          break unless matched
           matches += match
         end
 
         return position, matches if matched
+        return if pattern.first.caret?
         position += 1
       end
 

data/lib/dentaku/expression.rb

@@ -2,13 +2,14 @@ require 'dentaku/tokenizer'
 
 module Dentaku
   class Expression
-    attr_reader :tokens
+    attr_reader :tokens, :variables
 
     def initialize(string, variables={})
       @raw = string
       @tokenizer ||= Tokenizer.new
       @tokens = @tokenizer.tokenize(@raw)
-      replace_identifiers_with_values(variables)
+      @variables = Hash[variables.map { |k,v| [k.to_s, v] }]
+      replace_identifiers_with_values
     end
 
     def identifiers
@@ -21,18 +22,18 @@ module Dentaku
 
     private
 
-    def replace_identifiers_with_values(variables)
+    def replace_identifiers_with_values
       @tokens.map! do |token|
         if token.is?(:identifier)
-          replace_identifier_with_value(token, variables)
+          replace_identifier_with_value(token)
         else
           token
         end
       end
     end
 
-    def replace_identifier_with_value(token, variables)
-      key = token.value.to_sym
+    def replace_identifier_with_value(token)
+      key = token.value.to_s
 
       if variables.key? key
         value = variables[key]

data/lib/dentaku/external_function.rb

@@ -1,7 +1,7 @@
 class ExternalFunction < Struct.new(:name, :type, :signature, :body)
   def initialize(*)
     super
-    self.name = self.name.to_sym
+    self.name = self.name.to_s
   end
 
   def tokens

data/lib/dentaku/rules.rb

@@ -13,6 +13,7 @@ module Dentaku
         [ p(:not),        :not            ],
 
         [ p(:group),      :evaluate_group ],
+        [ p(:start_neg),  :negate         ],
         [ p(:math_pow),   :apply          ],
         [ p(:math_mod),   :apply          ],
         [ p(:math_mul),   :apply          ],
@@ -66,7 +67,8 @@ module Dentaku
         :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
+        :logical, :combinator, :if, :round, :roundup, :rounddown, :not,
+        :anchored_minus
       ].each_with_object({}) do |name, matchers|
         matchers[name] = TokenMatcher.send(name)
       end
@@ -80,6 +82,7 @@ module Dentaku
         math_pow:   pattern(:numeric,  :pow,            :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),

data/lib/dentaku/token_matcher.rb

@@ -44,6 +44,15 @@ module Dentaku
       [matched, matched_tokens]
     end
 
+    def caret
+      @caret = true
+      self
+    end
+
+    def caret?
+      @caret
+    end
+
     def star
       @min = 0
       @max = Float::INFINITY
@@ -93,6 +102,7 @@ module Dentaku
 
     def self.addsub;         new(:operator, [:add, :subtract]);    end
     def self.subtract;       new(:operator, :subtract);            end
+    def self.anchored_minus; new(:operator, :subtract).caret;      end
     def self.muldiv;         new(:operator, [:multiply, :divide]); end
     def self.pow;            new(:operator, :pow);                 end
     def self.mod;            new(:operator, :mod);                 end

data/lib/dentaku/token_scanner.rb

@@ -81,7 +81,7 @@ module Dentaku
       end
 
       def identifier
-        new(:identifier, '\w+\b', lambda { |raw| raw.strip.downcase.to_sym })
+        new(:identifier, '\w+\b', lambda { |raw| raw.strip.downcase.to_s })
       end
     end
   end

data/lib/dentaku/tokenizer.rb

@@ -10,7 +10,7 @@ module Dentaku
     def tokenize(string)
       @nesting = 0
       @tokens  = []
-      input    = string.dup
+      input    = string.to_s.dup
 
       until input.empty?
         raise "parse error at: '#{ input }'" unless TokenScanner.scanners.any? do |scanner|

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

data/spec/calculator_spec.rb

@@ -6,6 +6,22 @@ describe Dentaku::Calculator do
 
   it 'evaluates an expression' do
     expect(calculator.evaluate('7+3')).to eq(10)
+    expect(calculator.evaluate('2 -1')).to eq(1)
+    expect(calculator.evaluate('-1 + 2')).to eq(1)
+    expect(calculator.evaluate('1 - 2')).to eq(-1)
+    expect(calculator.evaluate('1 - - 2')).to eq(3)
+    expect(calculator.evaluate('-1 - - 2')).to eq(1)
+    expect(calculator.evaluate('1 - - - 2')).to eq(-1)
+    expect(calculator.evaluate('(-1 + 2)')).to eq(1)
+    expect(calculator.evaluate('-(1 + 2)')).to eq(-3)
+    expect(calculator.evaluate('2 ^ - 1')).to eq(0.5)
+    expect(calculator.evaluate('2 ^ -(3 - 2)')).to eq(0.5)
+    expect(calculator.evaluate('(2 + 3) - 1')).to eq(4)
+    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)
   end
 
   describe 'memory' do
@@ -32,10 +48,10 @@ describe Dentaku::Calculator do
 
   describe 'dependencies' do
     it "finds dependencies in a generic statement" do
-      expect(calculator.dependencies("bob + dole / 3")).to eq([:bob, :dole])
+      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])
+      expect(with_memory.dependencies("apples + oranges")).to eq(['oranges'])
     end
   end
 
@@ -48,6 +64,14 @@ describe Dentaku::Calculator do
       )).to eq(pear: 1, weekly_apple_budget: 21, weekly_fruit_budget: 25)
     end
 
+    it "preserves hash keys" do
+      expect(calculator.solve!(
+        'meaning_of_life' => 'age + kids',
+        'age'  => 40,
+        'kids' =>  2
+      )).to eq('age' => 40, 'kids' => 2, 'meaning_of_life' => 42)
+    end
+
     it "lets you know about a cycle if one occurs" do
       expect do
         calculator.solve!(health: "happiness", happiness: "health")
@@ -64,7 +88,7 @@ describe Dentaku::Calculator do
     unbound = 'foo * 1.5'
     expect { calculator.evaluate!(unbound) }.to raise_error(Dentaku::UnboundVariableError)
     expect { calculator.evaluate!(unbound) }.to raise_error do |error|
-      expect(error.unbound_variables).to eq [:foo]
+      expect(error.unbound_variables).to eq ['foo']
     end
     expect(calculator.evaluate(unbound)).to be_nil
     expect(calculator.evaluate(unbound) { :bar }).to eq :bar
@@ -112,7 +136,6 @@ describe Dentaku::Calculator do
     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
@@ -138,5 +161,12 @@ describe Dentaku::Calculator do
       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
+    end
   end
 end

data/spec/dentaku_spec.rb

@@ -12,4 +12,11 @@ describe Dentaku do
   it 'evaulates a nested function' do
     expect(Dentaku('roundup(roundup(3 * cherries) + raspberries)', cherries: 1.5, raspberries: 0.9)).to eql(6)
   end
+
+  it 'treats variables as case-insensitive' do
+    expect(Dentaku('40 + N', 'n' => 2)).to eql(42)
+    expect(Dentaku('40 + N', 'N' => 2)).to eql(42)
+    expect(Dentaku('40 + n', 'N' => 2)).to eql(42)
+    expect(Dentaku('40 + n', 'n' => 2)).to eql(42)
+  end
 end

data/spec/evaluator_spec.rb

@@ -44,6 +44,8 @@ describe Dentaku::Evaluator do
     it 'supports unary minus' do
       expect(evaluator.evaluate(token_stream(:subtract, 1))).to eq(-1)
       expect(evaluator.evaluate(token_stream(1, :subtract, :subtract, 1))).to eq(2)
+      expect(evaluator.evaluate(token_stream(1, :subtract, :subtract, :subtract, 1))).to eq(0)
+      expect(evaluator.evaluate(token_stream(:subtract, 1, :add, 1))).to eq(0)
     end
 
     it 'supports unary percentage' do
@@ -77,6 +79,23 @@ describe Dentaku::Evaluator do
         expect(position).to eq 0
         expect(tokens.length).to eq 8
       end
+
+      describe 'with start-anchored token' do
+        let(:number) { [Dentaku::TokenMatcher.new(:numeric).caret] }
+        let(:string) { [Dentaku::TokenMatcher.new(:string).caret] }
+        let(:stream) { token_stream(1, 'foo') }
+
+        it 'matches anchored to the beginning of the token stream' do
+          position, tokens = evaluator.find_rule_match(number, stream)
+          expect(position).to eq 0
+          expect(tokens.length).to eq 1
+        end
+
+        it 'does not match later in the stream' do
+          position, _tokens = evaluator.find_rule_match(string, stream)
+          expect(position).to be_nil
+        end
+      end
     end
 
     describe 'functions' do

data/spec/tokenizer_spec.rb

@@ -16,19 +16,19 @@ describe Dentaku::Tokenizer do
   it 'tokenizes comparison with =' do
     tokens = tokenizer.tokenize('number = 5')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:number, :eq, 5])
+    expect(tokens.map(&:value)).to eq(['number', :eq, 5])
   end
 
   it 'tokenizes comparison with =' do
     tokens = tokenizer.tokenize('number = 5')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:number, :eq, 5])
+    expect(tokens.map(&:value)).to eq(['number', :eq, 5])
   end
 
   it 'tokenizes comparison with alternate ==' do
     tokens = tokenizer.tokenize('number == 5')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:number, :eq, 5])
+    expect(tokens.map(&:value)).to eq(['number', :eq, 5])
   end
 
   it 'ignores whitespace' do
@@ -52,37 +52,55 @@ describe Dentaku::Tokenizer do
   it 'accepts arbitrary identifiers' do
     tokens = tokenizer.tokenize('monkeys > 1500')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:monkeys, :gt, 1500])
+    expect(tokens.map(&:value)).to eq(['monkeys', :gt, 1500])
   end
 
   it 'recognizes double-quoted strings' do
     tokens = tokenizer.tokenize('animal = "giraffe"')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :string])
-    expect(tokens.map(&:value)).to eq([:animal, :eq, 'giraffe'])
+    expect(tokens.map(&:value)).to eq(['animal', :eq, 'giraffe'])
   end
 
   it 'recognizes single-quoted strings' do
     tokens = tokenizer.tokenize("animal = 'giraffe'")
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :string])
-    expect(tokens.map(&:value)).to eq([:animal, :eq, 'giraffe'])
+    expect(tokens.map(&:value)).to eq(['animal', :eq, 'giraffe'])
+  end
+
+  it 'recognizes binary minus operator' do
+    tokens = tokenizer.tokenize('2 - 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :subtract, 3])
+  end
+
+  it 'recognizes unary minus operator' do
+    tokens = tokenizer.tokenize('-2 + 3')
+    expect(tokens.map(&:category)).to eq([:operator, :numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([:subtract, 2, :add, 3])
+  end
+
+  it 'recognizes unary minus operator' do
+    tokens = tokenizer.tokenize('2 - -3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :subtract, :subtract, 3])
   end
 
   it 'matches "<=" before "<"' do
     tokens = tokenizer.tokenize('perimeter <= 7500')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:perimeter, :le, 7500])
+    expect(tokens.map(&:value)).to eq(['perimeter', :le, 7500])
   end
 
   it 'matches "and" for logical expressions' do
     tokens = tokenizer.tokenize('octopi <= 7500 AND sharks > 1500')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric, :combinator, :identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:octopi, :le, 7500, :and, :sharks, :gt, 1500])
+    expect(tokens.map(&:value)).to eq(['octopi', :le, 7500, :and, 'sharks', :gt, 1500])
   end
 
   it 'matches "or" for logical expressions' do
     tokens = tokenizer.tokenize('size < 3 or admin = 1')
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric, :combinator, :identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:size, :lt, 3, :or, :admin, :eq, 1])
+    expect(tokens.map(&:value)).to eq(['size', :lt, 3, :or, 'admin', :eq, 1])
   end
 
   it 'detects unbalanced parentheses' do
@@ -94,7 +112,7 @@ describe Dentaku::Tokenizer do
     tokens = tokenizer.tokenize('andover < 10')
     expect(tokens.length).to eq(3)
     expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
-    expect(tokens.map(&:value)).to eq([:andover, :lt, 10])
+    expect(tokens.map(&:value)).to eq(['andover', :lt, 10])
   end
 
   describe 'functions' do
@@ -102,7 +120,7 @@ describe Dentaku::Tokenizer do
       tokens = tokenizer.tokenize('if(x < 10, y, z)')
       expect(tokens.length).to eq(10)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :identifier, :comparator, :numeric, :grouping, :identifier, :grouping, :identifier, :grouping])
-      expect(tokens.map(&:value)).to eq([:if, :fopen, :x, :lt, 10, :comma, :y, :comma, :z, :close])
+      expect(tokens.map(&:value)).to eq([:if, :fopen, 'x', :lt, 10, :comma, 'y', :comma, 'z', :close])
     end
 
     it 'include ROUND/UP/DOWN' do

metadata

@@ -1,59 +1,53 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 1.2.1
-  prerelease: 
+  version: 1.2.2
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-22 00:00:00.000000000 Z
+date: 2014-12-19 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: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
@@ -86,33 +80,26 @@ files:
 homepage: http://github.com/rubysolo/dentaku
 licenses:
 - MIT
+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'
-      segments:
-      - 0
-      hash: -1375666282720046081
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -1375666282720046081
 requirements: []
 rubyforge_project: dentaku
-rubygems_version: 1.8.23.2
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A formula language parser and evaluator
 test_files:
 - spec/binary_operation_spec.rb