RubyGems - csv_decision - Versions diffs - 0.0.3 → 0.0.4 - Mend

csv_decision 0.0.3 → 0.0.4

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 (87) hide show

checksums.yaml +4 -4
data/.codeclimate.yml +2 -0
data/.gitignore +2 -1
data/.travis.yml +2 -3
data/CHANGELOG.md +19 -1
data/README.md +49 -16
data/{benchmark.rb → benchmarks/rufus_decision.rb} +1 -1
data/csv_decision.gemspec +1 -1
data/doc/CSVDecision/CellValidationError.html +143 -0
data/doc/CSVDecision/Columns/Default.html +409 -0
data/doc/CSVDecision/Columns/Dictionary.html +410 -0
data/doc/CSVDecision/Columns/Entry.html +321 -0
data/doc/CSVDecision/Columns.html +476 -0
data/doc/CSVDecision/Constant.html +295 -0
data/doc/CSVDecision/Data.html +344 -0
data/doc/CSVDecision/Decide.html +434 -0
data/doc/CSVDecision/Decision.html +604 -0
data/doc/CSVDecision/Error.html +139 -0
data/doc/CSVDecision/FileError.html +143 -0
data/doc/CSVDecision/Function.html +229 -0
data/doc/CSVDecision/Header.html +520 -0
data/doc/CSVDecision/Input.html +305 -0
data/doc/CSVDecision/Load.html +225 -0
data/doc/CSVDecision/Matchers/Constant.html +242 -0
data/doc/CSVDecision/Matchers/Function.html +342 -0
data/doc/CSVDecision/Matchers/Matcher.html +325 -0
data/doc/CSVDecision/Matchers/Numeric.html +277 -0
data/doc/CSVDecision/Matchers/Pattern.html +600 -0
data/doc/CSVDecision/Matchers/Range.html +413 -0
data/doc/CSVDecision/Matchers/Symbol.html +280 -0
data/doc/CSVDecision/Matchers.html +1529 -0
data/doc/CSVDecision/Numeric.html +259 -0
data/doc/CSVDecision/Options.html +445 -0
data/doc/CSVDecision/Parse.html +270 -0
data/doc/CSVDecision/ScanRow.html +746 -0
data/doc/CSVDecision/Symbol.html +256 -0
data/doc/CSVDecision/Table.html +1115 -0
data/doc/CSVDecision.html +652 -0
data/doc/_index.html +410 -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 +264 -0
data/doc/file_list.html +56 -0
data/doc/frames.html +17 -0
data/doc/index.html +264 -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 +683 -0
data/doc/top-level-namespace.html +110 -0
data/lib/csv_decision/columns.rb +15 -12
data/lib/csv_decision/constant.rb +54 -0
data/lib/csv_decision/decide.rb +5 -5
data/lib/csv_decision/decision.rb +3 -1
data/lib/csv_decision/function.rb +32 -0
data/lib/csv_decision/header.rb +27 -18
data/lib/csv_decision/input.rb +11 -8
data/lib/csv_decision/matchers/constant.rb +18 -0
data/lib/csv_decision/matchers/function.rb +11 -44
data/lib/csv_decision/matchers/numeric.rb +5 -33
data/lib/csv_decision/matchers/pattern.rb +26 -11
data/lib/csv_decision/matchers/range.rb +21 -5
data/lib/csv_decision/matchers/symbol.rb +20 -0
data/lib/csv_decision/matchers.rb +85 -20
data/lib/csv_decision/numeric.rb +38 -0
data/lib/csv_decision/options.rb +36 -27
data/lib/csv_decision/parse.rb +46 -39
data/lib/csv_decision/scan_row.rb +19 -7
data/lib/csv_decision/symbol.rb +73 -0
data/lib/csv_decision/table.rb +24 -18
data/lib/csv_decision.rb +25 -18
data/spec/csv_decision/columns_spec.rb +1 -1
data/spec/csv_decision/constant_spec.rb +60 -0
data/spec/csv_decision/examples_spec.rb +119 -0
data/spec/csv_decision/matchers/function_spec.rb +48 -28
data/spec/csv_decision/matchers/numeric_spec.rb +4 -41
data/spec/csv_decision/matchers/range_spec.rb +31 -61
data/spec/csv_decision/matchers/symbol_spec.rb +65 -0
data/spec/csv_decision/options_spec.rb +14 -2
data/spec/csv_decision/parse_spec.rb +10 -0
data/spec/csv_decision/table_spec.rb +112 -6
data/spec/data/valid/simple_constants.csv +3 -3
metadata +62 -7
data/spec/csv_decision/simple_example_spec.rb +0 -75
/data/spec/{csv_decision.rb → csv_decision_spec.rb} +0 -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 Tue Dec 26 18:31:37 2017 by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.9.12 (ruby-2.3.0).
+</div>
+    </div>
+  </body>
+</html>

