open-loam 0.1.1 → 0.3.0

data/lib/{loam → open_loam}/pending_actions.rb

@@ -1,19 +1,19 @@
-module Loam
-  # Staging and reviewing gated mutations (see Loam::PendingAction).
+module OpenLoam
+  # Staging and reviewing gated mutations (see OpenLoam::PendingAction).
   #
-  #   pending = Loam::PendingActions.stage(
+  #   pending = OpenLoam::PendingActions.stage(
   #     summary: "Raise the excavator's daily rate to 1100",
   #     on: equipment, action: :update, changes: { daily_rate: 1100 }
   #   )
   #   pending.preview            # => { "daily_rate" => { "from" => 950, "to" => 1100 } }
   #   pending.approve!(by: manager)   # role-gated; executes the change
   #
-  # `stage` NEVER touches the target — it only records the intent. Loam does not
+  # `stage` NEVER touches the target — it only records the intent. OpenLoam does not
   # intercept Active Record globally (that would be fragile and out of scope);
   # this is the primitive a confirm-mode write path calls instead of saving.
   module PendingActions
     class << self
-      def stage(summary:, on:, action:, changes: {}, idempotency_key: nil, actor: Loam::Current.actor)
+      def stage(summary:, on:, action:, changes: {}, idempotency_key: nil, actor: OpenLoam::Current.actor)
         target_type, target_id = resolve_target(on)
         changes = changes.transform_keys(&:to_s)
         key = idempotency_key || compute_key(target_type, target_id, action, changes)
@@ -21,10 +21,10 @@ module Loam
         # The same proposal staged twice collapses to one row — but only a still
         # PENDING one. A rejected or executed proposal with this key may be
         # re-staged as a fresh pending row (the partial index allows the coexist).
-        existing = Loam::PendingAction.pending.find_by(idempotency_key: key)
+        existing = OpenLoam::PendingAction.pending.find_by(idempotency_key: key)
         return existing if existing
 
