csv_decision 0.1.0 → 0.2.0

data/lib/csv_decision/matchers.rb

@@ -51,9 +51,6 @@ module CSVDecision
     # Negation sign prefixed to ranges and functions.
     NEGATE = '!'
 
-    # Cell constants and functions specified by prefixing the value with one of these 3 symbols.
-    EQUALS = '==|:=|='
-
     # All regular expressions used for matching are anchored inside their own
     # non-capturing group.
     #
@@ -63,6 +60,9 @@ module CSVDecision
       Regexp.new("\\A(?:#{value})\\z").freeze
     end
 
+    # Cell constants and functions specified by prefixing the value with one of these 3 symbols.
+    EQUALS = '==|:=|='
+
     EQUALS_RE = regexp(EQUALS)
     private_constant :EQUALS_RE
 
@@ -71,7 +71,7 @@ module CSVDecision
     # @param operator [String]
     # @return [String]
     def self.normalize_operator(operator)
-      EQUALS_RE.match(operator) ? '==' : operator
+      EQUALS_RE.match?(operator) ? '==' : operator
     end
 
     # Regular expression used to recognise a numeric string with or without a decimal point.
@@ -135,9 +135,9 @@ module CSVDecision
 
     # @param options (see CSVDecision.parse)
     def initialize(options)
-      @matchers = options[:matchers].collect { |klass| klass.new(options) }
-      @ins = @matchers.select(&:ins?)
-      @outs = @matchers.select(&:outs?)
+      matchers = options[:matchers].collect { |klass| klass.new(options) }
+      @ins = matchers.select(&:ins?)
+      @outs = matchers.select(&:outs?)
     end
 
     # Parse the row's input columns using the input matchers.

data/lib/csv_decision/parse.rb

@@ -9,6 +9,9 @@ module CSVDecision
   class Error < StandardError; end
 
   # Error validating a cell when parsing input table data.
+  class TableValidationError < Error; end
+
+  # Error validating a cell when parsing input table cell data.
   class CellValidationError < Error; end
 
   # Table parsing error message enhanced to include the file being processed.
@@ -82,13 +85,31 @@ module CSVDecision
       # These override any options passed as parameters to the parse method.
       table.options = Options.from_csv(rows: table.rows, options: options).freeze
 
+      # Matchers
+      matchers = CSVDecision::Matchers.new(options)
+
       # Parse the header row
-      table.columns = CSVDecision::Columns.new(table)
+      table.columns = parse_header(table: table, matchers: matchers)
 
-      parse_data(table: table, matchers: Matchers.new(options))
+      # Parse the table's the data rows.
+      parse_data(table: table, matchers: matchers)
     end
     private_class_method :parse_table
 
+    def self.parse_header(table:, matchers:)
+      # Parse the header row
+      table.columns = CSVDecision::Columns.new(table)
+
+      # Parse the defaults row if present
+      return table.columns if table.columns.defaults.blank?
+
+      table.columns.defaults =
+        Defaults.parse(columns: table.columns, matchers: matchers.outs, row: table.rows.shift)
+
+      table.columns
+    end
+    private_class_method :parse_header
+
     def self.parse_data(table:, matchers:)
       table.rows.each_with_index do |row, index|
         # Mutate the row if we find anything other than a simple string constant in its
@@ -201,7 +222,7 @@ module CSVDecision
 
       add_ins_symbols(columns: columns, cell: cell)
     end
-    private_class_method :ins_cell_dictionary
+    # private_class_method :ins_cell_dictionary
 
     def self.add_ins_symbols(columns:, cell:)
       Array(cell.symbols).each do |symbol|

data/lib/csv_decision/scan_row.rb

@@ -27,6 +27,21 @@ module CSVDecision
       invalid_constant?(type: :constant, column: column)
     end
 
