csv_decision 0.4.1 → 0.5.0

data/lib/csv_decision/scan.rb

@@ -0,0 +1,116 @@
+# 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
+  # Scan the input hash for all the paths specified in the decision table
+  # @api private
+  class Scan
+    # Main method for making decisions with a table that has paths.
+    #
+    # @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.table(table:, input:, symbolize_keys:)
+      input = symbolize_keys ? input.deep_symbolize_keys : input
+      decision = Decision.new(table: table)
+      input_hashes = InputHashes.new
+
+      if table.options[:first_match]
+        scan_first_match(input: input, decision: decision, input_hashes: input_hashes)
+      else
+        scan_accumulate(input: input, decision: decision, input_hashes: input_hashes)
+      end
+    end
+
+    def self.scan_first_match(input:, decision:, input_hashes:)
+      decision.table.paths.each do |path, rows|
+        data = input_hashes.data(decision: decision, path: path, input: input)
+        next if data == {}
+
+        result = decision.index_scan_first_match(
+          scan_cols: data[:scan_cols],
+          hash: data[:hash],
+          index_rows: Array(rows)
+        )
+        return result if result != {}
+      end
+
+      {}
+    end
+    private_class_method :scan_first_match
+
+    def self.scan_accumulate(input:, decision:, input_hashes:)
+      # Final result
+      result = {}
+
+      decision.table.paths.each do |path, rows|
+        data = input_hashes.data(decision: decision, path: path, input: input)
+        next if data == {}
+
+        result = scan(rows: rows, input: data, final: result, decision: decision)
+      end
+
+      result
+    end
+    private_class_method :scan_accumulate
+
+    def self.scan(rows:, input:, final:, decision:)
+      # Note that +rows+ must be enclosed in an array for this method to work.
+      result = decision.index_scan_accumulate(scan_cols: input[:scan_cols],
+                                              hash: input[:hash],
+                                              index_rows: [rows])
+
+      # Accumulate this potentially multi-row result into the final result.
+      final = accumulate(final: final, result: result) if result.present?
+
+      final
+    end
+    private_class_method :scan
+
+    def self.accumulate(final:, result:)
+      return result if final == {}
+
+      final.each_pair { |key, value| final[key] = Array(value) + Array(result[key]) }
+      final
+    end
+    private_class_method :accumulate
+
+    # Derive the parsed input hash, using a cache for speed.
+    class InputHashes
+      def initialize
+        @input_hashes = {}
+      end
+
+      # @param path [Array<Symbol] Path for the input hash.
+      # @param input [Hash{Symbol=>Object}] Input hash.
+      # @return [Hash{Symbol=>Object}] Parsed input hash.
+      def data(decision:, path:, input:)
+        result = input(decision: decision, path: path, input: input)
+
+        decision.input(result) unless result == {}
+
+        result
+      end
+
+      private
+
+      def input(decision:, path:, input:)
+        return @input_hashes[path] if @input_hashes.key?(path)
+
+        # Use the path - an array of symbol keys, to dig out the input sub-hash
+        hash = path.empty? ? input : input.dig(*path)
+
+        # Parse and transform the hash supplied as input
+        data = hash.blank? ? {} : Input.parse_data(table: decision.table, input: hash)
+
+        # Cache the parsed input hash data for this path
+        @input_hashes[path] = data
+      end
+    end
+  end
+end

data/lib/csv_decision/table.rb

@@ -13,7 +13,7 @@ module CSVDecision
     # @param input [Hash] Input hash.
     # @return [{Symbol => Object, Array<Object>}] Decision hash.
     def decide(input)
-      Decision.make(table: self, input: input, symbolize_keys: true)
+      decision(input: input, symbolize_keys: true)
     end
 
     # Unsafe version of decide - may mutate the input hash and assumes the input
@@ -24,18 +24,22 @@ module CSVDecision
     #   Input hash will be mutated by any functions that have side effects.
     # @return (see #decide)
     def decide!(input)
-      Decision.make(table: self, input: input, symbolize_keys: false)
+      decision( input: input, symbolize_keys: false)
     end
 
     # @return [CSVDecision::Columns] Dictionary of all input and output columns.
     attr_accessor :columns
 
-    # @return [File, Pathname, nil] File path name if decision table was loaded from a CSV file.
+    # @return [File, Pathname, nil] File path name if decision table was loaded from a
+    # CSV file.
     attr_accessor :file
 
     # @return [CSVDecision::Index] The index built on one or more input columns.
     attr_accessor :index
 
