dentaku 1.0.0 → 1.1.0

data/spec/dentaku_spec.rb

@@ -1,11 +1,11 @@
 require 'dentaku'
 
 describe Dentaku do
-  it 'should evaulate an expression' do
-    Dentaku('5+3').should eql(8)
+  it 'evaulates an expression' do
+    expect(Dentaku('5+3')).to eql(8)
   end
 
-  it 'should bind values to variables' do
-    Dentaku('oranges > 7', {:oranges => 10}).should be_true
+  it 'binds values to variables' do
+    expect(Dentaku('oranges > 7', {:oranges => 10})).to be_truthy
   end
 end

data/spec/evaluator_spec.rb

@@ -5,104 +5,104 @@ describe Dentaku::Evaluator do
   let(:evaluator) { Dentaku::Evaluator.new }
 
   describe 'rule scanning' do
-    it 'should find a matching rule' do
+    it 'finds a matching rule' do
       rule   = [Dentaku::TokenMatcher.new(:numeric, nil)]
       stream = [Dentaku::Token.new(:numeric, 1), Dentaku::Token.new(:operator, :add), Dentaku::Token.new(:numeric, 1)]
       position, _match = evaluator.find_rule_match(rule, stream)
-      position.should eq(0)
+      expect(position).to eq(0)
     end
   end
 
   describe 'evaluating' do
-    it 'empty expression should be truthy' do
-      evaluator.evaluate([]).should be
+    it 'empty expression is be truthy' do
+      expect(evaluator.evaluate([])).to be
     end
 
-    it 'empty expression should equal 0' do
-      evaluator.evaluate([]).should eq(0)
+    it 'empty expression equals 0' do
+      expect(evaluator.evaluate([])).to eq(0)
     end
 
-    it 'single numeric should return value' do
-      evaluator.evaluate([Dentaku::Token.new(:numeric, 10)]).should eq(10)
-      evaluator.evaluate([Dentaku::Token.new(:string,  'a')]).should eq('a')
+    it 'single numeric evaluates to its value' do
+      expect(evaluator.evaluate([Dentaku::Token.new(:numeric, 10)])).to eq(10)
+      expect(evaluator.evaluate([Dentaku::Token.new(:string,  'a')])).to eq('a')
     end
 
-    it 'should evaluate one apply step' do
+    it 'evaluates one apply step' do
       stream   = token_stream(1, :add, 1, :add, 1)
       expected = token_stream(2, :add, 1)
 
-      evaluator.evaluate_step(stream, 0, 3, :apply).should eq(expected)
+      expect(evaluator.evaluate_step(stream, 0, 3, :apply)).to eq(expected)
     end
 
-    it 'should evaluate one grouping step' do
+    it 'evaluates one grouping step' do
       stream   = token_stream(:open, 1, :add, 1, :close, :multiply, 5)
       expected = token_stream(2, :multiply, 5)
 
-      evaluator.evaluate_step(stream, 0, 5, :evaluate_group).should eq(expected)
+      expect(evaluator.evaluate_step(stream, 0, 5, :evaluate_group)).to 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)
+      expect(evaluator.evaluate(token_stream(:subtract, 1))).to eq(-1)
+      expect(evaluator.evaluate(token_stream(1, :subtract, :subtract, 1))).to eq(2)
     end
 
     it 'supports unary percentage' do
-      evaluator.evaluate(token_stream(50, :mod)).should eq(0.5)
-      evaluator.evaluate(token_stream(50, :mod, :multiply, 100)).should eq(50)
+      expect(evaluator.evaluate(token_stream(50, :mod))).to eq(0.5)
+      expect(evaluator.evaluate(token_stream(50, :mod, :multiply, 100))).to eq(50)
     end
 
     describe 'maths' do
-      it 'should perform addition' do
-        evaluator.evaluate(token_stream(1, :add, 1)).should eq(2)
+      it 'performs addition' do
+        expect(evaluator.evaluate(token_stream(1, :add, 1))).to eq(2)
       end
 
