ea 0.4.0 → 0.5.0

data/lib/ea/diagram/svg_renderer.rb

@@ -1,274 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Diagram
-      # Main SVG renderer for EA diagrams
-      class SvgRenderer
-        include Ea::Diagram::Util
-
-        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
-
-        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
-
-        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)
-          registry = ElementRenderers::DEFAULT_REGISTRY
-          renderer_class = registry.renderer_for(element[:type]) ||
-            ElementRenderers::BaseRenderer
-
-          renderer = renderer_class.new(element, style_resolver)
-          renderer.render
-        end
-
-      end
-    end
-end

data/lib/ea/diagram/util.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Diagram
-      module Util
-        # Convert a style hash to a CSS string
-        #
-        # @param style_hash [Hash] Style properties (e.g., { stroke: "#000" })
-        # @return [String] CSS string (e.g., "stroke:#000;fill:none")
-        def style_to_css(style_hash)
-          style_hash.map { |k, v| "#{k}:#{v}" }.join(";")
-        end
-
-        # 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 TypeError, NoMethodError
-          [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 ArgumentError, TypeError
-            data = {}
-          end
-          data
-        end
-      end
-    end
-end

data/lib/ea/svg/bounds_calculator.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Svg
-    # Computes the actual drawing-area bounding box of an
-    # Ea::Model::Diagram. EA stores bounds in pixel space with two
-    # quirks: element rects can be inverted (rectbottom < recttop,
-    # producing negative height), and elements/connectors can sit
-    # outside the canvas bounds. The drawing area is the union of
-    # all element rects and connector waypoint positions.
-    class BoundsCalculator
-      attr_reader :diagram
-
-      def initialize(diagram)
-        @diagram = diagram
-      end
-
-      def compute
-        points = all_points
-        return fallback_bounds if points.empty?
-
-        xs = points.map(&:first)
-        ys = points.map(&:last)
-        Bounds.new(x: xs.min, y: ys.min, width: xs.max - xs.min,
-                    height: ys.max - ys.min)
-      end
-
-      private
-
-      def all_points
-        points = []
-        diagram.elements.each do |elem|
-          next unless elem.bounds
-
-          b = normalize_bounds(elem.bounds)
-          points << [b.x, b.y]
-          points << [b.x + b.width, b.y + b.height]
-        end
-        diagram.connectors.each do |conn|
-          conn.waypoints.each do |wp|
-            next unless wp.position
-
-            points << [wp.position.x, wp.position.y]
-          end
-        end
-        points
-      end
-
-      # EA occasionally stores inverted rects (rectbottom < recttop).
-      # Normalize so width/height are non-negative.
-      def normalize_bounds(bounds)
-        x = bounds.x
-        y = bounds.y
-        w = bounds.width
-        h = bounds.height
-        x, w = x + w, -w if w.negative?
-        y, h = y + h, -h if h.negative?
-        Bounds.new(x: x, y: y, width: w, height: h)
-      end
-
-      def fallback_bounds
-        return Bounds.new(x: 0, y: 0, width: 1, height: 1) unless diagram.bounds
-
-        Bounds.new(x: diagram.bounds.x, y: diagram.bounds.y,
-                    width: diagram.bounds.width.abs,
-                    height: diagram.bounds.height.abs)
-      end
-
-      # Internal value type — keep private to avoid polluting the
-      # Ea::Svg namespace.
-      Bounds = Struct.new(:x, :y, :width, :height, keyword_init: true)
-    end
-  end
-end

data/lib/ea/svg/connector_path.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Svg
-    # Renders one DiagramConnector as an SVG <path> through its
-    # waypoints, with an arrowhead at the target end. Matches EA's
-    # convention: filled triangle for navigable associations, filled
-    # diamond for aggregations, open diamond for shared aggregations.
-    class ConnectorPath
-      ARROW_SIZE = 8
-
-      attr_reader :connector, :relationship
-
-      def initialize(connector, relationship: nil)
-        @connector = connector
-        @relationship = relationship
-      end
-
-      def render
-        points = waypoints
-        return "" if points.size < 2
-
-        path_d = build_path_d(points)
-        style = StyleResolver.new(connector.style)
-
-        parts = []
-        parts << %(<g class="connector" data-connector-id="#{escape(connector.id)}">)
-        parts << %(  <path d="#{path_d}" stroke="#{style.stroke_color}" stroke-width="#{style.stroke_width}" fill="none"/>)
-        parts << render_source_marker(points) if source_marker?
-        parts << render_target_marker(points)
-        parts << %(</g>)
-        parts.join("\n            ")
-      end
-
-      private
-
-      def waypoints
-        connector.waypoints.filter_map do |wp|
-          next unless wp.position
-
-          [wp.position.x, wp.position.y]
-        end
-      end
-
-      def build_path_d(points)
-        moves = points.each_with_index.map do |p, idx|
-          prefix = idx.zero? ? "M" : "L"
-          "#{prefix} #{p[0]} #{p[1]}"
-        end
-        moves.join(" ")
-      end
-
-      def source_marker?
-        return false unless relationship
-
-        relationship.is_a?(Ea::Model::Association) &&
-          relationship.source_aggregation != "none"
-      end
-
-      def render_source_marker(points)
-        case relationship.source_aggregation
-        when "composite" then filled_diamond(points.first, points[1])
-        when "shared" then open_diamond(points.first, points[1])
-        else ""
-        end
-      end
-
-      def render_target_marker(points)
-        filled_arrow(points.last, points[-2])
-      end
-
-      def filled_arrow(tip, base)
-        return "" unless tip && base
-
-        # Build a triangle pointing from base toward tip
-        bx, by = base
-        tx, ty = tip
-        # Perpendicular vector for the wings
-        dx = tx - bx
-        dy = ty - by
-        len = Math.sqrt(dx * dx + dy * dy)
-        return "" if len.zero?
-
-        ux = dx / len
-        uy = dy / len
-        # Wing points are ARROW_SIZE back from tip, perpendicular
-        back_x = tx - ux * ARROW_SIZE
-        back_y = ty - uy * ARROW_SIZE
-        perp_x = -uy * (ARROW_SIZE / 2.0)
-        perp_y = ux * (ARROW_SIZE / 2.0)
-        w1_x = back_x + perp_x
-        w1_y = back_y + perp_y
-        w2_x = back_x - perp_x
-        w2_y = back_y - perp_y
-        points_str = "#{tx} #{ty} #{w1_x.round(1)} #{w1_y.round(1)} #{w2_x.round(1)} #{w2_y.round(1)}"
-        %(  <polygon points="#{points_str}" fill="black" stroke="black" stroke-width="1"/>)
-      end
-
-      def filled_diamond(tip, base)
-        diamond_polygon(tip, base, fill: "black")
-      end
-
-      def open_diamond(tip, base)
-        diamond_polygon(tip, base, fill: "white")
-      end
-
-      def diamond_polygon(tip, base, fill:)
-        bx, by = base
-        tx, ty = tip
-        dx = tx - bx
-        dy = ty - by
-        len = Math.sqrt(dx * dx + dy * dy)
-        return "" if len.zero?
-
-        ux = dx / len
-        uy = dy / len
-        back_x = tx - ux * ARROW_SIZE
-        back_y = ty - uy * ARROW_SIZE
-        perp_x = -uy * (ARROW_SIZE / 2.0)
-        perp_y = ux * (ARROW_SIZE / 2.0)
-        far_x = tx - ux * (2 * ARROW_SIZE)
-        far_y = ty - uy * (2 * ARROW_SIZE)
-        w1_x = back_x + perp_x
-        w1_y = back_y + perp_y
-        w2_x = back_x - perp_x
-        w2_y = back_y - perp_y
-        points_str = "#{far_x.round(1)} #{far_y.round(1)} #{w1_x.round(1)} #{w1_y.round(1)} #{tx} #{ty} #{w2_x.round(1)} #{w2_y.round(1)}"
-        %(  <polygon points="#{points_str}" fill="#{fill}" stroke="black" stroke-width="1"/>)
-      end
-
-      def escape(text)
-        return "" if text.nil?
-
-        text.to_s.gsub("\"", "&quot;")
-      end
-    end
-  end
-end