csv_decision 0.0.8 → 0.0.9

data/lib/csv_decision/result.rb

@@ -0,0 +1,180 @@
+# 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) into a result hash.
+  # @api private
+  class Result
+    # @return [Hash{Symbol=>Object}, Hash{Integer=>Object}] The decision result hash containing
+    #   both result values and if: columns, which eventually get evaluated and removed.
+    attr_reader :attributes
+
+    # @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
+      @if_columns = table.columns.ifs
+
+      # Partial result always includes the input hash for calculating output functions.
+      @partial_result = input[:hash].dup if table.outs_functions
+
+      @attributes = {}
+      @multi_result = false
+    end
+
+    # Common case for building a single row result is just copying output column values to the
+    # final result hash.
+    # @param row [Array]
+    # @return [void]
+    def add_outs(row)
+      @outs.each_pair { |col, column| @attributes[column.name] = row[col] }
+    end
+
+    # Accumulate the outs into arrays.
+    # @param row [Array]
+    # @return [void]
+    def accumulate_outs(row)
+      @outs.each_pair { |col, column| add_cell(column_name: column.name, cell: row[col]) }
+    end
+
+    # Derive the final result.
+    # @return [{Symbol=>Object}]
+    def final
+      return @attributes if @if_columns.empty?
+
+      @multi_result ? multi_row_result : single_row_result
+    end
+
+    # Evaluate the output columns, and use them to start building the final result,
+    # along with the partial result required to evaluate functions.
+    #
+    # @param row [Array]
+    # @return (see #final)
+    def eval_outs(row)
+      # Set the constants first, in case the functions refer to them
+      eval_outs_constants(row: row)
+
+      # Then evaluate the procs, left to right
+      eval_outs_procs(row: row)
+
+      final
+    end
+
+    # Evaluate the cell proc using the partial result calculated so far.
+    #
+    # @param proc [Matchers::Pro]
+    # @param column_name [Symbol, Integer]
+    # @param index [Integer]
+    def eval_cell_proc(proc:, column_name:, index:)
+      @attributes[column_name][index] = proc.function[partial_result(index)]
+    end
+
+    private
+
+    # Case where we have a single row result
+    def single_row_result
+      @if_columns.each_key do |col|
+        return nil unless @attributes[col]
+
+        # Remove the if: column from the final result
+        @attributes.delete(col)
+      end
+
+      @attributes
+    end
+
+    def multi_row_result
+      @if_columns.each_key { |col| check_if_column(col) }
+
+      normalize_result
+    end
+
+    def check_if_column(col)
+      delete_rows = []
+      @attributes[col].each_with_index { |value, index| delete_rows << index unless value }
+
+      # Remove this if: column from the final result
+      @attributes.delete(col)
+
+      # Adjust the row index as we delete rows in sequence.
+      delete_rows.each_with_index { |index, sequence| delete_row(index - sequence) }
+    end
+
+    # Each result "row", given by the row +index+ is a collection of column arrays.
+    # @param index [Integer] Row index.
+    # @return [{Symbol=>Object}, {Integer=>Object}]
+    def delete_row(index)
+      @attributes.transform_values { |value| value.delete_at(index) }
+    end
+
+    # @return [{Symbol=>Object}] Decision result hash with any if: columns removed.
+    def normalize_result
+      # Peek at the first column's result and see how many rows it contains.
+      count = @attributes.values.first.count
+      @multi_result = count > 1
+
+      case count
+      when 0
+        {}
+        # Single row array values do not require arrays.
+      when 1
+        @attributes.transform_values!(&:first)
+      else
+        @attributes
+      end
+    end
+
+    def eval_outs_constants(row:)
+      @outs.each_pair do |col, column|
+        value = row[col]
+        next if value.is_a?(Matchers::Proc)
+
+        @partial_result[column.name] = value
+        @attributes[column.name] = value
+      end
+    end
+
+    def eval_outs_procs(row:)
+      @outs.each_pair do |col, column|
+        proc = row[col]
+        next unless proc.is_a?(Matchers::Proc)
+
+        value = proc.function[@partial_result]
+
+        @partial_result[column.name] = value
+        @attributes[column.name] = value
+      end
+    end
+
+    def partial_result(index)
+      @attributes.each_pair do |column_name, value|
+        # Delete this column from the partial result in case there is data from a prior result row
+        next @partial_result.delete(column_name) if value[index].is_a?(Matchers::Proc)
+
+        # Add this constant value to the partial result row built so far.
+        @partial_result[column_name] = value[index]
+      end
+
+      @partial_result
+    end
+
+    def add_cell(column_name:, cell:)
+      case (current = @attributes[column_name])
+      when nil
+        @attributes[column_name] = cell
+
+      when Array
+        @attributes[column_name] << cell
+
+      else
+        @attributes[column_name] = [current, cell]
+        @multi_result = true
+      end
+    end
+  end
+end

