contextual_config 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f59ad6d1973f90217140881d7cf16006e9a0447641b4f7cc2cd18116a97e2cb
-  data.tar.gz: ec5e9472a87b390f4f1b720c9a970cd39dbe498acf0e501722662d9bcfb5bc16
+  metadata.gz: 7c7a19182d63d0f03712caf91b5b996bd99af38f3a6eed254d8497ff3c78af46
+  data.tar.gz: a55ebca13917e3b7fe37f45a0d14a7279a860705ec3c1461eb0071cc1acf67c1
 SHA512:
-  metadata.gz: 96eec3b206c9f1138954885d5ba7af8c4f64751677ce41061829953278dd3e71c9f5f3f18de2a159b61259a7fae06c976b5c6dcfda0d04e99d30d85e62cb6f5b
-  data.tar.gz: 11bb322511c97d471442f84949f182758c97b45dba6938c59e03c7bbb9160bc2163f15565ba71a81d8a0e26710941149d882e1eee3a4a8ad44df15efd29468c9
+  metadata.gz: dfb97ec675a0d72ce010f4e9f809e25cc01baff02dbafbfd83a17ae62eba7bd2a5cf9dfc39fe670075c09ef17f205297fc63c074ecac3fa7b422faa08811ba95
+  data.tar.gz: 941b9502f8cbcaa055f57d668c87c622dcc0f3efd3d1ef929cf5dc2533a487820badd234557187080870d36a7c11460887c624944da9511091a8d769e85e0f7a

data/CLAUDE.md

@@ -18,7 +18,7 @@ ContextualConfig is a Ruby gem for context-aware configuration management built
 
 ### 1. Core Concerns (lib/contextual_config/concern/)
 
-- **Configurable**: Provides validations, scopes, and basic configuration functionality. Expects database columns: `key`, `config_data` (jsonb), `scoping_rules` (jsonb), `priority` (integer), `is_active` (boolean)
+- **Configurable**: Provides validations, scopes, and basic configuration functionality. Expects database columns: `key`, `config_data` (jsonb), `scoping_rules` (jsonb), `priority` (integer), `deleted_at` (datetime)
 - **Lookupable**: Handles configuration lookup logic with `find_applicable_config(key:, context:)` and `find_all_applicable_configs(context:)`  
 - **SchemaDrivenValidation**: Optional JSON schema validation for `config_data` and `scoping_rules`
 
@@ -51,7 +51,7 @@ t.string :key, null: false
 t.jsonb :config_data, null: false, default: {}
 t.jsonb :scoping_rules, null: false, default: {}
 t.integer :priority, null: false, default: 100
