ea 0.4.0 → 0.5.0

data/lib/ea/diagram/element_renderers/class_renderer.rb

@@ -1,323 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Diagram
-      module ElementRenderers
-        # Renderer for UML class elements
-        class ClassRenderer < BaseRenderer
-          def render_shape(style) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-            x = element[:x] || 0
-            y = element[:y] || 0
-            width = element[:width] || 120
-            height = element[:height] || 80
-
-            # Calculate compartment heights
-            name_height = 25
-            attributes_height = calculate_attributes_height
-            operations_height = calculate_operations_height
-
-            total_height = name_height + attributes_height + operations_height
-
-            # Adjust element height if needed
-            height = [height, total_height].max
-
-            # Build style string for the group
-            group_style_attrs = []
-            group_style_attrs << "stroke-width:#{style[:stroke_width] || 1}"
-            group_style_attrs << "stroke-linecap:#{style[:stroke_linecap] ||
-              'round'}"
-            group_style_attrs << "stroke-linejoin:#{style[:stroke_linejoin] ||
-              'bevel'}"
-            group_style_attrs << "fill:#{style[:fill]}"
-            group_style_attrs << "fill-opacity:#{style[:fill_opacity] ||
-              '1.00'}"
-            group_style_attrs << "stroke:#{style[:stroke]}"
-            group_style_attrs << "stroke-opacity:#{style[:stroke_opacity] ||
-              '1.00'}"
-
-            # Build style string for compartment lines
-            line_style_attrs = []
-            line_style_attrs << "stroke-width:#{style[:compartment_width] || 1}"
-            line_style_attrs << "stroke-linecap:#{style[:stroke_linecap] ||
-              'round'}"
-            line_style_attrs << "stroke-linejoin:#{style[:stroke_linejoin] ||
-              'bevel'}"
-            line_style_attrs << "fill:#000000"
-            line_style_attrs << "fill-opacity:0.00"
-            line_style_attrs << "stroke:#{style[:stroke] || '#000000'}"
-            line_style_attrs << "stroke-opacity:#{style[:stroke_opacity] ||
-              '1.00'}"
-
-            <<~SVG
-              <g style="#{group_style_attrs.join(';')}">
-               <rect x="#{x}"
-                    y="#{y}"
-                    width="#{width}"
-                    height="#{height}"
-                    rx="#{style[:corner_radius] || 0.00}"
-                    shape-rendering="#{style[:shape_rendering] || 'auto'}"  />
-              </g>
-              <g style="#{line_style_attrs.join(';')}">
-              <!-- Name compartment -->
-              <path d="M #{x} #{y + name_height} L #{x + width} #{y + name_height}" shape-rendering="#{style[:shape_rendering] || 'auto'}"/>
-
-              <!-- Attributes compartment (if any) -->
-              #{render_attributes_compartment_separator(x, y, width, name_height, attributes_height, style)}
-
-              <!-- Operations compartment (if any) -->
-              #{render_operations_compartment_separator(x, y, width, name_height, attributes_height, operations_height, style)}
-              </g>
-            SVG
-          end
-
-          def render_label(style) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-            x = element[:x] || 0
-            y = element[:y] || 0
-            width = element[:width] || 120
-
-            # Calculate compartment heights
-            name_height = 25
-            attributes_height = calculate_attributes_height
-            calculate_operations_height
-
-            svg_content = +""
-
-            # Class name (centered in name compartment)
-            name_y = y + (name_height / 2) + 5
-            svg_content << render_text_element(
-              element[:name],
-              x + (width / 2),
-              name_y,
-              style,
-              "lutaml-diagram-class-name",
-              font_weight: style[:font_weight] || "700",
-              font_style: style[:font_style] || "italic",
-              font_family: style[:font_family] || "Cambria",
-              font_size: style[:font_size] || "7pt",
-            )
-
-            # Stereotype (above name if present)
-            if element[:stereotype]
-              stereotype_y = y + 15
-              svg_content << render_text_element(
-                "«#{element[:stereotype]}»",
-                x + (width / 2),
-                stereotype_y,
-                style,
-                "lutaml-diagram-class-stereotype",
-                font_weight: style[:stereotype_font_weight] || "0",
-                font_style: style[:stereotype_font_style] || "normal",
-                font_family: style[:stereotype_font_family] || "Cambria",
-                font_size: style[:stereotype_font_size] || "7pt",
-              )
-            end
-
-            # Attributes
-            if element[:attributes]&.any?
-              attr_y = y + name_height + 15
-              element[:attributes].each do |attr|
-                svg_content << render_text_element(
-                  format_attribute(attr),
-                  x + 5,
-                  attr_y,
-                  style,
-                  "lutaml-diagram-class-attribute",
-                  font_weight: style[:attribute_font_weight] || "0",
-                  font_style: style[:attribute_font_style] || "normal",
-                  font_family: style[:attribute_font_family] || "Cambria",
-                  font_size: style[:attribute_font_size] || "7pt",
-                  text_anchor: "start",
-                )
-                attr_y += 15
-              end
-            end
-
-            # Operations
-            if element[:operations]&.any?
-              op_y = y + name_height + attributes_height + 15
-              element[:operations].each do |op|
-                svg_content << render_text_element(
-                  format_operation(op),
-                  x + 5,
-                  op_y,
-                  style,
-                  "lutaml-diagram-class-operation",
-                  font_weight: style[:attribute_font_weight] || "0",
-                  font_style: style[:attribute_font_style] || "normal",
-                  font_family: style[:attribute_font_family] || "Cambria",
-                  font_size: style[:attribute_font_size] || "7pt",
-                  text_anchor: "start",
-                )
-                op_y += 15
-              end
-            end
-
-            # Build text style string
-            text_style_attrs = []
-            text_style_attrs << "stroke-width:1"
-            text_style_attrs << "stroke-linecap:round"
-            text_style_attrs << "stroke-linejoin:bevel"
-            text_style_attrs << "fill:#000000"
-            text_style_attrs << "fill-opacity:1.00"
-            text_style_attrs << "stroke:#000000"
-            text_style_attrs << "stroke-opacity:0.00"
-
-            "<g style=\"#{text_style_attrs.join(';')}\">\n#{svg_content}\n</g>"
-          end
-
-
-          def calculate_attributes_height
-            return 0 unless element[:attributes]&.any?
-
-            (element[:attributes].size * 15) + 10
-          end
-
-          def calculate_operations_height
-            return 0 unless element[:operations]&.any?
-
-            (element[:operations].size * 15) + 10
-          end
-
-          def render_attributes_compartment_separator( # rubocop:disable Metrics/ParameterLists
-            x, y, width, name_height, # rubocop:disable Naming/MethodParameterName
-            attributes_height, style
-          )
-            return "" if attributes_height.zero?
-
-            separator_y = y + name_height + attributes_height
-            <<~SVG
-              <path d="M #{x} #{separator_y} L #{x + width} #{separator_y}" shape-rendering="#{style[:shape_rendering] || 'auto'}"/>
-            SVG
-          end
-
-          def render_operations_compartment_separator( # rubocop:disable Metrics/ParameterLists
-            x, y, width, name_height, # rubocop:disable Naming/MethodParameterName
-            attributes_height, operations_height, style
-          )
-            return "" if operations_height.zero?
-
-            separator_y = y + name_height +
-              attributes_height + operations_height
-            <<~SVG
-              <path d="M #{x} #{separator_y} L #{x + width} #{separator_y}" shape-rendering="#{style[:shape_rendering] || 'auto'}"/>
-            SVG
-          end
-
-          def render_text_element(text, x, y, style, css_class, options = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/ParameterLists,Naming/MethodParameterName
-            return "" unless text
-
-            font_size = options[:font_size] || style[:font_size] || "7pt"
-            font_weight = options[:font_weight] || style[:font_weight] || "0"
-            font_style = options[:font_style] || style[:font_style] || "normal"
-            font_family = options[:font_family] || style[:font_family] ||
-              "Cambria"
-            fill_color = options[:fill] || style[:text_color] || "#000000"
-            text_anchor = options[:text_anchor] || "middle"
-
-            # Calculate text length approximation
-            # (EA uses this for precise positioning)
-            text_length = calculate_text_length(text, font_size)
-
-            # Build transform attribute if needed
-            transform_attr = ""
-            if options[:rotate] && options[:rotate] != 0
-              transform_attr = "transform=\"rotate(#{options[:rotate]} " \
-                               "#{x} #{y})\""
-            end
-
-            # Text stroke styling (EA uses this for text elements)
-            text_stroke = options[:text_stroke] ||
-              style[:text_stroke] ||
-              "#000000"
-            text_stroke_opacity = options[:text_stroke_opacity] ||
-              style[:text_stroke_opacity] || "0.00"
-            text_stroke_width = options[:text_stroke_width] ||
-              style[:text_stroke_width] || "0"
-
-            <<~SVG
-              <text x="#{x}.00"
-                    y="#{y}.00"
-                    text-anchor="#{text_anchor}"
-                    class="#{css_class}"
-                    #{"textLength=\"#{text_length}\"" if text_length.positive?}
-                    style="font-family:#{font_family}; font-weight:#{font_weight}; font-style:#{font_style}; font-size:#{font_size}; fill:#{fill_color};fill-opacity:1.00; stroke:#{text_stroke}; stroke-opacity:#{text_stroke_opacity} stroke-width:#{text_stroke_width}; white-space: pre;"
-                    xml:space="preserve"
-                    #{transform_attr}>
-                #{escape_text(text)}
-              </text>
-            SVG
-          end
-
-          def format_attribute(attribute)
-            return attribute unless attribute.is_a?(Hash)
-
-            visibility = visibility_symbol(attribute[:visibility])
-            name = attribute[:name] || ""
-            type = attribute[:type] ? ": #{attribute[:type]}" : ""
-
-            "#{visibility}#{name}#{type}"
-          end
-
-          def format_operation(operation)
-            return operation unless operation.is_a?(Hash)
-
-            visibility = visibility_symbol(operation[:visibility])
-            name = operation[:name] || ""
-            params = format_parameters(operation[:parameters] || [])
-            return_type = if operation[:return_type]
-                            ": #{operation[:return_type]}"
-                          else
-                            ""
-                          end
-
-            "#{visibility}#{name}(#{params})#{return_type}"
-          end
-
-          def format_parameters(parameters)
-            parameters.map do |param|
-              if param.is_a?(Hash)
-                "#{param[:name]}: #{param[:type]}"
-              else
-                param.to_s
-              end
-            end.join(", ")
-          end
-
-          def visibility_symbol(visibility)
-            case visibility&.to_s
-            when "public" then "+"
-            when "private" then "-"
-            when "protected" then "#"
-            when "package" then "~"
-            else ""
-            end
-          end
-
-          # Parse font size string to get numeric value
-          def parse_font_size(font_size)
-            return 7 if font_size.nil? # default size
-
-            # Extract numeric part from font size string (e.g., "7pt" -> 7)
-            if font_size.is_a?(String)
-              match = font_size.match(/(\d+(?:\.\d+)?)/)
-              match ? match[1].to_f : 7
-            else
-              font_size.to_f
-            end
-          end
-
-          # Calculate approximate text length in pixels
-          # (EA uses this for precise positioning)
-          def calculate_text_length(text, font_size)
-            return 0 unless text
-
-            # Simple approximation: average character width * text length
-            # This is a rough approximation
-            # - in a real implementation, we'd use actual font metrics
-            font_size_num = parse_font_size(font_size)
-            text.to_s.length * (font_size_num * 0.6).to_i
-          end
-        end
-      end
-    end
-end

data/lib/ea/diagram/element_renderers/connector_renderer.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Diagram
-    module ElementRenderers
-      # Renderer for connector elements (relationships)
-      class ConnectorRenderer < BaseRenderer
-        attr_reader :source_element, :target_element
-
-        def initialize(connector, style_resolver, source_element = nil,
-                       target_element = nil)
-          super(connector, style_resolver)
-          @source_element = source_element
-          @target_element = target_element
-        end
-
-        # Render the connector as SVG path
-        # @return [String] SVG content for the connector
-        def render
-          path_builder = PathBuilder.new(element, source_element,
-                                         target_element)
-          path_data = path_builder.build_path
-
-          style = style_resolver.resolve_connector_style(element)
-
-          css_classes = ["lutaml-diagram-connector",
-                         "lutaml-diagram-connector-#{element[:type]}"]
-
-          <<~SVG
-            <path d="#{path_data}"
-                  class="#{css_classes.join(' ')}"
-                  style="#{style_to_css(style)}"
-                  data-connector-id="#{element[:id]}"
-                  data-connector-type="#{element[:type]}"
-                  marker-end="url(#arrowhead)" />
-          SVG
-        end
-      end
-    end
-  end
-end

data/lib/ea/diagram/element_renderers/package_renderer.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Diagram
-      module ElementRenderers
-        # Renderer for UML package elements
-        class PackageRenderer < BaseRenderer
-          def render_shape(style) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
-            x = element[:x] || 0
-            y = element[:y] || 0
-            width = element[:width] || 120
-            height = element[:height] || 80
-
-            # Package tab height
-            tab_height = 20
-
-            # Draw package shape with tab
-            <<~SVG
-              <!-- Main package body -->
-              <polygon points="#{x},#{y + tab_height} #{x + width},#{y + tab_height} #{x + width},#{y + height} #{x},#{y + height}"
-                       fill="#{style[:fill]}"
-                       stroke="#{style[:stroke]}"
-                       stroke-width="#{style[:stroke_width] || 2}"
-                       class="lutaml-diagram-package-shape" />
-
-              <!-- Package tab -->
-              <polygon points="#{x + 10},#{y + tab_height} #{x + 50},#{y + tab_height} #{x + 50},#{y} #{x + 10},#{y}"
-                       fill="#{style[:fill]}"
-                       stroke="#{style[:stroke]}"
-                       stroke-width="#{style[:stroke_width] || 2}"
-                       class="lutaml-diagram-package-tab" />
-            SVG
-          end
-
-          def render_label(style) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
-            x = element[:x] || 0
-            y = element[:y] || 0
-
-            # Package name positioned in the tab area
-            tab_height = 20
-            text_x = x + 30 # Center in the tab
-            text_y = y + (tab_height / 2) + 5
-
-            <<~SVG
-              <text x="#{text_x}"
-                    y="#{text_y}"
-                    text-anchor="middle"
-                    dominant-baseline="middle"
-                    font-family="#{style[:font_family]}"
-                    font-size="#{style[:font_size]}"
-                    font-weight="#{style[:font_weight] || 'bold'}"
-                    fill="#{style[:text_color] || '#000000'}"
-                    class="lutaml-diagram-package-name">
-                #{escape_text(element[:name])}
-              </text>
-            SVG
-          end
-        end
-      end
-    end
-end

data/lib/ea/diagram/element_renderers.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Ea
-  module Diagram
-    module ElementRenderers
-      autoload :BaseRenderer,
-               "ea/diagram/element_renderers/base_renderer"
-      autoload :ClassRenderer,
-               "ea/diagram/element_renderers/class_renderer"
-      autoload :PackageRenderer,
-               "ea/diagram/element_renderers/package_renderer"
-      autoload :ConnectorRenderer,
-               "ea/diagram/element_renderers/connector_renderer"
-
-      # Registry for element type to renderer class mapping.
-      # New element types can be added without modifying SvgRenderer.
-      class RendererRegistry
-        def initialize
-          @renderers = {}
-        end
-
-        def register(element_type, renderer_class)
-          @renderers[element_type.to_s] = renderer_class
-        end
-
-        def renderer_for(element_type)
-          @renderers[element_type.to_s]
-        end
-
-        def registered?(element_type)
-          @renderers.key?(element_type.to_s)
-        end
-      end
-
-      # Default registry with built-in renderers
-      DEFAULT_REGISTRY = RendererRegistry.new.tap do |r|
-        r.register("class", ClassRenderer)
-        r.register("datatype", ClassRenderer)
-        r.register("package", PackageRenderer)
-      end
-    end
-  end
-end