csv_decision 0.2.0 → 0.3.0

data/lib/csv_decision/matchers.rb

@@ -31,6 +31,18 @@ module CSVDecision
         freeze
       end
 
+      # @param hash [Hash] Input hash to function call.
+      # @param value [Object] Input value to function call.
+      # @return [Object] Value returned from function call.
+      def call(hash:, value: nil)
+        func = fetch(1)
+
+        return func.call(hash) if fetch(0) == :guard
+
+        # All other procs can take one or two args
+        func.arity == 1 ? func.call(value) : func.call(value, hash)
+      end
+
       # @return [Symbol] Type of the function value - e.g., :constant or :guard.
       def type
         fetch(0)
@@ -80,18 +92,12 @@ module CSVDecision
     NUMERIC_RE = regexp(NUMERIC)
     private_constant :NUMERIC_RE
 
-    # @param value [Object] Value from the input hash.
-    # @return [Boolean] Return true if value is an Integer or a BigDecimal, false otherwise.
-    def self.numeric?(value)
-      value.is_a?(Integer) || value.is_a?(BigDecimal)
-    end
-
     # Validate a numeric value and convert it to an Integer or BigDecimal if a valid numeric string.
     #
     # @param value [nil, String, Integer, BigDecimal]
     # @return [nil, Integer, BigDecimal]
     def self.numeric(value)
-      return value if numeric?(value)
+      return value if value.is_a?(Integer) || value.is_a?(BigDecimal)
       return unless value.is_a?(String)
 
       to_numeric(value)
@@ -124,7 +130,7 @@ module CSVDecision
       # Convert values in the data row if not just a simple constant.
       row = scan_row.scan_columns(columns: columns, matchers: matchers, row: row)
 
-      [row, scan_row.freeze]
+      [row, scan_row]
     end
 
     # @return [Array<Matchers::Matcher>] Matchers for the input columns.

data/lib/csv_decision/options.rb

@@ -5,18 +5,6 @@
 # @author Brett Vickers <brett@phillips-vickers.com>
 # See LICENSE and README.md for details.
 module CSVDecision
-  # # Specialized cell value matchers beyond simple string compares.
-  # # By default all these matchers are tried in the specified order on all
-  # # input data cells.
-  # DEFAULT_MATCHERS = [
-  #   Matchers::Range,
-  #   Matchers::Numeric,
-  #   Matchers::Pattern,
-  #   Matchers::Constant,
-  #   Matchers::Symbol,
-  #   Matchers::Guard
-  # ].freeze
-
   # Validate and normalize the options values supplied.
   # @api private
   module Options
@@ -44,10 +32,9 @@ module CSVDecision
     # These options may appear in the CSV file before the header row.
     # They get converted to a normalized option key value pair.
     CSV_NAMES = {
-      first_match: [:first_match, true],
-      accumulate: [:first_match, false],
+      first_match: [:first_match, true], accumulate: [:first_match, false],
       regexp_implicit: [:regexp_implicit, true],
-      text_only: [:text_only, true]
+      text_only: [:text_only, true], string_search: [:text_only, true]
     }.freeze
     private_constant :CSV_NAMES
 
@@ -55,7 +42,7 @@ module CSVDecision
     #
     # @param options [Hash] Input options hash supplied by the user.
     # @return [Hash] Options hash filled in with all required values, defaulted if necessary.
-    # @raise [ArgumentError] For invalid option keys.
+    # @raise [CellValidationError] For invalid option keys.
     def self.normalize(options)
       validate(options)
       default(options)
@@ -119,8 +106,9 @@ module CSVDecision
     private_class_method :matchers
 
     def self.option?(cell)
-      key = cell.downcase.to_sym
-      return CSV_NAMES[key] if CSV_NAMES.key?(key)
+      key = cell.strip.downcase.to_sym
+
+      CSV_NAMES[key]
     end
     private_class_method :option?
 
@@ -129,7 +117,7 @@ module CSVDecision
 
       return if invalid_options.empty?
 
-      raise ArgumentError, "invalid option(s) supplied: #{invalid_options.inspect}"
+      raise CellValidationError, "invalid option(s) supplied: #{invalid_options.inspect}"
     end
     private_class_method :validate
   end

