rails_lens 0.0.0 → 0.2.2

data/lib/rails_lens/connection.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RailsLens
+  class Connection
+    class << self
+      def adapter_for(model_class)
+        connection = model_class.connection
+        adapter_name = detect_adapter_name(connection)
+
+        adapter_class = resolve_adapter_class(adapter_name)
+        adapter_class.new(connection, model_class.table_name)
+      end
+
+      def resolve_adapter_class(adapter_name)
+        class_name = "RailsLens::Schema::Adapters::#{adapter_name.to_s.camelize}"
+
+        begin
+          class_name.constantize
+        rescue NameError
+          raise RailsLens::UnsupportedAdapterError,
+                "Unsupported database adapter: #{adapter_name}. " \
+                "Expected adapter class #{class_name} not found. " \
+                'Consider adding support by creating the adapter class.'
+        end
+      end
+
+      def detect_adapter_name(connection)
+        adapter_name = connection.adapter_name.downcase
+
+        case adapter_name
+        when /postgresql/, /postgis/
+          :postgresql
+        when /mysql2/, /trilogy/, /mariadb/
+          :mysql
+        when /sqlite/
+          :sqlite3
+        else
+          # Return the normalized adapter name for constantize
+          adapter_name.to_sym
+        end
+      end
+
+      def database_dialect(connection)
+        adapter_name = connection.adapter_name
+
+        case adapter_name.downcase
+        when /postgresql/, /postgis/
+          'PostgreSQL'
+        when /mysql2/, /trilogy/
+          'MySQL'
+        when /mariadb/
+          'MariaDB'
+        when /sqlite/
+          'SQLite'
+        else
+          adapter_name # Return the original adapter name if unknown
+        end
+      end
+
+      def connection_config(model_class)
+        if model_class.connection.respond_to?(:connection_db_config)
+          # Rails 6.1+
+          model_class.connection.connection_db_config.configuration_hash
+        elsif model_class.connection.respond_to?(:config)
+          # Older Rails versions
+          model_class.connection.config
+        else
+          {}
+        end
+      end
+
+      def database_version(model_class)
+        connection = model_class.connection
+
+        if connection.respond_to?(:database_version)
+          connection.database_version
+        elsif connection.respond_to?(:version)
+          connection.version
+        else
+          'Unknown'
+        end
+      rescue StandardError
+        'Unknown'
+      end
+
+      def connection_info(model_class)
+        {
+          adapter: detect_adapter_name(model_class.connection),
+          database: connection_config(model_class)[:database],
+          version: database_version(model_class),
+          encoding: connection_encoding(model_class)
+        }
+      end
+
+      def supports_foreign_keys?(model_class)
+        model_class.connection.supports_foreign_keys?
+      end
+
+      def supports_check_constraints?(model_class)
+        model_class.connection.supports_check_constraints?
+      end
+
+      def supports_comments?(model_class)
+        model_class.connection.supports_comments?
+      end
+
+      def supports_views?(model_class)
+        model_class.connection.supports_views?
+      end
+
+      def supports_materialized_views?(model_class)
+        model_class.connection.supports_materialized_views?
+      end
+
+      private
+
+      def connection_encoding(model_class)
+        connection = model_class.connection
+
+        if connection.respond_to?(:encoding)
+          connection.encoding
+        elsif connection.respond_to?(:charset)
+          connection.charset
+        else
+          config = connection_config(model_class)
+          config[:encoding] || config[:charset] || 'Unknown'
+        end
+      rescue StandardError
+        'Unknown'
+      end
+    end
+  end
+end

