rails_lens 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b150328b6771f2de4015820d40e3942c10b41903687f800fd4b068f79605deeb
-  data.tar.gz: 2d67fc7fd815b1af80c3cb9e1ad8b94e1166129fc3a1eb24e28958ad3e625b47
+  metadata.gz: ea81d5fe631c0523042ac851e7eaf48de1342e7d6e830512df298b25dd799b09
+  data.tar.gz: f3e09fd1d9aa9b18c0df790356007dc9c952db84268945a284b9f4b496627372
 SHA512:
-  metadata.gz: 0b9f944f8e7be0f11789817a49f168f7be310e6742207897029c20540b701c525da861a1b49cdcbeee0690a9bd6424fbace720e6bb42fd5d9d81b46cd244ed88
-  data.tar.gz: 22f3bc6e6223ad726c2fc3cf617c37af1e587e466119fd1138965e38ff51cb9128b441b5081214e79f9e2d334b8ec7990e437bdfb20257783a40a194f572ebfc
+  metadata.gz: cfaa977bdbbdb4496a46bbe0fcfa652814710ca25af99e0bbd9f4e71aa848a55d4085b9ebcf6e4813188ca98d36211add950feb2d3deee724d2bee5d19d1706d
+  data.tar.gz: e74ab70f37dc32b8584800eeb2cd71acf01b0b17680777034bb188d966e1d1c797a91f3edd92131ca291fa6fd4dfb1b47bc1374cf020d0e8c93e9f7ac280477e

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.2.7](https://github.com/seuros/rails_lens/compare/rails_lens/v0.2.6...rails_lens/v0.2.7) (2025-08-14)
+
+
+### Bug Fixes
+
+* use mermaid gem as backend ([#19](https://github.com/seuros/rails_lens/issues/19)) ([2297ecb](https://github.com/seuros/rails_lens/commit/2297ecb1a61ae1c3bb3ea4b1f602f9bea91a5aa8)), closes [#18](https://github.com/seuros/rails_lens/issues/18)
+
+## [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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'mermaid'
+
 module RailsLens
   module ERD
     class Visualizer
@@ -29,109 +31,61 @@ module RailsLens
           return save_output(mermaid_output, 'mmd')
         end
 
-        output = ['erDiagram']
-
-        # Add theme configuration
-        if config[:theme] || config[:colors]
-          output << ''
-          output << '  %% Theme Configuration'
-          add_theme_configuration(output)
-          output << ''
-        end
-
-        # Choose grouping strategy based on configuration
-        grouped_models = if config[:group_by_database]
-                           # Group models by database connection
-                           group_models_by_database(models)
-                         else
-                           # Group models by domain (existing behavior)
-                           group_models_by_domain(models)
-                         end
-
-        # Create color mapper for domains (for future extensibility)
-        unless config[:group_by_database]
-          domain_list = grouped_models.keys.sort
-          @color_mapper = create_domain_color_mapper(domain_list)
-        end
-
-        # Add entities
-        grouped_models.each do |group_key, group_models|
-          if config[:group_by_database]
-            output << "  %% Database: #{group_key}"
-          elsif group_key != :general
-            output << "  %% #{group_key.to_s.humanize} Domain"
-          end
-
-          group_models.each do |model|
-            # Additional safety check: Skip abstract models that might have slipped through
-            next if model.abstract_class?
+        # Create new ERDiagram using mermaid-ruby gem
+        diagram = Diagrams::ERDiagram.new
 
-            # Skip models without valid tables/views or columns
-            # Include both table-backed and view-backed models
-            is_view = ModelDetector.view_exists?(model)
-            has_data_source = is_view || (model.table_exists? && model.columns.present?)
-            next unless has_data_source
-
-            model_display_name = format_model_name(model)
+        # Process models and add them to the diagram
+        models.each do |model|
+          # Skip abstract models
+          next if model.abstract_class?
 
-            output << "  #{model_display_name} {"
-            # Track opening brace position for error recovery
-            brace_position = output.size
+          # Skip models without valid tables/views or columns
+          is_view = ModelDetector.view_exists?(model)
+          has_data_source = is_view || (model.table_exists? && model.columns.present?)
+          next unless has_data_source
 
-            columns_added = false
+          begin
+            # Create attributes for the entity
+            attributes = []
             model.columns.each do |column|
               type_str = format_column_type(column)
-              name_str = column.name
               keys = determine_keys(model, column)
-              key_str = keys.map(&:to_s).join(' ')
 
-              output << "    #{type_str} #{name_str}#{" #{key_str}" unless key_str.empty?}"
-              columns_added = true
+              attributes << {
+                type: type_str,
+                name: column.name,
+                keys: keys
+              }
             end
 
-            # Only close the entity if we successfully added columns
-            if columns_added
-              output << '  }'
-              output << ''
-              Rails.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]
-            end
+            # Add entity to diagram (model name will be automatically quoted if needed)
+            diagram.add_entity(
+              name: model.name,
+              attributes: attributes
+            )
+
+            RailsLens.logger.debug { "Added entity: #{model.name}" } if options[:verbose]
           rescue StandardError => e
-            Rails.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)
-            end
+            RailsLens.logger.debug { "Warning: Could not add entity #{model.name}: #{e.message}" }
           end
-        end
-
-        # Add visual styling for views vs tables
-        add_visual_styling(output, models)
 
-        # Add relationships
-        output << '  %% Relationships'
-        models.each do |model|
-          # Skip abstract models in relationship generation too
+          # Add relationships
           next if model.abstract_class?
 
-          # Include both table-backed and view-backed models
           is_view = ModelDetector.view_exists?(model)
           has_data_source = is_view || (model.table_exists? && model.columns.present?)
           next unless has_data_source
 
-          add_model_relationships(output, model, models)
+          add_model_relationships(diagram, model, models)
         end
 
-        # Generate mermaid syntax
-        mermaid_output = output.join("\n")
+        # Generate mermaid syntax using the gem
+        mermaid_output = diagram.to_mermaid
 
         # 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
 
@@ -159,7 +113,7 @@ module RailsLens
           end
         end
 
-        # Check unique indexes
+        # Check unique indexes - use UK which will be automatically quoted as comment
         if model.connection.indexes(model.table_name).any? do |idx|
           idx.unique && idx.columns.include?(column.name)
         end && keys.exclude?(:PK)
@@ -169,7 +123,7 @@ module RailsLens
         keys
       end
 
-      def add_model_relationships(output, model, models)
+      def add_model_relationships(diagram, model, models)
         model.reflect_on_all_associations.each do |association|
           next if association.options[:through] # Skip through associations for now
           next if association.polymorphic? # Skip polymorphic associations
@@ -190,177 +144,89 @@ module RailsLens
 
           case association.macro
           when :belongs_to
-            add_belongs_to_relationship(output, model, association, target_model)
+            add_belongs_to_relationship(diagram, model, association, target_model)
           when :has_one
-            add_has_one_relationship(output, model, association, target_model)
+            add_has_one_relationship(diagram, model, association, target_model)
           when :has_many
-            add_has_many_relationship(output, model, association, target_model)
+            add_has_many_relationship(diagram, model, association, target_model)
           when :has_and_belongs_to_many
-            add_habtm_relationship(output, model, association, target_model)
+            add_habtm_relationship(diagram, model, association, target_model)
           end
         end
 
         # Check for closure_tree self-reference - but only if model is not abstract
-        # rubocop:disable Style/GuardClause
-        if model.respond_to?(:_ct) && !model.abstract_class?
-          output << "  #{format_model_name(model)} }o--o{ #{format_model_name(model)} : \"closure_tree\""
-        end
-        # rubocop:enable Style/GuardClause
-      end
-
-      def add_belongs_to_relationship(output, model, association, target_model)
-        output << "  #{format_model_name(model)} }o--|| #{format_model_name(target_model)} : \"#{association.name}\""
+        return unless model.respond_to?(:_ct) && !model.abstract_class?
+
+        diagram.add_relationship(
+          entity1: model.name,
+          entity2: model.name,
+          cardinality1: :ZERO_OR_MORE,
+          cardinality2: :ZERO_OR_MORE,
+          identifying: false,
+          label: 'closure_tree'
+        )
+      end
+
+      def add_belongs_to_relationship(diagram, model, association, target_model)
+        diagram.add_relationship(
+          entity1: model.name,
+          entity2: target_model.name,
+          cardinality1: :ZERO_OR_MORE,
+          cardinality2: :ONE_ONLY,
+          identifying: false,
+          label: association.name.to_s
+        )
       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
 
-      def add_has_one_relationship(output, model, association, target_model)
-        output << "  #{format_model_name(model)} ||--o| #{format_model_name(target_model)} : \"#{association.name}\""
+      def add_has_one_relationship(diagram, model, association, target_model)
+        diagram.add_relationship(
+          entity1: model.name,
+          entity2: target_model.name,
+          cardinality1: :ONE_ONLY,
+          cardinality2: :ZERO_OR_ONE,
+          identifying: false,
+          label: association.name.to_s
+        )
       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
 
-      def add_has_many_relationship(output, model, association, target_model)
-        output << "  #{format_model_name(model)} ||--o{ #{format_model_name(target_model)} : \"#{association.name}\""
+      def add_has_many_relationship(diagram, model, association, target_model)
+        diagram.add_relationship(
+          entity1: model.name,
+          entity2: target_model.name,
+          cardinality1: :ONE_ONLY,
+          cardinality2: :ZERO_OR_MORE,
+          identifying: false,
+          label: association.name.to_s
+        )
       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
 
-      def add_habtm_relationship(output, model, association, target_model)
-        output << "  #{format_model_name(model)} }o--o{ #{format_model_name(target_model)} : \"#{association.name}\""
+      def add_habtm_relationship(diagram, model, association, target_model)
+        diagram.add_relationship(
+          entity1: model.name,
+          entity2: target_model.name,
+          cardinality1: :ZERO_OR_MORE,
+          cardinality2: :ZERO_OR_MORE,
+          identifying: false,
+          label: association.name.to_s
+        )
       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
 
-      def add_theme_configuration(output)
-        # Get default color palette
-        default_colors = config[:default_colors] || DomainColorMapper::DEFAULT_COLORS
-
-        # Use first few colors for Mermaid theme
-        primary_color = default_colors[0] || 'lightgray'
-        secondary_color = default_colors[1] || 'lightblue'
-        tertiary_color = default_colors[2] || 'lightcoral'
-
-        # Mermaid theme directives
-        output << '  %%{init: {'
-        output << '    "theme": "default",'
-        output << '    "themeVariables": {'
-        output << "      \"primaryColor\": \"#{primary_color}\","
-        output << '      "primaryTextColor": "#333",'
-        output << '      "primaryBorderColor": "#666",'
-        output << '      "lineColor": "#666",'
-        output << "      \"secondaryColor\": \"#{secondary_color}\","
-        output << "      \"tertiaryColor\": \"#{tertiary_color}\""
-        output << '    }'
-        output << '  }}%%'
-      end
-
-      def add_visual_styling(output, models)
-        # Add class definitions for visual distinction between tables and views
-        output << ''
-        output << '  %% Entity Styling'
-
-        # Define styling classes
-        output << '  classDef tableEntity fill:#f9f9f9,stroke:#333,stroke-width:2px'
-        output << '  classDef viewEntity fill:#e6f3ff,stroke:#333,stroke-width:2px,stroke-dasharray: 5 5'
-        output << '  classDef materializedViewEntity fill:#ffe6e6,stroke:#333,stroke-width:3px,stroke-dasharray: 5 5'
-
-        # Apply styling to each model
-        models.each do |model|
-          next if model.abstract_class?
-
-          is_view = ModelDetector.view_exists?(model)
-          has_data_source = is_view || (model.table_exists? && model.columns.present?)
-          next unless has_data_source
-
-          model_display_name = format_model_name(model)
-
-          if is_view
-            view_metadata = ViewMetadata.new(model)
-            output << if view_metadata.materialized_view?
-                        "  class #{model_display_name} materializedViewEntity"
-                      else
-                        "  class #{model_display_name} viewEntity"
-                      end
-          else
-            output << "  class #{model_display_name} tableEntity"
-          end
-        rescue StandardError => e
-          Rails.logger.debug { "Warning: Could not apply styling to #{model.name}: #{e.message}" }
-        end
-
-        output << ''
-      end
-
-      def group_models_by_database(models)
-        grouped = Hash.new { |h, k| h[k] = [] }
-
-        models.each do |model|
-          # Get the database name from the model's connection
-          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}" }
-          grouped['unknown'] << model
-        end
-
-        # Sort databases for consistent output
-        grouped.sort_by { |db_name, _| db_name.to_s }.to_h
-      end
-
-      def group_models_by_domain(models)
-        grouped = Hash.new { |h, k| h[k] = [] }
-
-        models.each do |model|
-          domain = determine_model_domain(model)
-          grouped[domain] << model
-        end
-
-        # Sort domains for consistent output
-        grouped.sort_by { |domain, _| domain.to_s }.to_h
-      end
-
-      def determine_model_domain(model)
-        model_name = model.name.downcase
-
-        # Basic domain detection based on common patterns
-        return :auth if model_name.match?(/user|account|session|authentication|authorization/)
-        return :content if model_name.match?(/post|article|comment|blog|page|content/)
-        return :commerce if model_name.match?(/product|order|payment|cart|invoice|transaction/)
-        return :core if model_name.match?(/category|tag|setting|configuration|notification/)
-
-        # Default domain
-        :general
-      end
-
-      def create_domain_color_mapper(domains)
-        # Get colors from config or use defaults
-        colors = config[:default_colors] || DomainColorMapper::DEFAULT_COLORS
-        DomainColorMapper.new(domains, colors: colors)
-      end
-
-      def format_model_name(model)
-        return model.name unless config[:include_all_databases] || config[:show_database_labels]
-
-        # Get database name from the model's connection
-        begin
-          db_name = model.connection.pool.db_config.name
-          return model.name if db_name == 'primary' # Don't prefix primary database models
-
-          "#{model.name}[#{db_name}]"
-        rescue StandardError
-          model.name
-        end
-      end
-
       def save_output(content, extension)
         output_dir = config[:output_dir] || 'doc/erd'
         FileUtils.mkdir_p(output_dir)
@@ -368,7 +234,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.7'
 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.7
 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