csv_decision 0.0.9 → 0.1.0

data/lib/csv_decision/matchers/pattern.rb

@@ -74,8 +74,7 @@ module CSVDecision
         # No need for a regular expression if we have simple string inequality
         pattern = comparator == '!=' ? value : Matchers.regexp(value)
 
-        Proc.with(type: :proc,
-                  function: PATTERN_LAMBDAS[comparator].curry[pattern].freeze)
+        Proc.new(type: :proc, function: PATTERN_LAMBDAS[comparator].curry[pattern].freeze)
       end
 
       # @param options [Hash{Symbol=>Object}] Used to determine the value of regexp_implicit:.

data/lib/csv_decision/matchers/range.rb

@@ -81,7 +81,7 @@ module CSVDecision
         negate, range = range(match, coerce: coerce)
         method = coerce ? :numeric_range : :alnum_range
         function = Range.send(method, negate, range).freeze
-        Proc.with(type: :proc, function: function)
+        Proc.new(type: :proc, function: function)
       end
       private_class_method :range_proc
 

data/lib/csv_decision/matchers/symbol.rb

@@ -60,7 +60,7 @@ module CSVDecision
       # E.g., > :col, we get comparator: >, args: col
       def self.comparison(comparator:, name:)
         function = COMPARE[comparator]
-        Matchers::Proc.with(type: :symbol, function: function[name])
+        Matchers::Proc.new(type: :symbol, function: function[name], symbols: name)
       end
       private_class_method :comparison
 

data/lib/csv_decision/matchers.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'values'
-
 # CSV Decision: CSV based Ruby decision tables.
 # Created December 2017.
 # @author Brett Vickers.
@@ -10,9 +8,45 @@ module CSVDecision
   # Match table data cells against a valid decision table expression or a simple constant.
   # @api private
   class Matchers
-    # Value object for a data cell proc.
+    # Composite object for a data cell proc. Note that we do not need it to be comparable.
+    # Implemented as an immutable array of 2 or 3 entries for memory compactness and speed.
     # @api private
-    Proc = Value.new(:type, :function)
+    class Proc < Array
+      # @param type [Symbol] Type of the function value - e.g., :constant or :guard.
+      # @param function [Object] Either a lambda function,
+      #   or some kind of constant such as an Integer.
+      # @param symbols [nil, Symbol, Array<Symbol>] The symbol or list of symbols
+      #   that the function uses to reference input hash keys (which are always symbolized).
+      def initialize(type:, function:, symbols: nil)
+        super()
+
+        self << type
+
+        # Function values should always be frozen
+        self << function.freeze
+
+        # Some function values, such as constants or 0-arity functions, do not reference symbols.
+        self << symbols if symbols
+
+        freeze
+      end
+
+      # @return [Symbol] Type of the function value - e.g., :constant or :guard.
+      def type
+        fetch(0)
+      end
+
+      # @return [Object] Either a lambda function, or some kind of constant such as an Integer.
+      def function
+        fetch(1)
+      end
+
+      # @return [nil, Symbol, Array<Symbol>] The symbol or list of symbols
+      #   that the function uses to reference input hash keys (which are always symbolized).
+      def symbols
+        fetch(2, nil)
+      end
+    end
 
     # Negation sign prefixed to ranges and functions.
     NEGATE = '!'

data/lib/csv_decision/parse.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'ice_nine'
-require 'ice_nine/core_ext/object'
-
 # CSV Decision: CSV based Ruby decision tables.
 # Created December 2017.
 # @author Brett Vickers.
@@ -63,7 +60,7 @@ module CSVDecision
       parse_table(table: table, input: data, options: options)
 
       # The table object is now immutable.
-      table.columns.deep_freeze
+      table.columns.freeze
       table.freeze
     rescue CSVDecision::Error => exp
       raise_error(file: table.file, exception: exp)
@@ -108,12 +105,110 @@ module CSVDecision
     private_class_method :parse_data
 
     def self.parse_row(table:, matchers:, row:, index:)
+      # Parse the input cells for this row
+      row = parse_row_ins(table: table, matchers: matchers, row: row, index: index)
+
+      # Parse the output cells for this row
+      parse_row_outs(table: table, matchers: matchers, row: row, index: index)
+    end
+    private_class_method :parse_row
+
+    def self.parse_row_ins(table:, matchers:, row:, index:)
+      # Parse the input cells for this row
       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)
+
+      row
+    end
+    private_class_method :parse_row_ins
+
+    def self.parse_row_outs(table:, matchers:, row:, index:)
+      # 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)
+
       row
     end
-    private_class_method :parse_row
+    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

@@ -20,10 +20,18 @@ module CSVDecision
       @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
