csv_decision 0.0.1 → 0.0.2

data/spec/csv_decision/load_spec.rb

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

data/spec/csv_decision/matchers/numeric_spec.rb

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

data/spec/csv_decision/matchers/pattern_spec.rb

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

data/spec/csv_decision/matchers/range_spec.rb

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

data/spec/csv_decision/options_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+SPEC_DATA_VALID ||= File.join(CSVDecision.root, 'spec', 'data', 'valid')
+
+describe CSVDecision::Options do
+  it 'sets the default options' do
+    data = <<~DATA
+      IN :input, OUT :output
+      input0,    output0
+    DATA
+
+    result = CSVDecision.parse(data)
+
+    expected = {
+      first_match: true,
+      regexp_implicit: false,
+      text_only: false,
+      matchers: CSVDecision::DEFAULT_MATCHERS
+    }
+    expect(result.options).to eql expected
+  end
+
+  it 'overrides the default options' do
+    data = <<~DATA
+      IN :input, OUT :output
+      input0,    output0
+    DATA
+
+    result = CSVDecision.parse(data, first_match: false)
+
+    expected = {
+      first_match: false,
+      regexp_implicit: false,
+      text_only: false,
+      matchers: CSVDecision::DEFAULT_MATCHERS
+    }
+    expect(result.options).to eql expected
+  end
+
+  it 'parses options from a CSV file' do
+    file = Pathname(File.join(SPEC_DATA_VALID, 'options_in_file1.csv'))
+    result = CSVDecision.parse(file)
+
+    expected = {
+      first_match: false,
+      regexp_implicit: false,
+      text_only: false,
+      matchers: CSVDecision::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)
+
+    expected = {
+      first_match: false,
+      regexp_implicit: true,
+      text_only: false,
+      matchers: CSVDecision::DEFAULT_MATCHERS
+    }
+    expect(result.options).to eql expected
+  end
+end