lagoon 0.1.0 → 0.2.0

data/lib/lagoon/renderer/class_diagram_renderer.rb

@@ -3,61 +3,63 @@
 module Lagoon
   module Renderer
     class ClassDiagramRenderer < BaseRenderer
+      def initialize(direction: 'TB', show_types: true)
+        super(direction: direction)
+        @show_types = show_types
+      end
+
       def render(parsed_data)
-        output = ["classDiagram"]
+        output = ['classDiagram']
         output << "    direction #{@direction}"
-        output << ""
+        output << ''
 
-        # クラス定義を追加
-        parsed_data[:classes].each do |klass|
+        classes = parsed_data.fetch(:classes, []).select { |klass| klass[:name] }
+        classes.sort_by { |klass| klass[:name].to_s }.each do |klass|
           output << render_class(klass)
+          output << ''
         end
 
-        output << ""
-
-        # 関係性を追加
-        parsed_data[:relationships].each do |rel|
+        relationships = parsed_data.fetch(:relationships, []).select { |rel| rel[:source] && rel[:target] }
+        relationships.sort_by { |rel| relationship_sort_key(rel) }.each do |rel|
           output << render_relationship(rel)
         end
 
-        output.join("\n")
+        output.join("\n").rstrip
       end
 
       private
 
       def render_class(klass)
         lines = []
-        class_name = escape_class_name(klass[:name])
+        class_name = aliased_identifier(klass[:name])
 
         lines << "    class #{class_name} {"
-        lines << "        <<abstract>>" if klass[:abstract]
+        lines << '        <<abstract>>' if klass[:abstract]
 
-        # 属性を追加
         if klass[:attributes]&.any?
-          klass[:attributes].each do |attr|
-            visibility = attr[:visibility] || "+"
+          klass[:attributes].sort_by { |attr| attr[:name].to_s }.each do |attr|
+            visibility = attr[:visibility] || '+'
             type = type_to_mermaid(attr[:type])
-            lines << "        #{visibility}#{type} #{attr[:name]}"
+            prefix = @show_types ? "#{type} " : ''
+            lines << "        #{visibility}#{prefix}#{escape_member(attr[:name])}"
           end
         end
 
-        # メソッドを追加
         if klass[:methods]&.any?
-          klass[:methods].each do |method|
-            visibility = method[:visibility] || "+"
-            return_type = method[:return_type] ? " #{type_to_mermaid(method[:return_type])}" : ""
-            lines << "        #{visibility}#{method[:name]}()#{return_type}"
+          klass[:methods].sort_by { |method| [method[:visibility].to_s, method[:name].to_s] }.each do |method|
+            visibility = method[:visibility] || '+'
+            return_type = method[:return_type] ? " #{type_to_mermaid(method[:return_type])}" : ''
+            lines << "        #{visibility}#{escape_member(method[:name])}()#{return_type}"
           end
         end
 
-        lines << "    }"
-        lines << ""
+        lines << '    }'
         lines.join("\n")
       end
 
       def render_relationship(rel)
-        source = escape_class_name(rel[:source])
-        target = escape_class_name(rel[:target])
+        source = safe_identifier(rel[:source])
+        target = safe_identifier(rel[:target])
         type = rel[:type]
         label = rel[:label]
         source_cardinality = rel[:source_cardinality]
@@ -65,17 +67,17 @@ module Lagoon
 
         arrow = case type
                 when :inheritance
-                  "<|--"
+                  '<|--'
                 when :composition
-                  "*--"
+                  '*--'
                 when :aggregation
-                  "o--"
+                  'o--'
                 when :association
-                  "-->"
+                  '-->'
                 when :dependency
-                  "..>"
+                  '..>'
                 else
-                  "--"
+                  '--'
                 end
 
         line = "    #{source}"
@@ -83,9 +85,13 @@ module Lagoon
         line += " #{arrow} "
         line += "\"#{target_cardinality}\" " if target_cardinality
         line += target
-        line += " : #{label}" if label
+        line += " : #{escape_label(label)}" if label && !label.to_s.empty?
         line
       end
+
+      def relationship_sort_key(relationship)
+        %i[source target type label].map { |key| relationship[key].to_s }
+      end
     end
   end
 end

