csv_decision2 0.5.1

data/spec/csv_decision/columns_spec.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+SPEC_DATA_VALID ||= File.join(CSVDecision.root, 'spec', 'data', 'valid')
+SPEC_DATA_INVALID ||= File.join(CSVDecision.root, 'spec', 'data', 'invalid')
+
+describe CSVDecision::Columns do
+  describe '#new' do
+    # it 'creates a columns object' do
+    #   table = CSVDecision::Table.new
+    #   columns = CSVDecision::Columns.new(table)
+    #
+    #   expect(columns).to be_a(CSVDecision::Columns)
+    # end
+  end
+
+  it 'rejects a duplicate output column name' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text : input, OUT/text:output
+      input0,    output0,     input1,          output1
+    DATA
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "output column name 'output' is duplicated")
+  end
+
+  it 'parses a decision table columns from a CSV string' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text : input, OUT/text:output2
+      input0,    output0,     input1,          output1
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns).to be_a(CSVDecision::Columns)
+    expect(table.columns.ins[0].to_h).to eq(name: :input, eval: nil, type: :in, set_if: nil)
+    expect(table.columns.ins[2].to_h).to eq(name: :input, eval: false, type: :in, set_if: nil)
+    expect(table.columns.outs[1].to_h).to eq(name: :output, eval: nil, type: :out, set_if: nil)
+    expect(table.columns.outs[3].to_h).to eq(name: :output2, eval: false, type: :out, set_if: nil)
+
+    expect(table.columns.dictionary).to eq(input: :in, output: 1, output2: 3)
+  end
+
+  it 'recognises all input and output column symbols' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: len,       guard:
+      input0,    output0,     input1,         output1,          :input2.length, 
+      input1,    output1,     input1,         output2,          :input3.length, :input4.present?
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns).to be_a(CSVDecision::Columns)
+    expect(table.columns.ins[0].to_h).to eq(name: :input, eval: nil, type: :in, set_if: nil)
+    expect(table.columns.ins[2].to_h).to eq(name: :input, eval: false, type: :in, set_if: nil)
+    expect(table.columns.ins[5].to_h).to eq(name: nil, eval: true, type: :guard, set_if: nil)
+
+    expect(table.columns.outs[1].to_h).to eq(name: :output, eval: nil, type: :out, set_if: nil)
+    expect(table.columns.outs[3].to_h).to eq(name: :output2, eval: false, type: :out, set_if: nil)
+    expect(table.columns.outs[4].to_h).to eq(name: :len, eval: true, type: :out, set_if: nil)
+
+    expect(table.columns.dictionary)
+      .to eq(input: :in, output: 1, output2: 3, len: 4, input2: :in, input3: :in, input4: :in)
+
+    expect(table.columns.input_keys).to eq %i[input input2 input4 input3]
+  end
+
+  it 'recognises the output symbol referenced by an output function' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: input3,      out: len       
+      input0,    output0,     input1,         output1,          ,                 :input2.length
+      input1,    output1,     input1,         output2,          :input4.present?, :input3.length
+    DATA
+
+    table = CSVDecision.parse(data)
+
+    expect(table.columns).to be_a(CSVDecision::Columns)
+    expect(table.columns.ins[0].to_h).to eq(name: :input, eval: nil, type: :in, set_if: nil)
+    expect(table.columns.ins[2].to_h).to eq(name: :input, eval: false, type: :in, set_if: nil)
+    expect(table.columns.outs[1].to_h).to eq(name: :output, eval: nil, type: :out, set_if: nil)
+    expect(table.columns.outs[3].to_h).to eq(name: :output2, eval: false, type: :out, set_if: nil)
+    expect(table.columns.outs[4].to_h).to eq(name: :input3, eval: true, type: :out, set_if: nil)
+    expect(table.columns.outs[5].to_h).to eq(name: :len, eval: true, type: :out, set_if: nil)
+
+    expect(table.columns.dictionary)
+      .to eq(input: :in, output: 1, output2: 3, len: 5, input2: :in, input3: 4, input4: :in)
+
+    expect(table.columns.input_keys).to eq %i[input input2 input4]
+  end
+
+  it 'raises an error for an output column referring to a later output column' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: len,        out: input3,            
+      input0,    output0,     input1,         output1,          :input2.length,                 
+      input1,    output1,     input1,         output2,          :input3.length   :input4.upcase
+    DATA
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(
+        CSVDecision::CellValidationError,
+        "output column 'len' makes an out of order reference to output column 'input3'"
+      )
+  end
+
+  it 'raises an error for an output column referring to itself' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: len,      out: input3,            
+      input0,    output0,     input1,         output1,          :len.length,                 
+      input1,    output1,     input1,         output2,          :len.length   :input4.upcase
+    DATA
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "output column 'len' makes reference to itself")
+  end
+
+  it 'parses a decision table columns from a CSV file' do
+    file = Pathname(File.join(SPEC_DATA_VALID, 'valid.csv'))
+    result = CSVDecision.parse(file)
+
+    expect(result.columns).to be_a(CSVDecision::Columns)
+    expect(result.columns.ins.count).to eq 1
+    expect(result.columns.outs.count).to eq 1
+    expect(result.columns.ins[0].to_h).to eql(name: :input, type: :in, eval: nil, set_if: nil)
+    expect(result.columns.outs[1].to_h).to eql(name: :output, type: :out, eval: nil, set_if: nil)
+  end
+
+  it 'rejects an invalid header column' do
+    data = [
+      ['IN :input', 'BAD :output'],
+      ['input', '']
+    ]
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "header column 'BAD :output' is not valid as " \
+                      'the column name is not well formed')
+  end
+
+  it 'rejects a missing column name' do
+    data = [
+      ['IN :input', 'IN: '],
+      ['input', '']
+    ]
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "header column 'IN:' is not valid as the column name is missing")
+  end
+
+  it 'rejects an invalid column name' do
+    data = [
+      ['IN :input', 'IN: a-b'],
+      ['input', '']
+    ]
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "header column 'IN: a-b' is not valid as " \
+                      "the column name 'a-b' contains invalid characters")
+  end
+
+  context 'rejects invalid CSV decision table columns' do
+    Dir[File.join(SPEC_DATA_INVALID, 'invalid_header*.csv')].each do |file_name|
+      pathname = Pathname(file_name)
+
+      it "rejects CSV file #{pathname.basename}" do
+        expect { CSVDecision.parse(pathname) }
+          .to raise_error(CSVDecision::FileError, /\Aerror processing CSV file/)
+      end
+    end
+  end
+
+  it 'recognises the guard column' do
+    data = <<~DATA
+      IN :country, guard:,          out :PAID, out :PAID_type
+      US,          :CUSIP.present?, :CUSIP,    CUSUP
+      GB,          :SEDOL.present?, :SEDOL,    SEDOL
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns.ins[1].to_h)
+      .to eq(name: nil, eval: true, type: :guard, set_if: nil)
+
+    expect(table.columns.input_keys).to eq %i[country CUSIP SEDOL]
+  end
+
+  it 'rejects output column being same as input column' do
+    data = <<~DATA
+      IN :country, guard:,          out :PAID, out :country
+      US,          :CUSIP.present?, :CUSIP,    CUSUP
+      GB,          :SEDOL.present?, :SEDOL,    SEDOL
+    DATA
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "output column name 'country' is also an input column")
+  end
+
+  it 'rejects output column being same as an input symbol not in the header' do
+    data = <<~DATA
+      in :parent, out :node
+      ==:node,    top
+      ,           child
+    DATA
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "output column name 'node' is also an input column")
+  end
+
+  it 'recognises the if: column' do
+    data = <<~DATA
+      in :country, out :PAID, out :PAID_type, if:
+      US,          :CUSIP,    CUSIP,          :PAID.present?
+      GB,          :SEDOL,    SEDOL,          :PAID.present?
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns.ifs[3].to_h).to eq(name: 3, eval: true, type: :if, set_if: nil)
+    expect(table.columns.input_keys).to eq %i[country CUSIP SEDOL]
+  end
+
+  it 'recognises the set: columns' do
+    data = <<~DATA
+      set/nil? :country, guard:,          set: class,    out :PAID, out: len,     if:
+      US,                ,                :class.upcase,
+      US,                :CUSIP.present?, != PRIVATE,    :CUSIP,    :PAID.length, :len == 9
+      !=US,              :ISIN.present?,  != PRIVATE,    :ISIN,     :PAID.length, :len == 12
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns.ins[0].to_h).to eq(name: :country, eval: nil, type: :set, set_if: :nil?)
+    expect(table.columns.ins[1].to_h).to eq(name: nil, eval: true, type: :guard, set_if: nil)
+    expect(table.columns.ins[2].to_h).to eq(name: :class, eval: nil, type: :set, set_if: true)
+
+    expect(table.columns.input_keys).to eq %i[country class CUSIP ISIN]
+  end
+
+  it 'recognises the path: columns' do
+    data = <<~DATA
+      path:,   path:,    in :type_cd, out :value, if:
+      header,  ,         !nil?,       :type_cd,   :value.present?
+      payload, ,         !nil?,       :type_cd,   :value.present?
+      payload, ref_data, ,            :type_id,   :value.present?
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns.input_keys).to eq %i[type_cd type_id]
+    expect(table.columns.paths[0].to_h).to eq(name: nil, eval: false, type: :path, set_if: nil)
+    expect(table.columns.paths[1].to_h).to eq(name: nil, eval: false, type: :path, set_if: nil)
+  end
+end

