lagoon 0.1.0

data/lib/lagoon/parser/model_parser.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string"
+
+module Lagoon
+  module Parser
+    class ModelParser
+      attr_reader :options, :config
+
+      def initialize(options = {})
+        @options = options
+        @config = Lagoon.configuration
+      end
+
+      def parse
+        models = load_models
+        classes = []
+        relationships = []
+
+        models.each do |model|
+          next if excluded?(model)
+
+          classes << parse_model(model)
+          relationships.concat(extract_associations(model))
+          relationships.concat(extract_inheritance(model)) if config.include_inheritance
+        end
+
+        {
+          classes: classes,
+          relationships: relationships
+        }
+      end
+
+      private
+
+      def load_models
+        # Railsアプリケーションの全モデルをロード
+        return [] unless defined?(Rails)
+
+        Rails.application.eager_load!
+        ActiveRecord::Base.descendants.reject(&:abstract_class?)
+      end
+
+      def excluded?(model)
+        model_name = model.name
+        config.exclude_models.include?(model_name)
+      end
+
+      def parse_model(model)
+        {
+          name: model.name,
+          abstract: model.abstract_class?,
+          attributes: config.show_attributes ? extract_columns(model) : [],
+          methods: config.show_methods ? extract_methods(model) : []
+        }
+      end
+
+      def extract_columns(model)
+        return [] unless model.table_exists?
+
+        columns = if options[:all_columns]
+                    model.columns
+                  else
+                    model.columns.reject { |col| magic_field?(col.name) }
+                  end
+
+        columns.map do |column|
+          {
+            name: column.name,
+            type: column.type,
+            visibility: "+"
+          }
+        end
+      end
+
+      def magic_field?(field_name)
+        # マジックフィールド（created_at, updated_at等）を判定
+        return false if options[:all_columns]
+
+        %w[id created_at updated_at].include?(field_name)
+      end
+
+      def extract_methods(_model)
+        # publicメソッドを抽出（必要に応じて実装）
+        []
+      end
+
+      def extract_associations(model)
+        associations = []
+
+        model.reflect_on_all_associations.each do |assoc|
+          next if assoc.options[:through] && options[:hide_through]
+
+          associations << build_association(model, assoc)
+        end
+
+        associations.compact
+      end
+
+      def build_association(model, assoc)
+        case assoc.macro
+        when :belongs_to
+          return nil unless options[:show_belongs_to]
+
+          {
+            source: model.name,
+            target: assoc.class_name,
+            type: :association,
+            label: "belongs_to #{assoc.name}",
+            source_cardinality: "1",
+            target_cardinality: "0..1"
+          }
+        when :has_one
+          {
+            source: model.name,
+            target: assoc.class_name,
+            type: :association,
+            label: "has_one #{assoc.name}",
+            source_cardinality: "1",
+            target_cardinality: "0..1"
+          }
+        when :has_many
+          {
+            source: model.name,
+            target: assoc.class_name,
+            type: :association,
+            label: "has_many #{assoc.name}",
+            source_cardinality: "1",
+            target_cardinality: "*"
+          }
+        when :has_and_belongs_to_many
+          {
+            source: model.name,
+            target: assoc.class_name,
+            type: :association,
+            label: "has_and_belongs_to_many #{assoc.name}",
+            source_cardinality: "*",
+            target_cardinality: "*"
+          }
+        end
+      rescue NameError
+        # アソシエーション先のクラスが見つからない場合はスキップ
+        nil
+      end
+
+      def extract_inheritance(model)
+        return [] if model.superclass == ActiveRecord::Base
+        return [] if model.superclass.abstract_class?
+
+        [{
+          source: model.superclass.name,
+          target: model.name,
+          type: :inheritance,
+          label: nil
+        }]
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/lagoon/parser/schema_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string"
+
+module Lagoon
+  module Parser
+    class SchemaParser
+      attr_reader :options, :config
+
+      def initialize(options = {})
+        @options = options
+        @config = Lagoon.configuration
+      end
+
+      def parse
+        tables = load_schema
+        entities = []
+        relationships = []
+
+        tables.each do |table_name, columns|
+          next if excluded?(table_name)
+
+          entity = parse_table(table_name, columns)
+          entities << entity
+          relationships.concat(extract_foreign_keys(table_name, columns))
+        end
+
+        {
+          entities: entities,
+          relationships: relationships
+        }
+      end
+
+      private
+
+      def load_schema
+        return {} unless defined?(ActiveRecord)
+
+        connection = ActiveRecord::Base.connection
+        tables_hash = {}
+
+        connection.tables.each do |table_name|
+          next if internal_table?(table_name)
+
+          columns = connection.columns(table_name)
+          tables_hash[table_name] = columns
+        end
+
+        tables_hash
+      end
+
+      def internal_table?(table_name)
+        # Railsの内部テーブルをスキップ
+        %w[schema_migrations ar_internal_metadata].include?(table_name)
+      end
+
+      def excluded?(_table_name)
+        false # 必要に応じて除外ロジックを追加
+      end
+
+      def parse_table(table_name, columns)
+        {
+          name: table_name,
+          attributes: columns.map { |col| parse_column(col) }
+        }
+      end
+
+      def parse_column(column)
+        {
+          name: column.name,
+          type: column.type,
+          primary_key: column.name == "id",
+          foreign_key: foreign_key?(column.name),
+          unique: false # 必要に応じて実装
+        }
+      end
+
+      def foreign_key?(column_name)
+        column_name.end_with?("_id")
+      end
+
+      def extract_foreign_keys(table_name, columns)
+        relationships = []
+
+        columns.each do |column|
+          next unless foreign_key?(column.name)
+
+          # column_nameから参照先テーブルを推測 (例: user_id -> users)
+          target_table = infer_target_table(column.name)
+          next unless target_table
+
+          relationships << {
+            source: table_name,
+            target: target_table,
+            label: "has many",
+            source_cardinality: "||",
+            target_cardinality: "}o",
+            identifying: true
+          }
+        end
+
+        relationships
+      end
+
+      def infer_target_table(foreign_key_name)
+        # user_id -> users のように推測
+        base_name = foreign_key_name.sub(/_id$/, "")
+        base_name.pluralize
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/lagoon/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lagoon
+  class Railtie < Rails::Railtie
+    railtie_name :lagoon
+
+    rake_tasks do
+      load "tasks/lagoon.rake"
+    end
+  end
+end

