RubyGems - csv_decision2 - Versions diffs - 0.5.1 - Mend

csv_decision2 0.5.1

Files changed (134) hide show

checksums.yaml +7 -0
data/.codeclimate.yml +3 -0
data/.coveralls.yml +2 -0
data/.gitignore +14 -0
data/.rspec +2 -0
data/.rubocop.yml +30 -0
data/.travis.yml +6 -0
data/CHANGELOG.md +85 -0
data/Dockerfile +6 -0
data/Gemfile +7 -0
data/LICENSE +21 -0
data/README.md +356 -0
data/benchmarks/rufus_decision.rb +158 -0
data/csv_decision2.gemspec +38 -0
data/doc/CSVDecision/CellValidationError.html +143 -0
data/doc/CSVDecision/Columns/Default.html +589 -0
data/doc/CSVDecision/Columns/Dictionary.html +801 -0
data/doc/CSVDecision/Columns/Entry.html +508 -0
data/doc/CSVDecision/Columns.html +1259 -0
data/doc/CSVDecision/Constant.html +254 -0
data/doc/CSVDecision/Data.html +479 -0
data/doc/CSVDecision/Decide.html +302 -0
data/doc/CSVDecision/Decision.html +1011 -0
data/doc/CSVDecision/Defaults.html +291 -0
data/doc/CSVDecision/Dictionary/Entry.html +1147 -0
data/doc/CSVDecision/Dictionary.html +426 -0
data/doc/CSVDecision/Error.html +139 -0
data/doc/CSVDecision/FileError.html +143 -0
data/doc/CSVDecision/Function.html +240 -0
data/doc/CSVDecision/Guard.html +245 -0
data/doc/CSVDecision/Header.html +647 -0
data/doc/CSVDecision/Index.html +741 -0
data/doc/CSVDecision/Input.html +404 -0
data/doc/CSVDecision/Load.html +296 -0
data/doc/CSVDecision/Matchers/Constant.html +484 -0
data/doc/CSVDecision/Matchers/Function.html +511 -0
data/doc/CSVDecision/Matchers/Guard.html +503 -0
data/doc/CSVDecision/Matchers/Matcher.html +507 -0
data/doc/CSVDecision/Matchers/Numeric.html +415 -0
data/doc/CSVDecision/Matchers/Pattern.html +491 -0
data/doc/CSVDecision/Matchers/Proc.html +704 -0
data/doc/CSVDecision/Matchers/Range.html +379 -0
data/doc/CSVDecision/Matchers/Symbol.html +426 -0
data/doc/CSVDecision/Matchers.html +1567 -0
data/doc/CSVDecision/Numeric.html +259 -0
data/doc/CSVDecision/Options.html +443 -0
data/doc/CSVDecision/Parse.html +282 -0
data/doc/CSVDecision/Paths.html +742 -0
data/doc/CSVDecision/Result.html +1200 -0
data/doc/CSVDecision/Scan/InputHashes.html +369 -0
data/doc/CSVDecision/Scan.html +313 -0
data/doc/CSVDecision/ScanRow.html +866 -0
data/doc/CSVDecision/Symbol.html +256 -0
data/doc/CSVDecision/Table.html +1470 -0
data/doc/CSVDecision/TableValidationError.html +143 -0
data/doc/CSVDecision/Validate.html +422 -0
data/doc/CSVDecision.html +621 -0
data/doc/_index.html +471 -0
data/doc/class_list.html +51 -0
data/doc/css/common.css +1 -0
data/doc/css/full_list.css +58 -0
data/doc/css/style.css +499 -0
data/doc/file.README.html +421 -0
data/doc/file_list.html +56 -0
data/doc/frames.html +17 -0
data/doc/index.html +421 -0
data/doc/js/app.js +248 -0
data/doc/js/full_list.js +216 -0
data/doc/js/jquery.js +4 -0
data/doc/method_list.html +1163 -0
data/doc/top-level-namespace.html +110 -0
data/docker-compose.yml +13 -0
data/lib/csv_decision/columns.rb +192 -0
data/lib/csv_decision/data.rb +92 -0
data/lib/csv_decision/decision.rb +196 -0
data/lib/csv_decision/defaults.rb +47 -0
data/lib/csv_decision/dictionary.rb +180 -0
data/lib/csv_decision/header.rb +83 -0
data/lib/csv_decision/index.rb +107 -0
data/lib/csv_decision/input.rb +121 -0
data/lib/csv_decision/load.rb +36 -0
data/lib/csv_decision/matchers/constant.rb +74 -0
data/lib/csv_decision/matchers/function.rb +56 -0
data/lib/csv_decision/matchers/guard.rb +142 -0
data/lib/csv_decision/matchers/numeric.rb +44 -0
data/lib/csv_decision/matchers/pattern.rb +94 -0
data/lib/csv_decision/matchers/range.rb +95 -0
data/lib/csv_decision/matchers/symbol.rb +149 -0
data/lib/csv_decision/matchers.rb +220 -0
data/lib/csv_decision/options.rb +124 -0
data/lib/csv_decision/parse.rb +165 -0
data/lib/csv_decision/paths.rb +78 -0
data/lib/csv_decision/result.rb +204 -0
data/lib/csv_decision/scan.rb +117 -0
data/lib/csv_decision/scan_row.rb +142 -0
data/lib/csv_decision/table.rb +101 -0
data/lib/csv_decision/validate.rb +85 -0
data/lib/csv_decision.rb +45 -0
data/spec/csv_decision/columns_spec.rb +251 -0
data/spec/csv_decision/constant_spec.rb +36 -0
data/spec/csv_decision/data_spec.rb +50 -0
data/spec/csv_decision/decision_spec.rb +19 -0
data/spec/csv_decision/examples_spec.rb +242 -0
data/spec/csv_decision/index_spec.rb +58 -0
data/spec/csv_decision/input_spec.rb +55 -0
data/spec/csv_decision/load_spec.rb +28 -0
data/spec/csv_decision/matchers/function_spec.rb +82 -0
data/spec/csv_decision/matchers/guard_spec.rb +170 -0
data/spec/csv_decision/matchers/numeric_spec.rb +47 -0
data/spec/csv_decision/matchers/pattern_spec.rb +183 -0
data/spec/csv_decision/matchers/range_spec.rb +70 -0
data/spec/csv_decision/matchers/symbol_spec.rb +67 -0
data/spec/csv_decision/options_spec.rb +94 -0
data/spec/csv_decision/parse_spec.rb +44 -0
data/spec/csv_decision/table_spec.rb +683 -0
data/spec/csv_decision_spec.rb +7 -0
data/spec/data/invalid/empty.csv +0 -0
data/spec/data/invalid/invalid_header1.csv +4 -0
data/spec/data/invalid/invalid_header2.csv +4 -0
data/spec/data/invalid/invalid_header3.csv +4 -0
data/spec/data/invalid/invalid_header4.csv +4 -0
data/spec/data/valid/benchmark_regexp.csv +10 -0
data/spec/data/valid/index_example.csv +13 -0
data/spec/data/valid/multi_column_index.csv +10 -0
data/spec/data/valid/multi_column_index2.csv +12 -0
data/spec/data/valid/options_in_file1.csv +5 -0
data/spec/data/valid/options_in_file2.csv +5 -0
data/spec/data/valid/options_in_file3.csv +13 -0
data/spec/data/valid/regular_expressions.csv +11 -0
data/spec/data/valid/simple_constants.csv +5 -0
data/spec/data/valid/simple_example.csv +10 -0
data/spec/data/valid/valid.csv +4 -0
data/spec/spec_helper.rb +106 -0
metadata +352 -0