data/lib/rails_lens/erd/column_type_formatter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module ERD
+    class ColumnTypeFormatter
+      def self.format(column)
+        new(column).format
+      end
+
+      def initialize(column)
+        @column = column
+      end
+
+      def format
+        # Default to the generic type
+        case @column.type
+        when :integer, :bigint then 'int'
+        when :string, :text then 'varchar'
+        when :boolean then 'boolean'
+        when :decimal, :float then 'decimal'
+        when :date then 'date'
+        when :datetime, :timestamp then 'datetime'
+        when :time then 'time'
+        when :binary then 'blob'
+        when :json, :jsonb then 'json'
+        else
+          @column.type.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/erd/domain_color_mapper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module ERD
+    # Assigns a consistent color to a domain from a predefined palette.
+    class DomainColorMapper
+      # Default color palette for domains using CSS named colors.
+      DEFAULT_COLORS = %w[
+        lightblue
+        lightcoral
+        lightgreen
+        lightyellow
+        plum
+        lightcyan
+        lightgray
+      ].freeze
+
+      # The color used for domains not found in the initial list.
+      FALLBACK_COLOR = 'lightgray'
+
+      # @param domains [Array<Symbol>] A unique list of domain names.
+      # @param colors [Array<String>] A list of hex color codes to cycle through.
+      def initialize(domains, colors: DEFAULT_COLORS)
+        @colors = colors.empty? ? [FALLBACK_COLOR] : colors
+        @domain_map = domains.uniq.each_with_index.to_h
+      end
+
+      # Returns the color for a given domain.
+      #
+      # @param domain [Symbol] The domain name.
+      # @return [String] The hex color code.
+      def color_for(domain)
+        domain_index = @domain_map[domain]
+        return FALLBACK_COLOR unless domain_index
+
+        @colors[domain_index % @colors.length]
+      end
+    end
+  end
+end

data/lib/rails_lens/erd/mysql_column_type_formatter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module ERD
+    class MysqlColumnTypeFormatter < ColumnTypeFormatter
+      def format
+        case @column.sql_type
+        when /json/i then 'json'
+        when /enum/i then 'enum'
+        when /set/i then 'set'
+        when /mediumtext/i then 'mediumtext'
+        when /tinyint\(1\)/i then 'boolean'
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/erd/postgresql_column_type_formatter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module ERD
+    class PostgresqlColumnTypeFormatter < ColumnTypeFormatter
+      def format
+        case @column.sql_type
+        when /jsonb/i then 'jsonb'
+        when /uuid/i then 'uuid'
+        when /inet/i then 'inet'
+        when /array/i then 'array'
+        when /tsvector/i then 'tsvector'
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/erd/visualizer.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module ERD
+    class Visualizer
+      require_relative 'domain_color_mapper'
+      attr_reader :options, :config
+
+      def initialize(options: {})
+        @options = options
+        @config = RailsLens.config.erd.merge(options.compact.transform_keys(&:to_sym))
+      end
+
+      def generate
+        models = load_models
+        generate_mermaid(models)
+      end
+
+      private
+
+      def load_models
+        ModelDetector.detect_models(options)
+      end
+
+      def generate_mermaid(models)
+        if models.blank?
+          # Still need to save the output even if no models found
+          mermaid_output = "erDiagram\n  %% No models found"
+          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?
+
+            # Skip models without valid tables or columns
+            next unless model.table_exists? && model.columns.present?
+
+            model_display_name = format_model_name(model)
+
+            output << "  #{model_display_name} {"
+            # Track opening brace position for error recovery
+            brace_position = output.size
+
+            columns_added = false
+            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
+            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
+          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
+          end
+        end
+
+        # Add relationships
+        output << '  %% Relationships'
+        models.each do |model|
+          # Skip abstract models in relationship generation too
+          next if model.abstract_class?
+          next unless model.table_exists? && model.columns.present?
+
+          add_model_relationships(output, model, models)
+        end
+
+        # Generate mermaid syntax
+        mermaid_output = output.join("\n")
+
+        # Save output
+        filename = save_output(mermaid_output, 'mmd')
+
+        Rails.logger.debug 'ERD generated successfully!'
+        filename # Return the filename instead of content
+      end
+
+      def format_column_type(column)
+        formatter_class = case column.sql_type
+                          when /jsonb|uuid|inet|array|tsvector/i
+                            PostgresqlColumnTypeFormatter
+                          when /json|enum|set|mediumtext|tinyint\(1\)/i
+                            MysqlColumnTypeFormatter
+                          else
+                            ColumnTypeFormatter
+                          end
+
+        formatter_class.format(column)
+      end
+
+      def determine_keys(model, column)
+        keys = []
+        keys << :PK if column.name == model.primary_key
+
+        # Check foreign keys
+        if model.respond_to?(:reflect_on_all_associations)
+          model.reflect_on_all_associations(:belongs_to).each do |assoc|
+            keys << :FK if assoc.foreign_key.to_s == column.name
+          end
+        end
+
+        # Check unique indexes
+        if model.connection.indexes(model.table_name).any? do |idx|
+          idx.unique && idx.columns.include?(column.name)
+        end && keys.exclude?(:PK)
+          keys << :UK
+        end
+
+        keys
+      end
+
+      def add_model_relationships(output, 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
+
+          # Check if target model exists and has table
+          target_model = nil
+          begin
+            target_model = association.klass
+          rescue NameError, ArgumentError
+            next # Skip if class can't be loaded
+          end
+
+          next unless target_model && models.include?(target_model)
+
+          # Skip relationships to abstract models
+          next if target_model.abstract_class?
+          next unless target_model.table_exists? && target_model.columns.present?
+
+          case association.macro
+          when :belongs_to
+            add_belongs_to_relationship(output, model, association, target_model)
+          when :has_one
+            add_has_one_relationship(output, model, association, target_model)
+          when :has_many
+            add_has_many_relationship(output, model, association, target_model)
+          when :has_and_belongs_to_many
+            add_habtm_relationship(output, 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}\""
+      rescue StandardError => e
+        Rails.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}\""
+      rescue StandardError => e
+        Rails.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}\""
+      rescue StandardError => e
+        Rails.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}\""
+      rescue StandardError => e
+        Rails.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 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)
+
+        filename = File.join(output_dir, "erd.#{extension}")
+        File.write(filename, content)
+
+        Rails.logger.debug { "ERD saved to: #{filename}" }
+        filename # Return the filename
+      end
+    end
+  end
+end