+    # Evaluate the cell proc against the column's input value and/or input hash.
+    #
+    # @param proc [CSVDecision::Proc] Proc in the table cell.
+    # @param value [Object] Value supplied in the input hash corresponding to this column.
+    # @param hash [{Symbol=>Object}] Input hash with symbolized keys.
+    def self.eval_matcher(proc:, hash:, value: nil)
+      function = proc.function
+
+      # A symbol guard expression just needs to be passed the input hash
+      return function[hash] if proc.type == :guard
+
+      # All other procs can take one or two args
+      function.arity == 1 ? function[value] : function[value, hash]
+    end
+
     def self.scan_matchers(column:, matchers:, cell:)
       matchers.each do |matcher|
         # Guard function only accepts the same matchers as an output column.
@@ -62,21 +77,6 @@ module CSVDecision
     end
     private_class_method :invalid_constant?
 
-    # Evaluate the cell proc against the column's input value and/or input hash.
-    #
-    # @param proc [CSVDecision::Proc] Proc in the table cell.
-    # @param value [Object] Value supplied in the input hash corresponding to this column.
-    # @param hash [{Symbol=>Object}] Input hash with symbolized keys.
-    def self.eval_matcher(proc:, hash:, value: nil)
-      function = proc.function
-
-      # A symbol guard expression just needs to be passed the input hash
-      return function[hash] if proc.type == :guard
-
-      # All other procs can take one or two args
-      function.arity == 1 ? function[value] : function[value, hash]
-    end
-
     # @return [Array<Integer>] Column indices for simple constants.
     attr_reader :constants
 
@@ -91,7 +91,7 @@ module CSVDecision
     # Scan all the specified +columns+ (e.g., inputs) in the given +data+ row using the +matchers+
     # array supplied.
     #
-    # @param row [Array] Data row.
+    # @param row [Array<String>] Data row - still just all string constants.
     # @param columns [Array<Columns::Entry>] Array of column dictionary entries.
     # @param matchers [Array<Matchers::Matcher>] Array of table cell matchers.
     # @return [Array] Data row with anything not a string constant replaced with a Proc or a

data/lib/csv_decision/table.rb

@@ -11,12 +11,13 @@ module CSVDecision
     #
     # @note Input hash keys may or may not be symbolized.
     # @param input [Hash] Input hash.
-    # @return [Hash{Symbol => Object, Array<Object>}] Decision hash.
+    # @return [{Symbol => Object, Array<Object>}] Decision hash.
     def decide(input)
       Decide.decide(table: self, input: input, symbolize_keys: true)
     end
 
-    # Unsafe version of decide - assumes the input hash is symbolized.
+    # Unsafe version of decide - may mutate the input hash and assumes the input
+    # hash is symbolized.
     #
     # @param input (see #decide)
     # @note Input hash must have its keys symbolized.
@@ -56,11 +57,6 @@ module CSVDecision
     # @api private
     attr_accessor :if_rows
 
-    # @return Array<CSVDecision::Table>] pre-loaded tables passed to this decision table
-    #   at load time. Used to allow this decision table to lookup values in other
-    #   decision tables. (Planned feature.)
-    # attr_reader :tables
-
     # Iterate through all data rows of the decision table, with an optional
     # first and last row index given.
     #