-        Loam::PendingAction.create!(
+        OpenLoam::PendingAction.create!(
           actor_id: actor&.id,
           action_type: action.to_s,
           target_type: target_type,
@@ -35,7 +35,7 @@ module Loam
         )
       rescue ActiveRecord::RecordNotUnique
         # Lost a concurrent double-stage race — return the pending row that won.
-        Loam::PendingAction.pending.find_by!(idempotency_key: key)
+        OpenLoam::PendingAction.pending.find_by!(idempotency_key: key)
       end
 
       private
@@ -53,7 +53,7 @@ module Loam
       # the same key; a reordered hash is treated as a different proposal.
       def compute_key(target_type, target_id, action, changes)
         payload = [ target_type, target_id, action, changes.to_json ].join("|")
-        Loam::Encryption.blind_index_scoped(payload, "tenant/#{Loam.tenant!.id}")
+        OpenLoam::Encryption.blind_index_scoped(payload, "tenant/#{OpenLoam.tenant!.id}")
       end
     end
   end

data/lib/{loam → open_loam}/permissions.rb

@@ -1,21 +1,21 @@
-module Loam
+module OpenLoam
   # Feature-string permissions with wildcards (L-705) — a fine-grained capability
   # layer that sits UNDER the coarse role. Roles answer "manager or clerk";
   # permissions answer "may this role do `equipment.edit`" without inventing a new
-  # role for every distinction. Orthogonal to Loam::Policy (which gates field-level
-  # writes on a record) and to Loam::Features (a per-tenant capability switch).
+  # role for every distinction. Orthogonal to OpenLoam::Policy (which gates field-level
+  # writes on a record) and to OpenLoam::Features (a per-tenant capability switch).
   #
   # Declared once, in the initializer (like broadcast_events / scheduler defaults):
   #
-  #   Loam::Permissions.configure do
+  #   OpenLoam::Permissions.configure do
   #     role :admin,   allow: "*"                              # everything
   #     role :manager, allow: %w[equipment.* damage_report.* billing.read]
   #     role :clerk,   allow: %w[equipment.read damage_report.create]
   #   end
   #
-  #   Loam::Permissions.allow?(:clerk, "equipment.read")  # => true
-  #   Loam::Permissions.allow?(:clerk, "equipment.edit")  # => false
-  #   Loam.can?("equipment.edit")                          # for the current actor's role
+  #   OpenLoam::Permissions.allow?(:clerk, "equipment.read")  # => true
+  #   OpenLoam::Permissions.allow?(:clerk, "equipment.edit")  # => false
+  #   OpenLoam.can?("equipment.edit")                          # for the current actor's role
   #
   # DENY BY DEFAULT: a role with no matching grant (or no grants at all) is denied.
   #
@@ -72,7 +72,7 @@ module Loam
     # Tiny DSL so `configure { role ... }` reads well without a receiver.
     class DSL
       def role(name, allow:)
-        Loam::Permissions.role(name, allow: allow)
+        OpenLoam::Permissions.role(name, allow: allow)
       end
     end
   end

data/lib/{loam → open_loam}/perspectives.rb

@@ -1,20 +1,20 @@
-module Loam
-  # Reading the saved views (Loam::Perspective) a user may see for an entity.
+module OpenLoam
+  # Reading the saved views (OpenLoam::Perspective) a user may see for an entity.
   #
-  #   Loam::Perspectives.visible_to("Equipment", user: current_actor)   # pick list
-  #   Loam::Perspectives.default_for("Equipment", user: current_actor)  # the applicable default
-  #   Loam::Perspectives.resolve("Equipment", user:, id: params[:perspective_id])
+  #   OpenLoam::Perspectives.visible_to("Equipment", user: current_actor)   # pick list
+  #   OpenLoam::Perspectives.default_for("Equipment", user: current_actor)  # the applicable default
+  #   OpenLoam::Perspectives.resolve("Equipment", user:, id: params[:perspective_id])
   #
-  # Every query is tenant-scoped by Loam::Perspective. The membership role used
+  # Every query is tenant-scoped by OpenLoam::Perspective. The membership role used
   # for role-shared views is the user's role in the CURRENT tenant.
   module Perspectives
     class << self
       # The views this user may see for an entity: their own private ones, the
       # role-shared ones matching their membership role, and the tenant-wide
       # ones. Default(s) first, then by name. Named `visible_to` rather than
-      # `for` so it does not read like Loam::Policy.for (which builds a policy).
+      # `for` so it does not read like OpenLoam::Policy.for (which builds a policy).
       def visible_to(entity_type, user:)
-        base = Loam::Perspective.where(entity_type: entity_type.to_s)
+        base = OpenLoam::Perspective.where(entity_type: entity_type.to_s)
         role = membership_role(user)
 
         # Build the OR chain on UNORDERED relations — `.or` refuses to combine
@@ -55,7 +55,7 @@ module Loam
       def membership_role(user)
         return nil unless user
 
-        Loam::Membership.find_by(user_id: user.id)&.role
+        OpenLoam::Membership.find_by(user_id: user.id)&.role
       end
     end
   end

data/lib/{loam → open_loam}/policy.rb

@@ -1,13 +1,13 @@
-module Loam
+module OpenLoam
   # Base policy. One policy class per entity, one instance per (actor, record)
   # pair. Action checks (read?/create?/update?/destroy?) default to "any member
   # of the current tenant"; field-level write access is declared, not coded:
   #
-  #   class EquipmentPolicy < Loam::Policy
+  #   class EquipmentPolicy < OpenLoam::Policy
   #     field :daily_rate, writable: [:manager]
   #   end
   #
-  # Roles come from Loam::Membership (actor + current tenant -> role).
+  # Roles come from OpenLoam::Membership (actor + current tenant -> role).
   class Policy
     class << self
       def field_rules
@@ -19,10 +19,23 @@ module Loam
       end
 
       def for(record)
-        policy_class = "#{record.class.name}Policy".safe_constantize
-        raise Error, "No policy defined for #{record.class.name} (expected #{record.class.name}Policy)" unless policy_class
+        policy_class_for(record.class).new(OpenLoam::Current.actor, record)
+      end
+
+      # A policy for a MODEL rather than one record — for bulk paths (export,
+      # import) that decide the column set once, before any row is read. The
+      # blank instance is a stand-in: the field checks key off the role, but
+      # the custom-field ones need record.class to find the definitions.
+      def for_model(model, actor)
+        policy_class_for(model).new(actor, model.new)
+      end
 
-        policy_class.new(Loam::Current.actor, record)
+      # Falling back to the base Policy for a model with no policy class would
+      # fail OPEN — every check there answers "any member", so a missing policy
+      # would silently grant what an explicit one restricts.
+      def policy_class_for(model)
+        "#{model.name}Policy".safe_constantize ||
+          raise(Error, "No policy defined for #{model.name} (expected #{model.name}Policy)")
       end
     end
 
@@ -36,7 +49,7 @@ module Loam
     def role
       return nil unless actor
 
-      @role ||= Loam::Membership.find_by(user_id: actor.id)&.role&.to_sym
+      @role ||= OpenLoam::Membership.find_by(user_id: actor.id)&.role&.to_sym
     end
 
     def member? = role.present?
@@ -73,7 +86,7 @@ module Loam
     end
 
     # Same semantics as the static `field writable:` declaration, but for a
-    # runtime Loam::FieldDefinition (see Loam::CustomFields): no
+    # runtime OpenLoam::FieldDefinition (see OpenLoam::CustomFields): no
     # writable_roles recorded means any member may write it.
     def custom_field_writable?(field_name)
       return false unless member?

data/lib/{loam → open_loam}/progress.rb

@@ -1,8 +1,8 @@
-module Loam
+module OpenLoam
   # Entry point for progress tracking. Start a job, then drive it through the
-  # returned Loam::ProgressJob:
+  # returned OpenLoam::ProgressJob:
   #
-  #   progress = Loam::Progress.start(name: "Reindex", total: equipment.count)
+  #   progress = OpenLoam::Progress.start(name: "Reindex", total: equipment.count)
   #   equipment.find_each do |record|
   #     break if progress.cancelled?   # cooperative cancel
   #     do_work(record)
@@ -12,18 +12,18 @@ module Loam
   #
   # The job is created in the current tenant (and stamped with the current
   # actor), so it is only visible and streamable there. In a background job,
-  # establish the tenant with Loam.as_tenant first, like the webhook/digest jobs.
+  # establish the tenant with OpenLoam.as_tenant first, like the webhook/digest jobs.
   module Progress
     module_function
 
     def start(name:, total:, key: nil)
-      Loam::ProgressJob.create!(
+      OpenLoam::ProgressJob.create!(
         key: key,
         name: name,
         total: total.to_i,
         completed: 0,
         status: "running",
-        actor_id: Loam.actor&.id,
+        actor_id: OpenLoam.actor&.id,
         started_at: Time.current
       )
     end

data/lib/{loam → open_loam}/record_locks.rb

@@ -1,15 +1,15 @@
-module Loam
-  # Advisory record locks (Loam::RecordLock) — a "who's editing this" courtesy
+module OpenLoam
+  # Advisory record locks (OpenLoam::RecordLock) — a "who's editing this" courtesy
   # for the multi-user admin.
   #
-  #   Loam::RecordLocks.acquire(record, by: current_actor)  # take/refresh, or nil if held
-  #   Loam::RecordLocks.holder(record)                      # the user holding it, or nil
-  #   Loam::RecordLocks.release(record, by: current_actor)  # give it up
-  #   Loam::RecordLocks.force_release(record)               # manager override
+  #   OpenLoam::RecordLocks.acquire(record, by: current_actor)  # take/refresh, or nil if held
+  #   OpenLoam::RecordLocks.holder(record)                      # the user holding it, or nil
+  #   OpenLoam::RecordLocks.release(record, by: current_actor)  # give it up
+  #   OpenLoam::RecordLocks.force_release(record)               # manager override
   #
   # THIS IS ADVISORY: a held lock warns, it does not hard-block — optimistic
   # locking (lock_version) is the actual guarantee that two edits can't clobber.
-  # Every query is tenant-scoped by Loam::RecordLock, so a lock is invisible and
+  # Every query is tenant-scoped by OpenLoam::RecordLock, so a lock is invisible and
   # unaffectable from another tenant.
   module RecordLocks
     DEFAULT_TTL = 5.minutes
@@ -25,7 +25,7 @@ module Loam
         lock = lock_row(record)
         return nil if lock && !lock.expired? && lock.locked_by_id != by.id
 
-        lock ||= Loam::RecordLock.new(lockable_type: type_of(record), lockable_id: record.id)
+        lock ||= OpenLoam::RecordLock.new(lockable_type: type_of(record), lockable_id: record.id)
         # A fresh session token when the lock is newly created or taken over from
         # an expired holder; kept as-is on a heartbeat by the same user.
         lock.token = SecureRandom.hex(16) if lock.new_record? || lock.locked_by_id != by.id
@@ -71,7 +71,7 @@ module Loam
       private
 
       def lock_row(record)
-        Loam::RecordLock.find_by(lockable_type: type_of(record), lockable_id: record.id)
+        OpenLoam::RecordLock.find_by(lockable_type: type_of(record), lockable_id: record.id)
       end
 
       def type_of(record)

data/lib/{loam → open_loam}/scheduler.rb

@@ -1,7 +1,7 @@
-module Loam
+module OpenLoam
   # Per-tenant recurring jobs. Modules self-register default schedules; an app
-  # also creates them from the admin. A runner calls Loam::Scheduler.tick
-  # periodically (wire `loam:scheduler:tick` to system cron — every minute) and
+  # also creates them from the admin. A runner calls OpenLoam::Scheduler.tick
+  # periodically (wire `open_loam:scheduler:tick` to system cron — every minute) and
   # each DUE schedule enqueues its ActiveJob.
   #
   # NO DOUBLE-FIRE — the whole correctness story. tick ATOMICALLY CLAIMS due
@@ -12,7 +12,7 @@ module Loam
   # The mechanism is behind `claim_due`, chosen per adapter. A claim also stamps
   # `locked_until` so a crashed worker's rows free themselves after LOCK_TTL.
   module Scheduler
-    class UnknownJobError < Loam::Error; end
+    class UnknownJobError < OpenLoam::Error; end
 
     class << self
       # --- declarative registry (like broadcast_events / feature_defaults) ---
@@ -31,14 +31,14 @@ module Loam
       end
 
       # Materialize the registered TENANT-scope schedules as rows in `tenant`
-      # (idempotent — safe from on_tenant_created and `loam:sync`). System-scope
+      # (idempotent — safe from on_tenant_created and `open_loam:sync`). System-scope
       # schedules are created explicitly by the app (they are not per-tenant).
       def sync_tenant(tenant)
-        Loam.as_tenant(tenant) do
+        OpenLoam.as_tenant(tenant) do
           registered.each do |default|
             next unless default[:scope] == "tenant"
 
-            job = Loam::ScheduledJob.find_or_initialize_by(key: default[:key])
+            job = OpenLoam::ScheduledJob.find_or_initialize_by(key: default[:key])
             job.name = default[:name]
             job.job_class = default[:job_class]
             job.schedule = default[:schedule]
@@ -56,7 +56,7 @@ module Loam
       # failure never blocks the others (its lock is released so a later tick
       # retries it).
       def tick(now: Time.current)
-        Loam::Telemetry.span("scheduler_tick") { run_tick(now) }
+        OpenLoam::Telemetry.span("scheduler_tick") { run_tick(now) }
       end
 
       def run_tick(now)
@@ -69,7 +69,7 @@ module Loam
             fired += 1
           rescue StandardError => error
             job.update_columns(locked_until: nil, updated_at: now)
-            logger&.error("[loam scheduler] #{job.key} failed: #{error.class}: #{error.message}")
+            logger&.error("[open_loam scheduler] #{job.key} failed: #{error.class}: #{error.message}")
           end
         end
         fired
@@ -83,7 +83,7 @@ module Loam
 
       # THE code-execution guard: a job_class must resolve to a real ActiveJob
       # subclass AND be ALLOWLISTED — either registered here or listed in
-      # Loam.schedulable_jobs. "Any ActiveJob" would let a tenant admin schedule
+      # OpenLoam.schedulable_jobs. "Any ActiveJob" would let a tenant admin schedule
       # ActiveStorage::PurgeJob, a mailer's delivery job, etc.
       def resolve_job_class(name)
         name = name.to_s
@@ -94,7 +94,7 @@ module Loam
       end
 
       def allowed_job_class?(name)
-        registered.any? { |default| default[:job_class] == name } || Loam.schedulable_jobs.include?(name)
+        registered.any? { |default| default[:job_class] == name } || OpenLoam.schedulable_jobs.include?(name)
       end
 
       def resolve_job_class!(name)
@@ -113,36 +113,36 @@ module Loam
         if job.scope == "system"
           klass.perform_later
         else
-          # Carry the tenant explicitly (ActiveJob doesn't serialize Loam::Current),
+          # Carry the tenant explicitly (ActiveJob doesn't serialize OpenLoam::Current),
           # and enqueue inside the tenant so any enqueue-time scoping is correct.
-          Loam.as_tenant(job.tenant) { klass.perform_later(tenant_id: job.tenant_id) }
+          OpenLoam.as_tenant(job.tenant) { klass.perform_later(tenant_id: job.tenant_id) }
         end
       end
 
       # Atomically claim due, unlocked schedules across ALL tenants (a blessed
       # cross-tenant scan — the runner has no tenant context, like
-      # Loam::Membership.tenants_for), stamping locked_until so a concurrent tick
+      # OpenLoam::Membership.tenants_for), stamping locked_until so a concurrent tick
       # skips them.
       def claim_due(now)
-        lock_until = now + Loam::ScheduledJob::LOCK_TTL
-        due = Loam::ScheduledJob.unscoped.active
+        lock_until = now + OpenLoam::ScheduledJob::LOCK_TTL
+        due = OpenLoam::ScheduledJob.unscoped.active
                                 .where("next_run_at <= ?", now)
                                 .where("locked_until IS NULL OR locked_until < ?", now)
 
         claimed = []
-        Loam::ScheduledJob.transaction do
+        OpenLoam::ScheduledJob.transaction do
           relation = postgres? ? due.lock("FOR UPDATE SKIP LOCKED") : due
           ids = relation.pluck(:id)
           break if ids.empty?
 
-          Loam::ScheduledJob.unscoped.where(id: ids).update_all(locked_until: lock_until)
-          claimed = Loam::ScheduledJob.unscoped.where(id: ids).to_a
+          OpenLoam::ScheduledJob.unscoped.where(id: ids).update_all(locked_until: lock_until)
+          claimed = OpenLoam::ScheduledJob.unscoped.where(id: ids).to_a
         end
         claimed
       end
 
       def postgres?
-        Loam::ScheduledJob.connection.adapter_name.to_s.downcase.include?("postgres")
+        OpenLoam::ScheduledJob.connection.adapter_name.to_s.downcase.include?("postgres")
       end
 
       def logger

data/lib/{loam → open_loam}/search/driver.rb

@@ -1,4 +1,4 @@
-module Loam
+module OpenLoam
   module Search
     # The driver contract. Subclass and override the class methods.
     #
@@ -10,10 +10,10 @@ module Loam
     #
     #   index(record) / remove(record)
     #     Maintain the driver's index as records are saved and destroyed. Called
-    #     from Loam::Searchable's after_save / after_destroy.
+    #     from OpenLoam::Searchable's after_save / after_destroy.
     #
     #   reindex(model)
-    #     Rebuild the index for a model (used by `loam:search:reindex` and seeds).
+    #     Rebuild the index for a model (used by `open_loam:search:reindex` and seeds).
     #
     # A driver that needs no index (LIKE) leaves index/remove/reindex as no-ops.
     class Driver

data/lib/{loam → open_loam}/search/like_driver.rb

@@ -1,24 +1,24 @@
-module Loam
+module OpenLoam
   module Search
     # The default driver: a substring LIKE across the declared columns — exactly
-    # the original Loam::Searchable behavior, now behind the seam. Portable
+    # the original OpenLoam::Searchable behavior, now behind the seam. Portable
     # (Arel's `matches` emits ILIKE on PostgreSQL, case-insensitive LIKE on
     # SQLite for ASCII) and needs no index, so index/remove/reindex are no-ops.
     #
     # What it does NOT do — ignore accents, split on words, rank — is the reason
-    # the seam exists: swap in Loam::Search::TokenDriver (or an external engine)
+    # the seam exists: swap in OpenLoam::Search::TokenDriver (or an external engine)
     # and every `Model.search(q)` call site keeps working unchanged.
     class LikeDriver < Driver
       class << self
         def search(model, query, scope:)
           query = query.to_s.strip
-          return scope if query.blank? || !model.loam_searchable?
+          return scope if query.blank? || !model.open_loam_searchable?
 
           # sanitize_sql_like escapes the LIKE wildcards so a literal % or _ in
           # the query stays literal; the second arg to `matches` declares that
           # escape character to the database (SQLite has none by default).
           pattern = "%#{model.sanitize_sql_like(query)}%"
-          conditions = model.loam_searchable_columns.map do |column|
+          conditions = model.open_loam_searchable_columns.map do |column|
             model.arel_table[column].matches(pattern, "\\")
           end
           scope.where(conditions.inject(:or))

data/lib/{loam → open_loam}/search/token_driver.rb

@@ -1,7 +1,7 @@
-module Loam
+module OpenLoam
   module Search
     # A portable, word-level index (the flagship second driver). Each record's
-    # searchable text is normalized into tokens stored in loam_search_tokens;
+    # searchable text is normalized into tokens stored in open_loam_search_tokens;
     # a query is tokenized the same way and matched with AND semantics — a record
     # must carry EVERY query token — so "excavator cat" finds "CAT 320 Excavator"
     # regardless of word order or position. Plain SQL: works on SQLite and
@@ -9,21 +9,21 @@ module Loam
     # order-independent). When an app outgrows even this, the same seam takes a
     # Meilisearch/Elasticsearch driver with no call-site change.
     #
-    # Tenant isolation is free: Loam::SearchToken is a TenantRecord, so both the
+    # Tenant isolation is free: OpenLoam::SearchToken is a TenantRecord, so both the
     # match subquery and every write are scoped to the current tenant.
     class TokenDriver < Driver
       class << self
         def search(model, query, scope:)
           tokens = tokenize(query)
-          return scope if tokens.empty? || !model.loam_searchable?
+          return scope if tokens.empty? || !model.open_loam_searchable?
 
           # AND semantics: keep only records carrying all N distinct query
           # tokens. Under AND every hit has the full match count, so ranking is
           # degenerate — ordering is left to the caller.
-          matches = Loam::SearchToken
+          matches = OpenLoam::SearchToken
             .where(searchable_type: type_for(model), token: tokens)
             .group(:searchable_id)
-            .having("COUNT(DISTINCT token) = #{tokens.size}")
+            .having("COUNT(DISTINCT token) = ?", tokens.size)
             .select(:searchable_id)
 
           scope.where(id: matches)
@@ -33,10 +33,10 @@ module Loam
         # the record's tenant, so the token rows land in the right tenant.
         def index(record)
           model = record.class
-          return unless model.loam_searchable?
+          return unless model.open_loam_searchable?
 
           type = type_for(model)
-          Loam::SearchToken.where(searchable_type: type, searchable_id: record.id).delete_all
+          OpenLoam::SearchToken.where(searchable_type: type, searchable_id: record.id).delete_all
 
           tokens = tokenize(searchable_text(record))
           return if tokens.empty?
@@ -44,17 +44,17 @@ module Loam
           rows = tokens.map do |token|
             { tenant_id: record.tenant_id, searchable_type: type, searchable_id: record.id, token: token }
           end
-          Loam::SearchToken.insert_all(rows)
+          OpenLoam::SearchToken.insert_all(rows)
         end
 
         def remove(record)
-          Loam::SearchToken.where(searchable_type: type_for(record.class), searchable_id: record.id).delete_all
+          OpenLoam::SearchToken.where(searchable_type: type_for(record.class), searchable_id: record.id).delete_all
         end
 
         # Rebuild every current-tenant record of a model — run inside
-        # Loam.as_tenant per tenant (the loam:search:reindex task does that).
+        # OpenLoam.as_tenant per tenant (the open_loam:search:reindex task does that).
         def reindex(model)
-          Loam::SearchToken.where(searchable_type: type_for(model)).delete_all
+          OpenLoam::SearchToken.where(searchable_type: type_for(model)).delete_all
           model.find_each { |record| index(record) }
         end
 
@@ -65,13 +65,13 @@ module Loam
         # THE SAFETY BOUNDARY: an encrypted column is skipped. Its stored value
         # is ciphertext (meaningless to tokenize), and tokenizing the PLAINTEXT
         # into a searchable table would recreate exactly the leak
-        # Loam::Encryptable closes — an encrypted field stays exact-match-only via
+        # OpenLoam::Encryptable closes — an encrypted field stays exact-match-only via
         # its blind index. `searchable_by` already refuses to declare an
         # encrypted column; this subtraction is the second line of that defense.
         def searchable_text(record)
-          columns = record.class.loam_searchable_columns
-          if record.class.respond_to?(:loam_encrypted_attributes)
-            columns -= record.class.loam_encrypted_attributes
+          columns = record.class.open_loam_searchable_columns
+          if record.class.respond_to?(:open_loam_encrypted_attributes)
+            columns -= record.class.open_loam_encrypted_attributes
           end
           columns.map { |column| record.public_send(column) }.join(" ")
         end

data/lib/{loam → open_loam}/search.rb

@@ -1,21 +1,21 @@
-module Loam
+module OpenLoam
   # The search seam. `Model.search(q)` and the `searchable_by` declaration never
   # change; the STRATEGY behind them is a swappable driver:
   #
-  #   Loam::Search.driver = Loam::Search::TokenDriver   # in an initializer
+  #   OpenLoam::Search.driver = OpenLoam::Search::TokenDriver   # in an initializer
   #
   # The default is the LIKE driver — portable and zero-setup — so nothing
   # changes out of the box. A driver turns a text query into a subset of an
   # already-tenant-scoped relation and maintains whatever index it needs; see
-  # Loam::Search::Driver for the contract. This is the same shape as
-  # Loam::EventStream.broadcaster and Loam::Enrichers: one seam, drivers behind
+  # OpenLoam::Search::Driver for the contract. This is the same shape as
+  # OpenLoam::EventStream.broadcaster and OpenLoam::Enrichers: one seam, drivers behind
   # it, callers untouched.
   module Search
     class << self
       attr_writer :driver
 
       def driver
-        @driver ||= Loam::Search::LikeDriver
+        @driver ||= OpenLoam::Search::LikeDriver
       end
 
       def search(model, query, scope:) = driver.search(model, query, scope: scope)