data/lib/csv_decision/columns.rb CHANGED Viewed

@@ -6,33 +6,35 @@
 module CSVDecision
   # Dictionary of all this table's columns - inputs, outputs etc.
   class Columns
-    # Value object used for column dictionary entries
+    # Value object to hold column dictionary entries.
     Entry = Struct.new(:name, :text_only)
-    # Value object used for any columns with defaults
-    Default = Struct.new(:name, :function, :default_if)
+    # TODO: 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.
+    # 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
+      # Input columns.
+      # @return [Hash{Integer=>Entry}] All input column dictionary entries.
       attr_accessor :ins
-      # Output columns
+      # Output columns.
+      # @return [Hash{Integer=>Entry}] All output column dictionary entries.
       attr_accessor :outs
-      # Input hash path - optional (planned feature)
-      attr_accessor :path
+      # TODO: Input hash path - optional (planned feature)
+      # attr_accessor :path
-      # Input columns with a default value (planned feature)
-      attr_accessor :defaults
+      # TODO: Input columns with a default value (planned feature)
+      # attr_accessor :defaults
       def initialize
         @ins = {}
         @outs = {}
-        @path = {}
-        @defaults = {}
+        # TODO: @path = {}
+        # TODO: @defaults = {}
       end
     end
@@ -59,6 +61,7 @@ module CSVDecision
     #   @dictionary.path
     # 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.

data/lib/csv_decision/constant.rb ADDED Viewed

@@ -0,0 +1,54 @@
+# 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
+  # Recognise constant expressions in table data cells.
+  module Constant
+    # Cell constant expression specified by prefixing the value with one of the three equality symbols.
+    EXPRESSION = Matchers.regexp("(?<operator>#{Matchers::EQUALS})\\s*(?<value>\\S.*)")
+    # rubocop: disable Lint/BooleanSymbol
+    # Non-numeric constants recognised by CSV Decision.
+    NON_NUMERIC = {
+      nil: nil,
+      true: true,
+      false: false
+    }.freeze
+    # rubocop: enable Lint/BooleanSymbol
+    # @param (see Matchers::Matcher#matches?)
+    # @return (see Matchers::Matcher#matches?)
+    def self.matches?(cell)
+      return false unless (match = EXPRESSION.match(cell))
+      proc = non_numeric?(match)
+      return proc if proc
+      numeric?(match)
+    end
+    def self.proc(function:)
+      Proc.with(type: :constant, function: function)
+    end
+    private_class_method :proc
+    def self.numeric?(match)
+      value = Matchers.to_numeric(match['value'])
+      return false unless value
+      proc(function: value)
+    end
+    private_class_method :numeric?
+    def self.non_numeric?(match)
+      name = match['value'].to_sym
+      return false unless NON_NUMERIC.key?(name)
+      proc(function: NON_NUMERIC[name])
+    end
+    private_class_method :non_numeric?
+  end
+end

data/lib/csv_decision/decide.rb CHANGED Viewed

@@ -8,11 +8,11 @@ module CSVDecision
   module Decide
     # Main method for making decisions.
     #