-
+      # Partial result always copies in the input hash for calculating output functions.
+      # Note that these input key values will not be mutated, as output columns can never
+      # 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
+
+      # 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
 
@@ -35,7 +43,7 @@ module CSVDecision
       @outs.each_pair { |col, column| @attributes[column.name] = row[col] }
     end
 
-    # Accumulate the outs into arrays.
+    # Accumulate the outs into arrays of values.
     # @param row [Array]
     # @return [void]
     def accumulate_outs(row)
@@ -45,6 +53,7 @@ module CSVDecision
     # Derive the final result.
     # @return [{Symbol=>Object}]
     def final
+      # If there are no if: columns, then nothing needs to be filtered out of this result hash.
       return @attributes if @if_columns.empty?
 
       @multi_result ? multi_row_result : single_row_result
@@ -76,12 +85,13 @@ module CSVDecision
 
     private
 
-    # Case where we have a single row result
+    # Case where we have a single row result, which either gets returned
+    # or filtered by the if: column conditions.
     def single_row_result
       @if_columns.each_key do |col|
         return nil unless @attributes[col]
 
-        # Remove the if: column from the final result
+        # Remove the if: column from the final result hash.
         @attributes.delete(col)
       end
 
@@ -121,9 +131,11 @@ module CSVDecision
       case count
       when 0
         {}
-        # Single row array values do not require arrays.
+
+      # Single row array values do not require arrays.
       when 1
         @attributes.transform_values!(&:first)
+
       else
         @attributes
       end
@@ -168,6 +180,10 @@ module CSVDecision
       when nil
         @attributes[column_name] = cell
 
+      when Matchers::Proc
+        @attributes[column_name] = [current, cell]
+        @multi_result = true
+
       when Array
         @attributes[column_name] << cell
 

data/lib/csv_decision/table.rb

@@ -16,11 +16,11 @@ module CSVDecision
       Decide.decide(table: self, input: input, symbolize_keys: true)
     end
 
-    # Unsafe version of decide - will mutate the hash if +set: column+ type
-    # is used (planned feature).
+    # Unsafe version of decide - assumes the input hash is symbolized.
     #
     # @param input (see #decide)
     # @note Input hash must have its keys symbolized.
+    #   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)

data/spec/csv_decision/columns_spec.rb

@@ -37,6 +37,80 @@ describe CSVDecision::Columns do
     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: :output2, eval: false, type: :out)
+
+    expect(table.columns.dictionary).to eq(input: :in, output: 1, output2: 3)
+  end
+
+  it 'recognises all input and output column symbols' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: len,       guard:
+      input0,    output0,     input1,         output1,          :input2.length, 
+      input1,    output1,     input1,         output2,          :input3.length, :input4.present?
+    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.ins[5].to_h).to eq(name: nil, eval: true, type: :guard)
+
+    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: :output2, eval: false, type: :out)
+    expect(table.columns.outs[4].to_h).to eq(name: :len, eval: true, type: :out)
+
+    expect(table.columns.dictionary)
+      .to eq(input: :in, output: 1, output2: 3, len: 4, input2: :in, input3: :in, input4: :in)
+
+    expect(table.columns.input_keys).to eq %i[input input2 input4 input3]
+  end
+
+  it 'recognises the output symbol referenced by an output function' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: input3,      out: len       
+      input0,    output0,     input1,         output1,          ,                 :input2.length
+      input1,    output1,     input1,         output2,          :input4.present?, :input3.length
+    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: :output2, eval: false, type: :out)
+    expect(table.columns.outs[4].to_h).to eq(name: :input3, eval: true, type: :out)
+    expect(table.columns.outs[5].to_h).to eq(name: :len, eval: true, type: :out)
+
+    expect(table.columns.dictionary)
+      .to eq(input: :in, output: 1, output2: 3, len: 5, input2: :in, input3: 4, input4: :in)
+
+    expect(table.columns.input_keys).to eq %i[input input2 input4]
+  end
+
+  it 'raises an error for an output column referring to a later output column' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: len,        out: input3,            
+      input0,    output0,     input1,         output1,          :input2.length,                 
+      input1,    output1,     input1,         output2,          :input3.length   :input4.upcase
+    DATA
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(
+        CSVDecision::CellValidationError,
+        "output column 'len' makes an out of order reference to output column 'input3'"
+      )
+  end
+
+  it 'raises an error for an output column referring to itself' do
+    data = <<~DATA
+      IN :input, OUT :output, IN/text :input, OUT/text:output2, out: len,      out: input3,            
+      input0,    output0,     input1,         output1,          :len.length,                 
+      input1,    output1,     input1,         output2,          :len.length   :input4.upcase
+    DATA
+
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "output column 'len' makes reference to itself")
   end
 
   it 'parses a decision table columns from a CSV file' do