data/lib/csv_decision/scan_row.rb

@@ -8,17 +8,23 @@ module CSVDecision
   # Data row object indicating which columns are constants versus procs.
   # @api private
   class ScanRow
+    # These column types cannot have constants in their data cells.
+    NO_CONSTANTS = Set.new(%i[guard if]).freeze
+    private_constant :NO_CONSTANTS
+
     # Scan the table cell against all matches.
     #
     # @param matchers [Array<Matchers::Matcher>]
     # @param cell [String]
     # @return [false, Matchers::Proc]
     def self.scan(column:, matchers:, cell:)
+      return false if cell == ''
+
       proc = scan_matchers(column: column, matchers: matchers, cell: cell)
       return proc if proc
 
-      # Must be a simple string constant - this is OK except for a guard column
-      guard_constant?(type: :constant, column: column)
+      # Must be a simple string constant - this is OK except for a certain column types.
+      invalid_constant?(type: :constant, column: column)
     end
 
     def self.scan_matchers(column:, matchers:, cell:)
@@ -43,18 +49,18 @@ module CSVDecision
 
     def self.scan_proc(column:, cell:, matcher:)
       proc = matcher.matches?(cell)
-      guard_constant?(type: proc.type, column: column) if proc
+      invalid_constant?(type: proc.type, column: column) if proc
 
       proc
     end
     private_class_method :scan_proc
 
-    def self.guard_constant?(type:, column:)
-      return false unless type == :constant && column.type == :guard
+    def self.invalid_constant?(type:, column:)
+      return false unless type == :constant && NO_CONSTANTS.member?(column.type)
 
-      raise CellValidationError, 'guard column cannot contain constants'
+      raise CellValidationError, "#{column.type}: column cannot contain constants"
     end
-    private_class_method :guard_constant?
+    private_class_method :invalid_constant?
 
     # Evaluate the cell proc against the column's input value and/or input hash.
     #

data/lib/csv_decision/table.rb

@@ -27,15 +27,12 @@ module CSVDecision
     end
 
     # @return [CSVDecision::Columns] Dictionary of all input and output columns.
-    # @api private
     attr_accessor :columns
 
     # @return [File, Pathname, nil] File path name if decision table was loaded from a CSV file.
-    # @api private
     attr_accessor :file
 
     # @return [Hash] All options, explicitly set or defaulted, used to parse the table.
-    # @api private
     attr_accessor :options
 
     # Set if the table row has any output functions (planned feature)
@@ -55,6 +52,10 @@ module CSVDecision
     # @api private
     attr_accessor :outs_rows
 
+    # @return [Array<CSVDecision::ScanRow>] Used to implement filtering of final results.
+    # @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.)
@@ -79,13 +80,13 @@ module CSVDecision
     def initialize
       @columns = nil
       @file = nil
-      @matchers = []
       @options = nil
       @outs_functions = nil
       @outs_rows = []
+      @if_rows = []
       @rows = []
       @scan_rows = []
-      @tables = nil
+      # @tables = nil
     end
   end
 end

data/lib/csv_decision.rb

@@ -13,16 +13,18 @@ module CSVDecision
     File.dirname __dir__
   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 :Columns,    'csv_decision/columns'
   autoload :Header,     'csv_decision/header'
   autoload :Input,      'csv_decision/input'
   autoload :Load,       'csv_decision/load'
   autoload :Matchers,   'csv_decision/matchers'
   autoload :Options,    'csv_decision/options'
   autoload :Parse,      'csv_decision/parse'
