json_logic_ruby 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ca5319a17275ae6b07caa25ed7fb14f8e3a507ac83d19a44c6b8bbc61783ced0
+  data.tar.gz: 1d728aecb2b1901441567e343c433ed45419b8da21dc6f070bdfb420a7a01609
+SHA512:
+  metadata.gz: 7d728d93db6bbda69b82bdb6915c1ff3cfe10f05ed5c0648d264b1b8ba287d115397abb3422beb0b852593ba7b476ac2f56c881a595f4b8a191d5f817b1a209e
+  data.tar.gz: e5245e733f1d727a58467f2d23a301273934eed585bdfc92f87df8cabc4b102ebcaa5efc1cc4a785380c86198a545dd9669b1af9024a5791c387994d6e304a9b

data/lib/json_logic/concerns/trackable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  module Trackable
+    attr_reader :tracker
+
+    def init_tracker(operator)
+      if @tracker.nil?
+        @tracker = Rule.new(operator)
+      elsif COMPLEX_OPERATORS.include?(operator)
+        @tracker = Rule.new(operator, @tracker)
+      end
+    end
+
+    def commit_rule_result!(var_name, 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
+      @tracker.add_data_point(var_name, operator, rules, data, result)
+      result
+    end
+  end
+end

data/lib/json_logic/evaluator.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  class Evaluator
+    include Trackable
+
+    def apply(rules, data = {})
+      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) }
+
+      operators(operator, values, rules, data)
+    end
+
+    def operators(operator, values, rules, data)
+      case operator
+      when 'var' then get_var_value(data, *values)
+      when 'missing' then missing(data, *values)
+      when 'missing_some' then missing_some(data, *values)
+      when 'map' then json_logic_map(data, *rules[operator])
+      else
+        raise("Unrecognized operation #{operator}") unless OPERATIONS.key?(operator)
+
+        execute_operation(operator, rules, data, *values)
+      end
+    end
+
+    # This method traverses `rules` (expected as a nested data structure
+    # composed of Hash and Array objects) to extract values associated
+    # with the key 'var'.
+    #
+    # It's a recursive method that digs into the structure to find 'var'.
+    #
+    # If `rules` is a Hash, it iterates through each key-value pair:
+    # - If the key is 'var', it appends the value to `vars`.
+    # - If the key is not 'var', it recurses into the value (if it's an Array or Hash).
+    #
+    # If `rules` is an Array, it iterates through each element,
+    # which should be a Hash or Array, and recurses through it.
+    #
+    # `vars`, is an optional accumulator Array to hold collected variables.
+    # It starts as an empty array if not provided.
+    #
+    # @param rules [Hash, Array] a data structure composed of nested Hashes
+    # and arrays that we want to extract values from.
+    #
+    # @param vars [Array] an optional accumulator array to hold collected variables.
+    #
+    # @return [Array] an array of extracted variable values.
+
+    def extract_vars(rules, vars = [])
+      if rules.is_a?(Hash)
+        rules.each do |key, value|
+          key == 'var' ? vars << value : extract_vars(value, vars)
+        end
+        return vars
+      end
+
+      rules.each { |rule| extract_vars(rule, vars) } and return vars if rules.is_a?(Array)
+
+      vars
+    end
+
+    # This method recursively searches through the `rules` data structure
+    # (composed of nested Hashes and Arrays) to find all values associated
+    # with a specified variable name.
+    #
+    # If `rules` is an Array:
+    # - It checks if the first element of the Array has the specified variable.
+    #   If so, it adds the second element of the Array (presumed to be the value
+    #   of the variable) to `values`.
+    # - If not, it recurses through each element of the Array.
+    #
+    # If `rules` is a Hash, it recurses through each value in the Hash.
+    #
+    # `values` is an optional accumulator Array used to collect the found variable values.
+    #
+    # @param rules [Hash, Array] a data structure composed of nested Hashes and
+    # Arrays to be searched through.
+    #
+    # @param var_name [String, Symbol] the name of the variable we want to find the values for.
+    #
+    # @param values [Array] an optional accumulator array to collect found values.
+    #
+    # @return [Array] an array of all values associated with the specified variable in `rules`.
+
+    def fetch_var_values(rules, var_name, values = [])
+      if rules.is_a?(Array)
+        return values << rules[1] if rule_has_var?(rules.first, var_name)
+
+        rules.each { |rule| fetch_var_values(rule, var_name, values) }
+        return values
+      end
+
+      if rules.is_a?(Hash)
+        rules.each { |_, rule| fetch_var_values(rule, var_name, values) }
+        return values
+      end
+
+      values
+    end
+
+    private
+
+    def rule_has_var?(rule, var_name)
+      rule.is_a?(Hash) && rule.key?('var') && rule['var'] == var_name
+    end
+
+    def json_logic_map(data, items_rule, map_rule)
+      items = apply(items_rule, data)
+
+      Array(items).map { |item| apply(map_rule, item) }
+    end
+
+    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)
+    end
+
+    # This method retrieves the value of a variable with a given name from the data structure.
+    #
+    # @param data [Hash] The data structure to search for the variable value.
+    # @param var_name [String] The name of the variable to retrieve.
+    # @return [String, Numeric, nil] The value of the variable if found, otherwise nil.
+
+    def get_var_value(data, var_name, default_value = nil)
+      var_name.to_s.split('.').each do |key|
+        data = data[key]
+      rescue TypeError
+        data = data[key.to_i]
+      end
+      data || default_value
+    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
+
+    def missing_some(data, min_required, args)
+      return [] if min_required < 1
+
+      missed_args, present_args = args.partition { |arg| get_var_value(data, arg).nil? }
+      present_args.length >= min_required ? [] : missed_args
+    end
+  end
+end