+    # @return [CSVDecision::Path] The array of paths built on one or more input columns.
+    attr_accessor :paths
+
     # @return [Hash] All options, explicitly set or defaulted, used to parse the table.
     attr_accessor :options
 
@@ -77,14 +81,21 @@ module CSVDecision
 
     # @api private
     def initialize
-      @file = nil
-      @index = nil
-      @options = nil
-      @outs_functions = nil
+      @paths = []
       @outs_rows = []
       @if_rows = []
       @rows = []
       @scan_rows = []
     end
+
+    private
+
+    def decision(input:, symbolize_keys:)
+      if columns.paths.empty?
+        Decision.make(table: self, input: input, symbolize_keys: symbolize_keys)
+      else
+        Scan.table(table: self, input: input, symbolize_keys: symbolize_keys)
+      end
+    end
   end
 end

data/lib/csv_decision/validate.rb

@@ -10,7 +10,7 @@ module CSVDecision
   # @api private
   module Validate
     # These column types do not need a name.
-    COLUMN_TYPE_ANONYMOUS = Set.new(%i[guard if]).freeze
+    COLUMN_TYPE_ANONYMOUS = Set.new(%i[guard if path]).freeze
     private_constant :COLUMN_TYPE_ANONYMOUS
 
     # Validate a column header cell and return its type and name.

data/spec/csv_decision/columns_spec.rb

@@ -234,4 +234,18 @@ describe CSVDecision::Columns do
 
     expect(table.columns.input_keys).to eq %i[country class CUSIP ISIN]
   end
+
+  it 'recognises the path: columns' do
+    data = <<~DATA
+      path:,   path:,    in :type_cd, out :value, if:
+      header,  ,         !nil?,       :type_cd,   :value.present?
+      payload, ,         !nil?,       :type_cd,   :value.present?
+      payload, ref_data, ,            :type_id,   :value.present?
+    DATA
+    table = CSVDecision.parse(data)
+
+    expect(table.columns.input_keys).to eq %i[type_cd type_id]
+    expect(table.columns.paths[0].to_h).to eq(name: nil, eval: false, type: :path, set_if: nil)
+    expect(table.columns.paths[1].to_h).to eq(name: nil, eval: false, type: :path, set_if: nil)
+  end
 end

data/spec/csv_decision/decision_spec.rb

@@ -12,9 +12,7 @@ describe CSVDecision::Decision do
 
     table = CSVDecision.parse(data)
 
-    input = { input: 'input0', input1: 'input1' }
-
-    decision = CSVDecision::Decision.new(table: table, input: input)
+    decision = CSVDecision::Decision.new(table: table)
 
     expect(decision).to be_a(CSVDecision::Decision)
   end

data/spec/csv_decision/examples_spec.rb

@@ -214,4 +214,29 @@ context 'simple examples' do
     expect(table.decide(ISIN: '123456789', country: 'GB', class: 'public')).to eq({})
     expect(table.decide(ISIN: '123456789012', country: 'GB', class: 'private')).to eq(PAID: '123456789012', len: 12)
   end
+
+  it 'scans the input hash paths accumulating matches' do
+    data = <<~DATA
+      path:,   path:,    out :value
+      header,  ,         :source_name
+      header,  metrics,  :service_name
+      payload, ,         :amount
+      payload, ref_data, :account_id
+    DATA
+    table = CSVDecision.parse(data, first_match: false)
+
+    input = {
+      header: {
+        id: 1, type_cd: 'BUY', source_name: 'Client', client_name: 'AAPL',
+        metrics: { service_name: 'Trading', receive_time: '12:00' }
+      },
+      payload: {
+        tran_id: 9, amount: '100.00',
+        ref_data: { account_id: '5010', type_id: 'BUYL' }
+      }
+    }
+
+    expect(table.decide(input)).to eq(value: %w[Client Trading 100.00 5010])
+    expect(table.decide!(input)).to eq(value: %w[Client Trading 100.00 5010])
+  end
 end

data/spec/csv_decision/table_spec.rb

@@ -592,5 +592,92 @@ describe CSVDecision::Table do
         end
       end
     end
