csv_decision2 0.5.1

data/lib/csv_decision/matchers/guard.rb

@@ -0,0 +1,142 @@
+# 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
+  # Recognise expressions in table data cells.
+  # @api private
+  class Matchers
+    # Match cell against a column symbol guard expression -
+    # e.g., +>:column.present?+ or +:column == 100.0+.
+    class Guard < Matcher
+      # Column symbol expression - e.g., +>:column+ or +:!column+.
+      SYMBOL_RE =
+        Matchers.regexp("(?<negate>#{Matchers::NEGATE}?)\\s*:(?<name>#{Header::COLUMN_NAME})")
+      private_constant :SYMBOL_RE
+
+      # Column symbol guard expression - e.g., +>:column.present?+ or +:column == 100.0+.
+      GUARD_RE = Matchers.regexp(
+        "(?<negate>#{Matchers::NEGATE}?)\\s*" \
+        ":(?<name>#{Header::COLUMN_NAME})\\s*" \
+        "(?<method>!=|=~|!~|<=|>=|>|<|#{Matchers::EQUALS}|\\.)\\s*" \
+        "(?<param>\\S.*)"
+      )
+      private_constant :GUARD_RE
+
+      # Negated methods
+      NEGATION = { '=' => '!=', '==' => '!=', ':=' => '!=', '!=' => '=',
+                   '>' => '<=', '>=' => '<', '<' => '>=', '<=' => '>',
+                   '.' => '!.',
+                   '=~' => '!~', '!~' => '=~' }.freeze
+      private_constant :NEGATION
+
+      # Note: value has already been converted to an Integer or BigDecimal.
+      NUMERIC_COMPARE = {
+        '=='  => proc { |symbol, value, hash| Matchers.numeric(hash[symbol])   == value },
+        '!='  => proc { |symbol, value, hash| Matchers.numeric(hash[symbol])   != value },
+        '>'   => proc { |symbol, value, hash| Matchers.numeric(hash[symbol]) &.>  value },
+        '>='  => proc { |symbol, value, hash| Matchers.numeric(hash[symbol]) &.>= value },
+        '<'   => proc { |symbol, value, hash| Matchers.numeric(hash[symbol]) &.<  value },
+        '<='  => proc { |symbol, value, hash| Matchers.numeric(hash[symbol]) &.<= value }
+      }.freeze
+      private_constant :NUMERIC_COMPARE
+
+      def self.symbol_function(symbol, method, hash)
+        hash[symbol].respond_to?(method) && hash[symbol].send(method)
+      end
+      private_class_method :symbol_function
+
+      def self.regexp_match(symbol, value, hash)
+        return false unless value.is_a?(String)
+        data = hash[symbol]
+        data.is_a?(String) && Matchers.regexp(value).match?(data)
+      end
+      private_class_method :regexp_match
+
+      FUNCTION = {
+        '.'  => proc { |symbol, method, hash|  symbol_function(symbol, method, hash) },
+        '!.' => proc { |symbol, method, hash| !symbol_function(symbol, method, hash) },
+        '=~' => proc { |symbol, value, hash|  regexp_match(symbol, value, hash) },
+        '!~' => proc { |symbol, value, hash| !regexp_match(symbol, value, hash) }
+      }.freeze
+      private_constant :FUNCTION
+
+      SYMBOL_PROC = {
+        ':'  => proc { |symbol, hash|  hash[symbol] },
+        '!:' => proc { |symbol, hash| !hash[symbol] }
+      }.freeze
+      private_constant :SYMBOL_PROC
+
+      def self.non_numeric(method)
+        proc = FUNCTION[method]
+        return proc if proc
+
+        proc { |symbol, value, hash| Matchers.compare?(lhs: hash[symbol], compare: method, rhs: value) }
+      end
+      private_class_method :non_numeric
+
+      def self.method(match)
+        method = match['method']
+        match['negate'].present? ? NEGATION[method] : Matchers.normalize_operator(method)
+      end
+      private_class_method :method
+
+      def self.guard_proc(match)
+        method = method(match)
+        param =  match['param']
+
+        # If the parameter is a numeric value then use numeric compares rather than string compares.
+        if (value = Matchers.to_numeric(param))
+          return [NUMERIC_COMPARE[method], value]
+        end
+
+        # Process a non-numeric method where the param is just a string
+        [non_numeric(method), param]
+      end
+      private_class_method :guard_proc
+
+      def self.symbol_proc(cell)
+        match = SYMBOL_RE.match(cell)
+        return false unless match
+
+        method = match['negate'].present? ? '!:' : ':'
+        proc = SYMBOL_PROC[method]
+        symbol = match['name'].to_sym
+        Matchers::Proc.new(type: :guard, symbols: symbol, function: proc.curry[symbol].freeze)
+      end
+      private_class_method :symbol_proc
+
+      def self.symbol_guard(cell)
+        match = GUARD_RE.match(cell)
+        return false unless match
+
+        proc, value = guard_proc(match)
+        symbol = match['name'].to_sym
+        Matchers::Proc.new(type: :guard, symbols: symbol,
+                           function: proc.curry[symbol][value].freeze)
+      end
+      private_class_method :symbol_guard
+
+      # (see Matcher#matches?)
+      def self.matches?(cell)
+        proc = symbol_proc(cell)
+        return proc if proc
+
+        symbol_guard(cell)
+      end
+
+      # @param (see Matcher#matches?)
+      # @return (see Matcher#matches?)
+      def matches?(cell)
+        Guard.matches?(cell)
+      end
+
+      # @return (see Matcher#outs?)
+      def outs?
+        true
+      end
+    end
+  end
+end

