togglefy 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5938d2ca0587fdf06293a3e2da8ad72bb6b7c642eab6a6f12d80f51d963bc3d
-  data.tar.gz: eab43dc22d9a8d0be5566fe2ac81c710d95a6e42972a46073e2e8e390262d894
+  metadata.gz: 2ec8a6fb7ce76c460e59858e7037e4f77f4c86dbc21c1584f9f65f03f39485d2
+  data.tar.gz: 3b8c29fd2841dc785b630698ee18978bce872eafd23fbc591ffeb2f9c9bbb210
 SHA512:
-  metadata.gz: 62cfb19a3d90fa016d451f5fa784a5ce549f8500e43bbd75eb59fa184c3dfb999f65c82eedc41b543830772a7a116287f8a8521b04c775d9f1cea93e66938b99
-  data.tar.gz: cdafbc45941cb93063cad62a4491fd87dc4714da4f71949b686bec1a850246a0d50a0680a4dbd5644c59f001924e01d917bc499a06063c753327121b00a94e26
+  metadata.gz: 98464474a3a3649798424f4c3998db66bf6e07fbeb52505ea94b0bf56ee2d6fbc0b04ecd850e2224d48750930115e55933b3f61d7f5d608b3074411eccb94df3
+  data.tar.gz: f8e53d024ddcfcccde3f098545ce95287d53f32774cf94197e2c2b9361f460bef05ed849af20a0ae14eaa6c8b67577c53014d3c344ba8f4f5a090e6305379fa4

data/README.md

@@ -1,7 +1,13 @@
 # Togglefy
 
