ea 0.4.0 → 0.5.0

data/lib/ea/svg/ea_emitter/layer_sequencer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Sequences SVG layer output in EA's canonical order:
+      #
+      #   1. Background <g>
+      #   2. (optional) Diagram frame: border + tab + label
+      #   3. Per-element groups (shape, header, divider, attrs)
+      #   4. Connector + marker groups (merged by style)
+      #   5. Labels <g>
+      #
+      # Reads diagram.theme once and passes to all child renderers
+      # so theme settings (font, colors, stroke width) apply
+      # uniformly across the entire SVG output.
+      #
+      # Document delegates the layer assembly here so the Document
+      # class shrinks to SVG envelope construction.
+      class LayerSequencer
+        DEFAULT_STROKE_WIDTH = 2
+
+        attr_reader :diagram, :model_index, :canvas, :frame_enabled, :theme,
+                    :document
+
+        def initialize(diagram, model_index:, canvas:, frame: false, document: nil)
+          @diagram = diagram
+          @model_index = model_index
+          @canvas = canvas
+          @frame_enabled = frame
+          @theme = diagram.theme
+          @document = document
+        end
+
+        def layers
+          layers = [Background.render(canvas)]
+          layers += frame_layers if frame_enabled
+          layers += element_layers
+          layers += connector_layers
+          layers << labels_layer
+          layers << ghost_labels_layer
+          layers
+        end
+
+        private
+
+        def frame_layers
+          DiagramFrame.new(canvas: canvas, theme: theme).layers(diagram).map(&:to_svg)
+        end
+
+        def element_layers
+          Elements.new(diagram, model_index: model_index, canvas: canvas,
+                        document: document).groups
+        end
+
+        def connector_layers
+          connector_layers_raw = Connectors.new(diagram, canvas: canvas,
+                                                  grouped: true,
+                                                  stroke_width: DEFAULT_STROKE_WIDTH).layers
+          marker_layers_raw = Markers.new(diagram, model_index: model_index,
+                                           canvas: canvas, grouped: true,
+                                           stroke_width: DEFAULT_STROKE_WIDTH).layers
+          merge_layers_by_style(connector_layers_raw + marker_layers_raw).map(&:to_svg)
+        end
+
+        def labels_layer
+          Labels.new(diagram, canvas: canvas, model_index: model_index,
+                      theme: theme, document: document).render
+        end
+
+        def ghost_labels_layer
+          GhostLabels.new(diagram, canvas: canvas).render
+        end
+
+        def merge_layers_by_style(layers)
+          merged = {}
+          layers.each do |layer|
+            if merged[layer.style_key]
+              merged[layer.style_key] = Layer.new(
+                style_key: layer.style_key,
+                style: layer.style,
+                body: "#{merged[layer.style_key].body}\n  #{layer.body}"
+              )
+            else
+              merged[layer.style_key] = layer
+            end
+          end
+          merged.values
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/marker/arrow_path.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Marker
+        # Navigability arrow at the target end of an association.
+        # Rendered as a `<path>` (not polygon) sharing style with the
+        # connector line. When both ends are navigable
+        # (bidirectional association), EA renders a separate arrow at
+        # each end.
+        class ArrowPath < Kind
+          def self.handles?(effective_type)
+            effective_type == "Association"
+          end
+
+          def self.specs_for(connector, source, target, before_target,
+                             after_source, relationship: nil)
+            return bidirectional_specs(source, target, before_target,
+                                       after_source) if bidirectional?(connector)
+
+            whole_end_at_source = whole_end_at_source?(connector)
+            anchor = whole_end_at_source ? target : source
+            base = whole_end_at_source ? before_target : after_source
+            [Registry::Spec.new(shape: :arrow, anchor: anchor, base: base)]
+          end
+
+          # EA marks truly bidirectional associations with
+          # direction="Bi-Directional" on t_connector. These get a
+          # separate arrow at each end. All other directions render
+          # a single arrow at the navigable end.
+          def self.bidirectional?(connector)
+            connector.direction == "Bi-Directional"
+          end
+          private_class_method :bidirectional?
+
+          def self.bidirectional_specs(source, target, before_target, after_source)
+            [
+              Registry::Spec.new(shape: :arrow, anchor: source,
+                                 base: after_source),
+              Registry::Spec.new(shape: :arrow, anchor: target,
+                                 base: before_target)
+            ]
+          end
+          private_class_method :bidirectional_specs
+        end
+      end
+    end
+  end
+end
+
+Ea::Svg::EaEmitter::Marker::Registry.register(Ea::Svg::EaEmitter::Marker::ArrowPath)

