ea 0.1.0 → 0.1.4

data/lib/ea/diagram/svg_renderer.rb

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

@@ -0,0 +1,73 @@
+# 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/diagram.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Ea
+  module Diagram
+    autoload :SvgRenderer, "ea/diagram/svg_renderer"
+    autoload :LayoutEngine, "ea/diagram/layout_engine"
+    autoload :StyleParser, "ea/diagram/style_parser"
+    autoload :PathBuilder, "ea/diagram/path_builder"
+    autoload :StyleResolver, "ea/diagram/style_resolver"
+    autoload :Configuration, "ea/diagram/configuration"
+    autoload :Util, "ea/diagram/util"
+    autoload :Extractor, "ea/diagram/extractor"
+    autoload :ElementRenderers, "ea/diagram/element_renderers"
+
+    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
+
+      def render_svg(options = {})
+        svg_renderer = SvgRenderer.new(self, options)
+        svg_renderer.render
+      end
+
+      def bounds
+        layout_engine.calculate_bounds(diagram_data)
+      end
+
+      def elements
+        diagram_data[:elements] || []
+      end
+
+      def connectors
+        diagram_data[:connectors] || []
+      end
+    end
+
+    def self.render(diagram_data, options = {})
+      renderer = DiagramRenderer.new(diagram_data)
+      renderer.render_svg(options)
+    end
+  end
+end