+
+    it 'scans the input hash paths for a first match' do
+      data = <<~DATA
+        path:,   path:,    in :type_cd, out :value, if:
+        header,  ,         !nil?,       :type_cd,   :value.present?
+        payload, ,         !nil?,       :type_cd,   :value.present?
+        payload, ref_data, ,            :type_id,   :value.present?
+      DATA
+      table = CSVDecision.parse(data)
+
+      input = {
+        header: { id: 1, type_cd: 'BUY' },
+        payload: { tran_id: 9,
+                   ref_data: { account_id: 5, type_id: 'BUYL' }
+        }
+      }
+      expect(table.decide(input)).to eq(value: 'BUY')
+      expect(table.decide!(input)).to eq(value: 'BUY')
+
+      input = {
+        header: { id: 1 },
+        payload: { tran_id: 9,
+                   ref_data: { account_id: 5, type_id: 'BUYL' }
+        }
+      }
+      expect(table.decide(input)).to eq(value: 'BUYL')
+      expect(table.decide!(input)).to eq(value: 'BUYL')
+
+      input = {
+        payload: { tran_id: 9,
+                   ref_data: { account_id: 5, type_id: 'BUYL' }
+        }
+      }
+      expect(table.decide(input)).to eq(value: 'BUYL')
+
+      input = {
+        payload: { tran_id: nil,
+                   ref_data: {  type_id: '' }
+        }
+      }
+      expect(table.decide(input)).to eq({})
+    end
+
+    it 'scans the input hash paths accumulating matches' do
+      data = <<~DATA
+        path:,   path:,    out :value,     out :key,   if:
+        header,  ,         :source_name,   source_nm,     :value.present?
+        header,  ,         :client_name,   client_nm,     :value.present?
+        header,  ,         :client_ref,    client_ref_id, :value.present?
+        header,  metrics,  :service_name,  service_nm,    :value.present?
+        payload, ,         :amount,        trade_am,      :value.present?
+        payload, ref_data, :account_id,    account_id,    :value.present?
+        header,  metrics,  :receive_time,  receive_tm,    :value.present?
+      DATA
+      table = CSVDecision.parse(data, first_match: false)
+
+      input = {
+        header: {
+          id: 1, type_cd: 'BUY', source_name: 'Client', client_name: 'AAPL', client_ref: 'A1',
+          metrics: { service_name: 'Trading', receive_time: '12:00' }
+        },
+        payload: { tran_id: 9,
+                   amount: '100.00',
+                   ref_data: { account_id: '5010', type_id: 'BUYL' }
+        }
+      }
+      result = { value: %w[Client AAPL A1 Trading 100.00 5010 12:00],
+                 key: %w[source_nm client_nm client_ref_id service_nm trade_am account_id receive_tm] }
+      expect(table.decide(input)).to eq result
+      expect(table.decide!(input)).to eq result
+
+      input = {
+        header: {
+          id: 1, type_cd: 'BUY', source_name: 'Client', client_ref: 'A1',
+          metrics: { service_name: 'Trading' }
+        },
+        payload: { tran_id: 9,
+                   amount: '100.00',
+                   ref_data: { type_id: 'BUYL' }
+        }
+      }
+      result = { value: %w[Client A1 Trading 100.00],
+                 key: %w[source_nm client_ref_id service_nm trade_am] }
+
+      expect(table.decide(input)).to eq result
+      expect(table.decide!(input)).to eq result
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csv_decision
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Brett Vickers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-10 00:00:00.000000000 Z
+date: 2018-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -203,7 +203,10 @@ files:
 - doc/CSVDecision/Numeric.html
 - doc/CSVDecision/Options.html
 - doc/CSVDecision/Parse.html
+- doc/CSVDecision/Paths.html
 - doc/CSVDecision/Result.html
+- doc/CSVDecision/Scan.html
+- doc/CSVDecision/Scan/InputHashes.html
 - doc/CSVDecision/ScanRow.html
 - doc/CSVDecision/Symbol.html
 - doc/CSVDecision/Table.html
@@ -243,7 +246,9 @@ files:
 - lib/csv_decision/matchers/symbol.rb
 - lib/csv_decision/options.rb
 - lib/csv_decision/parse.rb
+- lib/csv_decision/paths.rb
 - lib/csv_decision/result.rb
+- lib/csv_decision/scan.rb
 - lib/csv_decision/scan_row.rb
 - lib/csv_decision/table.rb
 - lib/csv_decision/validate.rb