-![Gem](https://img.shields.io/gem/v/togglefy)
-![Downloads](https://img.shields.io/gem/dt/togglefy)
+[![Gem](https://img.shields.io/gem/v/togglefy)](https://rubygems.org/gems/togglefy)
+[![CI](https://github.com/azeveco/Togglefy/actions/workflows/ci.yml/badge.svg)](https://github.com/azeveco/Togglefy/actions/workflows/ci.yml)
+[![Downloads](https://img.shields.io/gem/dt/togglefy)](https://rubygems.org/gems/togglefy)
+[![License](https://img.shields.io/badge/license-MIT-yellowgreen.svg)](#license)
+
+[![GitHub](https://img.shields.io/badge/github-azeveco/Togglefy-blue.svg)](http://github.com/azeveco/Togglefy)
+[![Documentation](https://img.shields.io/badge/docs-rdoc.info-yellow.svg)](https://rubydoc.info/github/azeveco/Togglefy/main)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/azeveco/Togglefy)
 
 Togglefy is a simple feature management solution to help you control which features an user or a group has access to.
 
@@ -11,9 +17,8 @@ Togglefy is free, open source and you are welcome to help build it.
 
 Add the gem manually to your Gemfile:
 
-```gemfile
-gem 'togglefy', '~> 1.0', '>= 1.1.1'
-```
+```ruby
+gem "togglefy", "~> 1.2.1"
 
 Or install it and add to the application's Gemfile by executing:
 
@@ -32,48 +37,27 @@ gem install togglefy
 ### First steps
 
 #### Installing inside the project
+
 After adding the gem to your project, you need to run the generate command to add the necessary files:
+
 ```bash
 rails generate togglefy:install
 ```
 
 This command will create the migrations to create the tables inside your project.
 
-If you use an older version of Rails (< 5), then the migration files don't need you to specify the version.
-
-To fix this, you will have to manually go to the two migration files of Togglefy: `create_feature` and `create_feature_assignments` and do the following:
-
-Change these lines from this:
-
-```ruby
-rails_version = "#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}"
-
-class CreateTogglefyFeatures < ActiveRecord::Migration[rails_version]
-```
-
-```ruby
-rails_version = "#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}"
-
-class CreateTogglefyFeatureAssignments < ActiveRecord::Migration[rails_version]
-```
-
-To this:
-
-```ruby
-class CreateTogglefyFeatures < ActiveRecord::Migration
-```
-
-```ruby
-class CreateTogglefyFeatureAssignments < ActiveRecord::Migration
-```
+Make sure that the migration `CreateTogglefyFeatureAssignments` have the correct data type for the assignable (table/model) that you're going to use.
 
 Please, don't remove/change anything else that's there or Togglefy may not work as expected.
 
 Run the migration to create these in your datase:
+
 ```bash
 rails db:migrate
 ```
+
 Or if you're using a legacy codebase:
+
 ```bash
 rake db:migrate
 ```
@@ -87,6 +71,7 @@ After that, the next steps are also pretty simple.
 #### Including inside the Assignable
 
 Add the following to your model that will have a relation with the features. It can be an `User`, `Account` or something you decide:
+
 ```ruby
 include Togglefy::Assignable
 ```
@@ -100,6 +85,7 @@ With that, everything is ready to use **Togglefy**, welcome!
 ### Managing Features
 
 #### Creating Features
+
 To create features it's as simple as drinking a nice cold beer after a hard day or drinking the entire bottle of coffee in a span of 1 hour:
 
 ```ruby
@@ -146,16 +132,18 @@ The identifier is the name, downcased and snake_cased 🐍
 Whenever you create a `Togglefy::Feature`, you can expect something like this:
 
 ```ruby
-id: 1,
-name: "Super Powers",
-identifier: "super_powers",
-description: "With great power comes great responsibility",
-created_at: "2025-04-12 01:39:10.176561000 +0000",
-updated_at: "2025-04-12 01:39:46.818928000 +0000",
-tenant_id: "123abc",
-group: "admin",
-environment: "production",
-status: "inactive"
+{
+  id: 1,
+  name: "Super Powers",
+  identifier: "super_powers",
+  description: "With great power comes great responsibility",
+  created_at: "2025-04-12 01:39:10.176561000 +0000",
+  updated_at: "2025-04-12 01:39:46.818928000 +0000",
+  tenant_id: "123abc",
+  group: "admin",
+  environment: "production",
+  status: "inactive"
+}
 ```
 
 #### Updating a Feature
@@ -210,14 +198,16 @@ The status holds the `inactive` or `active` values. This status is not to define
 It's up to you to define how you will implement it.
 
 * Is it disabled? Then this feature is likely unrelease
-* Or maybe if it is disabled, you can see the flag to active to an assignable but can't change the values?
+* Or maybe if it is inactive, it means that the feature is unavailable for some reason? Maintenance?
 
 Again, it's up to you!
 
 You can change the status by:
+
 * Sending a value during creation
 * Updating the column
 * Doing a:
+
   ```ruby
   Togglefy::Feature.find_by(identifier: :super_powers).active!
   Togglefy.feature(:super_powers).active!
@@ -231,6 +221,7 @@ You can change the status by:
   ```
 
 ### Managing Assignables <-> Features
+
 Now that we know how to create features, let's check how we can manage them.
 
 An assignable has some direct methods thanks to the `include Togglefy::Assignable`, which are (and let's use an user as an example of an assignable):
@@ -269,27 +260,29 @@ Togglefy.for(assignable).disable(:alpha_access).enable(:beta_access)
 This second method may look strange, but it's the default used by the gem and you will see that right now!
 
 #### Mass Enable/Disable of Features to/from Assignables
+
 You can mass enable/disable features to/from Assignables.
 
 Doing that is simple! Let's assume that your assignable is an User model.
 
 ```ruby
 Togglefy.mass_for(User).bulk.enable(:super_powers) # To enable a specific feature to all users
-Togglefy.mass_for(User).bulk.enable([:super_powers, :magic, ...]) # To enable two or more features to all users
+Togglefy.mass_for(User).bulk.enable([:super_powers, :magic]) # To enable two or more features to all users
 Togglefy.mass_for(User).bulk.enable(:super_powers, percentage: 20) # To enable a feature to 20% of all users
-Togglefy.mass_for(User).bulk.enable([:super_powers, :magic, ...], percentage: 50) # To enable two or more features to 50% of all users
+Togglefy.mass_for(User).bulk.enable([:super_powers, :magic], percentage: 50) # To enable two or more features to 50% of all users
 ```
 
 The same applies to the disable:
 
 ```ruby
 Togglefy.mass_for(User).bulk.disable(:super_powers) # To disable a specific feature to all users
-Togglefy.mass_for(User).bulk.disable([:super_powers, :magic, ...]) # To disable two or more features to all users
+Togglefy.mass_for(User).bulk.disable([:super_powers, :magic]) # To disable two or more features to all users
 Togglefy.mass_for(User).bulk.disable(:super_powers, percentage: 5) # To disable a feature to 5% of all users
-Togglefy.mass_for(User).bulk.disable([:super_powers, :magic, ...], percentage: 75) # To disable two or more features to 75% of all users
+Togglefy.mass_for(User).bulk.disable([:super_powers, :magic], percentage: 75) # To disable two or more features to 75% of all users
 ```
 
 There are a few things to pay attention:
+
 * Whenever you do a enable/disable, it will only query for valid assignables, so:
   * If you do a enable, it will query all assignables that don't have the feature(s) enabled
   * If you do a disable, it will query all assignables that do already have the feature(s) enabled
@@ -309,6 +302,7 @@ Togglefy.mass_for(User).bulk.disable(:magic, group: :dev, env: :production, perc
 ```
 
 ### Querying Features
+
 Remember when I told you a looooong time ago that the strange way is the default using by the gem? If you don't, no worries. It was a really loooong time ago, like `1.minute.ago`.
 
 It's actually pretty simple. Each line of each code block will show you a way to query to achieve the same result in the context. You **don't** need to use all of options listed in each code block.
@@ -337,7 +331,7 @@ This will query me all `Togglefy::Feature`s that belongs to group admin and the
 The `Togglefy.for_filters` can have the following filters:
 
 ```ruby
-filters: {
+{
   group:,
   role:, # Acts as a group, explained in the Aliases section
   environment:,
@@ -371,6 +365,7 @@ Togglefy.without_tenant
 ```
 
 #### Querying by Status
+
 To query Togglefy::Features by status (the same applies to inactive).
 
 ```ruby
@@ -380,6 +375,7 @@ Togglefy.with_status(:active)
 ```
 
 #### Finding a specific feature
+
 ```ruby
 Togglefy.feature(:super_powers)
 Togglefy::Feature.identifier(:super_powers)
@@ -387,6 +383,7 @@ Togglefy::Feature.find_by(identifier: :super_powers)
 ```
 
 #### Finding multiple features
+
 ```ruby
 Togglefy.feature([:super_powers, :magic])
 Togglefy::Feature.identifier([:super_powers, :magic])
@@ -394,6 +391,7 @@ Togglefy::Feature.where(identifier: [:super_powers, :magic])
 ```
 
 #### List all features of an Assignable
+
 Let's pretend that your assignable is an User.
 
 ```ruby
@@ -402,6 +400,7 @@ user.features
 ```
 
 #### Check all features an Assignable have/doesn't have
+
 Again, let's pretend that your assignable is an User. This is the only case you need to send the feature id and not the identifier.
 
 ```ruby
@@ -412,12 +411,14 @@ User.without_features([2, 3])
 ```
 
 #### Querying all features
+
 ```ruby
-Togglefy.features(:super_powers)
+Togglefy.features
 Togglefy::Feature.all
 ```
 
 #### Querying all features enabled to a klass
+
 Let's assume that you have two different assignables: User and Account.
 
 You want to list all features being used by assignables of User type:
@@ -431,6 +432,7 @@ Togglefy.for_type(User) # This returns all current FeatureAssignment with a User
 By the way, did you notice that I wrote `group` and `role` to get group?
 
 There are aliases for both group and environment that can be used outside of `Togglefy::Feature`. If you want to query `Togglefy::Feature` directly, use only the default name.
+
 * `group` can be written as `role` outside of `Togglefy::Feature`
 * `environment` can be written as `env` out side of `Togglefy::Feature`
 
@@ -467,44 +469,67 @@ You can use either, as long as you respect the rules listed.
 | `deactive!`           | `inactivate_feature` | None                                                |
 | `destroy`             | `destroy_feature`    | None                                                |
 
-
 ## Development
+
 ### Setup the environment
+
 1. Clone the repository
 2. Run `bin/setup` on the Gem's root directory to install dependencies and run the dummy Rails app migrations used for tests
 3. Create your branch and checkout to it
 
 ### Running the tests
+
 1. Make sure that the dummy Rails app db and migrations were ran
 2. Run `bundle exec rspec` on the Gem's root directory to run all the tests
 3. If you want to specify a single file to run the tests: `bundle exec rspec path/to/spec/file.rb`
 4. If you want to specify a single test of a single file to run: `bundle exec spec path/to/spec/file.rb:42` where 42 represents the number of the line
 
 ### Running RuboCop
+
 1. Make sure you're at the Gem's root directory
 2. Run `bundle exec rubocop` to run RuboCop on all files not ignored by the `.rubocop.yml` file
 3. Run `bundle exec rubocop app spec lib/something.rb` to run RuboCop on specific directories/files
 4. Run `bundle exec rubocop -a` to fix all the auto-correctable offenses listed by RuboCop
 
+### Generate YARD documentation (optional)
+
+If you want to generate the YARD documentation, you can do it by running the following command in your terminal:
+
+```bash
+yardoc
+```
+
+The documentation will be generated inside the `doc` folder.
+You can also run the YARD server to check the documentation in your browser:
+
+```bash
+yard server
+```
+
+The folder `docs` is the documentation available for the gem that you can check at https://togglefy.azeveco.com and it does not relate to the `doc` folder generated by the YARD.
+
 ### Other
+
 1. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 ### Use local Togglefy Gem with a Rails application
+
 1. Open the Gemfile of your Rails application
 2. Add the following: `gem "togglefy", path: "path/to/togglefy/directory"`
 3. Now you can test everything inside of your Rails application
 
-#### If you make a change to the Togglefy's code and want to test it, make sure to:
+#### If you make a change to the Togglefy's code and want to test it, make sure to
+
 1. If you're running a Rails server: restart
 2. If you're running a Rails console: `reload!` or restart
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/azeveco/togglefy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/azeveco/togglefy/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at <https://github.com/azeveco/togglefy>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/azeveco/togglefy/blob/master/CODE_OF_CONDUCT.md).
 
 * Where can I check for planned features but not started?
-  * You can check Togglefy's project here: https://github.com/users/azeveco/projects/2 to see the priorities, status and more
-  * Or you can check the issues: https://github.com/azeveco/Togglefy/issues
+  * You can check Togglefy's project here: <https://github.com/users/azeveco/projects/2> to see the priorities, status and more
+  * Or you can check the issues: <https://github.com/azeveco/Togglefy/issues>
 * I have an idea of a feature! What do I do?
   * First things first, check if there's an issue about it first. If it does, put your comments there. If it doesn't, do the following:
     * Are you a developer that wants to develop it? Create a new issue, select the New Feature 🚀 template and fill out everything

data/app/models/togglefy/feature.rb

@@ -1,33 +1,112 @@
 # frozen_string_literal: true
 
 module Togglefy
-  class Feature < ApplicationRecord
-    enum :status, %i[inactive active]
+  # Represents a feature in the Togglefy system.
+  # A feature can have various attributes such as name, identifier, status, and associations with assignables.
+  class Feature < (defined?(ApplicationRecord) ? ApplicationRecord : ActiveRecord::Base)
+    # Enum for feature status.
+    # If Rails version is 7 or higher, use the new enum syntax.
+    # If Rails version is lower, use the old enum syntax.
+    # @!attribute [r] status
+    #   @return [Symbol] The status of the feature (:inactive or :active).
+    if Rails::VERSION::MAJOR >= 7
+      enum :status, %i[inactive active]
+    else
+      enum status: %i[inactive active]
+    end
 
+    # Associations
+    # @!attribute [rw] feature_assignments
+    #   @return [ActiveRecord::Relation] The feature assignments associated with this feature.
     has_many :feature_assignments, dependent: :destroy
-    has_many :assignables, through: :feature_assignments, source: :assignable
 
+    # Callbacks
+    # Builds an identifier for the feature before validation if the name is present and identifier is blank.
     before_validation :build_identifier, if: proc { |f| f.name.present? && f.identifier.blank? }
 
-    scope :identifier, ->(identifier) { where(identifier:) }
+    # Scopes
+    # Finds features by their identifier.
+    # @param identifier [Symbol, String, Array<Symbol, String>] The identifier to search for.
+    # @return [ActiveRecord::Relation] The features matching the identifier.
+    scope :identifier, ->(identifier) { where(identifier: identifier) }
+
+    # Finds features by their group.
+    # @param group [String] The group to search for.
+    # @return [ActiveRecord::Relation] The features matching the group.
+    scope :for_group, ->(group) { where(group: group) }
 
-    scope :for_group, ->(group) { where(group:) }
+    # Finds features without a group.
+    # @return [ActiveRecord::Relation] The features without a group.
     scope :without_group, -> { where(group: nil) }
 
-    scope :for_environment, ->(environment) { where(environment:) }
+    # Finds features by their environment.
+    # @param environment [String] The environment to search for.
+    # @return [ActiveRecord::Relation] The features matching the environment.
+    scope :for_environment, ->(environment) { where(environment: environment) }
+
+    # Finds features without an environment.
+    # @return [ActiveRecord::Relation] The features without an environment.
     scope :without_environment, -> { where(environment: nil) }
 
-    scope :for_tenant, ->(tenant_id) { where(tenant_id:) }
+    # Finds features by their tenant ID.
+    # @param tenant_id [String] The tenant ID to search for.
+    # @return [ActiveRecord::Relation] The features matching the tenant ID.
+    scope :for_tenant, ->(tenant_id) { where(tenant_id: tenant_id) }
+
+    # Finds features without a tenant.
+    # @return [ActiveRecord::Relation] The features without a tenant.
     scope :without_tenant, -> { where(tenant_id: nil) }
 
+    # Finds features with an inactive status.
+    # @return [ActiveRecord::Relation] The features with an inactive status.
     scope :inactive, -> { where(status: :inactive) }
+
+    # Finds features with an active status.
+    # @return [ActiveRecord::Relation] The features with an active status.
     scope :active, -> { where(status: :active) }
-    scope :with_status, ->(status) { where(status:) }
 
+    # Finds features by their status.
+    # @param status [Symbol, String, Integer] The status to search
+    # (:inactive || "inactive" || 0) or (:active || "active" || 1).
+    # @return [ActiveRecord::Relation] The features matching the status.
+    scope :with_status, ->(status) { where(status: status) }
+
+    # Validations
+    # Validates the presence and uniqueness of the name and identifier attributes.
     validates :name, :identifier, presence: true, uniqueness: true
+    validates :identifier, format: {
+      with: /\A[a-z]+(_[a-z0-9]+)*\z/,
+      message: "must be in snake_case (lowercase letters and underscores only)"
+    }
+
+    # This method retrieves all assignables linked to the feature through feature assignments.
+    # @return [ActiveRecord::Relation] The assignables associated with the feature.
+    # @example
+    #   feature.assignables
+    #   Togglefy.feature(:super_powers).assignables
+    #   Togglefy::Feature.find_by(identifier: :super_powers).assignables
+    # @note This method includes all assignables, regardless of their class.
+    def assignables
+      feature_assignments.includes(:assignable).map(&:assignable)
+    end
+
+    # This method retrieves assignables of a specific class linked to the feature through feature assignments.
+    # @param klass [String, Class] The class name or class of the assignable class.
+    # @return [ActiveRecord::Relation] The assignables of the specified class associated with the feature.
+    # @example
+    #   feature.assignables_for_klass("User")
+    #   feature.assignables_for_klass(User)
+    #   Togglefy.feature(:super_powers).assignables_for_klass(User)
+    #   Togglefy::Feature.find_by(identifier: :super_powers).assignables_for_klass(User)
+    def assignables_for_type(klass)
+      feature_assignments.includes(:assignable).where(assignable_type: klass.to_s).map(&:assignable)
+    end
 
     private
 
+    # Builds a unique identifier for the feature based on its name.
+    # The identifier is generated by parameterizing the name with underscores.
+    # @return [void]
     def build_identifier
       self.identifier = name.underscore.parameterize(separator: "_")
     end

data/app/models/togglefy/feature_assignment.rb

@@ -1,10 +1,22 @@
 # frozen_string_literal: true
 
 module Togglefy
+  # Represents the assignment of a feature to an assignable entity.
+  # A feature assignment links a feature to an assignable object, which can be of any polymorphic type.
   class FeatureAssignment < ApplicationRecord
+    # Associations
+    # @!attribute [rw] feature
+    #   @return [Feature] The feature associated with this assignment.
     belongs_to :feature, class_name: "Togglefy::Feature"
+
+    # @!attribute [rw] assignable
+    #   @return [Object] The polymorphic assignable object associated with this assignment.
     belongs_to :assignable, polymorphic: true
 
+    # Scopes
+    # Finds feature assignments for a specific assignable type.
+    # @param klass [Class] The class type of the assignable.
+    # @return [ActiveRecord::Relation] The feature assignments for the given type.
     scope :for_type, ->(klass) { where(assignable_type: klass.to_s) }
   end
 end

data/lib/generators/togglefy/install_generator.rb

@@ -4,20 +4,49 @@ require "rails/generators"
 require "rails/generators/migration"
 
 module Togglefy
+  # The Generators module contains Rails generators for setting up and managing Togglefy in a Rails application.
   module Generators
+    # The InstallGenerator class is responsible for setting up the necessary migrations
+    # for the Togglefy gem in a Rails application. It generates migration files for
+    # creating features and feature assignments.
+    #
+    # @example Usage
+    #   rails generate togglefy:install
     class InstallGenerator < Rails::Generators::Base
       include Rails::Generators::Migration
 
+      # Sets the source directory for templates used by the generator.
       source_root File.expand_path("templates", __dir__)
 
+      # Generates a migration file numbered with the current timestamp.
+      #
+      # @param _path [String] The path to the migration file.
+      # @return [String] The migration number formatted as YYYYMMDDHHMMSS.
+      # @example
+      #   def self.next_migration_number(_path)
+      #     Time.now.utc.strftime("%Y%m%d%H%M%S")
+      #   end
+      #   # => "20231005123456"
+      # @note This method is used to ensure that the migration file has a unique
+      #       timestamp, preventing conflicts with other migrations.
       def self.next_migration_number(_path)
         Time.now.utc.strftime("%Y%m%d%H%M%S")
       end
 
+      # Copies the migration templates to the Rails application's db/migrate directory.
+      #
+      # @return [void]
+      # @note The `sleep` call ensures that the second migration file gets a unique timestamp.
       def copy_migrations
-        migration_template "create_features.rb", "db/migrate/create_togglefy_features.rb"
-        sleep 1.5
-        migration_template "create_feature_assignments.rb", "db/migrate/create_togglefy_feature_assignments.rb"
+        if Rails::VERSION::MAJOR >= 5
+          migration_template "create_features.rb", "db/migrate/create_togglefy_features.rb"
+          sleep 1
+          migration_template "create_feature_assignments.rb", "db/migrate/create_togglefy_feature_assignments.rb"
+        else
+          migration_template "older_rails_create_features.rb", "db/migrate/create_togglefy_features.rb"
+          sleep 1
+          migration_template "older_rails_create_feature_assignments.rb", "db/migrate/create_togglefy_feature_assignments.rb" # rubocop:disable Layout/LineLength
+        end
       end
     end
   end

data/lib/generators/togglefy/templates/older_rails_create_feature_assignments.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateTogglefyFeatureAssignments < ActiveRecord::Migration
+  def change
+    create_table :togglefy_feature_assignments do |t|
+      t.references :feature, null: false
+      t.references :assignable, polymorphic: true, null: false
+      t.timestamps
+    end
+    add_foreign_key :togglefy_feature_assignments, :togglefy_features, column: :feature_id
+    add_index :togglefy_feature_assignments, %i[feature_id assignable_type assignable_id], unique: true,
+                                                                                           name: "index_togglefy_assignments_uniqueness"
+  end
+end

data/lib/generators/togglefy/templates/older_rails_create_features.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateTogglefyFeatures < ActiveRecord::Migration
+  def change
+    create_table :togglefy_features do |t|
+      t.string :name, null: false
+      t.string :identifier, null: false
+      t.string :description
+      t.string :tenant_id
+      t.string :group
+      t.string :environment
+      t.integer :status, default: 0, null: false
+      t.timestamps
+    end
+    add_index :togglefy_features, :name, unique: true
+    add_index :togglefy_features, :identifier, unique: true
+  end
+end

data/lib/togglefy/assignable.rb

@@ -3,13 +3,19 @@
 require "active_support/concern"
 
 module Togglefy
+  # The Assignable module provides functionality for models to relate with features.
+  # It includes methods to add, remove, and query features, as well as ActiveRecord scopes.
   module Assignable
     extend ActiveSupport::Concern
 
     included do
+      # Establishes a many-to-many relationship with features through feature assignments.
       has_many :feature_assignments, as: :assignable, class_name: "Togglefy::FeatureAssignment"
       has_many :features, through: :feature_assignments, class_name: "Togglefy::Feature"
 
+      # Scope to retrieve assignables with specific features.
+      #
+      # @param feature_ids [Array<Integer>] The IDs of the features to filter by.
       scope :with_features, lambda { |feature_ids|
         joins(:feature_assignments)
           .where(feature_assignments: {
@@ -18,6 +24,9 @@ module Togglefy
           .distinct
       }
 
+      # Scope to retrieve assignables without specific features.
+      #
+      # @param feature_ids [Array<Integer>] The IDs of the features to filter by.
       scope :without_features, lambda { |feature_ids|
         joins(left_join_on_features(feature_ids))
           .where("fa.id IS NULL")
@@ -25,27 +34,42 @@ module Togglefy
       }
     end
 
+    # Checks if the assignable has a specific feature.
+    #
+    # @param identifier [Symbol, String] The identifier of the feature.
+    # @return [Boolean] True if the feature exists, false otherwise.
     def feature?(identifier)
-      features.exists?(identifier: identifier.to_s)
+      features.active.exists?(identifier: identifier.to_s)
     end
     alias has_feature? feature?
 
+    # Adds a feature to the assignable.
+    #
+    # @param feature [Togglefy::Feature, String] The feature or its identifier.
     def add_feature(feature)
       feature = find_feature!(feature)
       features << feature unless has_feature?(feature.identifier)
     end
 
+    # Removes a feature from the assignable.
+    #
+    # @param feature [Togglefy::Feature, String] The feature or its identifier.
     def remove_feature(feature)
       feature = find_feature!(feature)
       features.destroy(feature) if has_feature?(feature.identifier)
     end
 
+    # Clears all features from the assignable.
     def clear_features
       features.destroy_all
     end
 
     private
 
+    # Finds a feature by its identifier or returns the feature if already provided.
+    #
+    # @param feature [Togglefy::Feature, String] The feature or its identifier.
+    # @return [Togglefy::Feature] The found feature.
     def find_feature!(feature)
       return feature if feature.is_a?(Togglefy::Feature)
 
@@ -53,6 +77,10 @@ module Togglefy
     end
 
     class_methods do
+      # Generates a SQL LEFT JOIN clause for features.
+      #
+      # @param feature_ids [Array<Integer>] The IDs of the features to join on.
+      # @return [String] The SQL LEFT JOIN clause.
       def left_join_on_features(feature_ids)
         table = table_name
         type = name