data/doc/top-level-namespace.html ADDED Viewed

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>
+  Top Level Namespace
+    &mdash; Documentation by YARD 0.9.12
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" charset="utf-8" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" charset="utf-8" />
+<script type="text/javascript" charset="utf-8">
+  pathId = "";
+  relpath = '';
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div class="nav_wrap">
+      <iframe id="nav" src="class_list.html?1"></iframe>
+      <div id="resizer"></div>
+    </div>
+    <div id="main" tabindex="-1">
+      <div id="header">
+        <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+</div>
+        <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+        <svg width="24" height="24">
+          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
+        </svg>
+    </a>
+</div>
+        <div class="clear"></div>
+      </div>
+      <div id="content"><h1>Top Level Namespace
+</h1>
+<div class="box_info">
+</div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="CSVDecision.html" title="CSVDecision (module)">CSVDecision</a></span>
+</p>
+</div>
+      <div id="footer">
+  Generated on Sun Feb 11 10:26:07 2018 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.9.12 (ruby-2.4.0).
+</div>
+    </div>
+  </body>
+</html>

data/docker-compose.yml ADDED Viewed

@@ -0,0 +1,13 @@
+version: "3.8"
+services:
+  app:
+    container_name: csv_decision_app
+    build: .
+    command: bash
+    volumes:
+      - .:/app
+      - bundle:/usr/local/bundle
+    stdin_open: true
+    tty: true
+volumes:
+  bundle:

