overule 0.1.0

data/app/controllers/overule/application_controller.rb

@@ -0,0 +1,35 @@
+module Overule
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    before_action :authenticate_with_overule_http_basic
+    before_action :set_overule_actor
+
+    helper_method :builder_js if respond_to?(:helper_method)
+
+    private
+
+    def builder_js
+      @builder_js ||= File.read(Overule::Engine.root.join("app/assets/javascripts/overule/builder.js"))
+    end
+
+    # Populate Overule::Current.actor from the host app's configured
+    # actor_proc (set in config/initializers/overule.rb). Host apps that
+    # prefer to set Current.actor themselves can leave actor_proc nil.
+    def set_overule_actor
+      actor = Overule.config.actor_for(self)
+      Overule::Current.actor = actor if actor
+    end
+
+    # Gate every Overule action behind HTTP Basic auth when the host app has
+    # configured credentials. When unset (the default), no gate is applied
+    # and the engine relies on the host's existing auth (or none).
+    def authenticate_with_overule_http_basic
+      return unless Overule.config.http_basic_auth_configured?
+
+      authenticate_or_request_with_http_basic("Overule") do |username, password|
+        Overule.config.http_basic_auth_matches?(username, password)
+      end
+    end
+  end
+end

data/app/controllers/overule/rule_versions_controller.rb

@@ -0,0 +1,24 @@
+module Overule
+  class RuleVersionsController < ApplicationController
+    before_action :set_rule
+    before_action :set_version, only: [:show]
+
+    def index
+      @versions = @rule.versions.ordered.reverse_order
+    end
+
+    def show
+      # Rendered implicitly: the show view consumes @rule and @version loaded by the before_actions.
+    end
+
+    private
+
+    def set_rule
+      @rule = Rule.find(params[:rule_id])
+    end
+
+    def set_version
+      @version = @rule.versions.find_by!(version: params[:id])
+    end
+  end
+end

data/app/controllers/overule/rules_controller.rb

@@ -0,0 +1,60 @@
+module Overule
+  class RulesController < ApplicationController
+    before_action :set_rule, only: %i[show edit update destroy]
+
+    def index
+      @rules = Rule.order(:name)
+    end
+
+    def show
+      # Rendered implicitly: the show view consumes @rule loaded by set_rule.
+    end
+
+    def new
+      @rule = Rule.new(definition: Rule::BLANK_DEFINITION.deep_dup)
+    end
+
+    def edit
+      # Rendered implicitly: the edit view consumes @rule loaded by set_rule.
+    end
+
+    def create
+      @rule = Rule.new(rule_params)
+      if @rule.save
+        redirect_to @rule, notice: "Rule created."
+      else
+        render :new, status: :unprocessable_entity
+      end
+    end
+
+    def update
+      if @rule.update(rule_params)
+        redirect_to @rule, notice: "Rule updated."
+      else
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @rule.destroy
+      redirect_to rules_path, notice: "Rule deleted."
+    end
+
+    private
+
+    def set_rule
+      @rule = Rule.find(params[:id])
+    end
+
+    def rule_params
+      permitted = params.require(:rule).permit(:name, :description, :enabled, :definition)
+      if permitted[:definition].is_a?(String) && !permitted[:definition].empty?
+        permitted[:definition] = JSON.parse(permitted[:definition])
+      end
+      permitted
+    rescue JSON::ParserError
+      permitted[:definition] = Rule::BLANK_DEFINITION.deep_dup
+      permitted
+    end
+  end
+end

data/app/models/concerns/overule/rule_activity_behavior.rb

@@ -0,0 +1,24 @@
+module Overule
+  module RuleActivityBehavior
+    extend ActiveSupport::Concern
+
+    ACTIONS = %w[created updated destroyed].freeze
+
+    included do
+      validates :action,    inclusion: { in: ACTIONS }
+      validates :rule_name, presence: true
+
+      scope :recent, -> { order(created_at: :desc) }
+    end
+
+    def changed_fields
+      return [] unless action == "updated"
+
+      diff.keys
+    end
+
+    def snapshot
+      diff["snapshot"] if %w[created destroyed].include?(action)
+    end
+  end
+end

