dentaku 3.2.0 → 3.5.1

data/spec/parser_spec.rb

@@ -1,189 +1,166 @@
 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
+
+  it 'evaluates a nested case statement with case-sensitivity' do
+    node = parse('CASE x WHEN 1 THEN CASE Y WHEN "A" THEN 2 WHEN "B" THEN 3 END END', { case_sensitive: true }, { case_sensitive: true })
+    expect(node.value("x" => 1, "y" => "A", "Y" => "B")).to eq(3)
+  end
+
+  it 'evaluates arrays' do
+    node = parse('{1, 2, 3}')
+    expect(node.value).to eq([1, 2, 3])
   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 too many operands' do
       expect {
-        described_class.new([this, also]).parse
+        parse("IF(1, 0, IF(1, 2, 3, 4))")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CASE a WHEN 1 THEN true ELSE THEN IF(1, 2, 3, 4) END")
       }.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 a parse error for bad grouping structure' do
+      expect {
+        parse(",")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("5, x")
+        described_class.new([five, comma, x]).parse
+      }.to raise_error(Dentaku::ParseError)
 
       expect {
-        described_class.new([fn]).parse
+        parse("5 + 5, x")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("{1, 2, }")
+      }.to raise_error(Dentaku::ParseError)
+
+      expect {
+        parse("CONCAT('1', '2', )")
+      }.to raise_error(Dentaku::ParseError)
+    end
+
+    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 {
+        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, parser_options = {}, tokenizer_options = {})
+    tokens = Dentaku::Tokenizer.new.tokenize(expr, tokenizer_options)
+    described_class.new(tokens, parser_options).parse
+  end
 end

data/spec/print_visitor_spec.rb

@@ -0,0 +1,66 @@
+require 'dentaku/print_visitor'
+require 'dentaku/tokenizer'
+require 'dentaku/parser'
+
+describe Dentaku::PrintVisitor do
+  it 'prints a representation of an AST' do
+    repr = roundtrip('5+4')
+    expect(repr).to eq('5 + 4')
+  end
+
+  it 'quotes string literals' do
+    repr = roundtrip('Concat(\'a\',   "B")')
+    expect(repr).to eq('CONCAT("a", "B")')
+  end
+
+  it 'handles unary operations on literals' do
+    repr = roundtrip('- 4')
+    expect(repr).to eq('-4')
+  end
+
+  it 'handles unary operations on trees' do
+    repr = roundtrip('- (5 + 5)')
+    expect(repr).to eq('-(5 + 5)')
+  end
+
+  it 'handles a complex arithmetic expression' do
+    repr = roundtrip('(((1 + 7) * (8 ^ 2)) / - (3.0 - apples))')
+    expect(repr).to eq('(1 + 7) * 8 ^ 2 / -(3.0 - apples)')
+  end
+
+  it 'handles a complex logical expression' do
+    repr = roundtrip('1 < 2 and 3 <= 4 or 5 > 6 AND 7 >= 8 OR 9 != 10 and true')
+    expect(repr).to eq('1 < 2 and 3 <= 4 or 5 > 6 and 7 >= 8 or 9 != 10 and true')
+  end
+
+  it 'handles a function call' do
+    repr = roundtrip('IF(a[0] = NULL, "five", \'seven\')')
+    expect(repr).to eq('IF(a[0] = NULL, "five", "seven")')
+  end
+
+  it 'handles a case statement' do
+    repr = roundtrip('case (a % 5) when 0 then a else b end')
+    expect(repr).to eq('CASE a % 5 WHEN 0 THEN a ELSE b END')
+  end
+
+  it 'handles a bitwise operators' do
+    repr = roundtrip('0xCAFE & 0xDECAF | 0xBEEF')
+    expect(repr).to eq('0xCAFE & 0xDECAF | 0xBEEF')
+  end
+
+  it 'handles a datetime literal' do
+    repr = roundtrip('2017-12-24 23:59:59')
+    expect(repr).to eq('2017-12-24 23:59:59')
+  end
+
+  private
+
+  def roundtrip(string)
+    described_class.new(parsed(string)).to_s
+  end
+
+  def parsed(string)
+    tokens = Dentaku::Tokenizer.new.tokenize(string)
+    Dentaku::Parser.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

