lagoon 0.1.0 → 0.2.0

data/lib/lagoon/analyzer/action_controller_analyzer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Analyzer
+    # Analyzes ActionController classes to extract metadata
+    # including methods and inheritance
+    class ActionControllerAnalyzer
+      # Analyze a single controller and return its metadata
+      #
+      # @param controller [Class] ActionController class
+      # @param options [Hash] Analysis options
+      # @return [Hash] Controller metadata
+      def analyze_controller(controller, options = {})
+        {
+          name: controller.name,
+          abstract: abstract_controller?(controller),
+          attributes: [],
+          methods: extract_methods(controller, options)
+        }
+      end
+
+      # Extract inheritance relationship from a controller
+      #
+      # @param controller [Class] ActionController class
+      # @return [Array<Hash>] Inheritance metadata (empty or single element)
+      def extract_inheritance(controller, include_framework_base: false)
+        return [] if controller.superclass == ActionController::Base && !include_framework_base
+        return [] unless controller.superclass.name
+        return [] if !include_framework_base && controller.superclass.name.start_with?('ActionController::')
+
+        [{
+          source: controller.superclass.name,
+          target: controller.name,
+          type: :inheritance,
+          label: nil
+        }]
+      rescue NameError
+        []
+      end
+
+      private
+
+      def extract_methods(controller, options = {})
+        methods = []
+
+        # Public methods (action methods)
+        unless options[:hide_public]
+          declared_public = controller.public_instance_methods(false).map(&:to_s)
+          public_methods = controller.action_methods.to_a.map(&:to_s) & declared_public
+          methods.concat(public_methods.map { |m| { name: m, visibility: '+' } })
+        end
+
+        # Protected methods
+        unless options[:hide_protected]
+          protected_methods = controller.protected_instance_methods(false).map(&:to_s)
+          methods.concat(protected_methods.map { |m| { name: m, visibility: '#' } })
+        end
+
+        # Private methods
+        unless options[:hide_private]
+          private_methods = controller.private_instance_methods(false).map(&:to_s)
+          methods.concat(private_methods.map { |m| { name: m, visibility: '-' } })
+        end
+
+        methods.sort_by { |method| [method[:visibility], method[:name]] }
+      end
+
+      def abstract_controller?(controller)
+        return controller.abstract? if controller.respond_to?(:abstract?)
+        return controller.abstract_controller? if controller.respond_to?(:abstract_controller?)
+
+        false
+      end
+    end
+  end
+end

