lutaml 0.10.19 → 0.11.2

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

@@ -1,279 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,69 +0,0 @@
-# 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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Ea
-    module Diagram
-      autoload :SvgRenderer, "lutaml/ea/diagram/svg_renderer"
-      autoload :LayoutEngine, "lutaml/ea/diagram/layout_engine"
-      autoload :StyleParser, "lutaml/ea/diagram/style_parser"
-      autoload :PathBuilder, "lutaml/ea/diagram/path_builder"
-      autoload :StyleResolver, "lutaml/ea/diagram/style_resolver"
-      autoload :Configuration, "lutaml/ea/diagram/configuration"
-      autoload :Util, "lutaml/ea/diagram/util"
-      autoload :Extractor, "lutaml/ea/diagram/extractor"
-      autoload :ElementRenderers, "lutaml/ea/diagram/element_renderers"
-
-      # 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/ea.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Ea
-    autoload :Diagram, "lutaml/ea/diagram"
-  end
-end

data/lib/lutaml/formatter/base.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Formatter
-    class Base
-      class << self
-        def inherited(subclass) # rubocop:disable Lint/MissingSuper
-          Formatter.all << subclass
-        end
-
-        def format(node, attributes = {})
-          new(attributes).format(node)
-        end
-
-        def name
-          to_s.split("::").last.downcase.to_sym
-        end
-      end
-
-      include ::Lutaml::Uml::HasAttributes
-
-      # rubocop:disable Rails/ActiveRecordAliases
-      def initialize(attributes = {})
-        update_attributes(attributes)
-      end
-      # rubocop:enable Rails/ActiveRecordAliases
-
-      def name
-        self.class.name
-      end
-
-      attr_reader :type
-
-      def type=(value)
-        @type = value.to_s.strip.downcase.to_sym
-      end
-
-      def format(node) # rubocop:disable Metrics/CyclomaticComplexity
-        case 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)
-        when ::Lutaml::Uml::Node::ClassNode then format_class(node)
-        when ::Lutaml::Uml::Document then format_document(node)
-        end
-      end
-
-      def format_attribute(_node); raise NotImplementedError; end
-
-      def format_operation(_node); raise NotImplementedError; end
-
-      def format_relationship(_node);       raise NotImplementedError; end
-
-      def format_class_relationship(_node); raise NotImplementedError; end
-
-      def format_class(_node);              raise NotImplementedError; end
-
-      def format_document(_node);           raise NotImplementedError; end
-    end
-  end
-end