Merge pull request #4 from Kaligo/feature/logic-compiler

Add logic compiler

Author: imrefoldeskaligo

lib/core_ext/deep_fetch.rb

@@ -18,7 +18,11 @@ def deep_fetch(keys, default = nil)
 
 class Hash
   def deep_fetch(keys, default = nil)
-    value = dig(*keys) rescue default
+    value = keys.inject(self) do |memo, item|
+      memo.key?(item) ? memo[item] : memo[item.to_sym]
+    rescue
+      default
+    end
     value.nil? ? default : value  # value can be false (Boolean)
   end
 end

lib/core_ext/stringify_keys.rb

@@ -1,27 +1,60 @@
 require 'core_ext/deep_fetch'
-require 'core_ext/stringify_keys'
 require 'json_logic/truthy'
 require 'json_logic/operation'
 require 'json_logic/var_cache'
 
 module JSONLogic
-  def self.apply(logic, data)
-    if logic.is_a?(Array)
-      logic.map do |val|
-        apply(val, data)
+
+  def self.compile(logic)
+    klass = Class.new { define_method(:to_s) { logic.to_s }  }
+
+    case logic
+    when Array
+
+      compiled_values = logic.map { |item| JSONLogic.compile(item) }
+
+      klass.define_method(:evaluate) do |data|
+        compiled_values.map { |item| item.evaluate(data) }
       end
-    elsif !logic.is_a?(Hash)
-      # Pass-thru
-      logic
-    else
-      if data.is_a?(Hash)
-        data = data.stringify_keys
+
+    when Hash
+
+      operation, values = logic.first
+      values = [values] unless values.is_a?(Array)
+
+      compiled_values = values.map do |value|
+        JSONLogic.compile(value)
       end
-      data ||= {}
 
-      operator, values = operator_and_values_from_logic(logic)
-      Operation.perform(operator, values, data)
+      klass.define_method(:evaluate) do |data|
+        evaluated_values =
+          case operation
+          when 'filter', 'some', 'none', 'all', 'map'
+            input = compiled_values[0].evaluate(data)
+            params = input&.map { |item| compiled_values[1].evaluate(item) }
+            [input, params]
+          when 'reduce'
+            input = compiled_values[0].evaluate(data)
+            accumulator = compiled_values[2].evaluate(data)
+            [input, compiled_values[1], accumulator]
+          else
+            compiled_values.map { |item| item.evaluate(data) }
+          end
+
+        Operation.perform(operation, evaluated_values, data)
+      end
+
+    else
+
+      klass.define_method(:evaluate) { |_data| logic }
+
     end
+
+    klass.new
+  end
+
+  def self.apply(logic, data)
+    compile(logic).evaluate(data)
   end
 
   # Return a list of the non-literal data used. Eg, if the logic contains a {'var' => 'bananas'} operation, the result of

lib/json_logic.rb

@@ -18,7 +18,7 @@ class Operation
         end
       end,
       'missing' => ->(v, d) do
-        v.select do |val|
+        v.flatten.select do |val|
           keys = VarCache.fetch_or_store(val)
           d.deep_fetch(keys).nil?
         end
@@ -30,15 +30,15 @@ class Operation
       'some' => -> (v,d) do
         return false unless v[0].is_a?(Array)
 
-        v[0].any? do |val|
-          interpolated_block(v[1], val).truthy?
+        v[1].any? do |item|
+          item.truthy?
         end
       end,
       'filter' => -> (v,d) do
         return [] unless v[0].is_a?(Array)
 
-        v[0].select do |val|
-          interpolated_block(v[1], val).truthy?
+        v[0].select.with_index do |_, index|
+          v[1][index].truthy?
         end
       end,
       'substr' => -> (v,d) do
@@ -54,33 +54,28 @@ class Operation
          v[0][v[1]..limit]
       end,
       'none' => -> (v,d) do
+        return false unless v[0].is_a?(Array)
 
-        v[0].each do |val|
-          this_val_satisfies_condition = interpolated_block(v[1], val)
-          if this_val_satisfies_condition
-            return false
-          end
+        v[1].all? do |item|
+          item.falsy?
         end
-
-        return true
       end,
       'all' => -> (v,d) do
+        return false unless v[0].is_a?(Array)
         # Difference between Ruby and JSONLogic spec ruby all? with empty array is true
         return false if v[0].empty?
 
-        v[0].all? do |val|
-          interpolated_block(v[1], val)
+        v[1].all? do |item|
+          item.truthy?
         end
       end,
       'reduce' => -> (v,d) do
         return v[2] unless v[0].is_a?(Array)
-        v[0].inject(v[2]) { |acc, val| interpolated_block(v[1], { "current": val, "accumulator": acc })}
+        v[0].inject(v[2]) { |acc, val| v[1].evaluate({ "current" => val, "accumulator" => acc })}
       end,
       'map' => -> (v,d) do
         return [] unless v[0].is_a?(Array)
-        v[0].map do |val|
-          interpolated_block(v[1], val)
-        end
+        v[1]
       end,
       'if' => ->(v, d) {
         v.each_slice(2) do |condition, value|
@@ -115,42 +110,23 @@ class Operation
       '%'     => ->(v, d) { v.map(&:to_i).reduce(:%) },
       '^'     => ->(v, d) { v.map(&:to_f).reduce(:**) },
       'merge' => ->(v, d) { v.flatten },
-      'in'    => ->(v, d) { interpolated_block(v[1], d).include? v[0] },
+      'in'    => ->(v, d) { v[1].include?(v[0]) },
       'cat'   => ->(v, d) { v.map(&:to_s).join },
       'log'   => ->(v, d) { puts v }
     }
 
-    def self.interpolated_block(block, data)
-      # Make sure the empty var is there to be used in iterator
-      JSONLogic.apply(block, data.is_a?(Hash) ? data.merge({"": data}) : { "": data })
-    end
-
     def self.perform(operator, values, data)
-      # If iterable, we can only pre-fill the first element, the second one must be evaluated per element.
-      # If not, we can prefill all.
-
-      if is_iterable?(operator)
-        interpolated = [JSONLogic.apply(values[0], data), *values[1..-1]]
+      if is_standard?(operator)
+        LAMBDAS[operator.to_s].call(values, data)
       else
-        interpolated = values.map { |val| JSONLogic.apply(val, data) }
+        send(operator, values, data)
       end
-
-      interpolated.flatten!(1) if interpolated.size == 1           # [['A']] => ['A']
-
-      return LAMBDAS[operator.to_s].call(interpolated, data) if is_standard?(operator)
-      send(operator, interpolated, data)
     end
 
     def self.is_standard?(operator)
       LAMBDAS.key?(operator.to_s)
     end
 
-    # Determine if values associated with operator need to be re-interpreted for each iteration(ie some kind of iterator)
-    # or if values can just be evaluated before passing in.
-    def self.is_iterable?(operator)
-      ['filter', 'some', 'all', 'none', 'in', 'map', 'reduce'].include?(operator.to_s)
-    end
-
     def self.add_operation(operator, function)
       self.class.send(:define_method, operator) do |v, d|
         function.call(v, d)