data/spec/csv_decision/constant_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Constant do
+  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::Matchers::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/data_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Data do
+  it 'parses an CSV string' do
+    result = CSVDecision::Data.to_array(data: '')
+    expect(result).to be_a Array
+    expect(result.empty?).to eq true
+  end
+
+  it 'parses an array' do
+    result = CSVDecision::Data.to_array(data: [[]])
+    expect(result).to eq []
+
+    data = [
+      ['#header', "R\u00E9sum\u00E9", '# comments'],
+      ['IN :input', ' OUT :output  ', nil],
+      ['input', '# comment', nil]
+    ]
+    result = CSVDecision::Data.to_array(data: data)
+    expect(result).to eq [['IN :input', 'OUT :output', ''], ['input', '', '']]
+  end
+
+  it 'parses a CSV file' do
+    file = Pathname(File.join(CSVDecision.root, 'spec/data/valid', 'valid.csv'))
+    result = CSVDecision::Data.to_array(data: file)
+    expected = [
+      ['', 'IN :input', '', 'OUT :output', ''],
+      ['', 'input', '', '', '']
+    ]
+    expect(result).to eq(expected)
+
+    file = Pathname(File.join(CSVDecision.root, 'spec/data/valid', 'options_in_file2.csv'))
+    result = CSVDecision::Data.to_array(data: file)
+    expected = [
+      ['accumulate'],
+      ['regexp_implicit'],
+      ['IN :input', 'OUT :output'],
+      ['input', '']
+    ]
+    expect(result).to eq(expected)
+  end
+
+  it 'raises an error for invalid input' do
+    expect { CSVDecision::Data.to_array(data: {}) }
+      .to raise_error(ArgumentError,
+                      'Hash input invalid; ' \
+                      'input must be a file path name, CSV string or array of arrays')
+  end
+end

