csv_decision 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7238268643ad9dc69c91b0367550cd0ed2577b7d
-  data.tar.gz: d00d7a55a444b8026cb2bf477ce2812f16c2084d
+  metadata.gz: 4fc2bc37813bc6b1bf8cff959e559b808dc5125b
+  data.tar.gz: 75446892df8690d268627583c46df139b0fea96c
 SHA512:
-  metadata.gz: 89b76ce96dd906ab748158e6a96bb0f02e40abf6b4df4a5fafa5809dac1663a1b7ea97cbbc1cdfad7e10456e5b78b3e674e9e2032dcd24ac6009d8dcc8467b82
-  data.tar.gz: bde8179729614e89c2fa5fa5861e5ca55fe34a2038b752e3d4e27968f9eb83fb8a5979d18bd5353089482e54315355190e28792a1008618d169267df15a7790c
+  metadata.gz: 2def585d31f8dc19baa761c9407520b74be312da434f3521fc7e27c64bf035572c1f174b7271a66159f0746253897681735f0102580ec25479eba5401fb21725
+  data.tar.gz: 27084f128c9ccf26dd81b932e9f9498a165dca08530c9c064f862267ceaab147ded8918bea1a8d037c7ffd5ea30368e7cf4ce3e024485379cabe7988201dcd45

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## v0.4.1, 10 February 2018.
+*Additions*
+- For consistency, input columns may now use the form `!nil?` to negate 0-arity Ruby methods.
+(Typical SME users can be somewhat lax with syntax.)
+
 ## v0.4.0, 28 January 2018.
 *Additions*
 - Input columns may now use 0-arity Ruby methods to implement conditional logic.

data/README.md

@@ -20,10 +20,10 @@ producing a decision as an output hash.
  
 Typical "business logic" is notoriously illogical - full of corner cases and one-off 
 exceptions. 
-A decision table can express data-based decisions in a way that comes more naturally 
-to subject matter experts, who typically prefer spreadsheet models. 
-Business logic may then be encapsulated, avoiding the need to write tortuous 
-conditional expressions in Ruby that draw the ire of `rubocop` and its ilk.
+A decision table can express data-based decisions in a way that comes naturally 
+to subject matter experts, who typically use spreadsheet models. 
+Business logic can be encapsulated in a table, avoiding the need for tortuous conditional 
+expressions.
 
 This gem and the examples below take inspiration from 
 [rufus/decision](https://github.com/jmettraux/rufus-decision).
@@ -75,7 +75,7 @@ the world, except for `America` and `Europe`, *must* come after his colleagues
 `Charlie` and `Donald`. `Zach` has been placed last, catching all the input combos
 not matching any other row.
 
-Here is the example as code:
+Here's the example as code:
  
  ```ruby
   # Valid CSV string
@@ -127,7 +127,7 @@ Complete documentation of all table parameters is in the code - see
  * Either returns the first matching row as a hash (default), or accumulates all matches as an 
  array of hashes (i.e., `parse` option `first_match: false` or CSV file option `accumulate`).
  * Fast decision-time performance (see `benchmarks` folder). Automatically indexes all 
- text-only columns that do not contain any empty strings.
+ constants-only columns that do not contain any empty strings.
  * In addition to simple strings, `csv_decision` can match basic Ruby constants (e.g., `=nil`), 
  regular expressions (e.g., `=~ on|off`), comparisons (e.g., `> 100.0` ) and 
  Ruby-style ranges (e.g., `1..10`)
@@ -198,7 +198,8 @@ may be simplified to:
  ```
 These comparison operators are also supported: `!=`, `>`, `>=`, `<`, `<=`. 
 In addition, you can also apply a Ruby 0-arity method - e.g., `.present?` or `.nil?`. Negation is
-also supported - e.g., `!.nil?`.
+also supported - e.g., `!.nil?`. Note that `.nil?` can also be written as `:= nil?`, and `!.nil?`
+as `:= !nil?`, depending on preference.
 
 For more simple examples see `spec/csv_decision/examples_spec.rb`.
 

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.4.0'
+  spec.version       = '0.4.1'
   spec.authors       = ['Brett Vickers']
   spec.email         = ['brett@phillips-vickers.com']
   spec.description   = 'CSV based Ruby decision tables.'

data/lib/csv_decision/matchers/constant.rb

@@ -43,8 +43,7 @@ module CSVDecision
       private_class_method :proc
 
       def self.numeric?(match)
-        value = Matchers.to_numeric(match['value'])
-        return false unless value
+        return false unless (value = Matchers.to_numeric(match['value']))
 
         proc(function: value)
       end

data/lib/csv_decision/matchers/guard.rb

@@ -69,20 +69,11 @@ module CSVDecision
       }.freeze
       private_constant :SYMBOL_PROC
 
-      def self.compare?(lhs:, compare:, rhs:)
-        # Is the rhs the same class or a superclass of lhs, and does rhs respond to the
-        # compare method?
-        return lhs.send(compare, rhs) if lhs.is_a?(rhs.class) && rhs.respond_to?(compare)
-
-        nil
-      end
-      private_class_method :compare?
-
       def self.non_numeric(method)
         proc = FUNCTION[method]
         return proc if proc
 
-        proc { |symbol, value, hash| compare?(lhs: hash[symbol], compare: method, rhs: value) }
+        proc { |symbol, value, hash| Matchers.compare?(lhs: hash[symbol], compare: method, rhs: value) }
       end
       private_class_method :non_numeric
 

data/lib/csv_decision/matchers/numeric.rb

@@ -27,11 +27,8 @@ module CSVDecision
 
       # (see Matcher#matches?)
       def self.matches?(cell)
-        match = COMPARISON.match(cell)
-        return false unless match
-
-        numeric_cell = Matchers.to_numeric(match['value'])
-        return false unless numeric_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,

data/lib/csv_decision/matchers/pattern.rb

@@ -41,7 +41,6 @@ module CSVDecision
         return false if value.blank?
 
         # We cannot do a regexp comparison against a symbol name.
-        # (Maybe we should add this feature?)
         return if value[0] == ':'
 
         # If no comparator then the implicit option must be on

data/lib/csv_decision/matchers/symbol.rb

@@ -17,7 +17,7 @@ module CSVDecision
       # 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})"
+        "(?<comparator>#{SYMBOL_COMPARATORS})?\\s*(?<type>[.:!])?(?<name>#{Header::COLUMN_NAME})"
       private_constant :SYMBOL_COMPARE
 
       # Symbol comparision regular expression.
@@ -33,8 +33,10 @@ module CSVDecision
       }.freeze
       private_constant :EQUALITY
 
-      def self.compare_proc(compare)
-        proc { |symbol, value, hash| compare?(lhs: value, compare: compare, rhs: hash[symbol]) }
+      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
 
@@ -73,14 +75,6 @@ module CSVDecision
       }.freeze
       private_constant :COMPARE
 
-      def self.compare?(lhs:, compare:, rhs:)
-        # Is the rhs a superclass of lhs, and does rhs respond to the compare method?
-        return lhs.public_send(compare, rhs) if lhs.is_a?(rhs.class) && rhs.respond_to?(compare)
-
-        false
-      end
-      private_class_method :compare?
-
       # E.g., > :col, we get comparator: >, name: col
       def self.comparison(comparator:, name:)
         function = COMPARE[comparator]
@@ -88,16 +82,29 @@ module CSVDecision
       end
       private_class_method :comparison
 
-      # E.g., !.nil?, we get comparator: !, name: nil?
-      def self.method_call(comparator:, name:)
-        equality = EQUALS_RE.match?(comparator)
-        inequality = !equality && INEQUALITY_RE.match?(comparator)
-        return false unless equality || inequality
+      # 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?
 
-        method_function(name: name, negate: inequality)
+        # 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.
@@ -108,22 +115,29 @@ module CSVDecision
       end
       private_class_method :method_function
 
-      # @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'] || '='
-        name = match['name'].to_sym
-        if match['type'] == ':'
+      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)
+          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?)

data/lib/csv_decision/matchers.rb

@@ -75,14 +75,14 @@ module CSVDecision
     # Symbols used for inequality
     INEQUALITY = '!=|!'
 
-    # Match string for inequality
+    # Match Regexp for inequality
     INEQUALITY_RE = regexp(INEQUALITY)
 
     # Equality, cell constants and functions specified by prefixing the value with
     # one of these 3 symbols.
     EQUALS = '==|:=|='
 
-    # Match string for equality
+    # Match Regexp for equality
     EQUALS_RE = regexp(EQUALS)
 
     # Method names are stricter than CSV column names.
@@ -124,6 +124,20 @@ module CSVDecision
       BigDecimal(value.chomp('.'))
     end
 
+    # Compare one object with another if they both respond to the compare method.
+    #
+    # @param lhs [Object]
+    # @param compare [Object]
+    # @param rhs [Object]
+    # @return [nil, Boolean]
+    def self.compare?(lhs:, compare:, rhs:)
+      # Is the rhs the same class or a superclass of lhs, and does rhs respond to the
+      # compare method?
+      return lhs.send(compare, rhs) if lhs.is_a?(rhs.class) && rhs.respond_to?(compare)
+
+      nil
+    end
+
     # Parse the supplied input columns for the row supplied using an array of matchers.
     #
     # @param columns [Hash{Integer=>Columns::Entry}] Input columns hash.

data/spec/csv_decision/matchers/symbol_spec.rb

@@ -42,7 +42,7 @@ describe CSVDecision::Matchers::Symbol do
         { cell:  '<=:col', value:  0,  hash: { col:  1 },  result: true },
         { cell:  '<=:col', value:  1,  hash: { col:  0 },  result: false },
         { cell:  '<=:col', value:  1,  hash: { col:  1 },  result: true },
-        { cell:  '<=:col', value: '1', hash: { col:  1 },  result: false },
+        { cell:  '<=:col', value: '1', hash: { col:  1 },  result: nil },
         { cell:  '<=:col', value: '1', hash: { col: '1' }, result: true },
       ]
       examples.each do |ex|
@@ -55,7 +55,7 @@ describe CSVDecision::Matchers::Symbol do
     end
 
     context 'does not match a function' do
-      data = ['1', 'abc', 'abc.*def', '-1..1', '0...3', ':= false', ':= lookup?']
+      data = ['1', 'abc', 'abc.*def', '-1..1', '0...3', ':= false()', ':= lookup?()']
 
       data.each do |cell|
         it "cell #{cell} is not a function" do

data/spec/csv_decision/table_spec.rb

@@ -568,10 +568,10 @@ describe CSVDecision::Table do
             != .present?, ,           integer,  none,      :=nil
             =.present?,   ,           integer,  one,       :=1
             ==.blank?,    ,           integer,  one,       :=nil
-            ,             .present?,  string,   none,      0
+            ,             != !blank?, string,   none,      0
             .blank?,      ,           string,   none,      :=nil
             ,             !.blank?,   string,   one,       1
-            .blank?,      ,           string,   one,       :=nil
+            !present?,    ,           string,   one,       :=nil
           DATA
         },
         { example: 'evaluates multi-column index CSV file',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csv_decision
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Brett Vickers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-28 00:00:00.000000000 Z
+date: 2018-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport