csv_decision2 0.5.1

data/spec/csv_decision/input_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Input do
+  it 'rejects a non-hash or empty hash value' do
+    expect { CSVDecision::Input.parse(table: nil, input: [], symbolize_keys: true ) }
+      .to raise_error(ArgumentError, 'input must be a non-empty hash')
+    expect { CSVDecision::Input.parse(table: nil, input: {}, symbolize_keys: true ) }
+      .to raise_error(ArgumentError, 'input must be a non-empty hash')
+  end
+
+  it 'processes input hash with symbolize_keys: true' do
+    data = <<~DATA
+      IN :input, OUT :output, IN: input1
+      input0,    output0,     input1
+      input0,    output1,
+    DATA
+
+    table = CSVDecision.parse(data)
+
+    input = { 'input' => 'input0', input1: 'input1' }
+    expected = {
+      hash: { input: 'input0', input1: 'input1' },
+      scan_cols: { 0 => 'input0', 2 => 'input1'},
+      key: 'input0'
+    }
+
+    result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: true)
+
+    expect(result).to eql expected
+    expect(result[:hash]).not_to equal expected[:hash]
+  end
+
+  it 'processes input hash with symbolize_keys: false' do
+    data = <<~DATA
+      IN :input, OUT :output, IN: input1
+      input0,    output0,     input1
+      input0,    output1,
+    DATA
+
+    table = CSVDecision.parse(data)
+    input = { input: 'input0', input1: 'input1' }
+    expected = {
+      hash: input,
+      scan_cols: { 0 => 'input0', 2 => 'input1'},
+      key: 'input0'
+    }
+
+    result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: false)
+
+    expect(result).to eql expected
+    expect(result[:hash]).to equal expected[:hash]
+  end
+end

data/spec/csv_decision/load_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Load do
+  path = Pathname(File.join(CSVDecision.root, 'spec/data/valid'))
+
+  it "loads all valid CSV files in the directory" do
+    tables = CSVDecision.load(path, first_match: false, regexp_implicit: true)
+    expect(tables).to be_a Hash
+    expect(tables.count).to eq Dir[path.join('*.csv')].count
+
+    tables.each_pair do |name, table|
+      expect(name).to be_a(Symbol)
+      expect(table).to be_a(CSVDecision::Table)
+    end
+  end
+
+  it 'rejects an invalid path name' do
+    expect { CSVDecision.load('path') }
+      .to raise_error(ArgumentError, 'path argument must be a Pathname')
+  end
+
+  it 'rejects an invalid folder name' do
+    expect { CSVDecision.load(Pathname('path')) }
+      .to raise_error(ArgumentError, 'path argument not a valid folder')
+  end
+end