data/lib/csv_decision/columns.rb ADDED Viewed

@@ -0,0 +1,192 @@
+# 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
+  # Dictionary of all this table's columns - inputs, outputs etc.
+  # @api private
+  class Columns
+    # @param columns [CSVDecision::Columns] Table's columns dictionary.
+    # @param row [Array] Data row.
+    # @return [void]
+    def self.outs_dictionary(columns:, row:)
+      row.each_with_index do |cell, index|
+        outs_check_cell(columns: columns, cell: cell, index: index)
+      end
+    end
+    # @param columns [CSVDecision::Columns] Table's columns dictionary.
+    # @param row [Array] Data row.
+    # @return [void]
+    def self.ins_dictionary(columns:, row:)
+      row.each { |cell| ins_cell_dictionary(columns: columns, cell: cell) }
+    end
+    # @param columns [CSVDecision::Columns] Table's columns dictionary.
+    # @param cell [Object] Data row cell.
+    # @return [void]
+    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
+    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
+    private_class_method :invalid_out_ref?
+    def self.add_ins_symbols(columns:, cell:)
+      Array(cell.symbols).each do |symbol|
+        CSVDecision::Dictionary.add_name(columns: columns, name: symbol)
+      end
+    end
+    private_class_method :add_ins_symbols
+    # Dictionary of all table data columns.
+    # The key of each hash is the header cell's array column index.
+    # Note that input and output columns may be interspersed, and multiple input columns
+    # may refer to the same input hash key symbol.
+    # However, output columns must have unique symbols, which cannot overlap with input
+    # column symbols.
+    class Dictionary
+      # @return [Hash{Integer=>Entry}] All column names.
+      attr_accessor :columns
+      # @return [Hash{Integer=>Entry}] All input column dictionary entries.
+      attr_accessor :ins
+      # @return [Hash{Integer=>Entry}] All defaulted input column dictionary
+      #  entries. This is actually just a subset of :ins.
+      attr_accessor :defaults
+      # @return [Hash{Integer=>Entry}] All output column dictionary entries.
+      attr_accessor :outs
+      # @return [Hash{Integer=>Entry}] All if: column dictionary entries.
+      #   This is actually just a subset of :outs.
+      attr_accessor :ifs
+      # @return [Hash{Integer=>Symbol}] All path columns.
+      #   This is actually just a subset of :outs.
+      attr_accessor :paths
+      def initialize
+        @columns = {}
+        @defaults = {}
+        @ifs = {}
+        @ins = {}
+        @outs = {}
+        @paths = {}
+      end
+    end
+    # Input columns with defaults specified
+    def defaults
+      @dictionary&.defaults
+    end
+    # Set defaults for columns with defaults specified
+    def defaults=(value)
+      @dictionary.defaults = value
+    end
+    # @return [Hash{Symbol=>[false, Integer]}] Dictionary of all
+    #   input and output column names.
+    def dictionary
+      @dictionary.columns
+    end
+    # Input columns hash keyed by column index.
+    # @return [Hash{Index=>Entry}]
+    def ins
+      @dictionary.ins
+    end
+    # Output columns hash keyed by column index.
+    # @return [Hash{Index=>Entry}]
+    def outs
+      @dictionary&.outs
+    end
+    # if: columns hash keyed by column index.
+    # @return [Hash{Index=>Entry}]
+    def ifs
+      @dictionary.ifs
+    end
+    # path: columns hash keyed by column index.
+    # @return [Hash{Index=>Entry}]
+    def paths
+      @dictionary.paths
+    end
+    # @return [Array<Symbol>] All input column symbols.
+    def input_keys
+      @dictionary.columns.select { |_k, v| v == :in }.keys
+    end
+    # @param table [Table] Decision table being constructed.
+    def initialize(table)
+      # If a column does not have a valid header cell, then it's empty of data.
+      # Return the stripped header row, and remove it from the data array.
+      row = Header.strip_empty_columns(rows: table.rows)
+      # No header row found?
+      raise TableValidationError, 'table has no header row' unless row
+      # Build a dictionary of all valid data columns from the header row.
+      @dictionary = CSVDecision::Dictionary.build(header: row, dictionary: Dictionary.new)
+      freeze
+    end
+  end
+end

