hayadentaku 3.5.7

data/spec/token_matcher_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'dentaku/token_matcher'
+
+describe Dentaku::TokenMatcher do
+  it 'with single category matches token category' do
+    matcher = described_class.new(:numeric)
+    token   = Dentaku::Token.new(:numeric, 5)
+
+    expect(matcher).to eq(token)
+  end
+
+  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)
+
+    expect(matcher).to eq(comparator)
+    expect(matcher).to eq(operator)
+    expect(matcher).not_to eq(numeric)
+  end
+
+  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)
+
+    expect(matcher).to eq(addition)
+    expect(matcher).not_to eq(subtraction)
+  end
+
+  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)
+
+    expect(matcher).to eq(add)
+    expect(matcher).to eq(sub)
+    expect(matcher).not_to eq(mul)
+    expect(matcher).not_to eq(div)
+  end
+
+  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)
+
+    expect(matcher).not_to eq(add)
+    expect(matcher).to eq(mul)
+    expect(matcher).to eq(cmp)
+  end
+
+  describe 'combining multiple tokens' do
+    let(:numeric) { described_class.new(:numeric) }
+    let(:string)  { described_class.new(:string) }
+
+    it 'matches either' do
+      either = numeric | string
+      expect(either).to eq(Dentaku::Token.new(:numeric, 5))
+      expect(either).to eq(Dentaku::Token.new(:string, 'rhubarb'))
+    end
+
+    it 'matches any value' do
+      value = described_class.value
+      expect(value).to eq(Dentaku::Token.new(:numeric, 8))
+      expect(value).to eq(Dentaku::Token.new(:string, 'apricot'))
+      expect(value).to eq(Dentaku::Token.new(:logical, false))
+      expect(value).not_to eq(Dentaku::Token.new(:function, :round))
+      expect(value).not_to eq(Dentaku::Token.new(:identifier, :hello))
+    end
+  end
+
+  describe 'stream matching' do
+    let(:stream) { token_stream(5, 11, 9, 24, :hello, 8) }
+
+    describe 'standard' do
+      let(:standard) { described_class.new(:numeric) }
+
+      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])
+
+        matched, substream = standard.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).not_to be_truthy
+      end
+    end
+
+    describe 'star' do
+      let(:star) { described_class.new(:numeric).star }
+
+      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])
+
+        matched, substream = star.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).to be_truthy
+      end
+    end
+
+    describe 'plus' do
+      let(:plus) { described_class.new(:numeric).plus }
+
+      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])
+
+        matched, substream = plus.match(stream, 4)
+        expect(substream).to be_empty
+        expect(matched).not_to be_truthy
+      end
+    end
+
+    describe 'arguments' do
+      it 'matches comma-separated values' 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])
+      end
+    end
+  end
+end

data/spec/token_scanner_spec.rb

@@ -0,0 +1,49 @@
+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(raw) : raw.to_i })
+  }
+  let(:custom)     { described_class.new(:identifier, '#\w+\b',
+    ->(raw) { raw.gsub('#', '').to_sym })
+  }
+
+  after { described_class.register_default_scanners }
+
+  it 'returns a token for a matching string' do
+    token = whitespace.scan(' ').first
+    expect(token.category).to eq(:whitespace)
+    expect(token.value).to eq(' ')
+  end
+
+  it 'returns falsy for a non-matching string' do
+    expect(whitespace.scan('A')).not_to be
+  end
+
+  it 'performs raw value conversion' do
+    token = numeric.scan('5').first
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(5)
+  end
+
+  it 'allows customizing available scanners' do
+    described_class.scanners = [:whitespace, :numeric]
+    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)
+  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)
+
+    token = custom.scan('#apple + #pear').first
+    expect(token.category).to eq(:identifier)
+    expect(token.value).to eq(:apple)
+  end
+end

data/spec/token_spec.rb

@@ -0,0 +1,16 @@
+require 'dentaku/token'
+
+describe Dentaku::Token do
+  it 'has a category and a value' do
+    token = Dentaku::Token.new(:numeric, 5)
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(5)
+    expect(token.is?(:numeric)).to be_truthy
+  end
+
+  it 'compares category and value to determine equality' do
+    t1 = Dentaku::Token.new(:numeric, 5)
+    t2 = Dentaku::Token.new(:numeric, 5)
+    expect(t1 == t2).to be_truthy
+  end
+end

data/spec/tokenizer_spec.rb

