lutaml 0.9.43 → 0.10.0

data/lib/lutaml/uml_repository/presenters/diagram_presenter.rb

@@ -0,0 +1,508 @@
+# frozen_string_literal: true
+
+require_relative "element_presenter"
+require_relative "../../ea/diagram/svg_renderer"
+require_relative "../../ea/diagram/layout_engine"
+require_relative "../../ea/diagram/style_resolver"
+
+module Lutaml
+  module UmlRepository
+    module Presenters
+      # Presenter for UML Diagram elements
+      #
+      # Coordinates the entire diagram rendering pipeline by:
+      # 1. Loading elements and connectors from the repository
+      # 2. Converting EA coordinates to SVG format
+      # 3. Using StyleResolver to merge EA data + config + defaults
+      # 4. Creating a DiagramRenderer wrapper
+      # 5. Generating SVG output via SvgRenderer
+      class DiagramPresenter < ElementPresenter
+        attr_reader :config_path
+
+        # @param diagram [Lutaml::Uml::Diagram] The diagram to present
+        # @param repository [Repository] Repository for looking up elements
+        # @param options [Hash] Rendering options
+        # @option options [String] :config_path Path to diagram configuration
+        def initialize(diagram, repository, options = {})
+          super(diagram, repository)
+          @config_path = options[:config_path]
+          @layout_engine = Ea::Diagram::LayoutEngine.new
+        end
+
+        # Generate SVG output for the diagram
+        #
+        # @param options [Hash] Rendering options
+        # @option options [Integer] :padding (20) Padding around diagram
+        # @option options [String] :background_color ("#ffffff")
+        # Background color
+        # @option options [Boolean] :grid_visible (false) Show grid
+        # @option options [Boolean] :interactive (false)
+        # Enable interactive features
+        # @return [String] Complete SVG content
+        def svg_output(options = {}) # rubocop:disable Metrics/MethodLength
+          # Build diagram data structure
+          diagram_data = {
+            name: element.name,
+            elements: build_elements_data,
+            connectors: build_connectors_data,
+          }
+
+          # Create diagram renderer wrapper
+          diagram_renderer = DiagramRendererWrapper.new(diagram_data,
+                                                        @layout_engine)
+
+          # Create SVG renderer with configuration
+          renderer_options = options.merge(config_path: config_path)
+          svg_renderer = Ea::Diagram::SvgRenderer.new(diagram_renderer,
+                                                      renderer_options)
+
+          # Generate and return SVG
+          svg_renderer.render
+        end
+
+        # Get elements in the diagram
+        #
+        # @return [Array<Hash>] Array of element data hashes
+        def elements
+          build_elements_data
+        end
+
+        # Get connectors in the diagram
+        #
+        # @return [Array<Hash>] Array of connector data hashes
+        def connectors
+          build_connectors_data
+        end
+
+        # Text output for diagram
+        def to_text # rubocop:disable Metrics/AbcSize
+          lines = []
+          lines << "Diagram: #{element.name}"
+          lines << ("=" * 50)
+          lines << ""
+          lines << "Type:          #{element.diagram_type}"
+          lines << "Package:       #{element.package_name || 'Unknown'}"
+          lines << "Elements:      #{(element.diagram_objects || []).count}"
+          lines << "Connectors:    #{(element.diagram_links || []).count}"
+          lines.join("\n")
+        end
+
+        # Table row for diagram
+        def to_table_row
+          {
+            type: "Diagram",
+            name: element.name || "(unnamed)",
+            details: "#{element.diagram_type} " \
+                     "- #{(element.diagram_objects || []).count} elements",
+          }
+        end
+
+        # Hash representation
+        def to_hash
+          {
+            type: "Diagram",
+            name: element.name,
+            diagram_type: element.diagram_type,
+            package_name: element.package_name,
+            elements_count: (element.diagram_objects || []).count,
+            connectors_count: (element.diagram_links || []).count,
+          }
+        end
+
+        private
+
+        # Build element data from diagram_objects
+        #
+        # @return [Array<Hash>] Array of element data for rendering
+        def build_elements_data # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return [] unless element.diagram_objects
+
+          element.diagram_objects.filter_map do |diagram_object|
+            # Look up the actual element in the repository
+            uml_element = find_element_by_xmi_id(diagram_object.object_xmi_id)
+            next nil unless uml_element
+
+            # Convert EA coordinates to SVG format
+            coords = @layout_engine.convert_ea_coordinates(diagram_object)
+
+            # Build element data hash
+            {
+              id: diagram_object.object_xmi_id,
+              name: uml_element.name,
+              type: determine_element_type(uml_element),
+              x: coords[:x],
+              y: coords[:y],
+              width: coords[:width],
+              height: coords[:height],
+              stereotype: extract_stereotype(uml_element),
+              attributes: extract_attributes(uml_element),
+              operations: extract_operations(uml_element),
+              element: uml_element, # Original UML element
+              diagram_object: diagram_object, # Original diagram placement data
+            }
+          end
+        end
+
+        # Build connector data from diagram_links
+        #
+        # @return [Array<Hash>] Array of connector data for rendering
+        def build_connectors_data # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return [] unless element.diagram_links
+
+          # Build elements index for quick lookup by XMI ID
+          elements_map = build_elements_data
+            .to_h do |elem|
+            [elem[:id], elem]
+          end
+
+          # Build diagram objects map for EA internal ID lookup
+          diagram_objects_map = {}
+          element.diagram_objects&.each do |dobj|
+            diagram_objects_map[extract_ea_id(dobj)] = dobj.object_xmi_id
+          end
+
+          element.diagram_links.filter_map do |diagram_link| # rubocop:disable Metrics/BlockLength
+            # Skip hidden connectors
+            next nil if diagram_link.hidden
+
+            # Look up the actual connector in the repository
+            connector = find_connector_by_xmi_id(diagram_link.connector_xmi_id)
+
+            # Even if connector object not found, we can still render
+            # Original diagram routing datausing geometry
+            # The diagram_link contains all visual information needed
+            connector_type = if connector
+                               determine_connector_type(connector)
+                             else
+                               # Default to association if connector object
+                               # not found
+                               "association"
+                             end
+
+            # Parse source and target from diagram_link style
+            # (contains SOID/EOID)
+            style_data = parse_diagram_link_style(diagram_link.style)
+
+            source_elem = nil
+            target_elem = nil
+
+            # Try to find elements using EA internal IDs from style
+            if style_data[:soid]
+              source_xmi_id = diagram_objects_map[style_data[:soid]]
+              source_elem = elements_map[source_xmi_id] if source_xmi_id
+            end
+
+            if style_data[:eoid]
+              target_xmi_id = diagram_objects_map[style_data[:eoid]]
+              target_elem = elements_map[target_xmi_id] if target_xmi_id
+            end
+
+            # Fallback: try to find from connector object
+            # if style parsing failed
+            if (!source_elem || !target_elem) && connector
+              source_elem ||= find_connector_source(connector, elements_map)
+              target_elem ||= find_connector_target(connector, elements_map)
+            end
+
+            # Build connector data hash
+            {
+              id: diagram_link.connector_xmi_id,
+              type: connector_type,
+              geometry: diagram_link.geometry,
+              style: diagram_link.style,
+              # Source element for geometry calculation
+              source_element: source_elem,
+              # Target element for geometry calculation
+              target_element: target_elem,
+              # May be nil if not found
+              element: connector,
+              # Original diagram routing data
+              diagram_link: diagram_link,
+            }
+          end
+        end
+
+        # Parse EA diagram link style string
+        #
+        # Style format: "Mode=3;EOID=82C649C4;SOID=21096985;
+        # Color=-1;LWidth=2;TREE=V;"
+        # SOID = Source Object ID (EA internal ID)
+        # EOID = End Object ID (EA internal ID)
+        #
+        # @param style_string [String] EA style string
+        # @return [Hash] Parsed style data
+        def parse_diagram_link_style(style_string) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          return {} unless style_string
+
+          data = {}
+          style_string.split(";").each do |pair|
+            next if pair.empty?
+
+            key, value = pair.split("=", 2)
+            next unless key && value
+
+            case key.strip
+            when "SOID"
+              data[:soid] = value.strip
+            when "EOID"
+              data[:eoid] = value.strip
+            end
+          end
+          data
+        end
+
+        # Extract EA internal ID from diagram object
+        #
+        # @param diagram_object [Object] Diagram object
+        # @return [String, nil] EA internal ID (DUID from style)
+        def extract_ea_id(diagram_object)
+          # EA stores the internal ID as DUID in the style string
+          unless diagram_object.respond_to?(:style) && diagram_object.style
+            return nil
+          end
+
+          # Parse DUID from style string
+          # Style format: "NSL=0;LCol=-1;...;DUID=82C649C4;BCol=16764159;..."
+          style = diagram_object.style
+          match = style.match(/DUID=([^;]+)/)
+          return match[1] if match
+
+          nil
+        end
+
+        # Find element in repository by XMI ID
+        #
+        # @param xmi_id [String] XMI identifier
+        # @return [Object, nil] UML element or nil if not found
+        def find_element_by_xmi_id(xmi_id)
+          return nil unless xmi_id && repository
+
+          # Try to find in classes index (includes classes, datatypes, enums)
+          element = repository.classes_index.find { |cls| cls.xmi_id == xmi_id }
+          return element if element
+
+          # Try to find in packages index
+          repository.packages_index.find { |pkg| pkg.xmi_id == xmi_id }
+        end
+
+        # Find connector in repository by XMI ID
+        #
+        # @param xmi_id [String] XMI identifier
+        # @return [Object, nil] UML connector or nil if not found
+        def find_connector_by_xmi_id(xmi_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return nil unless xmi_id && repository
+
+          # Look in document-level associations index
+          connector = repository.associations_index.find do |assoc|
+            assoc.xmi_id == xmi_id
+          end
+
+          return connector if connector
+
+          repository.classes_index.each do |klass|
+            if klass.respond_to?(:generalization) && klass.generalization
+              # Look in class-level generalizations
+              gen = klass.generalization
+
+              # Handle both single generalization and array of generalizations
+              generalizations = gen.is_a?(Array) ? gen : [gen]
+
+              generalizations.each do |g|
+                return g if g.respond_to?(:xmi_id) && g.xmi_id == xmi_id
+              end
+            elsif klass.respond_to?(:associations) && klass.associations
+              # Look in class-level associations
+              assoc = klass.associations.find do |a|
+                a.respond_to?(:xmi_id) && a.xmi_id == xmi_id
+              end
+              return assoc if assoc
+            end
+          end
+
+          nil
+        end
+
+        # Find connector target element
+        #
+        # @param connector [Object] UML connector
+        # @param elements_map [Hash] Map of element ID to element data
+        # @return [Hash, nil] Target element data
+        def find_connector_target(connector, elements_map) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          target_id = nil
+
+          if connector.respond_to?(:target) && connector.target
+            target_id = connector.target
+          elsif connector.respond_to?(:supplier) && connector.supplier
+            target_id = connector.supplier
+          elsif connector.respond_to?(:general) && connector.general
+            target_id = connector.general
+          elsif connector.respond_to?(:member_end) && connector.member_end
+            # For associations, use the second member_end
+            ends = if connector.member_end.is_a?(Array)
+                     connector.member_end
+                   else
+                     [connector.member_end]
+                   end
+            if ends.size > 1
+              target_id = ends[1]
+            end
+          end
+
+          elements_map[target_id]
+        end
+
+        # Find connector source element
+        #
+        # @param connector [Object] UML connector
+        # @param elements_map [Hash] Map of element ID to element data
+        # @return [Hash, nil] Source element data
+        def find_connector_source(connector, elements_map) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          source_id = nil
+
+          if connector.respond_to?(:source) && connector.source
+            source_id = connector.source
+          elsif connector.respond_to?(:client) && connector.client
+            source_id = connector.client
+          elsif connector.respond_to?(:specific) && connector.specific
+            source_id = connector.specific
+          elsif connector.respond_to?(:owner_end) && connector.owner_end
+            source_id = connector.owner_end
+          elsif connector.respond_to?(:member_end) && connector.member_end
+            # For associations, use the first member_end
+            ends = if connector.member_end.is_a?(Array)
+                     connector.member_end
+                   else
+                     [connector.member_end]
+                   end
+            if ends.any?
+              source_id = ends[0]
+            end
+          end
+
+          elements_map[source_id]
+        end
+
+        # Determine element type for rendering
+        #
+        # @param uml_element [Object] UML element
+        # @return [String] Element type
+        def determine_element_type(uml_element)
+          case uml_element.class.name
+          when /DataType/
+            "datatype"
+          when /Enum/
+            "enum"
+          when /Package/
+            "package"
+          else
+            "class"
+          end
+        end
+
+        # Determine connector type for rendering
+        #
+        # @param connector [Object] UML connector
+        # @return [String] Connector type
+        def determine_connector_type(connector)
+          case connector.class.name
+          when /Generalization/
+            "generalization"
+          when /Dependency/
+            "dependency"
+          when /Realization/
+            "realization"
+          else
+            "association"
+          end
+        end
+
+        # Extract stereotype from element
+        #
+        # @param uml_element [Object] UML element
+        # @return [String, nil] Stereotype name
+        def extract_stereotype(uml_element)
+          return nil unless uml_element.respond_to?(:stereotype)
+
+          stereotype = uml_element.stereotype
+          return nil unless stereotype
+
+          # Handle array of stereotypes
+          if stereotype.is_a?(Array)
+            stereotype.first
+          else
+            stereotype
+          end
+        end
+
+        # Extract attributes from element
+        #
+        # @param uml_element [Object] UML element
+        # @return [Array<Hash>] Array of attribute data
+        def extract_attributes(uml_element)
+          return [] unless uml_element.respond_to?(:attributes)
+          return [] unless uml_element.attributes
+
+          uml_element.attributes.map do |attr|
+            {
+              name: attr.name,
+              type: attr.type,
+              visibility: attr.respond_to?(:visibility) ? attr.visibility : nil,
+            }
+          end
+        end
+
+        # Extract operations from element
+        #
+        # @param uml_element [Object] UML element
+        # @return [Array<Hash>] Array of operation data
+        def extract_operations(uml_element)
+          return [] unless uml_element.respond_to?(:operations)
+          return [] unless uml_element.operations
+
+          uml_element.operations.map do |op|
+            {
+              name: op.name,
+              visibility: op.respond_to?(:visibility) ? op.visibility : nil,
+              return_type: op.respond_to?(:return_type) ? op.return_type : nil,
+              parameters: extract_parameters(op),
+            }
+          end
+        end
+
+        # Extract parameters from operation
+        #
+        # @param operation [Object] UML operation
+        # @return [Array<Hash>] Array of parameter data
+        def extract_parameters(operation)
+          return [] unless operation.respond_to?(:owned_parameter)
+          return [] unless operation.owned_parameter
+
+          operation.owned_parameter.map do |param|
+            {
+              name: param.name,
+              type: param.type,
+            }
+          end
+        end
+
+        # Wrapper class to adapt diagram data to SvgRenderer expectations
+        class DiagramRendererWrapper
+          attr_reader :diagram_data, :bounds, :elements, :connectors
+
+          def initialize(diagram_data, layout_engine)
+            @diagram_data = diagram_data
+            @elements = diagram_data[:elements] || []
+            @connectors = diagram_data[:connectors] || []
+            @bounds = layout_engine.calculate_bounds(diagram_data)
+          end
+        end
+      end
+
+      # Register with factory
+      PresenterFactory.register(
+        Lutaml::Uml::Diagram,
+        DiagramPresenter,
+      )
+    end
+  end
+end

data/lib/lutaml/uml_repository/presenters/element_presenter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module UmlRepository
+    module Presenters
+      # Abstract base class for presenting UML elements.
+      #
+      # Defines the common interface that all element presenters must
+      # implement. Provides shared utility methods for formatting.
+      #
+      # Subclasses must implement: to_text, to_table_row, to_hash
+      class ElementPresenter
+        attr_reader :element, :repository, :context
+
+        # @param element [Object] The UML element to present
+        # @param repository [UmlRepository, nil] Optional repository for
+        #   additional context
+        # @param context [Hash, nil] Optional context hash
+        def initialize(element, repository = nil, context = nil)
+          @element = element
+          @repository = repository
+          @context = context || {}
+        end
+
+        protected
+
+        # Generate detailed text view of the element.
+        #
+        # @return [String] Formatted text representation
+        # @raise [NotImplementedError] if not implemented by subclass
+        def to_text
+          raise NotImplementedError,
+                "#{self.class} must implement #to_text"
+        end
+
+        # Generate a single row for table display.
+        #
+        # @return [Hash] Hash with keys: :type, :name, :details, etc.
+        # @raise [NotImplementedError] if not implemented by subclass
+        def to_table_row
+          raise NotImplementedError,
+                "#{self.class} must implement #to_table_row"
+        end
+
+        # Generate structured hash for JSON/YAML output.
+        #
+        # @return [Hash] Structured data representation
+        # @raise [NotImplementedError] if not implemented by subclass
+        def to_hash
+          raise NotImplementedError,
+                "#{self.class} must implement #to_hash"
+        end
+
+        # Format cardinality for display.
+        #
+        # @param attr [Object] Attribute or property with cardinality
+        # @return [String] Formatted cardinality like "[1..1]" or "[0..*]"
+        def format_cardinality(attr) # rubocop:disable Metrics/CyclomaticComplexity
+          return "" unless attr.respond_to?(:cardinality) &&
+            attr.cardinality
+
+          card = attr.cardinality
+          min = card.respond_to?(:min) ? (card.min || "0") : "0"
+          max = card.respond_to?(:max) ? (card.max || "*") : "*"
+
+          "[#{min}..#{max}]"
+        end
+
+        # Truncate text to maximum length.
+        #
+        # @param text [String, nil] Text to truncate
+        # @param max_length [Integer] Maximum length
+        # @return [String] Truncated text with "..." if needed
+        def truncate(text, max_length = 50)
+          return "" if text.nil?
+          return text if text.length <= max_length
+
+          "#{text[0...(max_length - 3)]}..."
+        end
+
+        # Extract package path from qualified name.
+        #
+        # @param qualified_name [String] Fully qualified name
+        # @return [String] Package path (everything except last component)
+        def extract_package_path(qualified_name)
+          parts = qualified_name.to_s.split("::")
+          parts[0..-2].join("::")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/uml_repository/presenters/enum_presenter.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "element_presenter"
+require_relative "presenter_factory"
+
+module Lutaml
+  module UmlRepository
+    module Presenters
+      # Presenter for UML Enumeration elements.
+      #
+      # Formats enumeration information including literal values.
+      class EnumPresenter < ElementPresenter
+        def initialize(element, repository = nil, context = nil)
+          super
+        end
+
+        def to_text # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          lines = []
+          lines << "Enumeration: #{element.name}"
+          lines << ("=" * 50)
+          lines << ""
+          lines << "Name:          #{element.name}"
+          if element.respond_to?(:xmi_id) && element.xmi_id
+            lines << "XMI ID:        #{element.xmi_id}"
+          end
+          if element.respond_to?(:stereotype) && element.stereotype
+            lines << "Stereotype:    #{element.stereotype}"
+          end
+          if element.respond_to?(:visibility) && element.visibility
+            lines << "Visibility:    #{element.visibility}"
+          end
+          lines << ""
+
+          if element.values && !element.values.empty?
+            lines << "Literal Values (#{element.values.size}):"
+            element.each_value do |value|
+              lines << "  - #{value.name || value.to_s}"
+            end
+          else
+            lines << "Literal Values: (none)"
+          end
+
+          lines.join("\n")
+        end
+
+        def to_table_row
+          value_count = element.values ? element.values.size : 0
+          {
+            type: "Enumeration",
+            name: element.name || "(unnamed)",
+            details: "#{value_count} literal value(s)",
+          }
+        end
+
+        def to_hash # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          data = {
+            type: "Enumeration",
+            name: element.name,
+            value_count: element.values ? element.values.size : 0,
+          }
+
+          data[:xmi_id] = element.xmi_id if
+            element.respond_to?(:xmi_id) && element.xmi_id
+          data[:stereotype] = element.stereotype if
+            element.respond_to?(:stereotype) && element.stereotype
+          data[:visibility] = element.visibility if
+            element.respond_to?(:visibility) && element.visibility
+
+          if element.values && !element.values.empty?
+            data[:values] = element.values.map do |v|
+              v.respond_to?(:name) ? v.name : v.to_s
+            end
+          end
+
+          data
+        end
+      end
+
+      # Register with factory
+      PresenterFactory.register(Lutaml::Uml::Enum, EnumPresenter)
+    end
+  end
+end