data/spec/csv_decision/decision_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Decision do
+  it 'decision for table with no functions and first_match: true' do
+    data = <<~DATA
+      IN :input, OUT :output, IN: input1
+      input0,    output0,     input1
+      input0,    output1,
+    DATA
+
+    table = CSVDecision.parse(data)
+
+    decision = CSVDecision::Decision.new(table: table)
+
+    expect(decision).to be_a(CSVDecision::Decision)
+  end
+end

data/spec/csv_decision/examples_spec.rb

@@ -0,0 +1,242 @@
+# 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 'simple example - column symbols not in header' do
+    data = <<~DATA
+      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
+
+  it '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
+    table = CSVDecision.parse(data)
+
+    expect(table.columns.input_keys).to eq %i[traded settled]
+
+    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
+  
+  it 'makes a correct decision using a guard column' do
+    data = <<~DATA
+      in :country, guard:,          out :ID, out :ID_type, out :len
+      US,          :CUSIP.present?, :CUSIP,  CUSIP,        :ID.length
+      GB,          :SEDOL.present?, :SEDOL,  SEDOL,        :ID.length
+      ,            :ISIN.present?,  :ISIN,   ISIN,         :ID.length
+      ,            :SEDOL.present?, :SEDOL,  SEDOL,        :ID.length
+      ,            :CUSIP.present?, :CUSIP,  CUSIP,        :ID.length
+      ,            ,                := nil,  := nil,       := nil
+    DATA
+
+    table = CSVDecision.parse(data)
+
+    expect(table.decide(country: 'US',  CUSIP: '123456789'))
+      .to eq(ID: '123456789', ID_type: 'CUSIP', len: 9)
+    expect(table.decide(country: 'EU',  CUSIP: '123456789', ISIN:'123456789012'))
+      .to eq(ID: '123456789012', ID_type: 'ISIN', len: 12)
+  end
+
+  it 'makes a correct decision using an if column' do
+    data = <<~DATA
+      in :country, guard:,          out :ID, out :ID_type, out :len,  if:
+      US,          :CUSIP.present?, :CUSIP,  CUSIP8,       :ID.length, :len == 8
+      US,          :CUSIP.present?, :CUSIP,  CUSIP9,       :ID.length, :len == 9
+      US,          :CUSIP.present?, :CUSIP,  DUMMY,        :ID.length,
+      ,            :ISIN.present?,  :ISIN,   ISIN,         :ID.length, :len == 12
+      ,            :ISIN.present?,  :ISIN,   DUMMY,        :ID.length,
+      ,            :CUSIP.present?, :CUSIP,  DUMMY,        :ID.length,
+      DATA
+
+    table = CSVDecision.parse(data)
+
+    expect(table.decide(country: 'US',  CUSIP: '12345678'))
+      .to eq(ID: '12345678', ID_type: 'CUSIP8', len: 8)
+    expect(table.decide(country: 'US',  CUSIP: '123456789'))
+      .to eq(ID: '123456789', ID_type: 'CUSIP9', len: 9)
+    expect(table.decide(country: 'US',  CUSIP: '1234567890'))
+      .to eq(ID: '1234567890', ID_type: 'DUMMY', len: 10)
+    expect(table.decide(country: nil,  CUSIP: '123456789', ISIN:'123456789012'))
+      .to eq(ID: '123456789012', ID_type: 'ISIN', len: 12)
+    expect(table.decide(CUSIP: '12345678', ISIN:'1234567890'))
+      .to eq(ID: '1234567890', ID_type: 'DUMMY', len: 10)
+  end
+
+  it 'recognises the set: columns and uses correct defaults' do
+    data = <<~DATA
+      set/nil? :country, guard:,          set: class,    out :PAID, out: len,     if:
+      US,                ,                :class.upcase,
+      US,                :CUSIP.present?, != PRIVATE,    :CUSIP,    :PAID.length, :len == 9
+      !=US,              :ISIN.present?,  != PRIVATE,    :ISIN,     :PAID.length, :len == 12
+      US,                :CUSIP.present?, PRIVATE,       :CUSIP,    :PAID.length,
+      !=US,              :ISIN.present?,  PRIVATE,       :ISIN,     :PAID.length,
+    DATA
+
+    table = CSVDecision.parse(data)
+    expect(table.decide(CUSIP: '1234567890', class: 'Private')).to eq(PAID: '1234567890', len: 10)
+    expect(table.decide(CUSIP: '123456789', class: 'Public')).to eq(PAID: '123456789', len: 9)
+    expect(table.decide(ISIN: '123456789', country: 'GB', class: 'public')).to eq({})
+    expect(table.decide(ISIN: '123456789012', country: 'GB', class: 'private')).to eq(PAID: '123456789012', len: 12)
+  end
+
+  it 'recognises in column method call conditions' do
+    data = <<~DATA
+      set/nil? :country, in :CUSIP,       in :ISIN,   set: class,    out :PAID, out: len,     if:
+      US,                ,                ,           :class.upcase,
+      US,                .present?,       ,           != PRIVATE,    :CUSIP,    :PAID.length, :len == 9
+      !=US,              ,                .present?,  != PRIVATE,    :ISIN,     :PAID.length, :len == 12
+      US,                =.present?,      ,           PRIVATE,       :CUSIP,    :PAID.length,
+      !=US,              ,                !.blank?,   PRIVATE,       :ISIN,     :PAID.length,
+    DATA
+
+    table = CSVDecision.parse(data)
+    expect(table.decide(CUSIP: '1234567890', class: 'Private')).to eq(PAID: '1234567890', len: 10)
+    expect(table.decide(CUSIP: '123456789', class: 'Public')).to eq(PAID: '123456789', len: 9)
+    expect(table.decide(ISIN: '123456789', country: 'GB', class: 'public')).to eq({})
+    expect(table.decide(ISIN: '123456789012', country: 'GB', class: 'private')).to eq(PAID: '123456789012', len: 12)
+  end
+
+  it 'scans the input hash paths accumulating matches' do
+    data = <<~DATA
+      path:,   path:,    out :value
+      header,  ,         :source_name
+      header,  metrics,  :service_name
+      payload, ,         :amount
+      payload, ref_data, :account_id
+    DATA
+    table = CSVDecision.parse(data, first_match: false)
+
+    input = {
+      header: {
+        id: 1, type_cd: 'BUY', source_name: 'Client', client_name: 'AAPL',
+        metrics: { service_name: 'Trading', receive_time: '12:00' }
+      },
+      payload: {
+        tran_id: 9, amount: '100.00',
+        ref_data: { account_id: '5010', type_id: 'BUYL' }
+      }
+    }
+
+    expect(table.decide(input)).to eq(value: %w[Client Trading 100.00 5010])
+    expect(table.decide!(input)).to eq(value: %w[Client Trading 100.00 5010])
+  end
+end

