rails_lens 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b150328b6771f2de4015820d40e3942c10b41903687f800fd4b068f79605deeb
-  data.tar.gz: 2d67fc7fd815b1af80c3cb9e1ad8b94e1166129fc3a1eb24e28958ad3e625b47
+  metadata.gz: d9c79f3cf64c15c090934062200871d4166ecc1a68ae4942a078ea4bf39c7c09
+  data.tar.gz: b91275cfeb9c312c6498da217eb0b907e8e6e220793007a75ea27b5d9b6f19e3
 SHA512:
-  metadata.gz: 0b9f944f8e7be0f11789817a49f168f7be310e6742207897029c20540b701c525da861a1b49cdcbeee0690a9bd6424fbace720e6bb42fd5d9d81b46cd244ed88
-  data.tar.gz: 22f3bc6e6223ad726c2fc3cf617c37af1e587e466119fd1138965e38ff51cb9128b441b5081214e79f9e2d334b8ec7990e437bdfb20257783a40a194f572ebfc
+  metadata.gz: 0ccba97c7621956220bce1cfb2c2c6f1152fec52bf95b70247a53e20ccacea4ad414575d41a27a41b43b6818ad9e1d617a57e594820c8d789f1d917e78018f15
+  data.tar.gz: 803764fabe90e5029a46682063980601dba2c8775db3b7e0eb095751270dfce77028ccbe0940876c058b9cc6f0c0d1d909885af7c16a86457a1757af143a0739

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.2.6](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.5...rails_lens/v0.2.6) (2025-08-06)
+
+
+### Bug Fixes
+
+* improve logger configuration and use ActiveRecord ignore_tables ([#16](https://github.com/seuros/rails_lens/issues/16)) ([cf914b9](https://github.com/seuros/rails_lens/commit/cf914b9a421f2f69328e80733229408c9f362963))
+
 ## [0.2.5](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.4...rails_lens/v0.2.5) (2025-07-31)
 
 

data/README.md

@@ -154,13 +154,12 @@ bundle exec rails_lens erd --verbose
 
 ```yaml
 # .rails-lens.yml (optional)
-adapter: auto  # auto-detects PostgreSQL/MySQL/SQLite3
-marker_format: rails-lens:schema  # LLM-friendly markers
-include_notes: true  # Performance recommendations
+schema:
+  include_notes: true  # Performance recommendations
 extensions:
   enabled: true  # ClosureTree, PostGIS, etc.
 erd:
-  output: doc/diagrams  # For those Midjourney visuals!
+  output_dir: doc/diagrams  # You need to add mermaid gem to your Gemfile
 ```
 
 **Database Support**:

data/lib/rails_lens/analyzers/association_analyzer.rb

@@ -69,10 +69,10 @@ module RailsLens
           end
         end
       rescue NameError => e
-        Rails.logger.debug { "Failed to check bidirectional association: #{e.message}" }
+        RailsLens.logger.debug { "Failed to check bidirectional association: #{e.message}" }
         false
       rescue NoMethodError => e
-        Rails.logger.debug { "Method error checking bidirectional association: #{e.message}" }
+        RailsLens.logger.debug { "Method error checking bidirectional association: #{e.message}" }
         false
       end
 

data/lib/rails_lens/analyzers/composite_keys.rb

@@ -21,10 +21,10 @@ module RailsLens
 
         nil
       rescue NoMethodError => e
-        Rails.logger.debug { "Failed to analyze composite keys for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to analyze composite keys for #{model_class.name}: #{e.message}" }
         nil
       rescue ActiveRecord::ConnectionNotEstablished => e
-        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
         nil
       end
 
@@ -51,10 +51,10 @@ module RailsLens
         keys = result.pluck('attname')
         keys.empty? ? nil : keys
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Failed to detect composite keys from database for #{table_name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to detect composite keys from database for #{table_name}: #{e.message}" }
         nil
       rescue PG::Error => e
-        Rails.logger.debug { "PostgreSQL error detecting composite keys: #{e.message}" }
+        RailsLens.logger.debug { "PostgreSQL error detecting composite keys: #{e.message}" }
         nil
       end
     end

data/lib/rails_lens/analyzers/database_constraints.rb

@@ -24,10 +24,10 @@ module RailsLens
 
         constraints.empty? ? nil : constraints.join("\n")
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
         nil
       rescue NoMethodError => e
-        Rails.logger.debug { "Check constraints not supported by adapter: #{e.message}" }
+        RailsLens.logger.debug { "Check constraints not supported by adapter: #{e.message}" }
         nil
       end
     end

data/lib/rails_lens/analyzers/delegated_types.rb

@@ -81,10 +81,10 @@ module RailsLens
 
         delegated_info
       rescue NoMethodError => e
-        Rails.logger.debug { "Failed to find delegated type info for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to find delegated type info for #{model_class.name}: #{e.message}" }
         nil
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Database error finding delegated type info: #{e.message}" }
+        RailsLens.logger.debug { "Database error finding delegated type info: #{e.message}" }
         nil
       end
 
@@ -118,10 +118,10 @@ module RailsLens
           []
         end
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Database error inferring delegated types: #{e.message}" }
+        RailsLens.logger.debug { "Database error inferring delegated types: #{e.message}" }
         []
       rescue Errno::ENOENT => e
-        Rails.logger.debug { "File not found when inferring delegated types: #{e.message}" }
+        RailsLens.logger.debug { "File not found when inferring delegated types: #{e.message}" }
         []
       end
     end

data/lib/rails_lens/analyzers/generated_columns.rb

@@ -45,10 +45,10 @@ module RailsLens
           }
         end
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Failed to detect generated columns for #{table_name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to detect generated columns for #{table_name}: #{e.message}" }
         []
       rescue PG::Error => e
-        Rails.logger.debug { "PostgreSQL error detecting generated columns: #{e.message}" }
+        RailsLens.logger.debug { "PostgreSQL error detecting generated columns: #{e.message}" }
         []
       end
     end

data/lib/rails_lens/analyzers/inheritance.rb

@@ -33,10 +33,10 @@ module RailsLens
         model_class.respond_to?(:delegated_type_reflection) &&
           model_class.delegated_type_reflection.present?
       rescue NoMethodError => e
-        Rails.logger.debug { "Failed to check delegated type for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to check delegated type for #{model_class.name}: #{e.message}" }
         false
       rescue NameError => e
-        Rails.logger.debug { "Name error checking delegated type: #{e.message}" }
+        RailsLens.logger.debug { "Name error checking delegated type: #{e.message}" }
         false
       end
 
@@ -91,10 +91,10 @@ module RailsLens
 
         subclasses.sort
       rescue NoMethodError => e
-        Rails.logger.debug { "Failed to find STI subclasses for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to find STI subclasses for #{model_class.name}: #{e.message}" }
         []
       rescue NameError => e
-        Rails.logger.debug { "Name error finding STI subclasses: #{e.message}" }
+        RailsLens.logger.debug { "Name error finding STI subclasses: #{e.message}" }
         []
       end
 
@@ -110,10 +110,10 @@ module RailsLens
 
         siblings.sort
       rescue NoMethodError => e
-        Rails.logger.debug { "Failed to find STI siblings for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to find STI siblings for #{model_class.name}: #{e.message}" }
         []
       rescue NameError => e
-        Rails.logger.debug { "Name error finding STI siblings: #{e.message}" }
+        RailsLens.logger.debug { "Name error finding STI siblings: #{e.message}" }
         []
       end
 
@@ -136,10 +136,10 @@ module RailsLens
 
         types.uniq.sort
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Database error finding delegated types for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Database error finding delegated types for #{model_class.name}: #{e.message}" }
         []
       rescue ActiveRecord::ConnectionNotEstablished => e
-        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
         []
       end
 
@@ -201,10 +201,10 @@ module RailsLens
           .compact
           .sort
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Database error finding polymorphic types for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Database error finding polymorphic types for #{model_class.name}: #{e.message}" }
         []
       rescue ActiveRecord::ConnectionNotEstablished => e
-        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
         []
       end
     end

data/lib/rails_lens/analyzers/notes.rb

@@ -11,15 +11,15 @@ module RailsLens
         @connection = model_class.connection
         @table_name = model_class.table_name
       rescue ActiveRecord::ConnectionNotEstablished => e
-        Rails.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "No database connection for #{model_class.name}: #{e.message}" }
         @connection = nil
         @table_name = nil
       rescue NoMethodError => e