data/lib/lagoon/analyzer/active_record_analyzer.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Analyzer
+    # Analyzes ActiveRecord models to extract metadata
+    # including columns, methods, associations, and inheritance
+    class ActiveRecordAnalyzer
+      # Analyze a single model and return its metadata
+      #
+      # @param model [Class] ActiveRecord model class
+      # @param options [Hash] Analysis options
+      # @return [Hash] Model metadata
+      def analyze_model(model, options = {})
+        {
+          name: model.name,
+          abstract: model.abstract_class?,
+          attributes: extract_columns(model, options),
+          methods: extract_methods(model, options)
+        }
+      end
+
+      # Extract associations from a model
+      #
+      # @param model [Class] ActiveRecord model class
+      # @param options [Hash] Extraction options
+      # @return [Array<Hash>] Association metadata
+      def extract_associations(model, options = {})
+        associations = []
+
+        model.reflect_on_all_associations.each do |assoc|
+          next if assoc.options[:through] && options[:hide_through]
+
+          association_data = build_association(model, assoc, options)
+          associations << association_data if association_data
+        end
+
+        associations
+      end
+
+      # Extract inheritance relationship from a model
+      #
+      # @param model [Class] ActiveRecord model class
+      # @return [Array<Hash>] Inheritance metadata (empty or single element)
+      def extract_inheritance(model)
+        extract_inheritance_with_options(model)
+      end
+
+      def extract_inheritance_with_options(model, include_framework_base: false)
+        return [] if model.superclass == ActiveRecord::Base && !include_framework_base
+        return [] if model.superclass.nil? || model.superclass.name.nil?
+        return [] if !include_framework_base && framework_model?(model.superclass)
+
+        [{
+          source: model.superclass.name,
+          target: model.name,
+          type: :inheritance,
+          label: nil
+        }]
+      rescue NameError
+        []
+      end
+
+      private
+
+      def extract_columns(model, options = {})
+        return [] unless options.fetch(:show_attributes, true)
+        return [] unless model.table_exists?
+        return [] if sti_subclass?(model) && !options[:duplicate_sti_attributes]
+
+        columns = model.columns
+        if options[:hide_magic] && !options[:all_columns]
+          columns = columns.reject do |column|
+            magic_field?(column.name)
+          end
+        end
+
+        columns.sort_by(&:name).map do |column|
+          {
+            name: column.name,
+            type: column.type,
+            visibility: '+'
+          }
+        end
+      end
+
+      def magic_field?(field_name)
+        %w[id created_at updated_at].include?(field_name)
+      end
+
+      def extract_methods(model, options = {})
+        return [] unless options[:show_methods]
+
+        declared_methods(model, :public_instance_methods, '+') +
+          declared_methods(model, :protected_instance_methods, '#') +
+          declared_methods(model, :private_instance_methods, '-')
+      end
+
+      def build_association(model, assoc, options = {})
+        case assoc.macro
+        when :belongs_to
+          return nil unless options[:show_belongs_to]
+
+          {
+            source: model.name,
+            target: association_target(assoc),
+            type: :association,
+            macro: :belongs_to,
+            label: association_label(assoc),
+            source_cardinality: '1',
+            target_cardinality: belongs_to_optional?(model, assoc) ? '0..1' : '1',
+            polymorphic: !assoc.options[:polymorphic].nil?
+          }
+        when :has_one
+          {
+            source: model.name,
+            target: assoc.class_name,
+            type: :association,
+            macro: :has_one,
+            label: association_label(assoc),
+            source_cardinality: '1',
+            target_cardinality: '0..1'
+          }
+        when :has_many
+          {
+            source: model.name,
+            target: assoc.class_name,
+            type: :association,
+            macro: :has_many,
+            label: association_label(assoc),
+            source_cardinality: '1',
+            target_cardinality: '*'
+          }
+        when :has_and_belongs_to_many
+          {
+            source: model.name,
+            target: assoc.class_name,
+            type: :association,
+            macro: :has_and_belongs_to_many,
+            label: association_label(assoc),
+            source_cardinality: '*',
+            target_cardinality: '*'
+          }
+        end
+      rescue NameError
+        nil
+      end
+
+      def declared_methods(model, query, visibility)
+        model.public_send(query, false).select { |name| application_method?(model, name) }
+                                       .sort_by(&:to_s).map do |name|
+          { name: name.to_s, visibility: visibility }
+        end
+      end
+
+      def application_method?(model, method_name)
+        source_file = model.instance_method(method_name).source_location&.first
+        return false unless source_file
+        return application_model_file?(source_file) if defined?(Rails) && Rails.respond_to?(:root)
+
+        !source_file.match?(%r{/gems/(?:activerecord|activesupport)-})
+      rescue NameError
+        false
+      end
+
+      def application_model_file?(source_file)
+        models_path = File.expand_path(File.join(Rails.root.to_s, 'app', 'models'))
+        File.expand_path(source_file).start_with?("#{models_path}#{File::SEPARATOR}")
+      end
+
+      def association_target(association)
+        return association.name.to_s.camelize if association.options[:polymorphic]
+
+        association.class_name
+      end
+
+      def association_label(association)
+        label = "#{association.macro} #{association.name}"
+        label += " through #{association.options[:through]}" if association.options[:through]
+        label += ' (polymorphic)' if association.options[:polymorphic]
+        label
+      end
+
+      def belongs_to_optional?(model, association)
+        return association.options[:optional] if association.options.key?(:optional)
+        return !association.options[:required] if association.options.key?(:required)
+
+        return false unless model.respond_to?(:belongs_to_required_by_default)
+
+        required = model.belongs_to_required_by_default
+        required.nil? ? false : !required
+      end
+
+      def sti_subclass?(model)
+        model.respond_to?(:base_class) && model.base_class != model && model.table_name == model.base_class.table_name
+      end
+
+      def framework_model?(model)
+        model.name.start_with?('ActiveRecord::')
+      end
+    end
+  end
+end

