lagoon 0.1.0 → 0.2.0

data/lib/lagoon/options.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Lagoon
+  class Options
+    include Enumerable
+
+    COMMON_KEYS = %i[output verbose strict eager_load].freeze
+    KEYS = {
+      model: COMMON_KEYS + %i[
+        direction brief show_attributes show_methods include_inheritance exclude specify
+        all_models show_belongs_to hide_through all_columns hide_magic hide_types
+        include_framework_bases duplicate_sti_attributes
+      ],
+      controller: COMMON_KEYS + %i[
+        direction brief include_inheritance exclude specify all_controllers hide_public
+        hide_protected hide_private include_framework_bases
+      ],
+      er: COMMON_KEYS + %i[exclude specify connections internal_tables],
+      controller_model: COMMON_KEYS + %i[
+        direction exclude specify all_controllers show_actions helper_models
+      ]
+    }.transform_values(&:freeze).freeze
+
+    attr_reader :kind
+
+    def self.for(kind, raw_options = nil, config: Lagoon.configuration, **keyword_options)
+      options = (raw_options || {}).to_h.merge(keyword_options)
+      new(kind, options, config: config)
+    end
+
+    def self.allowed_keys(kind)
+      KEYS.fetch(kind)
+    end
+
+    def initialize(kind, raw_options = {}, config: Lagoon.configuration)
+      @kind = kind.to_sym
+      @config = config
+      @raw = symbolize_keys(raw_options)
+      validate_keys!
+      @values = normalize.freeze
+      freeze
+    end
+
+    def [](key)
+      @values[key.to_sym]
+    end
+
+    def fetch(key, *defaults, &)
+      @values.fetch(key.to_sym, *defaults, &)
+    end
+
+    def key?(key)
+      @values.key?(key.to_sym)
+    end
+
+    def each(&)
+      @values.each(&)
+    end
+
+    def to_h
+      @values.dup
+    end
+
+    private
+
+    def symbolize_keys(raw_options)
+      raw_options.to_h.transform_keys(&:to_sym)
+    end
+
+    def validate_keys!
+      unknown = @raw.keys - self.class.allowed_keys(@kind)
+      return if unknown.empty?
+
+      raise ConfigurationError, "Unknown #{@kind} option(s): #{unknown.sort.join(', ')}"
+    end
+
+    def normalize
+      values = common_values
+      case @kind
+      when :model then values.merge(model_values)
+      when :controller then values.merge(controller_values)
+      when :er then values.merge(er_values)
+      when :controller_model then values.merge(controller_model_values)
+      else raise ConfigurationError, "Unknown diagram kind: #{@kind}"
+      end
+    end
+
+    def common_values
+      {
+        output: optional_path(@raw[:output]),
+        verbose: boolean(:verbose, false),
+        strict: boolean(:strict, @config.strict),
+        eager_load: boolean(:eager_load, true)
+      }
+    end
+
+    def model_values
+      brief = boolean(:brief, false)
+      {
+        direction: direction,
+        brief: brief,
+        show_attributes: brief ? false : boolean(:show_attributes, @config.show_attributes),
+        show_methods: brief ? false : boolean(:show_methods, @config.show_methods),
+        include_inheritance: boolean(:include_inheritance, @config.include_inheritance),
+        exclude: names(@config.exclude_models, @raw[:exclude]),
+        specify: names(@raw[:specify]),
+        all_models: boolean(:all_models, false),
+        show_belongs_to: boolean(:show_belongs_to, false),
+        hide_through: boolean(:hide_through, false),
+        all_columns: boolean(:all_columns, false),
+        hide_magic: boolean(:hide_magic, false),
+        hide_types: boolean(:hide_types, false),
+        include_framework_bases: boolean(:include_framework_bases, @config.include_framework_bases),
+        duplicate_sti_attributes: boolean(:duplicate_sti_attributes, false)
+      }
+    end
+
+    def controller_values
+      brief = boolean(:brief, false)
+      {
+        direction: direction,
+        brief: brief,
+        include_inheritance: boolean(:include_inheritance, @config.include_inheritance),
+        exclude: names(@config.exclude_controllers, @raw[:exclude]),
+        specify: names(@raw[:specify]),
+        all_controllers: boolean(:all_controllers, false),
+        hide_public: brief || boolean(:hide_public, false),
+        hide_protected: brief || boolean(:hide_protected, false),
+        hide_private: brief || boolean(:hide_private, false),
+        include_framework_bases: boolean(:include_framework_bases, @config.include_framework_bases)
+      }
+    end
+
+    def er_values
+      {
+        exclude: names(@config.exclude_tables, @raw[:exclude]),
+        specify: names(@raw[:specify]),
+        connections: @raw[:connections],
+        internal_tables: names(@raw.fetch(:internal_tables, @config.internal_tables))
+      }
+    end
+
+    def controller_model_values
+      {
+        direction: direction,
+        exclude: names(@config.exclude_controllers, @raw[:exclude]),
+        specify: names(@raw[:specify]),
+        all_controllers: boolean(:all_controllers, false),
+        show_actions: boolean(:show_actions, true),
+        helper_models: normalize_helper_models(@raw.fetch(:helper_models, @config.helper_models))
+      }
+    end
+
+    def direction
+      value = @raw.fetch(:direction, @config.diagram_direction)
+      Configuration.validate_direction!(value)
+    end
+
+    def boolean(key, default)
+      @raw.key?(key) ? !!@raw[key] : default
+    end
+
+    def names(*groups)
+      groups.compact.flatten.map(&:to_s).reject(&:empty?).uniq.sort.freeze
+    end
+
+    def normalize_helper_models(mapping)
+      mapping.to_h.each_with_object({}) do |(helper, model), result|
+        result[helper.to_s] = model.to_s
+      end.freeze
+    end
+
+    def optional_path(path)
+      return nil if path.nil?
+
+      value = path.to_s
+      raise ConfigurationError, 'Output path cannot be empty' if value.empty?
+
+      value.freeze
+    end
+  end
+end

