rails_lens 0.0.0 → 0.2.2

data/lib/rails_lens/extension_loader.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module RailsLens
+  class ExtensionLoader
+    class << self
+      def load_extensions
+        return [] unless extensions_enabled?
+
+        extensions = []
+
+        # Load built-in extensions
+        extensions.concat(load_builtin_extensions)
+
+        # Load gem-provided extensions
+        extensions.concat(load_gem_extensions) if autoload_enabled?
+
+        # Load custom extensions
+        extensions.concat(load_custom_extensions)
+
+        # Filter out ignored extensions
+        extensions.reject { |ext| ignored?(ext) }
+      end
+
+      def find_extension_for(_model_class)
+        load_extensions.find do |extension_class|
+          extension_class.detect? && extension_class.compatible?
+        end
+      end
+
+      def apply_extensions(model_class)
+        results = {
+          annotations: [],
+          notes: [],
+          erd_additions: {
+            relationships: [],
+            badges: [],
+            attributes: {}
+          }
+        }
+
+        load_extensions.each do |extension_class|
+          next unless extension_class.detect?
+          next unless extension_class.compatible?
+
+          extension = extension_class.new(model_class)
+
+          # Collect annotations with individual error handling
+          begin
+            if (annotation = extension.annotate)
+              results[:annotations] << annotation
+            end
+          rescue StandardError => e
+            log_extension_method_error(extension_class, 'annotate', e, model_class)
+          end
+
+          # Collect notes with individual error handling
+          begin
+            notes = extension.notes
+            results[:notes].concat(notes) if notes.is_a?(Array)
+          rescue StandardError => e
+            log_extension_method_error(extension_class, 'notes', e, model_class)
+          end
+
+          # Collect ERD additions with individual error handling
+          begin
+            erd = extension.erd_additions
+            if erd.is_a?(Hash)
+              results[:erd_additions][:relationships].concat(erd[:relationships] || [])
+              results[:erd_additions][:badges].concat(erd[:badges] || [])
+              results[:erd_additions][:attributes].merge!(erd[:attributes] || {})
+            end
+          rescue StandardError => e
+            log_extension_method_error(extension_class, 'erd_additions', e, model_class)
+          end
+        rescue StandardError => e
+          log_extension_error("Failed to initialize or detect extension #{extension_class}: #{e.message}",
+                              extension_class.gem_name)
+        end
+
+        results
+      end
+
+      private
+
+      def extensions_enabled?
+        extensions_config = RailsLens.config.extensions
+        extensions_config && extensions_config[:enabled]
+      end
+
+      def autoload_enabled?
+        extensions_config = RailsLens.config.extensions
+        extensions_config && extensions_config[:autoload]
+      end
+
+      def ignored?(extension_class)
+        extensions_config = RailsLens.config.extensions
+        ignored_gems = extensions_config ? extensions_config[:ignore] : []
+        ignored_gems.include?(extension_class.gem_name)
+      end
+
+      def load_builtin_extensions
+        extensions = []
+
+        # Load all Ruby files in the extensions directory
+        Dir[File.join(__dir__, 'extensions', '*.rb')].each do |file|
+          next if file.end_with?('base.rb') # Skip the base class
+
+          begin
+            require file
+
+            # Find the extension class
+            basename = File.basename(file, '.rb')
+            class_name = basename.split('_').map(&:capitalize).join
+
+            if RailsLens::Extensions.const_defined?(class_name)
+              extension_class = RailsLens::Extensions.const_get(class_name)
+              if valid_extension?(extension_class)
+                extensions << extension_class
+              else
+                log_extension_error("Builtin extension #{class_name} failed validation", file)
+              end
+            else
+              log_extension_error("Expected class #{class_name} not found", file)
+            end
+          rescue LoadError, SyntaxError => e
+            log_extension_error("Failed to load extension file: #{e.message}", file)
+          rescue StandardError => e
+            log_extension_error("Unexpected error loading extension: #{e.message}", file)
+          end
+        end
+
+        extensions
+      end
+
+      def load_gem_extensions
+        extensions = []
+
+        # Check each loaded gem for RailsLens extensions
+
+        Gem.loaded_specs.each_key do |gem_name|
+          # Try to find extension in the gem
+          gem_constant_name = gem_name.gsub('-', '_').split('_').map(&:capitalize).join
+          extension_constant_name = "#{gem_constant_name}::RailsLensExtension"
+
+          # Skip gems that are likely to cause autoload issues
+          next if %w[digest openssl uri net json].include?(gem_name)
+
+          # First check if the gem constant exists without triggering autoload
+          next unless Object.const_defined?(gem_constant_name, false)
+
+          gem_constant = Object.const_get(gem_constant_name)
+          next unless gem_constant.is_a?(Module)
+
+          # Then check if it has a RailsLensExtension without triggering autoload
+          next unless gem_constant.const_defined?('RailsLensExtension', false)
+
+          extension_class = gem_constant.const_get('RailsLensExtension')
+          if valid_extension?(extension_class)
+            extensions << extension_class
+          else
+            log_extension_error("Gem extension #{extension_constant_name} failed validation", gem_name)
+          end
+        rescue NameError
+          # No extension found in this gem - this is normal, not an error
+        rescue StandardError => e
+          log_extension_error("Error loading gem extension: #{e.message}", gem_name)
+        end
+
+        extensions
+      end
+
+      def load_custom_extensions
+        extensions = []
+
+        custom_paths = RailsLens.config.extensions[:custom_paths]
+        custom_paths.each do |path|
+          next unless File.directory?(path)
+
+          Dir[File.join(path, '*.rb')].each do |file|
+            require file
+
+            # Try to determine the class name from the file
+            basename = File.basename(file, '.rb')
+            class_name = basename.split('_').map(&:capitalize).join
+
+            # Check in various namespaces
+            found = false
+            [class_name, "RailsLens::Extensions::#{class_name}"].each do |full_name|
+              extension_class = Object.const_get(full_name)
+              if valid_extension?(extension_class)
+                extensions << extension_class
+                found = true
+                break
+              else
+                log_extension_error("Custom extension #{full_name} failed validation", file)
+              end
+            rescue NameError
+              # Try next namespace
+            end
+
+            unless found
+              log_extension_error(
+                "No valid extension class found (tried: #{class_name}, RailsLens::Extensions::#{class_name})", file
+              )
+            end
+          rescue LoadError, SyntaxError => e
+            log_extension_error("Failed to load custom extension file: #{e.message}", file)
+          rescue StandardError => e
+            log_extension_error("Unexpected error loading custom extension: #{e.message}", file)
+          end
+        end
+
+        extensions
+      end
+
+      def valid_extension?(klass)
+        klass.is_a?(Class) &&
+          klass.respond_to?(:gem_name) &&
+          klass.respond_to?(:detect?) &&
+          klass.respond_to?(:interface_version) &&
+          klass.respond_to?(:compatible?) &&
+          klass.compatible?
+      end
+
+      def log_extension_error(message, context = nil)
+        error_reporting = RailsLens.config.extensions[:error_reporting] || :warn
+
+        case error_reporting
+        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
+        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
+        end
+      end
+
+      def log_extension_method_error(extension_class, method_name, error, model_class)
+        context = "#{extension_class.name}##{method_name} for #{model_class.name}"
+        error_reporting = RailsLens.config.extensions[:error_reporting] || :warn
+
+        message = case error_reporting
+                  when :verbose
+                    "#{error.message}\n#{error.backtrace&.first(5)&.join("\n")}"
+                  else
+                    error.message
+                  end
+
+        log_extension_error("Method failed: #{message}", context)
+      end
+    end
+  end
+end