data/spec/csv_decision/matchers/function_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Function do
+  subject { described_class.new }
+
+  describe '#new' do
+    it { is_expected.to be_a CSVDecision::Matchers::Function }
+    it { is_expected.to be_a CSVDecision::Matchers::Matcher }
+    it { is_expected.to respond_to(:matches?).with(1).argument }
+  end
+
+  context 'cell value recognition' do
+    cells = {
+      ':=function' => { operator: ':=', name: 'function' },
+      ':=function()' => { operator: ':=', name: 'function', args:'()' },
+      ':=function(arg: value)' => { operator: ':=', name: 'function', args:'(arg: value)' },
+      ':= !function(arg: value)' => { operator: ':=', negate: '!', name: 'function', args:'(arg: value)' },
+      '== ! func(arg: val)' => { operator: '==', negate: '!', name: 'func', args:'(arg: val)' },
+    }
+    cells.each_pair do |cell, expected|
+      it "recognises #{cell} as a function" do
+        match = CSVDecision::Matchers::Function::FUNCTION_RE.match(cell)
+        expect(match['operator']).to eq expected[:operator]
+        expect(match['name']).to eq expected[:name]
+      end
+    end
+  end
+
+  describe '#matches?' do
+    matcher = described_class.new
+
+    # context 'symbol expression matches value to hash data' do
+    #   examples = [
+    #     { cell:  ':col',   value:  0,  hash: { col:  0 },  result: true },
+    #     { cell:  ':col',   value: '0', hash: { col: '0' }, result: true },
+    #     { cell:  ':col',   value:  0,  hash: { col: '0' }, result: false },
+    #     { cell:  ':col',   value: '0', hash: { col:  0 },  result: false },
+    #     { cell:  ':col',   value:  1,  hash: { col:  0 },  result: false },
+    #     { cell:  ':key',   value:  0,  hash: { col:  0 },  result: false },
+    #     { cell: '!=:col',  value:  0,  hash: { col:  0 },  result: false },
+    #     { cell: '!=:col',  value: '0', hash: { col: '0' }, result: false },
+    #     { cell: '!=:col',  value:  0,  hash: { col: '0' }, result: true },
+    #     { cell: '!=:col',  value: '0', hash: { col:  0 },  result: true },
+    #     { cell: '!=:col',  value:  1,  hash: { col:  0 },  result: true },
+    #     { cell: '!=:key',  value:  0,  hash: { col:  0 },  result: true },
+    #     { cell:  '>:col',  value:  1,  hash: { col:  0 },  result: true },
+    #     { cell:  '>:col',  value:  0,  hash: { col:  1 },  result: false },
+    #     { cell:  '<:col',  value:  0,  hash: { col:  1 },  result: true },
+    #     { cell:  '<:col',  value:  1,  hash: { col:  0 },  result: false },
+    #     { cell:  '= :col', value:  0,  hash: { col:  0 },  result: true },
+    #     { cell:  '==:col', value:  0,  hash: { col:  0 },  result: true },
+    #     { cell:  ':=:col', value:  0,  hash: { col:  0 },  result: true },
+    #     { cell:  '= :col', value: '0', hash: { col:  0 },  result: false },
+    #     { cell:  '>=:col', value:  1,  hash: { col:  0 },  result: true },
+    #     { cell:  '>=:col', value:  0,  hash: { col:  1 },  result: false },
+    #     { cell:  '<=:col', value:  0,  hash: { col:  1 },  result: true },
+    #     { cell:  '<=:col', value:  1,  hash: { col:  0 },  result: false },
+    #     { cell:  '<=:col', value: '1', hash: { col:  1 },  result: false },
+    #   ]
+    #
+    #   examples.each do |ex|
+    #     it "cell #{ex[:cell]} matches value: #{ex[:value]} to hash: #{ex[:hash]}" do
+    #       proc = matcher.matches?(ex[:cell])
+    #       expect(proc).to be_a(CSVDecision::Proc)
+    #       expect(proc.function.call(ex[:value], ex[:hash])).to eq ex[:result]
+    #     end
+    #   end
+    # end
+
+    context 'does not match a non-function string' do
+      data = ['1', 'abc', 'abc.*def', '-1..1', '0...3']
+
+      data.each do |cell|
+        it "cell #{cell} is not a function" do
+          expect(matcher.matches?(cell)).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/csv_decision/matchers/guard_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Guard do
+  subject { described_class.new }
+
+  describe '#new' do
+    it { is_expected.to be_a CSVDecision::Matchers::Guard }
+    it { is_expected.to be_a CSVDecision::Matchers::Matcher }
+    it { is_expected.to respond_to(:matches?).with(1).argument }
+  end
+
+  describe '#matches?' do
+    matcher = described_class.new
+
+    context 'symbol expression matches hash data' do
+      examples = [
+        # Integer equality
+        { cell: ':col == 0',   hash: { col:   0  }, result: true },
+        { cell: ':col == 0',   hash: { col:  '0' }, result: true },
+        { cell: ':col == 0',   hash: { col:   1 },  result: false },
+        { cell: ':col == 0',   hash: { col:  '1' }, result: false },
+        { cell: ':col == 0',   hash: { col:  nil }, result: false },
+        # Integer inequality
+        { cell: ':col != 0',   hash: { col:   0  }, result: false },
+        { cell: ':col != 0',   hash: { col:  '0' }, result: false },
+        { cell: ':col != 0',   hash: { col:   1 },  result: true },
+        { cell: ':col != 0',   hash: { col:  '1' }, result: true },
+        { cell: ':col != 0',   hash: { col:  nil }, result: true },
+        # Kind of silly, but valid
+        { cell: '!:col = 0',   hash: { col:   0  }, result: false },
+        { cell: '!:col = 0',   hash: { col:  '0' }, result: false },
+        { cell: '!:col = 0',   hash: { col:   1 },  result: true },
+        { cell: '!:col = 0',   hash: { col:  '1' }, result: true },
+        { cell: '!:col = 0',   hash: { col:  nil }, result: true },
+        # Integer compares
+        { cell: ':col > 0',   hash: { col:   0  }, result: false },
+        { cell: ':col > 0',   hash: { col:  '0' }, result: false },
+        { cell: ':col > 0',   hash: { col:   1 },  result: true },
+        { cell: ':col > 0',   hash: { col:  '1' }, result: true },
+        { cell: ':col > 0',   hash: { col:  nil }, result: nil },
+        { cell: ':col >=0',   hash: { col:   0  }, result: true },
+        { cell: ':col >=0',   hash: { col:  '0' }, result: true },
+        { cell: ':col >=0',   hash: { col:  -1 },  result: false },
+        { cell: ':col >=0',   hash: { col: '-1' }, result: false },
+        { cell: ':col >=0',   hash: { col:  nil }, result: nil },
+        { cell: ':col < 0',   hash: { col:   0  }, result: false },
+        { cell: ':col < 0',   hash: { col:  '0' }, result: false },
+        { cell: ':col < 0',   hash: { col:  -1 },  result: true },
+        { cell: ':col < 0',   hash: { col: '-1' }, result: true },
+        { cell: ':col < 0',   hash: { col:  nil }, result: nil },
+        { cell: ':col <=0',   hash: { col:   0  }, result: true },
+        { cell: ':col <=0',   hash: { col:  '0' }, result: true },
+        { cell: ':col <=0',   hash: { col:   1 },  result: false },
+        { cell: ':col <=0',   hash: { col:  '1' }, result: false },
+        { cell: ':col <=0',   hash: { col:  nil }, result: nil },
+        # BigDecimal equality
+        { cell: ':col == 0.0', hash: { col: BigDecimal('0.0') }, result: true },
+        { cell: ':col == 0.0', hash: { col: '0.0' },             result: true },
+        { cell: ':col == 0.0', hash: { col:  0  },               result: true },
+        { cell: ':col == 0.0', hash: { col: '0' },               result: true },
+        { cell: ':col == 0.0', hash: { col: '0.1' },             result: false },
+        { cell: ':col == 0.0', hash: { col:  0.0 },              result: false },
+        { cell: ':col == 0.0', hash: { col:  nil },              result: false },
+        # BigDecimal inequality
+        { cell: ':col != 0.0', hash: { col: BigDecimal('0.0') }, result: false },
+        { cell: ':col != 0.0', hash: { col: '0.0' },             result: false },
+        { cell: ':col != 0.0', hash: { col:  0  },               result: false },
+        { cell: ':col != 0.0', hash: { col: '0' },               result: false },
+        { cell: ':col != 0.0', hash: { col: '0.1' },             result: true },
+        { cell: ':col != 0.0', hash: { col:  0.0 },              result: true },
+        { cell: ':col != 0.0', hash: { col:  nil },              result: true },
+        # String compare
+        { cell:  ':col > m',  hash: { col:   0  }, result: nil },
+        { cell:  ':col > m',  hash: { col:  'a' }, result: false },
+        { cell:  ':col > m',  hash: { col:  'n' }, result: true },
+        { cell:  ':col > m',  hash: { col:  nil }, result: nil },
+        { cell:  ':col >=m',  hash: { col:   0  }, result: nil },
+        { cell:  ':col >=m',  hash: { col:  'a' }, result: false },
+        { cell:  ':col >=m',  hash: { col:  'n' }, result: true },
+        { cell:  ':col >=m',  hash: { col:  'm' }, result: true },
+        { cell:  ':col >=m',  hash: { col:  nil }, result: nil },
+        { cell:  ':col < m',  hash: { col:   0  }, result: nil },
+        { cell:  ':col < m',  hash: { col:  'a' }, result: true },
+        { cell:  ':col < m',  hash: { col:  'n' }, result: false },
+        { cell:  ':col < m',  hash: { col:  nil }, result: nil },
+        { cell:  ':col <=m',  hash: { col:   0  }, result: nil },
+        { cell:  ':col <=m',  hash: { col:  'a' }, result: true },
+        { cell:  ':col <=m',  hash: { col:  'n' }, result: false },
+        { cell:  ':col <=n',  hash: { col:  'n' }, result: true },
+        { cell:  ':col <=m',  hash: { col:  nil }, result: nil },
+        { cell: '!:col <=m',  hash: { col:   0  }, result: nil },
+        { cell: '!:col <=m',  hash: { col:  'a' }, result: false },
+        { cell: '!:col <=m',  hash: { col:  'n' }, result: true },
+        { cell: '!:col <=n',  hash: { col:  'n' }, result: false },
+        { cell: '!:col <=m',  hash: { col:  nil }, result: nil },
+        # Method calls
+        { cell:  ':col.nil?',   hash: { col:  nil },  result: true },
+        { cell:  ':col.nil?',   hash: { col:  0 },    result: false },
+        { cell: '!:col.nil?',   hash: { col:  nil },  result: false },
+        { cell: '!:col.nil?',   hash: { col:  0 },    result: true },
+        { cell:  ':col.upcase', hash: { col:  'u' },  result: 'U' },
+        { cell:  ':col.next',   hash: { col:  -1 },   result: 0 },
+        { cell:  ':col.first',  hash: { col:  '98' }, result: '9' },
+        { cell:  ':col.last',   hash: { col:  '98' }, result: '8' },
+        { cell:  ':col.zero?',  hash: { col:  0 },    result: true },
+        { cell:  ':col.zero?',  hash: { col:  nil },  result: false },
+        # Symbol
+        { cell:  ':col',  hash: { col: true }, result: true },
+        { cell:  ':col',  hash: { col: nil }, result: nil },
+        { cell: '!:col', hash: { col: nil }, result: true },
+        { cell: '!:col', hash: { col: true }, result: false },
+      ]
+
+      examples.each do |ex|
+        it "cell #{ex[:cell]} matches to hash: #{ex[:hash]}" do
+          proc = matcher.matches?(ex[:cell])
+          expect(proc).to be_a(CSVDecision::Matchers::Proc)
+          expect(proc.type).to eq :guard
+          expect(proc.function.call(ex[:hash])).to eq ex[:result]
+        end
+      end
+    end
+
+    context 'does not match a symbol guard condition' do
+      data = ['1', 'abc', 'abc.*def', '-1..1', '0...3', ':= true', ':= lookup(:table)', '>= :col']
+
+      data.each do |cell|
+        it "cell #{cell} is not a function" do
+          expect(matcher.matches?(cell)).to eq false
+        end
+      end
+    end
+
+    context 'raises an error for a constant in a guard column' do
+      data = <<~DATA
+        IN :country, guard : country, out :PAID, out :PAID_type, out :len
+        US,          :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
+        GB,          :SEDOL.present?, :SEDOL,    SEDOL,          :PAID.length
+        ,            :ISIN.present?,  :ISIN,     ISIN,           :PAID.length
+        ,            :SEDOL.present?, :SEDOL,    SEDOL,          :PAID.length
+        ,            :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
+        ,            := nil,          := nil,    MISSING,        := nil
+      DATA
+
+      specify do
+        expect { CSVDecision.parse(data) }
+          .to raise_error(CSVDecision::CellValidationError, 'guard: column cannot contain constants')
+      end
+    end
+
+    context 'raises an error for a constant in an if column' do
+      data = <<~DATA
+        IN :country, guard : country, out :PAID, out :PAID_type, if:
+        US,          :CUSIP.present?, :CUSIP,    CUSIP,          TRUE
+        GB,          :SEDOL.present?, :SEDOL,    SEDOL,          
+        ,            :ISIN.present?,  :ISIN,     ISIN,           
+        ,            :SEDOL.present?, :SEDOL,    SEDOL,          
+        ,            :CUSIP.present?, :CUSIP,    CUSIP,          
+        ,            := nil,          := nil,    MISSING,        := nil
+      DATA
+
+      specify do
+        expect { CSVDecision.parse(data) }
+          .to raise_error(CSVDecision::CellValidationError, 'if: column cannot contain constants')
+      end
+    end
+  end
+end

