csv_decision2 0.5.1 → 0.5.2

data/spec/{csv_decision → csv_decision2}/examples_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../lib/csv_decision'
+require_relative '../../lib/csv_decision2'
 
 context 'simple examples' do
   context 'simple example - strings-only' do
@@ -18,7 +18,7 @@ context 'simple examples' do
     DATA
 
     it 'makes correct decisions for CSV string' do
-      table = CSVDecision.parse(data)
+      table = CSVDecision2.parse(data)
 
       result = table.decide(topic: 'finance', region: 'Europe')
       expect(result).to eq(team_member: 'Donald')
@@ -31,7 +31,7 @@ context 'simple examples' do
     end
 
     it 'makes correct decisions for CSV file' do
-      table = CSVDecision.parse(Pathname('spec/data/valid/simple_example.csv'))
+      table = CSVDecision2.parse(Pathname('spec/data/valid/simple_example.csv'))
 
       result = table.decide(topic: 'finance', region: 'Europe')
       expect(result).to eq(team_member: 'Donald')
@@ -55,7 +55,7 @@ context 'simple examples' do
     DATA
 
     it 'makes correct decisions for CSV string' do
-      table = CSVDecision.parse(data)
+      table = CSVDecision2.parse(data)
 
       result = table.decide(constant: nil)
       expect(result).to eq(value: nil)
@@ -82,7 +82,7 @@ context 'simple examples' do
     DATA
 
     it 'makes correct decisions' do
-      table = CSVDecision.parse(data)
+      table = CSVDecision2.parse(data)
 
       result = table.decide(node: 0, parent: 0)
       expect(result).to eq(top?: 'yes')
@@ -103,7 +103,7 @@ context 'simple examples' do
     DATA
 
     it 'makes correct decisions' do
-      table = CSVDecision.parse(data)
+      table = CSVDecision2.parse(data)
 
       result = table.decide(node: 0, parent: 0)
       expect(result).to eq(top?: 'yes')
@@ -124,7 +124,7 @@ context 'simple examples' do
       ,           <:traded,    invalid trade
       ,                   ,    invalid data
     DATA
-    table = CSVDecision.parse(data)
+    table = CSVDecision2.parse(data)
 
     expect(table.columns.input_keys).to eq %i[traded settled]
 
@@ -136,7 +136,7 @@ context 'simple examples' do
     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
@@ -148,7 +148,7 @@ context 'simple examples' do
       ,            ,                := nil,  := nil,       := nil
     DATA
 
-    table = CSVDecision.parse(data)
+    table = CSVDecision2.parse(data)
 
     expect(table.decide(country: 'US',  CUSIP: '123456789'))
       .to eq(ID: '123456789', ID_type: 'CUSIP', len: 9)
@@ -167,7 +167,7 @@ context 'simple examples' do
       ,            :CUSIP.present?, :CUSIP,  DUMMY,        :ID.length,
       DATA
 
-    table = CSVDecision.parse(data)
+    table = CSVDecision2.parse(data)
 
     expect(table.decide(country: 'US',  CUSIP: '12345678'))
       .to eq(ID: '12345678', ID_type: 'CUSIP8', len: 8)
@@ -191,7 +191,7 @@ context 'simple examples' do
       !=US,              :ISIN.present?,  PRIVATE,       :ISIN,     :PAID.length,
     DATA
 
-    table = CSVDecision.parse(data)
+    table = CSVDecision2.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({})
@@ -208,7 +208,7 @@ context 'simple examples' do
       !=US,              ,                !.blank?,   PRIVATE,       :ISIN,     :PAID.length,
     DATA
 
-    table = CSVDecision.parse(data)
+    table = CSVDecision2.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({})
@@ -223,7 +223,7 @@ context 'simple examples' do
       payload, ,         :amount
       payload, ref_data, :account_id
     DATA
-    table = CSVDecision.parse(data, first_match: false)
+    table = CSVDecision2.parse(data, first_match: false)
 
     input = {
       header: {
@@ -239,4 +239,4 @@ context 'simple examples' do
     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
+end

data/spec/{csv_decision → csv_decision2}/index_spec.rb

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

data/spec/{csv_decision → csv_decision2}/input_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../../lib/csv_decision'
+require_relative '../../lib/csv_decision2'
 
-describe CSVDecision::Input do
+describe CSVDecision2::Input do
   it 'rejects a non-hash or empty hash value' do
-    expect { CSVDecision::Input.parse(table: nil, input: [], symbolize_keys: true ) }
+    expect { CSVDecision2::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 ) }
+    expect { CSVDecision2::Input.parse(table: nil, input: {}, symbolize_keys: true ) }
       .to raise_error(ArgumentError, 'input must be a non-empty hash')
   end
 
@@ -17,7 +17,7 @@ describe CSVDecision::Input do
       input0,    output1,
     DATA
 
-    table = CSVDecision.parse(data)
+    table = CSVDecision2.parse(data)
 
     input = { 'input' => 'input0', input1: 'input1' }
     expected = {
@@ -26,7 +26,7 @@ describe CSVDecision::Input do
       key: 'input0'
     }
 
-    result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: true)
+    result = CSVDecision2::Input.parse(table: table, input: input, symbolize_keys: true)
 
     expect(result).to eql expected
     expect(result[:hash]).not_to equal expected[:hash]