-        Rails.logger.debug { "Failed to initialize Notes analyzer for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Failed to initialize Notes analyzer for #{model_class.name}: #{e.message}" }
         @connection = nil
         @table_name = nil
       rescue RuntimeError => e
-        Rails.logger.debug { "Runtime error initializing Notes analyzer for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Runtime error initializing Notes analyzer for #{model_class.name}: #{e.message}" }
         @connection = nil
         @table_name = nil
       end
@@ -48,10 +48,10 @@ module RailsLens
 
         notes.compact.uniq
       rescue ActiveRecord::StatementInvalid => e
-        Rails.logger.debug { "Database error analyzing notes for #{@table_name}: #{e.message}" }
+        RailsLens.logger.debug { "Database error analyzing notes for #{@table_name}: #{e.message}" }
         nil
       rescue NoMethodError => e
-        Rails.logger.debug { "Method error analyzing notes for #{@table_name}: #{e.message}" }
+        RailsLens.logger.debug { "Method error analyzing notes for #{@table_name}: #{e.message}" }
         nil
       end
 
@@ -72,7 +72,7 @@ module RailsLens
 
         notes
       rescue StandardError => e
-        Rails.logger.debug { "Error checking view readonly status for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Error checking view readonly status for #{model_class.name}: #{e.message}" }
         []
       end
 