data/lib/lagoon/parser/application_class_filter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+
+module Lagoon
+  module Parser
+    class ApplicationClassFilter
+      def initialize(directory:, include_all: false)
+        @directory = directory
+        @include_all = include_all
+      end
+
+      def include?(klass)
+        return false unless klass.name
+        return true if @include_all
+        return true unless defined?(Rails) && Rails.respond_to?(:root)
+
+        application_directory = File.expand_path(File.join(Rails.root.to_s, 'app', @directory))
+        source_locations(klass).any? do |location|
+          File.expand_path(location).start_with?("#{application_directory}#{File::SEPARATOR}")
+        end
+      end
+
+      private
+
+      def source_locations(klass)
+        locations = [constant_source_location(klass)]
+        method_names = klass.instance_methods(false) +
+                       klass.private_instance_methods(false) +
+                       klass.protected_instance_methods(false)
+        locations.concat(method_names.filter_map { |name| klass.instance_method(name).source_location&.first })
+        locations.compact.uniq
+      rescue NameError
+        []
+      end
+
+      def constant_source_location(klass)
+        namespace_name = klass.name.deconstantize
+        constant_name = klass.name.demodulize.to_sym
+        namespace = namespace_name.empty? ? Object : namespace_name.safe_constantize
+        namespace&.const_source_location(constant_name)&.first
+      end
+    end
+  end
+end