data/lib/rails_lens/errors.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RailsLens
+  # Base error class for all Rails Lens errors
+  class Error < StandardError; end
+
+  # Configuration-related errors
+  class ConfigurationError < Error; end
+
+  # Model detection errors
+  class ModelDetectionError < Error; end
+  class ModelNotFoundError < ModelDetectionError; end
+  class InvalidModelError < ModelDetectionError; end
+
+  # Database-related errors
+  class DatabaseError < Error; end
+  class ConnectionError < DatabaseError; end
+  class SchemaError < DatabaseError; end
+  class TableNotFoundError < DatabaseError; end
+  class UnsupportedAdapterError < DatabaseError; end
+
+  # Annotation-related errors
+  class AnnotationError < Error; end
+  class FileNotFoundError < AnnotationError; end
+  class ParseError < AnnotationError; end
+  class InsertionError < AnnotationError; end
+
+  # Extension-related errors
+  class ExtensionError < Error; end
+  class ExtensionLoadError < ExtensionError; end
+  class ExtensionConfigError < ExtensionError; end
+
+  # Analysis errors
+  class AnalysisError < Error; end
+  class AnalyzerError < AnalysisError; end
+
+  # ERD generation errors
+  class ERDError < Error; end
+  class VisualizationError < ERDError; end
+
+  # Error reporter for centralized error handling
+  class ErrorReporter
+    class << self
+      def report(error, context = {})
+        return unless RailsLens.verbose || RailsLens.debug
+
+        message = build_error_message(error, context)
+
+        # Use Rails logger for verbose mode
+        Rails.logger&.error message
+
+        # Use kernel output for debug mode to ensure visibility
+        return unless RailsLens.debug
+
+        Rails.logger.debug message
+      end
+
+      def handle(context = {})
+        yield
+      rescue StandardError => e
+        report(e, context)
+        raise if RailsLens.raise_on_error
+
+        nil
+      end
+
+      private
+
+      def build_error_message(error, context)
+        message = ['[RailsLens Error]']
+        message << "Context: #{context.inspect}" if context.any?
+        message << "#{error.class}: #{error.message}"
+        message << error.backtrace.first(5).join("\n") if error.backtrace && RailsLens.config.debug
+        message.join("\n")
+      end
+    end
+  end
+end