@@ -106,6 +180,8 @@ describe CSVDecision::Columns do
 
     expect(table.columns.ins[1].to_h)
       .to eq(name: nil, eval: true, type: :guard)
+
+    expect(table.columns.input_keys).to eq %i[country CUSIP SEDOL]
   end
 
   it 'rejects output column being same as input column' do
@@ -114,11 +190,23 @@ describe CSVDecision::Columns do
       US,          :CUSIP.present?, :CUSIP,    CUSUP
       GB,          :SEDOL.present?, :SEDOL,    SEDOL
     DATA
+
     expect { CSVDecision.parse(data) }
       .to raise_error(CSVDecision::CellValidationError,
                       "output column name 'country' is also an input column")
   end
 
+  it 'rejects output column being same as an input symbol not in the header' do
+    data = <<~DATA
+      in :parent, out :node
+      ==:node,    top
+      ,           child
+    DATA
+    expect { CSVDecision.parse(data) }
+      .to raise_error(CSVDecision::CellValidationError,
+                      "output column name 'node' is also an input column")
+  end
+
   it 'recognises the if: column' do
     data = <<~DATA
       in :country, out :PAID, out :PAID_type, if:
@@ -128,5 +216,6 @@ describe CSVDecision::Columns do
     table = CSVDecision.parse(data)
 
     expect(table.columns.ifs[3].to_h).to eq(name: 3, eval: true, type: :if)
+    expect(table.columns.input_keys).to eq %i[country CUSIP SEDOL]
   end
 end

data/spec/csv_decision/examples_spec.rb

@@ -95,6 +95,27 @@ context 'simple examples' do
     end
   end
 
+  context 'simple example - column symbols not in header' do
+    data = <<~DATA
+      in :parent, out :top?
+      ==:node,   yes
+      ,          no
+    DATA
+
+    it 'makes correct decisions' do
+      table = CSVDecision.parse(data)
+
+      result = table.decide(node: 0, parent: 0)
+      expect(result).to eq(top?: 'yes')
+
+      result = table.decide(node: 1, parent: 0)
+      expect(result).to eq(top?: 'no')
+
+      result = table.decide(node: '0', parent: 0)
+      expect(result).to eq(top?: 'no')
+    end
+  end
+
   it 'makes correct decision for table with symbol ordered compares' do
     data = <<~DATA
       in :traded, in :settled, out :status
@@ -103,9 +124,10 @@ context 'simple examples' do
       ,           <:traded,    invalid trade
       ,                   ,    invalid data
     DATA
-
     table = CSVDecision.parse(data)
 
+    expect(table.columns.input_keys).to eq %i[traded settled]
+
     expect(table.decide(traded: '20171227',  settled: '20171227')).to eq(status: 'same day')
     expect(table.decide(traded:  20171227,   settled:  20171227 )).to eq(status: 'same day')
     expect(table.decide(traded: '20171227',  settled: '20171228')).to eq(status: 'pending')

data/spec/csv_decision/input_spec.rb

@@ -30,7 +30,6 @@ describe CSVDecision::Input do
     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
@@ -49,6 +48,5 @@ describe CSVDecision::Input do
     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

data/spec/csv_decision/table_spec.rb

@@ -439,7 +439,7 @@ describe CSVDecision::Table do
           it "#{method} correctly #{test[:example]}" do
             table = CSVDecision.parse(test[:data], test[:options])
 
-            expect(table.send(method, country: 'US',  CUSIP: '123456789'))
+            expect(table.send(method, country: 'US',  CUSIP: '123456789', Ticker: 'USTY'))
               .to eq(ID: '123456789', ID_type: 'CUSIP', len: 9)
 
             expect(table.send(method, country: 'US',  CUSIP: '123456789', ISIN: '123456789012'))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csv_decision
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Brett Vickers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-06 00:00:00.000000000 Z
+date: 2018-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,34 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.1'
-- !ruby/object:Gem::Dependency
-  name: ice_nine
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
-- !ruby/object:Gem::Dependency
-  name: values
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.8'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -223,6 +195,7 @@ files:
 - doc/CSVDecision/Matchers/Matcher.html
 - doc/CSVDecision/Matchers/Numeric.html
 - doc/CSVDecision/Matchers/Pattern.html
+- doc/CSVDecision/Matchers/Proc.html
 - doc/CSVDecision/Matchers/Range.html
 - doc/CSVDecision/Matchers/Symbol.html
 - doc/CSVDecision/Numeric.html