lagoon 0.1.0 → 0.2.0

data/lib/lagoon/parser/model_parser.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string"
+require 'logger'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
 
 module Lagoon
   module Parser
@@ -8,8 +10,9 @@ module Lagoon
       attr_reader :options, :config
 
       def initialize(options = {})
-        @options = options
-        @config = Lagoon.configuration
+        @options = options.is_a?(Options) ? options : Options.for(:model, options)
+        @analyzer = Lagoon::Analyzer::ActiveRecordAnalyzer.new
+        @filter = ApplicationClassFilter.new(directory: 'models', include_all: @options[:all_models])
       end
 
       def parse
@@ -17,144 +20,86 @@ module Lagoon
         classes = []
         relationships = []
 
-        models.each do |model|
+        warnings = []
+
+        models.sort_by { |model| model.name.to_s }.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
+          analyze_model(model, classes, relationships)
+        rescue StandardError => e
+          raise if options[:strict]
+
+          warnings << "Failed to analyze model #{model.name || '(anonymous)'}: #{e.message}"
         end
 
+        normalized_relationships = deduplicate_relationships(relationships)
         {
-          classes: classes,
-          relationships: relationships
+          classes: classes.sort_by { |model| model[:name] },
+          relationships: normalized_relationships,
+          warnings: warnings,
+          counts: { classes: classes.size, relationships: normalized_relationships.size, skipped: warnings.size }
         }
       end
 
       private
 
       def load_models
-        # Railsアプリケーションの全モデルをロード
-        return [] unless defined?(Rails)
+        return [] unless defined?(ActiveRecord::Base)
 
-        Rails.application.eager_load!
-        ActiveRecord::Base.descendants.reject(&:abstract_class?)
+        Rails.application.eager_load! if options[:eager_load] && defined?(Rails)
+        ActiveRecord::Base.descendants
       end
 
       def excluded?(model)
         model_name = model.name
-        config.exclude_models.include?(model_name)
+        return true unless model_name
+        return true unless @filter.include?(model)
+        return true if options[:exclude].include?(model_name)
+        return !options[:specify].include?(model_name) if options[:specify].any?
+
+        false
       end
 
-      def parse_model(model)
+      def analysis_options
         {
-          name: model.name,
-          abstract: model.abstract_class?,
-          attributes: config.show_attributes ? extract_columns(model) : [],
-          methods: config.show_methods ? extract_methods(model) : []
+          show_attributes: options[:show_attributes],
+          show_methods: options[:show_methods],
+          all_columns: options[:all_columns],
+          hide_magic: options[:hide_magic],
+          hide_through: options[:hide_through],
+          show_belongs_to: options[:show_belongs_to],
+          duplicate_sti_attributes: options[:duplicate_sti_attributes]
         }
       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)
+      def analyze_model(model, classes, relationships)
+        classes << @analyzer.analyze_model(model, analysis_options)
+        relationships.concat(@analyzer.extract_associations(model, analysis_options))
+        return unless options[:include_inheritance]
+
+        relationships.concat(
+          @analyzer.extract_inheritance_with_options(
+            model,
+            include_framework_base: options[:include_framework_bases]
+          )
+        )
       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)
+      def deduplicate_relationships(relationships)
+        grouped = relationships.group_by { |relationship| relationship_key(relationship) }
+        deduplicated = grouped.values.map do |duplicates|
+          duplicates.min_by { |relationship| relationship[:macro] == :belongs_to ? 1 : 0 }
         end
 
-        associations.compact
+        deduplicated.sort_by { |relationship| relationship_key(relationship) }
       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: "*"
-          }
+      def relationship_key(relationship)
+        if relationship[:type] == :association && !relationship[:polymorphic]
+          [relationship[:type].to_s, *[relationship[:source], relationship[:target]].sort]
+        else
+          [relationship[:type].to_s, relationship[:source].to_s, relationship[:target].to_s]
         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

data/lib/lagoon/parser/schema_parser.rb

@@ -1,113 +1,166 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string"
-
 module Lagoon
   module Parser
     class SchemaParser
-      attr_reader :options, :config
+      ConnectionEntry = Data.define(:name, :connection)
+      TableMetadata = Data.define(:name, :raw_name, :prefix, :columns, :primary_keys, :foreign_keys, :indexes)
+
+      attr_reader :options
 
       def initialize(options = {})
-        @options = options
-        @config = Lagoon.configuration
+        @options = options.is_a?(Options) ? options : Options.for(:er, options)
+        @analyzer = Lagoon::Analyzer::DatabaseSchemaAnalyzer.new
       end
 
       def parse