data/app/models/concerns/overule/rule_behavior.rb

@@ -0,0 +1,106 @@
+module Overule
+  module RuleBehavior
+    extend ActiveSupport::Concern
+
+    AUDITED_COLUMNS  = %w[name description enabled definition].freeze
+    BLANK_DEFINITION = {
+      "when" => { "cond" => [], "set" => [], "op" => "and" },
+      "then" => { "$static" => {} }
+    }.freeze
+
+    included do
+      validates :name, presence: true, uniqueness: true
+      validate  :definition_shape
+
+      after_create   :log_created
+      after_update   :log_updated
+      # prepend so we capture the last version BEFORE dependent: :nullify
+      # severs the rule_id pointers on associated versions.
+      before_destroy :log_destroyed, prepend: true
+    end
+
+    def infer(facts)
+      Overule::Inference.new(definition, facts).infer
+    end
+
+    private
+
+    def definition_shape
+      unless definition.is_a?(Hash) && definition["when"].is_a?(Hash)
+        errors.add(:definition, "must contain a 'when' object")
+      end
+      unless definition.is_a?(Hash) && definition["then"].is_a?(Hash)
+        errors.add(:definition, "must contain a 'then' object")
+      end
+    end
+
+    def log_created
+      version = create_version!
+      Overule::RuleActivity.create!(
+        rule:         self,
+        rule_version: version,
+        rule_name:    name,
+        action:       "created",
+        actor:        Overule::Current.actor,
+        diff:         { "snapshot" => snapshot_attrs }
+      )
+    end
+
+    def log_updated
+      changes = saved_changes.slice(*AUDITED_COLUMNS)
+      return if changes.empty?
+
+      # Only definition (rule-body) changes bump the version. Metadata
+      # edits — name, description, enabled — still log an activity, but
+      # the activity links back to the current body version.
+      version = changes.key?("definition") ? create_version! : versions.ordered.last
+      diff    = changes.each_with_object({}) do |(col, (before, after)), acc|
+        acc[col] = { "before" => before, "after" => after }
+      end
+
+      Overule::RuleActivity.create!(
+        rule:         self,
+        rule_version: version,
+        rule_name:    name,
+        action:       "updated",
+        actor:        Overule::Current.actor,
+        diff:         diff
+      )
+    end
+
+    def log_destroyed
+      last_version = versions.ordered.last
+      Overule::RuleActivity.create!(
+        rule_version: last_version,
+        rule_name:    name,
+        action:       "destroyed",
+        actor:        Overule::Current.actor,
+        diff:         { "snapshot" => snapshot_attrs }
+      )
+    end
+
+    def create_version!
+      # `pluck(:version).max` works identically on both AR and Mongoid scopes,
+      # unlike `maximum(:version)` which has different names across ORMs.
+      next_version = (versions.pluck(:version).max || 0) + 1
+      versions.create!(
+        rule_name:   name,
+        version:     next_version,
+        name:        name,
+        description: description,
+        enabled:     enabled,
+        definition:  definition,
+        created_at:  Time.current
+      )
+    end
+
+    def snapshot_attrs
+      {
+        "name"        => name,
+        "description" => description,
+        "enabled"     => enabled,
+        "definition"  => definition
+      }
+    end
+  end
+end

data/app/models/concerns/overule/rule_version_behavior.rb

@@ -0,0 +1,15 @@
+module Overule
+  module RuleVersionBehavior
+    extend ActiveSupport::Concern
+
+    included do
+      validates :version, :rule_name, :name, presence: true
+
+      scope :ordered, -> { order(:version) }
+    end
+
+    def to_param
+      version.to_s
+    end
+  end
+end

data/app/models/overule/current.rb

@@ -0,0 +1,7 @@
+module Overule
+  # Host apps set Current.actor in a before_action so activity log entries
+  # can attribute changes to a user. Falls back to nil when unset.
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :actor
+  end
+end

