overule 0.1.0

data/lib/overule/condition.rb

@@ -0,0 +1,40 @@
+module Overule
+  # Evaluates conditions defined in rules against a given context
+  # Conditions are used to determine whether actions should be executed
+  # based on the state of variables in the context
+  class Condition
+    NUMERIC_DATATYPES = %w[number integer float decimal].freeze
+    ORDERING_OPS      = %w[gt lt gte lte range].freeze
+
+    def self.evaluate(conditions, context)
+      return [] if conditions.empty?
+
+      conditions.map do |condition|
+        actual   = context.get(condition["var"])
+        expected = condition["value"]
+        actual, expected = coerce(actual, expected, condition["datatype"], condition["op"])
+
+        Operator.operate(condition["op"], actual, expected)
+      end
+    end
+
+    # Coerce numeric strings before ordering comparisons so that
+    # "1220000" > "2000000" doesn't compare lexically.
+    def self.coerce(actual, expected, datatype, op)
+      return [actual, expected] unless ORDERING_OPS.include?(op)
+      return [actual, expected] unless NUMERIC_DATATYPES.include?(datatype)
+
+      [to_number(actual), to_number(expected)]
+    end
+
+    def self.to_number(value)
+      return value if value.is_a?(Numeric)
+      return value.map { |v| to_number(v) } if value.is_a?(Array)
+      return nil if value.nil?
+
+      Float(value.to_s)
+    rescue ArgumentError, TypeError
+      value
+    end
+  end
+end

data/lib/overule/configuration.rb

@@ -0,0 +1,75 @@
+require "active_support/security_utils"
+
+module Overule
+  # Host-app configuration for the Overule gem. Populate via the initializer
+  # the install generator drops at `config/initializers/overule.rb`, or call
+  # `Overule.configure { |c| ... }` directly from non-Rails code.
+  class Configuration
+    SUPPORTED_ORMS = %i[active_record mongoid].freeze
+
+    attr_reader   :orm
+    attr_accessor :actor_proc,
+                  :http_basic_auth,
+                  :http_basic_auth_username,
+                  :http_basic_auth_password
+
+    def initialize
+      @orm                      = :active_record
+      @actor_proc               = nil
+      @http_basic_auth          = false
+      @http_basic_auth_username = nil
+      @http_basic_auth_password = nil
+    end
+
+    def http_basic_auth_configured?
+      !!http_basic_auth
+    end
+
+    # Returns true iff the given credentials match the configured username and
+    # password. Uses constant-time comparison on both fields (always evaluating
+    # both with bitwise `&`) so the response time can't reveal which side
+    # mismatched. Raises if auth is toggled on but credentials weren't set.
+    def http_basic_auth_matches?(username, password)
+      return true unless http_basic_auth_configured?
+
+      if http_basic_auth_username.nil? || http_basic_auth_password.nil?
+        raise ArgumentError,
+              "Overule.config.http_basic_auth is true but http_basic_auth_username " \
+              "and/or http_basic_auth_password are not set"
+      end
+
+      ActiveSupport::SecurityUtils.secure_compare(username.to_s, http_basic_auth_username.to_s) &
+        ActiveSupport::SecurityUtils.secure_compare(password.to_s, http_basic_auth_password.to_s)
+    end
+
+    def orm=(value)
+      sym = value.to_sym
+      unless SUPPORTED_ORMS.include?(sym)
+        raise ArgumentError, "Unsupported ORM #{value.inspect}. Supported: #{SUPPORTED_ORMS.inspect}"
+      end
+
+      @orm = sym
+    end
+
+    def actor_for(controller)
+      return nil unless actor_proc.respond_to?(:call)
+
+      actor_proc.call(controller)
+    end
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield(config)
+    end
+
+    # Test/reset hook — clears any host-app configuration. Internal use.
+    def reset_configuration!
+      @config = Configuration.new
+    end
+  end
+end

data/lib/overule/context.rb

@@ -0,0 +1,22 @@
+require "active_support/core_ext/hash/indifferent_access"
+
+module Overule
+  # Maintains the state of facts and variables used in rule evaluation
+  # Provides methods to get and set values in the context
+  # Uses HashWithIndifferentAccess for flexible key access
+  class Context
+    attr_reader :facts
+
+    def initialize(facts = {})
+      @facts = HashWithIndifferentAccess.new(facts)
+    end
+
+    def get(key)
+      @facts[key]
+    end
+
+    def set(key, value)
+      @facts[key] = value
+    end
+  end
+end

data/lib/overule/engine.rb

@@ -0,0 +1,7 @@
+require "rails/engine"
+
+module Overule
+  class Engine < ::Rails::Engine
+    isolate_namespace Overule
+  end
+end

data/lib/overule/inference.rb