-    # @param table [CSVDecision::Table]
-    # @param input [Hash] - input hash (keys may or may not be symbolized)
-    # @param symbolize_keys [true, false] - set to true if keys are symbolized and it's
+    # @param table [CSVDecision::Table] Decision table.
+    # @param input [Hash] Input hash (keys may or may not be symbolized)
+    # @param symbolize_keys [true, false] 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]
+    # @return [Hash] Decision result.
     def self.decide(table:, input:, symbolize_keys:)
       # Parse and transform the hash supplied as input
       parsed_input = Input.parse(table: table, input: input, symbolize_keys: symbolize_keys)
@@ -37,7 +37,7 @@ module CSVDecision
     def self.eval_matcher(proc:, value:, hash:)
       function = proc.function
-      # A symbol expression just needs to be passed the input hash
+      # A symbol guard expression just needs to be passed the input hash
       return function[hash] if proc.type == :expression
       # All other procs can take one or two args

data/lib/csv_decision/decision.rb CHANGED Viewed

@@ -12,7 +12,9 @@ module CSVDecision
       # Relevant table attributes
       @first_match = table.options[:first_match]
       @outs = table.columns.outs
-      @outs_functions = table.outs_functions
+      # TODO: Planned feature
+      # @outs_functions = table.outs_functions
       # Partial result always includes the input hash for calculating output functions
       @partial_result = input[:hash].dup if @outs_functions

data/lib/csv_decision/function.rb ADDED Viewed

@@ -0,0 +1,32 @@
+# 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 recognise various function expressions
+  # TODO: fully implement
+  module Function
+    # 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>.*)"
+    private_constant :FUNCTION_CALL
+    FUNCTION_RE = Matchers.regexp(FUNCTION_CALL)
+    def self.matches?(cell)
+      match = FUNCTION_RE.match(cell)
+      return false unless match
+      # operator = match['operator']&.gsub(/\s+/, '')
+      # name = match['name'].to_sym
+      # args = match['args'].strip
+      # negate = match['negate'] == Matchers::NEGATE
+    end
+  end
+end

data/lib/csv_decision/header.rb CHANGED Viewed

@@ -6,32 +6,41 @@
 module CSVDecision
   # Parse the CSV file's header row. These methods are only required at table load time.
   module Header
-    # Column header looks like IN :col_name or cond:
+    # TODO: implement all column types
+    # COLUMN_TYPE = %r{
+    #   \A(?<type>in|out|in/text|out/text|set|set/nil|set/blank|path|guard|if)
+    #   \s*:\s*(?<name>\S?.*)\z
+    # }xi
+    # Column types recognise din the header row.
     COLUMN_TYPE = %r{
-      \A(?<type>in|out|in/text|out/text|set|set/nil|set/blank|path|cond|if)
+      \A(?<type>in|out|in/text|out/text)
       \s*:\s*(?<name>\S?.*)\z
     }xi
     # These column types do not need a name
-    COLUMN_TYPE_ANONYMOUS = Set.new(%i[path if cond]).freeze
+    # TODO: implement anonymous column types
+    # COLUMN_TYPE_ANONYMOUS = Set.new(%i[path if guard]).freeze
-    # More lenient than a Ruby method name -
-    # any spaces will have been replaced with underscores
+    # Regular expression string for a column name.
+    # More lenient than a Ruby method name - note any spaces will have been replaced with underscores.
     COLUMN_NAME = "\\w[\\w:/!?]*"
+    # Column name regular expression.
     COLUMN_NAME_RE = Matchers.regexp(COLUMN_NAME)
-    # Does this row contain a recognisable header cell?
+    # Check if the given row contains a recognisable header cell.
     #
-    # @param row [Array<String>] header row
-    # @return [Boolean] true if the row looks like a header
+    # @param row [Array<String>] Header row.
+    # @return [Boolean] Return true if the row looks like a header.
     def self.row?(row)
       row.find { |cell| cell.match(COLUMN_TYPE) }
     end
     # Strip empty columns from all data rows.
     #
-    # @param rows [Array<Array<String>>]
-    # @return [Array<Array<String>>] - data array after removing any empty columns and the
+    # @param rows [Array<Array<String>>] Data rows.
+    # @return [Array<Array<String>>] Data array after removing any empty columns and the
     #   header row.
     def self.strip_empty_columns(rows:)
       empty_cols = empty_columns?(row: rows.first)