data/lib/csv_decision/data.rb ADDED Viewed

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+require 'csv'
+# 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
+  # All cells starting with this character are comments, and treated as a blank cell.
+  COMMENT_CHARACTER = '#'
+  private_constant :COMMENT_CHARACTER
+  # Methods to load data from a file, CSV string or an array of arrays.
+  # @api private
+  module Data
+    # Options passed to CSV.parse and CSV.read.
+    CSV_OPTIONS = { encoding: 'UTF-8', skip_blanks: true }.freeze
+    private_constant :CSV_OPTIONS
+    # Parse the input data which may either be a file path name, CSV string or
+    # array of arrays. Strips out empty columns/rows and comment cells.
+    #
+    # @param data (see Parse.parse)
+    # @return [Array<Array<String>>] Data array stripped of empty rows.
+    def self.to_array(data:)
+      strip_rows(data: data_array(data))
+    end
+    # If the input is a file name return true, otherwise false.
+    #
+    # @param data (see Parse.parse)
+    # @return [Boolean] Set to true if the input data is passed as a File or Pathname.
+    def self.input_file?(data)
+      data.is_a?(Pathname) || data.is_a?(File)
+    end
+    # Strip the empty columns from the input data rows.
+    #
+    # @param data (see Parse.parse)
+    # @param empty_columns [Array<Index>]
+    # @return [Array<Array<String>>] Data array stripped of empty columns.
+    def self.strip_columns(data:, empty_columns:)
+      # Adjust column indices as we delete columns the rest shift to the left by 1
+      empty_columns.map!.with_index { |col, index| col - index }
+      # Delete all empty columns from the array of arrays
+      empty_columns.each { |col| data.each_index { |row| data[row].delete_at(col) } }
+    end
+    # Parse the input data which may either be a file path name, CSV string or
+    # array of arrays
+    def self.data_array(input)
+      return CSV.read(input, **CSV_OPTIONS) if input_file?(input)
+      return input.deep_dup if input.is_a?(Array) && input[0].is_a?(Array)
+      return CSV.parse(input, **CSV_OPTIONS) if input.is_a?(String)
+      raise ArgumentError,
+            "#{input.class} input invalid; " \
+            'input must be a file path name, CSV string or array of arrays'
+    end
+    private_class_method :data_array
+    def self.strip_rows(data:)
+      rows = []
+      data.each do |row|
+        row = strip_cells(row: row)
+        rows << row if row.find { |cell| cell != '' }
+      end
+      rows
+    end
+    private_class_method :strip_rows
+    # Strip cells of leading/trailing spaces; treat comments as an empty cell.
+    # Non string values treated as empty cells.
+    # Non-ascii strings treated as empty cells by default.
+    def self.strip_cells(row:)
+      row.map! { |cell| strip_cell(cell) }
+    end
+    private_class_method :strip_cells
+    def self.strip_cell(cell)
+      return '' unless cell.is_a?(String)
+      cell = cell.force_encoding('UTF-8')
+      return '' unless cell.ascii_only?
+      return '' if cell.lstrip[0] == COMMENT_CHARACTER
+      cell.strip
+    end
+    private_class_method :strip_cell
+  end
+end