data/lib/lagoon/renderer/controller_model_er_renderer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Renderer
+    class ControllerModelErRenderer < BaseRenderer
+      def initialize(options = {})
+        super(direction: options[:direction] || 'TB')
+        @show_actions = options.fetch(:show_actions, true)
+      end
+
+      def render(parsed_data)
+        output = ['classDiagram', "    direction #{@direction}", '']
+
+        relationships = parsed_data[:relationships] || []
+        return output.join("\n").rstrip if relationships.empty?
+
+        render_classes(output, relationships)
+        output << ''
+
+        relationships.sort_by { |rel| [rel[:controller].to_s, rel[:model].to_s] }.each do |rel|
+          output << render_relationship(rel)
+        end
+
+        output.join("\n").rstrip
+      end
+
+      private
+
+      def render_relationship(rel)
+        controller = safe_identifier(rel[:controller])
+        model = safe_identifier(rel[:model])
+        actions = rel[:actions] || []
+        label = @show_actions && actions.any? ? " : #{escape_label(actions.sort.join(', '))}" : ''
+
+        "    #{controller} ..> #{model}#{label}"
+      end
+
+      def render_classes(output, relationships)
+        controllers = relationships.filter_map { |rel| rel[:controller] }.uniq.sort
+        models = relationships.filter_map { |rel| rel[:model] }.uniq.sort
+
+        controllers.each { |name| output << "    class #{aliased_identifier(name)}" }
+        models.each { |name| output << "    class #{aliased_identifier(name)}" }
+      end
+    end
+  end
+end

data/lib/lagoon/renderer/er_diagram_renderer.rb

@@ -4,101 +4,102 @@ module Lagoon
   module Renderer
     class ErDiagramRenderer < BaseRenderer
       def render(parsed_data)
-        output = ["erDiagram"]
+        output = ['erDiagram']
 
-        # リレーションシップを先に追加
         if parsed_data[:relationships]&.any?
-          parsed_data[:relationships].each do |rel|
+          parsed_data[:relationships].sort_by { |rel| relationship_sort_key(rel) }.each do |rel|
             output << render_relationship(rel)
           end
-          output << ""
+          output << ''
         end
 
-        # エンティティ定義を追加
-        parsed_data[:entities].each do |entity|
+        parsed_data.fetch(:entities, []).sort_by { |entity| entity[:name].to_s }.each do |entity|
           output << render_entity(entity)
         end
 
-        output.join("\n")
+        output.join("\n").rstrip
       end
 
       private
 
       def render_entity(entity)
         lines = []
-        entity_name = entity[:name].upcase
+        entity_name = aliased_identifier(entity[:name], uppercase: true)
 
         lines << "    #{entity_name} {"
-        entity[:attributes].each do |attr|
+        entity.fetch(:attributes, []).sort_by { |attr| attr[:name].to_s }.each do |attr|
           type = type_to_er_type(attr[:type])
           constraints = []
-          constraints << "PK" if attr[:primary_key]
-          constraints << "FK" if attr[:foreign_key]
-          constraints << "UK" if attr[:unique]
+          constraints << 'PK' if attr[:primary_key]
+          constraints << 'FK' if attr[:foreign_key]
+          constraints << 'UK' if attr[:unique]
 
-          line = "        #{type} #{attr[:name]}"
-          line += " #{constraints.join(" ")}" if constraints.any?
+          line = "        #{safe_identifier(type)} #{safe_identifier(attr[:name])}"
+          line += " #{constraints.join(',')}" if constraints.any?
+          line += " #{mermaid_string(attr[:name])}" if safe_identifier(attr[:name]) != attr[:name].to_s
           lines << line
         end
-        lines << "    }"
-        lines << ""
+        lines << '    }'
+        lines << ''
 
         lines.join("\n")
       end
 
       def render_relationship(rel)
-        source = rel[:source].upcase
-        target = rel[:target].upcase
+        source = safe_identifier(rel[:source], uppercase: true)
+        target = safe_identifier(rel[:target], uppercase: true)
         label = rel[:label]
 
-        # カーディナリティを決定
         source_card = cardinality_symbol(rel[:source_cardinality])
         target_card = cardinality_symbol(rel[:target_cardinality])
 
-        # 関係の種類（識別 or 非識別）
-        line_type = rel[:identifying] ? "--" : ".."
+        line_type = rel[:identifying] ? '--' : '..'
 
-        "    #{source} #{source_card}#{line_type}#{target_card} #{target} : \"#{label}\""
+        "    #{source} #{source_card}#{line_type}#{target_card} #{target} : #{mermaid_string(label)}"
       end
 
       def cardinality_symbol(cardinality)
-        case cardinality
-        when "1", "one"
-          "||"
-        when "0..1", "zero_or_one"
-          "|o"
-        when "1..*", "one_or_more"
-          "}|"
-        when "*", "0..*", "zero_or_more", "many"
-          "}o"
+        case cardinality&.to_sym
+        when :one
+          '||'
+        when :zero_or_one
+          'o|'
+        when :one_or_more
+          '}|'
+        when :zero_or_many
+          'o{'
         else
-          "||" # デフォルト
+          raise ConfigurationError, "Unknown ER cardinality: #{cardinality.inspect}"
         end
       end
 
+      def relationship_sort_key(relationship)
+        %i[source target label].map { |key| relationship[key].to_s }
+      end
+
       def type_to_er_type(type)
         # Ruby/Rails型をERダイアグラム用の型に変換
         case type.to_s.downcase
         when /integer/, /bigint/
-          "int"
+          'int'
         when /string/, /varchar/
-          "string"
+          'string'
         when /text/
-          "text"
+          'text'
         when /boolean/
-          "boolean"
+          'boolean'
         when /datetime/, /timestamp/
-          "datetime"
+          'datetime'
         when /date/
-          "date"
+          'date'
         when /time/
-          "time"
+          'time'
         when /decimal/, /numeric/
-          "decimal"
+          'decimal'
         when /float/, /double/
-          "float"
+          'float'
         when /json/, /jsonb/
-          "json"
+          'json'
         else
           type.to_s.downcase
         end

data/lib/lagoon/result.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lagoon
+  Result = Data.define(:path, :content, :warnings, :counts) do
+    def initialize(path:, content:, warnings: [], counts: {})
+      super(
+        path: path.to_s.freeze,
+        content: content.to_s.freeze,
+        warnings: warnings.map(&:to_s).freeze,
+        counts: counts.transform_keys(&:to_sym).freeze
+      )
+    end
+
+    def to_s
+      path
+    end
+
+    def to_path
+      path
+    end
+  end
+end

data/lib/lagoon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lagoon
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'
 end

data/lib/lagoon.rb

@@ -1,22 +1,32 @@
 # frozen_string_literal: true
 
-require_relative "lagoon/version"
-require_relative "lagoon/configuration"
-require_relative "lagoon/diagram/base"
-require_relative "lagoon/diagram/model_diagram"
-require_relative "lagoon/diagram/controller_diagram"
-require_relative "lagoon/diagram/er_diagram"
-require_relative "lagoon/parser/model_parser"
-require_relative "lagoon/parser/controller_parser"
-require_relative "lagoon/parser/schema_parser"
-require_relative "lagoon/renderer/base_renderer"
-require_relative "lagoon/renderer/class_diagram_renderer"
-require_relative "lagoon/renderer/er_diagram_renderer"
-require_relative "lagoon/railtie" if defined?(Rails::Railtie)
+require 'logger'
+require 'active_support'
+require_relative 'lagoon/version'
+require_relative 'lagoon/errors'
+require_relative 'lagoon/result'
+require_relative 'lagoon/configuration'
+require_relative 'lagoon/options'
+require_relative 'lagoon/diagram/base'
+require_relative 'lagoon/diagram/model_diagram'
+require_relative 'lagoon/diagram/controller_diagram'
+require_relative 'lagoon/diagram/er_diagram'
+require_relative 'lagoon/diagram/controller_model_diagram'
+require_relative 'lagoon/analyzer/active_record_analyzer'
+require_relative 'lagoon/analyzer/action_controller_analyzer'
+require_relative 'lagoon/analyzer/database_schema_analyzer'
+require_relative 'lagoon/parser/application_class_filter'
+require_relative 'lagoon/parser/model_parser'
+require_relative 'lagoon/parser/controller_parser'
+require_relative 'lagoon/parser/schema_parser'
+require_relative 'lagoon/parser/controller_model_parser'
+require_relative 'lagoon/renderer/base_renderer'
+require_relative 'lagoon/renderer/class_diagram_renderer'
+require_relative 'lagoon/renderer/er_diagram_renderer'
+require_relative 'lagoon/renderer/controller_model_er_renderer'
+require_relative 'lagoon/railtie' if defined?(Rails::Railtie)
 
 module Lagoon
