csv_decision 0.0.3 → 0.0.4

data/lib/csv_decision/table.rb

@@ -6,42 +6,47 @@
 module CSVDecision
   # Decision Table that accepts input hashes and makes decisions
   class Table
-    # CSVDecision::Columns object - dictionary of all input and output columns
+    # @return [CSVDecision::Columns] Dictionary of all input and output columns.
     attr_accessor :columns
 
-    # File path name if decision table loaded from a CSV file
+    # @return [File, Pathname, nil] File path name if decision table was loaded from a CSV file.
     attr_accessor :file
 
-    # All options used to parse the table
+    # @return [Hash] All options, explicitly set or defaulted, used to parse the table.
     attr_accessor :options
 
-    # Set if the table has any output functions (planned feature)
-    attr_accessor :outs_functions
+    # Set if the table row has any output functions (planned feature)
+    # attr_accessor :outs_functions
 
-    # Data rows - an array of arrays
+    # @return [Array<Array>] Data rows after parsing.
     attr_accessor :rows
 
-    # Array of CSVDecision::ScanRow objects used to implement matching logic
+    # @return [Array<CSVDecision::ScanRow>] Scanning objects used to implement input matching logic.
     attr_accessor :scan_rows
 
-    # Any array of CSVDecision::Table pre-loaded tables passed to this decision table
-    # at load time. Used to allow this decision table to lookup values in other
-    # decision tables. (Planned feature.)
-    attr_reader :tables
+    # @return [Array<CSVDecision::ScanRow>] Used to implement outputting of final results.
+    attr_accessor :outs_rows
+
+    # @return Array<CSVDecision::Table>] pre-loaded tables passed to this decision table
+    #   at load time. Used to allow this decision table to lookup values in other
+    #   decision tables. (Planned feature.)
+    # attr_reader :tables
 
     # Main public method for making decisions.
     #
-    # @param input [Hash] - input hash (keys may or may not be symbolized)
-    # @return [Hash{Symbol => Object, Array<Object>}] decision
+    # @note Input hash keys may or may not be symbolized.
+    # @param input [Hash] Input hash.
+    # @return [Hash{Symbol => Object, Array<Object>}] Decision hash.
     def decide(input)
       Decide.decide(table: self, input: input, symbolize_keys: true).result
     end
 
-    # Unsafe version of decide - will mutate the hash if set: column type
+    # Unsafe version of decide - will mutate the hash if +set: column+ type
     # is used (planned feature).
     #
-    # @param input [Hash{Symbol => Object}] - input hash (all keys must already be symbolized)
-    # @return [Hash{Symbol => Object, Array<Object>}]
+    # @param input (see #decide)
+    # @note Input hash must have its keys symbolized.
+    # @return (see #decide)
     def decide!(input)
       Decide.decide(table: self, input: input, symbolize_keys: false).result
     end
@@ -49,8 +54,8 @@ module CSVDecision
     # Iterate through all data rows of the decision table, with an optional
     # first and last row index given.
     #
-    # @param first [Integer] start row
-    # @param last [Integer, nil] last row
+    # @param first [Integer] Start row.
+    # @param last [Integer, nil] Last row.
     def each(first = 0, last = @rows.count - 1)
       index = first
       while index <= (last || first)
@@ -66,6 +71,7 @@ module CSVDecision
       @matchers = []
       @options = nil
       @outs_functions = nil
+      @outs_rows = []
       @rows = []
       @scan_rows = []
       @tables = nil

data/lib/csv_decision.rb

@@ -4,7 +4,8 @@ require 'active_support/core_ext/object'
 require 'csv_decision/parse'
 
 # CSV Decision: CSV based Ruby decision tables.
-# Created December 2017 by Brett Vickers
+# Created December 2017.
+# @author Brett Vickers <brett@phillips-vickers.com>
 # See LICENSE and README.md for details.
 module CSVDecision
   # @return [String] gem project's root directory
@@ -12,23 +13,29 @@ module CSVDecision
     File.dirname __dir__
   end
 
