dentaku 3.3.0 → 3.3.1

data/spec/external_function_spec.rb

@@ -66,8 +66,8 @@ describe Dentaku::Calculator do
       calculator2 = Dentaku::Calculator.new
       calculator2.add_function(:my_function, :numeric, ->(x) { 4 * x + 3 })
 
-      expect(calculator1.evaluate("1 + my_function(2)")). to eq (1 + 2 * 2 + 1)
-      expect(calculator2.evaluate("1 + my_function(2)")). to eq (1 + 4 * 2 + 3)
+      expect(calculator1.evaluate("1 + my_function(2)")). to eq(1 + 2 * 2 + 1)
+      expect(calculator2.evaluate("1 + my_function(2)")). to eq(1 + 4 * 2 + 3)
 
       expect {
         Dentaku::Calculator.new.evaluate!("1 + my_function(2)")
@@ -76,7 +76,7 @@ describe Dentaku::Calculator do
 
     it 'self.add_function adds to default/global function registry' do
       Dentaku::Calculator.add_function(:global_function, :numeric, ->(x) { 10 + x**2 })
-      expect(Dentaku::Calculator.new.evaluate("global_function(3) + 5")).to eq (10 + 3**2 + 5)
+      expect(Dentaku::Calculator.new.evaluate("global_function(3) + 5")).to eq(10 + 3**2 + 5)
     end
   end
 end

data/spec/parser_spec.rb

@@ -1,189 +1,138 @@
 require 'spec_helper'
 require 'dentaku/token'
+require 'dentaku/tokenizer'
 require 'dentaku/parser'
 
 describe Dentaku::Parser do
-  it 'is constructed from a token' do
-    token = Dentaku::Token.new(:numeric, 5)
-    node  = described_class.new([token]).parse
-    expect(node.value).to eq 5
+  it 'parses an integer literal' do
+    node = parse('5')
+    expect(node.value).to eq(5)
   end
 
   it 'performs simple addition' do
-    five = Dentaku::Token.new(:numeric, 5)
-    plus = Dentaku::Token.new(:operator, :add)
-    four = Dentaku::Token.new(:numeric, 4)
-
-    node = described_class.new([five, plus, four]).parse
-    expect(node.value).to eq 9
+    node = parse('5 + 4')
+    expect(node.value).to eq(9)
   end
 
   it 'compares two numbers' do
-    five = Dentaku::Token.new(:numeric, 5)
-    lt   = Dentaku::Token.new(:comparator, :lt)
-    four = Dentaku::Token.new(:numeric, 4)
-
-    node = described_class.new([five, lt, four]).parse
-    expect(node.value).to eq false
+    node = parse('5 < 4')
+    expect(node.value).to eq(false)
   end
 
   it 'calculates unary percentage' do
-    five = Dentaku::Token.new(:numeric, 5)
-    mod  = Dentaku::Token.new(:operator, :mod)
-
-    node = described_class.new([five, mod]).parse
-    expect(node.value).to eq 0.05
+    node = parse('5%')
+    expect(node.value).to eq(0.05)
   end
 
   it 'calculates bitwise OR' do
-    two   = Dentaku::Token.new(:numeric, 2)
-    bitor = Dentaku::Token.new(:operator, :bitor)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([two, bitor, three]).parse
-    expect(node.value).to eq 3
+    node = parse('2|3')
+    expect(node.value).to eq(3)
   end
 
   it 'performs multiple operations in one stream' do
-    five  = Dentaku::Token.new(:numeric, 5)
-    plus  = Dentaku::Token.new(:operator, :add)
-    four  = Dentaku::Token.new(:numeric, 4)
-    times = Dentaku::Token.new(:operator, :multiply)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([five, plus, four, times, three]).parse
-    expect(node.value).to eq 17
+    node = parse('5 * 4 + 3')
+    expect(node.value).to eq(23)
   end
 
   it 'respects order of operations' do
-    five  = Dentaku::Token.new(:numeric, 5)
-    times = Dentaku::Token.new(:operator, :multiply)
-    four  = Dentaku::Token.new(:numeric, 4)
-    plus  = Dentaku::Token.new(:operator, :add)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([five, times, four, plus, three]).parse
-    expect(node.value).to eq 23
+    node = parse('5 + 4*3')
+    expect(node.value).to eq(17)
   end
 
   it 'respects grouping by parenthesis' do
-    lpar  = Dentaku::Token.new(:grouping, :open)
-    five  = Dentaku::Token.new(:numeric, 5)
-    plus  = Dentaku::Token.new(:operator, :add)
-    four  = Dentaku::Token.new(:numeric, 4)
-    rpar  = Dentaku::Token.new(:grouping, :close)
-    times = Dentaku::Token.new(:operator, :multiply)
-    three = Dentaku::Token.new(:numeric, 3)
-
-    node  = described_class.new([lpar, five, plus, four, rpar, times, three]).parse
-    expect(node.value).to eq 27
+    node = parse('(5 + 4) * 3')
+    expect(node.value).to eq(27)
   end
 
   it 'evaluates functions' do
-    fn    = Dentaku::Token.new(:function, :if)
-    fopen = Dentaku::Token.new(:grouping, :open)
-    five  = Dentaku::Token.new(:numeric, 5)
-    lt    = Dentaku::Token.new(:comparator, :lt)
-    four  = Dentaku::Token.new(:numeric, 4)
-    comma = Dentaku::Token.new(:grouping, :comma)
-    three = Dentaku::Token.new(:numeric, 3)
-    two   = Dentaku::Token.new(:numeric, 2)
-    rpar  = Dentaku::Token.new(:grouping, :close)
-
-    node  = described_class.new([fn, fopen, five, lt, four, comma, three, comma, two, rpar]).parse
-    expect(node.value).to eq 2
+    node = parse('IF(5 < 4, 3, 2)')
+    expect(node.value).to eq(2)
   end
 
   it 'represents formulas with variables' do
-    five  = Dentaku::Token.new(:numeric, 5)
-    times = Dentaku::Token.new(:operator, :multiply)
-    x     = Dentaku::Token.new(:identifier, :x)
-
-    node  = described_class.new([five, times, x]).parse
+    node = parse('5 * x')
     expect { node.value }.to raise_error(Dentaku::UnboundVariableError)
-    expect(node.value(x: 3)).to eq 15
+    expect(node.value("x" => 3)).to eq(15)
   end
 
   it 'evaluates access into data structures' do
-    a        = token(:a)
-    lbracket = token(:lbracket)
-    one      = token(1)
-    rbracket = token(:rbracket)
-
-    node = described_class.new([a, lbracket, one, rbracket]).parse
+    node = parse('a[1]')
     expect { node.value }.to raise_error(Dentaku::UnboundVariableError)
-    expect(node.value(a: [1, 2, 3])).to eq 2
+    expect(node.value("a" => [1, 2, 3])).to eq(2)
   end
 
   it 'evaluates boolean expressions' do
-    d_true  = Dentaku::Token.new(:logical, true)
-    d_and   = Dentaku::Token.new(:combinator, :and)
-    d_false = Dentaku::Token.new(:logical, false)
-
-    node = described_class.new([d_true, d_and, d_false]).parse
-    expect(node.value).to eq false
+    node = parse('true AND false')
+    expect(node.value).to eq(false)
   end
 
   it 'evaluates a case statement' do
-    case_start = Dentaku::Token.new(:case, :open)
-    x = Dentaku::Token.new(:identifier, :x)
-    case_when1 = Dentaku::Token.new(:case, :when)
-    one = Dentaku::Token.new(:numeric, 1)
-    case_then1 = Dentaku::Token.new(:case, :then)
-    two = Dentaku::Token.new(:numeric, 2)
-    case_when2 = Dentaku::Token.new(:case, :when)
-    three = Dentaku::Token.new(:numeric, 3)
-    case_then2 = Dentaku::Token.new(:case, :then)
-    four = Dentaku::Token.new(:numeric, 4)
-    case_close = Dentaku::Token.new(:case, :close)
-
-    node = described_class.new(
-      [case_start,
-       x,
-       case_when1,
-       one,
-       case_then1,
-       two,
-       case_when2,
-       three,
-       case_then2,
-       four,
-       case_close]).parse
-    expect(node.value(x: 3)).to eq(4)
+    node = parse('CASE x WHEN 1 THEN 2 WHEN 3 THEN 4 END')
+    expect(node.value("x" => 3)).to eq(4)
   end
 
   context 'invalid expression' do
     it 'raises a parse error for bad math' do
-      five  = Dentaku::Token.new(:numeric, 5)
-      times = Dentaku::Token.new(:operator, :multiply)
-      minus = Dentaku::Token.new(:operator, :subtract)
-
       expect {
-        described_class.new([five, times, minus]).parse
+        parse("5 * -")
       }.to raise_error(Dentaku::ParseError)
     end
 
     it 'raises a parse error for bad logic' do
-      this = Dentaku::Token.new(:logical, true)
-      also = Dentaku::Token.new(:combinator, :and)
+      expect {
+        parse("TRUE AND")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises a parse error for bad grouping structure' do
+      expect {
+        parse(",")
+      }.to raise_error(Dentaku::ParseError)
 
       expect {
-        described_class.new([this, also]).parse
+        parse("5, x")
+        described_class.new([five, comma, x]).parse
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("5 + 5, x")
       }.to raise_error(Dentaku::ParseError)
     end
 
-    it 'raises an exception when trying to access an undefined function' do
-      fn = Dentaku::Token.new(:function, 'non_exists_func')
+    it 'raises parse errors for malformed case statements' do
+      expect {
+        parse("CASE a when 'one' then 1")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("case a whend 'one' then 1 end")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CASE a WHEN 'one' THEND 1 END")
+      }.to raise_error(Dentaku::ParseError)
 
       expect {
-        described_class.new([fn]).parse
+        parse("CASE a when 'one' then end")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    it 'raises a parse error when trying to access an undefined function' do
+      expect {
+        parse("undefined()")
       }.to raise_error(Dentaku::ParseError)
     end
   end
 
-  it "evaluates explicit 'NULL' as a Nil" do
-    null = Dentaku::Token.new(:null, nil)
-    node = described_class.new([null]).parse
+  it "evaluates explicit 'NULL' as nil" do
+    node = parse("NULL")
     expect(node.value).to eq(nil)
   end
+
+  private
+
+  def parse(expr)
+    tokens = Dentaku::Tokenizer.new.tokenize(expr)
+    described_class.new(tokens).parse
+  end
 end

data/spec/spec_helper.rb

@@ -16,9 +16,11 @@ end
 
 RSpec.configure do |c|
   c.before(:all) {
-    # add example for alias because we can set aliases just once
-    # before `calculator` method called
-    Dentaku.aliases = { roundup: ['roundupup'] }
+    if Dentaku.respond_to?(:aliases=)
+      # add example for alias because we can set aliases just once
+      # before `calculator` method called
+      Dentaku.aliases = { roundup: ['roundupup'] }
+    end
   }
 end
 
@@ -45,7 +47,7 @@ def type_for(value)
     :grouping
   when :lbracket, :rbracket
     :access
-  when :le, :ge, :ne, :ne, :lt, :gt, :eq
+  when :le, :ge, :ne, :lt, :gt, :eq
     :comparator
   when :and, :or
     :combinator

data/spec/token_matcher_spec.rb

@@ -82,8 +82,8 @@ describe Dentaku::TokenMatcher do
       it 'matches zero or more occurrences in a token stream' do
         matched, substream = standard.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 1
-        expect(substream.map(&:value)).to eq [5]
+        expect(substream.length).to eq(1)
+        expect(substream.map(&:value)).to eq([5])
 
         matched, substream = standard.match(stream, 4)
         expect(substream).to be_empty
@@ -97,8 +97,8 @@ describe Dentaku::TokenMatcher do
       it 'matches zero or more occurrences in a token stream' do
         matched, substream = star.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 4
-        expect(substream.map(&:value)).to eq [5, 11, 9, 24]
+        expect(substream.length).to eq(4)
+        expect(substream.map(&:value)).to eq([5, 11, 9, 24])
 
         matched, substream = star.match(stream, 4)
         expect(substream).to be_empty
@@ -112,8 +112,8 @@ describe Dentaku::TokenMatcher do
       it 'matches one or more occurrences in a token stream' do
         matched, substream = plus.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 4
-        expect(substream.map(&:value)).to eq [5, 11, 9, 24]
+        expect(substream.length).to eq(4)
+        expect(substream.map(&:value)).to eq([5, 11, 9, 24])
 
         matched, substream = plus.match(stream, 4)
         expect(substream).to be_empty
@@ -126,8 +126,8 @@ describe Dentaku::TokenMatcher do
         stream = token_stream(1, :comma, 2, :comma, true, :comma, 'olive', :comma, :'(')
         matched, substream = described_class.arguments.match(stream)
         expect(matched).to be_truthy
-        expect(substream.length).to eq 8
-        expect(substream.map(&:value)).to eq [1, :comma, 2, :comma, true, :comma, 'olive', :comma]
+        expect(substream.length).to eq(8)
+        expect(substream.map(&:value)).to eq([1, :comma, 2, :comma, true, :comma, 'olive', :comma])
       end
     end
   end

data/spec/token_scanner_spec.rb

@@ -3,7 +3,7 @@ require 'dentaku/token_scanner'
 describe Dentaku::TokenScanner do
   let(:whitespace) { described_class.new(:whitespace, '\s') }
   let(:numeric)    { described_class.new(:numeric,    '(\d+(\.\d+)?|\.\d+)',
-    ->(raw) { raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i })
+    ->(raw) { raw =~ /\./ ? BigDecimal(raw) : raw.to_i })
   }
   let(:custom)     { described_class.new(:identifier, '#\w+\b',
     ->(raw) { raw.gsub('#', '').to_sym })
@@ -29,18 +29,18 @@ describe Dentaku::TokenScanner do
 
   it 'allows customizing available scanners' do
     described_class.scanners = [:whitespace, :numeric]
-    expect(described_class.scanners.length).to eq 2
+    expect(described_class.scanners.length).to eq(2)
   end
 
   it 'ignores invalid scanners' do
     described_class.scanners = [:whitespace, :numeric, :fake]
-    expect(described_class.scanners.length).to eq 2
+    expect(described_class.scanners.length).to eq(2)
   end
 
   it 'uses a custom scanner' do
     described_class.scanners = [:whitespace, :numeric]
     described_class.register_scanner(:custom, custom)
-    expect(described_class.scanners.length).to eq 3
+    expect(described_class.scanners.length).to eq(3)
 
     token = custom.scan('#apple + #pear').first
     expect(token.category).to eq(:identifier)

data/spec/tokenizer_spec.rb

@@ -243,22 +243,22 @@ describe Dentaku::Tokenizer 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, :open, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:round, :open, BigDecimal('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, :open, BigDecimal.new('8.75'), :comma, 1, :close])
+      expect(tokens.map(&:value)).to eq([:round, :open, BigDecimal('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, :open, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:roundup, :open, BigDecimal('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, :open, BigDecimal.new('8.2'), :close])
+      expect(tokens.map(&:value)).to eq([:rounddown, :open, BigDecimal('8.2'), :close])
     end
 
     it 'include NOT' do
@@ -298,25 +298,25 @@ describe Dentaku::Tokenizer do
     it 'replaced with function name' do
       input = 'rrrrround!(8.2) + minimo(4,6,2)'
       tokenizer.tokenize(input, aliases: aliases)
-      expect(tokenizer.replace_aliases(input)).to eq 'round(8.2) + min(4,6,2)'
+      expect(tokenizer.replace_aliases(input)).to eq('round(8.2) + min(4,6,2)')
     end
 
     it 'case insensitive' do
       input = 'MinImO(4,6,2)'
       tokenizer.tokenize(input, aliases: aliases)
-      expect(tokenizer.replace_aliases(input)).to eq 'min(4,6,2)'
+      expect(tokenizer.replace_aliases(input)).to eq('min(4,6,2)')
     end
 
     it 'replace only whole aliases without word parts' do
       input = 'maximo(2,minimoooo())' # `minimoooo` doesn't match `minimo`
       tokenizer.tokenize(input, aliases: aliases)
-      expect(tokenizer.replace_aliases(input)).to eq 'max(2,minimoooo())'
+      expect(tokenizer.replace_aliases(input)).to eq('max(2,minimoooo())')
     end
 
     it 'work with non-latin symbols' do
       input = '如果(1,2,3)'
       tokenizer.tokenize(input, aliases: aliases)
-      expect(tokenizer.replace_aliases(input)).to eq 'if(1,2,3)'
+      expect(tokenizer.replace_aliases(input)).to eq('if(1,2,3)')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dentaku
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.3.1
 platform: ruby
 authors:
 - Solomon White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-04 00:00:00.000000000 Z
+date: 2019-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov