consolidate all comparison operations

Author: kbrock

lib/floe/workflow/choice_rule/data.rb

@@ -4,21 +4,38 @@ module Floe
   class Workflow
     class ChoiceRule
       class Data < Floe::Workflow::ChoiceRule
-        COMPARE_KEYS = %w[IsNull IsPresent IsNumeric IsString IsBoolean IsTimestamp String Numeric Boolean Timestamp].freeze
+        OPERATIONS = {"Equals" => :==, "LessThan" => :<, "GreaterThan" => :>, "LessThanEquals" => :<=, "GreaterThanEquals" => :>=}.freeze
+        TYPES = %w[String Numeric Boolean Timestamp].freeze
+        COMPARE_RULE = /^(Is)?(#{TYPES.join("|")}|Null|Present)(#{OPERATIONS.keys.join("|")}|Matches)?(Path)?$/.freeze
 
-        attr_reader :compare_key
+        attr_reader :compare_key, :ref, :path
 
         def initialize(*)
           super
-          @compare_key = payload.keys.detect { |key| key.match?(/^(#{COMPARE_KEYS.join("|")})/) }
+          payload.each do |key, value|
+            is, type, operator, @path = COMPARE_RULE.match(key)&.captures
+            if is
+              # e.g.: IsTypeGreaterThan is not valid
+              @compare_key = "#{is}#{type}" unless operator || path
+              break
+            elsif operator == "Matches"
+              # only MatchesString is valid
+              @compare_key = "#{type}#{operator}" unless type != "String" || path
+              @ref = value
+              break
+            elsif operator
+              # e.g.: NullGreaterThan not valid
+              @compare_key = OPERATIONS[operator] unless %w[Null Present].include?(type)
+              @ref = value
+              break
+            end
+          end
 
-          raise Floe::InvalidWorkflowError, "Data-test Expression Choice Rule must have a compare key" if @compare_key.nil?
+          raise Floe::InvalidWorkflowError, "Data-test Expression Choice Rule must have a valid compare key" unless compare_key
         end
 
         def true?(context, input)
           lhs = variable_value(context, input)
-          rhs = compare_value(context, input)
-          return false unless valid?(lhs)
 
           case compare_key
           when "IsNull" then is_null?(lhs)
@@ -27,31 +44,12 @@ def true?(context, input)
           when "IsString" then is_string?(lhs)
           when "IsBoolean" then is_boolean?(lhs)
           when "IsTimestamp" then is_timestamp?(lhs)
-          when "StringEquals", "StringEqualsPath",
-               "NumericEquals", "NumericEqualsPath",
-               "BooleanEquals", "BooleanEqualsPath",
-               "TimestampEquals", "TimestampEqualsPath"
-            lhs == rhs
-          when "StringLessThan", "StringLessThanPath",
-               "NumericLessThan", "NumericLessThanPath",
-               "TimestampLessThan", "TimestampLessThanPath"
-            lhs < rhs
-          when "StringGreaterThan", "StringGreaterThanPath",
-               "NumericGreaterThan", "NumericGreaterThanPath",
-               "TimestampGreaterThan", "TimestampGreaterThanPath"
-            lhs > rhs
-          when "StringLessThanEquals", "StringLessThanEqualsPath",
-               "NumericLessThanEquals", "NumericLessThanEqualsPath",
-               "TimestampLessThanEquals", "TimestampLessThanEqualsPath"
-            lhs <= rhs
-          when "StringGreaterThanEquals", "StringGreaterThanEqualsPath",
-               "NumericGreaterThanEquals", "NumericGreaterThanEqualsPath",
-               "TimestampGreaterThanEquals", "TimestampGreaterThanEqualsPath"
-            lhs >= rhs
           when "StringMatches"
-            lhs.match?(Regexp.escape(rhs).gsub('\*', '.*?'))
+            rhs = compare_value(context, input)
+            !lhs.nil? && lhs.match?(Regexp.escape(rhs).gsub('\*', '.*?'))
           else
-            raise Floe::InvalidWorkflowError, "Invalid choice [#{compare_key}]"
+            rhs = compare_value(context, input)
+            !lhs.nil? && lhs.send(compare_key, rhs)
           end
         end
 
@@ -82,6 +80,8 @@ def is_boolean?(value) # rubocop:disable Naming/PredicateName
         end
 
         def is_timestamp?(value) # rubocop:disable Naming/PredicateName
+          return false if value.nil?
+
           require "date"
 
           DateTime.rfc3339(value)
@@ -91,7 +91,7 @@ def is_timestamp?(value) # rubocop:disable Naming/PredicateName
         end
 
         def compare_value(context, input)
-          compare_key.end_with?("Path") ? Path.value(payload[compare_key], context, input) : payload[compare_key]
+          path ? Path.value(ref, context, input) : ref
         end
       end
     end

spec/workflow/choice_rule_spec.rb

@@ -88,7 +88,7 @@
         let(:input) { {"foo" => "bar"} }
 
         it "raises an exception" do
-          expect { subject }.to raise_exception(Floe::InvalidWorkflowError, "Data-test Expression Choice Rule must have a compare key")
+          expect { subject }.to raise_exception(Floe::InvalidWorkflowError, "Data-test Expression Choice Rule must have a valid compare key")
         end
       end