csv_decision2 0.5.1

data/spec/csv_decision/table_spec.rb

@@ -0,0 +1,683 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+SPEC_DATA_VALID ||= File.join(CSVDecision.root, 'spec', 'data', 'valid')
+
+describe CSVDecision::Table do
+  describe '#decide' do
+    context 'makes correct decisions for simple, text-only tables' do
+      examples = [
+        {
+          example: 'parses CSV file',
+          options: {},
+          data: Pathname(File.join(SPEC_DATA_VALID, 'simple_example.csv'))
+        },
+        {
+          example: 'parses data array',
+          options: {},
+          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']
+          ]
+        },
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]} with first_match: true" do
+            options = test[:options].merge(first_match: true)
+            table = CSVDecision.parse(test[:data], options)
+
+            expect(table.send(method, topic: 'finance', region: 'Europe')).to eq(team_member: 'Donald')
+            expect(table.send(method, topic: 'sports',  region: nil)).to eq(team_member: 'Bob')
+            expect(table.send(method, topic: 'culture', region: 'America')).to eq(team_member: 'Zach')
+          end
+
+          it "#{method} correctly #{test[:example]} with first_match: false" do
+            options = test[:options].merge(first_match: false)
+            table = CSVDecision.parse(test[:data], options)
+
+            expect(table.send(method, topic: 'finance', region: 'Europe'))
+              .to eq(team_member: %w[Donald Ernest Zach])
+            expect(table.send(method, topic: 'sports',  region: nil))
+              .to eq(team_member: %w[Bob Zach])
+            expect(table.send(method, topic: 'culture', region: 'America'))
+              .to eq(team_member: 'Zach')
+          end
+        end
+      end
+    end
+
+    context 'makes correct decisions for simple non-string constants' do
+      examples = [
+        {
+          example: 'parses CSV file',
+          options: {},
+          data: Pathname(File.join(SPEC_DATA_VALID, 'simple_constants.csv'))
+        },
+        {
+          example: 'parses CSV string',
+          options: {},
+          data: <<~DATA
+            in :constant, out :type
+            :=nil,        :=nil
+            = 0,          = 0
+            :=100.0,      :=100
+            ,             Unrecognized
+          DATA
+        },
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]} with first_match: true" do
+            options = test[:options].merge(first_match: true)
+            table = CSVDecision.parse(test[:data], options)
+
+            expect(table.send(method, constant: nil)).to eq(type: nil)
+            expect(table.send(method, constant: 0)).to eq(type: 0)
+            expect(table.send(method, constant: BigDecimal('100.0'))).to eq(type: BigDecimal('100.0'))
+            expect(table.send(method, constant: ':=nil')).to eq(type: 'Unrecognized')
+            expect(table.send(method, constant: '= 0')).to eq(type: 'Unrecognized')
+            expect(table.send(method, constant: ':=100.0')).to eq(type: 'Unrecognized')
+          end
+        end
+      end
+    end
+
+    context 'makes correct decisions for a table with regexps and ranges' do
+      examples = [
+        {
+          example: 'implicit regular expressions from CSV file',
+          options: {},
+          data: Pathname('spec/data/valid/regular_expressions.csv')
+        },
+        {
+          example: 'implicit regular expressions',
+          options: { regexp_implicit: true },
+          data: <<~DATA
+            in :age,   in :trait,  out :salesperson
+            18..35,    maniac,      Adelsky
+            23..40,    bad|maniac,  Bronco
+            36..50,    bad.*,       Espadas
+            := 100,    ,            Thorsten
+            44..100,   !~ maniac,   Ojiisan
+            > 100,     maniac.*,    Chester
+            23..35,    .*rich,      Kerfelden
+            ,          cheerful,    Swanson
+            ,          maniac,      Korolev
+          DATA
+        },
+        {
+          example: 'explicit regular expressions',
+          options: { regexp_implicit: false },
+          data: <<~DATA
+            in :age,   in :trait,     out :salesperson
+            18..35,    maniac,        Adelsky
+            23..40,    =~ bad|maniac, Bronco
+            36..50,    =~ bad.*,      Espadas
+            ==100,     ,              Thorsten
+            44..100,   !~ maniac,     Ojiisan
+            > 100,     =~ maniac.*,   Chester
+            23..35,    =~ .*rich,     Kerfelden
+            ,          cheerful,      Swanson
+            ,          maniac,        Korolev
+          DATA
+        },
+        {
+          example: 'guard condition',
+          options: { regexp_implicit: false },
+          data: <<~DATA
+            in :age,   guard:,               out :salesperson
+            18..35,    :trait == maniac,     Adelsky
+            23..40,    :trait =~ bad|maniac, Bronco
+            36..50,    :trait =~ bad.*,      Espadas
+            ==100,     ,                     Thorsten
+            44..100,   :trait !~ maniac,     Ojiisan
+            > 100,     :trait =~ maniac.*,   Chester
+            23..35,    :trait =~ .*rich,     Kerfelden
+            ,          :trait == cheerful,   Swanson
+            ,          :trait == maniac,     Korolev
+          DATA
+        },
+        {
+          example: 'multiple in column references',
+          options: { regexp_implicit: false },
+          data: <<~DATA
+            in :age,  in :age, in :trait,     out :salesperson
+            >= 18,    <= 35,   maniac,        Adelsky
+            >= 23,    <= 40,   =~ bad|maniac, Bronco
+            >= 36,    <= 50,   =~ bad.*,      Espadas
+            == 100,   ,        ,              Thorsten
+            >= 44,    <= 100,  != maniac,     Ojiisan
+            > 100,    ,        =~ maniac.*,   Chester
+            >= 23,    <= 35,   =~ .*rich,     Kerfelden
+            ,         ,        cheerful,      Swanson
+            ,         ,        maniac,        Korolev
+          DATA
+        },
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly uses #{test[:example]} with first_match: true" do
+            options = test[:options].merge(first_match: true)
+            table = CSVDecision.parse(test[:data], options)
+
+            expect(table.send(method, age: 100)).to eq(salesperson: 'Thorsten')
+            expect(table.send(method, age:  25,  trait: 'very rich')).to eq(salesperson: 'Kerfelden')
+            expect(table.send(method, age:  25,  trait: 'maniac')).to eq(salesperson: 'Adelsky')
+            expect(table.send(method, age:  44,  trait: 'maniac')).to eq(salesperson: 'Korolev')
+            expect(table.send(method, age: 101,  trait: 'maniacal')).to eq(salesperson: 'Chester')
+            expect(table.send(method, age:  44,  trait: 'cheerful')).to eq(salesperson: 'Ojiisan')
+            expect(table.send(method, age:  49,  trait: 'bad')).to eq(salesperson: 'Espadas')
+            expect(table.send(method, age: '40', trait: 'maniac')).to eq(salesperson: 'Bronco')
+          end
+
+          it "#{method} correctly uses #{test[:example]} with first_match: false" do
+            options = test[:options].merge(first_match: false)
+            table = CSVDecision.parse(test[:data], options)
+
+            expect(table.send(method, age: 100))
+              .to eq(salesperson: %w[Thorsten Ojiisan])
+            expect(table.send(method, age:  25, trait: 'very rich'))
+              .to eq(salesperson: 'Kerfelden')
+            expect(table.send(method, age:  25, trait: 'maniac'))
+              .to eq(salesperson: %w[Adelsky Bronco Korolev])
+            expect(table.send(method, age:  44, trait: 'maniac'))
+              .to eq(salesperson: 'Korolev')
+            expect(table.send(method, age: 101, trait: 'maniacal'))
+              .to eq(salesperson: 'Chester')
+            expect(table.send(method, age:  45, trait: 'cheerful'))
+              .to eq(salesperson: %w[Ojiisan Swanson])
+            expect(table.send(method, age:  49, trait: 'bad'))
+              .to eq(salesperson: %w[Espadas Ojiisan])
+            expect(table.send(method, age: '40', trait: 'maniac'))
+              .to eq(salesperson: %w[Bronco Korolev])
+          end
+        end
+      end
+    end
+
+    context 'makes correct decision for table with symbol equality compares' do
+      examples = [
+        { example: 'uses == :node',
+          options: {},
+          data: <<~DATA
+            in :node, in :parent, out :top?
+            ,          ==:node,   yes
+            ,          ,          no
+          DATA
+        },
+        { example: 'uses :node',
+          options: {},
+          data: <<~DATA
+            in :node, in :parent, out :top?
+            ,         :node,      yes
+            ,         ,           no
+          DATA
+        },
+        { example: 'uses := :node',
+          options: {},
+          data: <<~DATA
+            in :node, in :parent, out :top?
+            ,         := :node,   yes
+            ,         ,           no
+          DATA
+        },
+        { example: 'uses = :node',
+          options: {},
+          data: <<~DATA
+            in :node, in :parent, out :top?
+            ,         = :node,    yes
+            ,         ,           no
+          DATA
+        },
+        { example: 'uses :node, drops :node input column',
+          options: {},
+          data: <<~DATA
+            in :parent, out :top?
+            :node,      yes
+            ,           no
+          DATA
+        },
+        { example: 'uses :parent, drops :parent input column',
+          options: {},
+          data: <<~DATA
+            in :node, out :top?
+            :parent,  yes
+            ,         no
+          DATA
+        },
+        { example: 'uses ==:parent & != :parent',
+          options: { first_match: false },
+          data: <<~DATA
+            in :node,    out :top?
+            == :parent,  yes
+            != :parent,  no
+          DATA
+        },
+        { example: 'uses != :parent, drops :parent input column',
+          options: {},
+          data: <<~DATA
+            in :node,  out :top?
+            !:parent,  no
+            ,          yes
+          DATA
+        },
+        { example: 'uses != :parent and == :parent',
+          options: { first_match: false },
+          data: <<~DATA
+            in :node,    out :top?
+            != :parent,  no
+            == :parent,  yes
+          DATA
+        }
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]}" do
+            options = test[:options]
+            table = CSVDecision.parse(test[:data], options)
+
+            expect(table.send(method, node:  0,  parent: 0)).to eq(top?: 'yes')
+            expect(table.send(method, node:  1,  parent: 0)).to eq(top?: 'no')
+            expect(table.send(method, node: '0', parent: 0)).to eq(top?: 'no')
+          end
+        end
+      end
+    end
+
+    context 'makes correct decision for table with symbol ordered compares' do
+      examples = [
+        { example: 'explicitly mentions :traded',
+          options: {},
+          data: <<~DATA
+            in :traded, in :settled, out :status
+            ,            :traded,    same day
+            ,           >:traded,    pending
+            ,           <:traded,    invalid trade
+            ,                   ,    invalid data
+          DATA
+        },
+        { example: 'does not mention :traded',
+          options: {},
+          data: <<~DATA
+            in :settled, out :status
+            :traded,     same day
+            >:traded,    pending
+            <:traded,    invalid trade
+            ,            invalid data
+          DATA
+        }
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]}" do
+            table = CSVDecision.parse(test[:data], test[:options])
+
+            expect(table.send(method, traded: '20171227',  settled: '20171227')).to eq(status: 'same day')
+            expect(table.send(method, traded:  20171227,   settled:  20171227 )).to eq(status: 'same day')
+            expect(table.send(method, traded: '20171227',  settled: '20171228')).to eq(status: 'pending')
+            expect(table.send(method, traded:  20171227,   settled:  20171228 )).to eq(status: 'pending')
+            expect(table.send(method, traded: '20171228',  settled: '20171227')).to eq(status: 'invalid trade')
+            expect(table.send(method, traded:  20171228,   settled:  20171227 )).to eq(status: 'invalid trade')
+            expect(table.send(method, traded: '20171227',   settled: 20171228 )).to eq(status: 'invalid data')
+          end
+        end
+      end
+    end
+
+    context 'makes correct decisions for table with column symbol guards' do
+      examples = [
+        { example: 'evaluates guard conditions & output functions',
+          options: {},
+          data: <<~DATA
+            IN :country, guard:,          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,    MISSING,        := nil
+          DATA
+        },
+        { example: 'evaluates named guard condition',
+          options: {},
+          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,    MISSING,        := nil
+          DATA
+        },
+        { example: 'evaluates named if condition',
+          options: {},
+          data: <<~DATA
+            in :country, out :PAID, out :PAID_type, out :len,     if:
+            US,          :CUSIP,    CUSIP,          :PAID.length, :PAID.present?
+            GB,          :SEDOL,    SEDOL,          :PAID.length, :PAID.present?
+            ,            :ISIN,     ISIN,           :PAID.length, :PAID.present?
+            ,            :SEDOL,    SEDOL,          :PAID.length, :PAID.present?
+            ,            :CUSIP,    CUSIP,          :PAID.length, :PAID.present?
+            ,            := nil,    MISSING,        := nil,
+          DATA
+        },
+        { example: 'evaluates multiple if conditions',
+          options: {},
+          data: <<~DATA
+            in :country, out :PAID, if:,           out :PAID_type, out :len,     if:,            if: stupid
+            US,          :CUSIP,    !:PAID.blank?, CUSIP,          :PAID.length, :PAID.present?, :len >= 9
+            GB,          :SEDOL,    !:PAID.blank?, SEDOL,          :PAID.length, :PAID.present?, :len >= 9
+            ,            :ISIN,     !:PAID.blank?, ISIN,           :PAID.length, :PAID.present?, :len >= 9
+            ,            :SEDOL,    !:PAID.blank?, SEDOL,          :PAID.length, :PAID.present?, :len >= 9
+            ,            :CUSIP,    !:PAID.blank?, CUSIP,          :PAID.length, :PAID.present?, :len >= 9
+            ,            := nil,    ,              MISSING,        := nil,,
+          DATA
+        }
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]}" do
+            table = CSVDecision.parse(test[:data], test[:options])
+
+            expect(table.send(method, country: 'US',  CUSIP: '123456789'))
+              .to eq(PAID: '123456789', PAID_type: 'CUSIP', len: 9)
+            expect(table.send(method, country: 'EU',  CUSIP: '123456789', ISIN:'123456789012'))
+              .to eq(PAID: '123456789012', PAID_type: 'ISIN', len: 12)
+            expect(table.send(method, country: 'AU', ISIN: ''))
+              .to eq(PAID: nil, PAID_type: 'MISSING', len: nil)
+          end
+        end
+      end
+    end
+
+    context 'makes correct decisions for table with column symbol guards and first_match: false' do
+      examples = [
+        { example: 'evaluates guard conditions & output functions',
+          options: { first_match: false },
+          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
+            ,            :SEDOL.present?, :SEDOL,    SEDOL,      :ID.length
+            ,            :ISIN.present?,  :ISIN,     ISIN,       :ID.length
+          DATA
+        },
+        { example: 'evaluates if: column conditions & output functions',
+          options: { first_match: false },
+          data: <<~DATA
+            IN :country, out :ID, out :ID_type, out :len,   if:
+            US,          :CUSIP,  CUSIP,        :ID.length, :ID.present?
+            GB,          :SEDOL,  SEDOL,        :ID.length, :ID.present?
+            ,            :SEDOL,  SEDOL,        :ID.length, :ID.present?
+            ,            :ISIN,   ISIN,         :ID.length, :ID.present?
+          DATA
+        },
+        { example: 'evaluates multiple if: column conditions & output functions',
+          options: { first_match: false },
+          data: <<~DATA
+            IN :country, out :ID, if:,         out :ID_type, out :len,   if:,       if:
+            US,          :CUSIP,  !:ID.blank?, CUSIP,        :ID.length, :len == 9, :ID.present?
+            GB,          :SEDOL,  !:ID.blank?, SEDOL,        :ID.length, :len == 7, :ID.present?
+            ,            :SEDOL,  !:ID.blank?, SEDOL,        :ID.length, :len == 7, :ID.present?
+            ,            :ISIN,   !:ID.blank?, ISIN,         :ID.length, :len ==12, :ID.present?
+          DATA
+        }
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]}" do
+            table = CSVDecision.parse(test[:data], test[:options])
+
+            expect(table.send(method, country: 'US',  CUSIP: '123456789', Ticker: 'USTY'))
+              .to eq(ID: '123456789', ID_type: 'CUSIP', len: 9)
+
+            expect(table.send(method, country: 'US',  CUSIP: '123456789', ISIN: '123456789012'))
+              .to eq(ID: %w[123456789 123456789012], ID_type: %w[CUSIP ISIN], len: [9, 12])
+
+            expect(table.send(method, country: 'US',  Ticker: 'USTY'))
+              .to eq({})
+          end
+        end
+      end
+    end
+
+    context 'recognises the set: columns and uses correct defaults' do
+      examples = [
+        { example: 'evaluates set/nil? and set columns',
+          options: { first_match: true },
+          data: <<~DATA
+            set/nil? :country, in: type, guard:,          set: class,    out :PAID, out: len,     if:
+            US,                ,         ,                :class.upcase,
+            US,                Equity,   :CUSIP.present?, != PRIVATE,    :CUSIP,    :PAID.length, :len == 9
+            !=US,              Equity,   :ISIN.present?,  != PRIVATE,    :ISIN,     :PAID.length, :len == 12
+            US,                ,         :CUSIP.present?, PRIVATE,       :CUSIP,    :PAID.length,
+            !=US,              ,         :ISIN.present?,  PRIVATE,       :ISIN,     :PAID.length,
+          DATA
+        },
+        { example: 'evaluates set/blank? and set columns',
+          options: { first_match: true },
+          data: <<~DATA
+            set/blank? :country, in: type, guard:,          set: class,    out :PAID, out: len,     if:
+            US,                  ,         ,                :class.upcase,
+            US,                  Equity,   :CUSIP.present?, != PRIVATE,    :CUSIP,    :PAID.length, :len == 9
+            !=US,                Equity,   :ISIN.present?,  != PRIVATE,    :ISIN,     :PAID.length, :len == 12
+            US,                  ,         :CUSIP.present?, PRIVATE,       :CUSIP,    :PAID.length,
+            !=US,                ,         :ISIN.present?,  PRIVATE,       :ISIN,     :PAID.length,
+          DATA
+        }
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]}" do
+            table = CSVDecision.parse(test[:data], test[:options])
+
+            expect(table.send(method, CUSIP: '1234567890', class: 'Private')).to eq(PAID: '1234567890', len: 10)
+            expect(table.send(method, CUSIP: '123456789', type: 'Equity', class: 'Public')).to eq(PAID: '123456789', len: 9)
+            expect(table.send(method, ISIN: '123456789', country: 'GB', class: 'public')).to eq({})
+            expect(table.send(method, ISIN: '123456789012', country: 'GB', class: 'private')).to eq(PAID: '123456789012', len: 12)
+          end
+        end
+      end
+    end
+
+    context 'uses single column index to make correct decisions' do
+      examples = [
+        { example: 'evaluates single-column index CSV string',
+          options: { first_match: false },
+          data: <<~DATA
+            text_only
+            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
+            sports,   ,          Zach
+            finance,  ,          Zach
+            politics, ,          Zach
+          DATA
+        },
+        { example: 'evaluates single-column index CSV file',
+          options: { first_match: false },
+          data: Pathname(File.join(SPEC_DATA_VALID, 'index_example.csv'))
+        }
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]}" do
+            table = CSVDecision.parse(test[:data], test[:options])
+
+            expect(table.send(method, topic: 'politics', region: 'Arctic'))
+              .to eq(team_member: %w[Henry Zach])
+            expect(table.send(method, topic: 'culture', region: 'America'))
+              .to eq({})
+          end
+        end
+      end
+    end
+
+    context 'uses multi-column index to make correct decisions' do
+      examples = [
+        { example: 'evaluates multi-column index CSV string with guard',
+          options: { first_match: true },
+          data: <<~DATA
+            guard:,           in :type, IN :input, OUT :output
+            :number.present?, integer,  none,      :=0
+            :number.blank?,   integer,  none,      :=nil
+            :number.present?, integer,  one,       :=1
+            :number.blank?,   integer,  one,       :=nil
+            :string.present?, string,   none,      0
+            :number.blank?,   string,   none,      :=nil
+            :string.present?, string,   one,       1
+            :number.blank?,   string,   one,       :=nil
+          DATA
+        },
+        { example: 'evaluates multi-column index CSV string with symbol conditions',
+          options: { first_match: true },
+          data: <<~DATA
+            in: number, in: string, in :type, IN :input, OUT :output
+            .present?,  ,           integer,  none,      :=0
+            .blank?,    ,           integer,  none,      :=nil
+            .present?,  ,           integer,  one,       :=1
+            .blank?,    ,           integer,  one,       :=nil
+            ,           .present?,  string,   none,      0
+            .blank?,    ,           string,   none,      :=nil
+            ,           .present?,  string,   one,       1
+            .blank?,    ,           string,   one,       :=nil
+          DATA
+        },
+        { example: 'evaluates multi-column index CSV string with negated symbol conditions',
+          options: { first_match: true },
+          data: <<~DATA
+            in: number,   in: string, in :type, IN :input, OUT :output
+            !.blank?,     ,           integer,  none,      :=0
+            != .present?, ,           integer,  none,      :=nil
+            =.present?,   ,           integer,  one,       :=1
+            ==.blank?,    ,           integer,  one,       :=nil
+            ,             != !blank?, string,   none,      0
+            .blank?,      ,           string,   none,      :=nil
+            ,             !.blank?,   string,   one,       1
+            !present?,    ,           string,   one,       :=nil
+          DATA
+        },
+        { example: 'evaluates multi-column index CSV file',
+          options: { first_match: true },
+          data: Pathname(File.join(SPEC_DATA_VALID, 'multi_column_index.csv'))
+        }
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]}" do
+            table = CSVDecision.parse(test[:data], test[:options])
+
+            expect(table.send(method, number: 1,   type: 'integer', input: 'none')).to eq(output: 0)
+            expect(table.send(method, number: nil, type: 'string', input: 'one')).to eq(output: nil)
+            expect(table.send(method, string: '1', type: 'string', input: 'one')).to eq(output: '1')
+            expect(table.send(method, number: '1', type: 'string', input: 'one')).to eq({})
+          end
+        end
+      end
+    end
+
+    it 'scans the input hash paths for a first match' 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)
+
+      input = {
+        header: { id: 1, type_cd: 'BUY' },
+        payload: { tran_id: 9,
+                   ref_data: { account_id: 5, type_id: 'BUYL' }
+        }
+      }
+      expect(table.decide(input)).to eq(value: 'BUY')
+      expect(table.decide!(input)).to eq(value: 'BUY')
+
+      input = {
+        header: { id: 1 },
+        payload: { tran_id: 9,
+                   ref_data: { account_id: 5, type_id: 'BUYL' }
+        }
+      }
+      expect(table.decide(input)).to eq(value: 'BUYL')
+      expect(table.decide!(input)).to eq(value: 'BUYL')
+
+      input = {
+        payload: { tran_id: 9,
+                   ref_data: { account_id: 5, type_id: 'BUYL' }
+        }
+      }
+      expect(table.decide(input)).to eq(value: 'BUYL')
+
+      input = {
+        payload: { tran_id: nil,
+                   ref_data: {  type_id: '' }
+        }
+      }
+      expect(table.decide(input)).to eq({})
+    end
+
+    it 'scans the input hash paths accumulating matches' do
+      data = <<~DATA
+        path:,   path:,    out :value,     out :key,   if:
+        header,  ,         :source_name,   source_nm,     :value.present?
+        header,  ,         :client_name,   client_nm,     :value.present?
+        header,  ,         :client_ref,    client_ref_id, :value.present?
+        header,  metrics,  :service_name,  service_nm,    :value.present?
+        payload, ,         :amount,        trade_am,      :value.present?
+        payload, ref_data, :account_id,    account_id,    :value.present?
+        header,  metrics,  :receive_time,  receive_tm,    :value.present?
+      DATA
+      table = CSVDecision.parse(data, first_match: false)
+
+      input = {
+        header: {
+          id: 1, type_cd: 'BUY', source_name: 'Client', client_name: 'AAPL', client_ref: 'A1',
+          metrics: { service_name: 'Trading', receive_time: '12:00' }
+        },
+        payload: { tran_id: 9,
+                   amount: '100.00',
+                   ref_data: { account_id: '5010', type_id: 'BUYL' }
+        }
+      }
+      result = { value: %w[Client AAPL A1 Trading 100.00 5010 12:00],
+                 key: %w[source_nm client_nm client_ref_id service_nm trade_am account_id receive_tm] }
+      expect(table.decide(input)).to eq result
+      expect(table.decide!(input)).to eq result
+
+      input = {
+        header: {
+          id: 1, type_cd: 'BUY', source_name: 'Client', client_ref: 'A1',
+          metrics: { service_name: 'Trading' }
+        },
+        payload: { tran_id: 9,
+                   amount: '100.00',
+                   ref_data: { type_id: 'BUYL' }
+        }
+      }
+      result = { value: %w[Client A1 Trading 100.00],
+                 key: %w[source_nm client_ref_id service_nm trade_am] }
+
+      expect(table.decide(input)).to eq result
+      expect(table.decide!(input)).to eq result
+    end
+  end
+end

data/spec/csv_decision_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+describe CSVDecision do
+  describe '.root' do
+    specify { expect(CSVDecision.root).to eq File.dirname __dir__ }
+  end
+end