data/lib/lagoon/parser/controller_model_parser.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+
+module Lagoon
+  module Parser
+    class ControllerModelParser
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = options.is_a?(Options) ? options : Options.for(:controller_model, options)
+        @filter = ApplicationClassFilter.new(
+          directory: 'controllers',
+          include_all: @options[:all_controllers]
+        )
+      end
+
+      def parse
+        relationships = []
+        warnings = []
+        model_metadata = load_model_metadata(warnings)
+
+        load_controllers.sort_by { |controller| controller.name.to_s }.each do |controller|
+          next if excluded?(controller)
+
+          analyze_controller(controller, model_metadata, relationships, warnings)
+        end
+
+        aggregated = aggregate_relationships(relationships)
+        {
+          relationships: aggregated,
+          warnings: warnings,
+          counts: { relationships: aggregated.size, skipped: warnings.size }
+        }
+      end
+
+      private
+
+      def load_controllers
+        return [] unless defined?(ActionController::Base)
+
+        Rails.application.eager_load! if options[:eager_load] && defined?(Rails)
+        ActionController::Base.descendants
+      end
+
+      def load_model_metadata(warnings)
+        return { names: [], associations: {} } unless defined?(ActiveRecord::Base)
+
+        models = ActiveRecord::Base.descendants.select(&:name)
+        associations = models.to_h do |model|
+          [model.name, association_mapping(model, warnings)]
+        end
+        { names: models.map(&:name), associations: associations }
+      end
+
+      def association_mapping(model, warnings)
+        model.reflect_on_all_associations.each_with_object({}) do |association, result|
+          next if association.options[:polymorphic]
+
+          result[association.name.to_s] = association.class_name
+        rescue NameError => e
+          warnings << "Could not resolve #{model.name}.#{association.name}: #{e.message}"
+        end
+      end
+
+      def excluded?(controller)
+        controller_name = controller.name
+        return true unless controller_name
+        return true unless @filter.include?(controller)
+        return true if options[:exclude].include?(controller_name)
+        return !options[:specify].include?(controller_name) if options[:specify].any?
+
+        false
+      end
+
+      def analyze_controller(controller, model_metadata, relationships, warnings)
+        actions = controller.action_methods.to_a.map(&:to_s).sort
+        return if actions.empty?
+
+        source_context = source_context_for(controller, actions)
+        if source_context[:files].empty?
+          warnings << "No source file found for #{controller.name}"
+          return
+        end
+
+        action_models = analyze_source_files(
+          source_context[:files],
+          actions,
+          source_context[:controller_names],
+          model_metadata
+        )
+        add_relationships(controller.name, action_models, relationships)
+      rescue Errno::ENOENT, Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError, ParseError => e
+        raise if options[:strict]
+
+        warnings << "Failed to parse #{controller.name}: #{e.message}"
+      end
+
+      def source_context_for(controller, actions)
+        owners = actions.filter_map do |action|
+          controller.instance_method(action).owner
+        rescue NameError
+          nil
+        end
+        owners << controller
+        owners.concat(callback_owners(controller))
+        owners.select!(&:name)
+
+        {
+          controller_names: owners.map(&:name).uniq,
+          files: owners.flat_map { |owner| source_files_for(owner) }.compact.uniq.select { |file| File.file?(file) }
+        }
+      end
+
+      def source_files_for(controller)
+        method_names = controller.instance_methods(false) +
+                       controller.private_instance_methods(false) +
+                       controller.protected_instance_methods(false)
+        files = method_names.filter_map do |method_name|
+          controller.instance_method(method_name).source_location&.first
+        end
+        constant_location = constant_source_location(controller)
+        files << constant_location if constant_location
+        files << conventional_source_file(controller) if files.empty?
+        files
+      rescue NameError
+        [conventional_source_file(controller)]
+      end
+
+      def constant_source_location(controller)
+        namespace_name = controller.name.deconstantize
+        namespace = namespace_name.empty? ? Object : namespace_name.safe_constantize
+        namespace&.const_source_location(controller.name.demodulize.to_sym)&.first
+      end
+
+      def conventional_source_file(controller)
+        return nil unless defined?(Rails) && Rails.respond_to?(:root)
+
+        Rails.root.join('app', 'controllers', "#{controller.name.underscore}.rb").to_s
+      end
+
+      def callback_methods(controller)
+        return [] unless controller.respond_to?(:_process_action_callbacks)
+
+        controller._process_action_callbacks.filter_map do |callback|
+          callback.filter.to_s if callback.filter.is_a?(Symbol)
+        end.uniq
+      end
+
+      def callback_owners(controller)
+        callback_methods(controller).filter_map do |method_name|
+          controller.instance_method(method_name).owner
+        rescue NameError
+          nil
+        end
+      end
+
+      def analyze_source_files(file_paths, action_names, controller_names, model_metadata)
+        require_relative '../analyzer/ast_model_reference_analyzer'
+        analyzer = Lagoon::Analyzer::AstModelReferenceAnalyzer.new
+        analyzer.analyze(
+          file_paths,
+          action_names,
+          controller_names: controller_names,
+          model_names: model_metadata[:names],
+          associations: model_metadata[:associations],
+          helper_models: options[:helper_models]
+        )
+      end
+
+      def add_relationships(controller_name, action_models, relationships)
+        action_models.each do |action, models|
+          models.each do |model|
+            relationships << { controller: controller_name, action: action, model: model }
+          end
+        end
+      end
+
+      def aggregate_relationships(relationships)
+        grouped = relationships.group_by { |relationship| [relationship[:controller], relationship[:model]] }
+
+        aggregated = grouped.map do |(controller, model), items|
+          {
+            controller: controller,
+            model: model,
+            actions: items.map { |item| item[:action] }.sort.uniq
+          }
+        end
+
+        aggregated.sort_by { |relationship| [relationship[:controller], relationship[:model]] }
+      end
+    end
+  end
+end