-  autoload :Data,     'csv_decision/data'
-  autoload :Decide,   'csv_decision/decide'
-  autoload :Decision, 'csv_decision/decision'
-  autoload :Columns,  'csv_decision/columns'
-  autoload :Header,   'csv_decision/header'
-  autoload :Input,    'csv_decision/input'
-  autoload :Load,     'csv_decision/load'
-  autoload :Matchers, 'csv_decision/matchers'
-  autoload :Options,  'csv_decision/options'
-  autoload :Parse,    'csv_decision/parse'
-  autoload :ScanRow,  'csv_decision/scan_row'
-  autoload :Table,    'csv_decision/table'
+  autoload :Constant,   'csv_decision/constant'
+  autoload :Data,       'csv_decision/data'
+  autoload :Decide,     'csv_decision/decide'
+  autoload :Decision,   'csv_decision/decision'
+  autoload :Columns,    'csv_decision/columns'
+  autoload :Function,   'csv_decision/function'
+  autoload :Header,     'csv_decision/header'
+  autoload :Input,      'csv_decision/input'
+  autoload :Load,       'csv_decision/load'
+  autoload :Matchers,   'csv_decision/matchers'
+  autoload :Numeric,    'csv_decision/numeric'
+  autoload :Options,    'csv_decision/options'
+  autoload :Parse,      'csv_decision/parse'
+  autoload :ScanRow,    'csv_decision/scan_row'
+  autoload :Symbol,     'csv_decision/symbol'
+  autoload :Table,      'csv_decision/table'
 
-  module Matchers
-    autoload :Function, 'csv_decision/matchers/function'
-    autoload :Numeric,  'csv_decision/matchers/numeric'
-    autoload :Pattern,  'csv_decision/matchers/pattern'
-    autoload :Range,    'csv_decision/matchers/range'
+  class Matchers
+    autoload :Constant,      'csv_decision/matchers/constant'
+    autoload :Function,      'csv_decision/matchers/function'
+    autoload :Numeric,       'csv_decision/matchers/numeric'
+    autoload :Pattern,       'csv_decision/matchers/pattern'
+    autoload :Range,         'csv_decision/matchers/range'
+    autoload :Symbol,        'csv_decision/matchers/symbol'
   end
 end

data/spec/csv_decision/columns_spec.rb

@@ -74,7 +74,7 @@ describe CSVDecision::Columns do
   end
 
   context 'rejects invalid CSV decision table columns' do
-    Dir[File.join(SPEC_DATA_INVALID, 'invalid_columns*.csv')].each do |file_name|
+    Dir[File.join(SPEC_DATA_INVALID, 'invalid_header*.csv')].each do |file_name|
       pathname = Pathname(file_name)
 
       it "rejects CSV file #{pathname.basename}" do