-      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)
+      it 'respects order of precedence' do
+        expect(evaluator.evaluate(token_stream(1, :add, 1, :multiply, 5))).to eq(6)
+        expect(evaluator.evaluate(token_stream(2, :add, 10, :mod, 2))).to eq(2)
       end
 
-      it 'should respect explicit grouping' do
-        evaluator.evaluate(token_stream(:open, 1, :add, 1, :close, :multiply, 5)).should eq(10)
+      it 'respects explicit grouping' do
+        expect(evaluator.evaluate(token_stream(:open, 1, :add, 1, :close, :multiply, 5))).to eq(10)
       end
 
-      it 'should return floating point from division when there is a remainder' do
-        evaluator.evaluate(token_stream(5, :divide, 4)).should eq(1.25)
+      it 'returns floating point from division when there is a remainder' do
+        expect(evaluator.evaluate(token_stream(5, :divide, 4))).to eq(1.25)
       end
     end
 
     describe 'functions' do
-      it 'should be evaluated' do
-        evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :close)).should eq 2
-        evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :comma, 2, :close)).should eq 1.67
-        evaluator.evaluate(token_stream(:roundup,   :open, 5, :divide, 1.2, :close)).should eq 5
-        evaluator.evaluate(token_stream(:rounddown, :open, 5, :divide, 1.2, :close)).should eq 4
+      it 'is evaluated' do
+        expect(evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :close))).to eq 2
+        expect(evaluator.evaluate(token_stream(:round,     :open, 5, :divide, 3.0, :comma, 2, :close))).to eq 1.67
+        expect(evaluator.evaluate(token_stream(:roundup,   :open, 5, :divide, 1.2, :close))).to eq 5
+        expect(evaluator.evaluate(token_stream(:rounddown, :open, 5, :divide, 1.2, :close))).to eq 4
       end
     end
 
     describe 'logic' do
-      it 'should evaluate conditional' do
-        evaluator.evaluate(token_stream(5, :gt, 1)).should be_true
+      it 'evaluates conditional' do
+        expect(evaluator.evaluate(token_stream(5, :gt, 1))).to be_truthy
       end
 
-      it 'should expand inequality ranges' do
+      it 'expands inequality ranges' do
         stream   = token_stream(5, :lt, 10, :le, 10)
         expected = token_stream(5, :lt, 10, :and, 10, :le, 10)
-        evaluator.evaluate_step(stream, 0, 5, :expand_range).should eq(expected)
+        expect(evaluator.evaluate_step(stream, 0, 5, :expand_range)).to eq(expected)
 
-        evaluator.evaluate(token_stream(5, :lt, 10, :le, 10)).should be_true
-        evaluator.evaluate(token_stream(3, :gt,  5, :ge,  1)).should be_false
+        expect(evaluator.evaluate(token_stream(5, :lt, 10, :le, 10))).to be_truthy
+        expect(evaluator.evaluate(token_stream(3, :gt,  5, :ge,  1))).to be_falsey
 
-        lambda { evaluator.evaluate(token_stream(3, :gt,  2, :lt,   1)) }.should raise_error
+        expect { evaluator.evaluate(token_stream(3, :gt,  2, :lt,   1)) }.to raise_error
       end
 
-      it 'should evaluate combined conditionals' do
-        evaluator.evaluate(token_stream(5, :gt, 1, :or, :false)).should be_true
-        evaluator.evaluate(token_stream(5, :gt, 1, :and, :false)).should be_false
+      it 'evaluates combined conditionals' do
+        expect(evaluator.evaluate(token_stream(5, :gt, 1, :or, :false))).to be_truthy
+        expect(evaluator.evaluate(token_stream(5, :gt, 1, :and, :false))).to be_falsey
       end
 
