organizations 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1c3b465c2092c9234aed9d1751337abae3bfef4a86bf1bd2fd34bafb5bee7fb
-  data.tar.gz: cc0b5a830649d91a464ba72f5603bec472c45d11818974c6d1567db4a65422ef
+  metadata.gz: bc99dabb60fe5f7d0c4ae8567fd62c4920f4a403b804dfe4e8dcac4d3c66fa11
+  data.tar.gz: '024976f0f5cd19fd8530179977a34e21d7ca54968bbf62d50eeff0d5f70dc1ea'
 SHA512:
-  metadata.gz: 181defb79c40e269ea86b28d3f6d6d262d3834eaf31674ab66b33a807e685bec9ef085b3251490a26b0c02c870b680b803f020341c7555cebee261fd1984a0e9
-  data.tar.gz: 34e5d034196756c2bf436341766a1889b9c665e7a42c70a7a7ad5ba52863da56a0a845d4842b171cd4fbf6354a8be44cbfef476716f6e8c78c665e6e403ed563
+  metadata.gz: b14290ba7ecfc72544a5b4553fc5fd633ab51af9bcf1e3e1ed2bd90769ce2099a658f815191f1cf8c5e4706978d0070b80654e6b6da978b636ba6a87e60e11c9
+  data.tar.gz: 07bb21cfe8a870b8f672069ac7cb3f9512dad17ad1ea472b4cc34db9eaaf292773f05c6eb105dc5e220dc3b4b2139bfcdee1d097201774ca92cb79356373c8a3

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.2.0] - 2026-02-20
+
+- Namespaced all tables with `organizations_` prefix to prevent collisions with host apps
+
+## [0.1.1] - 2026-02-19
+
+- Removed `slugifiable` dependency (deferred to host app)
+
 ## [0.1.0] - 2026-02-19
 
 Initial release.

data/README.md

@@ -48,7 +48,7 @@ gem "organizations"
 ```
 
 > [!NOTE]
-> The `organizations` gem depends on [`slugifiable`](https://github.com/rameerez/slugifiable) for URL-friendly organization slugs (auto-included). For beautiful invitation emails, optionally add [`goodmail`](https://github.com/rameerez/goodmail).
+> For beautiful invitation emails, optionally add [`goodmail`](https://github.com/rameerez/goodmail).
 
 Then:
 
@@ -458,10 +458,10 @@ The helper returns:
 
 ```ruby
 {
-  current: { id: "...", name: "Acme Corp", slug: "acme-corp" },
+  current: { id: "...", name: "Acme Corp" },
   others: [
-    { id: "...", name: "Personal", slug: "personal" },
-    { id: "...", name: "StartupCo", slug: "startupco" }
+    { id: "...", name: "Personal" },
+    { id: "...", name: "StartupCo" }
   ],
   switch_path: ->(org_id) { "/organizations/switch/#{org_id}" }
 }
@@ -1026,7 +1026,6 @@ The gem works with Rails fixtures:
 # test/fixtures/organizations.yml
 acme:
   name: Acme Corp
-  slug: acme-corp
 
 # test/fixtures/memberships.yml
 john_at_acme:
@@ -1065,9 +1064,9 @@ The gem provides `Organizations::Organization` as the base model. You can extend
 # db/migrate/xxx_add_custom_fields_to_organizations.rb
 class AddCustomFieldsToOrganizations < ActiveRecord::Migration[8.0]
   def change
-    add_column :organizations, :support_email, :string
-    add_column :organizations, :billing_address, :text
-    add_column :organizations, :settings, :jsonb, default: {}
+    add_column :organizations_organizations, :support_email, :string
+    add_column :organizations_organizations, :billing_address, :text
+    add_column :organizations_organizations, :settings, :jsonb, default: {}
   end
 end
 ```
@@ -1111,24 +1110,23 @@ This is standard Rails practice — the gem provides the foundation (memberships
 
 The gem creates three tables:
 
-### organizations
+### organizations_organizations
 
 ```sql
-organizations
+organizations_organizations
   - id (primary key, auto-detects UUID or integer from your app)
   - name (string, required)
-  - slug (string, unique, indexed) -- auto-generated via slugifiable gem
   - metadata (jsonb, default: {})
   - created_at
   - updated_at
 ```
 
-> **Note:** The gem automatically detects your app's primary key type (UUID or integer) and uses it for all tables. Slugs are auto-generated from the organization name using the [`slugifiable`](https://github.com/rameerez/slugifiable) gem.
+> **Note:** The gem automatically detects your app's primary key type (UUID or integer) and uses it for all tables.
 
-### memberships
+### organizations_memberships
 
 ```sql
-memberships
+organizations_memberships
   - id (primary key)
   - user_id (foreign key, indexed)
   - organization_id (foreign key, indexed)
@@ -1140,10 +1138,10 @@ memberships
   unique index: [user_id, organization_id]
 ```
 
-### organization_invitations
+### organizations_invitations
 
 ```sql
-organization_invitations
+organizations_invitations
   - id (primary key)
   - organization_id (foreign key, indexed)
   - email (string, required, indexed)
@@ -1181,7 +1179,6 @@ organization_invitations
 | Ownership transfer to removed user | Transaction lock, verifies membership exists before transfer |
 | Concurrent role changes on same user | Row-level lock on membership row |
 | Session points to org user was removed from | `current_organization` verifies membership, clears stale session |
-| Duplicate org slug on creation | Unique constraint, retries with suffix (acme-corp-2) |
 | Token collision on invitation | Unique constraint, regenerates token |
 
 ## Performance notes