@@ -101,7 +101,7 @@ module RailsLens
 
         notes
       rescue StandardError => e
-        Rails.logger.debug { "Error analyzing view gotchas for #{model_class.name}: #{e.message}" }
+        RailsLens.logger.debug { "Error analyzing view gotchas for #{model_class.name}: #{e.message}" }
         []
       end
 
@@ -341,10 +341,10 @@ module RailsLens
           inverse = association.klass.reflect_on_association(association.inverse_of&.name || model_class.name.underscore.pluralize)
           inverse && inverse.macro == :has_many && !association.options[:counter_cache]
         rescue NameError => e
-          Rails.logger.debug { "Failed to check counter cache for association: #{e.message}" }
+          RailsLens.logger.debug { "Failed to check counter cache for association: #{e.message}" }
           false
         rescue NoMethodError => e
-          Rails.logger.debug { "Method error checking counter cache: #{e.message}" }
+          RailsLens.logger.debug { "Method error checking counter cache: #{e.message}" }
           false
         end
       end
@@ -425,7 +425,7 @@ module RailsLens
           false
         end
       rescue StandardError => e
-        Rails.logger.debug { "Error checking view existence for #{view_name}: #{e.message}" }
+        RailsLens.logger.debug { "Error checking view existence for #{view_name}: #{e.message}" }
         false
       end
     end

data/lib/rails_lens/cli.rb

@@ -79,7 +79,7 @@ module RailsLens
 
         # Transform CLI options to visualizer options
         visualizer_options = options.dup
-        visualizer_options[:output_dir] = options[:output] || 'output'
+        visualizer_options[:output_dir] = options[:output] if options[:output]
 
         commands = Commands.new(self)
         commands.generate_erd(visualizer_options)

data/lib/rails_lens/cli_error_handler.rb

@@ -79,7 +79,7 @@ module RailsLens
         say error.backtrace.first(10).join("\n"), :yellow
       end
 
-      say "\nPlease report this issue at: https://github.com/your-org/rails_lens/issues", :cyan
+      say "\nPlease report this issue at: https://github.com/seuros/rails_lens/issues", :cyan
       exit 1
     end
   end

data/lib/rails_lens/configuration.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Configuration
+    extend ActiveSupport::Concern
+
+    included do
+      # Add configuration for error handling
+      config_accessor :verbose, default: false
+      config_accessor :debug, default: false
+      config_accessor :raise_on_error, default: false
+
+      # Logger configuration
+      config_accessor :logger
+
+      # Configuration using ActiveSupport::Configurable
+      config_accessor :annotations do
+        {
+          position: :before,
+          format: :rdoc
+        }
+      end
+
+      config_accessor :erd do
+        {
+          output_dir: 'doc/erd',
+          orientation: 'TB',
+          theme: true,
+          default_colors: %w[
+            lightblue
+            lightcoral
+            lightgreen
+            lightyellow
+            plum
+            lightcyan
+            lightgray
+          ]
+        }
+      end
+
+      config_accessor :schema do
+        {
+          adapter: :auto,
+          include_notes: true,
+          exclude_tables: nil, # Will use ActiveRecord::SchemaDumper.ignore_tables if nil
+          format_options: {
+            show_defaults: true,
+            show_comments: true,
+            show_foreign_keys: true,
+            show_indexes: true,
+            show_check_constraints: true
+          }
+        }
+      end
+
+      config_accessor :extensions do
+        {
+          enabled: true,
+          autoload: true,
+          interface_version: '1.0',
+          ignore: [],
+          custom_paths: [],
+          error_reporting: :warn,    # :silent, :warn, :verbose
+          fail_safe_mode: true,      # Continue processing if extensions fail
+          track_health: false        # Track extension success/failure rates
+        }
+      end
+
+      config_accessor :routes do
+        {
+          enabled: true,
+          include_defaults: true,
+          include_constraints: true,
+          pattern: '**/*_controller.rb',
+          exclusion_pattern: 'vendor/**/*_controller.rb'
+        }
+      end
+
+      config_accessor :mailers do
+        {
+          enabled: true,
+          include_templates: true,
+          include_delivery_methods: true,
+          include_variables: true,
+          include_locales: true,
+          include_defaults: true,
+          pattern: '**/*_mailer.rb',
+          exclusion_pattern: 'vendor/**/*_mailer.rb'
+        }
+      end
+    end
+  end
+end

data/lib/rails_lens/erd/visualizer.rb

@@ -93,14 +93,14 @@ module RailsLens
             if columns_added
               output << '  }'
               output << ''
-              Rails.logger.debug { "Added entity: #{model_display_name}" } if options[:verbose]
+              RailsLens.logger.debug { "Added entity: #{model_display_name}" } if options[:verbose]
             else
               # Remove the opening brace if no columns were added
               output.slice!(brace_position..-1)
-              Rails.logger.debug { "Skipped entity #{model_display_name}: no columns found" } if options[:verbose]
+              RailsLens.logger.debug { "Skipped entity #{model_display_name}: no columns found" } if options[:verbose]
             end
           rescue StandardError => e
-            Rails.logger.debug { "Warning: Could not add entity #{model.name}: #{e.message}" }
+            RailsLens.logger.debug { "Warning: Could not add entity #{model.name}: #{e.message}" }
             # Remove any partial entity content added since the opening brace
             if output.size > brace_position
               output.slice!(brace_position..-1)
@@ -131,7 +131,7 @@ module RailsLens
         # Save output
         filename = save_output(mermaid_output, 'mmd')
 
-        Rails.logger.debug 'ERD generated successfully!'
+        RailsLens.logger.debug 'ERD generated successfully!'
         filename # Return the filename instead of content
       end
 
@@ -211,7 +211,7 @@ module RailsLens
       def add_belongs_to_relationship(output, model, association, target_model)
         output << "  #{format_model_name(model)} }o--|| #{format_model_name(target_model)} : \"#{association.name}\""
       rescue StandardError => e
-        Rails.logger.debug do
+        RailsLens.logger.debug do
           "Warning: Could not add belongs_to relationship #{model.name} -> #{association.name}: #{e.message}"
         end
       end
@@ -219,7 +219,7 @@ module RailsLens
       def add_has_one_relationship(output, model, association, target_model)
         output << "  #{format_model_name(model)} ||--o| #{format_model_name(target_model)} : \"#{association.name}\""
       rescue StandardError => e
-        Rails.logger.debug do
+        RailsLens.logger.debug do
           "Warning: Could not add has_one relationship #{model.name} -> #{association.name}: #{e.message}"
         end
       end
@@ -227,7 +227,7 @@ module RailsLens
       def add_has_many_relationship(output, model, association, target_model)
         output << "  #{format_model_name(model)} ||--o{ #{format_model_name(target_model)} : \"#{association.name}\""
       rescue StandardError => e
-        Rails.logger.debug do
+        RailsLens.logger.debug do
           "Warning: Could not add has_many relationship #{model.name} -> #{association.name}: #{e.message}"
         end
       end
@@ -235,7 +235,7 @@ module RailsLens
       def add_habtm_relationship(output, model, association, target_model)
         output << "  #{format_model_name(model)} }o--o{ #{format_model_name(target_model)} : \"#{association.name}\""
       rescue StandardError => e
-        Rails.logger.debug do
+        RailsLens.logger.debug do
           "Warning: Could not add habtm relationship #{model.name} -> #{association.name}: #{e.message}"
         end
       end
@@ -294,7 +294,7 @@ module RailsLens
             output << "  class #{model_display_name} tableEntity"
           end
         rescue StandardError => e
-          Rails.logger.debug { "Warning: Could not apply styling to #{model.name}: #{e.message}" }
+          RailsLens.logger.debug { "Warning: Could not apply styling to #{model.name}: #{e.message}" }
         end
 
         output << ''
