open-loam 0.1.1 → 0.2.0

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

@@ -1,8 +1,8 @@
-module Loam
+module OpenLoam
   # Base class for every tenant-scoped model. Inheriting from it is what makes
-  # a model a "Loam entity":
+  # a model a "OpenLoam entity":
   #
-  #   * every query is scoped to Loam::Current.tenant via default_scope
+  #   * every query is scoped to OpenLoam::Current.tenant via default_scope
   #   * building/creating a record assigns the current tenant automatically
   #   * touching the model with NO tenant in context raises MissingTenantError
   #
@@ -12,24 +12,24 @@ module Loam
   class TenantRecord < ActiveRecord::Base
     self.abstract_class = true
 
-    # Generates the key when it is not an integer (see Loam::GeneratedKey).
-    include Loam::GeneratedKey
+    # Generates the key when it is not an integer (see OpenLoam::GeneratedKey).
+    include OpenLoam::GeneratedKey
 
-    belongs_to :tenant, class_name: "Loam::Tenant"
+    belongs_to :tenant, class_name: "OpenLoam::Tenant"
 
-    default_scope { where(tenant_id: Loam.tenant!.id) }
+    default_scope { where(tenant_id: OpenLoam.tenant!.id) }
 
     validates :tenant_id, presence: true
 
     before_validation on: :create do
-      self.tenant_id ||= Loam.tenant!.id
+      self.tenant_id ||= OpenLoam.tenant!.id
     end
 
     # Guardrail for writes: a record can never be saved into a foreign tenant.
     before_save do
-      if tenant_id != Loam.tenant!.id
+      if tenant_id != OpenLoam.tenant!.id
         raise MissingTenantError, "Attempted to write #{self.class.name} into tenant #{tenant_id} " \
-                                  "while Loam::Current.tenant is #{Loam.tenant!.id}"
+                                  "while OpenLoam::Current.tenant is #{OpenLoam.tenant!.id}"
       end
     end
   end

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

@@ -1,15 +1,15 @@
-module Loam
+module OpenLoam
   # Mixed into ActiveSupport::TestCase by the install generator.
   module TestHelpers
     extend ActiveSupport::Concern
 
     included do
-      setup { Loam::Current.reset }
-      teardown { Loam::Current.reset }
+      setup { OpenLoam::Current.reset }
+      teardown { OpenLoam::Current.reset }
     end
 
     def with_tenant(tenant, actor: nil, &block)
-      Loam.as_tenant(tenant, actor: actor, &block)
+      OpenLoam.as_tenant(tenant, actor: actor, &block)
     end
   end
 end

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

@@ -3,7 +3,7 @@ require "securerandom"
 require "uri"
 require "erb"
 
-module Loam
+module OpenLoam
   # RFC 6238 time-based one-time passwords — the shipped second factor.
   # HMAC-SHA1, 30-second step, 6 digits, ±1 step of drift tolerance (so a code
   # entered a few seconds either side of a boundary still verifies). Hand-rolled
@@ -17,7 +17,7 @@ module Loam
     # A fresh random secret, base32-encoded for authenticator apps. 20 bytes
     # (160 bits) is the RFC-recommended size for SHA1.
     def self.generate_secret(bytes: 20)
-      Loam::Base32.encode(SecureRandom.random_bytes(bytes))
+      OpenLoam::Base32.encode(SecureRandom.random_bytes(bytes))
     end
 
     # True if `code` is valid for `secret` right now.
@@ -44,7 +44,7 @@ module Loam
 
     # The HOTP code for a given step counter (RFC 4226 dynamic truncation).
     def self.code_at(secret, counter, digits: DIGITS)
-      hmac = OpenSSL::HMAC.digest("SHA1", Loam::Base32.decode(secret), [counter].pack("Q>"))
+      hmac = OpenSSL::HMAC.digest("SHA1", OpenLoam::Base32.decode(secret), [counter].pack("Q>"))
       offset = hmac.bytes.last & 0x0f
       truncated = hmac[offset, 4].unpack1("N") & 0x7fffffff
       (truncated % (10**digits)).to_s.rjust(digits, "0")

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

@@ -1,32 +1,32 @@
-module Loam
+module OpenLoam
   # Per-record, per-locale translations of DATA fields — a product name, a
   # category label — distinct from Rails i18n (developer UI strings, still
   # Rails-native and out of scope here).
   #