data/lib/lagoon/renderer/base_renderer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Renderer
+    class BaseRenderer
+      attr_reader :direction
+
+      def initialize(direction: "TB")
+        @direction = direction
+      end
+
+      def render(parsed_data)
+        raise NotImplementedError, "Subclasses must implement #render"
+      end
+
+      protected
+
+      def escape_class_name(name)
+        # Mermaidで特殊文字を含むクラス名をエスケープ
+        if name.match?(/[^a-zA-Z0-9_]/)
+          "`#{name}`"
+        else
+          name
+        end
+      end
+
+      def type_to_mermaid(type)
+        # Ruby/Rails型をMermaid表記に変換
+        case type.to_s
+        when /integer/i then "Integer"
+        when /string/i then "String"
+        when /text/i then "Text"
+        when /boolean/i then "Boolean"
+        when /datetime/i then "DateTime"
+        when /date/i then "Date"
+        when /time/i then "Time"
+        when /decimal/i then "Decimal"
+        when /float/i then "Float"
+        when /json/i then "JSON"
+        else type.to_s.capitalize
+        end
+      end
+    end
+  end
+end

data/lib/lagoon/renderer/class_diagram_renderer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Renderer
+    class ClassDiagramRenderer < BaseRenderer
+      def render(parsed_data)
+        output = ["classDiagram"]
+        output << "    direction #{@direction}"
+        output << ""
+
+        # クラス定義を追加
+        parsed_data[:classes].each do |klass|
+          output << render_class(klass)
+        end
+
+        output << ""
+
+        # 関係性を追加
+        parsed_data[:relationships].each do |rel|
+          output << render_relationship(rel)
+        end
+
+        output.join("\n")
+      end
+
+      private
+
+      def render_class(klass)
+        lines = []
+        class_name = escape_class_name(klass[:name])
+
+        lines << "    class #{class_name} {"
+        lines << "        <<abstract>>" if klass[:abstract]
+
+        # 属性を追加
+        if klass[:attributes]&.any?
+          klass[:attributes].each do |attr|
+            visibility = attr[:visibility] || "+"
+            type = type_to_mermaid(attr[:type])
+            lines << "        #{visibility}#{type} #{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}"
+          end
+        end
+
+        lines << "    }"
+        lines << ""
+        lines.join("\n")
+      end
+
+      def render_relationship(rel)
+        source = escape_class_name(rel[:source])
+        target = escape_class_name(rel[:target])
+        type = rel[:type]
+        label = rel[:label]
+        source_cardinality = rel[:source_cardinality]
+        target_cardinality = rel[:target_cardinality]
+
+        arrow = case type
+                when :inheritance
+                  "<|--"
+                when :composition
+                  "*--"
+                when :aggregation
+                  "o--"
+                when :association
+                  "-->"
+                when :dependency
+                  "..>"
+                else
+                  "--"
+                end
+
+        line = "    #{source}"
+        line += " \"#{source_cardinality}\"" if source_cardinality
+        line += " #{arrow} "
+        line += "\"#{target_cardinality}\" " if target_cardinality
+        line += target
+        line += " : #{label}" if label
+        line
+      end
+    end
+  end
+end