data/app/models/overule/rule.rb

@@ -0,0 +1,48 @@
+module Overule
+  if Overule.config.orm == :mongoid
+    require "mongoid"
+
+    class Rule
+      include ::Mongoid::Document
+      include ::Mongoid::Timestamps
+
+      field :name,        type: String
+      field :description, type: String
+      field :enabled,     type: ::Mongoid::Boolean, default: true
+      field :definition,  type: Hash, default: -> { RuleBehavior::BLANK_DEFINITION.deep_dup }
+
+      index({ name: 1 }, unique: true)
+
+      has_many :versions,   class_name: "Overule::RuleVersion",
+                            inverse_of: :rule, dependent: :nullify
+      has_many :activities, class_name: "Overule::RuleActivity",
+                            inverse_of: :rule, dependent: :nullify
+
+      include RuleBehavior
+
+      BLANK_DEFINITION = RuleBehavior::BLANK_DEFINITION
+      AUDITED_COLUMNS  = RuleBehavior::AUDITED_COLUMNS
+    end
+  else
+    class Rule < ::ActiveRecord::Base
+      self.table_name = "overule_rules"
+
+      has_many :versions,   class_name: "Overule::RuleVersion",
+                            foreign_key: :rule_id, dependent: :nullify, inverse_of: :rule
+      has_many :activities, class_name: "Overule::RuleActivity",
+                            foreign_key: :rule_id, dependent: :nullify, inverse_of: :rule
+
+      include RuleBehavior
+
+      BLANK_DEFINITION = RuleBehavior::BLANK_DEFINITION
+      AUDITED_COLUMNS  = RuleBehavior::AUDITED_COLUMNS
+
+      # SQLite returns json columns as Strings on some adapter/Rails combos;
+      # parse defensively. Postgres/MySQL already deserialize to Hash.
+      def definition
+        value = super
+        value.is_a?(String) ? JSON.parse(value) : value
+      end
+    end
+  end
+end

data/app/models/overule/rule_activity.rb

@@ -0,0 +1,40 @@
+module Overule
+  if Overule.config.orm == :mongoid
+    require "mongoid"
+
+    class RuleActivity
+      include ::Mongoid::Document
+
+      # Created-only timestamp — activities are immutable, no updated_at.
+      field :created_at, type: DateTime, default: -> { Time.current }
+      field :rule_name,  type: String
+      field :action,     type: String
+      field :actor,      type: String
+      field :diff,       type: Hash, default: {}
+
+      belongs_to :rule,         class_name: "Overule::Rule",
+                                optional: true, inverse_of: :activities
+      belongs_to :rule_version, class_name: "Overule::RuleVersion",
+                                optional: true, inverse_of: :activities
+
+      index({ created_at: -1 })
+      index({ action: 1 })
+
+      include RuleActivityBehavior
+    end
+  else
+    class RuleActivity < ::ActiveRecord::Base
+      self.table_name = "overule_rule_activities"
+
+      belongs_to :rule,         class_name: "Overule::Rule",        optional: true
+      belongs_to :rule_version, class_name: "Overule::RuleVersion", optional: true
+
+      include RuleActivityBehavior
+
+      def diff
+        value = super
+        value.is_a?(String) ? JSON.parse(value) : (value || {})
+      end
+    end
+  end
+end

data/app/models/overule/rule_version.rb