@@ -308,7 +308,7 @@ module RailsLens
           db_name = model.connection.pool.db_config.name
           grouped[db_name] << model
         rescue StandardError => e
-          Rails.logger.debug { "Warning: Could not determine database for #{model.name}: #{e.message}" }
+          RailsLens.logger.debug { "Warning: Could not determine database for #{model.name}: #{e.message}" }
           grouped['unknown'] << model
         end
 
@@ -368,7 +368,7 @@ module RailsLens
         filename = File.join(output_dir, "erd.#{extension}")
         File.write(filename, content)
 
-        Rails.logger.debug { "ERD saved to: #{filename}" }
+        RailsLens.logger.debug { "ERD saved to: #{filename}" }
         filename # Return the filename
       end
     end

data/lib/rails_lens/errors.rb

@@ -47,12 +47,12 @@ module RailsLens
         message = build_error_message(error, context)
 
         # Use Rails logger for verbose mode
-        Rails.logger&.error message
+        RailsLens.logger.error message
 
         # Use kernel output for debug mode to ensure visibility
         return unless RailsLens.debug
 
-        Rails.logger.debug message
+        RailsLens.logger.debug message
       end
 
       def handle(context = {})

data/lib/rails_lens/extension_loader.rb

@@ -229,17 +229,9 @@ module RailsLens
         when :silent
           # Do nothing
         when :warn