data/lib/csv_decision/matchers/numeric.rb

@@ -0,0 +1,44 @@
+# 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
+  # Methods to assign a matcher to data cells.
+  # @api private
+  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/
+      private_constant :COMPARISON
+
+      # 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
+      private_constant :COMPARATORS
+
+      # (see Matcher#matches?)
+      def self.matches?(cell)
+        return false unless (match = COMPARISON.match(cell))
+        return false unless (numeric_cell = Matchers.to_numeric(match['value']))
+
+        comparator = match['comparator']
+        Matchers::Proc.new(type: :proc,
+                           function: COMPARATORS[comparator].curry[numeric_cell].freeze)
+      end
+
+      # (see Matcher#matches?)
+      def matches?(cell)
+        Numeric.matches?(cell)
+      end
+    end
+  end
+end

data/lib/csv_decision/matchers/pattern.rb

@@ -0,0 +1,94 @@
+# 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
+  # Methods to assign a matcher to data cells
+  # @api private
+  class Matchers
+    # Match cell against a regular expression pattern - e.g., +=~ hot|col+ or +.*OPT.*+
+    class Pattern < Matcher
+      EXPLICIT_COMPARISON = Matchers.regexp("(?<comparator>=~|!~|!=)\\s*(?<value>\\S.*)")
+      private_constant :EXPLICIT_COMPARISON
+
+      IMPLICIT_COMPARISON = Matchers.regexp("(?<comparator>=~|!~|!=)?\\s*(?<value>\\S.*)")
+      private_constant :IMPLICIT_COMPARISON
+
+      PATTERN_LAMBDAS = {
+        '!=' => proc { |pattern, value|  pattern != value }.freeze,
+        '=~' => proc { |pattern, value|  pattern.match?(value) }.freeze,
+        '!~' => proc { |pattern, value| !pattern.match?(value) }.freeze
+      }.freeze
+      private_constant :PATTERN_LAMBDAS
+
+      def self.regexp?(cell:, explicit:)
+        # By default a regexp pattern must use an explicit comparator
+        match = explicit ? EXPLICIT_COMPARISON.match(cell) : IMPLICIT_COMPARISON.match(cell)
+        return false if match.nil?
+
+        comparator = match['comparator']
+
+        # Comparator may be omitted if the regexp_explicit option is off.
+        return false if explicit && comparator.nil?
+
+        parse(comparator: comparator, value: match['value'])
+      end
+      private_class_method :regexp?
+
+      def self.parse(comparator:, value:)
+        return false if value.blank?
+
+        # We cannot do a regexp comparison against a symbol name.
+        return if value[0] == ':'
+
+        # If no comparator then the implicit option must be on
+        comparator = regexp_implicit(value) if comparator.nil?
+
+        [comparator, value]
+      end
+      private_class_method :parse
+
+      def self.regexp_implicit(value)
+        # rubocop: disable Style/CaseEquality
+        return unless /\W/ === value
+        # rubocop: enable Style/CaseEquality
+
+        # Make the implicit comparator explicit
+        '=~'
+      end
+      private_class_method :regexp_implicit
+
+      # @api private
+      # (see Pattern#matches)
+      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
+
+        # No need for a regular expression if we have simple string inequality
+        pattern = comparator == '!=' ? value : Matchers.regexp(value)
+
+        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:.
+      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 Matcher#matches?)
+      # @return (see Matcher#matches?)
+      def matches?(cell)
+        Pattern.matches?(cell, regexp_explicit: @regexp_explicit)
+      end
+    end
+  end
+end

