csv_decision 0.0.1 → 0.0.2

data/lib/csv_decision/parse.rb

@@ -1,38 +1,92 @@
 # frozen_string_literal: true
 
-require_relative 'table'
-require_relative 'data'
-require_relative 'header'
-require_relative 'options'
-
 # CSV Decision: CSV based Ruby decision tables.
 # Created December 2017 by Brett Vickers
 # See LICENSE and README.md for details.
 module CSVDecision
-  # Parse the input data which may either be a path name, CSV string or array of arrays
-  def self.parse(input, options: {})
-    # Parse and normalize user supplied options
-    options = Options.new(options)
+  class Error < StandardError; end
+  class CellValidationError < Error; end
+  class FileError < Error; end
 
-    # Parse input data, which may include overriding options specified in a CSV file
-    table = Parse.data(table: Table.new, input: input, options: options)
+  # Builds a decision table from the input data - which may either be a file, CSV string
+  # or array of arrays.
+  #
+  # @param data [Pathname, File, Array<Array<String>>, String] - input data given as
+  #   a file, array of arrays or CSV string.
+  # @param options [Hash] - options hash supplied by the user
+  #   * first_match: stop after finding the first match
+  #   * regexp_implicit: Set to make regular expressions implicit rather than requiring
+  #                      the comparator =~
+  #   * text_only:       Set to make all cells be treated as simple strings by turning
+  #                      off all special matchers.
+  #   * matchers         May be used to control the inclusion and ordering of special
+  #                      matchers.
+  # @return [CSVDecision::Table] - resulting decision table
+  def self.parse(data, options = {})
+    Parse.table(input: data, options: Options.normalize(options))
+  end
 
-    options = options.from_csv(table)
+  # Parse the CSV file and create a new decision table object.
+  #
+  # (see #parse)
+  module Parse
+    def self.table(input:, options:)
+      table = CSVDecision::Table.new
 
-    # Set to the options hash
-    table.options = options.attributes.freeze
+      # In most cases the decision table will be loaded from a CSV file.
+      table.file = input if Data.input_file?(input)
 
-    table.freeze
-  end
+      parse_table(table: table, input: input, options: options)
+    rescue CSVDecision::Error => exp
+      raise_error(file: table.file, exception: exp)
+    end
 
-  # Parse the CSV file and create a new decision table object
-  module Parse
-    def self.data(table:, input:, options:)
-      table.file = input if input.is_a?(Pathname)
-      table.rows = Data.to_array(data: input, options: options.attributes)
+    def self.raise_error(file:, exception:)
+      raise exception unless file
+      message = "error processing CSV file #{table.file}\n#{exception.inspect}"
+      raise CSVDecision::FileError, message
+    end
+    private_class_method :raise_error
+
+    def self.parse_table(table:, input:, options:)
+      # 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
+
+      # Parse the header row
+      table.columns = CSVDecision::Columns.new(table)
+
+      parse_data(table: table, matchers: matchers(table.options).freeze)
+
+      table.freeze
+    end
+    private_class_method :parse_table
+
+    def self.parse_data(table:, matchers:)
+      table.rows.each_with_index do |row, index|
+        # Build an array of column indexes requiring simple matches.
+        # and a second array of columns requiring special matchers
+        table.scan_rows[index] = Matchers.parse(columns: table.columns.ins,
+                                                matchers: matchers,
+                                                row: row)
+
+        # parse_outputs(row, index)
+
+        row.freeze
+        table.scan_rows[index].freeze
+      end
+
+      table.columns.freeze
+    end
+
+    private_class_method :parse_data
 
-      table.header = Header.parse(table: table, options: options)
-      table
+    def self.matchers(options)
+      options[:matchers].collect { |klass| klass.new(options) }
     end
+    private_class_method :matchers
   end
 end