@@ -39,7 +39,7 @@ describe CSVDecision::Input do
       input0,    output1,
     DATA
 
-    table = CSVDecision.parse(data)
+    table = CSVDecision2.parse(data)
     input = { input: 'input0', input1: 'input1' }
     expected = {
       hash: input,
@@ -47,9 +47,9 @@ describe CSVDecision::Input do
       key: 'input0'
     }
 
-    result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: false)
+    result = CSVDecision2::Input.parse(table: table, input: input, symbolize_keys: false)
 
     expect(result).to eql expected
     expect(result[:hash]).to equal expected[:hash]
   end
-end
+end

data/spec/{csv_decision → csv_decision2}/load_spec.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
-require_relative '../../lib/csv_decision'
+require_relative '../../lib/csv_decision2'
 
-describe CSVDecision::Load do
-  path = Pathname(File.join(CSVDecision.root, 'spec/data/valid'))
+describe CSVDecision2::Load do
+  path = Pathname(File.join(CSVDecision2.root, 'spec/data/valid'))
 
   it "loads all valid CSV files in the directory" do
-    tables = CSVDecision.load(path, first_match: false, regexp_implicit: true)
+    tables = CSVDecision2.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)
+      expect(table).to be_a(CSVDecision2::Table)
     end
   end
 
   it 'rejects an invalid path name' do
-    expect { CSVDecision.load('path') }
+    expect { CSVDecision2.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')) }
+    expect { CSVDecision2.load(Pathname('path')) }
       .to raise_error(ArgumentError, 'path argument not a valid folder')
   end
-end
+end

data/spec/{csv_decision → csv_decision2}/matchers/function_spec.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../../lib/csv_decision'
+require_relative '../../../lib/csv_decision2'
 
-describe CSVDecision::Matchers::Function do
+describe CSVDecision2::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 be_a CSVDecision2::Matchers::Function }
+    it { is_expected.to be_a CSVDecision2::Matchers::Matcher }
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
@@ -21,7 +21,7 @@ describe CSVDecision::Matchers::Function do
     }
     cells.each_pair do |cell, expected|
       it "recognises #{cell} as a function" do
-        match = CSVDecision::Matchers::Function::FUNCTION_RE.match(cell)
+        match = CSVDecision2::Matchers::Function::FUNCTION_RE.match(cell)
         expect(match['operator']).to eq expected[:operator]
         expect(match['name']).to eq expected[:name]
       end
@@ -63,7 +63,7 @@ describe CSVDecision::Matchers::Function do
     #   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).to be_a(CSVDecision2::Proc)
     #       expect(proc.function.call(ex[:value], ex[:hash])).to eq ex[:result]
     #     end
     #   end
@@ -79,4 +79,4 @@ describe CSVDecision::Matchers::Function do
       end
     end
   end
-end
+end

data/spec/{csv_decision → csv_decision2}/matchers/guard_spec.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../../lib/csv_decision'
+require_relative '../../../lib/csv_decision2'
 
-describe CSVDecision::Matchers::Guard do
+describe CSVDecision2::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 be_a CSVDecision2::Matchers::Guard }
+    it { is_expected.to be_a CSVDecision2::Matchers::Matcher }
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
@@ -116,7 +116,7 @@ describe CSVDecision::Matchers::Guard do
       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).to be_a(CSVDecision2::Matchers::Proc)
           expect(proc.type).to eq :guard
           expect(proc.function.call(ex[:hash])).to eq ex[:result]
         end
@@ -145,8 +145,8 @@ describe CSVDecision::Matchers::Guard do
       DATA
 
       specify do
-        expect { CSVDecision.parse(data) }
-          .to raise_error(CSVDecision::CellValidationError, 'guard: column cannot contain constants')
+        expect { CSVDecision2.parse(data) }
+          .to raise_error(CSVDecision2::CellValidationError, 'guard: column cannot contain constants')
       end
     end
 
@@ -154,17 +154,17 @@ describe CSVDecision::Matchers::Guard 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,          
+        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')
+        expect { CSVDecision2.parse(data) }
+          .to raise_error(CSVDecision2::CellValidationError, 'if: column cannot contain constants')
       end
     end
   end
-end
+end

data/spec/{csv_decision → csv_decision2}/matchers/numeric_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../../../lib/csv_decision'
+require_relative '../../../lib/csv_decision2'
 
