lutaml 0.9.43 → 0.10.0

data/lib/lutaml/ea/diagram/svg_renderer.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require_relative "path_builder"
+require_relative "style_resolver"
+require_relative "element_renderers/base_renderer"
+require_relative "element_renderers/class_renderer"
+require_relative "element_renderers/package_renderer"
+
+module Lutaml
+  module Ea
+    module Diagram
+      # Main SVG renderer for EA diagrams
+      class SvgRenderer
+        attr_reader :diagram_renderer, :options, :bounds, :style_resolver
+
+        DEFAULT_OPTIONS = {
+          padding: 20,
+          background_color: "#ffffff",
+          grid_visible: false,
+          interactive: false,
+          css_classes: [],
+        }.freeze
+
+        def initialize(diagram_renderer, options = {})
+          @diagram_renderer = diagram_renderer
+          @options = DEFAULT_OPTIONS.merge(options)
+          @bounds = diagram_renderer.bounds
+          @style_resolver = StyleResolver.new(options[:config_path])
+        end
+
+        # Render the complete SVG diagram
+        # @return [String] Complete SVG content
+        def render # rubocop:disable Metrics/AbcSize
+          svg_content = +""
+          svg_content << svg_header
+          svg_content << defs_section
+          svg_content << background_layer
+          svg_content << grid_layer if options[:grid_visible]
+          svg_content << connectors_layer
+          svg_content << elements_layer
+          svg_content << interactive_layer if options[:interactive]
+          svg_content << svg_footer
+          svg_content
+        end
+
+        private
+
+        def svg_header # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          # Bounds already include padding from LayoutEngine
+          width = bounds[:width]
+          height = bounds[:height]
+
+          # Normalize viewBox to start at 0,0 (matching EA export format)
+          # Shift all content to positive coordinates
+          offset_x = bounds[:x].negative? ? bounds[:x].abs : 0
+          offset_y = bounds[:y].negative? ? bounds[:y].abs : 0
+          total_width = width + offset_x
+          total_height = height + offset_y
+
+          view_box = "0 0 #{total_width} #{total_height}"
+
+          # Format width/height in cm (matching EA export format)
+          width_cm = format("%.2f", (total_width / 37.7952755906).round(2))
+          height_cm = format("%.2f", (total_height / 37.7952755906).round(2))
+
+          <<~SVG
+            <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+            <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
+
+            <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="#{width_cm}cm" height="#{height_cm}cm" viewBox="#{view_box}">
+            <title></title>
+            <desc>Created with Enterprise Architect (Build: 1624) 2</desc>
+          SVG
+        end
+
+        def defs_section
+          <<~SVG
+            <defs>
+              <style type="text/css">
+                <![CDATA[
+                .lutaml-diagram-element { cursor: pointer; }
+                .lutaml-diagram-element:hover { opacity: 0.8; }
+                .lutaml-diagram-connector { fill: none; stroke: #000000; stroke-width: 1; }
+                .lutaml-diagram-connector:hover { stroke-width: 2; }
+                .lutaml-diagram-grid { stroke: #e0e0e0; stroke-width: 0.5; }
+                .lutaml-diagram-text { font-family: Arial, sans-serif; font-size: 11px; }
+                .lutaml-diagram-stereotype { font-style: italic; font-size: 9px; }
+                .lutaml-diagram-class-name { font-weight: bold; font-size: 12px; }
+                ]]>
+              </style>
+              <!-- EA-style arrow markers -->
+              <marker id="generalization-arrow" markerWidth="10" markerHeight="7"
+                      refX="9" refY="3.5" orient="auto">
+                <polygon points="0 0, 10 3.5, 0 7" fill="#FFFFFF" stroke="#000000" stroke-width="1" />
+              </marker>
+              <marker id="association-arrow" markerWidth="10" markerHeight="7"
+                      refX="9" refY="3.5" orient="auto">
+                <polygon points="0 0, 10 3.5, 0 7" fill="#000000" />
+              </marker>
+              <marker id="aggregation-arrow" markerWidth="12" markerHeight="12"
+                      refX="6" refY="6" orient="auto">
+                <polygon points="6,0 12,6 6,12 0,6" fill="#FFFFFF" stroke="#000000" stroke-width="1" />
+              </marker>
+              <marker id="composition-arrow" markerWidth="12" markerHeight="12"
+                      refX="6" refY="6" orient="auto">
+                <polygon points="6,0 12,6 6,12 0,6" fill="#000000" stroke="#000000" stroke-width="1" />
+              </marker>
+              <marker id="dependency-arrow" markerWidth="10" markerHeight="7"
+                      refX="9" refY="3.5" orient="auto">
+                <polygon points="0 0, 10 3.5, 0 7" fill="#000000" />
+              </marker>
+              <marker id="realization-arrow" markerWidth="10" markerHeight="7"
+                      refX="9" refY="3.5" orient="auto">
+                <polygon points="0 0, 10 3.5, 0 7" fill="#FFFFFF" stroke="#000000" stroke-width="1" />
+              </marker>
+            </defs>
+          SVG
+        end
+
+        def background_layer # rubocop:disable Metrics/AbcSize
+          offset_x = bounds[:x].negative? ? bounds[:x].abs : 0
+          offset_y = bounds[:y].negative? ? bounds[:y].abs : 0
+          total_width = bounds[:width] + offset_x
+          total_height = bounds[:height] + offset_y
+
+          <<~SVG
+            <g style="fill:#{options[:background_color]};fill-opacity:1.00;">
+                 <rect x="0" y="0" width="#{total_width}" height="#{total_height}" shape-rendering="auto"/>
+            </g>
+          SVG
+        end
+
+        def grid_layer # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          grid_size = 20
+          grid_lines = +""
+
+          # Vertical lines
+          x = bounds[:x]
+          while x <= bounds[:x] + bounds[:width]
+            grid_lines << "<line x1=\"#{x}\" y1=\"#{bounds[:y]}\" " \
+                          "x2=\"#{x}\" " \
+                          "y2=\"#{bounds[:y] + bounds[:height]}\" " \
+                          "class=\"lutaml-diagram-grid\" />\n"
+            x += grid_size
+          end
+
+          # Horizontal lines
+          y = bounds[:y]
+          while y <= bounds[:y] + bounds[:height]
+            grid_lines << "<line x1=\"#{bounds[:x]}\" y1=\"#{y}\" " \
+                          "x2=\"#{bounds[:x] + bounds[:width]}\" " \
+                          "y2=\"#{y}\" class=\"lutaml-diagram-grid\" />\n"
+            y += grid_size
+          end
+
+          "<g id=\"grid-layer\" " \
+            "class=\"lutaml-diagram-grid-layer\">\n#{grid_lines}</g>\n"
+        end
+
+        def connectors_layer
+          connectors_svg = diagram_renderer.connectors.map do |connector|
+            render_connector(connector)
+          end.join("\n")
+
+          "<g id=\"connectors-layer\" " \
+            "class=\"lutaml-diagram-connectors-layer\">\n" \
+            "#{connectors_svg}\n</g>\n"
+        end
+
+        def elements_layer
+          elements_svg = diagram_renderer.elements.map do |element|
+            render_element(element)
+          end.join("\n")
+
+          "<g id=\"elements-layer\" " \
+            "class=\"lutaml-diagram-elements-layer\">\n#{elements_svg}\n</g>\n"
+        end
+
+        def interactive_layer
+          # Add interactive JavaScript if needed
+          <<~SVG
+            <script type="text/javascript">
+            <![CDATA[
+              // Basic interactivity
+              document.addEventListener('DOMContentLoaded', function() {
+                var elements = document.querySelectorAll('.lutaml-diagram-element');
+                elements.forEach(function(el) {
+                  el.addEventListener('click', function(e) {
+                    var event = new CustomEvent('lutaml:element:click', {
+                      detail: {
+                        elementId: e.target.getAttribute('data-element-id'),
+                        elementType: e.target.getAttribute('data-element-type')
+                      }
+                    });
+                    document.dispatchEvent(event);
+                    console.log('Element clicked:', e.target.getAttribute('data-element-id'));
+                  });
+                });
+              });
+            ]]>
+            </script>
+          SVG
+        end
+
+        def svg_footer
+          "</svg>\n"
+        end
+
+        def render_connector(connector) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          path_builder = PathBuilder.new(
+            connector,
+            connector[:source_element],
+            connector[:target_element],
+          )
+          path_data = path_builder.build_path
+
+          style = style_resolver.resolve_connector_style(connector)
+
+          # Determine marker based on connector type
+          markers = determine_marker_type(connector[:type])
+          marker_start = markers[:start] || ""
+          marker_end = markers[:end] || ""
+
+          # Build style string
+          style_attrs = []
+          style_attrs << "stroke:#{style[:stroke] || '#000000'}"
+          style_attrs << "stroke-width:#{style[:stroke_width] || '1'}"
+          style_attrs << "stroke-linecap:#{style[:stroke_linecap] || 'round'}"
+          style_attrs << "stroke-linejoin:#{style[:stroke_linejoin] || 'bevel'}"
+          style_attrs << "fill:#{style[:fill] || 'none'}"
+          style_attrs << "shape-rendering:#{style[:shape_rendering] || 'auto'}"
+          if style[:stroke_dasharray]
+            style_attrs << "stroke-dasharray:#{style[:stroke_dasharray]}"
+          end
+
+          <<~SVG
+            <g style="#{style_attrs.join(';')}">
+              <path d="#{path_data}"
+                    class="lutaml-diagram-connector lutaml-diagram-connector-#{connector[:type]}"
+                    data-connector-id="#{connector[:id]}"
+                    data-connector-type="#{connector[:type]}"
+                    #{"marker-start=\"#{marker_start}\"" unless marker_start.empty?}
+                    #{"marker-end=\"#{marker_end}\"" unless marker_end.empty?}
+                    shape-rendering="auto" />
+            </g>
+          SVG
+        end
+
+        def render_element(element)
+          renderer_class = case element[:type]
+                           when "class", "datatype" then ElementRenderers::ClassRenderer
+                           when "package" then ElementRenderers::PackageRenderer
+                           else ElementRenderers::BaseRenderer
+                           end
+
+          renderer = renderer_class.new(element, style_resolver)
+          renderer.render
+        end
+
+        def determine_marker_type(connector_type) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          normalized_type = connector_type.to_s.downcase
+
+          case normalized_type
+          when "generalization", "inheritance"
+            { end: "url(#generalization-arrow)" }
+          when "aggregation"
+            { start: "url(#aggregation-arrow)" }
+          when "composition"
+            { start: "url(#composition-arrow)" }
+          when "dependency"
+            { end: "url(#dependency-arrow)" }
+          when "realization", "implementation"
+            { end: "url(#realization-arrow)" }
+          else
+            { end: "url(#association-arrow)" }
+          end
+        end
+
+        def style_to_css(style_hash)
+          style_hash.map { |k, v| "#{k}:#{v}" }.join(";")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/ea/diagram/util.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Ea
+    module Diagram
+      module Util
+        # Parse geometry offsets
+        def parse_geometry_offsets(geometry_string)
+          geometry = parse_ea_geometry(geometry_string)
+
+          [
+            geometry[:source_offset_x].to_i,
+            geometry[:source_offset_y].to_i,
+            geometry[:target_offset_x].to_i,
+            geometry[:target_offset_y].to_i,
+          ]
+        rescue StandardError
+          # handles malformed geometry gracefully
+          [0, 0, 0, 0]
+        end
+
+        def parse_ea_geometry(geometry_string) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return nil if geometry_string.nil? || geometry_string.strip.empty?
+
+          data = {}
+          begin
+            geometry = geometry_string
+              .gsub(/\s/, "")
+              .downcase
+              .split(";")
+              .to_h { |pair| pair.split("=") }
+
+            geometry.each do |k, v|
+              if v.include?(",")
+                # waypoints
+                data[:waypoints] ||= []
+                x_str, y_str = v.split(",")
+                data[:waypoints] << { x: x_str.to_i, y: y_str.to_i }
+              else
+                key = case k
+                      when "sx"
+                        data[:has_relative_coords] ||= true
+                        "source_offset_x"
+                      when "sy"
+                        data[:has_relative_coords] ||= true
+                        "source_offset_y"
+                      when "ex"
+                        data[:has_relative_coords] ||= true
+                        "target_offset_x"
+                      when "ey"
+                        data[:has_relative_coords] ||= true
+                        "target_offset_y"
+                      else
+                        k
+                      end
+
+                data[key.to_sym] = v.to_i
+              end
+            end
+          rescue StandardError
+            # handles malformed geometry gracefully
+            data = {}
+          end
+          data
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/ea/diagram.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "diagram/svg_renderer"
+require_relative "diagram/layout_engine"
+require_relative "diagram/style_parser"
+require_relative "diagram/path_builder"
+require_relative "diagram/element_renderers/base_renderer"
+require_relative "diagram/element_renderers/class_renderer"
+require_relative "diagram/element_renderers/package_renderer"
+require_relative "diagram/element_renderers/connector_renderer"
+
+module Lutaml
+  module Ea
+    # Diagram rendering module for converting EA diagrams to SVG
+    #
+    # This module provides comprehensive diagram rendering capabilities
+    # for Enterprise Architect UML diagrams, converting them to clean,
+    # interactive SVG format for web display.
+    #
+    # Key Features:
+    # - SVG rendering with proper layout and styling
+    # - Support for classes, packages, and connectors
+    # - EA-specific style parsing and conversion
+    # - Interactive elements with hover effects
+    # - Path calculation for complex connector routing
+    #
+    # Usage:
+    #   diagram = Lutaml::Ea::Diagram.new(ea_diagram_data)
+    #   svg_content = diagram.render_svg
+    module Diagram
+      # Main entry point for diagram rendering
+      class DiagramRenderer
+        attr_reader :diagram_data, :layout_engine, :style_parser
+
+        def initialize(diagram_data)
+          @diagram_data = diagram_data
+          @layout_engine = LayoutEngine.new
+          @style_parser = StyleParser.new
+        end
+
+        # Render the complete diagram as SVG
+        # @return [String] SVG content
+        def render_svg(options = {})
+          svg_renderer = SvgRenderer.new(self, options)
+          svg_renderer.render
+        end
+
+        # Get diagram bounds for viewport calculation
+        # @return [Hash] Bounds with x, y, width, height
+        def bounds
+          layout_engine.calculate_bounds(diagram_data)
+        end
+
+        # Get all elements in the diagram
+        # @return [Array] Array of diagram elements
+        def elements
+          diagram_data[:elements] || []
+        end
+
+        # Get all connectors in the diagram
+        # @return [Array] Array of connector elements
+        def connectors
+          diagram_data[:connectors] || []
+        end
+      end
+
+      # Convenience method for rendering diagrams
+      # @param diagram_data [Hash] EA diagram data
+      # @param options [Hash] Rendering options
+      # @return [String] SVG content
+      def self.render(diagram_data, options = {})
+        renderer = DiagramRenderer.new(diagram_data)
+        renderer.render_svg(options)
+      end
+    end
+  end
+end

data/lib/lutaml/express/parsers/exp.rb

@@ -13,7 +13,7 @@ module Lutaml
         #
         # @return [Expressir::Model::Repository]
         def self.parse(io, _options = {})
-          Expressir::Express::Parser.from_file(io.path)
+          Expressir::Express::Parser.from_files([io.path])
         end
       end
     end

data/lib/lutaml/express.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-require "lutaml/express/parsers/exp"
-
 module Lutaml
   module Express
+    # Parsers
+    module Parsers
+      autoload :Exp, "lutaml/express/parsers/exp"
+    end
   end
 end

data/lib/lutaml/formatter/base.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "lutaml/formatter"
-require "lutaml/uml/has_attributes"
+require_relative "../formatter"
+require_relative "../uml/has_attributes"
 
 module Lutaml
   module Formatter
@@ -40,8 +40,8 @@ module Lutaml
 
       def format(node) # rubocop:disable Metrics/CyclomaticComplexity
         case node
-        when ::Lutaml::Uml::Node::Field  then format_field(node)
-        when ::Lutaml::Uml::Node::Method then format_method(node)
+        when ::Lutaml::Uml::Node::Attribute then format_attribute(node)
+        when ::Lutaml::Uml::Node::Operation then format_operation(node)
         when ::Lutaml::Uml::Node::Relationship then format_relationship(node)
         when ::Lutaml::Uml::Node::ClassRelationship
           format_class_relationship(node)
@@ -50,9 +50,9 @@ module Lutaml
         end
       end
 
-      def format_field(_node);              raise NotImplementedError; end
+      def format_attribute(_node); raise NotImplementedError; end
 
-      def format_method(_node);             raise NotImplementedError; end
+      def format_operation(_node); raise NotImplementedError; end
 
       def format_relationship(_node);       raise NotImplementedError; end
 

data/lib/lutaml/formatter/graphviz.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require "open3"
-require "lutaml/formatter/base"
-require "lutaml/layout/graph_viz_engine"
+require_relative "base"
+require_relative "../layout/graph_viz_engine"
 
 module Lutaml
   module Formatter
@@ -87,7 +87,7 @@ module Lutaml
           .gsub("]", "]")
       end
 
-      def format_field(node) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      def format_attribute(node) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
         symbol = ACCESS_SYMBOLS[node.visibility]
         result = "#{symbol}#{node.name}"
         if node.type
@@ -104,7 +104,7 @@ module Lutaml
         result
       end
 
-      def format_method(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+      def format_operation(node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
         symbol = ACCESS_SYMBOLS[node.access]
         result = "#{symbol} #{node.name}"
         if node.arguments
@@ -217,7 +217,7 @@ module Lutaml
         end
 
         field_rows = members.map do |field|
-          %{<TR><TD ALIGN="LEFT">#{format_field(field)}</TD></TR>}
+          %{<TR><TD ALIGN="LEFT">#{format_attribute(field)}</TD></TR>}
         end
         field_table = <<~HEREDOC.chomp
           <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
@@ -228,7 +228,7 @@ module Lutaml
         field_table
       end
 
-      def format_class(node, hide_members) # rubocop:disable Metrics/AbcSize
+      def format_class(node, hide_members) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
         name = ["<B>#{node.name}</B>"]
         name.unshift("«#{node.keyword}»") if node.keyword
         name_html = <<~HEREDOC
@@ -238,7 +238,9 @@ module Lutaml
         HEREDOC
 
         field_table = format_member_rows(node.attributes, hide_members)
-        method_table = format_member_rows(node.methods, hide_members)
+        method_table = if node.respond_to?(:operations)
+                         format_member_rows(node.operations, hide_members)
+                       end
         table_body = [name_html, field_table, method_table].map do |type|
           next if type.nil?
 
@@ -277,7 +279,7 @@ module Lutaml
               label=<#{format_class(class_node, hide_members)}>]
           HEREDOC
         end.join("\n")
-        associations = node.classes.map(&:associations).compact.flatten +
+        associations = node.classes.filter_map(&:associations).flatten +
           node.associations
         if node.groups
           associations = sort_by_document_grouping(node.groups,

data/lib/lutaml/formatter.rb

@@ -2,6 +2,9 @@
 
 module Lutaml
   module Formatter
+    autoload :Base, "lutaml/formatter/base"
+    autoload :Graphviz, "lutaml/formatter/graphviz"
+
     class << self
       def all
         @all ||= []

data/lib/lutaml/layout/engine.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 module Lutaml
-  class Engine
-    attr_accessor :input
+  module Layout
+    class Engine
+      attr_accessor :input
 
-    def initialize(input:)
-      @input = input
-    end
+      def initialize(input:)
+        @input = input
+      end
 
-    def render(_type)
-      raise ArgumentError, "Implement render method"
+      def render(_type)
+        raise ArgumentError, "Implement render method"
+      end
     end
   end
 end

data/lib/lutaml/layout/graph_viz_engine.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require "ruby-graphviz"
-require "lutaml/layout/engine"
+require "open3"
+require_relative "engine"
 
 module Lutaml
   module Layout

data/lib/lutaml/layout.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Layout
+    autoload :Engine, "lutaml/layout/engine"
+    autoload :GraphVizEngine, "lutaml/layout/graph_viz_engine"
+  end
+end