@@ -0,0 +1,42 @@
+module Overule
+  if Overule.config.orm == :mongoid
+    require "mongoid"
+
+    class RuleVersion
+      include ::Mongoid::Document
+
+      field :created_at,  type: DateTime, default: -> { Time.current }
+      field :rule_name,   type: String
+      field :version,     type: Integer
+      field :name,        type: String
+      field :description, type: String
+      field :enabled,     type: ::Mongoid::Boolean, default: true
+      field :definition,  type: Hash, default: {}
+
+      belongs_to :rule, class_name: "Overule::Rule",
+                        optional: true, inverse_of: :versions
+      has_many   :activities, class_name: "Overule::RuleActivity",
+                              inverse_of: :rule_version, dependent: :nullify
+
+      index({ rule_id: 1, version: 1 }, unique: true)
+
+      include RuleVersionBehavior
+    end
+  else
+    class RuleVersion < ::ActiveRecord::Base
+      self.table_name = "overule_rule_versions"
+
+      belongs_to :rule, class_name: "Overule::Rule", optional: true
+      has_many   :activities, class_name: "Overule::RuleActivity",
+                              foreign_key: :rule_version_id,
+                              dependent: :nullify, inverse_of: :rule_version
+
+      include RuleVersionBehavior
+
+      def definition
+        value = super
+        value.is_a?(String) ? JSON.parse(value) : value
+      end
+    end
+  end
+end

data/app/views/layouts/overule/application.html.erb

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Overule — Rule Builder</title>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag if respond_to?(:csp_meta_tag) %>
+
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>[x-cloak] { display: none !important; }</style>
+    <script>
+      <%= raw builder_js %>
+    </script>
+    <script defer src="https://unpkg.com/alpinejs@3.14.1/dist/cdn.min.js"></script>
+  </head>
+  <body class="bg-slate-50 text-slate-900 min-h-screen">
+    <header class="bg-white border-b border-slate-200">
+      <div class="max-w-5xl mx-auto px-6 py-4 flex items-center justify-between">
+        <%= link_to "Overule", rules_path, class: "text-xl font-semibold tracking-tight" %>
+        <nav class="flex gap-2">
+          <%= link_to "Rules",    rules_path,      class: "px-3 py-1.5 text-sm rounded hover:bg-slate-100" %>
+          <%= link_to "Activity", activities_path, class: "px-3 py-1.5 text-sm rounded hover:bg-slate-100" %>
+          <%= link_to "New rule", new_rule_path,   class: "px-3 py-1.5 text-sm rounded bg-slate-900 text-white hover:bg-slate-700" %>
+        </nav>
+      </div>
+    </header>
+
+    <% if notice = flash[:notice] %>
+      <div class="max-w-5xl mx-auto px-6 mt-4">
+        <div class="bg-emerald-100 border border-emerald-200 text-emerald-900 px-4 py-2 rounded text-sm"><%= notice %></div>
+      </div>
+    <% end %>
+
+    <main class="max-w-5xl mx-auto px-6 py-8">
+      <%= yield %>
+    </main>
+  </body>
+</html>

data/app/views/overule/activities/_activity.html.erb

