dentaku 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa37d9abba8c7bf0ea6d99f1f0ac472058772436
-  data.tar.gz: c07c67b22659bb6c26d7a70edd119bee53ada064
+  metadata.gz: 321fc84e833503ab21de4fdb06254666376ebe85
+  data.tar.gz: aa1d2820110ba82ff68219e6b5b0681224bfd44d
 SHA512:
-  metadata.gz: 4b489326fecca7a6a114c64d01efd17149992338167e42cec9fd71f1e12b96bafb72a91ccf2b8b4f6ab895b85d72a74ceb12ad3c3a2b574bff7f3a43471bbb2f
-  data.tar.gz: 58bf32696c4c604269f117fa062dc5ea155dd6c9d2eab7007611dd8bc75b129b332d63dfa15aff3deb4f5c6bd1153aed9546fa3ffbca0b59a8c9fa398dfc0868
+  metadata.gz: d5929679dbe4e6caea26ba61f4c920fe9a1d9e3b4880cc21c59a57e33109dc0ae9896f1c47ad4baadfe3ad1e2a0ac20d588b2266b63c8b3fcf4f535504871c95
+  data.tar.gz: aae2e18c9cad2e3452e2c8193c93be0754ee09628095119fdff91db9de613526cba57f9f4b3f5ff0c0eee6935298c754075ded6cd75b86c96c3aa1000cc29add

data/.travis.yml

@@ -7,5 +7,6 @@ rvm:
   - 2.2.0
   - 2.2.1
   - 2.2.2
+  - 2.2.3
   - jruby-19mode
   - rbx-2

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## [v2.0.2] 2015-08-20
+- bug fixes
+- performance enhancements
+- code cleanup
+
 ## [v2.0.1] 2015-08-15
 - add support for boolean literals
 - implement basic parse-time type checking
@@ -75,6 +80,8 @@
 ## [v0.1.0] 2012-01-20
 - initial release
 
+[v2.0.2]:  https://github.com/rubysolo/dentaku/compare/v2.0.1...v2.0.2
+[v2.0.1]:  https://github.com/rubysolo/dentaku/compare/v2.0.0...v2.0.1
 [v2.0.0]:  https://github.com/rubysolo/dentaku/compare/v1.2.6...v2.0.0
 [v1.2.6]:  https://github.com/rubysolo/dentaku/compare/v1.2.5...v1.2.6
 [v1.2.5]:  https://github.com/rubysolo/dentaku/compare/v1.2.2...v1.2.5

data/README.md