data/lib/ea/svg/ea_emitter/marker/diamond.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Marker
+        # Diamond marker at the whole end of an aggregation or
+        # composition, PLUS a navigability arrow at the part end
+        # when the connector's direction is "Destination -> Source".
+        # Reference SVGs confirm EA emits BOTH markers for
+        # reverse-direction aggregations on the plateau: the diamond
+        # distinguishes aggregation from association, the arrow shows
+        # navigability direction. Forward-direction ("Source ->
+        # Destination") aggregations get the diamond only — verified
+        # against basic.qea's "Two Level Class Composition Hierarchy"
+        # diagram, where the reference SVG has 17 diamonds and 0
+        # arrows.
+        class Diamond < Kind
+          def self.handles?(effective_type)
+            effective_type == "Aggregation" || effective_type == "Composition"
+          end
+
+          def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
+            whole_end_at_source = whole_end_at_source?(connector)
+            whole_anchor = whole_end_at_source ? source : target
+            whole_base = whole_end_at_source ? after_source : before_target
+            specs = [Registry::Spec.new(shape: :diamond,
+                                        anchor: whole_anchor,
+                                        base: whole_base)]
+            return specs unless navigable_part_end?(connector)
+
+            part_anchor = whole_end_at_source ? target : source
+            part_base = whole_end_at_source ? before_target : after_source
+            specs << Registry::Spec.new(shape: :arrow,
+                                        anchor: part_anchor,
+                                        base: part_base)
+            specs
+          end
+
+          # EA renders the navigability arrow at the part end of an
+          # aggregation only when the connector's direction is
+          # "Destination -> Source" — the conventional EA encoding
+          # for "part -> whole" with navigability back to the whole.
+          # Forward-direction aggregations ("Source -> Destination")
+          # omit the arrow: the diamond already communicates the
+          # aggregation semantic and the destination is not
+          # explicitly navigable.
+          def self.navigable_part_end?(connector)
+            connector.direction == "Destination -> Source"
+          end
+        end
+      end
+    end
+  end
+end
+
+Ea::Svg::EaEmitter::Marker::Registry.register(Ea::Svg::EaEmitter::Marker::Diamond)

data/lib/ea/svg/ea_emitter/marker/kind.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Marker
+        # Base class for marker kinds. Subclasses declare which
+        # connector types they handle and produce Spec instances
+        # describing the marker geometry.
+        class Kind
+          # Returns true if this kind handles the given effective
+          # connector type (e.g. "Aggregation", "Generalization").
+          def self.handles?(_effective_type)
+            false
+          end
+
+          # Returns an Array of Spec instances describing the
+          # markers to emit. Each Spec has :shape, :anchor, :base.
+          # `relationship` is the resolved relationship model (e.g.
+          # Association) when available, nil otherwise.
+          def self.specs_for(_connector, _source, _target,
+                             _before_target, _after_source, relationship: nil)
+            []
+          end
+
+          # Common helper: "destination → source" direction means
+          # the whole end of an aggregation is at the target end.
+          def self.whole_end_at_source?(connector)
+            connector.direction != "Destination -> Source"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/marker/open_triangle.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Marker
+        # Open triangle marker for UML generalization, realization,
+        # and dependency. White-filled 3-point polygon at the
+        # general / supplier end.
+        class OpenTriangle < Kind
+          def self.handles?(effective_type)
+            %w[Generalization Realization Dependency].include?(effective_type)
+          end
+
+          def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
+            whole_end_at_source = whole_end_at_source?(connector)
+            anchor = whole_end_at_source ? target : source
+            base = whole_end_at_source ? before_target : after_source
+            [Registry::Spec.new(shape: :triangle, anchor: anchor, base: base)]
+          end
+        end
+      end
+    end
+  end
+end
+
+Ea::Svg::EaEmitter::Marker::Registry.register(Ea::Svg::EaEmitter::Marker::OpenTriangle)

data/lib/ea/svg/ea_emitter/marker/package_import.rb