+  autoload :Result,     'csv_decision/result'
   autoload :ScanRow,    'csv_decision/scan_row'
   autoload :Table,      'csv_decision/table'
 

data/spec/csv_decision/columns_spec.rb

@@ -15,18 +15,28 @@ describe CSVDecision::Columns do
     end
   end
 
-  it 'parses a decision table columns from a CSV string' do
+  it 'rejects a duplicate output column name' do
     data = <<~DATA
       IN :input, OUT :output, IN/text : input, OUT/text:output
       input0,    output0,     input1,          output1
     DATA
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "output column name 'output' is duplicated")
+  end
+
+  it 'parses a decision table columns from a CSV string' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text : input, OUT/text:output2
+      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, 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: :output, eval: false, type: :out)
+    expect(table.columns.outs[3].to_h).to eq(name: :output2, eval: false, type: :out)
   end
 
   it 'parses a decision table columns from a CSV file' do
@@ -35,9 +45,9 @@ describe CSVDecision::Columns do
 
     expect(result.columns).to be_a(CSVDecision::Columns)
     expect(result.columns.ins)
-      .to eq(0 => CSVDecision::Columns::Entry.new(:input, nil, :in))
+      .to eq(0 => CSVDecision::Dictionary::Entry.new(:input, nil, :in))
     expect(result.columns.outs)
-      .to eq(1 => CSVDecision::Columns::Entry.new(:output, nil, :out))
+      .to eq(1 => CSVDecision::Dictionary::Entry.new(:output, nil, :out))
   end
 
   it 'rejects an invalid header column' do
@@ -108,4 +118,15 @@ describe CSVDecision::Columns do
       .to raise_error(CSVDecision::CellValidationError,
                       "output column name 'country' is also an input column")
   end
+
+  it 'recognises the if: column' do
+    data = <<~DATA
+      in :country, out :PAID, out :PAID_type, if:
+      US,          :CUSIP,    CUSIP,          :PAID.present?
+      GB,          :SEDOL,    SEDOL,          :PAID.present?
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns.ifs[3].to_h).to eq(name: 3, eval: true, type: :if)
+  end
 end

data/spec/csv_decision/examples_spec.rb

@@ -133,4 +133,29 @@ context 'simple examples' do
     expect(table.decide(country: 'EU',  CUSIP: '123456789', ISIN:'123456789012'))
       .to eq(ID: '123456789012', ID_type: 'ISIN', len: 12)
   end
+
+  it 'makes a correct decision using an if column' do
+    data = <<~DATA
+      in :country, guard:,          out :ID, out :ID_type, out :len,  if:
+      US,          :CUSIP.present?, :CUSIP,  CUSIP8,       :ID.length, :len == 8
+      US,          :CUSIP.present?, :CUSIP,  CUSIP9,       :ID.length, :len == 9
+      US,          :CUSIP.present?, :CUSIP,  DUMMY,        :ID.length,
+      ,            :ISIN.present?,  :ISIN,   ISIN,         :ID.length, :len == 12
+      ,            :ISIN.present?,  :ISIN,   DUMMY,        :ID.length,
+      ,            :CUSIP.present?, :CUSIP,  DUMMY,        :ID.length,
+      DATA
+
+    table = CSVDecision.parse(data)
+
+    expect(table.decide(country: 'US',  CUSIP: '12345678'))
+      .to eq(ID: '12345678', ID_type: 'CUSIP8', len: 8)
+    expect(table.decide(country: 'US',  CUSIP: '123456789'))
+      .to eq(ID: '123456789', ID_type: 'CUSIP9', len: 9)
+    expect(table.decide(country: 'US',  CUSIP: '1234567890'))
+      .to eq(ID: '1234567890', ID_type: 'DUMMY', len: 10)
+    expect(table.decide(country: nil,  CUSIP: '123456789', ISIN:'123456789012'))
+      .to eq(ID: '123456789012', ID_type: 'ISIN', len: 12)
+    expect(table.decide(CUSIP: '12345678', ISIN:'1234567890'))
+      .to eq(ID: '1234567890', ID_type: 'DUMMY', len: 10)
+  end
 end

data/spec/csv_decision/matchers/guard_spec.rb