data/spec/csv_decision/constant_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Constant do
+  context 'cell string value recognition' do
+    cells = {
+      ':= 0.0' => { operator: ':=', value: '0.0' },
+      ':= 0.'  => { operator: ':=', value: '0.' },
+      ':= .0'  => { operator: ':=', value:  '.0' },
+      '==0.0'  => { operator: '==', value: '0.0' },
+      '== 0.'  => { operator: '==', value: '0.' },
+      '==.0'   => { operator: '==', value:  '.0' },
+      '=0.0'   => { operator: '=',  value: '0.0' },
+      '= 0.'   => { operator: '=',  value: '0.' },
+      '=.0'    => { operator: '=',  value:  '.0' },
+      '= nil'  => { operator: '=',  value: 'nil' },
+      ':= nil' => { operator: ':=', value: 'nil' },
+      '==nil'  => { operator: '==', value:  'nil' }
+    }
+    cells.each_pair do |cell, expected|
+      it "recognises #{cell} as a constant" do
+        match = described_class::EXPRESSION.match(cell)
+        expect(match['operator']).to eq expected[:operator]
+        expect(match['value']).to eq expected[:value]
+      end
+    end
+  end
+
+  describe '#matches?' do
+    context 'constant matches value' do
+      data = [
+          ['= 1',    1],
+          ['== 1',   1],
+          [':=1',    1],
+          ['==.1',   BigDecimal('0.1')],
+          [':= 1.1', BigDecimal('1.1')]
+      ]
+
+      data.each do |cell, value|
+        it "constant #{cell} matches #{value}" do
+          proc = described_class.matches?(cell)
+          expect(proc).to be_a(CSVDecision::Proc)
+          expect(proc.type).to eq :constant
+          expect(proc.function).to eq value
+        end
+      end
+    end
+
+    context 'does not match strings and non-constants' do
+      data = ['true', 'nil', 'false', ':column', '> 0', '!= 1.0', 'abc.*def', '-1..1', '0...3']
+
+      data.each do |cell|
+        it "cell #{cell} is not a non-string constant}" do
+          expect(described_class.matches?(cell)).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/csv_decision/examples_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+context 'simple examples' do
+  context 'simple example - strings-only' do
+    data = <<~DATA
+      in :topic, in :region,  out :team_member
+      sports,    Europe,      Alice
+      sports,    ,            Bob
+      finance,   America,     Charlie
+      finance,   Europe,      Donald
+      finance,   ,            Ernest
+      politics,  Asia,        Fujio
+      politics,  America,     Gilbert
+      politics,  ,            Henry
+      ,          ,            Zach
+    DATA
+
+    it 'makes correct decisions for CSV string' do
+      table = CSVDecision.parse(data)
+
+      result = table.decide(topic: 'finance', region: 'Europe')
+      expect(result).to eq(team_member: 'Donald')
+
+      result = table.decide(topic: 'sports', region: nil)
+      expect(result).to eq(team_member: 'Bob')
+
+      result = table.decide(topic: 'culture', region: 'America')
+      expect(result).to eq(team_member: 'Zach')
+    end
+
+    it 'makes correct decisions for CSV file' do
+      table = CSVDecision.parse(Pathname('spec/data/valid/simple_example.csv'))
+
+      result = table.decide(topic: 'finance', region: 'Europe')
+      expect(result).to eq(team_member: 'Donald')
+
+      result = table.decide(topic: 'sports', region: nil)
+      expect(result).to eq(team_member: 'Bob')
+
+      result = table.decide(topic: 'culture', region: 'America')
+      expect(result).to eq(team_member: 'Zach')
+    end
+  end
+
+  context 'simple example - constants' do
+    data = <<~DATA
+      in :constant, out :value
+      :=nil,        :=nil
+      ==false,      ==false
+      =true,        =true
+      = 0,          = 0
+      :=100.0,      :=100.0
+    DATA
+
+    it 'makes correct decisions for CSV string' do
+      table = CSVDecision.parse(data)
+
+      result = table.decide(constant: nil)
+      expect(result).to eq(value: nil)
+
+      result = table.decide(constant: true)
+      expect(result).to eq(value: true)
+
+      result = table.decide(constant: false)
+      expect(result).to eq(value: false)
+
+      result = table.decide(constant: 0)
+      expect(result).to eq(value: 0)
+
+      result = table.decide(constant: BigDecimal('100.0'))
+      expect(result).to eq(value: BigDecimal('100.0'))
+    end
+  end
+
+  context 'simple example - symbols' do
+    data = <<~DATA
+      in :node, in :parent, out :top?
+      ,          ==:node,   yes
+      ,          ,          no
+    DATA
+
+    it 'makes correct decisions' do
+      table = CSVDecision.parse(data)
+
+      result = table.decide(node: 0, parent: 0)
+      expect(result).to eq(top?: 'yes')
+
+      result = table.decide(node: 1, parent: 0)
+      expect(result).to eq(top?: 'no')
+
+      result = table.decide(node: '0', parent: 0)
+      expect(result).to eq(top?: 'no')
+    end
+  end
+
+  context 'makes correct decision for table with symbol ordered compares' do
+    data = <<~DATA
+        in :traded, in :settled, out :status
+        ,            :traded,    same day
+        ,           >:traded,    pending
+        ,           <:traded,    invalid trade
+        ,                   ,    invalid data
+    DATA
+
+    it 'decides correctly' do
+      table = CSVDecision.parse(data)
+
+      expect(table.decide(traded: '20171227',  settled: '20171227')).to eq(status: 'same day')
+      expect(table.decide(traded:  20171227,   settled:  20171227 )).to eq(status: 'same day')
+      expect(table.decide(traded: '20171227',  settled: '20171228')).to eq(status: 'pending')
+      expect(table.decide(traded:  20171227,   settled:  20171228 )).to eq(status: 'pending')
+      expect(table.decide(traded: '20171228',  settled: '20171227')).to eq(status: 'invalid trade')
+      expect(table.decide(traded:  20171228,   settled:  20171227 )).to eq(status: 'invalid trade')
+      expect(table.decide(traded: '20171227',  settled:  20171228 )).to eq(status: 'invalid data')
+    end
+  end
+end

data/spec/csv_decision/matchers/function_spec.rb