@@ -0,0 +1,39 @@
+# frozen_string: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Marker
+        # PackageImport marker for «import» connectors between
+        # packages. EA draws a closed trapezoid silhouette at the
+        # source end (the importing package) and an open V-arrow at
+        # the target end (the imported package) — but ONLY when the
+        # connector's geometry string carries explicit SX/SY offset
+        # fields. Auto-routed connectors (no SX/SY) render as a
+        # plain solid line with no package_anchor marker.
+        #
+        # Verified against both QEAs (output by the same EA run):
+        #   - basic.qea Package Imports: SX=0;SY=0 present → marker
+        #   - plateau Urban Planning ADE2: SX/SY absent → no marker
+        class PackageImport < Kind
+          def self.handles?(effective_type)
+            effective_type == "Package"
+          end
+
+          def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
+            return [] unless connector.has_geometry_offsets
+
+            [
+              Registry::Spec.new(shape: :package_anchor,
+                                 anchor: source, base: after_source),
+              Registry::Spec.new(shape: :arrow, anchor: target,
+                                 base: before_target)
+            ]
+          end
+        end
+      end
+    end
+  end
+end
+
+Ea::Svg::EaEmitter::Marker::Registry.register(Ea::Svg::EaEmitter::Marker::PackageImport)

data/lib/ea/svg/ea_emitter/marker/plus.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Marker
+        # Plus-symbol marker at the contained end of a Nesting
+        # connector. EA renders a "+" (16x16, two crossed lines)
+        # at the end pointing INTO the container.
+        #
+        # Path encoding (two sub-paths in one <path>):
+        #
+        #   M cx cy-8 L cx cy+8    (vertical arm, 16 tall)
+        #   M cx+8 cy L cx-8 cy    (horizontal arm, 16 wide)
+        #
+        # cx, cy = plus center, anchored at the source-end waypoint.
+        class Plus < Kind
+          ARM_LENGTH = 8
+
+          def self.handles?(effective_type)
+            effective_type == "Nesting"
+          end
+
+          def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
+            # Plus is at the contained (child) end. EA's convention:
+            # source end is the child, target end is the parent.
+            # Default to source unless the connector direction
+            # reverses the ends.
+            whole_end_at_source = whole_end_at_source?(connector)
+            anchor = whole_end_at_source ? source : target
+            base = whole_end_at_source ? after_source : before_target
+            [Registry::Spec.new(shape: :plus, anchor: anchor, base: base)]
+          end
+        end
+      end
+    end
+  end
+end
+
+Ea::Svg::EaEmitter::Marker::Registry.register(Ea::Svg::EaEmitter::Marker::Plus)

data/lib/ea/svg/ea_emitter/marker/registry.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Marker
+        # Dispatches a connector to the first registered Kind that
+        # handles its effective type. New kinds are added by calling
+        # `Registry.register(MyKind)` — no modification of existing
+        # code required (OCP).
+        class Registry
+          @kinds = []
+
+          class << self
+            attr_reader :kinds
+
+            def register(kind)
+              @kinds << kind
+            end
+
+            def specs_for(connector, effective_type, source, target,
+                          before_target, after_source, relationship: nil)
+              # Lazy: ensure built-in markers are registered on first
+              # query. The Marker module's autoload declaration means
+              # the marker files only load when referenced.
+              Marker.ensure_builtins_registered! if defined?(Marker)
+              kind = @kinds.find { |k| k.handles?(effective_type) }
+              return [] unless kind
+
+              kind.specs_for(connector, source, target, before_target,
+                             after_source, relationship: relationship)
+            end
+          end
+
+          # Spec carries the geometry recipe for a single marker
+          # emission. Renderers consume it.
+          Spec = Struct.new(:shape, :anchor, :base, keyword_init: true)
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/marker.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Marker dispatch registry. Each `Kind` subclass handles one
+      # connector type (or family) and produces the marker specs.
+      # Adding a new marker kind = creating a class + registering
+      # it (OCP).
+      module Marker
+        autoload :Kind, "ea/svg/ea_emitter/marker/kind"
+        autoload :Registry, "ea/svg/ea_emitter/marker/registry"
+        autoload :Diamond, "ea/svg/ea_emitter/marker/diamond"
+        autoload :OpenTriangle, "ea/svg/ea_emitter/marker/open_triangle"
+        autoload :ArrowPath, "ea/svg/ea_emitter/marker/arrow_path"
+        autoload :Plus, "ea/svg/ea_emitter/marker/plus"
+        autoload :PackageImport, "ea/svg/ea_emitter/marker/package_import"
+
+        # Built-in marker kinds register themselves at the bottom of
+        # their respective files. Referencing each constant here
+        # forces autoload, which runs the per-file registration lines.
+        # Diamond first so "Aggregation" wins over generic fallback.
+        def self.ensure_builtins_registered!
+          # Touch the constants to trigger autoload + registration.
+          # Each constant is autoloaded, so merely referencing it
+          # causes the file to load. Registration lines at the
+          # bottom of each file then add the kind to the Registry.
+          Diamond
+          OpenTriangle
+          Plus
+          ArrowPath
+          PackageImport
+        end
+      end
+    end
+  end
+end