-  class Error < StandardError; end
-
   class << self
     attr_writer :configuration
 
@@ -28,24 +38,63 @@ module Lagoon
       yield(configuration)
     end
 
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
     def generate_model_diagram(options = {})
-      Diagram::ModelDiagram.new(options).generate
+      Diagram::ModelDiagram.new(options, configuration: configuration.dup).generate
     end
 
     def generate_controller_diagram(options = {})
-      Diagram::ControllerDiagram.new(options).generate
+      Diagram::ControllerDiagram.new(options, configuration: configuration.dup).generate
     end
 
     def generate_er_diagram(options = {})
-      Diagram::ErDiagram.new(options).generate
+      Diagram::ErDiagram.new(options, configuration: configuration.dup).generate
+    end
+
+    def generate_controller_model_diagram(options = {})
+      Diagram::ControllerModelDiagram.new(options, configuration: configuration.dup).generate
     end
 
     def generate_all(options = {})
+      raw_options = options.to_h.transform_keys(&:to_sym)
+      validate_all_options!(raw_options)
+      eager_load_application!
+      output_dir = raw_options.delete(:output)
+
       {
-        models: generate_model_diagram(options),
-        controllers: generate_controller_diagram(options),
-        er: generate_er_diagram(options)
+        models: generate_model_diagram(options_for(:model, raw_options, output_dir, 'models.mermaid')),
+        controllers: generate_controller_diagram(
+          options_for(:controller, raw_options, output_dir, 'controllers.mermaid')
+        ),
+        er: generate_er_diagram(options_for(:er, raw_options, output_dir, 'er_diagram.mermaid')),
+        controller_models: generate_controller_model_diagram(
+          options_for(:controller_model, raw_options, output_dir, 'controller_models.mermaid')
+        )
       }
     end
+
+    private
+
+    def eager_load_application!
+      Rails.application.eager_load! if defined?(Rails) && Rails.respond_to?(:application)
+    end
+
+    def validate_all_options!(options)
+      allowed = Options::KEYS.values.flatten.uniq + [:output]
+      unknown = options.keys - allowed
+      return if unknown.empty?
+
+      raise ConfigurationError, "Unknown all option(s): #{unknown.sort.join(', ')}"
+    end
+
+    def options_for(kind, options, output_dir, filename)
+      selected = options.slice(*Options.allowed_keys(kind))
+      selected[:eager_load] = false
+      selected[:output] = File.join(output_dir.to_s, filename) if output_dir
+      selected
+    end
   end
 end

data/lib/tasks/lagoon.rake

@@ -1,39 +1,47 @@
 # frozen_string_literal: true
 
 namespace :mermaid do
-  desc "Generate all Mermaid diagrams"
+  desc 'Generate all Mermaid diagrams'
   task all: :environment do
     results = Lagoon.generate_all
-    puts "All diagrams generated:"
+    puts 'All diagrams generated:'
     puts "  Models: #{results[:models]}"
     puts "  Controllers: #{results[:controllers]}"
     puts "  ER: #{results[:er]}"
+    puts "  Controller-Models: #{results[:controller_models]}"
   end
 
-  desc "Generate Mermaid model diagram"
+  desc 'Generate Mermaid model diagram'
   task models: :environment do
     output_file = Lagoon.generate_model_diagram
     puts "Model diagram generated: #{output_file}"
   end
 
-  desc "Generate Mermaid controller diagram"
+  desc 'Generate Mermaid controller diagram'
   task controllers: :environment do
     output_file = Lagoon.generate_controller_diagram
     puts "Controller diagram generated: #{output_file}"
   end
 
-  desc "Generate Mermaid ER diagram"
+  desc 'Generate Mermaid ER diagram'
   task er: :environment do
     output_file = Lagoon.generate_er_diagram
     puts "ER diagram generated: #{output_file}"
   end
 