@@ -99,6 +99,26 @@ Dentaku('plums * 1.5', plums: 2)
 #=> 3.0
 ```
 
+PERFORMANCE
+-----------
+
+The flexibility and safety of Dentaku don't come without a price.  Tokenizing a
+string, parsing to an AST, and then evaluating that AST are about 2 orders of
+magnitude slower than doing the same math in pure Ruby!
+
+The good news is that most of the time is spent in the tokenization and parsing
+phases, so if performance is a concern, you can enable AST caching:
+
+```ruby
+Dentaku.enable_ast_cache!
+```
+
+After this, Dentaku will cache the AST of each formula that it evaluates, so
+subsequent evaluations (even with different values for variables) will be much
+faster -- closer to 4x native Ruby speed.  As usual, these benchmarks should be
+considered rough estimates, and you should measure with representative formulas
+from your application.  Also, if new formulas are constantly introduced to your
+application, AST caching will consume more memory with each new formula.
 
 BUILT-IN OPERATORS AND FUNCTIONS
 ---------------------------------

data/lib/dentaku/ast/combinators.rb

@@ -8,6 +8,10 @@ module Dentaku
         fail "#{ self.class } requires logical operands" unless valid_node?(left) && valid_node?(right)
       end
 
+      def type
+        :logical
+      end
+
       private
 
       def valid_node?(node)

data/lib/dentaku/calculator.rb

@@ -59,14 +59,14 @@ module Dentaku
     end
 
     def store(key_or_hash, value=nil)
-      restore = memory.dup
+      restore = Hash[memory]
 
       if value.nil?
         key_or_hash.each do |key, val|
-          memory[key.downcase.to_s] = val
+          memory[key.to_s.downcase] = val
         end
       else
-        memory[key_or_hash.to_s] = value
+        memory[key_or_hash.to_s.downcase] = value
       end
 
       if block_given?

data/lib/dentaku/parser.rb

@@ -60,7 +60,7 @@ module Dentaku
 
         when :grouping
           case token.value
-          when :open, :fopen
+          when :open
             if input.first && input.first.value == :close
               input.shift
               consume(0)

data/lib/dentaku/token_matcher.rb

@@ -112,7 +112,6 @@ module Dentaku
     def self.comp_gt;        new(:comparator, [:gt, :ge]);         end
     def self.comp_lt;        new(:comparator, [:lt, :le]);         end
 
-    def self.fopen;          new(:grouping, :fopen);               end
     def self.open;           new(:grouping, :open);                end
     def self.close;          new(:grouping, :close);               end
     def self.comma;          new(:grouping, :comma);               end

data/lib/dentaku/token_matchers.rb

@@ -5,7 +5,7 @@ module Dentaku
     end
 
     def self.function_token_matchers(function_name, *symbols)
-      token_matchers(:fopen, *symbols, :close).unshift(
+      token_matchers(:open, *symbols, :close).unshift(
         TokenMatcher.send(function_name)
       )
     end
@@ -13,7 +13,7 @@ module Dentaku
     def self.matcher(symbol)
       @matchers ||= [
         :numeric, :string, :addsub, :subtract, :muldiv, :pow, :mod,
-        :comparator, :comp_gt, :comp_lt, :fopen, :open, :close, :comma,
+        :comparator, :comp_gt, :comp_lt, :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

data/lib/dentaku/token_scanner.rb

@@ -64,7 +64,6 @@ module Dentaku
           last_token.is?(:comparator) ||
           last_token.is?(:combinator) ||
           last_token.value == :open   ||
-          last_token.value == :fopen  ||
           last_token.value == :comma
         })
       end
@@ -96,7 +95,7 @@ module Dentaku
       def function
         new(:function, '\w+\s*\(', lambda do |raw|
           function_name = raw.gsub('(', '')
-          [Token.new(:function, function_name.strip.downcase.to_sym, function_name), Token.new(:grouping, :fopen, '(')]
+          [Token.new(:function, function_name.strip.downcase.to_sym, function_name), Token.new(:grouping, :open, '(')]
         end)
       end
 

data/lib/dentaku/tokenizer.rb

@@ -4,7 +4,7 @@ require 'dentaku/token_scanner'
 
 module Dentaku
   class Tokenizer
-    LPAREN = TokenMatcher.new(:grouping, [:open, :fopen])
+    LPAREN = TokenMatcher.new(:grouping, :open)
     RPAREN = TokenMatcher.new(:grouping, :close)
 
     def tokenize(string)

data/lib/dentaku/version.rb

@@ -1,3 +1,3 @@
 module Dentaku
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 end

data/spec/ast/and_spec.rb

@@ -23,5 +23,10 @@ describe Dentaku::AST::And do
     expect {
       described_class.new(t, expression)
     }.not_to raise_error
+
+    expression = Dentaku::AST::Or.new(t, f)
+    expect {
+      described_class.new(t, expression)
+    }.not_to raise_error
   end
 end

data/spec/benchmark.rb

@@ -26,20 +26,19 @@ def test(args, custom_function: true)
     bm = Benchmark.measure do
       stats = AllocationStats.trace do
 
-        calls.each do |formule, bound|
+        calls.each do |formula, bound|
 
           calculator = Dentaku::Calculator.new
 
           if custom_function
             calculator.add_function(
-              name:      :sum,
-              type:      :numeric,
-              signature: [:arguments],
-              body:      ->(numbers) { numbers.inject(:+) },
+              :sum,
+              :numeric,
+              ->(numbers) { numbers.inject(:+) }
             )
           end
 
-          calculator.evaluate(formule, bound)
+          calculator.evaluate(formula, bound)
         end
       end
     end

data/spec/parser_spec.rb

@@ -63,7 +63,7 @@ describe Dentaku::Parser do
 
   it 'evaluates functions' do
     fn    = Dentaku::Token.new(:function, :if)
-    fopen = Dentaku::Token.new(:grouping, :fopen)
+    fopen = Dentaku::Token.new(:grouping, :open)
     five  = Dentaku::Token.new(:numeric, 5)
     lt    = Dentaku::Token.new(:comparator, :lt)
     four  = Dentaku::Token.new(:numeric, 4)

data/spec/spec_helper.rb

@@ -19,7 +19,7 @@ def type_for(value)
     :logical
   when :add, :subtract, :multiply, :divide, :mod, :pow
     :operator
-  when :fopen, :open, :close, :comma
+  when :open, :close, :comma
     :grouping
   when :le, :ge, :ne, :ne, :lt, :gt, :eq
     :comparator

data/spec/tokenizer_spec.rb

@@ -31,7 +31,7 @@ describe Dentaku::Tokenizer do
       :operator, :numeric                                        # - 9
     ])
     expect(tokens.map(&:value)).to eq([
-      :if, :fopen,                  # if(
+      :if, :open,                   # if(
       :negate, 5, :gt, 'x', :comma, # -5 > x,
       :negate, 7, :comma,           # -7,
       :negate, 8, :close,           # -8)
@@ -170,43 +170,43 @@ 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, :open, 'x', :lt, 10, :comma, 'y', :comma, 'z', :close])
     end
 
     it 'include ROUND/UP/DOWN' do
       tokens = tokenizer.tokenize('round(8.2)')
       expect(tokens.length).to eq(4)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:round, :fopen, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:round, :open, BigDecimal.new('8.2'), :close])
 
       tokens = tokenizer.tokenize('round(8.75, 1)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:round, :fopen, BigDecimal.new('8.75'), :comma, 1, :close])
+      expect(tokens.map(&:value)).to eq([:round, :open, BigDecimal.new('8.75'), :comma, 1, :close])
 
       tokens = tokenizer.tokenize('ROUNDUP(8.2)')
       expect(tokens.length).to eq(4)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:roundup, :fopen, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:roundup, :open, BigDecimal.new('8.2'), :close])
 
       tokens = tokenizer.tokenize('RoundDown(8.2)')
       expect(tokens.length).to eq(4)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:rounddown, :fopen, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:rounddown, :open, BigDecimal.new('8.2'), :close])
     end
 
     it 'include NOT' do
       tokens = tokenizer.tokenize('not(8 < 5)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :comparator, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:not, :fopen, 8, :lt, 5, :close])
+      expect(tokens.map(&:value)).to eq([:not, :open, 8, :lt, 5, :close])
     end
 
     it 'handles whitespace after function name' do
       tokens = tokenizer.tokenize('not (8 < 5)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :comparator, :numeric, :grouping])
-      expect(tokens.map(&:value)).to eq([:not, :fopen, 8, :lt, 5, :close])
+      expect(tokens.map(&:value)).to eq([:not, :open, 8, :lt, 5, :close])
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-16 00:00:00.000000000 Z
+date: 2015-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake