rails_lens 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e06defab67dbc0cea4db854e6eb7efc9d66f292dfc675c4f30a6df45d757a8ad
-  data.tar.gz: 621535415ca17f88bc82cc0cf933284e3251fd2d8f7feed01139820b0c62bbfd
+  metadata.gz: 983d1382bf42b79549a4a504e696814846eccf606cd17f9fc3e521cce211f729
+  data.tar.gz: 69714d9bfaf91dc139158649596b8111b6910d7515adb9be9928476ff95e6c3a
 SHA512:
-  metadata.gz: 0dde2b4d9087a1221242451d4c9a31bd558c566659ae25115be060618bd318c40a864b291965d9dab8fd16a9a6f05ddbf9a2e901f9c845a15b8b38e93573988b
-  data.tar.gz: accd1ecbba992e1904c098ad03f946c19b181a42029fb02594efb72af2aee6e169441286cf754ffc866a45de5ed21d24839d77df0ca9cc9fb7a96358b65c5c7c
+  metadata.gz: e580de20d715134c6066995921030e9aaf27ecdce188f455b93eb4bfd3b84d1bf9fcce109d75fe0d0fd340fd856c428d8da0e338e5d3b97299efc60098f72ebd
+  data.tar.gz: b069e0140d3ff3924b4f0ba18695f7646a88167a797e10bdd35d5fb25783ac2f8c7c305e59b22458b1424be22b75c494d2ab37b6f4d4d79448ee189624c869aa

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.5.0](https://github.com/seuros/rails_lens/compare/rails_lens/v0.3.0...rails_lens/v0.5.0) (2025-12-06)
+
+
+### ⚠ BREAKING CHANGES
+
+* refactor the extension modules
+
+### Features
+
+* refactor the extension modules ([de80a63](https://github.com/seuros/rails_lens/commit/de80a638f968cc24e1b8c7906054dbb2292df772))
+
 ## [0.3.0](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.13...rails_lens/v0.3.0) (2025-11-29)
 
 

data/lib/rails_lens/commands.rb

@@ -211,14 +211,14 @@ module RailsLens
       File.write(rake_file, rake_task_template)
 
       output.say "Created rake task at #{rake_file}", :green
-      output.say '', :reset
+      output.say ''
       output.say 'The following task has been installed:', :blue
       output.say '  • rails_lens:annotate - Annotate models after migrations', :green
-      output.say '', :reset
+      output.say ''
       output.say 'Configuration options in lib/tasks/rails_lens.rake:', :blue
       output.say '  • AUTO_ANNOTATE (default: true in development)', :cyan
       output.say '  • RAILS_LENS_ENV (default: development)', :cyan
-      output.say '', :reset
+      output.say ''
       output.say 'Disable auto-annotation:', :blue
       output.say '  export AUTO_ANNOTATE=false', :cyan
 

data/lib/rails_lens/configuration.rb

@@ -3,7 +3,7 @@
 module RailsLens
   class Config
     attr_accessor :verbose, :debug, :raise_on_error, :logger,
-                  :annotations, :erd, :schema, :extensions, :routes, :mailers
+                  :annotations, :erd, :schema, :extensions, :routes, :mailers, :model_sources
 
     def initialize
       @verbose = false
@@ -76,6 +76,11 @@ module RailsLens
         pattern: '**/*_mailer.rb',
         exclusion_pattern: 'vendor/**/*_mailer.rb'
       }
+
+      @model_sources = {
+        enabled: true,              # Enable gem-provided model sources
+        error_reporting: :warn      # :silent, :warn, :verbose
+      }
     end
   end
 

data/lib/rails_lens/extension_loader.rb

@@ -138,13 +138,14 @@ module RailsLens
         # Check each loaded gem for RailsLens extensions
 
         Gem.loaded_specs.each_key do |gem_name|
-          # Try to find extension in the gem
-          gem_constant_name = gem_name.gsub('-', '_').split('_').map(&:capitalize).join
-          extension_constant_name = "#{gem_constant_name}::RailsLensExtension"
-
           # Skip gems that are likely to cause autoload issues
           next if %w[digest openssl uri net json].include?(gem_name)
 
+          # Try to find extension in the gem
+          # Use ActiveSupport's camelize for proper Rails-style conversion (e.g., 'activecypher' -> 'ActiveCypher')
+          gem_constant_name = gem_name.gsub('-', '_').camelize
+          extension_constant_name = "#{gem_constant_name}::RailsLensExtension"
+
           # First check if the gem constant exists without triggering autoload
           next unless Object.const_defined?(gem_constant_name, false)
 

data/lib/rails_lens/model_source.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Base class for model sources
+  # Model sources provide pluggable discovery of different model types
+  # (e.g., ActiveRecord, ActiveCypher, etc.)
+  #
+  # Gems can register their own model source by defining:
+  #   GemName::RailsLensModelSource < RailsLens::ModelSource
+  #
+  # Example:
+  #   module MyOrm
+  #     class ModelSource < ::RailsLens::ModelSource
+  #       def self.models(options = {})
+  #         # Return array of model classes
+  #       end
+  #
+  #       def self.file_patterns
+  #         ['app/my_models/**/*.rb']
+  #       end
+  #
+  #       def self.annotate_model(model, options = {})
+  #         # Return { status: :annotated/:skipped/:failed, model: name, ... }
+  #       end
+  #
+  #       def self.remove_annotation(model)
+  #         # Return { status: :removed/:skipped, model: name, ... }
+  #       end
+  #     end
+  #
+  #     RailsLensModelSource = ModelSource
+  #   end
+  #
+  class ModelSource
+    class << self
+      # Return array of model classes to annotate
+      # @param options [Hash] Options passed from CLI
+      # @return [Array<Class>] Array of model classes
+      def models(_options = {})
+        raise NotImplementedError, "#{name} must implement .models"
+      end
+
+      # Return file patterns for annotation removal
+      # Used when removing annotations by filesystem scan
+      # @return [Array<String>] Glob patterns relative to Rails.root
+      def file_patterns
+        raise NotImplementedError, "#{name} must implement .file_patterns"
+      end
+
+      # Annotate a single model
+      # @param model [Class] The model class to annotate
+      # @param options [Hash] Options passed from CLI
+      # @return [Hash] Result with :status (:annotated, :skipped, :failed), :model, :file, :message
+      def annotate_model(_model, _options = {})
+        raise NotImplementedError, "#{name} must implement .annotate_model"
+      end
+
+      # Remove annotation from a single model
+      # @param model [Class] The model class
+      # @return [Hash] Result with :status (:removed, :skipped), :model, :file
+      def remove_annotation(_model)
+        raise NotImplementedError, "#{name} must implement .remove_annotation"
+      end
+
+      # Human-readable name for this source (used in logging)
+      # @return [String]
+      def source_name
+        name.demodulize.sub(/Source$/, '').underscore.humanize
+      end
+    end
+  end
+end

data/lib/rails_lens/model_source_loader.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Discovers and loads model sources from gems
+  # Gems can register sources in two ways:
+  # 1. Define GemName::RailsLensModelSource (auto-discovery)
+  # 2. Call RailsLens::ModelSourceLoader.register(SourceClass) explicitly
+  class ModelSourceLoader
+    @registered_sources = []
+
+    class << self
+      # Register a model source explicitly
+      # Use this when gem naming doesn't follow conventions
+      # @param source [Class] Model source class
+      def register(source)
+        return unless valid_source?(source)
+
+        @registered_sources ||= []
+        @registered_sources << source unless @registered_sources.include?(source)
+      end
+
+      # Load all available model sources
+      # @return [Array<Class>] Array of model source classes
+      def load_sources
+        sources = []
+
+        # Always include ActiveRecord source first
+        sources << ModelSources::ActiveRecordSource
+
+        # Include explicitly registered sources
+        @registered_sources ||= []
+        sources.concat(@registered_sources)
+
+        # Load gem-provided sources via auto-discovery if enabled
+        sources.concat(load_gem_sources) if config_enabled?
+
+        # Deduplicate in case a source was both registered and auto-discovered
+        sources.uniq
+      end
+
+      # List all loaded sources (for debugging/info)
+      # @return [Array<Hash>] Source info with name and class
+      def list_sources
+        load_sources.map do |source|
+          {
+            name: source.source_name,
+            class: source.name,
+            patterns: source.file_patterns
+          }
+        end
+      end
+
+      private
+
+      def config_enabled?
+        config = RailsLens.config.model_sources
+        config && config[:enabled]
+      end
+
+      def load_gem_sources
+        sources = []
+
+        Gem.loaded_specs.each_key do |gem_name|
+          source = find_source_for_gem(gem_name)
+          sources << source if source && valid_source?(source)
+        end
+
+        sources
+      end
+
+      def find_source_for_gem(gem_name)
+        # Skip gems that might cause autoload issues
+        return nil if %w[digest openssl uri net json].include?(gem_name)
+
+        # Convert gem name to constant (e.g., 'activecypher' -> 'ActiveCypher')
+        # Use ActiveSupport's camelize for proper Rails-style conversion
+        gem_constant_name = gem_name.gsub('-', '_').camelize
+
+        # Check if gem constant exists without triggering autoload
+        return nil unless Object.const_defined?(gem_constant_name, false)
+
+        gem_constant = Object.const_get(gem_constant_name)
+        return nil unless gem_constant.is_a?(Module)
+
+        # Check if it has a RailsLensModelSource
+        return nil unless gem_constant.const_defined?('RailsLensModelSource', false)
+
+        gem_constant.const_get('RailsLensModelSource')
+      rescue NameError
+        nil
+      rescue StandardError => e
+        log_error("Error loading model source from #{gem_name}: #{e.message}")
+        nil
+      end
+
+      def valid_source?(klass)
+        return false unless klass.is_a?(Class)
+
+        required_methods = %i[models file_patterns annotate_model remove_annotation]
+        required_methods.all? { |m| klass.respond_to?(m) }
+      end
+
+      def log_error(message)
+        error_reporting = RailsLens.config.model_sources[:error_reporting] || :warn
+
+        case error_reporting
+        when :silent
+          # Do nothing
+        when :warn
+          RailsLens.logger.warn "[RailsLens ModelSources] #{message}"
+        when :verbose
+          RailsLens.logger.error "[RailsLens ModelSources] #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/model_sources/active_record_source.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module ModelSources
+    # Built-in model source for ActiveRecord models
+    class ActiveRecordSource < ModelSource
+      class << self
+        def models(options = {})
+          # Convert models option to include option for ModelDetector
+          opts = options.dup
+          opts[:include] = opts.delete(:models) if opts[:models]
+
+          models = ModelDetector.detect_models(opts)
+
+          # Filter abstract classes based on options
+          if opts[:include_abstract]
+            # Include all models
+          elsif opts[:abstract_only]
+            models = models.select(&:abstract_class?)
+          else
+            # Default: exclude abstract classes
+            models = models.reject(&:abstract_class?)
+          end
+
+          models
+        end
+
+        def file_patterns
+          ['app/models/**/*.rb']
+        end
+
+        def annotate_model(model, options = {})
+          # Use the optimized connection-pooled annotation
+          results = { annotated: [], skipped: [], failed: [] }
+
+          # Group this single model by connection pool for consistency
+          begin
+            pool = model.connection_pool
+            pool.with_connection do |connection|
+              Schema::AnnotationManager.process_model_with_connection(model, connection, results, options)
+            end
+          rescue StandardError
+            # Fallback without connection management
+            Schema::AnnotationManager.process_model_with_connection(model, nil, results, options)
+          end
+
+          if results[:annotated].include?(model.name)
+            { status: :annotated, model: model.name, file: model_file_path(model) }
+          elsif results[:failed].any? { |f| f[:model] == model.name }
+            failure = results[:failed].find { |f| f[:model] == model.name }
+            { status: :failed, model: model.name, message: failure[:error] }
+          else
+            { status: :skipped, model: model.name }
+          end
+        end
+
+        def remove_annotation(model)
+          manager = Schema::AnnotationManager.new(model)
+          if manager.remove_annotations
+            { status: :removed, model: model.name, file: model_file_path(model) }
+          else
+            { status: :skipped, model: model.name }
+          end
+        rescue StandardError => e
+          { status: :failed, model: model.name, message: e.message }
+        end
+
+        def source_name
+          'ActiveRecord'
+        end
+
+        private
+
+        def model_file_path(model)
+          return nil unless model.name
+
+          const_source_location = Object.const_source_location(model.name)
+          return const_source_location.first if const_source_location
+
+          if defined?(Rails.root)
+            Rails.root.join('app', 'models', "#{model.name.underscore}.rb").to_s
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/schema/annotation_manager.rb

@@ -148,6 +148,53 @@ module RailsLens
       end
 
       def self.annotate_all(options = {})
+        results = { annotated: [], skipped: [], failed: [] }
+
+        # Iterate through all model sources
+        ModelSourceLoader.load_sources.each do |source|
+          puts "Annotating #{source.source_name} models..." if options[:verbose]
+          source_results = annotate_source(source, options)
+          merge_results(results, source_results)
+        end
+
+        results
+      end
+
+      # Annotate models from a specific source
+      def self.annotate_source(source, options = {})
+        results = { annotated: [], skipped: [], failed: [] }
+
+        begin
+          models = source.models(options)
+          puts "  Found #{models.size} #{source.source_name} models" if options[:verbose]
+
+          models.each do |model|
+            result = source.annotate_model(model, options)
+            case result[:status]
+            when :annotated
+              results[:annotated] << result[:model]
+            when :skipped
+              results[:skipped] << result[:model]
+            when :failed
+              results[:failed] << { model: result[:model], error: result[:message] }
+            end
+          end
+        rescue StandardError => e
+          puts "  Error processing #{source.source_name} source: #{e.message}" if options[:verbose]
+        end
+
+        results
+      end
+
+      # Merge source results into main results
+      def self.merge_results(main, source)
+        main[:annotated].concat(source[:annotated] || [])
+        main[:skipped].concat(source[:skipped] || [])
+        main[:failed].concat(source[:failed] || [])
+      end
+
+      # Original ActiveRecord-specific annotation logic (used by ActiveRecordSource)
+      def self.annotate_active_record_models(options = {})
         # Convert models option to include option for ModelDetector
         if options[:models]
           options[:include] = options[:models]
@@ -265,10 +312,52 @@ module RailsLens
       end
 
       def self.remove_all(options = {})
-        # Use filesystem-based removal (doesn't require database)
-        remove_all_by_filesystem(options)
+        results = { removed: [], skipped: [], failed: [] }
+
+        # Iterate through all model sources
+        ModelSourceLoader.load_sources.each do |source|
+          puts "Removing annotations from #{source.source_name} models..." if options[:verbose]
+          source_results = remove_source(source, options)
+          merge_remove_results(results, source_results)
+        end
+
+        results
+      end
+
+      # Remove annotations from a specific source
+      def self.remove_source(source, options = {})
+        results = { removed: [], skipped: [], failed: [] }
+
+        begin
+          models = source.models(options.merge(include_abstract: true))
+          puts "  Found #{models.size} #{source.source_name} models" if options[:verbose]
+
+          models.each do |model|
+            result = source.remove_annotation(model)
+            case result[:status]
+            when :removed
+              results[:removed] << result[:model]
+            when :skipped
+              results[:skipped] << result[:model]
+            when :failed
+              results[:failed] << { model: result[:model], error: result[:message] }
+            end
+          end
+        rescue StandardError => e
+          puts "  Error removing from #{source.source_name} source: #{e.message}" if options[:verbose]
+        end
+
+        results
+      end
+
+      # Merge removal results into main results
+      def self.merge_remove_results(main, source)
+        main[:removed].concat(source[:removed] || [])
+        main[:skipped].concat(source[:skipped] || [])
+        main[:failed].concat(source[:failed] || [])
       end
 
+      # Original filesystem-based removal (kept for backwards compatibility)
       def self.remove_all_by_filesystem(options = {})
         base_path = options[:models_path] || default_models_path
         results = { removed: [], skipped: [], failed: [] }

data/lib/rails_lens/tasks/annotate.rake

@@ -21,9 +21,38 @@ namespace :rails_lens do
     end
   end
 
+  desc 'Remove all annotations from models'
+  task remove: :environment do
+    require 'rails_lens/schema/annotation_manager'
+
+    results = RailsLens::Schema::AnnotationManager.remove_all
+
+    puts "Removed annotations from #{results[:removed].length} models" if results[:removed].any?
+    puts "Skipped #{results[:skipped].length} models (no annotations)" if results[:skipped].any?
+    if results[:failed].any?
+      puts "Failed to remove annotations from #{results[:failed].length} models:"
+      results[:failed].each do |failure|
+        puts "  - #{failure[:model]}: #{failure[:error]}"
+      end
+    end
+  end
+
+  desc 'List registered model sources'
+  task sources: :environment do
+    require 'rails_lens'
+
+    puts 'Registered model sources:'
+    RailsLens::ModelSourceLoader.list_sources.each do |source|
+      puts "  - #{source[:name]} (#{source[:class]})"
+      source[:patterns].each do |pattern|
+        puts "      #{pattern}"
+      end
+    end
+  end
+
   desc 'Annotate all Rails files (models, routes, and mailers)'
   task all: :environment do
-    # Annotate models
+    # Annotate models (includes all registered model sources)
     Rake::Task['rails_lens:annotate'].invoke
 
     # Annotate routes
@@ -32,4 +61,16 @@ namespace :rails_lens do
     # Annotate mailers
     Rake::Task['rails_lens:mailers:annotate'].invoke
   end
+
+  desc 'Remove all annotations from Rails files (models, routes, and mailers)'
+  task remove_all: :environment do
+    # Remove model annotations (includes all registered model sources)
+    Rake::Task['rails_lens:remove'].invoke
+
+    # Remove route annotations
+    Rake::Task['rails_lens:routes:remove'].invoke
+
+    # Remove mailer annotations
+    Rake::Task['rails_lens:mailers:remove'].invoke
+  end
 end

data/lib/rails_lens/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsLens
-  VERSION = '0.3.0'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_lens
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -198,6 +198,9 @@ files:
 - lib/rails_lens/mailer/annotator.rb
 - lib/rails_lens/mailer/extractor.rb
 - lib/rails_lens/model_detector.rb
+- lib/rails_lens/model_source.rb
+- lib/rails_lens/model_source_loader.rb
+- lib/rails_lens/model_sources/active_record_source.rb
 - lib/rails_lens/note_codes.rb
 - lib/rails_lens/parsers.rb
 - lib/rails_lens/parsers/class_info.rb