-  desc "Generate brief diagrams (no attributes/methods)"
+  desc 'Generate controller-model relationship diagram'
+  task controller_models: :environment do
+    output_file = Lagoon.generate_controller_model_diagram
+    puts "Controller-model diagram generated: #{output_file}"
+  end
+
+  desc 'Generate brief diagrams (no attributes/methods)'
   task brief: :environment do
     results = Lagoon.generate_all(brief: true)
-    puts "Brief diagrams generated:"
+    puts 'Brief diagrams generated:'
     puts "  Models: #{results[:models]}"
     puts "  Controllers: #{results[:controllers]}"
     puts "  ER: #{results[:er]}"
+    puts "  Controller-Models: #{results[:controller_models]}"
   end
 end

data/sig/lagoon.rbs

@@ -0,0 +1,107 @@
+module Lagoon
+  VERSION: String
+
+  type option_key = Symbol | String
+  type options_hash = Hash[option_key, untyped]
+  type counts_hash = Hash[Symbol, Integer]
+
+  class Error < StandardError
+  end
+
+  class ConfigurationError < Error
+  end
+
+  class RailsLoadError < Error
+  end
+
+  class ParseError < Error
+  end
+
+  class OutputError < Error
+  end
+
+  class Configuration
+    DIRECTIONS: Array[String]
+
+    attr_accessor show_attributes: bool
+    attr_accessor show_methods: bool
+    attr_accessor include_inheritance: bool
+    attr_accessor exclude_models: Array[String]
+    attr_accessor exclude_controllers: Array[String]
+    attr_accessor exclude_tables: Array[String]
+    attr_accessor internal_tables: Array[String]
+    attr_accessor include_framework_bases: bool
+    attr_accessor strict: bool
+    attr_accessor helper_models: Hash[String, String]
+    attr_reader output_dir: String
+    attr_reader diagram_direction: String
+
+    def initialize: () -> void
+    def output_dir=: (String value) -> String
+    def diagram_direction=: (String value) -> String
+    def self.validate_direction!: (String | Symbol value) -> String
+    def initialize_copy: (Configuration original) -> void
+  end
+
+  class Options
+    include Enumerable[[Symbol, untyped]]
+
+    COMMON_KEYS: Array[Symbol]
+    KEYS: Hash[Symbol, Array[Symbol]]
+
+    attr_reader kind: Symbol
+
+    def self.for: (Symbol kind, ?options_hash? raw_options, ?config: Configuration, **untyped keyword_options) -> Options
+    def self.allowed_keys: (Symbol kind) -> Array[Symbol]
+    def initialize: (Symbol kind, ?options_hash raw_options, ?config: Configuration) -> void
+    def []: (option_key key) -> untyped
+    def fetch: (option_key key, *untyped defaults) { (Symbol) -> untyped } -> untyped
+             | (option_key key, *untyped defaults) -> untyped
+    def key?: (option_key key) -> bool
+    def each: () { ([Symbol, untyped]) -> void } -> Options
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+
+  class Result
+    attr_reader path: String
+    attr_reader content: String
+    attr_reader warnings: Array[String]
+    attr_reader counts: counts_hash
+
+    def initialize: (path: String, content: String, ?warnings: Array[String], ?counts: counts_hash) -> void
+    def to_s: () -> String
+    def to_path: () -> String
+  end
+
+  def self.configuration: () -> Configuration
+  def self.configuration=: (Configuration configuration) -> Configuration
+  def self.configure: () { (Configuration) -> untyped } -> untyped
+  def self.reset_configuration!: () -> Configuration
+  def self.generate_model_diagram: (?options_hash options) -> Result
+  def self.generate_controller_diagram: (?options_hash options) -> Result
+  def self.generate_er_diagram: (?options_hash options) -> Result
+  def self.generate_controller_model_diagram: (?options_hash options) -> Result
+  def self.generate_all: (?options_hash options) -> Hash[Symbol, Result]
+
+  module Diagram
+    class Base
+      attr_reader options: Options
+      attr_reader config: Configuration
+
+      def initialize: (?options_hash? options, ?configuration: Configuration, **untyped keyword_options) -> void
+      def generate: () -> Result
+    end
+
+    class ModelDiagram < Base
+    end
+
+    class ControllerDiagram < Base
+    end
+
+    class ErDiagram < Base
+    end
+
+    class ControllerModelDiagram < Base
+    end
+  end
+end