data/lib/json_logic/operations.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  COMPLEX_OPERATORS = %w[and or if].freeze
+
+  OPERATIONS = {
+    '==' => ->(a, b) { a == b },
+    '!=' => ->(a, b) { a != b },
+    '>' => ->(a, b) { to_comparable(a) > to_comparable(b) },
+    '>=' => ->(a, b) { to_comparable(a) >= to_comparable(b) },
+    '<' => ->(a, b) { to_comparable(a) < to_comparable(b) },
+    '<=' => lambda do |a, b, c = nil|
+      return to_comparable(a) <= to_comparable(b) if c.nil?
+
+      to_comparable(b).between?(to_comparable(a), to_comparable(c))
+    end,
+    '!' => ->(a) { json_logic_falsey(a) },
+    '!!' => ->(a) { json_logic_truthy(a) },
+    '%' => ->(a, b) { a % b },
+    'and' => ->(*args) { args.reduce(true) { |total, arg| total && arg } },
+    'or' => ->(*args) { args.reduce(false) { |total, arg| total || arg } },
+    '?:' => ->(a, b, c) { json_logic_truthy(a) ? b : c },
+    'if' => lambda do |*args|
+      (0...args.length - 1).step(2) do |i|
+        return args[i + 1] if json_logic_truthy(args[i])
+      end
+
+      args.length.odd? ? args[-1] : nil
+    end,
+    'log' => ->(a) { puts a },
+    'in' => ->(a, b) { b.respond_to?(:include?) ? b.include?(a) : false },
+    'cat' => ->(*args) { args.map(&:to_s).join },
+    '+' => ->(*args) { args.sum(&:to_f) },
+    '*' => ->(*args) { args.reduce(1) { |total, arg| total * arg.to_f } },
+    '-' => ->(*args) { args.length == 1 ? -args[0].to_f : args[0].to_f - args[1].to_f },
+    '/' => ->(a, b) { a.to_f / b },
+    'min' => ->(*args) { args.map { |arg| to_comparable(arg) }.min },
+    'max' => ->(*args) { args.map { |arg| to_comparable(arg) }.max },
+    'merge' => ->(*args) { args.flat_map { |arg| arg.is_a?(Array) ? arg.to_a : arg } },
+    'count' => ->(*args) { args.count { |a| a } }
+  }.freeze
+
+  private
+
+  COMPARATORS = {
+    NilClass => ->(_) { 0 },
+    FalseClass => ->(_) { 0 },
+    TrueClass => ->(_) { 1 },
+    Array => ->(arr) { arr.map { |item| to_comparable(item) } },
+    Hash => ->(hash) { hash.transform_values { |item| to_comparable(item) } },
+    Numeric => ->(num) { num.to_f }
+  }.freeze
+
+  def to_comparable(value)
+    comparator = COMPARATORS[value.class] || ->(val) { val }
+    comparator.call(value)
+  end
+
+  def json_logic_falsey(value)
+    case value
+    when NilClass, FalseClass, TrueClass
+      !value
+    when Numeric
+      value.zero?
+    when String, Array, Hash
+      value.empty?
+    else
+      false
+    end
+  end
+
+  def json_logic_truthy(value)
+    !json_logic_falsey(value)
+  end
+
+  module_function :to_comparable, :json_logic_falsey, :json_logic_truthy
+end