data/lib/csv_decision/validate.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# CSV Decision: CSV based Ruby decision tables.
+# Created December 2017.
+# @author Brett Vickers <brett@phillips-vickers.com>
+# See LICENSE and README.md for details.
+module CSVDecision
+  # Parse and validate the column names in the header row.
+  # These methods are only required at table load time.
+  # @api private
+  module Validate
+    # These column types do not need a name.
+    COLUMN_TYPE_ANONYMOUS = Set.new(%i[guard if]).freeze
+    private_constant :COLUMN_TYPE_ANONYMOUS
+
+    # Validate a column header cell and return its type and name.
+    #
+    # @param cell [String] Header cell.
+    # @param index [Integer] The header column's index.
+    # @return [Array<(Symbol, Symbol)>] Column type and column name symbols.
+    def self.column(cell:, index:)
+      match = Header::COLUMN_TYPE.match(cell)
+      raise CellValidationError, 'column name is not well formed' unless match
+
+      column_type = match['type']&.downcase&.to_sym
+      column_name = column_name(type: column_type, name: match['name'], index: index)
+
+      [column_type, column_name]
+    rescue CellValidationError => exp
+      raise CellValidationError, "header column '#{cell}' is not valid as the #{exp.message}"
+    end
+
+    # Validate the column name against the dictionary of column names.
+    #
+    # @param columns [Symbol=>[false, Integer]] Column name dictionary.
+    # @param name [Symbol] Column name.
+    # @param out [false, Integer] False if an input column, otherwise the column index of
+    #   the output column.
+    # @return [void]
+    # @raise [CellValidationError] Column name invalid.
+    def self.name(columns:, name:, out:)
+      return unless (in_out = columns[name])
+
+      return validate_out_name(in_out: in_out, name: name) if out
+      validate_in_name(in_out: in_out, name: name)
+    end
+
+    def self.column_name(type:, name:, index:)
+      # if: columns are named after their index, which is an integer and so cannot
+      # clash with other column name types, which are symbols.
+      return index if type == :if
+
+      return format_column_name(name) if name.present?
+
+      return if COLUMN_TYPE_ANONYMOUS.member?(type)
+      raise CellValidationError, 'column name is missing'
+    end
+    private_class_method :column_name
+
+    def self.format_column_name(name)
+      column_name = name.strip.tr("\s", '_')
+
+      return column_name.to_sym if Header.column_name?(column_name)
+      raise CellValidationError, "column name '#{name}' contains invalid characters"
+    end
+    private_class_method :format_column_name
+
+    def self.validate_out_name(in_out:, name:)
+      if in_out == :in
+        raise CellValidationError, "output column name '#{name}' is also an input column"
+      end
+
+      raise CellValidationError, "output column name '#{name}' is duplicated"
+    end
+    private_class_method :validate_out_name
+
+    def self.validate_in_name(in_out:, name:)
+      # in: columns may be duped
+      return if in_out == :in
+
+      raise CellValidationError, "output column name '#{name}' is also an input column"
+    end
+    private_class_method :validate_in_name
+  end
+end

data/lib/csv_decision.rb

@@ -14,10 +14,11 @@ module CSVDecision
   end
 
   autoload :Columns,    'csv_decision/columns'
-  autoload :Dictionary, 'csv_decision/dictionary'
   autoload :Data,       'csv_decision/data'
   autoload :Decide,     'csv_decision/decide'
   autoload :Decision,   'csv_decision/decision'
+  autoload :Defaults,   'csv_decision/defaults'
+  autoload :Dictionary, 'csv_decision/dictionary'
   autoload :Header,     'csv_decision/header'
   autoload :Input,      'csv_decision/input'
   autoload :Load,       'csv_decision/load'
@@ -27,6 +28,7 @@ module CSVDecision
   autoload :Result,     'csv_decision/result'
   autoload :ScanRow,    'csv_decision/scan_row'
   autoload :Table,      'csv_decision/table'
+  autoload :Validate,   'csv_decision/validate'
 
   class Matchers
     autoload :Constant,      'csv_decision/matchers/constant'

data/spec/csv_decision/columns_spec.rb

@@ -33,10 +33,10 @@ describe CSVDecision::Columns do
     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)
-    expect(table.columns.ins[2].to_h).to eq(name: :input, eval: false, type: :in)
-    expect(table.columns.outs[1].to_h).to eq(name: :output, eval: nil, type: :out)
-    expect(table.columns.outs[3].to_h).to eq(name: :output2, eval: false, type: :out)
+    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
@@ -50,13 +50,13 @@ describe CSVDecision::Columns do
     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)