data/lib/lagoon/analyzer/ast/controller_scope_collector.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Analyzer
+    class ControllerScopeCollector < Prism::Visitor
+      Callback = Data.define(:method_name, :only_actions, :except_actions) do
+        def applies_to?(action)
+          return false if except_actions.include?(action)
+          return true if only_actions.empty?
+
+          only_actions.include?(action)
+        end
+      end
+
+      attr_reader :methods
+
+      def initialize(controller_names: nil)
+        super()
+        @controller_names = Array(controller_names).compact.to_set(&:to_s)
+        @methods = {}
+        @callbacks = []
+        @namespace = []
+      end
+
+      def callbacks_for(action)
+        @callbacks.select { |callback| callback.applies_to?(action) }.map(&:method_name)
+      end
+
+      def visit_module_node(node)
+        with_namespace(constant_path_name(node.constant_path)) { super }
+      end
+
+      def visit_class_node(node)
+        class_name = qualified_name(node.constant_path)
+        return unless @controller_names.empty? || @controller_names.include?(class_name)
+
+        Array(node.body&.body).each do |child|
+          case child
+          when Prism::DefNode then @methods[child.name.to_s] = child
+          when Prism::CallNode then collect_callback(child)
+          end
+        end
+      end
+
+      private
+
+      def with_namespace(name)
+        @namespace << name
+        yield
+      ensure
+        @namespace.pop
+      end
+
+      def qualified_name(node)
+        path = constant_path_name(node)
+        return path if path.include?('::') || @namespace.empty?
+
+        [*@namespace, path].join('::')
+      end
+
+      def constant_path_name(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          [constant_path_name(node.parent), node.name.to_s].reject(&:empty?).join('::')
+        else
+          ''
+        end
+      end
+
+      def collect_callback(node)
+        return unless %i[before_action prepend_before_action append_before_action].include?(node.name)
+
+        arguments = Array(node.arguments&.arguments)
+        method_names = arguments.take_while { |argument| argument.is_a?(Prism::SymbolNode) }
+                                .map(&:unescaped)
+        options = callback_options(arguments.find { |argument| argument.is_a?(Prism::KeywordHashNode) })
+        method_names.each do |method_name|
+          @callbacks << Callback.new(
+            method_name: method_name,
+            only_actions: options.fetch('only', []),
+            except_actions: options.fetch('except', [])
+          )
+        end
+      end
+
+      def callback_options(keyword_hash)
+        return {} unless keyword_hash
+
+        keyword_hash.elements.each_with_object({}) do |element, result|
+          next unless element.is_a?(Prism::AssocNode) && element.key.is_a?(Prism::SymbolNode)
+
+          result[element.key.unescaped] = symbol_values(element.value)
+        end
+      end
+
+      def symbol_values(node)
+        nodes = node.is_a?(Prism::ArrayNode) ? node.elements : [node]
+        nodes.filter_map { |value| value.unescaped if value.is_a?(Prism::SymbolNode) }
+      end
+    end
+  end
+end

data/lib/lagoon/analyzer/ast/method_reference_visitor.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Analyzer
+    class MethodReferenceVisitor < Prism::Visitor
+      def initialize(methods:, model_names:, associations:, helper_models:)
+        super()
+        @methods = methods
+        @model_names = model_names.to_set(&:to_s)
+        @associations = normalize_associations(associations)
+        @helper_models = helper_models.to_h.transform_keys(&:to_s).transform_values(&:to_s)
+      end
+
+      def models_for(action, callbacks: [])
+        @models = Set.new
+        @instance_variables = {}
+        @method_stack = []
+
+        callbacks.each { |callback| analyze_method(callback.to_s) }
+        analyze_method(action.to_s)
+        @models
+      end
+
+      def visit_def_node(_node)
+        # Nested method definitions have an independent scope.
+      end
+
+      def visit_constant_read_node(node)
+        record_model(node.name.to_s)
+      end
+
+      def visit_constant_path_node(node)
+        record_model(constant_path_name(node))
+      end
+
+      def visit_local_variable_write_node(node)
+        node.value&.accept(self)
+        @local_variables[node.name.to_s] = infer_value(node.value)
+      end
+
+      def visit_instance_variable_write_node(node)
+        node.value&.accept(self)
+        @instance_variables[node.name.to_s] = infer_value(node.value)
+      end
+
+      def visit_call_node(node)
+        node.receiver&.accept(self)
+        node.arguments&.accept(self)
+
+        returned_models = infer_call(node)
+        returned_models.each { |model| record_model(model) }
+        visit_block(node.block, returned_models) if node.block
+      end
+
+      private
+
+      def analyze_method(method_name)
+        return Set.new if @method_stack.include?(method_name)
+
+        method_node = @methods[method_name]
+        return Set.new unless method_node
+
+        previous_locals = @local_variables
+        @local_variables = {}
+        @method_stack << method_name
+        begin
+          method_node.body&.accept(self)
+          infer_last_expression(method_node.body)
+        ensure
+          @method_stack.pop
+          @local_variables = previous_locals
+        end
+      end
+
+      def infer_last_expression(body)
+        last_node = body.respond_to?(:body) ? body.body.last : body
+        infer_value(last_node)
+      end
+
+      def infer_call(node)
+        if node.receiver.nil?
+          helper_model = @helper_models[node.name.to_s]
+          return Set[helper_model] if known_model?(helper_model)
+          return analyze_method(node.name.to_s) if no_arguments?(node)
+
+          return Set.new
+        end
+
+        receiver_models = infer_value(node.receiver)
+        association_models = receiver_models.filter_map do |model|
+          @associations.dig(model, node.name.to_s)
+        end.flatten.to_set
+
+        association_models.empty? ? receiver_models : association_models
+      end
+
+      def infer_value(node)
+        case node
+        when Prism::ConstantReadNode
+          known_set(node.name.to_s)
+        when Prism::ConstantPathNode
+          known_set(constant_path_name(node))
+        when Prism::LocalVariableReadNode
+          @local_variables.fetch(node.name.to_s, Set.new)
+        when Prism::InstanceVariableReadNode
+          @instance_variables.fetch(node.name.to_s, Set.new)
+        when Prism::CallNode
+          infer_call(node)
+        else
+          Set.new
+        end
+      end
+
+      def visit_block(block, yielded_models)
+        previous = {}
+        block_parameter_names(block).each do |name|
+          previous[name] = @local_variables[name]
+          @local_variables[name] = yielded_models
+        end
+        block.body&.accept(self)
+      ensure
+        previous&.each do |name, value|
+          value ? @local_variables[name] = value : @local_variables.delete(name)
+        end
+      end
+
+      def block_parameter_names(block)
+        parameters = block.parameters&.parameters
+        return [] unless parameters
+
+        parameters.requireds.map { |parameter| parameter.name.to_s }
+      end
+
+      def no_arguments?(node)
+        node.arguments.nil? || node.arguments.arguments.empty?
+      end
+
+      def record_model(name)
+        @models << name if known_model?(name)
+      end
+
+      def known_set(name)
+        known_model?(name) ? Set[name] : Set.new
+      end
+
+      def known_model?(name)
+        name && @model_names.include?(name)
+      end
+
+      def normalize_associations(associations)
+        associations.to_h.each_with_object({}) do |(model, mapping), result|
+          result[model.to_s] = mapping.to_h.each_with_object({}) do |(name, targets), model_result|
+            model_result[name.to_s] = Array(targets).map(&:to_s)
+          end
+        end
+      end
+
+      def constant_path_name(node)
+        case node
+        when Prism::ConstantReadNode
+          node.name.to_s
+        when Prism::ConstantPathNode
+          [constant_path_name(node.parent), node.name.to_s].reject(&:empty?).join('::')
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/lagoon/analyzer/ast_model_reference_analyzer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'prism'
+require_relative 'ast/controller_scope_collector'
+require_relative 'ast/method_reference_visitor'
+
+module Lagoon
+  module Analyzer
+    class AstModelReferenceAnalyzer
+      def analyze(file_paths, action_names, controller_names: nil, model_names: [], associations: {},
+                  helper_models: {}, callback_methods: [])
+        collector = ControllerScopeCollector.new(controller_names: controller_names)
+        Array(file_paths).uniq.each do |file_path|
+          parse_file(file_path).accept(collector)
+        end
+
+        visitor = MethodReferenceVisitor.new(
+          methods: collector.methods,
+          model_names: model_names,
+          associations: associations,
+          helper_models: helper_models
+        )
+
+        action_names.each_with_object({}) do |action_name, result|
+          action = action_name.to_s
+          next unless collector.methods.key?(action)
+
+          callbacks = collector.callbacks_for(action) | callback_methods.map(&:to_s)
+          result[action] = visitor.models_for(action, callbacks: callbacks)
+        end
+      end
+
+      private
+
+      def parse_file(file_path)
+        result = Prism.parse_file(file_path)
+        return result.value if result.success?
+
+        details = result.errors.map(&:message).uniq.join('; ')
+        raise ParseError, "Syntax error in #{file_path}: #{details}"
+      end
+    end
+  end
+end

data/lib/lagoon/analyzer/database_schema_analyzer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Analyzer
+    class DatabaseSchemaAnalyzer
+      def analyze_table(table_name, columns, primary_keys: [], foreign_keys: [], indexes: [])
+        foreign_key_columns = foreign_keys.flat_map { |foreign_key| Array(foreign_key.column).map(&:to_s) }
+        unique_columns = single_column_unique_indexes(indexes)
+        primary_key_columns = Array(primary_keys).map(&:to_s)
+
+        {
+          name: table_name,
+          attributes: columns.map do |column|
+            analyze_column(
+              column,
+              primary_keys: primary_key_columns,
+              foreign_keys: foreign_key_columns,
+              unique_columns: unique_columns
+            )
+          end
+        }
+      end
+
+      def analyze_column(column, primary_keys: [], foreign_keys: [], unique_columns: [])
+        {
+          name: column.name,
+          type: column.type,
+          primary_key: primary_keys.include?(column.name.to_s),
+          foreign_key: foreign_keys.include?(column.name.to_s),
+          unique: unique_columns.include?(column.name.to_s)
+        }
+      end
+
+      def extract_foreign_keys(table_name, columns, foreign_keys:, indexes: [], primary_keys: [], table_prefix: nil)
+        columns_by_name = columns.to_h { |column| [column.name.to_s, column] }
+        primary_key_columns = Array(primary_keys).map(&:to_s)
+
+        foreign_keys.filter_map do |foreign_key|
+          column_names = Array(foreign_key.column).map(&:to_s)
+          foreign_key_columns = column_names.filter_map { |name| columns_by_name[name] }
+          next if foreign_key_columns.empty?
+
+          unique = unique_foreign_key?(column_names, indexes)
+          nullable = foreign_key_columns.any? { |column| column.respond_to?(:null) ? column.null : true }
+          identifying = (column_names - primary_key_columns).empty?
+
+          {
+            source: qualify_table(foreign_key.to_table, table_prefix),
+            target: table_name,
+            label: unique ? 'has one' : 'has many',
+            source_cardinality: nullable ? :zero_or_one : :one,
+            target_cardinality: unique ? :zero_or_one : :zero_or_many,
+            identifying: identifying,
+            foreign_key: column_names
+          }
+        end
+      end
+
+      def internal_table?(table_name, internal_tables: %w[schema_migrations ar_internal_metadata])
+        internal_tables.include?(table_name.to_s)
+      end
+
+      private
+
+      def single_column_unique_indexes(indexes)
+        indexes.select { |index| index.unique && Array(index.columns).size == 1 }
+               .map { |index| Array(index.columns).first.to_s }
+      end
+
+      def unique_foreign_key?(column_names, indexes)
+        indexes.any? do |index|
+          index.unique && Array(index.columns).map(&:to_s).sort == column_names.sort
+        end
+      end
+
+      def qualify_table(table_name, prefix)
+        return table_name.to_s unless prefix
+
+        "#{prefix}.#{table_name}"
+      end
+    end
+  end
+end