-  #   class Equipment < Loam::TenantRecord
-  #     include Loam::Translatable
+  #   class Equipment < OpenLoam::TenantRecord
+  #     include OpenLoam::Translatable
   #     translates :name, :description
   #   end
   #
   # READ OVERLAY: the field reader returns the translation for the CURRENT locale
-  # (Loam.locale) when one exists, else the record's own COLUMN value — the base
+  # (OpenLoam.locale) when one exists, else the record's own COLUMN value — the base
   # is the fallback and stays authoritative for the default locale:
   #
-  #   equipment.name                  # => overlay for Loam.locale, else base
+  #   equipment.name                  # => overlay for OpenLoam.locale, else base
   #   equipment.name(locale: "de")    # => explicit locale, else base
   #   equipment.set_translation(:name, "de", "Bagger")
   #   equipment.translations_for(:name)  # => { "de" => "Bagger", ... }
   #
   # Writes still go through the ordinary `name=` writer to the base column, so
-  # translations are purely additive rows in loam_translations — the base value
+  # translations are purely additive rows in open_loam_translations — the base value
   # is never overwritten or lost.
   module Translatable
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :loam_translatable_attributes, default: [].freeze, instance_writer: false
+      class_attribute :open_loam_translatable_attributes, default: [].freeze, instance_writer: false
 
-      has_many :loam_translations, class_name: "Loam::Translation",
+      has_many :open_loam_translations, class_name: "OpenLoam::Translation",
                as: :translatable, dependent: :delete_all
     end
 
@@ -35,54 +35,54 @@ module Loam
         names = names.map(&:to_s)
 
         # An encrypted field must NOT be translatable: a translation row would
-        # store its PLAINTEXT in loam_translations, recreating exactly the leak
-        # Loam::Encryptable closes (same posture as searchable_by's refusal).
-        if respond_to?(:loam_encrypted_attributes)
-          conflict = names & loam_encrypted_attributes
+        # store its PLAINTEXT in open_loam_translations, recreating exactly the leak
+        # OpenLoam::Encryptable closes (same posture as searchable_by's refusal).
+        if respond_to?(:open_loam_encrypted_attributes)
+          conflict = names & open_loam_encrypted_attributes
           if conflict.any?
-            raise Loam::Error,
+            raise OpenLoam::Error,
                   "#{name}: cannot `translates` encrypted field(s) #{conflict.join(', ')} — " \
                   "a translation would store plaintext. Encrypted data is not translatable."
           end
         end
 
-        self.loam_translatable_attributes = (loam_translatable_attributes + names).freeze
+        self.open_loam_translatable_attributes = (open_loam_translatable_attributes + names).freeze
 
         names.each do |field|
           # The overlay reader. `read_attribute` (not super) is the base value,
           # so it works regardless of AR's lazy attribute-method definition.
           define_method(field) do |locale: nil|
-            loam_translation_value(field, locale) || read_attribute(field)
+            open_loam_translation_value(field, locale) || read_attribute(field)
           end
         end
       end
 
-      def loam_translatable?(field)
-        loam_translatable_attributes.include?(field.to_s)
+      def open_loam_translatable?(field)
+        open_loam_translatable_attributes.include?(field.to_s)
       end
     end
 
     # The stored translation for a field in a locale (default: the current one),
     # or nil when there is none.
-    def loam_translation_value(field, locale = nil)
-      locale = (locale || Loam.locale).to_s
+    def open_loam_translation_value(field, locale = nil)
+      locale = (locale || OpenLoam.locale).to_s
       return nil if locale.blank?
 
-      loam_translations.detect { |t| t.field == field.to_s && t.locale == locale }&.value
+      open_loam_translations.detect { |t| t.field == field.to_s && t.locale == locale }&.value
     end
 
     def set_translation(field, locale, value)
-      raise Loam::Error, "#{field} is not translatable on #{self.class.name}" unless self.class.loam_translatable?(field)
+      raise OpenLoam::Error, "#{field} is not translatable on #{self.class.name}" unless self.class.open_loam_translatable?(field)
 
-      row = loam_translations.find_or_initialize_by(field: field.to_s, locale: locale.to_s)
+      row = open_loam_translations.find_or_initialize_by(field: field.to_s, locale: locale.to_s)
       row.value = value
       row.save!
-      loam_translations.reset
+      open_loam_translations.reset
       value
     end
 
     def translations_for(field)