data/lib/rails_lens/extensions/base.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Extensions
+    class Base
+      INTERFACE_VERSION = '1.0'
+
+      class << self
+        def gem_name
+          raise NotImplementedError, "#{self.class.name} must implement .gem_name"
+        end
+
+        def detect?
+          raise NotImplementedError, "#{self.class.name} must implement .detect?"
+        end
+
+        def interface_version
+          self::INTERFACE_VERSION
+        rescue NameError
+          INTERFACE_VERSION
+        end
+
+        def compatible?
+          required_version = RailsLens.config.extensions[:interface_version]
+          Gem::Version.new(interface_version) >= Gem::Version.new(required_version)
+        end
+
+        # Helper method for gem-based detection
+        def gem_available?(gem_name)
+          Gem::Specification.find_by_name(gem_name)
+          true
+        rescue Gem::LoadError
+          false
+        end
+      end
+
+      attr_reader :model_class
+
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      # Override this method to provide model-specific annotations
+      def annotate
+        nil
+      end
+
+      # Override this method to provide analysis notes
+      def notes
+        []
+      end
+
+      # Override this method to provide ERD additions
+      def erd_additions
+        {
+          relationships: [],
+          badges: [],
+          attributes: {}
+        }
+      end
+
+      # Validation helper methods
+      def safe_method_call(method_name, default_value = nil)
+        return default_value unless respond_to?(method_name)
+
+        send(method_name)
+      rescue StandardError => e
+        log_method_error(method_name, e)
+        default_value
+      end
+
+      def validate_array_result(result, method_name = 'unknown')
+        return [] unless result.is_a?(Array)
+
+        result.select { |item| item.is_a?(String) }
+      rescue StandardError => e
+        log_method_error(method_name, e)
+        []
+      end
+
+      def validate_hash_result(result, required_keys = [], method_name = 'unknown')
+        unless result.is_a?(Hash)
+          log_method_error(method_name, "Expected Hash, got #{result.class}")
+          return required_keys.index_with { |_key| [] }
+        end
+
+        # Ensure required keys exist with default values
+        required_keys.each do |key|
+          result[key] ||= key == :attributes ? {} : []
+        end
+
+        result
+      rescue StandardError => e
+        log_method_error(method_name, e)
+        required_keys.index_with { |key| key == :attributes ? {} : [] }
+      end
+
+      protected
+
+      # Helper methods for extensions
+
+      def table_name
+        model_class.table_name
+      end
+
+      def connection
+        model_class.connection
+      end
+
+      def columns
+        @columns ||= connection.columns(table_name)
+      end
+
+      def column_names
+        @column_names ||= columns.map(&:name)
+      end
+
+      def has_column?(column_name)
+        column_names.include?(column_name.to_s)
+      end
+
+      def indexes
+        @indexes ||= connection.indexes(table_name)
+      end
+
+      def index_names
+        @index_names ||= indexes.map(&:name)
+      end
+
+      def has_index?(column_name)
+        indexes.any? { |index| index.columns.include?(column_name.to_s) }
+      end
+
+      def foreign_keys
+        @foreign_keys ||= if connection.respond_to?(:foreign_keys)
+                            connection.foreign_keys(table_name)
+                          else
+                            []
+                          end
+      end
+
+      def associations
+        @associations ||= model_class.reflect_on_all_associations
+      end
+
+      def has_many_associations
+        associations.select { |a| a.macro == :has_many }
+      end
+
+      def belongs_to_associations
+        associations.select { |a| a.macro == :belongs_to }
+      end
+
+      def has_one_associations
+        associations.select { |a| a.macro == :has_one }
+      end
+
+      def has_and_belongs_to_many_associations
+        associations.select { |a| a.macro == :has_and_belongs_to_many }
+      end
+
+      private
+
+      def log_method_error(method_name, error)
+        error_reporting = RailsLens.config.extensions[:error_reporting] || :warn
+        context = "#{self.class.name}##{method_name} for #{model_class.name}"
+
+        message = case error_reporting
+                  when :verbose
+                    error.is_a?(String) ? error : "#{error.message}\n#{error.backtrace&.first(3)&.join("\n")}"
+                  else
+                    error.is_a?(String) ? error : error.message
+                  end
+
+        case error_reporting
+        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
+        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
+        end
+      end
+    end
+  end
+end