-        tables = load_schema
         entities = []
         relationships = []
+        warnings = []
+
+        load_schema(warnings).each do |table|
+          next if excluded?(table)
 
-        tables.each do |table_name, columns|
-          next if excluded?(table_name)
+          analyze_table(table, entities, relationships)
+        rescue StandardError => e
+          raise if options[:strict]
 
-          entity = parse_table(table_name, columns)
-          entities << entity
-          relationships.concat(extract_foreign_keys(table_name, columns))
+          warnings << "Failed to analyze table #{table.name}: #{e.message}"
         end
 
         {
-          entities: entities,
-          relationships: relationships
+          entities: entities.sort_by { |entity| entity[:name] },
+          relationships: relationships.sort_by { |relationship| [relationship[:source], relationship[:target]] },
+          warnings: warnings,
+          counts: { entities: entities.size, relationships: relationships.size, skipped: warnings.size }
         }
       end
 
       private
 
-      def load_schema
-        return {} unless defined?(ActiveRecord)
+      def load_schema(warnings)
+        entries = connection_entries
+        multiple_connections = entries.size > 1
 
-        connection = ActiveRecord::Base.connection
-        tables_hash = {}
+        entries.flat_map do |entry|
+          load_connection_schema(entry, multiple_connections, warnings)
+        end
+      end
 
-        connection.tables.each do |table_name|
-          next if internal_table?(table_name)
+      def connection_entries
+        configured = options[:connections]
+        return normalize_configured_connections(configured) if configured
+        return [] unless defined?(ActiveRecord::Base)
 
-          columns = connection.columns(table_name)
-          tables_hash[table_name] = columns
+        pools = all_connection_pools
+        connections = pools.filter_map do |pool|
+          ConnectionEntry.new(name: connection_name(pool), connection: pool.connection)
+        rescue ActiveRecord::ConnectionNotEstablished
+          nil
         end
+        base = ConnectionEntry.new(name: 'primary', connection: ActiveRecord::Base.connection)
+        connections.unshift(base)
+        connections.uniq { |entry| entry.connection.object_id }
+      rescue NoMethodError
+        [ConnectionEntry.new(name: 'primary', connection: ActiveRecord::Base.connection)]
+      end
 
-        tables_hash
+      def all_connection_pools
+        handler = ActiveRecord::Base.connection_handler
+        return handler.all_connection_pools if handler.respond_to?(:all_connection_pools)
+
+        handler.connection_pool_list
       end
 
-      def internal_table?(table_name)
-        # Railsの内部テーブルをスキップ
-        %w[schema_migrations ar_internal_metadata].include?(table_name)
+      def normalize_configured_connections(configured)
+        pairs = configured.respond_to?(:to_h) ? configured.to_h : Array(configured).to_h
+        pairs.map { |name, connection| ConnectionEntry.new(name: name.to_s, connection: connection) }
+      rescue TypeError
+        Array(configured).each_with_index.map do |connection, index|
+          ConnectionEntry.new(name: "database_#{index + 1}", connection: connection)
+        end
+      end
+
+      def load_connection_schema(entry, multiple_connections, warnings)
+        connection = entry.connection
+        prefix = multiple_connections ? entry.name : nil
+
+        connection.tables.sort.filter_map do |table_name|
+          next if @analyzer.internal_table?(table_name, internal_tables: options[:internal_tables])
+
+          load_table_metadata(connection, table_name, prefix)
+        rescue StandardError => e
+          raise if options[:strict]
+
+          warnings << "Failed to inspect table #{qualify(table_name, prefix)}: #{e.message}"
+          nil
+        end
       end
 
-      def excluded?(_table_name)
-        false # 必要に応じて除外ロジックを追加
+      def load_table_metadata(connection, table_name, prefix)
+        TableMetadata.new(
+          name: qualify(table_name, prefix),
+          raw_name: table_name,
+          prefix: prefix,
+          columns: cached_columns(connection, table_name),
+          primary_keys: primary_keys(connection, table_name),
+          foreign_keys: connection.foreign_keys(table_name),
+          indexes: connection.indexes(table_name)
+        )
       end
 
-      def parse_table(table_name, columns)
-        {
-          name: table_name,
-          attributes: columns.map { |col| parse_column(col) }
-        }
+      def cached_columns(connection, table_name)
+        cache = connection.schema_cache
+        cache.columns(table_name)
+      rescue ArgumentError
+        cache.columns(connection.pool, table_name)
+      rescue NoMethodError
+        connection.columns(table_name)
       end
 
