RubyGems - csv_decision2 - Versions diffs - 0.5.1 - Mend

csv_decision2 0.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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