-      it 'should support negation of a logical value' do
-        evaluator.evaluate(token_stream(:not, :open, 5, :gt, 1, :or,  :false, :close)).should be_false
-        evaluator.evaluate(token_stream(:not, :open, 5, :gt, 1, :and, :false, :close)).should be_true
+      it 'negates a logical value' do
+        expect(evaluator.evaluate(token_stream(:not, :open, 5, :gt, 1, :or,  :false, :close))).to be_falsey
+        expect(evaluator.evaluate(token_stream(:not, :open, 5, :gt, 1, :and, :false, :close))).to be_truthy
       end
     end
   end

data/spec/expression_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dentaku/expression'
+
+describe Dentaku::Expression do
+  describe 'an all literal expression' do
+    it 'is fully bound' do
+      static = described_class.new('1 + 1')
+      expect(static).not_to be_unbound
+    end
+  end
+
+  describe 'an expression with variable identifiers' do
+    it 'is unbound' do
+      dynamic = described_class.new('a > 5')
+      expect(dynamic).to be_unbound
+    end
+
+    describe 'with values set for all variables' do
+      it 'is fully bound' do
+        dynamic = described_class.new('a > 5', {a: 7})
+        expect(dynamic).not_to be_unbound
+      end
+    end
+  end
+end

data/spec/external_function_spec.rb

@@ -34,24 +34,24 @@ describe Dentaku::Calculator do
         c.add_functions(fns)
       end
 
-      it 'should include NOW' do
+      it 'includes NOW' do
         now = with_external_funcs.evaluate('NOW()')
-        now.should_not be_nil
-        now.should_not be_empty
+        expect(now).not_to be_nil
+        expect(now).not_to 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)
+      it 'includes EXP' do
+        expect(with_external_funcs.evaluate('EXP(2,3)')).to eq(8)
+        expect(with_external_funcs.evaluate('EXP(3,2)')).to eq(9)
+        expect(with_external_funcs.evaluate('EXP(mantissa,exponent)', mantissa: 2, exponent: 4)).to eq(16)
       end
 
-      it 'should include MAX' do
-        with_external_funcs.evaluate('MAX(8,6,7,5,3,0,9)').should eq(9)
+      it 'includes MAX' do
+        expect(with_external_funcs.evaluate('MAX(8,6,7,5,3,0,9)')).to eq(9)
       end
 
-      it 'should include MIN' do
-        with_external_funcs.evaluate('MIN(8,6,7,5,3,0,9)').should eq(0)
+      it 'includes MIN' do
+        expect(with_external_funcs.evaluate('MIN(8,6,7,5,3,0,9)')).to eq(0)
       end
     end
   end

data/spec/token_matcher_spec.rb

@@ -2,102 +2,102 @@ require 'spec_helper'
 require 'dentaku/token_matcher'
 
 describe Dentaku::TokenMatcher do
-  it 'with single category should match token category' do
+  it 'with single category matches token category' do
     matcher = described_class.new(:numeric)
     token   = Dentaku::Token.new(:numeric, 5)
 
-    matcher.should == token
+    expect(matcher).to eq(token)
   end
 
-  it 'with multiple categories should match any included token category' do
+  it 'with multiple categories matches any included token category' do
     matcher    = described_class.new([:comparator, :operator])
     numeric    = Dentaku::Token.new(:numeric, 5)
     comparator = Dentaku::Token.new(:comparator, :lt)
     operator   = Dentaku::Token.new(:operator, :add)
 
-    matcher.should == comparator
-    matcher.should == operator
-    matcher.should_not == numeric
+    expect(matcher).to eq(comparator)
+    expect(matcher).to eq(operator)
+    expect(matcher).not_to eq(numeric)
   end
 
-  it 'with single category and value should match token category and value' do
+  it 'with single category and value matches token category and value' do
     matcher     = described_class.new(:operator, :add)
     addition    = Dentaku::Token.new(:operator, :add)
     subtraction = Dentaku::Token.new(:operator, :subtract)
 
-    matcher.should == addition
-    matcher.should_not == subtraction
+    expect(matcher).to eq(addition)
+    expect(matcher).not_to eq(subtraction)
   end
 