@@ -25,6 +25,12 @@ describe Dentaku::Tokenizer do
       expect(tokens.map(&:category)).to eq([:numeric])
       expect(tokens.map(&:value)).to eq([6.02e23])
     end
+
+    tokens = tokenizer.tokenize('6E23')
+    expect(tokens.map(&:value)).to eq([0.6e24])
+
+    tokens = tokenizer.tokenize('6e-23')
+    expect(tokens.map(&:value)).to eq([0.6e-22])
   end
 
   it 'tokenizes addition' do
@@ -83,6 +89,18 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq([2, :bitand, 3])
   end
 
+  it 'tokenizes bitwise SHIFT LEFT' do
+    tokens = tokenizer.tokenize('2 << 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftleft, 3])
+  end
+
+  it 'tokenizes bitwise SHIFT RIGHT' do
+    tokens = tokenizer.tokenize('2 >> 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitshiftright, 3])
+  end
+
   it 'ignores whitespace' do
     tokens = tokenizer.tokenize('1     / 1     ')
     expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
@@ -179,6 +197,12 @@ describe Dentaku::Tokenizer do
     expect(tokens.map(&:value)).to eq(['size', :lt, 3, :or, 'admin', :eq, 1])
   end
 
+  it 'tokenizes curly brackets for array literals' do
+    tokens = tokenizer.tokenize('{}')
+    expect(tokens.map(&:category)).to eq(%i(array array))
+    expect(tokens.map(&:value)).to eq(%i(array_start array_end))
+  end
+
   it 'tokenizes square brackets for data structure access' do
     tokens = tokenizer.tokenize('a[1]')
     expect(tokens.map(&:category)).to eq(%i(identifier access numeric access))
@@ -225,43 +249,62 @@ describe Dentaku::Tokenizer do
     ])
   end
 
-  describe 'functions' do
-    it 'include IF' do
+  describe 'tokenizing function calls' do
+    it 'handles IF' 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, :open, 'x', :lt, 10, :comma, 'y', :comma, 'z', :close])
     end
 
-    it 'include ROUND/UP/DOWN' do
+    it 'handles 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, :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
+    it 'handles 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, :open, 8, :lt, 5, :close])
     end
 
+    it 'handles ANY/ALL' do
+      %i( any all ).each do |fn|
+        tokens = tokenizer.tokenize("#{fn}(users, u, u.age > 18)")
+        expect(tokens.length).to eq(10)
+        expect(tokens.map { |t| [t.category, t.value] }).to eq([
+          [:function,   fn     ], # function call (any/all)
+          [:grouping,   :open  ], # (
+          [:identifier, "users"], # users
+          [:grouping,   :comma ], # ,
+          [:identifier, "u"    ], # u
+          [:grouping,   :comma ], # ,
+          [:identifier, "u.age"], # u.age
+          [:comparator, :gt    ], # >
+          [:numeric,    18     ], # 18
+          [:grouping,   :close ]  # )
+        ])
+      end
+    end
+
     it 'handles whitespace after function name' do
       tokens = tokenizer.tokenize('not (8 < 5)')
       expect(tokens.length).to eq(6)
@@ -269,7 +312,7 @@ describe Dentaku::Tokenizer do
       expect(tokens.map(&:value)).to eq([:not, :open, 8, :lt, 5, :close])
     end
 
-    it 'can end with a bang' do
+    it 'handles when function ends with a bang' do
       tokens = tokenizer.tokenize('exp!(5 * 3)')
       expect(tokens.length).to eq(6)
       expect(tokens.map(&:category)).to eq([:function, :grouping, :numeric, :operator, :numeric, :grouping])
@@ -292,25 +335,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

data/spec/visitor/infix_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+require 'dentaku/visitor/infix'
+
+class ArrayProcessor
+  attr_reader :expression
+  include Dentaku::Visitor::Infix
+
+  def initialize
+    @expression = []
+  end
+
+  def process(node)
+    @expression << node.to_s
+  end
+end
+
+RSpec.describe Dentaku::Visitor::Infix do
+  it 'generates array representation of operation' do
+    processor = ArrayProcessor.new
+    processor.visit(ast('5 + 3'))
+    expect(processor.expression).to eq ['5', '+', '3']
+  end
+
+  private
+
+  def ast(expression)
+    tokens = Dentaku::Tokenizer.new.tokenize(expression)
+    Dentaku::Parser.new(tokens).parse
+  end
+end