-      def parse_column(column)
-        {
-          name: column.name,
-          type: column.type,
-          primary_key: column.name == "id",
-          foreign_key: foreign_key?(column.name),
-          unique: false # 必要に応じて実装
-        }
+      def primary_keys(connection, table_name)
+        return Array(connection.primary_keys(table_name)) if connection.respond_to?(:primary_keys)
+
+        Array(connection.primary_key(table_name))
       end
 
-      def foreign_key?(column_name)
-        column_name.end_with?("_id")
+      def analyze_table(table, entities, relationships)
+        entities << @analyzer.analyze_table(
+          table.name,
+          table.columns,
+          primary_keys: table.primary_keys,
+          foreign_keys: table.foreign_keys,
+          indexes: table.indexes
+        )
+        relationships.concat(
+          @analyzer.extract_foreign_keys(
+            table.name,
+            table.columns,
+            foreign_keys: table.foreign_keys,
+            indexes: table.indexes,
+            primary_keys: table.primary_keys,
+            table_prefix: table.prefix
+          )
+        )
       end
 
-      def extract_foreign_keys(table_name, columns)
-        relationships = []
+      def excluded?(table)
+        return true if options[:exclude].include?(table.name) || options[:exclude].include?(table.raw_name)
+        return false if options[:specify].empty?
 
-        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
+        !options[:specify].include?(table.name) && !options[:specify].include?(table.raw_name)
+      end
 
-        relationships
+      def qualify(table_name, prefix)
+        prefix ? "#{prefix}.#{table_name}" : table_name.to_s
       end
 
-      def infer_target_table(foreign_key_name)
-        # user_id -> users のように推測
-        base_name = foreign_key_name.sub(/_id$/, "")
-        base_name.pluralize
-      rescue StandardError
-        nil
+      def connection_name(pool)
+        config = pool.respond_to?(:db_config) ? pool.db_config : nil
+        parts = [config&.name]
+        parts << pool.role if pool.respond_to?(:role)
+        parts << pool.shard if pool.respond_to?(:shard)
+        parts.compact.map(&:to_s).reject(&:empty?).join('_').then { |name| name.empty? ? 'database' : name }
       end
     end
   end

data/lib/lagoon/railtie.rb

@@ -5,7 +5,7 @@ module Lagoon
     railtie_name :lagoon
 
     rake_tasks do
-      load "tasks/lagoon.rake"
+      load 'tasks/lagoon.rake'
     end
   end
 end

data/lib/lagoon/renderer/base_renderer.rb

@@ -1,42 +1,72 @@
 # frozen_string_literal: true
 
+require 'digest'
+require 'json'
+
 module Lagoon
   module Renderer
     class BaseRenderer
       attr_reader :direction
 
-      def initialize(direction: "TB")
-        @direction = direction
+      def initialize(direction: 'TB', **_options)
+        @direction = Configuration.validate_direction!(direction)
       end
 
       def render(parsed_data)
-        raise NotImplementedError, "Subclasses must implement #render"
+        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
+        safe_identifier(name)
+      end
+
+      def safe_identifier(value, uppercase: false)
+        original = value.to_s
+        identifier = original.gsub(/[^a-zA-Z0-9_]/, '_').gsub(/_+/, '_')
+        identifier = "_#{identifier}" unless identifier.match?(/\A[a-zA-Z_]/)
+        identifier = "entity_#{Digest::SHA256.hexdigest(original)[0, 12]}" if identifier.empty? || identifier == '_'
+        uppercase ? identifier.upcase : identifier
+      end
+
+      def aliased_identifier(value, uppercase: false)
+        identifier = safe_identifier(value, uppercase: uppercase)
+        display = uppercase ? value.to_s.upcase : value.to_s
+        return identifier if identifier == display
+
+        "#{identifier}[#{mermaid_string(display)}]"
+      end
+
+      def mermaid_string(value)
+        JSON.generate(value.to_s.gsub(/[\r\n]+/, ' '))
+      end
+
+      def escape_member(value)
+        value.to_s.gsub(/[\r\n]+/, ' ')
+             .gsub('&', '&')
+             .gsub('"', '"')
+             .gsub('{', '{')
+             .gsub('}', '}')
+      end
+
+      def escape_label(value)
+        escape_member(value).gsub(':', ':')
       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"
+        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