data/lib/csv_decision/matchers/range.rb

@@ -0,0 +1,95 @@
+# 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
+  # Methods to assign a matcher to data cells.
+  # @api private
+  class Matchers
+    # Match cells against Ruby-like range expressions or their negation -
+    # e.g., +0...10+ or +!a..z+.
+    class Range < Matcher
+      # Match a table data cell string against a Ruby-like range expression.
+      #
+      # (see Matcher#matches?)
+      def self.matches?(cell)
+        if (match = NUMERIC_RANGE.match(cell))
+          return range_proc(match: match, coerce: :to_numeric)
+        end
+
+        if (match = ALNUM_RANGE.match(cell))
+          return range_proc(match: match)
+        end
+
+        false
+      end
+
+      # Range types are +..+ or +...+.
+      TYPE = '(\.\.\.|\.\.)'
+      private_constant :TYPE
+
+      # Range expression looks like +0...10+ or +a..z+.
+      # Can also be negated - e.g., +! 0..10+ or +!a..z+.
+      def self.range_re(value)
+        Matchers.regexp(
+          "(?<negate>#{NEGATE}?)\\s*(?<min>#{value})(?<type>#{TYPE})(?<max>#{value})"
+        )
+      end
+      private_class_method :range_re
+
+      NUMERIC_RANGE = range_re(Matchers::NUMERIC)
+      private_constant :NUMERIC_RANGE
+
+      # Alphanumeric range, e.g., +a...z+ or +!a..c+.
+      ALNUM_RANGE = range_re('[[:alnum:]][[:alnum:]]*')
+      private_constant :ALNUM_RANGE
+
+      # Coerce the string into a numeric value if required.
+      def self.convert(value, method)
+        method ? Matchers.send(method, value) : value
+      end
+      private_class_method :convert
+
+      def self.range(match, coerce: nil)
+        negate = match['negate'] == Matchers::NEGATE
+        min = convert(match['min'], coerce)
+        type = match['type']
+        max = convert(match['max'], coerce)
+
+        [negate, type == '...' ? min...max : min..max]
+      end
+      private_class_method :range
+
+      # Build the lambda proc for a numeric range.
+      def self.numeric_range(negate, range)
+        return ->(value) { range.include?(Matchers.numeric(value)) } unless negate
+        ->(value) { !range.include?(Matchers.numeric(value)) }
+      end
+      private_class_method :numeric_range
+
+      # Build the lambda proc for an alphanumeric range.
+      def self.alnum_range(negate, range)
+        return ->(value) { range.include?(value) } unless negate
+        ->(value) { !range.include?(value) }
+      end
+      private_class_method :alnum_range
+
+      def self.range_proc(match:, coerce: nil)
+        negate, range = range(match, coerce: coerce)
+        method = coerce ? :numeric_range : :alnum_range
+        function = Range.send(method, negate, range).freeze
+        Proc.new(type: :proc, function: function)
+      end
+      private_class_method :range_proc
+
+      # Ruby-like range expressions or their negation - e.g., +0...10+ or +!a..z+.
+      #
+      # @return (see Matcher#matches?)
+      def matches?(cell)
+        Range.matches?(cell)
+      end
+    end
+  end
+end

data/lib/csv_decision/matchers/symbol.rb