@@ -0,0 +1,38 @@
+require "active_support/hash_with_indifferent_access"
+
+module Overule
+  # Main class for executing business rules
+  # Takes a rule set and facts, evaluates conditions,
+  # and executes corresponding actions when conditions are met
+  class Inference
+    def initialize(rule, facts)
+      @rules = HashWithIndifferentAccess.new(rule)
+      @ctx   = Context.new(facts)
+    end
+
+    def infer
+      return unless @rules["when"] && evaluate(@rules["when"])
+
+      action = Action.new(@rules["then"], @ctx)
+      action.fire
+    end
+
+    private
+
+    def evaluate(rule)
+      cond = Array(rule["cond"])
+      set  = Array(rule["set"])
+
+      return true if cond.empty? && set.empty?
+
+      results = Condition.evaluate(cond, @ctx) + set.map { |sub| evaluate(sub) }
+
+      case rule["op"]&.downcase
+      when "and" then results.all?
+      when "or"  then results.any?
+      else
+        raise Overule::Error, "Unknown logical operator: #{rule["op"].inspect}"
+      end
+    end
+  end
+end

data/lib/overule/operator.rb

@@ -0,0 +1,25 @@
+module Overule
+  # Provides comparison operations for rule evaluation
+  # Supports various operators like equality, inequality,
+  # greater/less than, inclusion, and range checking
+  class Operator
+    OPERATORS = {
+      "eq" => ->(a, b) { a == b },
+      "neq" => ->(a, b) { a != b },
+      "gt" => ->(a, b) { a > b },
+      "lt" => ->(a, b) { a < b },
+      "gte" => ->(a, b) { a >= b },
+      "lte" => ->(a, b) { a <= b },
+      "in" => ->(a, b) { b.include?(a) },
+      "nin" => ->(a, b) { !b.include?(a) },
+      "contains" => ->(a, b) { a.include?(b) },
+      "range" => ->(a, b) { a >= b.first && a <= b.last }
+    }.freeze
+
+    def self.operate(operator, actual, expected)
+      raise NoMethodError, "Unsupported operator: #{operator}" unless OPERATORS.key?(operator)
+
+      OPERATORS[operator].call(actual, expected)
+    end
+  end
+end

data/lib/overule/version.rb

@@ -0,0 +1,3 @@
+module Overule
+  VERSION = "0.1.0".freeze
+end

data/lib/overule.rb

@@ -0,0 +1,13 @@
+require_relative "overule/version"
+require_relative "overule/configuration"
+require_relative "overule/context"
+require_relative "overule/operator"
+require_relative "overule/condition"
+require_relative "overule/action"
+require_relative "overule/inference"
+
+module Overule
+  class Error < StandardError; end
+end
+
+require_relative "overule/engine" if defined?(Rails::Engine)

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: overule
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- bugloper
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+description: Overule is a rule engine designed to help developers define, manage,
+  and evaluate logical rules and conditions in their Ruby applications.
+email:
+- bugloper@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- app/assets/javascripts/overule/builder.js
+- app/controllers/overule/activities_controller.rb
+- app/controllers/overule/application_controller.rb
+- app/controllers/overule/rule_versions_controller.rb
+- app/controllers/overule/rules_controller.rb
+- app/models/concerns/overule/rule_activity_behavior.rb
+- app/models/concerns/overule/rule_behavior.rb
+- app/models/concerns/overule/rule_version_behavior.rb
+- app/models/overule/current.rb
+- app/models/overule/rule.rb
+- app/models/overule/rule_activity.rb
+- app/models/overule/rule_version.rb
+- app/views/layouts/overule/application.html.erb
+- app/views/overule/activities/_activity.html.erb
+- app/views/overule/activities/index.html.erb
+- app/views/overule/rule_versions/index.html.erb
+- app/views/overule/rule_versions/show.html.erb
+- app/views/overule/rules/_form.html.erb
+- app/views/overule/rules/_group.html.erb
+- app/views/overule/rules/_static_node.html.erb
+- app/views/overule/rules/edit.html.erb
+- app/views/overule/rules/index.html.erb
+- app/views/overule/rules/new.html.erb
+- app/views/overule/rules/show.html.erb
+- config/routes.rb
+- lib/generators/overule/install/USAGE
+- lib/generators/overule/install/install_generator.rb
+- lib/generators/overule/install/templates/add_rule_version_to_overule_rule_activities.rb.tt
+- lib/generators/overule/install/templates/create_overule_rule_activities.rb.tt
+- lib/generators/overule/install/templates/create_overule_rule_versions.rb.tt
+- lib/generators/overule/install/templates/create_overule_rules.rb.tt
+- lib/generators/overule/install/templates/overule.rb.tt
+- lib/overule.rb
+- lib/overule/action.rb
+- lib/overule/condition.rb
+- lib/overule/configuration.rb
+- lib/overule/context.rb
+- lib/overule/engine.rb
+- lib/overule/inference.rb
+- lib/overule/operator.rb
+- lib/overule/version.rb
+homepage: https://github.com/SELISEdigitalplatforms/overule.git
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/SELISEdigitalplatforms/overule.git
+  source_code_uri: https://github.com/SELISEdigitalplatforms/overule.git
+  changelog_uri: https://github.com/SELISEdigitalplatforms/overule/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: A powerful and customizable rule engine for Ruby applications.
+test_files: []