@@ -0,0 +1,56 @@
+<%
+  badge_classes = case activity.action
+                  when "created"   then "bg-emerald-100 text-emerald-800 border-emerald-200"
+                  when "updated"   then "bg-sky-100 text-sky-800 border-sky-200"
+                  when "destroyed" then "bg-rose-100 text-rose-800 border-rose-200"
+                  end
+%>
+<article class="border border-slate-200 rounded-lg bg-white p-4" x-data="{ open: false }">
+  <header class="flex items-start gap-3">
+    <span class="<%= badge_classes %> text-xs font-medium uppercase tracking-wide border rounded px-2 py-0.5">
+      <%= activity.action %>
+    </span>
+
+    <% if activity.rule_version %>
+      <% if activity.rule %>
+        <%= link_to "v#{activity.rule_version.version}", rule_version_path(activity.rule, activity.rule_version),
+              class: "text-xs font-mono text-sky-700 underline decoration-sky-300 underline-offset-2 hover:decoration-sky-700 hover:bg-sky-50 border border-sky-200 rounded px-2 py-0.5 cursor-pointer",
+              title: "View version #{activity.rule_version.version} snapshot" %>
+      <% else %>
+        <span class="text-xs font-mono text-slate-500 border border-slate-200 rounded px-2 py-0.5">
+          v<%= activity.rule_version.version %>
+        </span>
+      <% end %>
+    <% end %>
+
+    <div class="flex-1 min-w-0">
+      <p class="text-sm">
+        <% if activity.rule %>
+          <%= link_to activity.rule_name, rule_path(activity.rule), class: "font-medium text-slate-900 hover:underline" %>
+        <% else %>
+          <span class="font-medium text-slate-700"><%= activity.rule_name %></span>
+          <span class="text-xs text-slate-400 italic">(deleted)</span>
+        <% end %>
+        <% if activity.action == "updated" && activity.changed_fields.any? %>
+          <span class="text-slate-500 text-xs">
+            — changed <%= activity.changed_fields.map { |f| "<code class=\"font-mono\">#{f}</code>".html_safe }.to_sentence.html_safe %>
+          </span>
+        <% end %>
+      </p>
+      <p class="text-xs text-slate-500 mt-0.5">
+        <%= activity.created_at.strftime("%Y-%m-%d %H:%M:%S") %>
+        · <%= activity.actor.presence || "anonymous" %>
+      </p>
+    </div>
+
+    <button type="button" @click="open = !open"
+            class="text-xs text-slate-500 hover:text-slate-900 px-2 py-1 rounded hover:bg-slate-100">
+      <span x-show="!open">Details</span>
+      <span x-show="open">Hide</span>
+    </button>
+  </header>
+
+  <div x-show="open" x-cloak class="mt-3 pt-3 border-t border-slate-100">
+    <pre class="text-xs bg-slate-50 border border-slate-200 rounded p-3 overflow-x-auto"><code><%= JSON.pretty_generate(activity.diff) %></code></pre>
+  </div>
+</article>

data/app/views/overule/activities/index.html.erb

@@ -0,0 +1,30 @@
+<div class="flex items-center justify-between mb-6">
+  <div>
+    <h1 class="text-2xl font-semibold">
+      <% if @rule_filter %>
+        Activity for <span class="font-mono"><%= @rule_filter.name %></span>
+      <% else %>
+        Activities
+      <% end %>
+    </h1>
+    <% if @rule_filter %>
+      <p class="text-slate-500 text-sm mt-1">
+        <%= link_to "← All Activity", activities_path, class: "hover:underline" %>
+      </p>
+    <% else %>
+      <p class="text-slate-500 text-sm mt-1">Most recent rule changes across the system. Showing up to 200.</p>
+    <% end %>
+  </div>
+</div>
+
+<% if @activities.empty? %>
+  <div class="bg-white border border-dashed border-slate-300 rounded-lg p-12 text-center text-slate-500">
+    No Activity yet.
+  </div>
+<% else %>
+  <div class="space-y-2">
+    <% @activities.each do |activity| %>
+      <%= render "activity", activity: activity %>
+    <% end %>
+  </div>
+<% end %>

data/app/views/overule/rule_versions/index.html.erb

@@ -0,0 +1,44 @@
+<div class="flex items-center justify-between mb-6">
+  <div>
+    <h1 class="text-2xl font-semibold">
+      Versions of <span class="font-mono"><%= @rule.name %></span>
+    </h1>
+    <p class="text-slate-500 text-sm mt-1">
+      <%= link_to "← Back to rule", rule_path(@rule), class: "hover:underline" %>
+    </p>
+  </div>
+</div>
+
+<% if @versions.empty? %>
+  <div class="bg-white border border-dashed border-slate-300 rounded-lg p-12 text-center text-slate-500">
+    No versions recorded yet.
+  </div>
+<% else %>
+  <div class="bg-white border border-slate-200 rounded-lg overflow-hidden">
+    <table class="min-w-full text-sm">
+      <thead class="bg-slate-50 text-slate-600 text-left">
+        <tr>
+          <th class="px-4 py-2 font-medium w-20">Version</th>
+          <th class="px-4 py-2 font-medium">Name</th>
+          <th class="px-4 py-2 font-medium">Enabled</th>
+          <th class="px-4 py-2 font-medium">Captured</th>
+          <th class="px-4 py-2"></th>
+        </tr>
+      </thead>
+      <tbody class="divide-y divide-slate-200">
+        <% @versions.each do |version| %>
+          <tr>
+            <td class="px-4 py-3 font-mono text-slate-700">v<%= version.version %></td>
+            <td class="px-4 py-3"><%= version.name %></td>
+            <td class="px-4 py-3"><%= version.enabled? ? "yes" : "no" %></td>
+            <td class="px-4 py-3 text-slate-500"><%= version.created_at.strftime("%Y-%m-%d %H:%M:%S") %></td>
+            <td class="px-4 py-3 text-right">
+              <%= link_to "View →", rule_version_path(@rule, version),
+                    class: "text-slate-700 hover:underline" %>
+            </td>
+          </tr>
+        <% end %>
+      </tbody>
+    </table>
+  </div>
+<% end %>