-      loam_translations.select { |t| t.field == field.to_s }.to_h { |t| [ t.locale, t.value ] }
+      open_loam_translations.select { |t| t.field == field.to_s }.to_h { |t| [ t.locale, t.value ] }
     end
   end
 end

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

@@ -1,6 +1,6 @@
-module Loam
+module OpenLoam
   # Undo/redo built ON the audit trail (L-704). Every change already records a
-  # Loam::AuditRecord with its changeset; undoing one applies the inverse and
+  # OpenLoam::AuditRecord with its changeset; undoing one applies the inverse and
   # writes a NEW audit record — so the inverse is itself undoable, and "redo" is
   # just undoing that undo entry. No separate command log to keep in sync.
   #
@@ -12,11 +12,11 @@ module Loam
   #   * encrypted fields — the audit stores "[encrypted]", never the old value,
   #     so there is nothing to revert to;
   #   * the workflow column — a direct write is blocked by the transition gate
-  #     (Loam::Workflow), so state is undone by performing the reverse TRANSITION,
+  #     (OpenLoam::Workflow), so state is undone by performing the reverse TRANSITION,
   #     not here;
   #   * fields the actor's role may not write (when a policy is supplied).
   module Undo
-    class NotUndoableError < Loam::Error; end
+    class NotUndoableError < OpenLoam::Error; end
 
     IGNORE = %w[id lock_version created_at updated_at].freeze
 
@@ -53,7 +53,7 @@ module Loam
 
     def revert_fields(record, audit, policy)
       ensure_latest!(audit)
-      workflow_column = record.class.respond_to?(:loam_workflow) ? record.class.loam_workflow&.column.to_s : nil
+      workflow_column = record.class.respond_to?(:open_loam_workflow) ? record.class.open_loam_workflow&.column.to_s : nil
 
       updates = {}
       (audit.changeset || {}).each do |field, values|
@@ -69,10 +69,10 @@ module Loam
       raise NotUndoableError, "nothing revertable in this change" if updates.empty?
 
       # Relabel this save's audit as "undo" so the history reads legibly (and the
-      # entry is itself undoable = redo). loam_audit_as is the same hook
+      # entry is itself undoable = redo). open_loam_audit_as is the same hook
       # SoftDeletable uses for soft_delete/restore.
-      if record.respond_to?(:loam_audit_as, true)
-        record.send(:loam_audit_as, "undo") { record.update!(updates) }
+      if record.respond_to?(:open_loam_audit_as, true)
+        record.send(:open_loam_audit_as, "undo") { record.update!(updates) }
       else
         record.update!(updates)
       end
@@ -92,7 +92,7 @@ module Loam
     # The audit must be the record's most recent update/undo — else undoing it
     # would overwrite newer edits. Tenant-scoped via AuditRecord's default scope.
     def ensure_latest!(audit)
-      latest = Loam::AuditRecord
+      latest = OpenLoam::AuditRecord
                .where(auditable_type: audit.auditable_type, auditable_id: audit.auditable_id, action: %w[update undo])
                .order(:id).last
       return if latest.nil? || latest.id == audit.id
@@ -105,7 +105,7 @@ module Loam
     # restore. Never AuditRecord#auditable, which is unscoped.
     def load_record(audit)
       klass = audit.auditable_type.safe_constantize
-      raise NotUndoableError, "unknown type #{audit.auditable_type.inspect}" unless klass.is_a?(Class) && klass < Loam::TenantRecord
+      raise NotUndoableError, "unknown type #{audit.auditable_type.inspect}" unless klass.is_a?(Class) && klass < OpenLoam::TenantRecord
 
       scope = klass.respond_to?(:with_deleted) ? klass.with_deleted : klass.all
       record = scope.find_by(id: audit.auditable_id)
@@ -120,7 +120,7 @@ module Loam
     end
 
     def ensure_current_tenant!(audit)
-      raise NotUndoableError, "not in this tenant" unless audit.tenant_id == Loam.tenant!.id
+      raise NotUndoableError, "not in this tenant" unless audit.tenant_id == OpenLoam.tenant!.id
     end
   end
 end

data/lib/open_loam/version.rb

@@ -0,0 +1,3 @@
+module OpenLoam
+  VERSION = "0.2.0"
+end

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

@@ -1,12 +1,12 @@
-module Loam
+module OpenLoam
   # Domain events, delivered over HTTP to whoever asked for them.
   #