@@ -1243,12 +1240,12 @@ The `organization_switcher_data` helper is optimized for navbar use:
 
 ```ruby
 # Internally, it:
-# 1. Selects only id, name, slug (not full objects)
+# 1. Selects only id, name (not full objects)
 # 2. Memoizes within the request
 # 3. Returns a lightweight hash, not ActiveRecord objects
 
 organization_switcher_data
-# => { current: { id: "...", name: "Acme", slug: "acme" }, others: [...] }
+# => { current: { id: "...", name: "Acme" }, others: [...] }
 ```
 
 ### Counter caches for member counts
@@ -1257,7 +1254,7 @@ If you display member counts frequently (pricing pages, org listings), consider
 
 ```ruby
 # In a migration
-add_column :organizations, :memberships_count, :integer, default: 0, null: false
+add_column :organizations_organizations, :memberships_count, :integer, default: 0, null: false
 
 # Reset existing counts
 Organization.find_each do |org|
@@ -1278,9 +1275,9 @@ org.member_count
 Boolean checks use efficient SQL `EXISTS` queries:
 
 ```ruby
-user.belongs_to_any_organization?     # SELECT 1 FROM memberships WHERE ... LIMIT 1
-user.has_pending_organization_invitations?  # SELECT 1 FROM organization_invitations WHERE ... LIMIT 1
-org.has_any_members?                  # SELECT 1 FROM memberships WHERE ... LIMIT 1
+user.belongs_to_any_organization?     # SELECT 1 FROM organizations_memberships WHERE ... LIMIT 1
+user.has_pending_organization_invitations?  # SELECT 1 FROM organizations_invitations WHERE ... LIMIT 1
+org.has_any_members?                  # SELECT 1 FROM organizations_memberships WHERE ... LIMIT 1
 ```
 
 ### Scoped associations use JOINs
@@ -1290,13 +1287,13 @@ Methods like `org.admins` and `user.owned_organizations` use proper SQL JOINs:
 ```ruby
 org.admins
 # SELECT users.* FROM users
-# INNER JOIN memberships ON memberships.user_id = users.id
-# WHERE memberships.organization_id = ? AND memberships.role IN ('admin', 'owner')
+# INNER JOIN organizations_memberships ON organizations_memberships.user_id = users.id
+# WHERE organizations_memberships.organization_id = ? AND organizations_memberships.role IN ('admin', 'owner')
 
 user.owned_organizations
-# SELECT organizations.* FROM organizations
-# INNER JOIN memberships ON memberships.organization_id = organizations.id
-# WHERE memberships.user_id = ? AND memberships.role = 'owner'
+# SELECT organizations_organizations.* FROM organizations_organizations
+# INNER JOIN organizations_memberships ON organizations_memberships.organization_id = organizations_organizations.id
+# WHERE organizations_memberships.user_id = ? AND organizations_memberships.role = 'owner'
 ```
 
 ### Current organization memoization
@@ -1333,7 +1330,6 @@ These constraints prevent duplicate data at the database level:
 | `memberships [user_id, organization_id]` | User can only have one membership per org |
 | `invitations [organization_id, email] WHERE accepted_at IS NULL` | Only one pending invitation per email per org |
 | `invitations [token]` | Invitation tokens are globally unique |
-| `organizations [slug]` | Organization slugs are globally unique |
 
 ### Row-level locking
 
@@ -1423,10 +1419,6 @@ invitation.accept!
 # Adding an existing member
 org.add_member!(existing_user)
 # => Returns existing membership (doesn't raise)
-
-# Creating org with duplicate slug
-user.create_organization!("Acme Corp")  # slug: acme-corp exists
-# => Creates with suffix: acme-corp-2 (via slugifiable gem)
 ```
 
 ### Session integrity
@@ -1453,17 +1445,14 @@ The gem creates these indexes automatically:
 
 ```sql
 -- Fast membership lookups
-CREATE UNIQUE INDEX index_memberships_on_user_and_org ON memberships (user_id, organization_id);
-CREATE INDEX index_memberships_on_organization_id ON memberships (organization_id);
-CREATE INDEX index_memberships_on_role ON memberships (role);
+CREATE UNIQUE INDEX index_organizations_memberships_on_user_and_org ON organizations_memberships (user_id, organization_id);
+CREATE INDEX index_organizations_memberships_on_organization_id ON organizations_memberships (organization_id);
+CREATE INDEX index_organizations_memberships_on_role ON organizations_memberships (role);
 
 -- Fast invitation lookups
-CREATE UNIQUE INDEX index_invitations_on_token ON organization_invitations (token);
-CREATE INDEX index_invitations_on_email ON organization_invitations (email);
-CREATE UNIQUE INDEX index_invitations_pending ON organization_invitations (organization_id, LOWER(email)) WHERE accepted_at IS NULL;
-
--- Fast org lookups
-CREATE UNIQUE INDEX index_organizations_on_slug ON organizations (slug);
+CREATE UNIQUE INDEX index_organizations_invitations_on_token ON organizations_invitations (token);
+CREATE INDEX index_organizations_invitations_on_email ON organizations_invitations (email);
+CREATE UNIQUE INDEX index_organizations_invitations_pending ON organizations_invitations (organization_id, LOWER(email)) WHERE accepted_at IS NULL;
 ```
 
 ## Migration from 1:1 relationships

data/app/controllers/organizations/organizations_controller.rb