@@ -133,20 +133,37 @@ describe CSVDecision::Matchers::Guard do
       end
     end
 
-    context 'raises an error for a string in a guard column' do
+    context 'raises an error for a constant in a guard column' do
       data = <<~DATA
-            IN :country, guard : country, out :PAID, out :PAID_type, out :len
-            US,          :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
-            GB,          :SEDOL.present?, :SEDOL,    SEDOL,          :PAID.length
-            ,            :ISIN.present?,  :ISIN,     ISIN,           :PAID.length
-            ,            :SEDOL.present?, :SEDOL,    SEDOL,          :PAID.length
-            ,            :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
-            ,            := nil,          := nil,    MISSING,        := nil
+        IN :country, guard : country, out :PAID, out :PAID_type, out :len
+        US,          :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
+        GB,          :SEDOL.present?, :SEDOL,    SEDOL,          :PAID.length
+        ,            :ISIN.present?,  :ISIN,     ISIN,           :PAID.length
+        ,            :SEDOL.present?, :SEDOL,    SEDOL,          :PAID.length
+        ,            :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
+        ,            := nil,          := nil,    MISSING,        := nil
       DATA
 
       specify do
         expect { CSVDecision.parse(data) }
-          .to raise_error(CSVDecision::CellValidationError, 'guard column cannot contain constants')
+          .to raise_error(CSVDecision::CellValidationError, 'guard: column cannot contain constants')
+      end
+    end
+
+    context 'raises an error for a constant in an if column' do
+      data = <<~DATA
+        IN :country, guard : country, out :PAID, out :PAID_type, if:
+        US,          :CUSIP.present?, :CUSIP,    CUSIP,          TRUE
+        GB,          :SEDOL.present?, :SEDOL,    SEDOL,          
+        ,            :ISIN.present?,  :ISIN,     ISIN,           
+        ,            :SEDOL.present?, :SEDOL,    SEDOL,          
+        ,            :CUSIP.present?, :CUSIP,    CUSIP,          
+        ,            := nil,          := nil,    MISSING,        := nil
+      DATA
+
+      specify do
+        expect { CSVDecision.parse(data) }
+          .to raise_error(CSVDecision::CellValidationError, 'if: column cannot contain constants')
       end
     end
   end

data/spec/csv_decision/table_spec.rb

@@ -280,7 +280,6 @@ describe CSVDecision::Table do
           DATA
         }
       ]
-
       examples.each do |test|
         %i[decide decide!].each do |method|
           it "#{method} correctly #{test[:example]}" do
@@ -352,7 +351,7 @@ describe CSVDecision::Table do
         { example: 'evaluates named guard condition',
           options: {},
           data: <<~DATA
-            IN :country, guard : country, out :PAID, out :PAID_type, out :len
+            in :country, guard: country,  out :PAID, out :PAID_type, out :len
             US,          :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
             GB,          :SEDOL.present?, :SEDOL,    SEDOL,          :PAID.length
             ,            :ISIN.present?,  :ISIN,     ISIN,           :PAID.length
@@ -360,6 +359,30 @@ describe CSVDecision::Table do
             ,            :CUSIP.present?, :CUSIP,    CUSIP,          :PAID.length
             ,            ,                := nil,    MISSING,        := nil
           DATA
+        },
+        { example: 'evaluates named if condition',
+          options: {},
+          data: <<~DATA
+            in :country, out :PAID, out :PAID_type, out :len,     if:
+            US,          :CUSIP,    CUSIP,          :PAID.length, :PAID.present?
+            GB,          :SEDOL,    SEDOL,          :PAID.length, :PAID.present?
+            ,            :ISIN,     ISIN,           :PAID.length, :PAID.present?
+            ,            :SEDOL,    SEDOL,          :PAID.length, :PAID.present?
+            ,            :CUSIP,    CUSIP,          :PAID.length, :PAID.present?
+            ,            := nil,    MISSING,        := nil,
+          DATA
+        },
+        { example: 'evaluates multiple if conditions',
+          options: {},
+          data: <<~DATA
+            in :country, out :PAID, if:,           out :PAID_type, out :len,     if:,            if: stupid
+            US,          :CUSIP,    !:PAID.blank?, CUSIP,          :PAID.length, :PAID.present?, :len >= 9
+            GB,          :SEDOL,    !:PAID.blank?, SEDOL,          :PAID.length, :PAID.present?, :len >= 9
+            ,            :ISIN,     !:PAID.blank?, ISIN,           :PAID.length, :PAID.present?, :len >= 9
+            ,            :SEDOL,    !:PAID.blank?, SEDOL,          :PAID.length, :PAID.present?, :len >= 9
+            ,            :CUSIP,    !:PAID.blank?, CUSIP,          :PAID.length, :PAID.present?, :len >= 9
+            ,            := nil,    ,              MISSING,        := nil,,
+          DATA
         }
       ]
       examples.each do |test|
