csv_decision 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 824f8e4c688f507bc8e0ea1c65c37d7a615e7d1d
-  data.tar.gz: 644623f44ba59db10bc98470e113673f0482fbcd
+  metadata.gz: 5dd656bc42ac4a7e5bc1b3ba49599f972179fbe9
+  data.tar.gz: 8f97105d30b993279dbadf380798fb4fbc36d4dd
 SHA512:
-  metadata.gz: 005e743b69070d458d93d8fef1fd1e75e6328d3046e6adb7e2461d0d3201848d011922e3536b4942949697d3cbb04f985af21da48b3464690c2373490ffffd5c
-  data.tar.gz: e3dd1c8cc027ae660a82ad8f5c9be5f1307741aa329ca03c109bc28486acd59dac4ecc18ed497e75294f162fda596d91cd1e937f3ccbb494af4bd6fcf57e8692
+  metadata.gz: d7c5bb91fcb110d0ef7a39def02096ae65e6cfc4eb1b9b17ad4e17407baa02004d5e835a7ce24df016b9b47683afebfeb37e632372447082e0229cb46174a6de
+  data.tar.gz: bc3313687f8a01cdd82efdd59190bea881a4707382a23275c20b192b2d048db747a3200163e0b773c31fe9a500269484c10d990d363c9f75956df956ff1379c8

data/README.md

@@ -1,33 +1,43 @@
 CSV Decision
 ============
 