@@ -0,0 +1,375 @@
+require 'dentaku/exceptions'
+require 'dentaku/tokenizer'
+
+describe Dentaku::Tokenizer do
+  let(:tokenizer) { described_class.new }
+
+  it 'handles an empty expression' do
+    expect(tokenizer.tokenize('')).to be_empty
+  end
+
+  it 'tokenizes numeric literal in decimal' do
+    token = tokenizer.tokenize('80').first
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(80)
+  end
+
+  it 'tokenizes numeric literal in hexadecimal' do
+    token = tokenizer.tokenize('0x80').first
+    expect(token.category).to eq(:numeric)
+    expect(token.value).to eq(128)
+  end
+
+  it 'tokenizes numeric literal in scientific notation' do
+    %w( 6.02e23 .602E+24 ).each do |s|
+      tokens = tokenizer.tokenize(s)
+      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
+    tokens = tokenizer.tokenize('1+1')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([1, :add, 1])
+  end
+
+  it 'tokenizes unary minus' do
+    tokens = tokenizer.tokenize('-5')
+    expect(tokens.map(&:category)).to eq([:operator, :numeric])
+    expect(tokens.map(&:value)).to eq([:negate, 5])
+
+    tokens = tokenizer.tokenize('(-5)')
+    expect(tokens.map(&:category)).to eq([:grouping, :operator, :numeric, :grouping])
+    expect(tokens.map(&:value)).to eq([:open, :negate, 5, :close])
+
+    tokens = tokenizer.tokenize('{-5, -2}[-1]')
+    expect(tokens.map(&:category)).to eq([
+      :array,                                   # {
+      :operator, :numeric, :grouping,           # -5,
+      :operator, :numeric, :array,              # -2}
+      :access, :operator, :numeric, :access     # [-1]
+    ])
+    expect(tokens.map(&:value)).to eq([
+      :array_start,                     # {
+      :negate, 5, :comma,               # -5,
+      :negate, 2, :array_end,           # -2}
+      :lbracket, :negate, 1, :rbracket  # [-1]
+    ])
+
+    tokens = tokenizer.tokenize('if(-5 > x, -7, -8) - 9')
+    expect(tokens.map(&:category)).to eq([
+      :function, :grouping,                                      # if(
+      :operator, :numeric, :comparator, :identifier, :grouping,  # -5 > x,
+      :operator, :numeric, :grouping,                            # -7,
+      :operator, :numeric, :grouping,                            # -8)
+      :operator, :numeric                                        # - 9
+    ])
+    expect(tokens.map(&:value)).to eq([
+      :if, :open,                   # if(
+      :negate, 5, :gt, 'x', :comma, # -5 > x,
+      :negate, 7, :comma,           # -7,
+      :negate, 8, :close,           # -8)
+      :subtract, 9                  # - 9
+    ])
+  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 'tokenizes bitwise OR' do
+    tokens = tokenizer.tokenize('2 | 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :bitor, 3])
+  end
+
+  it 'tokenizes bitwise AND' do
+    tokens = tokenizer.tokenize('2 & 3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    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])
+    expect(tokens.map(&:value)).to eq([1, :divide, 1])
+  end
+
+  it 'tokenizes power operations in simple expressions' do
+    tokens = tokenizer.tokenize('10 ^ 2')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([10, :pow, 2])
+  end
+
+  it 'tokenizes power operations in complex expressions' do
+    tokens = tokenizer.tokenize('0 * 10 ^ -5')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric, :operator, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([0, :multiply, 10, :pow, :negate, 5])
+  end
+
+  it 'handles floating point operands' do
+    tokens = tokenizer.tokenize('1.5 * 3.7')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([1.5, :multiply, 3.7])
+  end
+
+  it 'does not require leading zero' do
+    tokens = tokenizer.tokenize('.5 * 3.7')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([0.5, :multiply, 3.7])
+  end
+
+  it 'accepts arbitrary identifiers' do
+    tokens = tokenizer.tokenize('sea_monkeys > 1500')
+    expect(tokens.map(&:category)).to eq([:identifier, :comparator, :numeric])
+    expect(tokens.map(&:value)).to eq(['sea_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'])
+  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'])
+  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 applied to left operand' do
+    tokens = tokenizer.tokenize('-2 + 3')
+    expect(tokens.map(&:category)).to eq([:operator, :numeric, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([:negate, 2, :add, 3])
+  end
+
+  it 'recognizes unary minus operator applied to right operand' do
+    tokens = tokenizer.tokenize('2 - -3')
+    expect(tokens.map(&:category)).to eq([:numeric, :operator, :operator, :numeric])
+    expect(tokens.map(&:value)).to eq([2, :subtract, :negate, 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])
+  end
+
+  it 'tokenizes "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])
+  end
+
+  it 'tokenizes "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])
+  end
+
+  it 'tokenizes "&&" for logical expressions' do
+    tokens = tokenizer.tokenize('octopi <= 7500 && 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])
+  end
+
+  it 'tokenizes "||" for logical expressions' do
+    tokens = tokenizer.tokenize('size < 3 || 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])
+  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))
+    expect(tokens.map(&:value)).to eq(['a', :lbracket, 1, :rbracket])
+  end
+
+  it 'detects unbalanced parentheses' do
+    expect { tokenizer.tokenize('(5+3') }.to raise_error(Dentaku::TokenizerError, /too many opening parentheses/)
+    expect { tokenizer.tokenize(')')    }.to raise_error(Dentaku::TokenizerError, /too many closing parentheses/)
+  end
+
+  it 'recognizes identifiers that share initial substrings with combinators' 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])
+  end
+
+  it 'tokenizes TRUE and FALSE literals' do
+    tokens = tokenizer.tokenize('true and false')
+    expect(tokens.length).to eq(3)
+    expect(tokens.map(&:category)).to eq([:logical, :combinator, :logical])
+    expect(tokens.map(&:value)).to eq([true, :and, false])
+
+    tokens = tokenizer.tokenize('true_lies and falsehoods')
+    expect(tokens.length).to eq(3)
+    expect(tokens.map(&:category)).to eq([:identifier, :combinator, :identifier])
+    expect(tokens.map(&:value)).to eq(['true_lies', :and, 'falsehoods'])
+  end
+
+  it 'tokenizes Time literals' do
+    tokens = tokenizer.tokenize('2017-01-01 2017-01-2 2017-1-03 2017-01-04 12:23:42 2017-1-5 1:2:3 2017-1-06 1:02:30 2017-01-07 12:34:56 Z 2017-01-08 1:2:3 +0800 2017-01-08T01:02:03.456Z')
+    expect(tokens.length).to eq(9)
+    expect(tokens.map(&:category)).to eq([:datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime, :datetime])
+    expect(tokens.map(&:value)).to eq([
+      Time.local(2017, 1, 1).to_datetime,
+      Time.local(2017, 1, 2).to_datetime,
+      Time.local(2017, 1, 3).to_datetime,
+      Time.local(2017, 1, 4, 12, 23, 42).to_datetime,
+      Time.local(2017, 1, 5, 1, 2, 3).to_datetime,
+      Time.local(2017, 1, 6, 1, 2, 30).to_datetime,
+      Time.utc(2017, 1, 7, 12, 34, 56).to_datetime,
+      Time.new(2017, 1, 8, 1, 2, 3, "+08:00").to_datetime,
+      Time.utc(2017, 1, 8, 1, 2, 3, 456000).to_datetime
+    ])
+  end
+
+  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 '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('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('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('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('8.2'), :close])
+    end
+
+    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)
+      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 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])
+      expect(tokens.map(&:value)).to eq([:exp!, :open, 5, :multiply, 3, :close])
+    end
+  end
+
+  describe 'aliases' do
+    let(:aliases) {
+      {
+        round: ['rrrrround!', 'redond'],
+        roundup: ['округлвверх'],
+        rounddown: ['округлвниз'],
+        if: ['если', 'cuando', '如果'],
+        max: ['макс', 'maximo'],
+        min: ['мин', 'minimo']
+      }
+    }
+
+    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)')
+    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)')
+    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())')
+    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)')
+    end
+  end
+end

data/spec/visitor/infix_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+require 'dentaku/visitor/infix'
+
+class ArrayProcessor
+  attr_reader :expression
+  include Dentaku::Visitor::Infix
+
+  def initialize
+    @expression = []
+  end
+
+  def visit_array(node)
+    @expression << "{"
+
+    head, *tail = node.value
+
+    process(head) if head
+
+    tail.each do |v|
+      @expression << ","
+      process(v)
+    end
+
+    @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
+
+  it 'supports array nodes' do
+    processor = ArrayProcessor.new
+    processor.visit(ast('{1, 2, 3}'))
+    expect(processor.expression).to eq ['{', '1', ',', '2', ',', '3', '}']
+  end
+
+  private
+
+  def ast(expression)
+    tokens = Dentaku::Tokenizer.new.tokenize(expression)
+    Dentaku::Parser.new(tokens).parse
+  end
+end