data/lib/csv_decision/decision.rb ADDED Viewed

@@ -0,0 +1,196 @@
+# 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
+  # Accumulate the matching row(s) and calculate the final result.
+  # @api private
+  class Decision
+    # Main method for making decisions without a path.
+    #
+    # @param table [CSVDecision::Table] Decision table.
+    # @param input [Hash] Input hash (keys may or may not be symbolized)
+    # @param symbolize_keys [Boolean] Set to false if keys are symbolized and it's
+    #   OK to mutate the input hash. Otherwise a copy of the input hash is symbolized.
+    # @return [Hash{Symbol=>Object}] Decision result.
+    def self.make(table:, input:, symbolize_keys:)
+      # Parse and transform the hash supplied as input
+      data = Input.parse(table: table, input: input, symbolize_keys: symbolize_keys)
+      # The decision object collects the results of the search and
+      # calculates the final result.
+      Decision.new(table: table).scan(data)
+    end
+    # @return [Boolean] True if a first match decision table.
+    attr_reader :first_match
+    # @return [CSVDecision::Table] Decision table object.
+    attr_reader :table
+    # @param table [CSVDecision::Table] Decision table being processed.
+    def initialize(table:)
+      # The result object is a hash of values, and each value will be an array if this is
+      # a multi-row result for the +first_match: false+ option.
+      @result = Result.new(table: table)
+      @first_match = table.options[:first_match]
+      @table = table
+    end
+    # Initialize the input data used to make the decision.
+    #
+    # @param data [Hash{Symbol=>Object}] Input hash data structure.
+    # @return [void]
+    def input(data)
+      @result.input(data[:hash])
+      # All rows picked by the matching process. An array if +first_match: false+,
+      # otherwise a single row.
+      @rows_picked = []
+      @input = data
+    end
+    # Scan the decision table and produce an output decision.
+    #
+    # @param data [Hash{Symbol=>Object}] Input hash data structure.
+    # @return (see .make)
+    def scan(data)
+      input(data)
+      # Use the table's index if present
+      @table.index ? index_scan : table_scan
+    end
+    #  Scan the index for a first match result.
+    #
+    # @param scan_cols [Hash{Integer=>Object}]
+    # @param hash [Hash{Symbol=>Object}]
+    # @param index_rows [Array<Integer>]
+    # @return [Hash{Symbol=>Object}]
+    def index_scan_first_match(scan_cols:, hash:, index_rows:)
+      index_rows.each do |start_row, end_row|
+        @table.each(start_row, end_row || start_row) do |row, index|
+          next unless @table.scan_rows[index].match?(row: row, hash: hash, scan_cols: scan_cols)
+          return @result.attributes if first_match_found(row)
+        end
+      end
+      {}
+    end
+    #  Scan the index for an accumulated result.
+    #
+    # @param scan_cols [Hash{Integer=>Object}]
+    # @param hash [Hash{Symbol=>Object}]
+    # @param index_rows [Array<Integer>]
+    # @return [Hash{Symbol=>Object}]
+    def index_scan_accumulate(scan_cols:, hash:, index_rows:)
+      index_rows.each do |start_row, end_row|
+        @table.each(start_row, end_row || start_row) do |row, index|
+          next unless @table.scan_rows[index].match?(row: row, hash: hash, scan_cols: scan_cols)
+          # Accumulate output rows.
+          @rows_picked << row
+          @result.accumulate_outs(row)
+        end
+      end
+      @rows_picked.empty? ? {} : accumulated_result
+    end
+    private
+    # Use an index to scan the decision table up against the input hash.
+    def index_scan_rows(rows:)
+      if @first_match
+        index_scan_first_match(scan_cols: @input[:scan_cols], hash: @input[:hash], index_rows: rows)
+      else
+        index_scan_accumulate(scan_cols: @input[:scan_cols], hash: @input[:hash], index_rows: rows)
+      end
+    end
+    def scan_first_match(hash:, scan_cols:)
+      @table.each do |row, index|
+        next unless @table.scan_rows[index].match?(row: row, hash: hash, scan_cols: scan_cols)
+        return @result.attributes if first_match_found(row)
+      end
+      {}
+    end
+    def scan_accumulate(hash:, scan_cols:)
+      @table.each do |row, index|
+        next unless @table.scan_rows[index].match?(row: row, hash: hash, scan_cols: scan_cols)
+        # Accumulate output rows
+        @rows_picked << row
+        @result.accumulate_outs(row)
+      end
+      @rows_picked.empty? ? {} : accumulated_result
+    end
+    # Scan the decision table up against the input hash.
+    def table_scan
+      if @first_match
+        scan_first_match(hash: @input[:hash], scan_cols:  @input[:scan_cols])
+      else
+        scan_accumulate(hash: @input[:hash], scan_cols:  @input[:scan_cols])
+      end
+    end
+    # Use an index to scan the decision table up against the input hash.
+    def index_scan
+      # If the index lookup fails, there's no match.
+      return {} unless (index_rows = Array(@table.index.hash[@input[:key]]))
+      index_scan_rows(rows: index_rows)
+    end
+    def accumulated_result
+      return @result.final_result unless @result.outs_functions
+      return @result.eval_outs(@rows_picked.first) unless @result.multi_result
+      multi_row_result
+    end
+    def multi_row_result
+      # Scan each output column that contains functions
+      @result.outs.each_pair { |col, column| eval_procs(col: col, column: column) if column.eval }
+      @result.final_result
+    end
+    def eval_procs(col:, column:)
+      @rows_picked.each_with_index do |row, index|
+        cell = row[col]
+        next unless cell.is_a?(Matchers::Proc)
+        # Evaluate the proc and update the result
+        @result.eval_cell_proc(proc: cell, column_name: column.name, index: index)
+      end
+    end
+    def first_match_found(row)
+      # This decision row may contain procs, which if present will need to be evaluated.
+      # If this row contains if: columns then this row may be filtered out, in which case
+      # this method call will return false.
+      return eval_single_row(row) if @result.outs_functions
+      # Common case is just copying output column values to the final result.
+      @rows_picked = row
+      @result.add_outs(row)
+    end
+    def eval_single_row(row)
+      return false unless (result = @result.eval_outs(row))
+      @rows_picked = row
+      result
+    end
+  end
+end