-<a href="https://codeclimate.com/github/bpvickers/csv_decision/maintainability"><img src="https://api.codeclimate.com/v1/badges/466a6c52e8f6a3840967/maintainability" /></a>
+[![Gem Version](https://badge.fury.io/rb/csv_decision.svg)](https://badge.fury.io/rb/csv_decision)
 [![Build Status](https://travis-ci.org/bpvickers/csv_decision.svg?branch=master)](https://travis-ci.org/bpvickers/csv_decision)
 [![Coverage Status](https://coveralls.io/repos/github/bpvickers/csv_decision/badge.svg?branch=master)](https://coveralls.io/github/bpvickers/csv_decision?branch=master)
-[![Gem Version](https://badge.fury.io/rb/csv_decision.svg)](http://badge.fury.io/rb/csv_decision)
+<a href="https://codeclimate.com/github/bpvickers/csv_decision/maintainability"><img src="https://api.codeclimate.com/v1/badges/466a6c52e8f6a3840967/maintainability" /></a>
 
-# CSV based Ruby decision tables
+### CSV based Ruby decision tables (a lightweight Hash transformation gem)
 
-`csv_decision` is a Ruby gem for CSV (comma separated values) based 
+`csv_decision` is a RubyGem for CSV (comma separated values) based 
 [decision tables](https://en.wikipedia.org/wiki/Decision_table). 
-It accepts decision tables written in a CSV file, which can then be used to execute 
-complex conditional logic against an input hash, producing a decision as an output hash.
+It accepts decision tables implemented as a 
+[CSV file](https://en.wikipedia.org/wiki/Comma-separated_values), 
+which can then be used to execute complex conditional logic against an input hash, 
+producing a decision as an output hash.
 
  ### `csv_decision` features
- * fast decision-time performance
- * can use regular expressions, numeric comparisons and Ruby-style ranges
- * accepts data as a file, CSV string or an array of arrays.
- * all CSV cells are parsed for correctness, and helpful error messages generated for bad 
- inputs
+ * Fast decision-time performance (see `benchmark.rb`).
+ * In addition to simple string matching, can use regular expressions, 
+ numeric comparisons and Ruby-style ranges.
+ * Accepts data as a file, CSV string or an array of arrays. (For safety all input data is 
+ force encoded to UTF-8, and non-ascii strings are converted to empty strings.)
+ * All CSV cells are parsed for correctness, and helpful error messages generated for bad 
+ inputs.
+ * Either returns the first matching row as a hash, or accumulates all matches as an 
+ array of hashes.
  
  ### Planned features
- * input columns may be indexed for faster lookup performance
- * either returns the first matching row as a hash, or accumulates all matches as an 
- array of hashes.
- * use of output functions to formulate the final decision
- * can use column symbol references or built-in guard functions for matching
- * may be extended with user-defined Ruby functions for tailored logic 
- * can use if conditions to filter the results of multi-row decision output
+ `csv_decision` is currently a work in progress, and will be enhanced to support
+ the following features:
+ * Input columns may be indexed for faster lookup performance.
+ * May use functions in the output columns to formulate the final decision.
+ * Input hash values may be conditionally defaulted using a constant or a function call
+ * Use of column symbol references or built-in guard functions in the input
+ columns for matching.
+ * Output columns may used interpolated strings referencing column symbols.
+ * May be extended with user-defined Ruby functions for tailored logic.
+ * Can use post-match guard conditions to filter the results of multi-row 
+ decision output.
  
  ### Why use `csv_decision`?
  
@@ -50,6 +60,11 @@ complex conditional logic against an input hash, producing a decision as an outp
  gem 'csv_decision', '~> 0.0.1'
  ```
  
+ or simply
+ ```bash
+ gem install csv_decision
+ ```
+ 
  ### Simple example
  
  A decision table may be as simple or as complex as you like (although very complex 
@@ -89,6 +104,7 @@ politics  |             | Henry
  Now for some code.
  
  ```ruby
+  # Valid CSV string
   data = <<~DATA
     in :topic, in :region,  out :team_member
     sports,    Europe,      Alice
@@ -118,10 +134,42 @@ politics  |             | Henry
 table = CSVDecision.parse(Pathname('spec/data/valid/simple_example.csv'))
 ```
  
+ We can also load this same table using the option: `first_match: false`.
+ 
+ ```ruby
+table = CSVDecision.parse(data, first_match: false)
+table.decide(topic: 'finance', region: 'Europe') # returns team_member: %w[Donald Ernest Zach] 
+```
+
+
  For more examples see `spec/csv_decision/table_spec.rb`. 
  Complete documentation of all table parameters is in the code - see 
  `lib/csv_decision/parse.rb` and `lib/csv_decision/table.rb`.
  
+ ### Constants other than strings
+ Although `csv_decision` is string oriented, it does recognise other types of constant
+ present in the input hash. Specifically, the following classes are recognized: 
+ `Integer`, `BigDecimal` and `NilClass`. 
+ 
+ This is accomplished by prefixing the value with one of the operators `=`, `==` or `:=`. 
+ (The syntax is intentionally lax.)
+ 
+ For example:
+ ```ruby
+    data = <<~DATA
+      in :constant, out :type
+      :=nil,        NilClass
+      ==false,      FALSE
+      =true,        TRUE
+      = 0,          Zero
+      :=100.0,      100%
+    DATA
+          
+  table = CSVDecision.parse(data)
+  table.decide(constant: nil) # returns type: 'NilClass'        
+  table.decide(constant: 0) # returns type: 'Zero'        
+  table.decide(constant: BigDecimal.new('100.0')) # returns type: '100%'        
+```
  
  ### Testing
  

data/benchmark.rb

@@ -19,7 +19,8 @@ benchmarks = [
     data: 'simple_example.csv',
     input: { 'topic' => 'culture', 'region' => 'America' },
     # Expected results for first_match and accumulate
-    first_match: { 'team_member' => 'Zach' }
+    first_match: { 'team_member' => 'Zach' },
+    accumulate: { 'team_member' => 'Zach' }
   }
 ].deep_freeze
 
@@ -31,7 +32,7 @@ puts '=' * tag_width
 puts ""
 
 # First match true and false run options
-[true].each do |first_match|
+[true, false].each do |first_match|
   puts "Table Decision Option: first_match: #{first_match}"
   puts '-' * tag_width
 

data/csv_decision.gemspec

@@ -5,7 +5,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = 'csv_decision'
-  spec.version       = '0.0.2'
+  spec.version       = '0.0.3'
   spec.authors       = ['Brett Vickers']
   spec.email         = ['brett@phillips-vickers.com']
   spec.description   = 'CSV based Ruby decision tables.'

data/lib/csv_decision.rb

@@ -26,8 +26,9 @@ module CSVDecision
   autoload :Table,    'csv_decision/table'
 
   module Matchers
-    autoload :Numeric, 'csv_decision/matchers/numeric'
-    autoload :Pattern, 'csv_decision/matchers/pattern'
-    autoload :Range,   'csv_decision/matchers/range'
+    autoload :Function, 'csv_decision/matchers/function'
+    autoload :Numeric,  'csv_decision/matchers/numeric'
+    autoload :Pattern,  'csv_decision/matchers/pattern'
+    autoload :Range,    'csv_decision/matchers/range'
   end
 end

data/lib/csv_decision/columns.rb

@@ -9,25 +9,29 @@ module CSVDecision
     # Value object used for column dictionary entries
     Entry = Struct.new(:name, :text_only)
 
-    # Value object used for columns with defaults
+    # Value object used for any columns with defaults
     Default = Struct.new(:name, :function, :default_if)
 
     # Dictionary of all data columns.
     # # Note that the key of each hash is the header cell's array column index.
     # Note that input and output columns can be interspersed and need not have unique names.
     class Dictionary
+      # Input columns
       attr_accessor :ins
+
+      # Output columns
       attr_accessor :outs
+
+      # Input hash path - optional (planned feature)
       attr_accessor :path
+
+      # Input columns with a default value (planned feature)
       attr_accessor :defaults
 
       def initialize
         @ins = {}
         @outs = {}
-
-        # Path for the input hash - optional
         @path = {}
-        # Hash of columns that require defaults to be set
         @defaults = {}
       end
     end
@@ -57,7 +61,7 @@ module CSVDecision
 
     def initialize(table)
       # If a column does not have a valid header cell, then it's empty of data.
-      # Return the stripped header row, removing it from the data array.
+      # Return the stripped header row, and remove it from the data array.
       row = Header.strip_empty_columns(rows: table.rows)
 
       # Build a dictionary of all valid data columns from the header row.

data/lib/csv_decision/header.rb

@@ -17,12 +17,13 @@ module CSVDecision
 
     # More lenient than a Ruby method name -
     # any spaces will have been replaced with underscores
-    COLUMN_NAME = %r{\A\w[\w:/!?]*\z}
+    COLUMN_NAME = "\\w[\\w:/!?]*"
+    COLUMN_NAME_RE = Matchers.regexp(COLUMN_NAME)
 
     # Does this row contain a recognisable header cell?
     #
-    # @param row [Array<String>]
-    # @return [true, false]
+    # @param row [Array<String>] header row
+    # @return [Boolean] true if the row looks like a header
     def self.row?(row)
       row.find { |cell| cell.match(COLUMN_TYPE) }
     end
@@ -34,9 +35,9 @@ module CSVDecision
     #   header row.
     def self.strip_empty_columns(rows:)
       empty_cols = empty_columns?(row: rows.first)
-      Data.strip_columns(data: rows, empty_columns: empty_cols) unless empty_cols.empty?
+      Data.strip_columns(data: rows, empty_columns: empty_cols) if empty_cols
 
-      # Remove the header row from the data array.
+      # Remove header row from the data array.
       rows.shift
     end
 
@@ -54,7 +55,7 @@ module CSVDecision
       dictionary
     end
 
-    def self.header_column?(cell:)
+    def self.validate_header_column(cell:)
       match = COLUMN_TYPE.match(cell)
       raise CellValidationError, 'column name is not well formed' unless match
 
@@ -66,14 +67,14 @@ module CSVDecision
       raise CellValidationError,
             "header column '#{cell}' is not valid as the #{exp.message}"
     end
-    private_class_method :header_column?
+    private_class_method :validate_header_column
 
     # Array of all empty column indices.
     def self.empty_columns?(row:)
       result = []
       row&.each_with_index { |cell, index| result << index if cell == '' }
 
-      result
+      result.empty? ? false : result
     end
     private_class_method :empty_columns?
 
@@ -83,14 +84,16 @@ module CSVDecision
 
       raise CellValidationError, 'column name is missing'
     end
+    private_class_method :column_name
 
     def self.format_column_name(name)
       column_name = name.strip.tr("\s", '_')
 
-      return column_name.to_sym if COLUMN_NAME.match(column_name)
+      return column_name.to_sym if COLUMN_NAME_RE.match(column_name)
 
       raise CellValidationError, "column name '#{name}' contains invalid characters"
     end
+    private_class_method :format_column_name
 
     # Returns the normalized column type, along with an indication if
     # the column is text only
@@ -110,11 +113,12 @@ module CSVDecision
         [type, nil]
       end
     end
+    private_class_method :column_type
 
     def self.parse_cell(cell:, index:, dictionary:)
-      column_type, column_name = header_column?(cell: cell)
+      column_type, column_name = validate_header_column(cell: cell)
 
-      type, text_only = Header.column_type(column_type)
+      type, text_only = column_type(column_type)
 
       dictionary_entry(dictionary: dictionary,
                        type: type,

data/lib/csv_decision/matchers.rb

@@ -9,61 +9,6 @@ module CSVDecision
   # Value object for a cell proc
   Proc = Value.new(:type, :function)
 
-  # Value object for a data row indicating which columns are constants versus procs.
-  # ScanRow = Struct.new(:constants, :procs) do
-  #   def scan_columns(columns:, matchers:, row:)
-  #     columns.each_pair do |col, column|
-  #       # Empty cell matches everything, and so never needs to be scanned
-  #       next if row[col] == ''
-  #
-  #       # If the column is text only then no special matchers need be invoked
-  #       next constants << col if column.text_only
-  #
-  #       # Need to scan the cell against all matchers
-  #       row[col] = scan_cell(col: col, matchers: matchers, cell: row[col])
-  #     end
-  #   end
-  #
-  #   def match_constants?(row:, scan_cols:)
-  #     constants.each do |col|
-  #       value = scan_cols.fetch(col, [])
-  #       # This only happens if the column is indexed
-  #       next if value == []
-  #       return false unless row[col] == value
-  #     end
-  #
-  #     true
-  #   end
-  #
-  #   def match_procs?(row:, input:)
-  #     hash = input[:hash]
-  #     scan_cols = input[:scan_cols]
-  #
-  #     procs.each do |col|
-  #       return false unless Decide.eval_matcher(proc: row[col],
-  #                                               value: scan_cols[col],
-  #                                               hash: hash)
-  #     end
-  #
-  #     true
-  #   end
-  #
-  #   private
-  #
-  #   def scan_cell(col:, matchers:, cell:)
-  #     # Scan the cell against all the matchers
-  #     proc = Matchers.scan(matchers: matchers, cell: cell)
-  #
-  #     if proc
-  #       procs << col
-  #       return proc
-  #     end
-  #
-  #     constants << col
-  #     cell
-  #   end
-  # end
-
   # Methods to assign a matcher to data cells
   module Matchers
     # Negation sign for ranges and functions
@@ -127,5 +72,13 @@ module CSVDecision
       # Must be a simple constant
       false
     end
+
+    # @abstract Subclass and override {#matches?} to implement
+    #   a custom Matcher class.
+    class Matcher
+      def initialize(_options = nil); end
+
+      def matches?(_cell); end
+    end
   end
 end

data/lib/csv_decision/matchers/function.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# CSV Decision: CSV based Ruby decision tables.
+# Created December 2017 by Brett Vickers
+# See LICENSE and README.md for details.
+module CSVDecision
+  # Methods to assign a matcher to data cells
+  module Matchers
+    # rubocop: disable Lint/BooleanSymbol
+    NON_NUMERIC_CONSTANTS = {
+      true: true,
+      false:  false,
+      nil: nil
+    }.freeze
+    # rubocop: enable Lint/BooleanSymbol
+
+    def self.input_cell_constant?(match)
+      return false unless CELL_CONSTANT.member?(match['operator'])
+      return false unless match['args'] == ''
+      return false unless match['negate'] == ''
+
+      name = match['name'].to_sym
+      return false unless NON_NUMERIC_CONSTANTS.key?(name)
+
+      Proc.with(type: :constant, function: NON_NUMERIC_CONSTANTS[name])
+    end
+
+    # Match cell against a function call or symbolic expression.
+    class Function < Matcher
+      # Looks like a function call or symbol expressions, e.g.,
+      # == true
+      # := function(arg: symbol)
+      # == :column_name
+      FUNCTION_CALL =
+        "(?<operator>=|:=|==|<|>|!=|>=|<=|:|!\\s*:)\s*(?<negate>!?)\\s*(?<name>#{Header::COLUMN_NAME}|:)(?<args>.*)"
+      FUNCTION_RE = Matchers.regexp(FUNCTION_CALL)
+
+      # COMPARATORS = {
+      #   '>'  => proc { |numeric_cell, value| Matchers.numeric(value) &.>  numeric_cell },
+      #   '>=' => proc { |numeric_cell, value| Matchers.numeric(value) &.>= numeric_cell },
+      #   '<'  => proc { |numeric_cell, value| Matchers.numeric(value) &.<  numeric_cell },
+      #   '<=' => proc { |numeric_cell, value| Matchers.numeric(value) &.<= numeric_cell },
+      #   '!=' => proc { |numeric_cell, value| Matchers.numeric(value) &.!= numeric_cell }
+      # }.freeze
+
+      def matches?(cell)
+        match = FUNCTION_RE.match(cell)
+        return false unless match
+
+        # Check if the guard condition is a cell constant
+        proc = Matchers.input_cell_constant?(match)
+        return proc if proc
+
+        false
+      end
+    end
+  end
+end

data/lib/csv_decision/matchers/numeric.rb

@@ -6,11 +6,16 @@
 module CSVDecision
   # Methods to assign a matcher to data cells
   module Matchers
-    # Match cell against a Ruby-like numeric comparison
-    class Numeric
-      # Range types are .. or ...
-      COMPARISON = /\A(?<comparator><=|>=|<|>|!=)\s*(?<value>\S.*)\z/
+    # Cell constant specified by prefixing the value with these symbols
+    CELL_CONSTANT = Set.new(%w[== := =]).freeze
 
+    # Match cell against a Ruby-like numeric comparison or a numeric constant
+    class Numeric < Matcher
+      # For example: >= 100 or != 0
+      COMPARISON = /\A(?<comparator><=|>=|<|>|!=|:=|==|=)\s*(?<value>\S.*)\z/
+
+      # Coerce the input value to a numeric representation before invoking the comparison.
+      # If the coercion fails, it will produce a nil value which always fails to match.
       COMPARATORS = {
         '>'  => proc { |numeric_cell, value| Matchers.numeric(value) &.>  numeric_cell },
         '>=' => proc { |numeric_cell, value| Matchers.numeric(value) &.>= numeric_cell },
@@ -26,12 +31,16 @@ module CSVDecision
         numeric_cell = Matchers.numeric(match['value'])
         return false unless numeric_cell
 
+        comparator = match['comparator']
+
+        # If the comparator is assignment/equality, then just treat as a simple constant
+        if CELL_CONSTANT.member?(comparator)
+          return Proc.with(type: :constant, function: numeric_cell)
+        end
+
         Proc.with(type: :proc,
-                  function: COMPARATORS[match['comparator']].curry[numeric_cell])
+                  function: COMPARATORS[comparator].curry[numeric_cell])
       end
-
-      # This matcher does not need access to the options hash
-      def initialize(_options = nil); end
     end
   end
 end

data/lib/csv_decision/matchers/pattern.rb

@@ -7,7 +7,7 @@ module CSVDecision
   # Methods to assign a matcher to data cells
   module Matchers
     # Match cell against a regular expression pattern
-    class Pattern
+    class Pattern < Matcher
       EXPLICIT_COMPARISON = /\A(?<comparator>=~|!~|!=)\s*(?<value>\S.*)\z/
       IMPLICIT_COMPARISON = /\A(?<comparator>=~|!~|!=)?\s*(?<value>\S.*)\z/
 

data/lib/csv_decision/matchers/range.rb

@@ -7,7 +7,7 @@ module CSVDecision
   # Methods to assign a matcher to data cells
   module Matchers
     # Match cell against a Ruby-like range
-    class Range
+    class Range < Matcher
       # Range types are .. or ...
       TYPE = '(\.\.\.|\.\.)'
 
@@ -68,9 +68,6 @@ module CSVDecision
 
         false
       end
-
-      # This matcher does not need access to the options hash
-      def initialize(_options = nil); end
     end
   end
 end

data/lib/csv_decision/options.rb

@@ -9,7 +9,8 @@ module CSVDecision
   DEFAULT_MATCHERS = [
     Matchers::Range,
     Matchers::Numeric,
-    Matchers::Pattern
+    Matchers::Pattern,
+    Matchers::Function
   ].freeze
 
   # All valid options with their default values.

data/lib/csv_decision/scan_row.rb

@@ -56,13 +56,22 @@ module CSVDecision
       # Scan the cell against all the matchers
       proc = Matchers.scan(matchers: matchers, cell: cell)
 
-      if proc
-        procs << col
-        return proc
-      end
+      return set(proc, col) if proc
 
+      # Just a plain constant
       constants << col
       cell
     end
+
+    def set(proc, col)
+      # Unbox a constant
+      if proc.type == :constant
+        constants << col
+        return proc.function
+      end
+
+      procs << col
+      proc
+    end
   end
 end

data/lib/csv_decision/table.rb

@@ -4,34 +4,53 @@
 # Created December 2017 by Brett Vickers
 # See LICENSE and README.md for details.
 module CSVDecision
-  # Decision Table that accepts input hashes and makes decision
+  # Decision Table that accepts input hashes and makes decisions
   class Table
+    # CSVDecision::Columns object - dictionary of all input and output columns
     attr_accessor :columns
+
+    # File path name if decision table loaded from a CSV file
     attr_accessor :file
+
+    # All options used to parse the table
     attr_accessor :options
+
+    # Set if the table has any output functions (planned feature)
     attr_accessor :outs_functions
+
+    # Data rows - an array of arrays
     attr_accessor :rows
+
+    # Array of CSVDecision::ScanRow objects used to implement matching logic
     attr_accessor :scan_rows
+
+    # Any array of 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.)
     attr_reader :tables
 
     # Main public method for making decisions.
+    #
     # @param input [Hash] - input hash (keys may or may not be symbolized)
-    # @return [Hash]
+    # @return [Hash{Symbol => Object, Array<Object>}] decision
     def decide(input)
       Decide.decide(table: self, input: input, symbolize_keys: true).result
     end
 
-    # Unsafe version of decide - will mutate the hash if set: option (planned feature)
-    # is used.
-    # @param input [Hash] - input hash (keys must be symbolized)
-    # @return [Hash]
+    # Unsafe version of decide - will mutate the hash if set: column type
+    # is used (planned feature).
+    #
+    # @param input [Hash{Symbol => Object}] - input hash (all keys must already be symbolized)
+    # @return [Hash{Symbol => Object, Array<Object>}]
     def decide!(input)
       Decide.decide(table: self, input: input, symbolize_keys: false).result
     end
 
-    # Iterate through all data rows of the decision table.
-    # @param first [Integer] - start row
-    # @param last [Integer] - last row
+    # Iterate through all data rows of the decision table, with an optional
+    # first and last row index given.
+    #
+    # @param first [Integer] start row
+    # @param last [Integer, nil] last row
     def each(first = 0, last = @rows.count - 1)
       index = first
       while index <= (last || first)

data/spec/csv_decision/matchers/function_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../../../lib/csv_decision'
+
+describe CSVDecision::Matchers::Function do
+  subject { described_class.new }
+
+  describe '#new' do
+    it { is_expected.to be_a CSVDecision::Matchers::Function }
+    it { is_expected.to be_a CSVDecision::Matchers::Matcher }
+    it { is_expected.to respond_to(:matches?).with(1).argument }
+  end
+
+  context 'cell value recognition' do
+    cells = {
+      ':= nil' => { operator: ':=', value: 'nil' },
+      '== nil' => { operator: '==', value: 'nil' },
+      '=  nil' => { operator: '=', value: 'nil' },
+      '==true' => { operator: '==', value: 'true' },
+      ':=false' => { operator: ':=', value: 'false' },
+    }
+    cells.each_pair do |cell, expected|
+      it "recognises #{cell} as a constant" do
+        match = described_class::FUNCTION_RE.match(cell)
+        expect(match['operator']).to eq expected[:operator]
+        expect(match['name']).to eq expected[:value]
+      end
+    end
+  end
+
+  describe '#matches?' do
+    matcher = described_class.new
+
+    context 'constant matches value' do
+      data = [
+        ['= nil', nil],
+        [':= false', false],
+        ['==true', true]
+      ]
+
+      data.each do |cell, value|
+        it "comparision #{cell} matches #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_a(CSVDecision::Proc)
+          expect(proc.type).to eq :constant
+          expect(proc.function).to eq value
+        end
+      end
+    end
+
+
+    context 'does not match a function constant' do
+      data = ['1', ':column', ':= 1.1', ':= abc', 'abc', 'abc.*def', '-1..1', '0...3']
+
+      data.each do |cell|
+        it "cell #{cell} is not a comparision}" do
+          expect(matcher.matches?(cell)).to eq false
+        end
+      end
+    end
+  end
+end

data/spec/csv_decision/matchers/numeric_spec.rb

@@ -11,14 +11,16 @@ describe CSVDecision::Matchers::Numeric do
   end
 
   context 'cell value recognition' do
-    ranges = {
+    cells = {
       '> -1' => { comparator: '>', value: '-1' },
       '>= 10.0' => { comparator: '>=', value: '10.0' },
       '< .0' => { comparator: '<', value: '.0' },
       '<= +1' => { comparator: '<=', value: '+1' },
-      '!= 0.0' => { comparator: '!=', value: '0.0' },
+      '!=0.0' => { comparator: '!=', value: '0.0' },
+      ':= 0.0' => { comparator: ':=', value: '0.0' },
+      '= 1.0' => { comparator: '=', value: '1.0' }
     }
-    ranges.each_pair do |cell, expected|
+    cells.each_pair do |cell, expected|
       it "recognises #{cell} as a comparision" do
         match = described_class::COMPARISON.match(cell)
         expect(match['comparator']).to eq expected[:comparator]
@@ -35,6 +37,7 @@ describe CSVDecision::Matchers::Numeric do
           ['< 1',  0],
           ['< 1', '0'],
           ['> 1',  5],
+          ['!= 1',  0],
           ['> 1', '5'],
           ['>= 1.1', BigDecimal.new('1.1')],
           ['<=-1.1', BigDecimal.new('-12')]
@@ -49,28 +52,25 @@ describe CSVDecision::Matchers::Numeric do
         end
       end
     end
-  #
-  #   context 'range does not match value' do
-  #     data = [
-  #       [ '-1..+4', 5],
-  #       ['!-1..+4', 2],
-  #       %w[a...z      z],
-  #       %w[!a..z      m],
-  #       %w[-1..1     1.1],
-  #       ['-1..1', BigDecimal.new('1.1')],
-  #       ['-1..1', BigDecimal.new('1.1')]
-  #     ]
-  #
-  #     data.each do |cell, value|
-  #       it "range #{cell} does not match #{value}" do
-  #         proc = matcher.matches?(cell)
-  #         expect(proc).to be_a(CSVDecision::Proc)
-  #         expect(proc.type).to eq :proc
-  #         expect(proc.function[value]).to eq false
-  #       end
-  #     end
-  #   end
-  #
+
+    context 'numeric constant' do
+      data = [
+        ['== 1',  1],
+        [':= 0', 0],
+        ['==1.1', BigDecimal.new('1.1')],
+        ['=-1.2', BigDecimal.new('-1.2')]
+      ]
+
+      data.each do |cell, value|
+        it "constant expression #{cell} evaluates to #{value}" do
+          proc = matcher.matches?(cell)
+          expect(proc).to be_a(CSVDecision::Proc)
+          expect(proc.type).to eq :constant
+          expect(proc.function).to eq value
+        end
+      end
+    end
+
     context 'does not match a numeric comparision' do
       data = ['1', ':column', ':= nil', ':= true', 'abc', 'abc.*def', '-1..1', '0...3']
 

data/spec/csv_decision/simple_example_spec.rb

@@ -2,7 +2,7 @@
 
 require_relative '../../lib/csv_decision'
 
-context 'simple example' do
+context 'simple example - strings-only' do
   data = <<~DATA
     in :topic, in :region,  out :team_member
     sports,    Europe,      Alice
@@ -29,7 +29,6 @@ context 'simple example' do
     expect(result).to eq(team_member: 'Zach')
   end
 
-
   it 'makes correct decisions for CSV file' do
     table = CSVDecision.parse(Pathname('spec/data/valid/simple_example.csv'))
 
@@ -43,3 +42,34 @@ context 'simple example' do
     expect(result).to eq(team_member: 'Zach')
   end
 end
+
+context 'simple example - constants' do
+  data = <<~DATA
+    in :constant, out :type
+    :=nil,        NilClass
+    ==false,      FALSE
+    =true,        TRUE
+    = 0,          Zero
+    :=100.0,      100%
+  DATA
+
+  it 'makes correct decisions for CSV string' do
+    table = CSVDecision.parse(data)
+
+    result = table.decide(constant: nil)
+    expect(result).to eq(type: 'NilClass')
+
+    result = table.decide(constant: true)
+    expect(result).to eq(type: 'TRUE')
+
+    result = table.decide(constant: false)
+    expect(result).to eq(type: 'FALSE')
+
+    result = table.decide(constant: 0)
+    expect(result).to eq(type: 'Zero')
+
+    result = table.decide(constant: BigDecimal.new('100.0'))
+    expect(result).to eq(type: '100%')
+  end
+end
+

data/spec/csv_decision/table_spec.rb

@@ -56,6 +56,42 @@ describe CSVDecision::Table do
       end
     end
 
+    context 'makes correct decisions for simple non-string constants' do
+      examples = [
+        {
+          example: 'parses CSV file',
+          options: {},
+          data: Pathname(File.join(SPEC_DATA_VALID, 'simple_constants.csv'))
+        },
+        {
+          example: 'parses CSV string',
+          options: {},
+          data: <<~DATA
+            in :constant, out :type
+            :=nil,        NilClass
+            = 0,          Zero
+            :=100.0,      100%
+            ,             Unrecognized
+          DATA
+        },
+      ]
+      examples.each do |test|
+        %i[decide decide!].each do |method|
+          it "#{method} correctly #{test[:example]} with first_match: true" do
+            options = test[:options].merge(first_match: true)
+            table = CSVDecision.parse(test[:data], options)
+
+            expect(table.send(method, constant: nil)).to eq(type: 'NilClass')
+            expect(table.send(method, constant: 0)).to eq(type: 'Zero')
+            expect(table.send(method, constant: BigDecimal.new('100.0'))).to eq(type: '100%')
+            expect(table.send(method, constant: ':=nil')).to eq(type: 'Unrecognized')
+            expect(table.send(method, constant: '= 0')).to eq(type: 'Unrecognized')
+            expect(table.send(method, constant: ':=100.0')).to eq(type: 'Unrecognized')
+          end
+        end
+      end
+    end
+
     context 'makes correct decisions for a table with regexps and ranges' do
       examples = [
         {
@@ -66,7 +102,7 @@ describe CSVDecision::Table do
             18..35,    maniac,      Adelsky
             23..40,    bad|maniac,  Bronco
             36..50,    bad.*,       Espadas
-            51..78,    ,            Thorsten
+            := 100,    ,            Thorsten
             44..100,   !~ maniac,   Ojiisan
             > 100,     maniac.*,    Chester
             23..35,    .*rich,      Kerfelden
@@ -82,7 +118,7 @@ describe CSVDecision::Table do
             18..35,    maniac,        Adelsky
             23..40,    =~ bad|maniac, Bronco
             36..50,    =~ bad.*,      Espadas
-            51..78,    ,              Thorsten
+            ==100,     ,              Thorsten
             44..100,   !~ maniac,     Ojiisan
             > 100,     =~ maniac.*,   Chester
             23..35,    =~ .*rich,     Kerfelden
@@ -98,7 +134,7 @@ describe CSVDecision::Table do
             >= 18,    <= 35,   maniac,        Adelsky
             >= 23,    <= 40,   =~ bad|maniac, Bronco
             >= 36,    <= 50,   =~ bad.*,      Espadas
-            >= 51,    <= 78,   ,              Thorsten
+            == 100,   ,        ,              Thorsten
             >= 44,    <= 100,  != maniac,     Ojiisan
             > 100,    ,        =~ maniac.*,   Chester
             >= 23,    <= 35,   =~ .*rich,     Kerfelden
@@ -113,12 +149,12 @@ describe CSVDecision::Table do
             options = test[:options].merge(first_match: true)
             table = CSVDecision.parse(test[:data], options)
 
-            expect(table.send(method, age:  72)).to eq(salesperson: 'Thorsten')
+            expect(table.send(method, age: 100)).to eq(salesperson: 'Thorsten')
             expect(table.send(method, age:  25, trait: 'very rich')).to eq(salesperson: 'Kerfelden')
             expect(table.send(method, age:  25, trait: 'maniac')).to eq(salesperson: 'Adelsky')
             expect(table.send(method, age:  44, trait: 'maniac')).to eq(salesperson: 'Korolev')
             expect(table.send(method, age: 101, trait: 'maniacal')).to eq(salesperson: 'Chester')
-            expect(table.send(method, age:  45, trait: 'cheerful')).to eq(salesperson: 'Ojiisan')
+            expect(table.send(method, age:  44, trait: 'cheerful')).to eq(salesperson: 'Ojiisan')
             expect(table.send(method, age:  49, trait: 'bad')).to eq(salesperson: 'Espadas')
             expect(table.send(method, age:  40, trait: 'maniac')).to eq(salesperson: 'Bronco')
           end
@@ -127,7 +163,7 @@ describe CSVDecision::Table do
             options = test[:options].merge(first_match: false)
             table = CSVDecision.parse(test[:data], options)
 
-            expect(table.send(method, age:  72))
+            expect(table.send(method, age: 100))
               .to eq(salesperson: %w[Thorsten Ojiisan])
             expect(table.send(method, age:  25, trait: 'very rich'))
               .to eq(salesperson: 'Kerfelden')

data/spec/data/valid/simple_constants.csv

@@ -0,0 +1,5 @@
+in :constant,out :type
+:=nil,        NilClass
+==0,          Zero
+:=100.0,      100%
+,             Unrecognized

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csv_decision
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Brett Vickers
@@ -205,6 +205,7 @@ files:
 - lib/csv_decision/input.rb
 - lib/csv_decision/load.rb
 - lib/csv_decision/matchers.rb
+- lib/csv_decision/matchers/function.rb
 - lib/csv_decision/matchers/numeric.rb
 - lib/csv_decision/matchers/pattern.rb
 - lib/csv_decision/matchers/range.rb
@@ -218,6 +219,7 @@ files:
 - spec/csv_decision/decision_spec.rb
 - spec/csv_decision/input_spec.rb
 - spec/csv_decision/load_spec.rb
+- spec/csv_decision/matchers/function_spec.rb
 - spec/csv_decision/matchers/numeric_spec.rb
 - spec/csv_decision/matchers/pattern_spec.rb
 - spec/csv_decision/matchers/range_spec.rb
@@ -232,6 +234,7 @@ files:
 - spec/data/valid/empty.csv
 - spec/data/valid/options_in_file1.csv
 - spec/data/valid/options_in_file2.csv
+- spec/data/valid/simple_constants.csv
 - spec/data/valid/simple_example.csv
 - spec/data/valid/valid.csv
 - spec/spec_helper.rb
@@ -266,6 +269,7 @@ test_files:
 - spec/csv_decision/decision_spec.rb
 - spec/csv_decision/input_spec.rb
 - spec/csv_decision/load_spec.rb
+- spec/csv_decision/matchers/function_spec.rb
 - spec/csv_decision/matchers/numeric_spec.rb
 - spec/csv_decision/matchers/pattern_spec.rb
 - spec/csv_decision/matchers/range_spec.rb
@@ -280,6 +284,7 @@ test_files:
 - spec/data/valid/empty.csv
 - spec/data/valid/options_in_file1.csv
 - spec/data/valid/options_in_file2.csv
+- spec/data/valid/simple_constants.csv
 - spec/data/valid/simple_example.csv
 - spec/data/valid/valid.csv
 - spec/spec_helper.rb