-describe CSVDecision::Matchers::Numeric do
+describe CSVDecision2::Matchers::Numeric do
   subject { described_class.new }
 
   describe '#new' do
-    it { is_expected.to be_a CSVDecision::Matchers::Numeric }
+    it { is_expected.to be_a CSVDecision2::Matchers::Numeric }
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
@@ -27,7 +27,7 @@ describe CSVDecision::Matchers::Numeric do
       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).to be_a(CSVDecision2::Matchers::Proc)
           expect(proc.type).to eq :proc
           expect(proc.function[value]).to eq true
         end
@@ -44,4 +44,4 @@ describe CSVDecision::Matchers::Numeric do
       end
     end
   end
-end
+end

data/spec/{csv_decision → csv_decision2}/matchers/pattern_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../../../lib/csv_decision'
+require_relative '../../../lib/csv_decision2'
 
-describe CSVDecision::Matchers::Pattern do
+describe CSVDecision2::Matchers::Pattern do
   subject { described_class.new }
 
   describe '#new' do
-    it { is_expected.to be_a CSVDecision::Matchers::Pattern }
+    it { is_expected.to be_a CSVDecision2::Matchers::Pattern }
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
@@ -27,7 +27,7 @@ describe CSVDecision::Matchers::Pattern do
       expressions.each do |cell|
         it "recognises regexp #{cell}" do
           proc = matcher.matches?(cell)
-          expect(proc).to be_a CSVDecision::Matchers::Proc
+          expect(proc).to be_a CSVDecision2::Matchers::Proc
           expect(proc.type).to eq :proc
           expect(proc.function).to be_a ::Proc
           expect(proc.function.arity).to eq -1
@@ -50,7 +50,7 @@ describe CSVDecision::Matchers::Pattern do
       expressions.each do |cell|
         it "recognises regexp #{cell}" do
           proc = matcher.matches?(cell)
-          expect(proc).to be_a CSVDecision::Matchers::Proc
+          expect(proc).to be_a CSVDecision2::Matchers::Proc
           expect(proc.type).to eq :proc
           expect(proc.function).to be_a ::Proc
           expect(proc.function.arity).to eq -1
@@ -180,4 +180,4 @@ describe CSVDecision::Matchers::Pattern do
       end
     end
   end
-end
+end

data/spec/{csv_decision → csv_decision2}/matchers/range_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../../../lib/csv_decision'
+require_relative '../../../lib/csv_decision2'
 
-describe CSVDecision::Matchers::Range do
+describe CSVDecision2::Matchers::Range do
   subject { described_class.new }
 
   describe '#new' do
-    it { is_expected.to be_a CSVDecision::Matchers::Range }
+    it { is_expected.to be_a CSVDecision2::Matchers::Range }
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
@@ -29,7 +29,7 @@ describe CSVDecision::Matchers::Range do
       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).to be_a(CSVDecision2::Matchers::Proc)
           expect(proc.type).to eq :proc
           expect(proc.function[value]).to eq true
         end
@@ -50,7 +50,7 @@ describe CSVDecision::Matchers::Range do
       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).to be_a(CSVDecision2::Matchers::Proc)
           expect(proc.type).to eq :proc
           expect(proc.function[value]).to eq false
         end

data/spec/{csv_decision → csv_decision2}/matchers/symbol_spec.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../../lib/csv_decision'
+require_relative '../../../lib/csv_decision2'
 
-describe CSVDecision::Matchers::Symbol do
+describe CSVDecision2::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 be_a CSVDecision2::Matchers::Symbol }
+    it { is_expected.to be_a CSVDecision2::Matchers::Matcher }
     it { is_expected.to respond_to(:matches?).with(1).argument }
   end
 
@@ -48,7 +48,7 @@ describe CSVDecision::Matchers::Symbol do
       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::Matchers::Proc)
+          expect(proc).to be_a(CSVDecision2::Matchers::Proc)
           expect(proc.function.call(ex[:value], ex[:hash])).to eq ex[:result]
         end
       end
@@ -64,4 +64,4 @@ describe CSVDecision::Matchers::Symbol do
       end
     end
   end
-end
+end

data/spec/{csv_decision → csv_decision2}/options_spec.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require_relative '../../lib/csv_decision'
+require_relative '../../lib/csv_decision2'
 
-SPEC_DATA_VALID ||= File.join(CSVDecision.root, 'spec', 'data', 'valid')
-SPEC_DATA_INVALID ||= File.join(CSVDecision.root, 'spec', 'data', 'invalid')
+SPEC_DATA_VALID ||= File.join(CSVDecision2.root, 'spec', 'data', 'valid')
+SPEC_DATA_INVALID ||= File.join(CSVDecision2.root, 'spec', 'data', 'invalid')
 