data/lib/csv_decision/parse.rb

@@ -78,37 +78,29 @@ module CSVDecision
     private_class_method :raise_error
 
     def self.parse_table(table:, input:, options:)
-      # Parse input data into an array of arrays
+      # Parse input data into an array of arrays.
       table.rows = Data.to_array(data: input)
 
       # Pick up any options specified in the CSV file before the header row.
       # 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 table header and data rows with special cell matchers.
+      parse_with_matchers(table: table, matchers: CSVDecision::Matchers.new(options))
 
-      # Parse the header row
-      table.columns = parse_header(table: table, matchers: matchers)
-
-      # Parse the table's the data rows.
-      parse_data(table: table, matchers: matchers)
+      # Build the index if one is indicated
+      Index.build(table: table)
     end
     private_class_method :parse_table
 
-    def self.parse_header(table:, matchers:)
+    def self.parse_with_matchers(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 = Header.parse(table: table, matchers: matchers)
 
-      table.columns.defaults =
-        Defaults.parse(columns: table.columns, matchers: matchers.outs, row: table.rows.shift)
-
-      table.columns
+      # Parse the table's the data rows.
+      parse_data(table: table, matchers: matchers)
     end
-    private_class_method :parse_header
+    private_class_method :parse_with_matchers
 
     def self.parse_data(table:, matchers:)
       table.rows.each_with_index do |row, index|
@@ -139,7 +131,7 @@ module CSVDecision
       row, table.scan_rows[index] = matchers.parse_ins(columns: table.columns.ins, row: row)
 
       # Add any symbol references made by input cell procs to the column dictionary
-      ins_column_dictionary(columns: table.columns.dictionary, row: row)
+      Columns.ins_dictionary(columns: table.columns.dictionary, row: row)
 
       row
     end
@@ -149,88 +141,12 @@ module CSVDecision
       # Parse the output cells for this row
       row, table.outs_rows[index] = matchers.parse_outs(columns: table.columns.outs, row: row)
 
-      outs_column_dictionary(columns: table.columns, row: row)
+      Columns.outs_dictionary(columns: table.columns, row: row)
 
       row
     end
     private_class_method :parse_row_outs
 
-    def self.outs_column_dictionary(columns:, row:)
-      row.each_with_index do |cell, index|
-        outs_check_cell(columns: columns, cell: cell, index: index)
-      end
-    end
-    private_class_method :outs_column_dictionary
-
-    def self.outs_check_cell(columns:, cell:, index:)
-      return unless cell.is_a?(Matchers::Proc)
-      return if cell.symbols.nil?
-
-      check_outs_symbols(columns: columns, cell: cell, index: index)
-    end
-    private_class_method :outs_check_cell
-
-    def self.check_outs_symbols(columns:, cell:, index:)
-      Array(cell.symbols).each do |symbol|
-        check_outs_symbol(columns: columns, symbol: symbol, index: index)
-      end
-    end
-    private_class_method :check_outs_symbols
-
-    def self.check_outs_symbol(columns:, symbol:, index:)
-      in_out = columns.dictionary[symbol]
-
-      # If its an input column symbol then we're good.
-      return if ins_symbol?(columns: columns, symbol: symbol, in_out: in_out)
-
-      # Check if this output symbol reference is on or after this cell's column
-      invalid_out_ref?(columns, index, in_out)
-    end
-    private_class_method :check_outs_symbol
-
-    # If the symbol exists either as an input or does not exist then we're good.
-    def self.ins_symbol?(columns:, symbol:, in_out:)
-      return true if in_out == :in
-
-      # It must an input symbol, as all the output symbols have been parsed.
-      return columns.dictionary[symbol] = :in if in_out.nil?
-
-      false
-    end
-    private_class_method :ins_symbol?
-
-    def self.invalid_out_ref?(columns, index, in_out)
-      return false if in_out < index
-
-      that_column = if in_out == index
-                      'reference to itself'
-                    else
-                      "an out of order reference to output column '#{columns.outs[in_out].name}'"
-                    end
-      raise CellValidationError,
-            "output column '#{columns.outs[index].name}' makes #{that_column}"
-    end
-
-    def self.ins_column_dictionary(columns:, row:)
-      row.each { |cell| ins_cell_dictionary(columns: columns, cell: cell) }
-    end
-    private_class_method :ins_column_dictionary
-
-    def self.ins_cell_dictionary(columns:, cell:)
-      return unless cell.is_a?(Matchers::Proc)
-      return if cell.symbols.nil?
-
-      add_ins_symbols(columns: columns, cell: cell)
-    end
-    # private_class_method :ins_cell_dictionary
-
-    def self.add_ins_symbols(columns:, cell:)
-      Array(cell.symbols).each do |symbol|
-        Dictionary.add_name(columns: columns, name: symbol)
-      end
-    end
-    private_class_method :add_ins_symbols
-
     def self.outs_functions(table:, index:)
       return if table.outs_rows[index].procs.empty?
 

data/lib/csv_decision/result.rb

@@ -12,12 +12,19 @@ module CSVDecision
     #   both result values and if: columns, which eventually get evaluated and removed.
     attr_reader :attributes
 
+    # @return [Hash{Index=>Dictionary::Entry}] Output columns.
+    attr_reader :outs
+
+    # @return [nil, true] Set to true if the table has output functions.
+    attr_reader :outs_functions
+
     # @return [Boolean] Returns true if this is a multi-row result
     attr_reader :multi_result
 
     # (see Decision.initialize)
     def initialize(table:, input:)
       @outs = table.columns.outs
+      @outs_functions = table.outs_functions
       @if_columns = table.columns.ifs
 
       # Partial result always copies in the input hash for calculating output functions.
@@ -25,14 +32,10 @@ module CSVDecision
       # have the same symbol as an input hash key.
       # However, the rest of this hash is mutated as output column evaluation results
       # are accumulated.
-      @partial_result = input[:hash]&.slice(*table.columns.input_keys) if table.outs_functions
+      @partial_result = input&.slice(*table.columns.input_keys) if @outs_functions
 
       # Attributes hash contains the output decision key value pairs
       @attributes = {}
-
-      # Set to true if the result has more than one row.
-      # Only possible for the first_match: false option.
-      @multi_result = false
     end
 
     # Common case for building a single row result is just copying output column values to the
@@ -156,10 +159,8 @@ module CSVDecision
         proc = row[col]
         next unless proc.is_a?(Matchers::Proc)
 
-        value = proc.function[@partial_result]
-
-        @partial_result[column.name] = value
-        @attributes[column.name] = value
+        @attributes[column.name] = proc.function[@partial_result]
+        @partial_result[column.name] = @attributes[column.name]
       end
     end
 

data/lib/csv_decision/scan_row.rb

@@ -14,6 +14,7 @@ module CSVDecision
 
     # Scan the table cell against all matches.
     #
+    # @param column [Dictionary::Entry] Column dictionary entry.
     # @param matchers [Array<Matchers::Matcher>]
     # @param cell [String]
     # @return [false, Matchers::Proc]
@@ -27,21 +28,6 @@ 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.
@@ -78,7 +64,7 @@ module CSVDecision
     private_class_method :invalid_constant?
 
     # @return [Array<Integer>] Column indices for simple constants.
-    attr_reader :constants
+    attr_accessor :constants
 
     # @return [Array<Integer>] Column indices for Proc objects.
     attr_reader :procs
@@ -98,46 +84,35 @@ module CSVDecision
     #   non-string constant.
     def scan_columns(row:, columns:, matchers:)
       columns.each_pair do |col, column|
-        # An empty input cell matches everything, and so never needs to be scanned
-        next if (cell = row[col]) == '' && column.ins?
+        cell = row[col]
+
+        # An empty input cell matches everything, and so never needs to be scanned,
+        # but it cannot be indexed either.
+        next column.indexed = false if cell == '' && column.ins?
 
-        # If the column is text only then no special matchers need be invoked
+        # If the column is text only then no special matchers need be used.
         next @constants << col if column.eval == false
 
         # Need to scan the cell against all matchers, and possibly overwrite
-        # the cell contents with a Matchers::Proc.
+        # the cell contents with a Matchers::Proc value.
         row[col] = scan_cell(column: column, col: col, matchers: matchers, cell: cell)
       end
 
       row
     end
 
-    # Match cells containing simple constants.
+    # Match cells in the input hash against a decision table row.
     # @param row (see ScanRow.scan_columns)
-    # @param scan_cols [Hash{Integer=>Object}]
+    # @param hash (see Decision#row_scan)
     # @return [Boolean] True for a match, false otherwise.
-    def match_constants?(row:, scan_cols:)
-      constants.each do |col|
-        return false unless row[col] == scan_cols[col]
-      end
+    def match?(row:, scan_cols:, hash:)
+      # Check any table row cell constants first, and maybe fail fast...
+      return false if @constants.any? { |col| row[col] != scan_cols[col] }
 
-      true
-    end
-
-    # Match cells containing a Proc object.
-    # @param row (see ScanRow.scan_columns)
-    # @param input  [Hash{Symbol => Hash{Symbol=>Object}, Hash{Integer=>Object}}]
-    # @return [Boolean] True for a match, false otherwise.
-    def match_procs?(row:, input:)
-      hash = input[:hash]
-      scan_cols = input[:scan_cols]
-
-      procs.each do |col|
-        match = ScanRow.eval_matcher(proc: row[col], value: scan_cols[col], hash: hash)
-        return false unless match
-      end
+      return true if @procs.empty?
 
-      true
+      # These table row cells are Proc objects which need evaluating
+      @procs.all? { |col| row[col].call(value: scan_cols[col], hash: hash) }
     end
 
     private
@@ -146,14 +121,14 @@ module CSVDecision
       # Scan the cell against all the matchers
       proc = ScanRow.scan(column: column, matchers: matchers, cell: cell)
 
-      return set(proc, col) if proc
+      return set(proc, col, column) if proc
 
       # Just a plain constant
       @constants << col
       cell
     end
 
-    def set(proc, col)
+    def set(proc, col, column)
       # Unbox a constant
       if proc.type == :constant
         @constants << col
@@ -161,6 +136,7 @@ module CSVDecision
       end
 
       @procs << col
+      column.indexed = false
       proc
     end
   end

data/lib/csv_decision/table.rb

@@ -13,7 +13,7 @@ module CSVDecision
     # @param input [Hash] Input hash.
     # @return [{Symbol => Object, Array<Object>}] Decision hash.
     def decide(input)
-      Decide.decide(table: self, input: input, symbolize_keys: true)
+      Decision.make(table: self, input: input, symbolize_keys: true)
     end
 
     # Unsafe version of decide - may mutate the input hash and assumes the input
@@ -24,7 +24,7 @@ module CSVDecision
     #   Input hash will be mutated by any functions that have side effects.
     # @return (see #decide)
     def decide!(input)
-      Decide.decide(table: self, input: input, symbolize_keys: false)
+      Decision.make(table: self, input: input, symbolize_keys: false)
     end
 
     # @return [CSVDecision::Columns] Dictionary of all input and output columns.
@@ -33,6 +33,9 @@ module CSVDecision
     # @return [File, Pathname, nil] File path name if decision table was loaded from a CSV file.
     attr_accessor :file
 
+    # @return [CSVDecision::Index] The index built on one or more input columns.
+    attr_accessor :index
+
     # @return [Hash] All options, explicitly set or defaulted, used to parse the table.
     attr_accessor :options
 
@@ -65,7 +68,7 @@ module CSVDecision
     # @api private
     def each(first = 0, last = @rows.count - 1)
       index = first
-      while index <= (last || first)
+      while index <= last
         yield(@rows[index], index)
 
         index += 1
@@ -76,13 +79,13 @@ module CSVDecision
     def initialize
       @columns = nil
       @file = nil
+      @index = nil
       @options = nil
       @outs_functions = nil
       @outs_rows = []
       @if_rows = []
       @rows = []
       @scan_rows = []
-      # @tables = nil
     end
   end
 end

data/lib/csv_decision.rb

@@ -15,11 +15,11 @@ module CSVDecision
 
   autoload :Columns,    'csv_decision/columns'
   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 :Index,      'csv_decision/index'
   autoload :Input,      'csv_decision/input'
   autoload :Load,       'csv_decision/load'
   autoload :Matchers,   'csv_decision/matchers'

data/spec/csv_decision/columns_spec.rb

@@ -7,12 +7,12 @@ SPEC_DATA_INVALID ||= File.join(CSVDecision.root, 'spec', 'data', 'invalid')
 
 describe CSVDecision::Columns do
   describe '#new' do
-    it 'creates a columns object' do
-      table = CSVDecision::Table.new
-      columns = CSVDecision::Columns.new(table)
-
-      expect(columns).to be_a(CSVDecision::Columns)
-    end
+    # it 'creates a columns object' do
+    #   table = CSVDecision::Table.new
+    #   columns = CSVDecision::Columns.new(table)
+    #
+    #   expect(columns).to be_a(CSVDecision::Columns)
+    # end
   end
 
   it 'rejects a duplicate output column name' do

data/spec/csv_decision/data_spec.rb

@@ -22,11 +22,6 @@ describe CSVDecision::Data do
   end
 
   it 'parses a CSV file' do
-    file = File.new(File.join(CSVDecision.root, 'spec/data/valid', 'empty.csv'))
-    result = CSVDecision::Data.to_array(data: file)
-    expect(result).to be_a Array
-    expect(result.empty?).to eq true
-
     file = Pathname(File.join(CSVDecision.root, 'spec/data/valid', 'valid.csv'))
     result = CSVDecision::Data.to_array(data: file)
     expected = [

data/spec/csv_decision/index_spec.rb

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

data/spec/csv_decision/input_spec.rb

@@ -22,7 +22,8 @@ describe CSVDecision::Input do
     input = { 'input' => 'input0', input1: 'input1' }
     expected = {
       hash: { input: 'input0', input1: 'input1' },
-      scan_cols: { 0 => 'input0', 2 => 'input1'}
+      scan_cols: { 0 => 'input0', 2 => 'input1'},
+      key: 'input0'
     }
 
     result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: true)
@@ -41,7 +42,11 @@ describe CSVDecision::Input do
 
     table = CSVDecision.parse(data)
     input = { input: 'input0', input1: 'input1' }
-    expected = { hash: input, scan_cols: { 0 => 'input0', 2 => 'input1'} }
+    expected = {
+      hash: input,
+      scan_cols: { 0 => 'input0', 2 => 'input1'},
+      key: 'input0'
+    }
 
     result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: false)
 