-  it 'with multiple values should match any included token value' do
+  it 'with multiple values matches any included token value' do
     matcher = described_class.new(:operator, [:add, :subtract])
     add = Dentaku::Token.new(:operator, :add)
     sub = Dentaku::Token.new(:operator, :subtract)
     mul = Dentaku::Token.new(:operator, :multiply)
     div = Dentaku::Token.new(:operator, :divide)
 
-    matcher.should == add
-    matcher.should == sub
-    matcher.should_not == mul
-    matcher.should_not == div
+    expect(matcher).to eq(add)
+    expect(matcher).to eq(sub)
+    expect(matcher).not_to eq(mul)
+    expect(matcher).not_to eq(div)
   end
 
-  it 'should be invertible' do
+  it 'is invertible' do
     matcher = described_class.new(:operator, [:add, :subtract]).invert
     add = Dentaku::Token.new(:operator, :add)
     mul = Dentaku::Token.new(:operator, :multiply)
     cmp = Dentaku::Token.new(:comparator, :lt)
 
-    matcher.should_not == add
-    matcher.should == mul
-    matcher.should == cmp
+    expect(matcher).not_to eq(add)
+    expect(matcher).to eq(mul)
+    expect(matcher).to eq(cmp)
   end
 
   describe 'stream matching' do
     let(:stream) { token_stream(5, 11, 9, 24, :hello, 8) }
 
-    describe :standard do
+    describe 'standard' do
       let(:standard) { described_class.new(:numeric) }
 
-      it 'should match zero or more occurrences in a token stream' do
-        substream = standard.match(stream)
-        substream.should be_matched
-        substream.length.should eq 1
-        substream.map(&:value).should eq [5]
+      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]
 
-        substream = standard.match(stream, 4)
-        substream.should be_empty
-        substream.should_not be_matched
+        matched, substream = standard.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).not_to be_truthy
       end
     end
 
-    describe :star do
+    describe 'star' do
       let(:star) { described_class.new(:numeric).star }
 
-      it 'should match zero or more occurrences in a token stream' do
-        substream = star.match(stream)
-        substream.should be_matched
-        substream.length.should eq 4
-        substream.map(&:value).should eq [5, 11, 9, 24]
+      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]
 
-        substream = star.match(stream, 4)
-        substream.should be_empty
-        substream.should be_matched
+        matched, substream = star.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).to be_truthy
       end
     end
 
-    describe :plus do
+    describe 'plus' do
       let(:plus) { described_class.new(:numeric).plus }
 
-      it 'should match one or more occurrences in a token stream' do
-        substream = plus.match(stream)
-        substream.should be_matched
-        substream.length.should eq 4
-        substream.map(&:value).should eq [5, 11, 9, 24]
+      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]
 
-        substream = plus.match(stream, 4)
-        substream.should be_empty
-        substream.should_not be_matched
+        matched, substream = plus.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).not_to be_truthy
       end
     end
   end

data/spec/token_scanner_spec.rb

@@ -2,26 +2,26 @@ require 'dentaku/token_scanner'
 
 describe Dentaku::TokenScanner do
   let(:whitespace) { described_class.new(:whitespace, '\s') }
-  let(:numeric)    { described_class.new(:numeric,    '(\d+(\.\d+)?|\.\d+)', lambda{|raw| raw =~ /\./ ? raw.to_f : raw.to_i }) }
+  let(:numeric)    { described_class.new(:numeric,    '(\d+(\.\d+)?|\.\d+)', lambda{|raw| raw =~ /\./ ? BigDecimal.new(raw) : raw.to_i }) }
 
-  it 'should return a token for a matching string' do
+  it 'returns a token for a matching string' do
     token = whitespace.scan(' ')
-    token.category.should eq(:whitespace)
-    token.value.should eq(' ')
+    expect(token.category).to eq(:whitespace)
+    expect(token.value).to eq(' ')
   end
 
-  it 'should return falsy for a non-matching string' do
-    whitespace.scan('A').should_not be
+  it 'returns falsy for a non-matching string' do
+    expect(whitespace.scan('A')).not_to be
   end
 