data/lib/rails_lens/extensions/closure_tree_ext.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RailsLens
+  module Extensions
+    class ClosureTreeExt < Base
+      def self.gem_name
+        'closure_tree'
+      end
+
+      def self.detect?
+        if gem_available?(gem_name)
+          require gem_name
+          true
+        else
+          false
+        end
+      end
+
+      def annotate
+        return nil unless model_uses_closure_tree?
+
+        lines = []
+        lines << '== Hierarchy (ClosureTree)'
+        lines << "Parent Column: #{parent_column_name}"
+        lines << "Hierarchy Table: #{hierarchy_table_name}"
+
+        lines << "Order Column: #{order_column}" if order_column
+
+        lines << "Depth Column: #{depth_column}" if depth_column && has_column?(depth_column)
+
+        lines.join("\n")
+      end
+
+      def notes
+        return [] unless model_uses_closure_tree?
+
+        notes = []
+
+        # Check parent column index
+        notes << "Missing index on parent column '#{parent_column_name}'" unless has_index?(parent_column_name)
+
+        # Check hierarchy table existence and indexes
+        if hierarchy_table_exists?
+          unless has_hierarchy_indexes?
+            notes << "Hierarchy table '#{hierarchy_table_name}' needs compound index on (ancestor_id, descendant_id)"
+          end
+
+          unless has_hierarchy_depth_index?
+            notes << 'Consider adding index on generations column in hierarchy table for depth queries'
+          end
+        else
+          notes << "Hierarchy table '#{hierarchy_table_name}' does not exist - run migrations"
+        end
+
+        # Check for counter cache
+        if should_have_counter_cache? && !has_counter_cache?
+          notes << "Consider adding counter cache '#{suggested_counter_cache_name}' for children count"
+        end
+
+        # Check depth column
+        if model_class.respond_to?(:cache_depth?) && model_class.cache_depth? && !has_column?(depth_column)
+          notes << "Depth caching enabled but column '#{depth_column}' is missing"
+        end
+
+        notes
+      end
+
+      def erd_additions
+        return default_erd_additions unless model_uses_closure_tree?
+
+        {
+          relationships: [
+            {
+              type: 'hierarchy',
+              from: table_name,
+              to: hierarchy_table_name,
+              label: 'closure table',
+              style: 'dashed'
+            }
+          ],
+          badges: ['tree'],
+          attributes: {
+            tree_type: 'closure_tree',
+            hierarchy_table: hierarchy_table_name
+          }
+        }
+      end
+
+      private
+
+      def model_uses_closure_tree?
+        # Check for both acts_as_tree and has_closure_tree
+        (model_class.respond_to?(:acts_as_tree) || model_class.respond_to?(:has_closure_tree)) &&
+          model_class.respond_to?(:_ct)
+      end
+
+      def parent_column_name
+        model_class._ct.parent_column_name
+      end
+
+      def hierarchy_table_name
+        model_class._ct.hierarchy_table_name
+      end
+
+      def order_column
+        model_class._ct.order_column
+      end
+
+      def depth_column
+        "#{model_class._ct.name_column}_depth"
+      end
+
+      def hierarchy_table_exists?
+        connection.table_exists?(hierarchy_table_name)
+      end
+
+      def has_hierarchy_indexes?
+        return false unless hierarchy_table_exists?
+
+        indexes = connection.indexes(hierarchy_table_name)
+        indexes.any? do |index|
+          index.columns.sort == %w[ancestor_id descendant_id].sort
+        end
+      end
+
+      def has_hierarchy_depth_index?
+        return false unless hierarchy_table_exists?
+
+        indexes = connection.indexes(hierarchy_table_name)
+        indexes.any? do |index|
+          index.columns.include?('generations')
+        end
+      end
+
+      def should_have_counter_cache?
+        # Suggest counter cache for models that likely have many children
+        has_many_associations.any? { |a| a.name.to_s.match?(/child|children|descendant/) }
+      end
+
+      def has_counter_cache?
+        column_names.any? { |col| col.match?(/children_count|descendants_count/) }
+      end
+
+      def suggested_counter_cache_name
+        'children_count'
+      end
+
+      def default_erd_additions
+        {
+          relationships: [],
+          badges: [],
+          attributes: {}
+        }
+      end
+    end
+  end
+end