data/lib/ea/qea/benchmark.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "benchmark"
+
+module Ea
+  module Qea
+    # Performance benchmarking utilities for comparing QEA vs XMI parsing
+    class Benchmark
+      class << self
+        # Compare QEA and XMI parsing performance
+        #
+        # @param qea_path [String] Path to QEA file
+        # @param xmi_path [String] Path to XMI file
+        # @return [Hash] Benchmark results
+        #
+        # @example
+        #   results = Ea::Qea::Benchmark.compare(
+        #     "model.qea",
+        #     "model.xmi"
+        #   )
+        #   puts "QEA: #{results[:qea][:time]}s"
+        #   puts "XMI: #{results[:xmi][:time]}s"
+        #   puts "Speedup: #{results[:speedup]}x"
+        def compare(qea_path, xmi_path) # rubocop:disable Metrics/MethodLength
+          qea_result = measure_qea(qea_path)
+          xmi_result = measure_xmi(xmi_path)
+
+          speedup = if qea_result[:time].positive?
+                      (xmi_result[:time] / qea_result[:time]).round(2)
+                    else
+                      0
+                    end
+
+          {
+            qea: qea_result,
+            xmi: xmi_result,
+            speedup: speedup,
+            improvement_percent: ((speedup - 1) * 100).round(1),
+          }
+        end
+
+        # Measure QEA parsing performance
+        #
+        # @param path [String] Path to QEA file
+        # @return [Hash] Performance metrics
+        #
+        # @example
+        #   result = Ea::Qea::Benchmark.measure_qea("model.qea")
+        #   puts "Time: #{result[:time]}s"
+        #   puts "Packages: #{result[:stats][:packages]}"
+        def measure_qea(path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          unless File.exist?(path)
+            return { error: "File not found: #{path}" }
+          end
+
+          result = {
+            file: path,
+            file_size_mb: (File.size(path) / 1024.0 / 1024.0).round(2),
+            format: "QEA",
+          }
+
+          # Measure parsing time
+          document = nil
+          time = ::Benchmark.realtime do
+            document = Ea::Qea.parse(path)
+          end
+
+          result[:time] = time.round(3)
+          result[:stats] = {
+            packages: document.packages&.size || 0,
+            classes: document.classes&.size || 0,
+            associations: document.associations&.size || 0,
+            diagrams: document.diagrams&.size || 0,
+          }
+
+          # Calculate throughput
+          if result[:file_size_mb].positive? && time.positive?
+            result[:throughput_mb_per_sec] =
+              (result[:file_size_mb] / time).round(2)
+          end
+
+          result
+        rescue StandardError => e
+          {
+            error: e.message,
+            file: path,
+            format: "QEA",
+          }
+        end
+
+        # Measure XMI parsing performance
+        #
+        # @param path [String] Path to XMI file
+        # @return [Hash] Performance metrics
+        #
+        # @example
+        #   result = Ea::Qea::Benchmark.measure_xmi("model.xmi")
+        #   puts "Time: #{result[:time]}s"
+        def measure_xmi(path) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          unless File.exist?(path)
+            return { error: "File not found: #{path}" }
+          end
+
+          result = {
+            file: path,
+            file_size_mb: (File.size(path) / 1024.0 / 1024.0).round(2),
+            format: "XMI",
+          }
+
+          # Measure parsing time
+          document = nil
+          time = ::Benchmark.realtime do
+            File.open(path) do |file|
+              document = Ea::Xmi::Parser.parse(file)
+            end
+          end
+
+          result[:time] = time.round(3)
+          result[:stats] = {
+            packages: document.packages&.size || 0,
+            classes: document.classes&.size || 0,
+            associations: document.associations&.size || 0,
+            diagrams: document.diagrams&.size || 0,
+          }
+
+          # Calculate throughput
+          if result[:file_size_mb].positive? && time.positive?
+            result[:throughput_mb_per_sec] =
+              (result[:file_size_mb] / time).round(2)
+          end
+
+          result
+        rescue StandardError => e
+          {
+            error: e.message,
+            file: path,
+            format: "XMI",
+          }
+        end
+
+        # Format benchmark results for display
+        #
+        # @param results [Hash] Results from compare method
+        # @return [String] Formatted text
+        def format_results(results) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return results[:error] if results[:error]
+
+          output = []
+          output << ("=" * 80)
+          output << "QEA vs XMI Performance Comparison"
+          output << ("=" * 80)
+          output << ""
+
+          if results[:qea][:error]
+            output << "QEA Error: #{results[:qea][:error]}"
+          else
+            output << "QEA File:"
+            output << "  Path:       #{results[:qea][:file]}"
+            output << "  Size:       #{results[:qea][:file_size_mb]} MB"
+            output << "  Parse Time: #{results[:qea][:time]}s"
+            if results[:qea][:throughput_mb_per_sec]
+              output << "  Throughput: " \
+                        "#{results[:qea][:throughput_mb_per_sec]} MB/s"
+            end
+            output << "  Packages:   #{results[:qea][:stats][:packages]}"
+            output << "  Classes:    #{results[:qea][:stats][:classes]}"
+          end
+
+          output << ""
+
+          if results[:xmi][:error]
+            output << "XMI Error: #{results[:xmi][:error]}"
+          else
+            output << "XMI File:"
+            output << "  Path:       #{results[:xmi][:file]}"
+            output << "  Size:       #{results[:xmi][:file_size_mb]} MB"
+            output << "  Parse Time: #{results[:xmi][:time]}s"
+            if results[:xmi][:throughput_mb_per_sec]
+              output << "  Throughput: " \
+                        "#{results[:xmi][:throughput_mb_per_sec]} MB/s"
+            end
+            output << "  Packages:   #{results[:xmi][:stats][:packages]}"
+            output << "  Classes:    #{results[:xmi][:stats][:classes]}"
+          end
+
+          output << ""
+          output << "Performance Improvement:"
+          output << "  QEA is #{results[:speedup]}x faster than XMI"
+          output << "  Improvement: #{results[:improvement_percent]}%"
+          output << ""
+
+          # Add interpretation
+          output << if results[:speedup] >= 10
+                      "  ✓ Significant performance improvement with QEA"
+                    elsif results[:speedup] >= 5
+                      "  ✓ Notable performance improvement with QEA"
+                    elsif results[:speedup] >= 2
+                      "  ✓ Moderate performance improvement with QEA"
+                    else
+                      "  ~ Minimal performance difference"
+                    end
+
+          output << ("=" * 80)
+
+          output.join("\n")
+        end
+      end
+    end
+  end
+end