data/lib/csv_decision/defaults.rb ADDED Viewed

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+# CSV Decision: CSV based Ruby decision tables.
+# Created December 2017.
+# @author Brett Vickers.
+# See LICENSE and README.md for details.
+module CSVDecision
+  # Parse the default row beneath the header row if present
+  # @api private
+  module Defaults
+    # Parse the defaults row that (optionally) appears just after the header row.
+    # We have already determined that this row must be present.
+    # @param columns [{Integer=>Dictionary::Entry}] Hash of header columns with defaults.
+    # @param matchers [Array<Matchers>] Output cell special matchers.
+    # @param row [Array<String>] Defaults row that appears just after the header row.
+    # @raise [TableValidationError] Missing defaults row.
+    def self.parse(columns:, matchers:, row:)
+      raise TableValidationError, 'Missing defaults row' if row.nil?
+      defaults = columns.defaults
+      # Scan the default row for procs and constants
+      scan_row = ScanRow.new.scan_columns(row: row, columns: defaults, matchers: matchers)
+      parse_columns(defaults: defaults, columns: columns.dictionary, row: scan_row)
+    end
+    def self.parse_columns(defaults:, columns:, row:)
+      defaults.each_pair do |col, entry|
+        parse_cell(cell: row[col], columns: columns, entry: entry)
+      end
+      defaults
+    end
+    private_class_method :parse_columns
+    def self.parse_cell(cell:, columns:, entry:)
+      return entry.function = cell unless cell.is_a?(Matchers::Proc)
+      entry.function = cell.function
+      # Add any referenced input column symbols to the column name dictionary
+      Columns.ins_cell_dictionary(columns: columns, cell: cell)
+    end
+    private_class_method :parse_cell
+  end
+end