-  # One global subscriber listens to every Loam event and, in the tenant the
+  # One global subscriber listens to every OpenLoam event and, in the tenant the
   # event was published in, enqueues a delivery per matching active endpoint.
   # Matching happens at dispatch time rather than at subscribe time because
   # endpoints are data: a tenant can add one from the admin without a reboot.
   module Webhooks
-    # Wired once from Loam::Engine. Idempotent: subscribing twice would deliver
+    # Wired once from OpenLoam::Engine. Idempotent: subscribing twice would deliver
     # every event twice.
     def self.subscribe!
       @subscription ||= Events.subscribe_all { |event_name, payload| dispatch(event_name, payload) }
@@ -22,7 +22,7 @@ module Loam
       # and scalars by convention, never records.
       deliverable = payload.transform_keys(&:to_s)
 
-      Loam.as_tenant(tenant) do
+      OpenLoam.as_tenant(tenant) do
         WebhookEndpoint.active.each do |endpoint|
           next unless endpoint.matches?(event_name)
 

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

@@ -1,9 +1,9 @@
-module Loam
+module OpenLoam
   # A registry of dashboard widgets — small, module-provided tiles (a metric, a
   # short list) shown on the admin home. A widget is a DATA PROVIDER plus a
   # title and an optional role filter; it never renders arbitrary code:
   #
-  #   Loam::Widgets.register(key: "open_rentals", title: "Open rentals", roles: %w[manager]) do |actor|
+  #   OpenLoam::Widgets.register(key: "open_rentals", title: "Open rentals", roles: %w[manager]) do |actor|
   #     { kind: "count", value: Rental.where(status: "open").count }   # tenant-scoped query
   #   end
   #
@@ -37,33 +37,33 @@ module Loam
       # can't see it (so its data is never computed), otherwise
       # { key, title, data } — or { key, title, error: } when the provider raises.
       def resolve(key, actor:, role:)
-        return nil if Loam::Overrides.disabled?(:widgets, key) # customization without forking
+        return nil if OpenLoam::Overrides.disabled?(:widgets, key) # customization without forking
 
         widget = find(key)
         return nil unless widget&.visible_to?(role)
 
-        provider = Loam::Overrides.replacement(:widgets, key) || widget.provider
+        provider = OpenLoam::Overrides.replacement(:widgets, key) || widget.provider
         { key: widget.key, title: widget.title, data: provider.call(actor) }
       rescue StandardError => error
         { key: widget&.key, title: widget&.title, error: error.message }
       end
 
-      # The widgets every Loam app starts with — registered at boot from the
+      # The widgets every OpenLoam app starts with — registered at boot from the
       # engine, so a fresh install has a useful default dashboard.
       def register_builtins!
         register(key: "audit_recent", title: "Recent activity") do |_actor|
-          items = Loam::AuditRecord.order(created_at: :desc).limit(8)
+          items = OpenLoam::AuditRecord.order(created_at: :desc).limit(8)
                                    .map { |a| "#{a.action} #{a.auditable_type} ##{a.auditable_id}" }
           { kind: "list", items: items }
         end
         register(key: "notifications_unread", title: "Unread notifications") do |actor|
-          { kind: "count", value: Loam::Notification.unread.where(user_id: actor&.id).count }
+          { kind: "count", value: OpenLoam::Notification.unread.where(user_id: actor&.id).count }
         end
         register(key: "pending_approvals", title: "Pending approvals", roles: %w[manager]) do |_actor|
-          { kind: "count", value: Loam::PendingAction.pending.count }
+          { kind: "count", value: OpenLoam::PendingAction.pending.count }
         end
         register(key: "open_progress", title: "Running tasks") do |_actor|
-          { kind: "count", value: Loam::ProgressJob.where(status: "running").count }
+          { kind: "count", value: OpenLoam::ProgressJob.where(status: "running").count }
         end
       end
 

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

@@ -1,9 +1,9 @@
-module Loam
+module OpenLoam
   # Declarative state machine for a tenant-scoped entity: the states a record
   # can be in, the legal moves between them, and who may make each move.
   #
-  #   class PurchaseOrder < Loam::TenantRecord
-  #     include Loam::Workflow
+  #   class PurchaseOrder < OpenLoam::TenantRecord
+  #     include OpenLoam::Workflow
   #
   #     workflow :status, initial: "draft" do
   #       state "draft"
@@ -18,14 +18,14 @@ module Loam
   #   order.submit!                         # draft -> pending_approval, publishes
   #                                         # "<domain>.purchase_order.submit"
   #   order.workflow_transitions_available  # => [:approve] for a manager, [] for anyone else
-  #   PurchaseOrder.loam_workflow           # the frozen definition, for agents and admin UI
+  #   PurchaseOrder.open_loam_workflow           # the frozen definition, for agents and admin UI
   #
   # What this buys over hand-rolled `if status == "draft"`: an illegal move
   # raises instead of silently writing a bad value, the roles that may move a
   # record are declared in one readable place instead of scattered across
   # controllers, and the whole machine is introspectable.
   #
-  # The state change itself is an ordinary attribute write, so Loam::Auditable
+  # The state change itself is an ordinary attribute write, so OpenLoam::Auditable
   # records it like any other change — a workflow adds no second audit trail.
   module Workflow
     extend ActiveSupport::Concern
@@ -99,22 +99,22 @@ module Loam
 
     included do
       # nil until `workflow` is called; inherited by subclasses.
-      class_attribute :loam_workflow, instance_writer: false, default: nil
+      class_attribute :open_loam_workflow, instance_writer: false, default: nil
 
       # THE gate: the workflow column may only change through a transition
-      # (loam_perform_transition!), which enforces from-state and role. A direct
+      # (open_loam_perform_transition!), which enforces from-state and role. A direct
       # write — the edit form, Bulk.set_field, an import, a business-rule
       # set_field — would otherwise let a member self-"approve", skipping the
       # transition's roles:. Closing it here closes ALL paths at once. Creation
       # (the initial state) is exempt (`on: :update`).
-      validate :loam_workflow_column_only_via_transition, on: :update
+      validate :open_loam_workflow_column_only_via_transition, on: :update
     end
 
     class_methods do
       # The DSL. `initial:` defaults to the first declared state.
       def workflow(column, initial: nil, &block)
         definition = Builder.new(column, initial).build(&block)
-        self.loam_workflow = definition
+        self.open_loam_workflow = definition
 
         before_validation on: :create do
           self[definition.column] = definition.initial if self[definition.column].blank?
@@ -125,29 +125,29 @@ module Loam
         validates definition.column,
                   inclusion: { in: definition.states, message: "is not one of: #{definition.states.join(', ')}" }
 
-        include loam_workflow_module(definition)
+        include open_loam_workflow_module(definition)
       end
 
       # Transition and predicate methods live in their own module rather than
       # on the class, so an app can override `submit!` and still call `super`.
-      def loam_workflow_module(definition)
+      def open_loam_workflow_module(definition)
         model = self
 
         Module.new do
           definition.transitions.each_value do |transition|
-            define_method("#{transition.name}!") { loam_perform_transition!(transition) }
+            define_method("#{transition.name}!") { open_loam_perform_transition!(transition) }
           end
 
           definition.states.each do |state|
             predicate = "#{state}?"
-            next unless model.loam_workflow_predicate_free?(predicate)
+            next unless model.open_loam_workflow_predicate_free?(predicate)
 
             # A state predicate must never shadow a real column: DamageReport
             # has both a workflow state "approved" and an `approved` boolean
             # column, and `record.approved?` has to stay the column's. The
             # column check happens at CALL time, not class-load time — at load
             # the schema may not be readable yet (fresh CI database, db:create),
-            # and a load-time decision made Loam behave differently on CI than
+            # and a load-time decision made OpenLoam behave differently on CI than
             # on a warmed-up dev machine.
             define_method(predicate) do
               if self.class.columns_hash.key?(state)
@@ -162,41 +162,41 @@ module Loam
 
       # Explicitly defined methods still win — only truly free names get a
       # workflow predicate. Column collisions are handled inside the predicate
-      # itself (see loam_workflow_module), where the schema is reliably known.
-      def loam_workflow_predicate_free?(predicate)
+      # itself (see open_loam_workflow_module), where the schema is reliably known.
+      def open_loam_workflow_predicate_free?(predicate)
         !method_defined?(predicate) && !private_method_defined?(predicate)
       end
     end
 
     # Transition names that are legal right now: from this record's state, for