-  it 'should perform raw value conversion' do
+  it 'performs raw value conversion' do
     token = numeric.scan('5')
-    token.category.should eq(:numeric)
-    token.value.should eq(5)
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(5)
   end
 
-  it 'should return a list of all configured scanners' do
-    described_class.scanners.length.should eq 10
+  it 'returns a list of all configured scanners' do
+    expect(described_class.scanners.length).to eq 10
   end
 end
 

data/spec/token_spec.rb

@@ -1,10 +1,10 @@
 require 'dentaku/token'
 
 describe Dentaku::Token do
-  it 'should have a category and a value' do
+  it 'has a category and a value' do
     token = Dentaku::Token.new(:numeric, 5)
-    token.category.should eq(:numeric)
-    token.value.should eq(5)
-    token.is?(:numeric).should be_true
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(5)
+    expect(token.is?(:numeric)).to be_truthy
   end
 end

data/spec/tokenizer_spec.rb

@@ -3,117 +3,135 @@ require 'dentaku/tokenizer'
 describe Dentaku::Tokenizer do
   let(:tokenizer) { described_class.new }
 
-  it 'should handle an empty expression' do
-    tokenizer.tokenize('').should be_empty
+  it 'handles an empty expression' do
+    expect(tokenizer.tokenize('')).to be_empty
   end
 
-  it 'should tokenize addition' do
+  it 'tokenizes addition' do
     tokens = tokenizer.tokenize('1+1')
-    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
-    tokens.map(&:value).should eq([1, :add, 1])
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([1, :add, 1])
+  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])
+  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])
+  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])
   end
 
-  it 'should ignore whitespace' do
+  it 'ignores whitespace' do
     tokens = tokenizer.tokenize('1     / 1     ')
-    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
-    tokens.map(&:value).should eq([1, :divide, 1])
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([1, :divide, 1])
   end
 
-  it 'should handle floating point' do
+  it 'handles floating point' do
     tokens = tokenizer.tokenize('1.5 * 3.7')
-    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
-    tokens.map(&:value).should eq([1.5, :multiply, 3.7])
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([1.5, :multiply, 3.7])
   end
 
-  it 'should not require leading zero' do
+  it 'does not require leading zero' do
     tokens = tokenizer.tokenize('.5 * 3.7')
-    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
-    tokens.map(&:value).should eq([0.5, :multiply, 3.7])
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([0.5, :multiply, 3.7])
   end
 
-  it 'should accept arbitrary identifiers' do
+  it 'accepts arbitrary identifiers' do
     tokens = tokenizer.tokenize('monkeys > 1500')
-    tokens.map(&:category).should eq([:identifier, :comparator, :numeric])
-    tokens.map(&:value).should eq([:monkeys, :gt, 1500])
+    expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
+    expect(tokens.map(&:value)).to eq([:monkeys, :gt, 1500])
   end
 
-  it 'should recognize double-quoted strings' do
+  it 'recognizes double-quoted strings' do
     tokens = tokenizer.tokenize('animal = "giraffe"')
-    tokens.map(&:category).should eq([:identifier, :comparator, :string])
-    tokens.map(&:value).should eq([:animal, :eq, 'giraffe'])
+    expect(tokens.map(&:category)).to eq([:identifier, :comparator, :string])
+    expect(tokens.map(&:value)).to eq([:animal, :eq, 'giraffe'])
   end
 
-  it 'should recognize single-quoted strings' do
+  it 'recognizes single-quoted strings' do
     tokens = tokenizer.tokenize("animal = 'giraffe'")
-    tokens.map(&:category).should eq([:identifier, :comparator, :string])
-    tokens.map(&:value).should eq([:animal, :eq, 'giraffe'])
+    expect(tokens.map(&:category)).to eq([:identifier, :comparator, :string])
+    expect(tokens.map(&:value)).to eq([:animal, :eq, 'giraffe'])
   end
 
-  it 'should match "<=" before "<"' do
+  it 'matches "<=" before "<"' do
     tokens = tokenizer.tokenize('perimeter <= 7500')