-          if Rails.logger
-            Rails.logger.warn "[RailsLens Extensions] #{message}#{" (#{context})" if context}"
-          else
-            Rails.logger.debug { "Warning: [RailsLens Extensions] #{message}#{" (#{context})" if context}" }
-          end
+          RailsLens.logger.warn "[RailsLens Extensions] #{message}#{" (#{context})" if context}"
         when :verbose
-          if Rails.logger
-            Rails.logger.error "[RailsLens Extensions] #{message}#{" (#{context})" if context}"
-          else
-            Rails.logger.debug { "Error: [RailsLens Extensions] #{message}#{" (#{context})" if context}" }
-          end
+          RailsLens.logger.error "[RailsLens Extensions] #{message}#{" (#{context})" if context}"
         end
       end
 

data/lib/rails_lens/extensions/base.rb

@@ -176,17 +176,9 @@ module RailsLens
         when :silent
           # Do nothing
         when :warn
-          if Rails.logger
-            Rails.logger.warn "[RailsLens Extensions] Method failed: #{message} (#{context})"
-          else
-            Rails.logger.debug { "Warning: [RailsLens Extensions] Method failed: #{message} (#{context})" }
-          end
+          RailsLens.logger.warn "[RailsLens Extensions] Method failed: #{message} (#{context})"
         when :verbose
-          if Rails.logger
-            Rails.logger.error "[RailsLens Extensions] Method failed: #{message} (#{context})"
-          else
-            Rails.logger.debug { "Error: [RailsLens Extensions] Method failed: #{message} (#{context})" }
-          end
+          RailsLens.logger.error "[RailsLens Extensions] Method failed: #{message} (#{context})"
         end
       end
     end

data/lib/rails_lens/model_detector.rb

@@ -126,7 +126,7 @@ module RailsLens
         trace_filtering = options[:trace_filtering] || ENV.fetch('RAILS_LENS_TRACE_FILTERING', nil)
 
         original_count = models.size
-        Rails.logger.debug { "[ModelDetector] Starting with #{original_count} models" } if trace_filtering
+        RailsLens.logger.debug { "[ModelDetector] Starting with #{original_count} models" } if trace_filtering
 
         # Remove anonymous classes and non-class objects
         before_count = models.size
@@ -157,7 +157,7 @@ module RailsLens
               end
             end
             if excluded && trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Excluding #{model.name}: matched exclude pattern"
               end
             end
@@ -182,12 +182,12 @@ module RailsLens
               end
             end
             if included && trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Including #{model.name}: matched include pattern"
               end
             end
             if !included && trace_filtering
-              Rails.logger.debug { "[ModelDetector] Excluding #{model.name}: did not match include patterns" }
+              RailsLens.logger.debug { "[ModelDetector] Excluding #{model.name}: did not match include patterns" }
             end
             included
           end
@@ -203,13 +203,13 @@ module RailsLens
         log_filter_step('Abstract/invalid table removal', before_count, models.size, trace_filtering)
 
         # Exclude tables from configuration
-        excluded_tables = RailsLens.config.schema[:exclude_tables]
+        excluded_tables = RailsLens.excluded_tables
         before_count = models.size
         models = models.reject do |model|
           begin
             excluded = excluded_tables.include?(model.table_name)
             if excluded && trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Excluding #{model.name}: table '#{model.table_name}' in exclude_tables config"
               end
             end
@@ -218,7 +218,7 @@ module RailsLens
             # This can happen in multi-db setups if the connection is not yet established
             # We will assume the model should be kept in this case
             if trace_filtering
-              Rails.logger.debug do
+              RailsLens.logger.debug do
                 "[ModelDetector] Keeping #{model.name}: connection not defined, assuming keep"
               end
             end
@@ -226,7 +226,7 @@ module RailsLens
           end
         rescue ActiveRecord::StatementInvalid => e
           if trace_filtering
-            Rails.logger.debug do
+            RailsLens.logger.debug do
               "[ModelDetector] Keeping #{model.name}: database error checking exclude_tables - #{e.message}"
             end
           end
@@ -235,11 +235,11 @@ module RailsLens
         log_filter_step('Configuration exclude_tables', before_count, models.size, trace_filtering)
 
         if trace_filtering
-          Rails.logger.debug do
+          RailsLens.logger.debug do
             "[ModelDetector] Final result: #{models.size} models after all filtering"
           end
         end
-        Rails.logger.debug { "[ModelDetector] Final models: #{models.map(&:name).join(', ')}" } if trace_filtering
+        RailsLens.logger.debug { "[ModelDetector] Final models: #{models.map(&:name).join(', ')}" } if trace_filtering
 
         models
       end
@@ -249,11 +249,11 @@ module RailsLens
 
         filtered_count = before_count - after_count
         if filtered_count.positive?
-          Rails.logger.debug do
+          RailsLens.logger.debug do
             "[ModelDetector] #{step_name}: filtered out #{filtered_count} models (#{before_count} -> #{after_count})"
           end
         else
-          Rails.logger.debug { "[ModelDetector] #{step_name}: no models filtered (#{after_count} remain)" }
+          RailsLens.logger.debug { "[ModelDetector] #{step_name}: no models filtered (#{after_count} remain)" }
         end
       end
 
@@ -301,7 +301,7 @@ module RailsLens
 
           if trace_filtering
             action = should_exclude ? 'Excluding' : 'Keeping'
-            Rails.logger.debug { "[ModelDetector] #{action} #{model.name}: #{reason}" }
+            RailsLens.logger.debug { "[ModelDetector] #{action} #{model.name}: #{reason}" }
           end
 
           { model: model, exclude: should_exclude }
@@ -408,7 +408,7 @@ module RailsLens
 
         if trace_filtering
           action = should_exclude ? 'Excluding' : 'Keeping'
-          Rails.logger.debug { "[ModelDetector] #{action} #{model.name}: #{reason}" }
+          RailsLens.logger.debug { "[ModelDetector] #{action} #{model.name}: #{reason}" }
         end
 
         { model: model, exclude: should_exclude }

data/lib/rails_lens/schema/adapters/mysql.rb

@@ -144,10 +144,10 @@ module RailsLens
             result[1] # Engine is typically the second column
           end
         rescue ActiveRecord::StatementInvalid => e
-          Rails.logger.debug { "Failed to fetch storage engine for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch storage engine for #{table_name}: #{e.message}" }
           nil
         rescue => e
-          Rails.logger.debug { "MySQL error fetching storage engine: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching storage engine: #{e.message}" }
           nil
         end
 
@@ -164,10 +164,10 @@ module RailsLens
 
           collation&.split('_')&.first
         rescue ActiveRecord::StatementInvalid => e
-          Rails.logger.debug { "Failed to fetch charset for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch charset for #{table_name}: #{e.message}" }
           nil
         rescue => e
-          Rails.logger.debug { "MySQL error fetching charset: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching charset: #{e.message}" }
           nil
         end
 
@@ -182,10 +182,10 @@ module RailsLens
             result[14] # Collation is typically the 15th column
           end
         rescue ActiveRecord::StatementInvalid => e
-          Rails.logger.debug { "Failed to fetch collation for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch collation for #{table_name}: #{e.message}" }
           nil
         rescue => e
-          Rails.logger.debug { "MySQL error fetching collation: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching collation: #{e.message}" }
           nil
         end
 
@@ -229,11 +229,11 @@ module RailsLens
           count.to_i.positive?
         rescue ActiveRecord::StatementInvalid => e
           # Table doesn't exist or no permission to query information_schema
-          Rails.logger.debug { "Failed to check partitions for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to check partitions for #{table_name}: #{e.message}" }
           false
         rescue => e
           # MySQL specific errors (connection issues, etc)
-          Rails.logger.debug { "MySQL error checking partitions: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error checking partitions: #{e.message}" }
           false
         end
 
@@ -259,10 +259,10 @@ module RailsLens
           end
         rescue ActiveRecord::StatementInvalid => e
           # Permission denied or table doesn't exist
-          Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
         rescue => e
           # MySQL specific errors
-          Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching partitions: #{e.message}" }
         end
 
         def add_partitions_toml(lines)
@@ -297,10 +297,10 @@ module RailsLens
           lines << ']'
         rescue ActiveRecord::StatementInvalid => e
           # Permission denied or table doesn't exist
-          Rails.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch partitions for #{table_name}: #{e.message}" }
         rescue => e
           # MySQL specific errors
-          Rails.logger.debug { "MySQL error fetching partitions: #{e.message}" }
+          RailsLens.logger.debug { "MySQL error fetching partitions: #{e.message}" }
         end
 
         def add_view_dependencies_toml(lines, view_info)
@@ -345,7 +345,7 @@ module RailsLens
             dependencies: row[1].to_s.split(',').reject(&:empty?)
           }
         rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
-          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
           nil
         end
 

data/lib/rails_lens/schema/adapters/postgresql.rb

@@ -150,11 +150,11 @@ module RailsLens
           end
         rescue ActiveRecord::StatementInvalid => e
           # Table doesn't exist or other database error
-          Rails.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch check constraints for #{table_name}: #{e.message}" }
           []
         rescue PG::Error => e
           # PostgreSQL specific errors
-          Rails.logger.debug { "PostgreSQL error fetching check constraints: #{e.message}" }
+          RailsLens.logger.debug { "PostgreSQL error fetching check constraints: #{e.message}" }
           []
         end
 
@@ -164,11 +164,11 @@ module RailsLens
           connection.column_comment(table_name, column_name)
         rescue ActiveRecord::StatementInvalid => e
           # Table or column doesn't exist
-          Rails.logger.debug { "Failed to fetch column comment for #{table_name}.#{column_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch column comment for #{table_name}.#{column_name}: #{e.message}" }
           nil
         rescue PG::Error => e
           # PostgreSQL specific errors
-          Rails.logger.debug { "PostgreSQL error fetching column comment: #{e.message}" }
+          RailsLens.logger.debug { "PostgreSQL error fetching column comment: #{e.message}" }
           nil
         end
 
@@ -178,11 +178,11 @@ module RailsLens
           connection.table_comment(table_name)
         rescue ActiveRecord::StatementInvalid => e
           # Table doesn't exist
-          Rails.logger.debug { "Failed to fetch table comment for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch table comment for #{table_name}: #{e.message}" }
           nil
         rescue PG::Error => e
           # PostgreSQL specific errors
-          Rails.logger.debug { "PostgreSQL error fetching table comment: #{e.message}" }
+          RailsLens.logger.debug { "PostgreSQL error fetching table comment: #{e.message}" }
           nil
         end
 
@@ -292,7 +292,7 @@ module RailsLens
             dependencies: row[2] || []
           }
         rescue ActiveRecord::StatementInvalid, PG::Error => e
-          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
           nil
         end
 

data/lib/rails_lens/schema/adapters/sqlite3.rb

@@ -93,10 +93,10 @@ module RailsLens
             lines << 'FOREIGN_KEYS_ENABLED: false' if fk_status && fk_status['foreign_keys'].zero?
           rescue ActiveRecord::StatementInvalid => e
             # SQLite doesn't recognize the pragma or access denied
-            Rails.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
+            RailsLens.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
           rescue SQLite3::Exception => e
             # SQLite specific errors (database locked, etc)
-            Rails.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
+            RailsLens.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
           end
         end
 
@@ -113,10 +113,10 @@ module RailsLens
             end
           rescue ActiveRecord::StatementInvalid => e
             # SQLite doesn't recognize the pragma or access denied
-            Rails.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
+            RailsLens.logger.debug { "Failed to fetch SQLite foreign_keys pragma: #{e.message}" }
           rescue SQLite3::Exception => e
             # SQLite specific errors (database locked, etc)
-            Rails.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
+            RailsLens.logger.debug { "SQLite error fetching pragmas: #{e.message}" }
           end
         end
 
@@ -164,7 +164,7 @@ module RailsLens
             dependencies: tables.sort
           }
         rescue ActiveRecord::StatementInvalid, SQLite3::Exception => e
-          Rails.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
+          RailsLens.logger.debug { "Failed to fetch view metadata for #{table_name}: #{e.message}" }
           nil
         end
 

data/lib/rails_lens/version.rb

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

data/lib/rails_lens.rb

@@ -26,92 +26,31 @@ loader.setup
 
 require_relative 'rails_lens/errors'
 require_relative 'rails_lens/cli'
+require_relative 'rails_lens/configuration'
 
 module RailsLens
   include ActiveSupport::Configurable
+  include Configuration
 
-  # Add configuration for error handling
-  config_accessor :verbose, default: false
-  config_accessor :debug, default: false
-  config_accessor :raise_on_error, default: false
-
-  # Configuration using ActiveSupport::Configurable
-  config_accessor :annotations do
-    {
-      position: :before,
-      format: :rdoc
-    }
-  end
-
-  config_accessor :erd do
-    {
-      output_dir: 'doc/erd',
-      orientation: 'TB',
-      theme: true,
-      default_colors: %w[
-        lightblue
-        lightcoral
-        lightgreen
-        lightyellow
-        plum
-        lightcyan
-        lightgray
-      ]
-    }
-  end
-
-  config_accessor :schema do
-    {
-      adapter: :auto,
-      include_notes: true,
-      exclude_tables: %w[schema_migrations ar_internal_metadata],
-      format_options: {
-        show_defaults: true,
-        show_comments: true,
-        show_foreign_keys: true,
-        show_indexes: true,
-        show_check_constraints: true
-      }
-    }
-  end
-
-  config_accessor :extensions do
-    {
-      enabled: true,
-      autoload: true,
-      interface_version: '1.0',
-      ignore: [],
-      custom_paths: [],
-      error_reporting: :warn,    # :silent, :warn, :verbose
-      fail_safe_mode: true,      # Continue processing if extensions fail
-      track_health: false        # Track extension success/failure rates
-    }
-  end
+  class << self
+    def logger
+      @logger ||= config.logger || default_logger
+    end
 
-  config_accessor :routes do
-    {
-      enabled: true,
-      include_defaults: true,
-      include_constraints: true,
-      pattern: '**/*_controller.rb',
-      exclusion_pattern: 'vendor/**/*_controller.rb'
-    }
-  end
+    def logger=(new_logger)
+      @logger = new_logger
+      config.logger = new_logger
+    end
 
-  config_accessor :mailers do
-    {
-      enabled: true,
-      include_templates: true,
-      include_delivery_methods: true,
-      include_variables: true,
-      include_locales: true,
-      include_defaults: true,
-      pattern: '**/*_mailer.rb',
-      exclusion_pattern: 'vendor/**/*_mailer.rb'
-    }
-  end
+    def default_logger
+      if defined?(Rails.logger) && Rails.logger
+        Rails.logger
+      else
+        require 'logger'
+        Logger.new($stdout)
+      end
+    end
 
-  class << self
     def load_config_file(path = '.rails-lens.yml')
       return unless File.exist?(path)
 
@@ -130,6 +69,17 @@ module RailsLens
       end
     end
 
+    # Get tables to exclude
+    def excluded_tables
+      custom_excludes = config.schema[:exclude_tables]
+      if custom_excludes.nil?
+        # Use ActiveRecord's default ignore tables
+        ActiveRecord::SchemaDumper.ignore_tables.to_a
+      else
+        Array(custom_excludes)
+      end
+    end
+
     # Schema annotation methods
     def annotate_models(options = {})
       Schema::AnnotationManager.annotate_all(options)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_lens
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -182,6 +182,7 @@ files:
 - lib/rails_lens/cli.rb
 - lib/rails_lens/cli_error_handler.rb
 - lib/rails_lens/commands.rb
+- lib/rails_lens/configuration.rb
 - lib/rails_lens/connection.rb
 - lib/rails_lens/erd/column_type_formatter.rb
 - lib/rails_lens/erd/domain_color_mapper.rb