data/lib/json_logic/rule.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  class DataPoint
+    attr_accessor :name, :operation, :expected, :current, :result
+
+    def initialize(name, operation, expected, current, result)
+      @name = name
+      @operation = operation
+      @expected = expected
+      @current = current
+      @result = result
+    end
+
+    def report
+      "DATA: '#{name}' data:#{current || 'None'} #{operation} expected:#{expected_args},  RESULT = #{result}"
+    end
+
+    private
+
+    def expected_args
+      @expected.length == 3 ? [@expected.first, @expected.last] : @expected.last
+    end
+  end
+
+  class Rule
+    attr_accessor :name, :reasons, :result, :parent, :deep_level
+
+    def initialize(name, parent = nil)
+      @name = name
+      @result = false
+      @parent = parent
+      @reasons = []
+      @deep_level = 0
+      return if @parent.nil?
+
+      @deep_level = @parent.deep_level + 1
+      @parent.reasons << self
+    end
+
+    def add_data_point(var_name, operator, rules, data, result)
+      @result = result
+      current_data = data.is_a?(Hash) ? data[var_name] : data
+      @reasons << DataPoint.new(var_name, operator, rules[operator], current_data, result)
+    end
+
+    def report
+      report = "LOGIC: '#{name}', RESULT = #{result}\n"
+      report + reasons.map do |rule|
+        "#{Array.new(deep_level + 1, "\t").join} #{rule.report}"
+      end.join("\n")
+    end
+  end
+end

data/lib/json_logic/validator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module JsonLogic
+  class Validator
+    def json_logic_valid?(rules)
+      return validate_hash(rules) if rules.is_a?(Hash)
+      return validate_array(rules) if rules.is_a?(Array)
+
+      primitive?(rules)
+    end
+
+    private
+
+    def operator?(operator)
+      operators = JsonLogic::OPERATIONS.keys
+      operators.include?(operator)
+    end
+
+    def variable?(value)
+      return false unless value.is_a?(Hash)
+
+      var = value['var']
+      return false unless var
+
+      var.is_a?(String) || var.is_a?(Numeric) || var.nil?
+    end
+
+    def primitive?(value)
+      value.is_a?(String) || value.is_a?(Numeric) ||
+        value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(NilClass)
+    end
+
+    def validate_hash(hash)
+      hash.all? do |operator, value|
+        operator?(operator) && json_logic_valid?(value)
+      end
+    end
+
+    def validate_array(array)
+      array.all? do |value|
+        json_logic_valid?(value) || variable?(value) || primitive?(value)
+      end
+    end
+
+    def validate_var(value)
+      return false unless value.is_a?(Hash)
+
+      value.key?('var') && value.keys.count == 1
+    end
+  end
+end

data/lib/json_logic/version.rb

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

data/lib/json_logic.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+
+require_relative 'json_logic/version'
+require_relative 'json_logic/operations'
+require_relative 'json_logic/rule'
+require_relative 'json_logic/concerns/trackable'
+require_relative 'json_logic/evaluator'
+require_relative 'json_logic/validator'
+
+module JsonLogic
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: json_logic_ruby
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Volodymyr Stashchenko
+- Andriy Savka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: Build complex rules, serialize them as JSON, and execute them in ruby.
+  See https://jsonlogic.com
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/json_logic.rb
+- lib/json_logic/concerns/trackable.rb
+- lib/json_logic/evaluator.rb
+- lib/json_logic/operations.rb
+- lib/json_logic/rule.rb
+- lib/json_logic/validator.rb
+- lib/json_logic/version.rb
+homepage: https://github.com/useful-libs/json_logic
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Build complex rules, serialize them as JSON, and execute them in ruby.
+test_files: []