data/spec/csv_decision/options_spec.rb

@@ -3,6 +3,7 @@
 require_relative '../../lib/csv_decision'
 
 SPEC_DATA_VALID ||= File.join(CSVDecision.root, 'spec', 'data', 'valid')
+SPEC_DATA_INVALID ||= File.join(CSVDecision.root, 'spec', 'data', 'invalid')
 
 describe CSVDecision::Options do
   it 'sets the default options' do
@@ -48,7 +49,8 @@ describe CSVDecision::Options do
     DATA
 
     expect { CSVDecision.parse(data, bad_option: false) }
-      .to raise_error(ArgumentError, "invalid option(s) supplied: [:bad_option]")
+      .to raise_error(CSVDecision::CellValidationError,
+                      "invalid option(s) supplied: [:bad_option]")
   end
 
   it 'parses options from a CSV file' do
@@ -76,4 +78,17 @@ describe CSVDecision::Options do
     }
     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)
+
+    expected = {
+      first_match: false,
+      regexp_implicit: true,
+      text_only: false,
+      matchers: CSVDecision::Options::DEFAULT_MATCHERS
+    }
+    expect(result.options).to eql expected
+  end
 end

data/spec/csv_decision/parse_spec.rb

@@ -3,11 +3,10 @@
 require_relative '../../lib/csv_decision'
 
 describe CSVDecision::Parse do
-  it 'loads an empty decision table' do
-    table =  CSVDecision.parse('')
-    expect(table).to be_a CSVDecision::Table
-    expect(table.frozen?).to eq true
-    expect(table.rows.empty?).to eq true
+  it 'rejects an empty decision table' do
+    expect { CSVDecision.parse('') }
+      .to raise_error(CSVDecision::TableValidationError,
+                      'table has no header row')
   end
 
   it 'parses a decision table from a CSV file' do