fix: Add support of complex not (!) operator (#18)

Author: Stashchenko

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    json_logic_ruby (0.2.3)
+    json_logic_ruby (0.2.4)
       activesupport (~> 7.0)
 
 GEM

lib/json_logic/concerns/trackable.rb

@@ -2,6 +2,8 @@
 
 module JsonLogic
   module Trackable
+    COMPLEX_OPERATORS = %w[and or if ! !! ?:].freeze
+
     attr_reader :tracker
 
     def init_tracker(operator)
@@ -12,15 +14,34 @@ def init_tracker(operator)
       end
     end
 
-    def commit_rule_result!(var_name, operator, data, rules, result)
+    def commit_rule_result!(operator, data, rules, result)
       if COMPLEX_OPERATORS.include?(operator)
         # change operand to parent & save result
         @tracker.result = result
         @tracker        = @tracker.parent unless @tracker.parent.nil?
         return result
       end
+      var_name = get_var_name(operator, rules)
       @tracker.add_data_point(var_name, operator, rules, data, result)
       result
     end
+
+    private
+
+    # This method retrieves the variable name from a hash of rules based on the given operator.
+    #   { "<=" : [ 25, { "var": "age" }, 75] }
+    #   { "<=" : [ { "var" : "age" }, 20 ] }
+    #
+    # @param operator [String] The operator for which to retrieve the variable name.
+    # @param rules [Hash] A hash containing rule data.
+    # @return [String, nil] The variable name if found, otherwise nil.
+
+    def get_var_name(operator, rules)
+      args = rules[operator]
+      index = COMPLEX_OPERATORS.exclude?(operator) && args.length == 3 ? 1 : 0
+      args.dig(index, 'var')
+    rescue TypeError
+      nil
+    end
   end
 end

lib/json_logic/evaluator.rb

@@ -5,12 +5,12 @@ class Evaluator
     include Trackable
 
     def apply(rules, data = {})
+      return rules.map { |val| apply(val, data) } if rules.is_a?(Array)
       return rules unless rules.is_a?(Hash)
 
       operator = rules.keys[0]
       init_tracker(operator)
-
-      values = operator == 'map' ? [] : Array(rules[operator]).map { |rule| apply(rule, data) }
+      values = operator == 'map' ? [] :  apply(rules[operator], data)
 
       operators(operator, values, rules, data)
     end
@@ -117,9 +117,7 @@ def json_logic_map(data, items_rule, map_rule)
 
     def execute_operation(operator, rules, data, *)
       result = OPERATIONS[operator].call(*)
-      var_name = get_var_name(operator, rules)
-
-      commit_rule_result!(var_name, operator, data, rules, result)
+      commit_rule_result!(operator, data, rules, result)
     end
 
     # This method retrieves the value of a variable with a given name from the data structure.
@@ -137,22 +135,6 @@ def get_var_value(data, var_name, default_value = nil)
       data.nil? ? default_value : data
     end
 
-    # This method retrieves the variable name from a hash of rules based on the given operator.
-    #   { "<=" : [ 25, { "var": "age" }, 75] }
-    #   { "<=" : [ { "var" : "age" }, 20 ] }
-    #
-    # @param operator [String] The operator for which to retrieve the variable name.
-    # @param rules [Hash] A hash containing rule data.
-    # @return [String, nil] The variable name if found, otherwise nil.
-
-    def get_var_name(operator, rules)
-      args = rules[operator]
-      index = COMPLEX_OPERATORS.exclude?(operator) && args.length == 3 ? 1 : 0
-      args.dig(index, 'var')
-    rescue TypeError
-      nil
-    end
-
     def missing(data, *args)
       args.select { |arg| get_var_value(data, arg).nil? }
     end

lib/json_logic/operations.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module JsonLogic
-  COMPLEX_OPERATORS = %w[and or if].freeze
-
   OPERATIONS = {
     '==' => ->(a, b) { a == b },
     '!=' => ->(a, b) { a != b },

lib/json_logic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JsonLogic
-  VERSION = '0.2.3'
+  VERSION = '0.2.4'
 end

spec/json_logic/evaluator_spec.rb

@@ -2,7 +2,9 @@
 
 RSpec.describe JsonLogic::Evaluator do
   describe '#apply' do
-    subject(:evaluator) { described_class.new.apply(rules, data) }
+    subject(:evaluator) { logic.apply(rules, data) }
+
+    let(:logic) { described_class.new }
 
     context 'with var' do
       let(:rules) { { 'var' => var } }
@@ -152,6 +154,122 @@
 
       it { is_expected.to eq(result) }
     end
+
+    context 'when not(!)' do
+      context 'when not between' do
+        let(:rules) { { '!' => { '<=' => [70, { 'var' => 'age' }, 75] } } }
+
+        context 'when main part is false' do
+          let(:data) { { 'age' => 69 } }
+
+          it 'returns and tracks true' do
+            expect(evaluator).to be(true)
+            expect(logic.tracker.result).to be(true)
+          end
+        end
+
+        context 'when main part is true' do
+          let(:data) { { 'age' => 72 } }
+
+          it 'returns and tracks false' do
+            expect(evaluator).to be(false)
+            expect(logic.tracker.result).to be(false)
+          end
+        end
+      end
+
+      context 'when not one of (select not any in)' do
+        context 'with string' do
+          let(:rules) { { '!' => { 'in' => [{ 'var' => 'drink' }, 'sell cola'] } } }
+
+          context 'when main part is false' do
+            let(:data) { { 'drink' => 'beer' } }
+
+            it 'returns and tracks true' do
+              expect(evaluator).to be(true)
+              expect(logic.tracker.result).to be(true)
+            end
+          end
+
+          context 'when main part is true' do
+            let(:data) { { 'drink' => 'cola' } }
+
+            it 'returns and tracks false' do
+              expect(evaluator).to be(false)
+              expect(logic.tracker.result).to be(false)
+            end
+          end
+        end
+
+        context 'with array' do
+          let(:rules) { { '!' => { 'in' => [{ 'var' => 'drink' }, %w[cola juice]] } } }
+
+          context 'when main part is false' do
+            let(:data) { { 'drink' => 'beer' } }
+
+            it 'returns and tracks true' do
+              expect(evaluator).to be(true)
+              expect(logic.tracker.result).to be(true)
+            end
+          end
+
+          context 'when main part is true' do
+            let(:data) { { 'drink' => 'cola' } }
+
+            it 'returns and tracks false' do
+              expect(evaluator).to be(false)
+              expect(logic.tracker.result).to be(false)
+            end
+          end
+        end
+      end
+
+      context 'when does not contain any of (not like)' do
+        context 'with string' do
+          let(:rules) { { '!' => { 'in' => ['ol', { 'var' => 'drink' }] } } }
+
+          context 'when main part is false' do
+            let(:data) { { 'drink' => 'juice' } }
+
+            it 'returns and tracks true' do
+              expect(evaluator).to be(true)
+              expect(logic.tracker.result).to be(true)
+            end
+          end
+
+          context 'when main part is true' do
+            let(:data) { { 'drink' => 'cola' } }
+
+            it 'returns and tracks false' do
+              expect(evaluator).to be(false)
+              expect(logic.tracker.result).to be(false)
+            end
+          end
+        end
+
+        context 'with array' do
+          let(:rules) { { '!' => { 'in' => ['beer', { 'var' => 'drinks' }] } } }
+
+          context 'when main part is false' do
+            let(:data) { { 'drinks' => %w[cola juice] } }
+
+            it 'returns and tracks true' do
+              expect(evaluator).to be(true)
+              expect(logic.tracker.result).to be(true)
+            end
+          end
+
+          context 'when main part is true' do
+            let(:data) { { 'drinks' => %w[beer cola] } }
+
+            it 'returns and tracks false' do
+              expect(evaluator).to be(false)
+              expect(logic.tracker.result).to be(false)
+            end
+          end
+        end
+      end
+    end
   end
 
   describe '#get_var_name' do
@@ -308,7 +426,7 @@
   end
 
   describe '#fetch_var_values' do
-    subject { described_class.new.send(:fetch_var_values, rules, var_name) }
+    subject { described_class.new.fetch_var_values(rules, var_name) }
 
     context 'when variable present' do
       let(:rules) do