@@ -150,7 +150,6 @@ module Organizations
         {
           id: org.id,
           name: org.name,
-          slug: org.slug,
           member_count: counts[org.id] || 0,
           role: membership.role,
           created_at: org.created_at,
@@ -168,7 +167,6 @@ module Organizations
       {
         id: org.id,
         name: org.name,
-        slug: org.slug,
         member_count: org.member_count,
         role: membership&.role,
         created_at: org.created_at,

data/app/controllers/organizations/switch_controller.rb

@@ -19,7 +19,7 @@ module Organizations
 
         respond_to do |format|
           format.html { redirect_to after_switch_path, notice: "Switched to #{org.name}" }
-          format.json { render json: { organization: { id: org.id, name: org.name, slug: org.slug } } }
+          format.json { render json: { organization: { id: org.id, name: org.name } } }
         end
       else
         respond_to do |format|

data/gemfiles/rails_7.2.gemfile

@@ -0,0 +1,25 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "rails", "~> 7.2.3"
+
+group :development do
+  gem "irb"
+  gem "rubocop", "~> 1.0"
+  gem "rubocop-minitest", "~> 0.35"
+  gem "rubocop-performance", "~> 1.0"
+end
+
+group :development, :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "rack-test"
+  gem "sqlite3", ">= 2.1"
+  gem "ostruct"
+  gem "simplecov", require: false
+end
+
+gemspec path: "../"

data/gemfiles/rails_8.1.gemfile

@@ -0,0 +1,25 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rake", "~> 13.0"
+gem "rails", "~> 8.1.2"
+
+group :development do
+  gem "irb"
+  gem "rubocop", "~> 1.0"
+  gem "rubocop-minitest", "~> 0.35"
+  gem "rubocop-performance", "~> 1.0"
+end
+
+group :development, :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "rack-test"
+  gem "sqlite3", ">= 2.1"
+  gem "ostruct"
+  gem "simplecov", require: false
+end
+
+gemspec path: "../"

data/lib/generators/organizations/install/templates/create_organizations_tables.rb.erb

@@ -6,20 +6,17 @@ class CreateOrganizationsTables < ActiveRecord::Migration<%= migration_version %
     adapter = connection.adapter_name.downcase
 
     # Organizations table
-    create_table :organizations, id: primary_key_type do |t|
+    create_table :organizations_organizations, id: primary_key_type do |t|
       t.string :name, null: false
-      t.string :slug, null: false
       t.send(json_column_type, :metadata, null: json_column_null, default: json_column_default)
 
       t.timestamps
     end
 
-    add_index :organizations, :slug, unique: true
-
     # Memberships join table (User ↔ Organization)
-    create_table :memberships, id: primary_key_type do |t|
+    create_table :organizations_memberships, id: primary_key_type do |t|
       t.references :user, null: false, type: foreign_key_type, foreign_key: true
-      t.references :organization, null: false, type: foreign_key_type, foreign_key: true
+      t.references :organization, null: false, type: foreign_key_type, foreign_key: { to_table: :organizations_organizations }
       t.references :invited_by, null: true, type: foreign_key_type, foreign_key: { to_table: :users }
       t.string :role, null: false, default: "member"
       t.send(json_column_type, :metadata, null: json_column_null, default: json_column_default)
@@ -27,27 +24,22 @@ class CreateOrganizationsTables < ActiveRecord::Migration<%= migration_version %
       t.timestamps
     end
 
-    add_index :memberships, [:user_id, :organization_id], unique: true
-    add_index :memberships, :role
+    add_index :organizations_memberships, [:user_id, :organization_id], unique: true
+    add_index :organizations_memberships, :role
 
     # Enforce "at most one owner membership per organization" at DB level where possible.
-    if adapter.include?("postgresql")
-      execute <<-SQL
-        CREATE UNIQUE INDEX index_memberships_single_owner
-        ON memberships (organization_id)
-        WHERE role = 'owner'
-      SQL
-    elsif adapter.include?("sqlite")
+    # Both PostgreSQL and SQLite support partial indexes with identical syntax.
+    if adapter.include?("postgresql") || adapter.include?("sqlite")
       execute <<-SQL
-        CREATE UNIQUE INDEX index_memberships_single_owner
-        ON memberships (organization_id)
+        CREATE UNIQUE INDEX index_organizations_memberships_single_owner
+        ON organizations_memberships (organization_id)
         WHERE role = 'owner'
       SQL
     end
 
     # Invitations table
-    create_table :organization_invitations, id: primary_key_type do |t|
-      t.references :organization, null: false, type: foreign_key_type, foreign_key: true
+    create_table :organizations_invitations, id: primary_key_type do |t|
+      t.references :organization, null: false, type: foreign_key_type, foreign_key: { to_table: :organizations_organizations }
       # invited_by is nullable to support dependent: :nullify when user is deleted
       t.references :invited_by, null: true, type: foreign_key_type, foreign_key: { to_table: :users }
       t.string :email, null: false
@@ -59,29 +51,22 @@ class CreateOrganizationsTables < ActiveRecord::Migration<%= migration_version %
       t.timestamps
     end
 
-    add_index :organization_invitations, :token, unique: true
-    add_index :organization_invitations, :email
+    add_index :organizations_invitations, :token, unique: true
+    add_index :organizations_invitations, :email
 
     # Unique partial index: only one pending (non-accepted) invitation per email per org
-    # Both PostgreSQL and SQLite support partial indexes
-    if adapter.include?("postgresql")
-      execute <<-SQL
-        CREATE UNIQUE INDEX index_invitations_pending_unique
-        ON organization_invitations (organization_id, LOWER(email))
-        WHERE accepted_at IS NULL
-      SQL
-    elsif adapter.include?("sqlite")
-      # SQLite supports partial indexes since 3.8.0
+    # Both PostgreSQL and SQLite (3.8.0+) support partial indexes with identical syntax.
+    if adapter.include?("postgresql") || adapter.include?("sqlite")
       execute <<-SQL
-        CREATE UNIQUE INDEX index_invitations_pending_unique
-        ON organization_invitations (organization_id, LOWER(email))
+        CREATE UNIQUE INDEX index_organizations_invitations_pending_unique
+        ON organizations_invitations (organization_id, LOWER(email))
         WHERE accepted_at IS NULL
       SQL
     elsif adapter.include?("mysql")
       # MySQL doesn't support partial indexes, so we use a generated column that is
       # only non-NULL for pending invitations and enforce uniqueness on that value.
       execute <<-SQL
-        ALTER TABLE organization_invitations
+        ALTER TABLE organizations_invitations
         ADD COLUMN pending_email VARCHAR(255)
         GENERATED ALWAYS AS (
           CASE
@@ -91,10 +76,10 @@ class CreateOrganizationsTables < ActiveRecord::Migration<%= migration_version %
         ) STORED
       SQL
 
-      add_index :organization_invitations, [:organization_id, :pending_email], unique: true, name: "index_invitations_pending_unique"
+      add_index :organizations_invitations, [:organization_id, :pending_email], unique: true, name: "index_organizations_invitations_pending_unique"
     else
       # For other adapters, fall back to app-level validation.
-      add_index :organization_invitations, [:organization_id, :email], name: "index_invitations_on_org_and_email"
+      add_index :organizations_invitations, [:organization_id, :email], name: "index_organizations_invitations_on_org_and_email"
     end
   end
 

data/lib/generators/organizations/install/templates/initializer.rb

@@ -71,13 +71,4 @@ Organizations.configure do |config|
   # Default: :current_organization_id
   # config.session_key = :current_organization_id
 
-  # ============================================================================
-  # URL SLUGS
-  # ============================================================================
-
-  # Organizations use slugifiable for URL-friendly slugs.
-  # Slugs are auto-generated from the organization name.
-  # Example: "Acme Corp" → "acme-corp"
-  #
-  # To customize slug generation, configure slugifiable separately.
 end

data/lib/organizations/models/concerns/has_organizations.rb

@@ -74,7 +74,7 @@ module Organizations
 
             # Organizations where user is owner (efficient JOIN)
             has_many :owned_organizations,
-                     -> { where(memberships: { role: "owner" }) },
+                     -> { where(organizations_memberships: { role: "owner" }) },
                      through: :memberships,
                      source: :organization,
                      class_name: "Organizations::Organization"

data/lib/organizations/models/invitation.rb

@@ -18,7 +18,7 @@ module Organizations
   #   invitation.expired?   # => false
   #
   class Invitation < ActiveRecord::Base
-    self.table_name = "organization_invitations"
+    self.table_name = "organizations_invitations"
 
     # === Associations ===
 

data/lib/organizations/models/membership.rb

@@ -16,7 +16,7 @@ module Organizations
   #   membership.demote_to!(:member)
   #
   class Membership < ActiveRecord::Base
-    self.table_name = "memberships"
+    self.table_name = "organizations_memberships"
 
     # Error raised when trying to demote below current role
     class CannotDemoteOwner < Organizations::Error; end

data/lib/organizations/models/organization.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "slugifiable/model"
-
 module Organizations
   # Organization model representing a team, workspace, or account.
   # Users belong to organizations through memberships with specific roles.
@@ -18,12 +16,7 @@ module Organizations
   #   org.member_count # => 5
   #
   class Organization < ActiveRecord::Base
-    self.table_name = "organizations"
-    include Slugifiable::Model
-
-    # Keep slug semantics aligned with README and slugifiable defaults:
-    # organization names become URL-friendly slugs, with collision handling.
-    generate_slug_based_on :name
+    self.table_name = "organizations_organizations"
 
     # Error raised when trying to perform invalid operations on organization
     class CannotRemoveOwner < Organizations::Error; end
@@ -53,14 +46,6 @@ module Organizations
     # === Validations ===
 
     validates :name, presence: true
-    validates :slug, presence: true, uniqueness: { case_sensitive: false }
-
-    # === Callbacks ===
-
-    # slugifiable persists slugs in after_create by default, but this gem keeps
-    # organizations.slug as NOT NULL and validates presence. We therefore compute
-    # a slug before validation when needed.
-    before_validation :ensure_slug_present, on: :create, if: -> { slug.blank? && name.present? }
 
     # === Scopes ===
 
@@ -69,7 +54,7 @@ module Organizations
     # @param user [User] The user
     # @return [ActiveRecord::Relation]
     scope :with_member, ->(user) {
-      joins(:memberships).where(memberships: { user_id: user.id })
+      joins(:memberships).where(organizations_memberships: { user_id: user.id })
     }
 
     # === Member Query Methods ===
@@ -90,7 +75,7 @@ module Organizations
     # Uses efficient JOIN query to avoid N+1
     # @return [ActiveRecord::Relation<User>]
     def admins
-      users.where(memberships: { role: %w[owner admin] }).distinct
+      users.where(organizations_memberships: { role: %w[owner admin] }).distinct
     end
 
     # Alias for users (semantic convenience)
@@ -385,10 +370,6 @@ module Organizations
 
     private
 
-    def ensure_slug_present
-      self.slug = compute_slug if slug.blank?
-    end
-
     # Defense in depth for organization-centric API usage.
     # The user-level API already checks this, but direct calls to `org.send_invite_to!`
     # must enforce membership and invite permission as well.

data/lib/organizations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Organizations
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/organizations/view_helpers.rb

@@ -24,7 +24,7 @@ module Organizations
     # === Organization Switcher ===
 
     # Returns optimized data for building an organization switcher
-    # Only selects needed columns (id, name, slug) for performance
+    # Only selects needed columns (id, name) for performance
     # Memoized within the request
     #
     # @return [Hash] Hash with :current, :others, and :switch_path
@@ -32,10 +32,10 @@ module Organizations
     # @example
     #   organization_switcher_data
     #   # => {
-    #   #   current: { id: "...", name: "Acme Corp", slug: "acme-corp" },
+    #   #   current: { id: "...", name: "Acme Corp" },
     #   #   others: [
-    #   #     { id: "...", name: "Personal", slug: "personal" },
-    #   #     { id: "...", name: "StartupCo", slug: "startupco" }
+    #   #     { id: "...", name: "Personal" },
+    #   #     { id: "...", name: "StartupCo" }
     #   #   ],
     #   #   switch_path: ->(org_id) { "/organizations/switch/#{org_id}" }
     #   # }
@@ -258,8 +258,8 @@ module Organizations
       memberships = user.memberships
                         .includes(:organization)
                         .joins(:organization)
-                        .select("memberships.id, memberships.organization_id, memberships.role, " \
-                                "organizations.id AS org_id, organizations.name AS org_name, organizations.slug AS org_slug")
+                        .select("organizations_memberships.id, organizations_memberships.organization_id, organizations_memberships.role, " \
+                                "organizations_organizations.id AS org_id, organizations_organizations.name AS org_name")
 
       current_data = nil
       others = []
@@ -268,7 +268,6 @@ module Organizations
         org_data = {
           id: m.organization_id,
           name: m.org_name,
-          slug: m.org_slug,
           role: m.role.to_sym,
           role_label: organization_role_label(m.role)
         }
@@ -281,7 +280,7 @@ module Organizations
       end
 
       # If no current org was found in memberships, user might not be a member anymore
-      current_data ||= { id: nil, name: nil, slug: nil, role: nil, current: true }
+      current_data ||= { id: nil, name: nil, role: nil, current: true }
 
       {
         current: current_data,
@@ -292,7 +291,7 @@ module Organizations
 
     def empty_switcher_data
       {
-        current: { id: nil, name: nil, slug: nil, role: nil, current: true },
+        current: { id: nil, name: nil, role: nil, current: true },
         others: [],
         switch_path: build_switch_path_lambda
       }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: organizations
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - rameerez
 bindir: exe
 cert_chain: []
-date: 2026-02-19 00:00:00.000000000 Z
+date: 2026-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -69,20 +69,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
-- !ruby/object:Gem::Dependency
-  name: slugifiable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
 description: Add organizations to any Rails app (with members, roles, and invitations).
   This gem implements the complete User → Membership → Organization pattern with scoped
   invitations, hierarchical roles (owner, admin, member, viewer), permissions, and
@@ -113,8 +99,8 @@ files:
 - app/views/organizations/invitation_mailer/invitation_email.html.erb
 - app/views/organizations/invitation_mailer/invitation_email.text.erb
 - config/routes.rb
-- examples/demo_insert_race_condition.rb
-- examples/demo_slugifiable_integration.rb
+- gemfiles/rails_7.2.gemfile
+- gemfiles/rails_8.1.gemfile
 - lib/generators/organizations/install/install_generator.rb
 - lib/generators/organizations/install/templates/create_organizations_tables.rb.erb
 - lib/generators/organizations/install/templates/initializer.rb

data/examples/demo_insert_race_condition.rb

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-# Demo: Verify INSERT-time race condition handling works for Organizations
-#
-# This simulates the exact race condition that Codex identified:
-# 1. Two processes try to create orgs with same name simultaneously
-# 2. Both compute slug "acme-corp" in before_validation
-# 3. First INSERT succeeds
-# 4. Second INSERT fails with RecordNotUnique
-# 5. around_create retries with recomputed slug
-#
-# Run: bundle exec ruby test/demo_insert_race_condition.rb
-
-require "bundler/setup"
-require "active_record"
-require "sqlite3"
-
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "organizations"
-
-puts "=" * 70
-puts "INSERT-TIME RACE CONDITION DEMO"
-puts "=" * 70
-puts
-
-# Setup
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-ActiveRecord::Base.logger = Logger.new(nil)
-
-ActiveRecord::Schema.define do
-  create_table :users, force: :cascade do |t|
-    t.string :email, null: false
-    t.timestamps
-  end
-
-  create_table :organizations, force: :cascade do |t|
-    t.string :name, null: false
-    t.string :slug, null: false  # NOT NULL - key for this test
-    t.timestamps
-  end
-  add_index :organizations, :slug, unique: true
-
-  create_table :memberships, force: :cascade do |t|
-    t.references :user, null: false
-    t.references :organization, null: false
-    t.string :role, null: false, default: "member"
-    t.timestamps
-  end
-
-  create_table :organization_invitations, force: :cascade do |t|
-    t.references :organization, null: false
-    t.string :email, null: false
-    t.string :token, null: false
-    t.string :role, null: false, default: "member"
-    t.datetime :accepted_at
-    t.datetime :expires_at
-    t.timestamps
-  end
-end
-
-class User < ActiveRecord::Base
-  extend Organizations::Models::Concerns::HasOrganizations::ClassMethods
-  has_organizations
-end
-
-# ============================================================================
-# Test 1: Verify around_create hook is available
-# ============================================================================
-puts "TEST 1: Verify around_create hook exists"
-puts "-" * 40
-
-org = Organizations::Organization.new(name: "Test")
-has_hook = org.respond_to?(:retry_create_on_slug_unique_violation, true)
-puts "Has retry_create_on_slug_unique_violation: #{has_hook ? '✅ YES' : '❌ NO'}"
-puts
-
-# ============================================================================
-# Test 2: Simulate race condition with injected conflicting INSERT
-# ============================================================================
-puts "TEST 2: Simulate INSERT-time race condition"
-puts "-" * 40
-
-# Create a subclass that injects a conflicting row on first INSERT attempt
-class RaceSimulationOrg < Organizations::Organization
-  self.table_name = "organizations"
-
-  class_attribute :insert_attempts, default: 0
-  class_attribute :collision_injected, default: false
-
-  before_create :inject_collision_once
-
-  private
-
-  def inject_collision_once
-    self.class.insert_attempts += 1
-    puts "  [DEBUG] INSERT attempt ##{self.class.insert_attempts}, slug=#{slug}"
-
-    return if self.class.collision_injected
-
-    self.class.collision_injected = true
-
-    # Inject a row with the same slug BEFORE this INSERT completes
-    conn = self.class.connection
-    now = Time.current
-    conn.execute(<<~SQL)
-      INSERT INTO organizations (name, slug, created_at, updated_at)
-      VALUES (
-        #{conn.quote("Injected by race simulation")},
-        #{conn.quote(slug)},
-        #{conn.quote(now)},
-        #{conn.quote(now)}
-      )
-    SQL
-    puts "  [DEBUG] Injected conflicting row with slug=#{slug}"
-  end
-end
-
-begin
-  org = RaceSimulationOrg.create!(name: "Acme Corp")
-
-  puts
-  puts "Result:"
-  puts "  Created successfully: #{org.persisted? ? '✅ YES' : '❌ NO'}"
-  puts "  INSERT attempts: #{RaceSimulationOrg.insert_attempts}"
-  puts "  Final slug: #{org.slug}"
-  puts "  Slug changed after retry: #{org.slug != 'acme-corp' ? '✅ YES' : '❌ NO'}"
-
-  if RaceSimulationOrg.insert_attempts == 2 && org.slug.start_with?("acme-corp-")
-    puts
-    puts "✅ PASS - Race condition handled correctly!"
-  else
-    puts
-    puts "⚠️ Unexpected behavior - check debug output"
-  end
-rescue => e
-  puts
-  puts "❌ FAIL - #{e.class}: #{e.message}"
-end
-puts
-
-# ============================================================================
-# Test 3: Verify non-slug unique violations still bubble up
-# ============================================================================
-puts "TEST 3: Non-slug unique violations bubble up"
-puts "-" * 40
-
-class NonSlugViolationOrg < Organizations::Organization
-  self.table_name = "organizations"
-
-  before_create do
-    raise ActiveRecord::RecordNotUnique, "UNIQUE constraint failed: organizations.external_id"
-  end
-end
-
-begin
-  NonSlugViolationOrg.create!(name: "Should Fail")
-  puts "❌ FAIL - Should have raised RecordNotUnique"
-rescue ActiveRecord::RecordNotUnique => e
-  if e.message.include?("external_id")
-    puts "✅ PASS - Non-slug violation bubbled up correctly"
-  else
-    puts "⚠️ Unexpected error: #{e.message}"
-  end
-rescue => e
-  puts "❌ FAIL - Wrong error type: #{e.class}"
-end
-puts
-
-# ============================================================================
-# Test 4: High-volume stress test with real database
-# ============================================================================
-puts "TEST 4: High-volume concurrent-like test (100 orgs, same name)"
-puts "-" * 40
-
-Organizations::Organization.delete_all
-
-start_time = Time.now
-orgs = []
-100.times do |i|
-  orgs << Organizations::Organization.create!(name: "Stress Test Corp")
-end
-elapsed = Time.now - start_time
-
-slugs = orgs.map(&:slug)
-unique_count = slugs.uniq.length
-
-puts "Created 100 organizations in #{(elapsed * 1000).round(2)}ms"
-puts "Unique slugs: #{unique_count}/100"
-puts "First slug: #{orgs.first.slug}"
-puts "Last slug: #{orgs.last.slug}"
-puts "Result: #{unique_count == 100 ? '✅ PASS' : '❌ FAIL'}"
-puts
-
-# ============================================================================
-# Summary
-# ============================================================================
-puts "=" * 70
-puts "SUMMARY"
-puts "=" * 70
-puts
-puts "The around_create hook in slugifiable correctly handles INSERT-time"
-puts "race conditions for NOT NULL slug columns."
-puts
-puts "Flow:"
-puts "1. before_validation: compute slug ('acme-corp')"
-puts "2. around_create: wrap INSERT"
-puts "3. INSERT fails: RecordNotUnique (slug collision)"
-puts "4. around_create: recompute slug ('acme-corp-123456')"
-puts "5. Retry INSERT: success"
-puts
-puts "This is the fix Codex added in slugifiable Round 9."
-puts "=" * 70

data/examples/demo_slugifiable_integration.rb

@@ -1,350 +0,0 @@
-# frozen_string_literal: true
-
-# Demo script to verify slugifiable integration with organizations gem
-#
-# This script tests:
-# 1. Basic slug generation from name
-# 2. Slug uniqueness handling
-# 3. Slug collision resolution with random suffixes
-# 4. NOT NULL constraint compatibility (before_validation hook)
-# 5. Race condition handling (simulated)
-#
-# Run with: bundle exec ruby test/demo_slugifiable_integration.rb
-
-require "bundler/setup"
-require "active_record"
-require "sqlite3"
-require "securerandom"
-
-# Setup in-memory SQLite
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-ActiveRecord::Base.logger = Logger.new(nil)
-
-# Load organizations gem
-$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
-require "organizations"
-
-puts "=" * 70
-puts "SLUGIFIABLE INTEGRATION DEMO"
-puts "=" * 70
-puts
-
-# Create schema
-ActiveRecord::Schema.define do
-  create_table :users, force: :cascade do |t|
-    t.string :name
-    t.string :email, null: false
-    t.timestamps
-  end
-  add_index :users, :email, unique: true
-
-  create_table :organizations, force: :cascade do |t|
-    t.string :name, null: false
-    t.string :slug, null: false  # NOT NULL - must be present before INSERT
-    t.timestamps
-  end
-  add_index :organizations, :slug, unique: true
-
-  create_table :memberships, force: :cascade do |t|
-    t.references :user, null: false, foreign_key: true
-    t.references :organization, null: false, foreign_key: true
-    t.string :role, null: false, default: "member"
-    t.timestamps
-  end
-  add_index :memberships, [:user_id, :organization_id], unique: true
-
-  create_table :organization_invitations, force: :cascade do |t|
-    t.references :organization, null: false, foreign_key: true
-    t.string :email, null: false
-    t.string :token, null: false
-    t.string :role, null: false, default: "member"
-    t.datetime :accepted_at
-    t.datetime :expires_at
-    t.timestamps
-  end
-  add_index :organization_invitations, :token, unique: true
-end
-
-class User < ActiveRecord::Base
-  extend Organizations::Models::Concerns::HasOrganizations::ClassMethods
-  has_organizations
-  validates :email, presence: true, uniqueness: true
-end
-
-# ============================================================================
-# Test 1: Basic Slug Generation
-# ============================================================================
-puts "TEST 1: Basic Slug Generation"
-puts "-" * 40
-
-org = Organizations::Organization.create!(name: "Acme Corporation")
-puts "Created: '#{org.name}'"
-puts "Slug:    '#{org.slug}'"
-puts "Expected: slug should be 'acme-corporation'"
-puts "Result:   #{org.slug == 'acme-corporation' ? '✅ PASS' : "❌ FAIL (got #{org.slug})"}"
-puts
-
-# ============================================================================
-# Test 2: Slug Uniqueness (Multiple orgs with same name)
-# ============================================================================
-puts "TEST 2: Slug Uniqueness (Collision Resolution)"
-puts "-" * 40
-
-Organizations::Organization.delete_all
-
-orgs = []
-10.times do |i|
-  org = Organizations::Organization.create!(name: "Test Company")
-  orgs << org
-  puts "Org #{i + 1}: slug = '#{org.slug}'"
-end
-
-slugs = orgs.map(&:slug)
-unique_slugs = slugs.uniq.length
-puts
-puts "Total orgs: #{orgs.length}"
-puts "Unique slugs: #{unique_slugs}"
-puts "Result: #{unique_slugs == 10 ? '✅ PASS - All slugs unique' : '❌ FAIL - Duplicate slugs found'}"
-puts
-
-# Verify first one has clean slug, others have suffixes
-puts "First org has clean slug: #{orgs.first.slug == 'test-company' ? '✅ PASS' : "❌ FAIL (got #{orgs.first.slug})"}"
-suffixed = orgs[1..].all? { |o| o.slug.start_with?('test-company-') }
-puts "Others have suffixes: #{suffixed ? '✅ PASS' : '❌ FAIL'}"
-puts
-
-# ============================================================================
-# Test 3: NOT NULL Constraint Compatibility
-# ============================================================================
-puts "TEST 3: NOT NULL Constraint (before_validation hook)"
-puts "-" * 40
-
-Organizations::Organization.delete_all
-
-# The schema has slug NOT NULL. Slugifiable normally uses after_create,
-# but organizations uses before_validation to compute slug early.
-
-begin
-  org = Organizations::Organization.new(name: "Startup Inc")
-  puts "Before save - slug: '#{org.slug.inspect}'"
-  org.save!
-  puts "After save - slug: '#{org.slug}'"
-  puts "Result: #{org.slug.present? ? '✅ PASS - Slug computed before INSERT' : '❌ FAIL'}"
-rescue ActiveRecord::NotNullViolation => e
-  puts "❌ FAIL - NOT NULL violation: #{e.message}"
-rescue => e
-  puts "❌ FAIL - Unexpected error: #{e.class} - #{e.message}"
-end
-puts
-
-# ============================================================================
-# Test 4: Slug Generation from Slugifiable Module
-# ============================================================================
-puts "TEST 4: Slugifiable Module Integration"
-puts "-" * 40
-
-org = Organizations::Organization.new(name: "My Awesome Org")
-
-# Check that slugifiable methods are available
-has_compute_slug = org.respond_to?(:compute_slug)
-has_generate_unique_slug = org.respond_to?(:generate_unique_slug, true)
-has_generate_slug_based_on = org.respond_to?(:generate_slug_based_on)
-
-puts "Has compute_slug method: #{has_compute_slug ? '✅ YES' : '❌ NO'}"
-puts "Has generate_unique_slug method: #{has_generate_unique_slug ? '✅ YES' : '❌ NO'}"
-puts "Has generate_slug_based_on method: #{has_generate_slug_based_on ? '✅ YES' : '❌ NO'}"
-
-if has_compute_slug
-  computed = org.compute_slug
-  puts "compute_slug returns: '#{computed}'"
-  puts "Result: #{computed == 'my-awesome-org' ? '✅ PASS' : "❌ FAIL (expected 'my-awesome-org')"}"
-end
-puts
-
-# ============================================================================
-# Test 5: High-Volume Collision Test
-# ============================================================================
-puts "TEST 5: High-Volume Collision Test (50 orgs, same name)"
-puts "-" * 40
-
-Organizations::Organization.delete_all
-
-start_time = Time.now
-orgs = []
-50.times do
-  orgs << Organizations::Organization.create!(name: "Popular Name")
-end
-elapsed = Time.now - start_time
-
-slugs = orgs.map(&:slug)
-unique_count = slugs.uniq.length
-
-puts "Created 50 organizations in #{(elapsed * 1000).round(2)}ms"
-puts "Unique slugs: #{unique_count}/50"
-puts "Result: #{unique_count == 50 ? '✅ PASS' : '❌ FAIL - Some slugs collided'}"
-
-# Show first few and last few slugs
-puts
-puts "Sample slugs:"
-puts "  First: #{orgs.first.slug}"
-puts "  #10:   #{orgs[9].slug}"
-puts "  #25:   #{orgs[24].slug}"
-puts "  Last:  #{orgs.last.slug}"
-puts
-
-# ============================================================================
-# Test 6: Slug Stability (Reloading doesn't change slug)
-# ============================================================================
-puts "TEST 6: Slug Stability (Reload Test)"
-puts "-" * 40
-
-Organizations::Organization.delete_all
-
-org = Organizations::Organization.create!(name: "Stable Org")
-original_slug = org.slug
-puts "Original slug: '#{original_slug}'"
-
-org.reload
-reloaded_slug = org.slug
-puts "After reload:  '#{reloaded_slug}'"
-
-org.touch
-touched_slug = org.slug
-puts "After touch:   '#{touched_slug}'"
-
-stable = (original_slug == reloaded_slug) && (reloaded_slug == touched_slug)
-puts "Result: #{stable ? '✅ PASS - Slug is stable' : '❌ FAIL - Slug changed unexpectedly'}"
-puts
-
-# ============================================================================
-# Test 7: Name Update Doesn't Change Slug (by default)
-# ============================================================================
-puts "TEST 7: Name Update Behavior"
-puts "-" * 40
-
-Organizations::Organization.delete_all
-
-org = Organizations::Organization.create!(name: "Original Name")
-original_slug = org.slug
-puts "Created with name: '#{org.name}', slug: '#{original_slug}'"
-
-org.update!(name: "Updated Name")
-updated_slug = org.slug
-puts "Updated name to: '#{org.name}', slug: '#{updated_slug}'"
-
-# Slugifiable typically doesn't update slugs on name change (by design - URLs stay stable)
-puts "Result: #{original_slug == updated_slug ? '✅ PASS - Slug preserved (URL stability)' : '⚠️ NOTE - Slug changed to reflect new name'}"
-puts
-
-# ============================================================================
-# Test 8: Special Characters in Name
-# ============================================================================
-puts "TEST 8: Special Characters in Name"
-puts "-" * 40
-
-Organizations::Organization.delete_all
-
-test_cases = [
-  ["Café & Bistro", "cafe-bistro"],
-  ["100% Organic Co.", "100-organic-co"],
-  ["日本語会社", nil],  # Non-latin - depends on implementation
-  ["  Lots   Of   Spaces  ", "lots-of-spaces"],
-  ["UPPERCASE NAME", "uppercase-name"],
-  ["name-with-dashes", "name-with-dashes"],
-  ["name_with_underscores", "name-with-underscores"],
-]
-
-test_cases.each do |name, expected|
-  begin
-    org = Organizations::Organization.create!(name: name)
-    if expected
-      result = org.slug == expected ? '✅' : "⚠️ got '#{org.slug}'"
-    else
-      result = org.slug.present? ? "✅ got '#{org.slug}'" : '❌ empty'
-    end
-    puts "  '#{name}' → '#{org.slug}' #{result}"
-  rescue => e
-    puts "  '#{name}' → ❌ ERROR: #{e.message}"
-  end
-end
-puts
-
-# ============================================================================
-# Test 9: Simulated Race Condition
-# ============================================================================
-puts "TEST 9: Simulated Race Condition"
-puts "-" * 40
-puts "(Testing that slugifiable handles RecordNotUnique gracefully)"
-
-Organizations::Organization.delete_all
-
-# Create an org with a specific slug
-existing = Organizations::Organization.create!(name: "Race Test")
-existing_slug = existing.slug
-puts "Existing org slug: '#{existing_slug}'"
-
-# Now simulate what happens if two processes try to create the same slug simultaneously
-# We can't truly simulate threading in this demo, but we can verify the retry mechanism
-# exists in slugifiable
-
-# Check if slugifiable has the retry mechanism
-org_instance = Organizations::Organization.new(name: "Test")
-has_retry = org_instance.respond_to?(:set_slug_with_retry, true)
-puts "Has set_slug_with_retry: #{has_retry ? '✅ YES' : '❌ NO'}"
-
-if has_retry
-  puts "Result: ✅ PASS - Race condition handling is available"
-else
-  puts "Result: ⚠️ NOTE - set_slug_with_retry not found (may be in older slugifiable version)"
-end
-puts
-
-# ============================================================================
-# Summary
-# ============================================================================
-puts "=" * 70
-puts "SUMMARY"
-puts "=" * 70
-
-# Count passing tests
-Organizations::Organization.delete_all
-
-tests_passed = 0
-tests_total = 9
-
-# Re-run quick checks
-org1 = Organizations::Organization.create!(name: "Summary Test")
-tests_passed += 1 if org1.slug == "summary-test"
-
-org2 = Organizations::Organization.create!(name: "Summary Test")
-tests_passed += 1 if org2.slug != org1.slug
-
-tests_passed += 1 if org1.slug.present? # NOT NULL works
-
-tests_passed += 1 if org1.respond_to?(:compute_slug)
-
-50.times { Organizations::Organization.create!(name: "Bulk") }
-tests_passed += 1 if Organizations::Organization.where("slug LIKE 'bulk%'").count == 50
-
-org1.reload
-tests_passed += 1 if org1.slug == "summary-test"
-
-original = org1.slug
-org1.update!(name: "Changed")
-tests_passed += 1 if org1.slug == original # Slug stability
-
-org3 = Organizations::Organization.create!(name: "Café Test")
-tests_passed += 1 if org3.slug.present?
-
-tests_passed += 1 if org1.respond_to?(:set_slug_with_retry, true)
-
-puts
-puts "Tests Passed: #{tests_passed}/#{tests_total}"
-puts
-if tests_passed == tests_total
-  puts "🎉 ALL TESTS PASSED - Slugifiable integration is working correctly!"
-else
-  puts "⚠️  Some tests need attention - see details above"
-end
-puts
-puts "=" * 70