@@ -13,17 +13,17 @@ describe CSVDecision::Matchers::Function do
 
   context 'cell value recognition' do
     cells = {
-      ':= nil' => { operator: ':=', value: 'nil' },
-      '== nil' => { operator: '==', value: 'nil' },
-      '=  nil' => { operator: '=', value: 'nil' },
-      '==true' => { operator: '==', value: 'true' },
-      ':=false' => { operator: ':=', value: 'false' },
+      ':=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 constant" do
-        match = described_class::FUNCTION_RE.match(cell)
+      it "recognises #{cell} as a function" do
+        match = CSVDecision::Function::FUNCTION_RE.match(cell)
         expect(match['operator']).to eq expected[:operator]
-        expect(match['name']).to eq expected[:value]
+        expect(match['name']).to eq expected[:name]
       end
     end
   end
@@ -31,29 +31,49 @@ describe CSVDecision::Matchers::Function do
   describe '#matches?' do
     matcher = described_class.new
 
-    context 'constant matches value' do
-      data = [
-        ['= nil', nil],
-        [':= false', false],
-        ['==true', true]
-      ]
-
-      data.each do |cell, value|
-        it "comparision #{cell} matches #{value}" do
-          proc = matcher.matches?(cell)
-          expect(proc).to be_a(CSVDecision::Proc)
-          expect(proc.type).to eq :constant
-          expect(proc.function).to eq value
-        end
-      end
-    end
-
+    # 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 function constant' do
-      data = ['1', ':column', ':= 1.1', ':= abc', 'abc', 'abc.*def', '-1..1', '0...3']
+    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 comparision}" do
+        it "cell #{cell} is not a function" do
           expect(matcher.matches?(cell)).to eq false
         end
       end

data/spec/csv_decision/matchers/numeric_spec.rb

@@ -10,25 +10,6 @@ describe CSVDecision::Matchers::Numeric do
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
-  context 'cell value recognition' do
-    cells = {
-      '> -1' => { comparator: '>', value: '-1' },
-      '>= 10.0' => { comparator: '>=', value: '10.0' },
-      '< .0' => { comparator: '<', value: '.0' },
-      '<= +1' => { comparator: '<=', value: '+1' },
-      '!=0.0' => { comparator: '!=', value: '0.0' },
-      ':= 0.0' => { comparator: ':=', value: '0.0' },
-      '= 1.0' => { comparator: '=', value: '1.0' }
-    }
-    cells.each_pair do |cell, expected|
-      it "recognises #{cell} as a comparision" do
-        match = described_class::COMPARISON.match(cell)
-        expect(match['comparator']).to eq expected[:comparator]
-        expect(match['value']).to eq expected[:value]
-      end
-    end
-  end
-
   describe '#matches?' do
     matcher = described_class.new
 
@@ -39,8 +20,8 @@ describe CSVDecision::Matchers::Numeric do
           ['> 1',  5],
           ['!= 1',  0],
           ['> 1', '5'],
-          ['>= 1.1', BigDecimal.new('1.1')],
-          ['<=-1.1', BigDecimal.new('-12')]
+          ['>= 1.1', BigDecimal('1.1')],
+          ['<=-1.1', BigDecimal('-12')]
       ]
 
       data.each do |cell, value|
@@ -53,26 +34,8 @@ describe CSVDecision::Matchers::Numeric do
       end
     end
 
-    context 'numeric constant' do
-      data = [
-        ['== 1',  1],
-        [':= 0', 0],
-        ['==1.1', BigDecimal.new('1.1')],
-        ['=-1.2', BigDecimal.new('-1.2')]
-      ]
-
-      data.each do |cell, value|
-        it "constant expression #{cell} evaluates to #{value}" do
-          proc = matcher.matches?(cell)
-          expect(proc).to be_a(CSVDecision::Proc)
-          expect(proc.type).to eq :constant
-          expect(proc.function).to eq value
-        end
-      end
-    end
-
-    context 'does not match a numeric comparision' do
-      data = ['1', ':column', ':= nil', ':= true', 'abc', 'abc.*def', '-1..1', '0...3']
+    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

data/spec/csv_decision/matchers/range_spec.rb

@@ -10,67 +10,37 @@ describe CSVDecision::Matchers::Range do
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
-  context 'cell value matching' do
-    ranges = {
-      '-1..1' => { min: '-1', type: '..', max: '1', negate: '' },
-      '! -1..1' => { min: '-1', type: '..', max: '1', negate: '!' },
-      '!-1.0..1.1' => { min: '-1.0', type: '..', max: '1.1', negate: '!' },
-      '!-1.0...1.1' => { min: '-1.0', type: '...', max: '1.1', negate: '!' }
-    }
-    ranges.each_pair do |range, expected|
-      it "matches #{range} as a numeric range" do
-        match = described_class::NUMERIC_RANGE.match(range)
-        expect(match['min']).to eq expected[:min]
-        expect(match['max']).to eq expected[:max]
-        expect(match['type']).to eq expected[:type]
-        expect(match['negate']).to eq expected[:negate]
-      end
-    end
-
-    ranges = {
-      'a..z' => { min: 'a', type: '..', max: 'z', negate: '' },
-      '!1...9' => { min: '1', type: '...', max: '9', negate: '!' },
-    }
-    ranges.each_pair do |range, expected|
-      it "matches #{range} as an alphanumeric range" do
-        match = described_class::ALNUM_RANGE.match(range)
-        expect(match['min']).to eq expected[:min]
-        expect(match['max']).to eq expected[:max]
-        expect(match['type']).to eq expected[:type]
-        expect(match['negate']).to eq expected[:negate]
-      end
-    end
-  end
-
-  describe '#range' do
-    it 'constructs various numeric ranges' do
-      ranges = {
-        '-1..1' => { range: -1..1, negate: false },
-        '! -1..1' => { range: -1..1, negate: true },
-        '!-1.0..1.1' => { range: BigDecimal.new('-1.0')..BigDecimal.new('1.1'), negate: true },
-        '!-1.0...1' => { range: BigDecimal.new('-1.0')...1, negate: true }
-      }
-      ranges.each_pair do |cell, expected|
-        match = described_class::NUMERIC_RANGE.match(cell)
-        negate, range = CSVDecision::Matchers::Range.range(match, coerce: :to_numeric)
-        expect(negate).to eq expected[:negate]
-        expect(range).to eq expected[:range]
-      end
-    end
-
-    it 'constructs various alphanumeric ranges' do
-      ranges = {
-        'a..z' => { range: 'a'..'z', negate: false },
-        '!1...9' => { range: '1'...'9', negate: true },
-      }
-      ranges.each_pair do |cell, expected|
-        match = described_class::ALNUM_RANGE.match(cell)
-        negate, range = described_class.range(match)
-        expect(negate).to eq expected[:negate]
-        expect(range).to eq expected[:range]
-      end
-    end
-  end
+  # context 'cell value matching' do
+  #   ranges = {
+  #     '-1..1' => { min: '-1', type: '..', max: '1', negate: '' },
+  #     '! -1..1' => { min: '-1', type: '..', max: '1', negate: '!' },
+  #     '!-1.0..1.1' => { min: '-1.0', type: '..', max: '1.1', negate: '!' },
+  #     '!-1.0...1.1' => { min: '-1.0', type: '...', max: '1.1', negate: '!' }
+  #   }
+  #   ranges.each_pair do |range, expected|
+  #     it "matches #{range} as a numeric range" do
+  #       match = described_class::NUMERIC_RANGE.match(range)
+  #       expect(match['min']).to eq expected[:min]
+  #       expect(match['max']).to eq expected[:max]
+  #       expect(match['type']).to eq expected[:type]
+  #       expect(match['negate']).to eq expected[:negate]
+  #     end
+  #   end
+  #
+  #   ranges = {
+  #     'a..z' => { min: 'a', type: '..', max: 'z', negate: '' },
+  #     '!1...9' => { min: '1', type: '...', max: '9', negate: '!' },
+  #   }
+  #   ranges.each_pair do |range, expected|
+  #     it "matches #{range} as an alphanumeric range" do
+  #       match = described_class::ALNUM_RANGE.match(range)
+  #       expect(match['min']).to eq expected[:min]
+  #       expect(match['max']).to eq expected[:max]
+  #       expect(match['type']).to eq expected[:type]
+  #       expect(match['negate']).to eq expected[:negate]
+  #     end
+  #   end
+  # end
 
   describe '#matches?' do
     matcher = described_class.new

data/spec/csv_decision/matchers/symbol_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Symbol do
+  subject { described_class.new }
+
+  describe '#new' do
+    it { is_expected.to be_a CSVDecision::Matchers::Symbol }
+    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 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 function' do
+      data = ['1', 'abc', 'abc.*def', '-1..1', '0...3', ':= false', ':= lookup?']
+
+      data.each do |cell|
+        it "cell #{cell} is not a function" do
+          expect(matcher.matches?(cell)).to eq false
+        end
+      end
+    end
+  end
+end