data/lib/lagoon/renderer/er_diagram_renderer.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Lagoon
+  module Renderer
+    class ErDiagramRenderer < BaseRenderer
+      def render(parsed_data)
+        output = ["erDiagram"]
+
+        # リレーションシップを先に追加
+        if parsed_data[:relationships]&.any?
+          parsed_data[:relationships].each do |rel|
+            output << render_relationship(rel)
+          end
+          output << ""
+        end
+
+        # エンティティ定義を追加
+        parsed_data[:entities].each do |entity|
+          output << render_entity(entity)
+        end
+
+        output.join("\n")
+      end
+
+      private
+
+      def render_entity(entity)
+        lines = []
+        entity_name = entity[:name].upcase
+
+        lines << "    #{entity_name} {"
+        entity[:attributes].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]
+
+          line = "        #{type} #{attr[:name]}"
+          line += " #{constraints.join(" ")}" if constraints.any?
+          lines << line
+        end
+        lines << "    }"
+        lines << ""
+
+        lines.join("\n")
+      end
+
+      def render_relationship(rel)
+        source = rel[:source].upcase
+        target = rel[:target].upcase
+        label = rel[:label]
+
+        # カーディナリティを決定
+        source_card = cardinality_symbol(rel[:source_cardinality])
+        target_card = cardinality_symbol(rel[:target_cardinality])
+
+        # 関係の種類（識別 or 非識別）
+        line_type = rel[:identifying] ? "--" : ".."
+
+        "    #{source} #{source_card}#{line_type}#{target_card} #{target} : \"#{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"
+        else
+          "||" # デフォルト
+        end
+      end
+
+      def type_to_er_type(type)
+        # Ruby/Rails型をERダイアグラム用の型に変換
+        case type.to_s.downcase
+        when /integer/, /bigint/
+          "int"
+        when /string/, /varchar/
+          "string"
+        when /text/
+          "text"
+        when /boolean/
+          "boolean"
+        when /datetime/, /timestamp/
+          "datetime"
+        when /date/
+          "date"
+        when /time/
+          "time"
+        when /decimal/, /numeric/
+          "decimal"
+        when /float/, /double/
+          "float"
+        when /json/, /jsonb/
+          "json"
+        else
+          type.to_s.downcase
+        end
+      end
+    end
+  end
+end

data/lib/lagoon/version.rb

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

data/lib/lagoon.rb

@@ -0,0 +1,51 @@
+# 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)
+
+module Lagoon
+  class Error < StandardError; end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def generate_model_diagram(options = {})
+      Diagram::ModelDiagram.new(options).generate
+    end
+
+    def generate_controller_diagram(options = {})
+      Diagram::ControllerDiagram.new(options).generate
+    end
+
+    def generate_er_diagram(options = {})
+      Diagram::ErDiagram.new(options).generate
+    end
+
+    def generate_all(options = {})
+      {
+        models: generate_model_diagram(options),
+        controllers: generate_controller_diagram(options),
+        er: generate_er_diagram(options)
+      }
+    end
+  end
+end

data/lib/tasks/lagoon.rake

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+namespace :mermaid do
+  desc "Generate all Mermaid diagrams"
+  task all: :environment do
+    results = Lagoon.generate_all
+    puts "All diagrams generated:"
+    puts "  Models: #{results[:models]}"
+    puts "  Controllers: #{results[:controllers]}"
+    puts "  ER: #{results[:er]}"
+  end
+
+  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"
+  task controllers: :environment do
+    output_file = Lagoon.generate_controller_diagram
+    puts "Controller diagram generated: #{output_file}"
+  end
+
+  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)"
+  task brief: :environment do
+    results = Lagoon.generate_all(brief: true)
+    puts "Brief diagrams generated:"
+    puts "  Models: #{results[:models]}"
+    puts "  Controllers: #{results[:controllers]}"
+    puts "  ER: #{results[:er]}"
+  end
+end