data/spec/csv_decision/matchers/numeric_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Numeric do
+  subject { described_class.new }
+
+  describe '#new' do
+    it { is_expected.to be_a CSVDecision::Matchers::Numeric }
+    it { is_expected.to respond_to(:matches?).with(1).argument }
+  end
+
+  describe '#matches?' do
+    matcher = described_class.new
+
+    context 'comparison matches value' do
+      data = [
+          ['< 1',  0],
+          ['< 1', '0'],
+          ['> 1',  5],
+          ['!= 1',  0],
+          ['> 1', '5'],
+          ['>= 1.1', BigDecimal('1.1')],
+          ['<=-1.1', BigDecimal('-12')]
+      ]
+
+      data.each do |cell, value|
+        it "comparision #{cell} matches #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_a(CSVDecision::Matchers::Proc)
+          expect(proc.type).to eq :proc
+          expect(proc.function[value]).to eq true
+        end
+      end
+    end
+
+    context 'does not match non-numeric comparision' do
+      data = ['1', ':column', ':= nil', ':= true', ':= 0', 'abc', 'abc.*def', '-1..1', '0...3']
+
+      data.each do |cell|
+        it "cell #{cell} is not a comparision}" do
+          expect(matcher.matches?(cell)).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/csv_decision/matchers/pattern_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Pattern do
+  subject { described_class.new }
+
+  describe '#new' do
+    it { is_expected.to be_a CSVDecision::Matchers::Pattern }
+    it { is_expected.to respond_to(:matches?).with(1).argument }
+  end
+
+  describe '#matches?' do
+    context 'recognises regular expressions with implicit option' do
+      matcher = described_class.new(regexp_implicit: true)
+
+      expressions = [
+        '!~Jerk',
+        '!=Jerk',
+        '=~ Jerk.+',
+        'a.+c',
+        '=~AB|BC|CD',
+        'TRP\.CRD',
+        '=~'
+      ]
+
+      expressions.each do |cell|
+        it "recognises regexp #{cell}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_a CSVDecision::Matchers::Proc
+          expect(proc.type).to eq :proc
+          expect(proc.function).to be_a ::Proc
+          expect(proc.function.arity).to eq -1
+        end
+      end
+    end
+
+    context 'recognises regular expressions with explicit option' do
+      matcher = described_class.new(regexp_implicit: true)
+
+      expressions = [
+        '!~Jerk',
+        '!=Jerk',
+        '=~ Jerk.+',
+        '=~a.+c',
+        '=~AB|BC|CD',
+        '=~ TRP\.CRD'
+      ]
+
+      expressions.each do |cell|
+        it "recognises regexp #{cell}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_a CSVDecision::Matchers::Proc
+          expect(proc.type).to eq :proc
+          expect(proc.function).to be_a ::Proc
+          expect(proc.function.arity).to eq -1
+        end
+      end
+    end
+
+    context 'matches regular expressions with implicit option' do
+      matcher = described_class.new(regexp_implicit: true)
+
+      expressions = [
+        %w[!~Jerk        Jerks],
+        %w[!=Jerk        Jerks],
+          ['=~ Jerk.+', 'Jerks'],
+        %w[a.+c          abc],
+        %w[=~AB|BC|CD    CD],
+        %w[TRP\.CRD      TRP.CRD],
+        %w[=~            =~]
+      ]
+
+      expressions.each do |cell, value|
+        it "matches regexp #{cell} to value #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc.function[value]).to be_truthy
+        end
+      end
+    end
+
+    context 'does not match regular expressions with implicit option' do
+      matcher = described_class.new(regexp_implicit: true)
+
+      expressions = [
+        %w[!~Jerk      Jerk],
+        %w[!=Jerk      Jerk],
+        ['=~ Jerk.+', 'Jerk'],
+        %w[a.+c        abcd],
+        %w[=~AB|BC|CD  C],
+        %w[TRP\.CRD    TRPxCRD]
+      ]
+
+      expressions.each do |cell, value|
+        it "matches regexp #{cell} to value #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc.function[value]).to be_falsey
+        end
+      end
+    end
+
+    context 'matches regular expressions with explicit option' do
+      matcher = described_class.new(regexp_implicit: false)
+
+      expressions = [
+        %w[!~Jerk      Jerks],
+        %w[!=Jerk      Jerks],
+        ['=~ Jerk.+', 'Jerks'],
+        %w[=~a.+c      abc],
+        %w[=~AB|BC|CD  CD],
+        %w[=~TRP\.CRD  TRP.CRD]
+      ]
+
+      expressions.each do |cell, value|
+        it "matches regexp #{cell} to value #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc.function[value]).to be_truthy
+        end
+      end
+    end
+
+    context 'does not match regular expressions with explicit option' do
+      matcher = described_class.new(regexp_implicit: false)
+
+      expressions = [
+        %w[!~Jerk      Jerk],
+        %w[!=Jerk      Jerk],
+        ['=~ Jerk.+', 'Jerk'],
+        %w[=~a.+c      abcd],
+        %w[=~AB|BC|CD  C],
+        %w[=~TRP\.CRD  TRPxCRD]
+      ]
+
+      expressions.each do |cell, value|
+        it "matches regexp #{cell} to value #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc.function[value]).to be_falsey
+        end
+      end
+    end
+
+    context 'does not recognise non-regular expressions with implicit option' do
+      matcher = described_class.new(regexp_implicit: true)
+
+      expressions = [
+        'Jerk',
+        ':Jerk',
+        '=~:Jerk',
+        ':= nil',
+        ':= 100.0'
+      ]
+
+      expressions.each do |cell|
+        it "does not match string #{cell}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_falsey
+        end
+      end
+    end
+
+    context 'does not recognise non-regular expressions with explicit option' do
+      matcher = described_class.new(regexp_implicit: false)
+
+      expressions = [
+        'Jerk',
+        ':Jerk',
+        '=~:Jerk',
+        'a.+c',
+        '*.OPT.*',
+        ':= nil',
+        ':= 100.0',
+        '=~'
+      ]
+
+      expressions.each do |cell|
+        it "does not match string #{cell}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_falsey
+        end
+      end
+    end
+  end
+end