-    tokens.map(&:category).should eq([:identifier, :comparator, :numeric])
-    tokens.map(&:value).should eq([:perimeter, :le, 7500])
+    expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
+    expect(tokens.map(&:value)).to eq([:perimeter, :le, 7500])
   end
 
-  it 'should match "and" for logical expressions' do
+  it 'matches "and" for logical expressions' do
     tokens = tokenizer.tokenize('octopi <= 7500 AND sharks > 1500')
-    tokens.map(&:category).should eq([:identifier, :comparator, :numeric, :combinator, :identifier, :comparator, :numeric])
-    tokens.map(&:value).should eq([:octopi, :le, 7500, :and, :sharks, :gt, 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])
   end
 
-  it 'should match "or" for logical expressions' do
+  it 'matches "or" for logical expressions' do
     tokens = tokenizer.tokenize('size < 3 or admin = 1')
-    tokens.map(&:category).should eq([:identifier, :comparator, :numeric, :combinator, :identifier, :comparator, :numeric])
-    tokens.map(&:value).should eq([:size, :lt, 3, :or, :admin, :eq, 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])
   end
 
-  it 'should detect unbalanced parentheses' do
-    lambda { tokenizer.tokenize('(5+3') }.should raise_error
-    lambda { tokenizer.tokenize(')')    }.should raise_error
+  it 'detects unbalanced parentheses' do
+    expect { tokenizer.tokenize('(5+3') }.to raise_error
+    expect { tokenizer.tokenize(')')    }.to raise_error
   end
 
-  it 'should recognize identifiers that share initial substrings with combinators' do
+  it 'recognizes identifiers that share initial substrings with combinators' do
     tokens = tokenizer.tokenize('andover < 10')
-    tokens.length.should eq(3)
-    tokens.map(&:category).should eq([:identifier, :comparator, :numeric])
-    tokens.map(&:value).should eq([:andover, :lt, 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])
   end
 
   describe 'functions' do
     it 'include IF' do
       tokens = tokenizer.tokenize('if(x < 10, y, z)')
-      tokens.length.should eq(10)
-      tokens.map(&:category).should eq([:function, :grouping, :identifier, :comparator, :numeric, :grouping, :identifier, :grouping, :identifier, :grouping])
-      tokens.map(&:value).should eq([:if, :open, :x, :lt, 10, :comma, :y, :comma, :z, :close])
+      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, :open, :x, :lt, 10, :comma, :y, :comma, :z, :close])
     end
 
     it 'include ROUND/UP/DOWN' do
       tokens = tokenizer.tokenize('round(8.2)')
-      tokens.length.should eq(4)
-      tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping])
-      tokens.map(&:value).should eq([:round, :open, 8.2, :close])
+      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])
 
       tokens = tokenizer.tokenize('round(8.75, 1)')
-      tokens.length.should eq(6)
-      tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping, :numeric, :grouping])
-      tokens.map(&:value).should eq([:round, :open, 8.75, :comma, 1, :close])
+      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])
 
       tokens = tokenizer.tokenize('ROUNDUP(8.2)')
-      tokens.length.should eq(4)
-      tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping])
-      tokens.map(&:value).should eq([:roundup, :open, 8.2, :close])
+      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])
 
       tokens = tokenizer.tokenize('RoundDown(8.2)')
-      tokens.length.should eq(4)
-      tokens.map(&:category).should eq([:function, :grouping, :numeric, :grouping])
-      tokens.map(&:value).should eq([:rounddown, :open, 8.2, :close])
+      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])
     end
 
     it 'include NOT' do
       tokens = tokenizer.tokenize('not(8 < 5)')
-      tokens.length.should eq(6)
-      tokens.map(&:category).should eq([:function, :grouping, :numeric, :comparator, :numeric, :grouping])
-      tokens.map(&:value).should eq([:not, :open, 8, :lt, 5, :close])
+      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, :open, 8, :lt, 5, :close])
     end
   end
 end