@@ -0,0 +1,149 @@
+# 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
+  # Recognise expressions in table data cells.
+  # @api private
+  class Matchers
+    # Match cell against a symbolic expression - e.g., :column, > :column.
+    # Can also call a Ruby method pn the column value - e.g, .blank? or !.blank?
+    class Symbol < Matcher
+      SYMBOL_COMPARATORS = "#{INEQUALITY}|>=|<=|<|>|#{EQUALS}"
+      private_constant :SYMBOL_COMPARATORS
+
+      # Column symbol comparison - e.g., > :column or != :column.
+      # Can also be a method call - e.g., .present? or .blank?
+      SYMBOL_COMPARE =
+        "(?<comparator>#{SYMBOL_COMPARATORS})?\\s*(?<type>[.:!])?(?<name>#{Header::COLUMN_NAME})"
+      private_constant :SYMBOL_COMPARE
+
+      # Symbol comparision regular expression.
+      SYMBOL_COMPARE_RE = Matchers.regexp(SYMBOL_COMPARE)
+      private_constant :SYMBOL_COMPARE_RE
+
+      # These procs compare one input hash value to another, and so do not coerce numeric values.
+      # Note that we do *not* check +hash.key?(symbol)+, so a +nil+ value will match a missing
+      # hash key.
+      EQUALITY = {
+        ':=' => proc { |symbol, value, hash| value == hash[symbol] },
+        '!=' => proc { |symbol, value, hash| value != hash[symbol] }
+      }.freeze
+      private_constant :EQUALITY
+
+      def self.compare_proc(sym)
+        proc do |symbol, value, hash|
+          Matchers.compare?(lhs: value, compare: sym, rhs: hash[symbol])
+        end
+      end
+      private_class_method :compare_proc
+
+      def self.value_method(value, method)
+        value.respond_to?(method) && value.send(method)
+      end
+      private_class_method :value_method
+
+      def self.method_proc(negate:)
+        if negate
+          proc { |symbol, value| !value_method(value, symbol) }
+        else
+          proc { |symbol, value|  value_method(value, symbol) }
+        end
+      end
+      private_class_method :method_proc
+
+      COMPARE = {
+        # Equality and inequality - create a lambda proc by calling with the actual column name
+        # symbol.
+        ':=' => ->(symbol) { EQUALITY[':='].curry[symbol].freeze },
+        '='  => ->(symbol) { EQUALITY[':='].curry[symbol].freeze },
+        '==' => ->(symbol) { EQUALITY[':='].curry[symbol].freeze },
+        '!=' => ->(symbol) { EQUALITY['!='].curry[symbol].freeze },
+        '!'  => ->(symbol) { EQUALITY['!='].curry[symbol].freeze },
+
+        # Comparisons - create a lambda proc by calling with the actual column name symbol.
+        '>'  => ->(symbol) { compare_proc(:'>').curry[symbol].freeze },
+        '>=' => ->(symbol) { compare_proc(:'>=').curry[symbol].freeze },
+        '<'  => ->(symbol) { compare_proc(:'<').curry[symbol].freeze },
+        '<=' => ->(symbol) { compare_proc(:'<=').curry[symbol].freeze },
+
+        # 0-arity Ruby method calls applied to an input column value.
+        '.'  => ->(symbol) { method_proc(negate: false).curry[symbol].freeze },
+        '!.' => ->(symbol) { method_proc(negate: true).curry[symbol].freeze }
+      }.freeze
+      private_constant :COMPARE
+
+      # E.g., > :col, we get comparator: >, name: col
+      def self.comparison(comparator:, name:)
+        function = COMPARE[comparator]
+        Matchers::Proc.new(type: :symbol, function: function[name], symbols: name)
+      end
+      private_class_method :comparison
+
+      # E.g., !.nil?, we get comparator: !, name: nil?, type: .
+      def self.method_call(comparator:, name:, type:)
+        negate = negated_comparator?(comparator: comparator)
+        return false if negate.nil?
+
+        # Check for double negation - e.g., != !blank?
+        negate = type == '!' ? !negate : negate
+        method_function(name: name, negate: negate)
+      end
+      private_class_method :method_call
+
+      def self.negated_comparator?(comparator:)
+        # Do we have an equality comparator?
+        if EQUALS_RE.match?(comparator)
+          false
+
+        # If do not have equality, do we have inequality?
+        elsif INEQUALITY_RE.match?(comparator)
+          true
+        end
+      end
+      private_class_method :negated_comparator?
+
+      # E.g., !.nil?, we get comparator: !, name: nil?
+      def self.method_function(name:, negate:)
+        # Allowed Ruby method names are a bit stricter than allowed decision table column names.
+        return false unless METHOD_NAME_RE.match?(name)
+
+        function = COMPARE[negate ? '!.' : '.']
+        Matchers::Proc.new(type: :proc, function: function[name])
+      end
+      private_class_method :method_function
+
+      def self.comparator_type(comparator:, name:, type:)
+        if type == ':'
+          comparison(comparator: comparator, name: name)
+
+        # Method call - e.g, .blank? or !.present?
+        # Can also take the forms: := .blank? or !=.present?
+        else
+          method_call(comparator: comparator, name: name, type: type || '.')
+        end
+      end
+      private_class_method :comparator_type
+
+      # @param (see Matchers::Matcher#matches?)
+      # @return (see Matchers::Matcher#matches?)
+      def self.matches?(cell)
+        return false unless (match = SYMBOL_COMPARE_RE.match(cell))
+
+        comparator = match['comparator']
+        type = match['type']
+        return false if comparator.nil? && type.nil?
+
+        comparator_type(comparator: comparator || '=', type: type, name: match['name'].to_sym)
+      end
+
+      # @param (see Matcher#matches?)
+      # @return (see Matcher#matches?)
+      def matches?(cell)
+        Symbol.matches?(cell)
+      end
+    end
+  end
+end