@@ -43,8 +52,8 @@ module CSVDecision
     # Classify and build a dictionary of all input and output columns.
     #
-    # @param row [Array<String>] - the header row after removing any empty columns.
-    # @return [Hash<Hash>] - Column dictionary if a hash of hashes.
+    # @param row [Array<String>] The header row after removing any empty columns.
+    # @return [Hash<Hash>] Column dictionary is a hash of hashes.
     def self.dictionary(row:)
       dictionary = Columns::Dictionary.new
@@ -80,7 +89,9 @@ module CSVDecision
     def self.column_name(type:, name:)
       return format_column_name(name) if name.present?
-      return if COLUMN_TYPE_ANONYMOUS.member?(type)
+      # TODO: implement anonymous column types
+      # return if COLUMN_TYPE_ANONYMOUS.member?(type)
       raise CellValidationError, 'column name is missing'
     end
@@ -102,8 +113,9 @@ module CSVDecision
       when :'in/text'
         [:in, true]
-      when :cond
-        [:in, false]
+      # TODO: planned feature
+      # when :guard
+      #   [:in, false]
       when :'out/text'
         [:out, true]
@@ -143,9 +155,6 @@ module CSVDecision
       when :out
         dictionary.outs[index] = entry
-      else
-        raise "internal error - column type #{type} not recognised"
       end
       dictionary

data/lib/csv_decision/input.rb CHANGED Viewed

@@ -1,24 +1,27 @@
 # frozen_string_literal: true
-require 'ice_nine'
-require 'ice_nine/core_ext/object'
 # CSV Decision: CSV based Ruby decision tables.
 # Created December 2017 by Brett Vickers
 # See LICENSE and README.md for details.
 module CSVDecision
-  # Parse the input hash
+  # Parse the input hash.
   module Input
+    # @param (see Decide.decide)
+    # @return [Hash{Symbol => Hash{Symbol=>Object}, Hash{Integer=>Object}}]
+    #   Returns  a hash of two hashes:
+    #   * hash: either a copy with keys symbolized or the original input object
+    #   * scan_cols: Picks out the value in the input hash for each table input column.
+    #     Defaults to nil if the key is missing in the input hash.
     def self.parse(table:, input:, symbolize_keys:)
       validate(input)
       # For safety the default is to symbolize keys and make a copy of the hash.
-      # However, if this is turned off assume keys are symbolized
-      # TODO: Is it OK to mutate the hash in this case?
-      input = symbolize_keys ? input.deep_symbolize_keys : input
+      # However, if this is turned off then the keys must already symbolized.
+      input = symbolize_keys ? input.symbolize_keys : input
       parsed_input = parse_input(table: table, input: input)
+      # Freeze the copy of the input hash we just created.
       parsed_input[:hash].freeze if symbolize_keys
       parsed_input
@@ -33,7 +36,7 @@ module CSVDecision
     def self.parse_input(table:, input:)
       scan_cols = {}
-      # Does this table have any defaulted columns?
+      # TODO: Does this table have any defaulted columns?
       # defaulted_columns = table.columns[:defaults]
       table.columns.ins.each_pair do |col, column|

data/lib/csv_decision/matchers/constant.rb ADDED Viewed

@@ -0,0 +1,18 @@
+# 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
+  class Matchers
+    # Cell constant matcher - e.g., := true, = nil.
+    class Constant < Matcher
+      # @param (see Matchers::Matcher)
+      # @return (see Matchers::Matcher)
+      def matches?(cell)
+        CSVDecision::Constant.matches?(cell)
+      end
+    end
+  end
+end

data/lib/csv_decision/matchers/function.rb CHANGED Viewed

@@ -5,53 +5,20 @@
 # 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 Matchers
+    # Match cell against a function call
+    #   * no arguments - e.g., := present?
+    #   * with arguments - e.g., :=lookup?(:table)
+    # TODO: fully implement
     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 initialize(options = {})
+        @options = options
+      end
+      # @param (see Matchers::Matcher#matches?)
+      # @return (see Matchers::Matcher#matches?)
       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
+        CSVDecision::Function.matches?(cell)
       end
     end
   end