-describe CSVDecision::Options do
+describe CSVDecision2::Options do
   it 'sets the default options' do
     data = <<~DATA
       IN :input, OUT :output
       input0,    output0
     DATA
 
-    result = CSVDecision.parse(data)
+    result = CSVDecision2.parse(data)
 
     expected = {
       first_match: true,
       regexp_implicit: false,
       text_only: false,
-      matchers: CSVDecision::Options::DEFAULT_MATCHERS
+      matchers: CSVDecision2::Options::DEFAULT_MATCHERS
     }
     expect(result.options).to eql expected
   end
@@ -29,15 +29,15 @@ describe CSVDecision::Options do
       input0,    output0
     DATA
 
-    result = CSVDecision.parse(data,
+    result = CSVDecision2.parse(data,
                                first_match: false,
-                               matchers: [CSVDecision::Matchers::Pattern])
+                               matchers: [CSVDecision2::Matchers::Pattern])
 
     expected = {
       first_match: false,
       regexp_implicit: false,
       text_only: false,
-      matchers: [CSVDecision::Matchers::Pattern]
+      matchers: [CSVDecision2::Matchers::Pattern]
     }
     expect(result.options).to eql expected
   end
@@ -48,47 +48,47 @@ describe CSVDecision::Options do
       input0,    output0
     DATA
 
-    expect { CSVDecision.parse(data, bad_option: false) }
-      .to raise_error(CSVDecision::CellValidationError,
+    expect { CSVDecision2.parse(data, bad_option: false) }
+      .to raise_error(CSVDecision2::CellValidationError,
                       "invalid option(s) supplied: [:bad_option]")
   end
 
   it 'parses options from a CSV file' do
     file = Pathname(File.join(SPEC_DATA_VALID, 'options_in_file1.csv'))
-    result = CSVDecision.parse(file)
+    result = CSVDecision2.parse(file)
 
     expected = {
       first_match: false,
       regexp_implicit: false,
       text_only: false,
-      matchers: CSVDecision::Options::DEFAULT_MATCHERS
+      matchers: CSVDecision2::Options::DEFAULT_MATCHERS
     }
     expect(result.options).to eql expected
   end
 
   it 'options from the CSV file override method options' do
     file = Pathname(File.join(SPEC_DATA_VALID, 'options_in_file2.csv'))
-    result = CSVDecision.parse(file, first_match: true, regexp_implicit: nil)
+    result = CSVDecision2.parse(file, first_match: true, regexp_implicit: nil)
 
     expected = {
       first_match: false,
       regexp_implicit: true,
       text_only: false,
-      matchers: CSVDecision::Options::DEFAULT_MATCHERS
+      matchers: CSVDecision2::Options::DEFAULT_MATCHERS
     }
     expect(result.options).to eql expected
   end
 
   it 'parses index option from the CSV file' do
     file = Pathname(File.join(SPEC_DATA_VALID, 'options_in_file3.csv'))
-    result = CSVDecision.parse(file)
+    result = CSVDecision2.parse(file)
 
     expected = {
       first_match: false,
       regexp_implicit: true,
       text_only: false,
-      matchers: CSVDecision::Options::DEFAULT_MATCHERS
+      matchers: CSVDecision2::Options::DEFAULT_MATCHERS
     }
     expect(result.options).to eql expected
   end
-end
+end

data/spec/csv_decision2/parse_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision2'
+
+describe CSVDecision2::Parse do
+  it 'rejects an empty decision table' do
+    expect { CSVDecision2.parse('') }
+      .to raise_error(CSVDecision2::TableValidationError,
+                      'table has no header row')
+  end
+
+  it 'parses a decision table from a CSV file' do
+    file = Pathname(File.join(CSVDecision2.root, 'spec/data/valid', 'valid.csv'))
+    result = CSVDecision2.parse(file)
+
+    expected = [
+      ['input', '']
+    ]
+
+    expect(result).to be_a(CSVDecision2::Table)
+    expect(result.rows).to eq expected
+  end
+
+  context 'it parses valid CSV files' do
+    Dir[File.join(CSVDecision2.root, 'spec/data/valid/*.csv')].each do |file_name|
+      pathname = Pathname(file_name)
+
+      it "loads CSV file: #{pathname.basename}" do
+        expect { CSVDecision2.parse(pathname) }.not_to raise_error
+        expect(CSVDecision2.parse(pathname)).to be_a CSVDecision2::Table
+      end
+    end
+  end
+
+  context 'it rejects invalid CSV files' do
+    Dir[File.join(CSVDecision2.root, 'spec/data/invalid/*.csv')].each do |file_name|
+      pathname = Pathname(file_name)
+
+      it "rejects CSV file: #{pathname.basename}" do
+        expect { CSVDecision2.parse(pathname) }.to raise_error(CSVDecision2::FileError)
+      end
+    end
+  end
+end