data/spec/csv_decision/matchers/range_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Range do
+  subject { described_class.new }
+
+  describe '#new' do
+    it { is_expected.to be_a CSVDecision::Matchers::Range }
+    it { is_expected.to respond_to(:matches?).with(1).argument }
+  end
+
+  describe '#matches?' do
+    matcher = described_class.new
+
+    context 'range matches value' do
+      data = [
+          [ '-1..+4', 0],
+          ['!-1..+4', 5],
+          ['1.1...4', 3],
+        %w[a..z       a],
+        %w[a..z       z],
+        %w[a..z       m],
+        %w[!-1..1     1.1],
+          ['! -1..1', BigDecimal('1.1')],
+          [  '-1..1', BigDecimal('1')]
+      ]
+
+      data.each do |cell, value|
+        it "range #{cell} matches #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_a(CSVDecision::Matchers::Proc)
+          expect(proc.type).to eq :proc
+          expect(proc.function[value]).to eq true
+        end
+      end
+    end
+
+    context 'range does not match value' do
+      data = [
+        [ '-1..+4', 5],
+        ['!-1..+4', 2],
+        %w[a...z      z],
+        %w[!a..z      m],
+        %w[-1..1     1.1],
+        ['-1..1', BigDecimal('1.1')],
+        ['-1..1', BigDecimal('1.1')]
+      ]
+
+      data.each do |cell, value|
+        it "range #{cell} does not match #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_a(CSVDecision::Matchers::Proc)
+          expect(proc.type).to eq :proc
+          expect(proc.function[value]).to eq false
+        end
+      end
+    end
+
+    context 'does not match a range' do
+      data = ['1', ':column', ':= nil', ':= true', 'abc', 'abc.*def']
+
+      data.each do |cell|
+        it "cell #{cell} is not a range}" do
+          expect(matcher.matches?(cell)).to eq false
+        end
+      end
+    end
+  end
+end