@@ -389,6 +412,26 @@ describe CSVDecision::Table do
             ,            :SEDOL.present?, :SEDOL,    SEDOL,      :ID.length
             ,            :ISIN.present?,  :ISIN,     ISIN,       :ID.length
           DATA
+        },
+        { example: 'evaluates if: column conditions & output functions',
+          options: { first_match: false },
+          data: <<~DATA
+            IN :country, out :ID, out :ID_type, out :len,   if:
+            US,          :CUSIP,  CUSIP,        :ID.length, :ID.present?
+            GB,          :SEDOL,  SEDOL,        :ID.length, :ID.present?
+            ,            :SEDOL,  SEDOL,        :ID.length, :ID.present?
+            ,            :ISIN,   ISIN,         :ID.length, :ID.present?
+          DATA
+        },
+        { example: 'evaluates multiple if: column conditions & output functions',
+          options: { first_match: false },
+          data: <<~DATA
+            IN :country, out :ID, if:,         out :ID_type, out :len,   if:,       if:
+            US,          :CUSIP,  !:ID.blank?, CUSIP,        :ID.length, :len == 9, :ID.present?
+            GB,          :SEDOL,  !:ID.blank?, SEDOL,        :ID.length, :len == 7, :ID.present?
+            ,            :SEDOL,  !:ID.blank?, SEDOL,        :ID.length, :len == 7, :ID.present?
+            ,            :ISIN,   !:ID.blank?, ISIN,         :ID.length, :len ==12, :ID.present?
+          DATA
         }
       ]
       examples.each do |test|
@@ -401,6 +444,9 @@ describe CSVDecision::Table do
 
             expect(table.send(method, country: 'US',  CUSIP: '123456789', ISIN: '123456789012'))
               .to eq(ID: %w[123456789 123456789012], ID_type: %w[CUSIP ISIN], len: [9, 12])
+
+            expect(table.send(method, country: 'US',  Ticker: 'USTY'))
+              .to eq({})
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csv_decision
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Brett Vickers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-31 00:00:00.000000000 Z
+date: 2018-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -207,6 +207,8 @@ files:
 - doc/CSVDecision/Data.html
 - doc/CSVDecision/Decide.html
 - doc/CSVDecision/Decision.html
+- doc/CSVDecision/Dictionary.html
+- doc/CSVDecision/Dictionary/Entry.html
 - doc/CSVDecision/Error.html
 - doc/CSVDecision/FileError.html
 - doc/CSVDecision/Function.html
@@ -226,6 +228,7 @@ files:
 - doc/CSVDecision/Numeric.html
 - doc/CSVDecision/Options.html
 - doc/CSVDecision/Parse.html
+- doc/CSVDecision/Result.html
 - doc/CSVDecision/ScanRow.html
 - doc/CSVDecision/Symbol.html
 - doc/CSVDecision/Table.html
@@ -248,6 +251,7 @@ files:
 - lib/csv_decision/data.rb
 - lib/csv_decision/decide.rb
 - lib/csv_decision/decision.rb
+- lib/csv_decision/dictionary.rb
 - lib/csv_decision/header.rb
 - lib/csv_decision/input.rb
 - lib/csv_decision/load.rb
@@ -261,6 +265,7 @@ files:
 - lib/csv_decision/matchers/symbol.rb
 - lib/csv_decision/options.rb
 - lib/csv_decision/parse.rb
+- lib/csv_decision/result.rb
 - lib/csv_decision/scan_row.rb
 - lib/csv_decision/table.rb
 - spec/csv_decision/columns_spec.rb