data/lib/csv_decision/scan_row.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'values'
+
+# CSV Decision: CSV based Ruby decision tables.
+# Created December 2017 by Brett Vickers
+# See LICENSE and README.md for details.
+module CSVDecision
+  # Data row object indicating which columns are constants versus procs.
+  class ScanRow
+    attr_accessor :constants
+    attr_accessor :procs
+
+    def initialize
+      @constants = []
+      @procs = []
+    end
+
+    def scan_columns(columns:, matchers:, row:)
+      columns.each_pair do |col, column|
+        # Empty cell matches everything, and so never needs to be scanned
+        next if (cell = row[col]) == ''
+
+        # If the column is text only then no special matchers need be invoked
+        next constants << col if column.text_only
+
+        # Need to scan the cell against all matchers, and possibly overwrite
+        # the cell contents with a proc.
+        row[col] = scan_cell(col: col, matchers: matchers, cell: cell)
+      end
+    end
+
+    def match_constants?(row:, scan_cols:)
+      constants.each do |col|
+        return false unless row[col] == scan_cols[col]
+      end
+
+      true
+    end
+
+    def match_procs?(row:, input:)
+      hash = input[:hash]
+      scan_cols = input[:scan_cols]
+
+      procs.each do |col|
+        match = Decide.eval_matcher(proc: row[col], value: scan_cols[col], hash: hash)
+        return false unless match
+      end
+
+      true
+    end
+
+    private
+
+    def scan_cell(col:, matchers:, cell:)
+      # Scan the cell against all the matchers
+      proc = Matchers.scan(matchers: matchers, cell: cell)
+
+      if proc
+        procs << col
+        return proc
+      end
+
+      constants << col
+      cell
+    end
+  end
+end

data/lib/csv_decision/table.rb

@@ -1,26 +1,54 @@
-# frozen_string_literal: true\
+# frozen_string_literal: true
 
 # CSV Decision: CSV based Ruby decision tables.
 # Created December 2017 by Brett Vickers
 # See LICENSE and README.md for details.
 module CSVDecision
-  # Decision Table that accepts input hashes and makes deciosn
+  # Decision Table that accepts input hashes and makes decision
   class Table
+    attr_accessor :columns
     attr_accessor :file
-    attr_accessor :header
     attr_accessor :options
+    attr_accessor :outs_functions
     attr_accessor :rows
+    attr_accessor :scan_rows
     attr_reader :tables
 
-    def decide(_input, _symbolize_keys: true)
-      {}
+    # Main public method for making decisions.
+    # @param input [Hash] - input hash (keys may or may not be symbolized)
+    # @return [Hash]
+    def decide(input)
+      Decide.decide(table: self, input: input, symbolize_keys: true).result
+    end
+
+    # Unsafe version of decide - will mutate the hash if set: option (planned feature)
+    # is used.
+    # @param input [Hash] - input hash (keys must be symbolized)
+    # @return [Hash]
+    def decide!(input)
+      Decide.decide(table: self, input: input, symbolize_keys: false).result
+    end
+
+    # Iterate through all data rows of the decision table.
+    # @param first [Integer] - start row
+    # @param last [Integer] - last row
+    def each(first = 0, last = @rows.count - 1)
+      index = first
+      while index <= (last || first)
+        yield(@rows[index], index)
+
+        index += 1
+      end
     end
 
     def initialize
+      @columns = nil
       @file = nil
-      @header = nil
+      @matchers = []
       @options = nil
+      @outs_functions = nil
       @rows = []
+      @scan_rows = []
       @tables = nil
     end
   end

data/spec/csv_decision/columns_spec.rb

@@ -0,0 +1,86 @@
+# 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::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
+  end
+
+  it 'parses a decision table columns from a CSV file' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text : input, OUT/text:output
+      input0,    output0,     input1,          output1
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns).to be_a(CSVDecision::Columns)
+    expect(table.columns.ins[0].to_h).to eq(name: :input, text_only: nil)
+    expect(table.columns.ins[2].to_h).to eq(name: :input, text_only: true)
+    expect(table.columns.outs[1].to_h).to eq(name: :output, text_only: nil)
+    expect(table.columns.outs[3].to_h).to eq(name: :output, text_only: true)
+  end
+
+  it 'parses a decision table columns from a CSV file' do
+    file = Pathname(File.join(SPEC_DATA_VALID, 'valid.csv'))
+    result = CSVDecision.parse(file)
+
+    expect(result.columns).to be_a(CSVDecision::Columns)
+    expect(result.columns.ins).to eq(0 => CSVDecision::Columns::Entry.new(:input, nil))
+    expect(result.columns.outs).to eq(1 => CSVDecision::Columns::Entry.new(:output, nil))
+  end
+
+  it 'rejects an invalid header column' do
+    data = [
+      ['IN :input', 'BAD :output'],
+      ['input', '']
+    ]
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "header column 'BAD :output' is not valid as " \
+                      'the column name is not well formed')
+  end
+
+  it 'rejects a missing column name' do
+    data = [
+      ['IN :input', 'IN: '],
+      ['input', '']
+    ]
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "header column 'IN:' is not valid as the column name is missing")
+  end
+
+  it 'rejects an invalid column name' do
+    data = [
+      ['IN :input', 'IN: a-b'],
+      ['input', '']
+    ]
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "header column 'IN: a-b' is not valid as " \
+                      "the column name 'a-b' contains invalid characters")
+  end
+
+  context 'rejects invalid CSV decision table columns' do
+    Dir[File.join(SPEC_DATA_INVALID, 'invalid_columns*.csv')].each do |file_name|
+      pathname = Pathname(file_name)
+
+      it "rejects CSV file #{pathname.basename}" do
+        expect { CSVDecision.parse(pathname) }
+          .to raise_error(CSVDecision::FileError, /\Aerror processing CSV file/)
+      end
+    end
+  end
+end