-    # the actor in Loam::Current. Never raises — an admin screen asks this to
+    # the actor in OpenLoam::Current. Never raises — an admin screen asks this to
     # decide which buttons to render.
     def workflow_transitions_available
-      role = loam_workflow_role
+      role = open_loam_workflow_role
 
-      self.class.loam_workflow.transitions_from(loam_workflow_state)
+      self.class.open_loam_workflow.transitions_from(open_loam_workflow_state)
           .select { |transition| transition.roles.empty? || transition.roles.include?(role) }
           .map(&:name)
     end
 
-    def loam_workflow_state
-      self[self.class.loam_workflow.column].to_s
+    def open_loam_workflow_state
+      self[self.class.open_loam_workflow.column].to_s
     end
 
     private
 
-    def loam_workflow_column_only_via_transition
-      return unless self.class.loam_workflow
+    def open_loam_workflow_column_only_via_transition
+      return unless self.class.open_loam_workflow
 
-      column = self.class.loam_workflow.column
+      column = self.class.open_loam_workflow.column
       return unless attribute_changed?(column)
-      return if @loam_in_transition
+      return if @open_loam_in_transition
 
       errors.add(column, "can only change through a workflow transition, not a direct write")
     end
 
-    def loam_perform_transition!(transition)
-      from = loam_workflow_state
+    def open_loam_perform_transition!(transition)
+      from = open_loam_workflow_state
 
       unless transition.from.include?(from)
         raise InvalidTransitionError,
@@ -204,53 +204,53 @@ module Loam
               "but this record is #{from.inspect}"
       end
 
-      loam_authorize_transition!(transition)
+      open_loam_authorize_transition!(transition)
 
-      self[self.class.loam_workflow.column] = transition.to
+      self[self.class.open_loam_workflow.column] = transition.to
       begin
-        @loam_in_transition = true # tells the guard THIS column change is blessed
+        @open_loam_in_transition = true # tells the guard THIS column change is blessed
         save!
       ensure
-        @loam_in_transition = false
+        @open_loam_in_transition = false
       end
 
-      Loam::Events.publish(
-        "#{loam_workflow_event_domain}.#{model_name.param_key}.#{transition.name}",
+      OpenLoam::Events.publish(
+        "#{open_loam_workflow_event_domain}.#{model_name.param_key}.#{transition.name}",
         id: id, from: from, to: transition.to
       )
 
       self
     end
 
-    def loam_authorize_transition!(transition)
+    def open_loam_authorize_transition!(transition)
       return if transition.roles.empty?
 
       allowed = transition.roles.join(", ")
-      unless Loam::Current.actor
+      unless OpenLoam::Current.actor
         raise NotAuthorizedError,
               "#{self.class.name}##{transition.name}! is restricted to #{allowed}, but there is no actor in " \
-              "Loam::Current — wrap the call in Loam.as_tenant(tenant, actor: user) { ... }"
+              "OpenLoam::Current — wrap the call in OpenLoam.as_tenant(tenant, actor: user) { ... }"
       end
 
-      return if transition.roles.include?(loam_workflow_role)
+      return if transition.roles.include?(open_loam_workflow_role)
 
       raise NotAuthorizedError,
             "#{self.class.name}##{transition.name}! is restricted to #{allowed}; " \
-            "this actor's role is #{loam_workflow_role.inspect}"
+            "this actor's role is #{open_loam_workflow_role.inspect}"
     end
 
-    # Role resolution deliberately goes through Loam::Policy: "your role" means
+    # Role resolution deliberately goes through OpenLoam::Policy: "your role" means
     # exactly one thing — your membership role in the current tenant — here, in
     # policies, and in the admin.
-    def loam_workflow_role
-      actor = Loam::Current.actor
-      actor && Loam::Policy.new(actor, self).role
+    def open_loam_workflow_role
+      actor = OpenLoam::Current.actor
+      actor && OpenLoam::Policy.new(actor, self).role
     end
 
     # Transitions publish into the model's own event domain when it has one
-    # (Loam::Eventful), so workflow events sit beside the lifecycle events.
-    def loam_workflow_event_domain
-      self.class.respond_to?(:loam_event_domain) ? self.class.loam_event_domain : "app"
+    # (OpenLoam::Eventful), so workflow events sit beside the lifecycle events.
+    def open_loam_workflow_event_domain
+      self.class.respond_to?(:open_loam_event_domain) ? self.class.open_loam_event_domain : "app"
     end
   end
 end