data/lib/csv_decision/matchers/numeric.rb CHANGED Viewed

@@ -5,41 +5,13 @@
 # See LICENSE and README.md for details.
 module CSVDecision
   # Methods to assign a matcher to data cells
-  module Matchers
-    # 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 Matchers
+    # Recognise numeric comparison expressions - e.g., +> 100+ or +!= 0+
     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 },
-        '<'  => 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
+      # @param (see Matchers::Matcher#matches?)
+      # @return (see Matchers::Matcher#matches?)
       def matches?(cell)
-        match = COMPARISON.match(cell)
-        return false unless match
-        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[comparator].curry[numeric_cell])
+        CSVDecision::Numeric.matches?(cell)
       end
     end
   end

data/lib/csv_decision/matchers/pattern.rb CHANGED Viewed

@@ -5,11 +5,14 @@
 # See LICENSE and README.md for details.
 module CSVDecision
   # Methods to assign a matcher to data cells
-  module Matchers
-    # Match cell against a regular expression pattern
+  class Matchers
+    # Match cell against a regular expression pattern - e.g., +=~ hot|col+ or +.*OPT.*+
     class Pattern < Matcher
-      EXPLICIT_COMPARISON = /\A(?<comparator>=~|!~|!=)\s*(?<value>\S.*)\z/
-      IMPLICIT_COMPARISON = /\A(?<comparator>=~|!~|!=)?\s*(?<value>\S.*)\z/
+      EXPLICIT_COMPARISON = Matchers.regexp("(?<comparator>=~|!~|!=)\\s*(?<value>\\S.*)")
+      private_constant :EXPLICIT_COMPARISON
+      IMPLICIT_COMPARISON = Matchers.regexp("(?<comparator>=~|!~|!=)?\\s*(?<value>\\S.*)")
+      private_constant :IMPLICIT_COMPARISON
       # rubocop: disable Style/DoubleNegation
       PATTERN_LAMBDAS = {
@@ -17,6 +20,7 @@ module CSVDecision
         '=~' => proc { |pattern, value| !!pattern.match(value) }.freeze,
         '!~' => proc { |pattern, value|  !pattern.match(value) }.freeze
       }.freeze
+      private_constant :PATTERN_LAMBDAS
       # rubocop: enable Style/DoubleNegation
       def self.regexp?(cell:, explicit:)
@@ -31,6 +35,7 @@ module CSVDecision
         parse(comparator: comparator, value: match['value'])
       end
+      private_class_method :regexp?
       def self.parse(comparator:, value:)
         return false if value.blank?
@@ -54,13 +59,8 @@ module CSVDecision
         '=~'
       end
-      def initialize(options = {})
-        # By default regexp's must have an explicit comparator
-        @regexp_explicit = !options[:regexp_implicit]
-      end
-      def matches?(cell)
-        comparator, value = Pattern.regexp?(cell: cell, explicit: @regexp_explicit)
+      def self.matches?(cell, regexp_explicit:)
+        comparator, value = regexp?(cell: cell, explicit: regexp_explicit)
         # We could not find a regexp pattern - maybe it's a simple string or something else?
         return false unless comparator
@@ -71,6 +71,21 @@ module CSVDecision
         Proc.with(type: :proc,
                   function: PATTERN_LAMBDAS[comparator].curry[pattern].freeze)
       end
+      # @param options [Hash{Symbol=>Object}] Used to determine the value of regexp_implicit:.
+      def initialize(options = {})
+        # By default regexp's must have an explicit comparator
+        @regexp_explicit = !options[:regexp_implicit]
+      end
+      # Recognise a regular expression pattern - e.g., +=~ on|off+ or +!~ OPT.*+.
+      # If the option regexp_implicit: true has been set, then cells may omit the +=~+ comparator so long as they
+      # contain non-word characters typically used in regular expressions such as +*+ and +.+.
+      # @param (see Matchers::Matcher#matches?)
+      # @return (see Matchers::Matcher#matches?)
+      def matches?(cell)
+        Pattern.matches?(cell, regexp_explicit: @regexp_explicit)
+      end
     end
   end
 end