-    expect(table.columns.ins[2].to_h).to eq(name: :input, eval: false, type: :in)
-    expect(table.columns.ins[5].to_h).to eq(name: nil, eval: true, type: :guard)
+    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)
-    expect(table.columns.outs[3].to_h).to eq(name: :output2, eval: false, type: :out)
-    expect(table.columns.outs[4].to_h).to eq(name: :len, eval: true, type: :out)
+    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)
@@ -74,12 +74,12 @@ describe CSVDecision::Columns do
     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)
-    expect(table.columns.ins[2].to_h).to eq(name: :input, eval: false, type: :in)
-    expect(table.columns.outs[1].to_h).to eq(name: :output, eval: nil, type: :out)
-    expect(table.columns.outs[3].to_h).to eq(name: :output2, eval: false, type: :out)
-    expect(table.columns.outs[4].to_h).to eq(name: :input3, eval: true, type: :out)
-    expect(table.columns.outs[5].to_h).to eq(name: :len, eval: true, type: :out)
+    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)
@@ -118,10 +118,10 @@ describe CSVDecision::Columns do
     result = CSVDecision.parse(file)
 
     expect(result.columns).to be_a(CSVDecision::Columns)
-    expect(result.columns.ins)
-      .to eq(0 => CSVDecision::Dictionary::Entry.new(:input, nil, :in))
-    expect(result.columns.outs)
-      .to eq(1 => CSVDecision::Dictionary::Entry.new(:output, nil, :out))
+    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
@@ -179,7 +179,7 @@ describe CSVDecision::Columns do
     table = CSVDecision.parse(data)
 
     expect(table.columns.ins[1].to_h)
-      .to eq(name: nil, eval: true, type: :guard)
+      .to eq(name: nil, eval: true, type: :guard, set_if: nil)
 
     expect(table.columns.input_keys).to eq %i[country CUSIP SEDOL]
   end
@@ -215,7 +215,23 @@ describe CSVDecision::Columns do
     DATA
     table = CSVDecision.parse(data)
 
-    expect(table.columns.ifs[3].to_h).to eq(name: 3, eval: true, type: :if)
+    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
 end

data/spec/csv_decision/examples_spec.rb

@@ -180,4 +180,21 @@ context 'simple examples' do
     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
 end

data/spec/csv_decision/matchers/range_spec.rb

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

data/spec/csv_decision/table_spec.rb

@@ -451,5 +451,44 @@ describe CSVDecision::Table do
         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
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csv_decision
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Brett Vickers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-07 00:00:00.000000000 Z
+date: 2018-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -179,6 +179,7 @@ files:
 - doc/CSVDecision/Data.html
 - doc/CSVDecision/Decide.html
 - doc/CSVDecision/Decision.html
+- doc/CSVDecision/Defaults.html
 - doc/CSVDecision/Dictionary.html
 - doc/CSVDecision/Dictionary/Entry.html
 - doc/CSVDecision/Error.html
@@ -205,6 +206,8 @@ files:
 - doc/CSVDecision/ScanRow.html
 - doc/CSVDecision/Symbol.html
 - doc/CSVDecision/Table.html
+- doc/CSVDecision/TableValidationError.html
+- doc/CSVDecision/Validate.html
 - doc/_index.html
 - doc/class_list.html
 - doc/css/common.css
@@ -224,6 +227,7 @@ files:
 - lib/csv_decision/data.rb
 - lib/csv_decision/decide.rb
 - lib/csv_decision/decision.rb
+- lib/csv_decision/defaults.rb
 - lib/csv_decision/dictionary.rb
 - lib/csv_decision/header.rb
 - lib/csv_decision/input.rb
@@ -241,6 +245,7 @@ files:
 - lib/csv_decision/result.rb
 - lib/csv_decision/scan_row.rb
 - lib/csv_decision/table.rb
+- lib/csv_decision/validate.rb
 - spec/csv_decision/columns_spec.rb
 - spec/csv_decision/constant_spec.rb
 - spec/csv_decision/data_spec.rb