data/spec/csv_decision/data_spec.rb

@@ -22,15 +22,28 @@ describe CSVDecision::Data do
   end
 
   it 'parses a CSV file' do
-    file = Pathname(File.join(CSVDecision.root, 'spec/data/valid', 'empty.csv'))
+    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)
-    expect(result).to be_a Array
-    expect(result).to eq [['IN :input', 'OUT :output'], ['input', '']]
+    expected = [
+      ['', 'IN :input', '', 'OUT :output', ''],
+      ['', 'input', '', '', '']
+    ]
+    expect(result).to eq(expected)
+
+    file = Pathname(File.join(CSVDecision.root, 'spec/data/valid', 'options_in_file2.csv'))
+    result = CSVDecision::Data.to_array(data: file)
+    expected = [
+      ['accumulate'],
+      ['regexp_implicit'],
+      ['IN :input', 'OUT :output'],
+      ['input', '']
+    ]
+    expect(result).to eq(expected)
   end
 
   it 'raises an error for invalid input' do

data/spec/csv_decision/decision_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Decision do
+  it 'decision for table with no functions and first_match: true' do
+    data = <<~DATA
+      IN :input, OUT :output, IN: input1
+      input0,    output0,     input1
+      input0,    output1,
+    DATA
+
+    table = CSVDecision.parse(data)
+
+    input = { input: 'input0', input1: 'input1' }
+
+    decision = CSVDecision::Decision.new(table: table, input: input)
+
+    expect(decision).to be_a(CSVDecision::Decision)
+    expect(decision.empty?).to eq true
+    expect(decision.exist?).to eq false
+
+    row = table.rows[0]
+    decision.add(row)
+
+    expect(decision.empty?).to eq false
+    expect(decision.exist?).to eq true
+    expect(decision.result).to eq(output: 'output0')
+  end
+end

data/spec/csv_decision/input_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/csv_decision'
+
+describe CSVDecision::Input do
+  it 'rejects a non-hash or empty hash value' do
+    expect { CSVDecision::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 ) }
+      .to raise_error(ArgumentError, 'input must be a non-empty hash')
+  end
+
+  it 'processes input hash with symbolize_keys: true' do
+    data = <<~DATA
+      IN :input, OUT :output, IN: input1
+      input0,    output0,     input1
+      input0,    output1,
+    DATA
+
+    table = CSVDecision.parse(data)
+
+    input = { 'input' => 'input0', input1: 'input1' }
+    expected = {
+      hash: { input: 'input0', input1: 'input1' },
+      scan_cols: { 0 => 'input0', 2 => 'input1'}
+    }
+
+    result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: true)
+
+    expect(result).to eql expected
+    expect(result[:hash]).not_to equal expected[:hash]
+    expect(result[:hash].frozen?).to eq true
+    expect(result[:defaults].frozen?).to eq true
+  end
+
+  it 'processes input hash with symbolize_keys: false' do
+    data = <<~DATA
+      IN :input, OUT :output, IN: input1
+      input0,    output0,     input1
+      input0,    output1,
+    DATA
+
+    table = CSVDecision.parse(data)
+    input = { input: 'input0', input1: 'input1' }
+    expected = { hash: input, scan_cols: { 0 => 'input0', 2 => 'input1'} }
+
+    result = CSVDecision::Input.parse(table: table, input: input, symbolize_keys: false)
+
+    expect(result).to eql expected
+    expect(result[:hash]).to equal expected[:hash]
+    expect(result[:hash].frozen?).to eq false
+    expect(result[:defaults].frozen?).to eq true
+  end
+end