data/app/views/overule/rule_versions/show.html.erb

@@ -0,0 +1,55 @@
+<%
+  prev_version = @rule.versions.where("version < ?", @version.version).ordered.last
+  next_version = @rule.versions.where("version > ?", @version.version).ordered.first
+%>
+
+<div class="flex items-start justify-between mb-6 gap-4">
+  <div>
+    <h1 class="text-2xl font-semibold">
+      <span class="font-mono text-slate-500">v<%= @version.version %></span>
+      <%= @version.name %>
+    </h1>
+    <p class="text-slate-500 text-sm mt-1">
+      Captured <%= @version.created_at.strftime("%Y-%m-%d %H:%M:%S") %>
+      · <%= link_to "← Back to rule", rule_path(@rule), class: "hover:underline" %>
+      · <%= link_to "All versions", rule_versions_path(@rule), class: "hover:underline" %>
+    </p>
+  </div>
+  <div class="flex gap-2 shrink-0">
+    <% if prev_version %>
+      <%= link_to "← v#{prev_version.version}", rule_version_path(@rule, prev_version),
+            class: "px-3 py-1.5 text-sm rounded border border-slate-300 hover:bg-slate-100" %>
+    <% end %>
+    <% if next_version %>
+      <%= link_to "v#{next_version.version} →", rule_version_path(@rule, next_version),
+            class: "px-3 py-1.5 text-sm rounded border border-slate-300 hover:bg-slate-100" %>
+    <% end %>
+  </div>
+</div>
+
+<section class="bg-white border border-slate-200 rounded-lg p-4 mb-4" x-data="{ copied: false }">
+  <div class="flex items-center justify-between mb-2">
+    <h2 class="text-sm font-medium text-slate-600">Definition at v<%= @version.version %></h2>
+    <button type="button"
+            @click="navigator.clipboard.writeText($refs.def.textContent).then(() => { copied = true; setTimeout(() => copied = false, 1500) })"
+            class="text-xs px-2 py-1 rounded bg-slate-700 hover:bg-slate-600 text-slate-100">
+      <span x-text="copied ? 'Copied!' : 'Copy'"></span>
+    </button>
+  </div>
+  <pre class="text-xs bg-slate-50 border border-slate-200 rounded p-3 overflow-x-auto"><code x-ref="def"><%= JSON.pretty_generate(@version.definition) %></code></pre>
+</section>
+
+<dl class="grid grid-cols-1 sm:grid-cols-3 gap-3 text-sm">
+  <div class="bg-white border border-slate-200 rounded p-3">
+    <dt class="text-xs uppercase text-slate-500 tracking-wide mb-1">Name</dt>
+    <dd class="font-mono"><%= @version.name %></dd>
+  </div>
+  <div class="bg-white border border-slate-200 rounded p-3">
+    <dt class="text-xs uppercase text-slate-500 tracking-wide mb-1">Enabled</dt>
+    <dd><%= @version.enabled? ? "yes" : "no" %></dd>
+  </div>
+  <div class="bg-white border border-slate-200 rounded p-3">
+    <dt class="text-xs uppercase text-slate-500 tracking-wide mb-1">Description</dt>
+    <dd class="text-slate-600"><%= @version.description.presence || "—" %></dd>
+  </div>
+</dl>