data/spec/csv_decision/index_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+SPEC_DATA_VALID ||= File.join(CSVDecision.root, 'spec', 'data', 'valid')
+SPEC_DATA_INVALID ||= File.join(CSVDecision.root, 'spec', 'data', 'invalid')
+
+describe CSVDecision::Index do
+  it 'indexes a single column CSV' do
+    file = Pathname(File.join(SPEC_DATA_VALID, 'options_in_file3.csv'))
+    result = CSVDecision.parse(file)
+
+    expected = {
+      'none' => 0,
+      'one' => 1,
+      'two' => 2,
+      'three' => 3,
+      nil => 4,
+      0 => 5,
+      1 => 6,
+      2 => 7,
+      3 => 8
+    }
+
+    expect(result.index.columns).to eq [0]
+    expect(result.index.hash).to eql expected
+  end
+
+  it 'indexes two columns with contiguous values' do
+    file = Pathname(File.join(SPEC_DATA_VALID, 'multi_column_index.csv'))
+    result = CSVDecision.parse(file)
+
+    expected = {
+      %w[integer none] => [[0, 1]],
+      %w[integer one] => [[2, 3]],
+      %w[string none] => [[4, 5]],
+      %w[string one] => [[6, 7]]
+    }
+
+    expect(result.index.columns).to eq [1, 2]
+    expect(result.index.hash).to eql expected
+  end
+
+  it 'indexes two columns with non-contiguous values' do
+    file = Pathname(File.join(SPEC_DATA_VALID, 'multi_column_index2.csv'))
+    result = CSVDecision.parse(file)
+
+    expected = {
+      %w[integer none] => [0, 8],
+      %w[string none] => [[1, 2]],
+      %w[string one] => [3, [6, 7]],
+      %w[integer one] => [[4, 5]]
+    }
+
+    expect(result.index.columns).to eq [1, 2]
+    expect(result.index.hash).to eql expected
+  end
+end