lutaml 0.10.4 → 0.10.6

data/lib/lutaml/uml_repository/exporters/markdown/class_page_builder.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    module Exporters
+      module Markdown
+        class ClassPageBuilder
+          include Formatting
+
+          def initialize(repository, link_resolver)
+            @repository = repository
+            @link_resolver = link_resolver
+          end
+
+          def build(klass, qname)
+            type = klass.class.name.split("::").last
+            pkg_path = @link_resolver.extract_package_path(qname)
+
+            <<~MARKDOWN
+              # #{type}: #{klass.name}
+
+              **Qualified Name**: `#{qname}`
+
+              **Package**: [#{pkg_path}](#{@link_resolver.package_link(pkg_path)})
+
+              #{build_stereotypes_section(klass)}
+
+              #{build_definition_section(klass)}
+
+              #{build_inheritance_section(klass)}
+
+              #{build_attributes_section(klass)}
+
+              #{build_operations_section(klass)}
+
+              #{build_associations_section(klass)}
+
+              #{build_enum_literals_section(klass)}
+
+              ---
+
+              [Back to Package](#{@link_resolver.package_link(pkg_path)}) | [Back to Index](../index.md)
+            MARKDOWN
+          end
+
+          private
+
+          def build_stereotypes_section(klass)
+            stereotypes_array = normalize_stereotypes(klass.stereotype)
+            return "" if stereotypes_array.empty?
+
+            "**Stereotypes**: #{stereotypes_array.map do |s|
+              "`#{s}`"
+            end.join(', ')}\n\n"
+          end
+
+          def build_definition_section(klass)
+            return "" unless klass.respond_to?(:definition) && klass.definition
+
+            "## Description\n\n#{klass.definition}\n\n"
+          end
+
+          def build_inheritance_section(klass)
+            parent = @repository.supertype_of(klass)
+            children = @repository.subtypes_of(klass)
+
+            return "" if parent.nil? && children.empty?
+
+            content = "## Inheritance\n\n"
+
+            if parent
+              parent_qname = @link_resolver.qualified_name(parent)
+              content += "**Extends**: [#{parent.name}](#{@link_resolver.class_link(parent_qname)})\n\n"
+            end
+
+            if children.any?
+              content += "**Extended by**:\n\n"
+              children.each do |child|
+                child_qname = @link_resolver.qualified_name(child)
+                content += "- [#{child.name}](#{@link_resolver.class_link(child_qname)})\n"
+              end
+              content += "\n"
+            end
+
+            content
+          rescue StandardError
+            ""
+          end
+
+          def build_attributes_section(klass)
+            return "" unless klass.attributes&.any?
+
+            content = "## Attributes\n\n"
+            content += "| Name | Type | Visibility | Cardinality |\n"
+            content += "|------|------|------------|-------------|\n"
+
+            klass.attributes.each do |attr|
+              visibility = attr.visibility || ""
+              cardinality = format_cardinality(attr.cardinality)
+              content += "| #{attr.name} | `#{attr.type}` | #{visibility} | " \
+                         "#{cardinality} |\n"
+            end
+
+            "#{content}\n"
+          end
+
+          def build_operations_section(klass)
+            return "" unless klass.respond_to?(:operations) && klass.operations&.any?
+
+            content = "## Operations\n\n"
+            content += "| Name | Return Type | Visibility |\n"
+            content += "|------|-------------|------------|\n"
+
+            klass.operations.each do |op|
+              visibility = op.visibility || ""
+              return_type = op.return_type || "void"
+              content += "| #{op.name} | `#{return_type}` | #{visibility} |\n"
+            end
+
+            "#{content}\n"
+          end
+
+          def build_associations_section(klass)
+            associations = @repository.associations_of(klass)
+            return "" if associations.empty?
+
+            content = "## Associations\n\n"
+            content += "| Name | Target Class | Cardinality | Navigable |\n"
+            content += "|------|--------------|-------------|-----------|\n"
+
+            associations.each do |assoc|
+              content += format_association_row(assoc, klass)
+            end
+
+            "#{content}\n"
+          rescue StandardError
+            ""
+          end
+
+          def format_association_row(association, klass)
+            source_end = association.member_end&.first
+            target_end = association.member_end&.last
+
+            end_obj = if source_end&.type&.xmi_id == klass.xmi_id
+                        target_end
+                      else
+                        source_end
+                      end
+
+            return "" unless end_obj&.type
+
+            target_qname = @link_resolver.qualified_name(end_obj.type)
+            name = association.name || end_obj.name || ""
+            cardinality = format_cardinality(end_obj.cardinality)
+            navigable = end_obj.navigable? ? "Yes" : "No"
+
+            "| #{name} | [#{end_obj.type.name}](#{@link_resolver.class_link(target_qname)}) | " \
+              "#{cardinality} | #{navigable} |\n"
+          end
+
+          def build_enum_literals_section(klass)
+            unless klass.is_a?(Lutaml::Uml::Enum) && klass.owned_literal&.any?
+              return ""
+            end
+
+            content = "## Literals\n\n"
+            klass.owned_literal.each do |literal|
+              content += "- `#{literal.name}`"
+              content += ": #{literal.definition}" if literal.definition
+              content += "\n"
+            end
+
+            "#{content}\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml_repository/exporters/markdown/formatting.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../../uml/model_helpers"
+
+module Lutaml
+  module UmlRepository
+    module Exporters
+      module Markdown
+        module Formatting
+          include Lutaml::Uml::ModelHelpers
+
+          def format_cardinality(cardinality)
+            return "" unless cardinality
+
+            min = cardinality.min || "0"
+            max = cardinality.max || "*"
+            "#{min}..#{max}"
+          end
+
+          def format_stereotypes(stereotype)
+            return "" unless stereotype
+
+            case stereotype
+            when Array
+              stereotype.join(", ")
+            when String
+              stereotype
+            else
+              ""
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml_repository/exporters/markdown/index_page_builder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    module Exporters
+      module Markdown
+        class IndexPageBuilder
+          def initialize(repository, options, link_resolver)
+            @repository = repository
+            @options = options
+            @link_resolver = link_resolver
+          end
+
+          def build
+            title = @options.fetch(:title, "UML Model Documentation")
+            stats = @repository.statistics
+
+            <<~MARKDOWN
+              # #{title}
+
+              ## Overview
+
+              This documentation provides comprehensive information about the UML model.
+
+              ## Statistics
+
+              - **Total Packages**: #{stats&.dig(:total_packages) || 0}
+              - **Total Classes**: #{stats&.dig(:total_classes) || 0}
+              - **Total Associations**: #{stats&.dig(:total_associations) || 0}
+              - **Total Diagrams**: #{stats&.dig(:total_diagrams) || 0}
+
+              ## Package Structure
+
+              #{build_package_tree_markdown}
+
+              ## Navigation
+
+              - [Packages](packages/)
+              - [Classes](classes/)
+            MARKDOWN
+          end
+
+          private
+
+          def build_package_tree_markdown
+            root_path = @options[:package] || "ModelRoot"
+            tree = @repository.package_tree(root_path)
+            return "No packages found." unless tree
+
+            build_tree_node(tree, 0)
+          end
+
+          def build_tree_node(node, depth)
+            indent = "  " * depth
+            path = node[:path]
+            link = @link_resolver.package_link(path)
+            result = "#{indent}- [#{node[:name]}](#{link})"
+            result += " (#{node[:classes_count]} classes)" if node[:classes_count].positive?
+            result += "\n"
+
+            if node[:children]&.any?
+              node[:children].each do |child|
+                result += build_tree_node(child, depth + 1)
+              end
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml_repository/exporters/markdown/link_resolver.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    module Exporters
+      module Markdown
+        class LinkResolver
+          def initialize(indexes)
+            @indexes = indexes
+          end
+
+          def package_link(path)
+            "../packages/#{sanitize_filename(path)}.md"
+          end
+
+          def class_link(qname)
+            "../classes/#{sanitize_filename(qname)}.md"
+          end
+
+          def package_path(package)
+            @indexes&.dig(:package_to_path, package.xmi_id) || package.name
+          end
+
+          def qualified_name(klass)
+            @indexes&.dig(:class_to_qname, klass.xmi_id) || klass.name
+          end
+
+          def extract_package_path(qname)
+            parts = qname.split("::")
+            parts.size > 1 ? parts[0..-2].join("::") : "ModelRoot"
+          end
+
+          def sanitize_filename(name)
+            name.gsub("::", "_").gsub(/[^a-zA-Z0-9_\-.]/, "_")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml_repository/exporters/markdown/package_page_builder.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    module Exporters
+      module Markdown
+        class PackagePageBuilder
+          include Formatting
+
+          def initialize(repository, link_resolver)
+            @repository = repository
+            @link_resolver = link_resolver
+          end
+
+          def build(package, path)
+            classes = @repository.classes_in_package(path, recursive: false)
+            sub_packages = package.packages || []
+
+            <<~MARKDOWN
+              # Package: #{package.name}
+
+              **Qualified Path**: `#{path}`
+
+              ## Description
+
+              #{package.definition || 'No description available.'}
+
+              ## Statistics
+
+              - **Direct Classes**: #{classes.size}
+              - **Sub-packages**: #{sub_packages.size}
+
+              #{build_sub_packages_section(sub_packages)}
+
+              #{build_classes_section(classes)}
+
+              #{build_diagrams_section(path)}
+
+              ---
+
+              [Back to Index](../index.md)
+            MARKDOWN
+          end
+
+          private
+
+          def build_sub_packages_section(packages)
+            return "" if packages.empty?
+
+            content = "## Sub-packages\n\n"
+            packages.each do |pkg|
+              pkg_path = @link_resolver.package_path(pkg)
+              link = @link_resolver.package_link(pkg_path)
+              content += "- [#{pkg.name}](#{link})\n"
+            end
+            "#{content}\n"
+          end
+
+          def build_classes_section(classes)
+            return "## Classes\n\nNo classes in this package.\n" if classes.empty?
+
+            content = "## Classes\n\n"
+            content += "| Name | Type | Stereotypes | Attributes | Associations |\n"
+            content += "|------|------|-------------|------------|--------------|\n"
+
+            classes.sort_by(&:name).each do |klass|
+              content += format_class_table_row(klass)
+            end
+
+            "#{content}\n"
+          end
+
+          def format_class_table_row(klass)
+            qname = @link_resolver.qualified_name(klass)
+            link = @link_resolver.class_link(qname)
+            type = klass.class.name.split("::").last
+            stereotypes = format_stereotypes(klass.stereotype)
+            attrs_count = klass.attributes&.size || 0
+            assocs_count = count_associations(klass)
+
+            "| [#{klass.name}](#{link}) | #{type} | #{stereotypes} | " \
+              "#{attrs_count} | #{assocs_count} |\n"
+          end
+
+          def build_diagrams_section(package_path)
+            diagrams = @repository.diagrams_in_package(package_path)
+            return "" if diagrams.empty?
+
+            content = "## Diagrams\n\n"
+            diagrams.each do |diagram|
+              content += "- **#{diagram.name}** (#{diagram.diagram_type})\n"
+            end
+            "#{content}\n"
+          rescue StandardError
+            ""
+          end
+
+          def count_associations(klass)
+            @repository.associations_of(klass).size
+          rescue StandardError
+            0
+          end
+        end
+      end
+    end
+  end
+end