-t.boolean :is_active, null: false, default: true
+t.datetime :deleted_at
 t.text :description
 t.string :type # For STI if needed
 ```

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in contextual_config.gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    contextual_config (0.1.0)
+    contextual_config (0.3.0)
       activerecord (>= 6.0)
       activesupport (>= 6.0)
       json-schema (~> 5.1)

data/README.md

@@ -111,7 +111,7 @@ Each configuration record contains:
 - **config_data**: The actual configuration payload (JSONB)
 - **scoping_rules**: Rules defining when this config applies (JSONB)
 - **priority**: Lower numbers = higher priority (integer)
-- **is_active**: Enable/disable configurations (boolean)
+- **deleted_at**: Soft delete timestamp (datetime, null for active)
 - **type**: For Single Table Inheritance (string, optional)
 
 ### Context Matching
@@ -229,7 +229,7 @@ def change
     t.jsonb :config_data, null: false, default: {}
     t.jsonb :scoping_rules, null: false, default: {}
     t.integer :priority, null: false, default: 100
-    t.boolean :is_active, null: false, default: true
+    t.datetime :deleted_at
     t.text :description
     t.string :type
     
@@ -665,21 +665,71 @@ Benefits::InsuranceConfig.create!(
 
 ## Performance Considerations
 
+### Caching System
+
+ContextualConfig includes a sophisticated two-level caching system for optimal performance:
+
+#### 1. Candidates Cache
+Caches the database query results (list of potential configurations) to avoid repeated database hits for the same key/context combinations.
+
+#### 2. Results Cache  
+Caches the final matched configuration after processing all matching logic, providing the fastest possible lookups for repeated requests.
+
+### Cache Configuration
+
+```ruby
+# Enable caching globally
+ContextualConfig.configure do |config|
+  config.cache_enabled = true
+  config.cache_ttl = 300 # 5 minutes
+  config.cache_store = Rails.cache
+end
+
+# Fine-grained cache control in your models
+class CustomConfig < ApplicationRecord
+  include ContextualConfig::Concern::Configurable
+  include ContextualConfig::Concern::Lookupable
+
+  protected
+
+  # Override to disable candidate caching for specific scenarios
+  def self.cache_candidates?(key:, context:)
+    # Only cache for stable contexts, not time-sensitive ones
+    !context.key?(:current_timestamp)
+  end
+
+  # Override to disable result caching for specific scenarios  
+  def self.cache_results?(key:, context:)
+    # Cache results except for admin users who need real-time data
+    context[:user_role] != 'admin'
+  end
+
+  # Override to customize candidate selection
+  def self.lookup_candidates(key:, context:)
+    # Custom logic for fetching candidates
+    active.where(key: key.to_s, department: context[:department]).order_by_priority
+  end
+end
+```
+
 ### Benchmarks
 
 Based on testing with the JisrHR application:
 
-- **Average lookup time**: ~3ms per configuration lookup
-- **100 concurrent lookups**: Completed in ~0.3 seconds  
+- **Average lookup time**: ~3ms per configuration lookup (uncached)
+- **Cached lookup time**: ~0.1ms per configuration lookup  
+- **100 concurrent lookups**: Completed in ~0.3 seconds (uncached), ~0.03 seconds (cached)
 - **Database indexes**: Automatically created by the generator for optimal performance
-- **Memory usage**: Minimal - configurations are loaded on-demand
+- **Memory usage**: Minimal - configurations are loaded on-demand with intelligent caching
 
 ### Optimization Tips
 
-1. **Use appropriate indexes**: The generator creates optimal indexes for common queries
-2. **Cache frequently accessed configurations**: Consider caching at the application level for high-traffic scenarios
-3. **Limit scoping rule complexity**: Simpler rules = faster matching
-4. **Use database-level constraints**: Leverage PostgreSQL JSONB indexes for complex queries
+1. **Enable caching**: Use the built-in two-level caching system for production deployments
+2. **Use appropriate indexes**: The generator creates optimal indexes for common queries
+3. **Customize cache behavior**: Override cache control methods for fine-grained performance tuning
+4. **Limit scoping rule complexity**: Simpler rules = faster matching
+5. **Use database-level constraints**: Leverage PostgreSQL JSONB indexes for complex queries
+6. **Monitor cache hit rates**: Use logging to monitor cache effectiveness
 
 ### Production Deployment
 
@@ -740,6 +790,13 @@ Provides configuration lookup methods:
 - `find_applicable_config(key:, context:)` - Find best match
 - `find_all_applicable_configs(context:)` - Find all matches
 
+**Protected Methods for Customization:**
+
+- `lookup_candidates(key:, context:)` - Override to customize candidate selection for specific keys
+- `lookup_all_candidates(context:)` - Override to customize candidate selection for all configurations
+- `cache_candidates?(key:, context:)` - Override to control candidate caching behavior
+- `cache_results?(key:, context:)` - Override to control result caching behavior
+
 #### ContextualConfig::Concern::SchemaDrivenValidation
 
 Provides JSON schema validation:

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 

data/contextual_config.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'lib/contextual_config/version'
 
 Gem::Specification.new do |spec|
@@ -10,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'ContextualConfig provides a flexible framework for managing configurations that can be applied based on contextual rules, priorities, and scoping. Perfect for complex applications requiring dynamic configuration resolution.'
   spec.homepage      = 'https://github.com/bazinga012/contextual_config'
   spec.license       = 'MIT'
-  spec.required_ruby_version = '>= 3.0.0' # rubocop:disable Gemspec/RequiredRubyVersion
+  spec.required_ruby_version = '>= 3.0.0'
 
   spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   spec.metadata['homepage_uri'] = spec.homepage

data/lib/contextual_config/concern/configurable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 
 module ContextualConfig
@@ -13,7 +15,7 @@ module ContextualConfig
         # - config_data:jsonb
         # - scoping_rules:jsonb
         # - priority:integer (default should be a higher number for lower priority)
-        # - is_active:boolean (default should be true)
+        # - deleted_at:datetime (null for active records)
         # - type:string (if STI is to be used on the including model)
         # - created_at:datetime
         # - updated_at:datetime
@@ -33,9 +35,6 @@ module ContextualConfig
         # It's often better to add this uniqueness validation directly in the consuming model
         # where the scope is clearer.
 
-        # Ensures 'is_active' is either true or false.
-        validates :is_active, inclusion: { in: [true, false], message: 'is not included in the list' }
-
         # Ensures 'priority' is an integer.
         validates :priority, numericality: { only_integer: true, message: 'is not a number' }
 
@@ -43,7 +42,7 @@ module ContextualConfig
 
         # Scope to retrieve only active configurations.
         # Usage: YourModel.active
-        scope :active, -> { where(is_active: true) }
+        scope :active, -> { where(deleted_at: nil) }
 
         # Scope to order configurations by priority.
         # Lower numbers indicate higher priority. Secondary sort by ID for deterministic ordering.
@@ -51,9 +50,8 @@ module ContextualConfig
         scope :order_by_priority, -> { order(priority: :asc, id: :asc) } # 'asc' for priority means 1 is higher than 10
 
         # --- Default Values ---
-        # It's generally recommended to set database-level defaults for `is_active` (true)
-        # and `priority` (e.g., a high number like 100 for low priority).
-        # If not set at DB level, you can use `after_initialize` here, but DB defaults are safer.
+        # It's generally recommended to set database-level defaults for `priority`
+        # (e.g., a high number like 100 for low priority). `deleted_at` defaults to NULL for active records.
         after_initialize :set_default_values, if: :new_record?
       end
 
@@ -63,10 +61,8 @@ module ContextualConfig
 
       def set_default_values
         # Only set defaults if the model is completely new (not loaded from DB and no explicit values set)
-        if new_record? && !attributes_before_type_cast.key?('is_active')
-          self.is_active = true
-        end
-        
+        # deleted_at defaults to NULL (active), no need to set explicitly
+
         # Override database default priority with module-specific priority if available
         set_module_default_priority if should_use_module_default_priority?
       end
@@ -100,7 +96,7 @@ module ContextualConfig
 
       # Helper to quickly check if a configuration is currently active
       def active?
-        is_active
+        deleted_at.nil?
       end
 
       # Get the module configuration for this model if available

data/lib/contextual_config/concern/lookupable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'digest'
 
@@ -17,18 +19,17 @@ module ContextualConfig
         #                                   and fetches only those.
         # @return [ActiveRecord::Base, nil] The instance of the best matching configuration, or nil if no match.
         def find_applicable_config(key:, context:, fetch_all_of_key: false) # rubocop:disable Lint/UnusedMethodArgument
-          # Check cache first if enabled
-          if ContextualConfig.configuration.cache_enabled?
+          # Check result cache first if enabled
+          if cache_results?(key: key, context: context)
+            cache_key = generate_cache_key(key, context)
             begin
-              cache_key = generate_cache_key(key, context)
               cached_result = ContextualConfig.configuration.cache_store.read(cache_key)
               if cached_result
-                log_lookup_attempt(key, context, 'cache_hit')
+                log_lookup_attempt(key, context, 'result_cache_hit')
                 return cached_result
               end
-            rescue => e
-              # Log cache error but continue with database lookup
-              log_cache_error('read', e)
+            rescue StandardError => e
+              log_lookup_attempt(key, context, "result_cache_error: #{e.message}")
             end
           end
 
@@ -37,13 +38,41 @@ module ContextualConfig
 
           # Start with active configurations, ordered by priority (higher priority first).
           # The `Configurable` concern is expected to provide `active` and `order_by_priority` scopes.
-          unless self.respond_to?(:active) && self.respond_to?(:order_by_priority)
-            raise(NoMethodError, "#{self.name} must include ContextualConfig::Concern::Configurable to use Lookupable.")
+          unless respond_to?(:active) && respond_to?(:order_by_priority)
+            raise(NoMethodError, "#{name} must include ContextualConfig::Concern::Configurable to use Lookupable.")
           end
 
-          log_lookup_attempt(key, context, 'database_lookup')
+          # Check candidates cache if enabled
+          candidates = nil
+          if cache_candidates?(key: key, context: context)
+            candidates_cache_key = generate_candidates_cache_key(key, context)
+            begin
+              candidates = ContextualConfig.configuration.cache_store.read(candidates_cache_key)
+              log_lookup_attempt(key, context, 'candidates_cache_hit') if candidates
+            rescue StandardError => e
+              log_lookup_attempt(key, context, "candidates_cache_error: #{e.message}")
+            end
+          end
 
-          candidates = self.active.where(key: key.to_s).order_by_priority
+          # Fetch candidates from database if not cached
+          if candidates.nil?
+            log_lookup_attempt(key, context, 'database_lookup')
+            candidates = lookup_candidates(key: key, context: context)
+            # Cache candidates if enabled
+            if cache_candidates?(key: key, context: context)
+              candidates_cache_key = generate_candidates_cache_key(key, context)
+              begin
+                ContextualConfig.configuration.cache_store.write(
+                  candidates_cache_key,
+                  candidates.to_a, # Convert to array to avoid caching AR relations
+                  expires_in: ContextualConfig.configuration.cache_ttl
+                )
+                log_lookup_attempt(key, context, 'candidates_cache_stored')
+              rescue StandardError => e
+                log_lookup_attempt(key, context, "candidates_cache_write_error: #{e.message}")
+              end
+            end
+          end
 
           # Delegate to the ContextualMatcher service to find the best match from the candidates.
           # The service will handle the logic of iterating through candidates, evaluating scoping_rules,
@@ -54,18 +83,17 @@ module ContextualConfig
           )
 
           # Cache the result if caching is enabled
-          if ContextualConfig.configuration.cache_enabled? && result
+          if cache_results?(key: key, context: context) && result
+            cache_key = generate_cache_key(key, context)
             begin
-              cache_key = generate_cache_key(key, context)
               ContextualConfig.configuration.cache_store.write(
                 cache_key,
                 result,
                 expires_in: ContextualConfig.configuration.cache_ttl
               )
-              log_lookup_attempt(key, context, 'cache_stored')
-            rescue => e
-              # Log cache error but don't fail the operation
-              log_cache_error('write', e)
+              log_lookup_attempt(key, context, 'result_cache_stored')
+            rescue StandardError => e
+              log_lookup_attempt(key, context, "result_cache_write_error: #{e.message}")
             end
           end
 
@@ -80,14 +108,14 @@ module ContextualConfig
         # @param context [Hash] A hash representing the current context.
         # @return [Array<ActiveRecord::Base>] An array of all matching configuration instances, ordered by priority.
         def find_all_applicable_configs(context:)
-          unless self.respond_to?(:active) && self.respond_to?(:order_by_priority)
-            raise(NoMethodError, "#{self.name} must include ContextualConfig::Concern::Configurable to use Lookupable.")
+          unless respond_to?(:active) && respond_to?(:order_by_priority)
+            raise(NoMethodError, "#{name} must include ContextualConfig::Concern::Configurable to use Lookupable.")
           end
 
           log_lookup_attempt('all_configs', context, 'all_configs_lookup')
 
           # Fetch all active configurations of this type, ordered by priority.
-          all_candidates = self.active.order_by_priority
+          all_candidates = lookup_all_candidates(context: context)
 
           # Delegate to the ContextualMatcher service.
           ContextualConfig::Services::ContextualMatcher.find_all_matches(
@@ -96,12 +124,60 @@ module ContextualConfig
           )
         end
 
+        protected
+
+        # Override this method in your configuration class to customize candidate selection
+        # for specific key lookups. This allows fine-grained control over which configurations
+        # are considered for matching.
+        #
+        # @param key [String, Symbol] The configuration key to look for
+        # @param context [Hash] The lookup context
+        # @return [ActiveRecord::Relation] The candidates for matching
+        def lookup_candidates(key:, context:) # rubocop:disable Lint/UnusedMethodArgument
+          active.where(key: key.to_s).order_by_priority
+        end
+
+        # Override this method in your configuration class to customize candidate selection
+        # for all configurations (used by find_all_applicable_configs).
+        #
+        # @param context [Hash] The lookup context
+        # @return [ActiveRecord::Relation] All candidates for matching
+        def lookup_all_candidates(context:) # rubocop:disable Lint/UnusedMethodArgument
+          active.order_by_priority
+        end
+
+        # Override this method to control whether candidates should be cached.
+        # By default, candidates are cached when caching is enabled globally.
+        #
+        # @param key [String, Symbol] The configuration key
+        # @param context [Hash] The lookup context
+        # @return [Boolean] Whether to cache candidates for this lookup
+        def cache_candidates?(key:, context:) # rubocop:disable Lint/UnusedMethodArgument
+          ContextualConfig.configuration.cache_enabled?
+        end
+
+        # Override this method to control whether results should be cached.
+        # By default, results are cached when caching is enabled globally.
+        #
+        # @param key [String, Symbol] The configuration key
+        # @param context [Hash] The lookup context
+        # @return [Boolean] Whether to cache the final result for this lookup
+        def cache_results?(key:, context:) # rubocop:disable Lint/UnusedMethodArgument
+          ContextualConfig.configuration.cache_enabled?
+        end
+
         private
 
         # Generate cache key for configuration lookup
         def generate_cache_key(key, context)
           context_hash = context.is_a?(Hash) ? context.sort.to_h : context
-          "contextual_config:#{self.name}:#{key}:#{Digest::MD5.hexdigest(context_hash.to_s)}"
+          "contextual_config:#{name}:#{key}:#{Digest::MD5.hexdigest(context_hash.to_s)}"
+        end
+
+        # Generate cache key for candidates
+        def generate_candidates_cache_key(key, context)
+          context_hash = context.is_a?(Hash) ? context.sort.to_h : context
+          "contextual_config_candidates:#{name}:#{key}:#{Digest::MD5.hexdigest(context_hash.to_s)}"
         end
 
         # Log configuration lookup attempts
@@ -110,17 +186,7 @@ module ContextualConfig
 
           logger = ContextualConfig.configuration.effective_logger
           logger.info(
-            "ContextualConfig::Lookupable: #{operation} for #{self.name} - Key: #{key}, Context: #{context}"
-          )
-        end
-
-        # Log cache errors
-        def log_cache_error(operation, error)
-          return unless ContextualConfig.configuration.enable_logging?
-
-          logger = ContextualConfig.configuration.effective_logger
-          logger.warn(
-            "ContextualConfig::Lookupable: Cache #{operation} error - #{error.class}: #{error.message}"
+            "ContextualConfig::Lookupable: #{operation} for #{name} - Key: #{key}, Context: #{context}"
           )
         end
       end

data/lib/contextual_config/concern/schema_driven_validation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'json-schema'
 
@@ -42,7 +44,7 @@ module ContextualConfig
 
         begin
           # Using fully_validate to get an array of all errors.
-          errors_found = JSON::Validator.fully_validate(schema, self.config_data, strict: false, insert_defaults: false)
+          errors_found = JSON::Validator.fully_validate(schema, config_data, strict: false, insert_defaults: false)
           if errors_found.any?
             errors_found.each do |error_message|
               # Add a somewhat generic error. More specific parsing of error_message could provide better field-level errors.
@@ -67,7 +69,8 @@ module ContextualConfig
         return unless schema # Skip if no schema defined
 
         begin
-          errors_found = JSON::Validator.fully_validate(schema, self.scoping_rules, strict: false, insert_defaults: false)
+          errors_found = JSON::Validator.fully_validate(schema, scoping_rules, strict: false,
+                                                                               insert_defaults: false)
           if errors_found.any?
             errors_found.each do |error_message|
               errors.add(:scoping_rules, "is invalid - #{error_message}")

data/lib/contextual_config/configuration.rb

@@ -55,13 +55,9 @@ module ContextualConfig
         raise(ConfigurationError, 'Cache is enabled but cache_store is not properly configured')
       end
 
-      if cache_ttl <= 0
-        raise(ConfigurationError, 'cache_ttl must be a positive number')
-      end
+      raise(ConfigurationError, 'cache_ttl must be a positive number') if cache_ttl <= 0
 
-      if default_priority.negative?
-        raise(ConfigurationError, 'default_priority must be non-negative')
-      end
+      raise(ConfigurationError, 'default_priority must be non-negative') if default_priority.negative?
 
       true
     end

data/lib/contextual_config/generators.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/generators'
 
 # Load all generators

data/lib/contextual_config/module_registry.rb

@@ -10,7 +10,7 @@ module ContextualConfig
     end
 
     # Register a module with its configuration
-    def register(module_name, &block)
+    def register(module_name)
       module_sym = module_name.to_sym
       config = @modules[module_sym] || ModuleConfig.new(module_name)
       yield(config) if block_given?

data/lib/contextual_config/services/contextual_matcher.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module ContextualConfig

data/lib/contextual_config/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ContextualConfig
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.3.0'
 end

data/lib/contextual_config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'contextual_config/version'
 require 'active_support'
 require 'active_record'
@@ -66,6 +68,4 @@ module ContextualConfig
 end
 
 # Load Rails generators if Rails is available
-if defined?(Rails)
-  require 'contextual_config/generators'
-end
+require 'contextual_config/generators' if defined?(Rails)

data/lib/generators/contextual_config/configurable_table/configurable_table_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/generators/active_record'
 
 module ContextualConfig

data/lib/generators/contextual_config/configurable_table/templates/migration.rb.tt

@@ -18,8 +18,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version
       # Lower numbers generally indicate higher priority.
       t.integer :priority, null: false, default: 100
 
-      # 'is_active' allows for soft-deleting or disabling configurations.
-      t.boolean :is_active, null: false, default: true
+      # 'deleted_at' allows for soft-deleting configurations.
+      # NULL indicates active configuration, timestamp indicates soft-deleted.
+      t.datetime :deleted_at
 
       # 'description' provides a human-readable summary of the configuration's purpose.
       t.text :description
@@ -41,8 +42,9 @@ class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version
     # Note: If 'type' is not used or key should be globally unique for this table,
     # a simpler index might be `add_index :<%= @migration_table_name %>, :key, unique: true`
 
-    # Index to efficiently query active configurations by priority.
-    add_index :<%= @migration_table_name %>, [:is_active, :priority], name: 'idx_<%= @migration_table_name.first(40) %>_on_active_priority'
+    # Functional index to efficiently query active configurations by priority.
+    # Uses expression index on (deleted_at IS NULL) for optimal soft-delete performance.
+    add_index :<%= @migration_table_name %>, ['(deleted_at IS NULL)', :priority], name: 'idx_<%= @migration_table_name.first(40) %>_on_active_priority'
 
     # Optional: GIN indexes for jsonb columns if you frequently query directly into them.
     # These can be large and have write performance implications, so add if needed.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contextual_config
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - bazinga012
@@ -162,7 +162,6 @@ files:
 - lib/contextual_config/module_registry.rb
 - lib/contextual_config/services/contextual_matcher.rb
 - lib/contextual_config/version.rb
-- lib/generators/contextual_config/configurable_table/USAGE
 - lib/generators/contextual_config/configurable_table/configurable_table_generator.rb
 - lib/generators/contextual_config/configurable_table/templates/migration.rb.tt
 homepage: https://github.com/bazinga012/contextual_config

data/lib/generators/contextual_config/configurable_table/USAGE

@@ -1,33 +0,0 @@
-Description:
-    Generates a migration file for a table that's compatible with ContextualConfig concerns.
-    The table includes all necessary columns for storing contextual configurations including
-    key, config_data (JSONB), scoping_rules (JSONB), priority, is_active, and type (for STI).
-
-Example:
-    ```rails generate contextual_config:configurable_table YourModel```
-
-    This will create:
-        db/migrate/create_your_models.rb
-
-Options:
-    --table-name=TABLE_NAME    # Override the default table name
-                               # Default: pluralized, underscored version of the model name
-
-Examples:
-    rails generate contextual_config:configurable_table Finance::Configuration
-    rails generate contextual_config:configurable_table UserPreference --table-name=user_prefs
-    rails generate contextual_config:configurable_table PayrollConfig
-
-The generated migration creates a table with:
-    - key (string): Identifier for the configuration
-    - config_data (jsonb): Main configuration payload
-    - scoping_rules (jsonb): Rules for when configuration applies
-    - priority (integer): Priority for conflict resolution
-    - is_active (boolean): Enable/disable configurations
-    - description (text): Human-readable description
-    - type (string): For Single Table Inheritance
-    - timestamps: created_at and updated_at
-
-Indexes are automatically created for:
-    - [type, key] (unique)
-    - [is_active, priority] (for efficient querying)