data/lib/lagoon/parser/controller_parser.rb

@@ -6,8 +6,9 @@ module Lagoon
       attr_reader :options, :config
 
       def initialize(options = {})
-        @options = options
-        @config = Lagoon.configuration
+        @options = options.is_a?(Options) ? options : Options.for(:controller, options)
+        @analyzer = Lagoon::Analyzer::ActionControllerAnalyzer.new
+        @filter = ApplicationClassFilter.new(directory: 'controllers', include_all: @options[:all_controllers])
       end
 
       def parse
@@ -15,80 +16,62 @@ module Lagoon
         classes = []
         relationships = []
 
-        controllers.each do |controller|
+        warnings = []
+
+        controllers.sort_by { |controller| controller.name.to_s }.each do |controller|
           next if excluded?(controller)
 
-          classes << parse_controller(controller)
-          relationships.concat(extract_inheritance(controller)) if config.include_inheritance
+          controller_data = @analyzer.analyze_controller(controller, analysis_options)
+          classes << controller_data
+
+          if options[:include_inheritance]
+            relationships.concat(
+              @analyzer.extract_inheritance(
+                controller,
+                include_framework_base: options[:include_framework_bases]
+              )
+            )
+          end
+        rescue StandardError => e
+          raise if options[:strict]
+
+          warnings << "Failed to analyze controller #{controller.name || '(anonymous)'}: #{e.message}"
         end
 
         {
-          classes: classes,
-          relationships: relationships
+          classes: classes.sort_by { |controller| controller[:name] },
+          relationships: relationships.sort_by { |relationship| [relationship[:source], relationship[:target]] },
+          warnings: warnings,
+          counts: { classes: classes.size, relationships: relationships.size, skipped: warnings.size }
         }
       end
 
       private
 
       def load_controllers
-        # Railsアプリケーションの全コントローラをロード
-        return [] unless defined?(Rails)
+        return [] unless defined?(ActionController::Base)
 
-        Rails.application.eager_load!
+        Rails.application.eager_load! if options[:eager_load] && defined?(Rails)
         ActionController::Base.descendants
       end
 
       def excluded?(controller)
         controller_name = controller.name
-        config.exclude_controllers.include?(controller_name)
+        return true unless controller_name
+        return true unless @filter.include?(controller)
+        return true if options[:exclude].include?(controller_name)
+        return !options[:specify].include?(controller_name) if options[:specify].any?
+
+        false
       end
 
-      def parse_controller(controller)
+      def analysis_options
         {
-          name: controller.name,
-          abstract: false,
-          attributes: [],
-          methods: extract_methods(controller)
+          hide_public: options[:hide_public],
+          hide_protected: options[:hide_protected],
+          hide_private: options[:hide_private]
         }
       end
-
-      def extract_methods(controller)
-        methods = []
-
-        # Public methods
-        unless options[:hide_public]
-          public_methods = controller.action_methods.to_a
-          methods.concat(public_methods.map { |m| { name: m, visibility: "+" } })
-        end
-
-        # Protected methods
-        unless options[:hide_protected]
-          protected_methods = controller.protected_instance_methods(false)
-          methods.concat(protected_methods.map { |m| { name: m, visibility: "#" } })
-        end
-
-        # Private methods
-        unless options[:hide_private]
-          private_methods = controller.private_instance_methods(false)
-          methods.concat(private_methods.map { |m| { name: m, visibility: "-" } })
-        end
-
-        methods
-      end
-
-      def extract_inheritance(controller)
-        return [] if controller.superclass == ActionController::Base
-        return [] unless controller.superclass.name
-
-        [{
-          source: controller.superclass.name,
-          target: controller.name,
-          type: :inheritance,
-          label: nil
-        }]
-      rescue StandardError
-        []
-      end
     end
   end
 end