ea 0.4.0 → 0.5.1

data/lib/ea/svg/ea_emitter/compartment/package_contents.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Package-contents compartment. Renders the package's child
+        # classifiers and sub-packages as a list of "+ Name" rows in
+        # the body, matching EA's package-on-diagram rendering. Each
+        # row also draws a small per-type icon to the left of the
+        # text (Enumeration gets a list-style icon; other classifiers
+        # get the "folded paper" silhouette).
+        module PackageContents
+          ROW_HEIGHT = 16
+          ICON_X_OFFSET = 5
+          TEXT_X_OFFSET = 23
+
+          module_function
+
+          def render(context)
+            rows = context.package_content_lines
+            return nil if rows.nil? || rows.empty?
+
+            bounds = context.bounds
+            first_y = context.geometry.attr_first_y
+            blocks = rows.each_with_index.flat_map do |row, idx|
+              y_top = first_y - 11 + (idx * ROW_HEIGHT)
+              y_text = first_y + (idx * ROW_HEIGHT)
+              [
+                icon_block(bounds, y_top, row.kind),
+                text_block(bounds, y_text, row.name, context)
+              ]
+            end
+            wrap_group(blocks.join("\n"))
+          end
+
+          def wrap_group(body)
+            %(<g style="#{group_style}">\n#{body}\n</g>)
+          end
+          module_function :wrap_group
+
+          def group_style
+            "stroke-width:1;stroke-linecap:square;stroke-linejoin:bevel; " \
+              "fill-opacity:1.00; stroke-opacity:1.00"
+          end
+          module_function :group_style
+
+          def icon_block(bounds, y_top, kind)
+            Element::RowIconRenderer.render(
+              x_pos: bounds.x + ICON_X_OFFSET,
+              y_pos: y_top,
+              kind: kind || :default
+            )
+          end
+          module_function :icon_block
+
+          def text_block(bounds, y, name, context)
+            TextRenderer.new(
+              content: "+ #{name}",
+              x: bounds.x + TEXT_X_OFFSET,
+              y: y,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit,
+              fill: context.theme.attribute_text_color
+            ).to_svg
+          end
+          module_function :text_block
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/compartment/package_from_parent.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Renders the "(from ParentPackage)" italic subtitle inside
+        # a Package element's body. EA emits this when a package is
+        # placed on a diagram whose own package is NOT the package's
+        # parent — the subtitle shows the package's actual parent
+        # context so the reader can locate it in the model tree.
+        #
+        # Format: italic, small font, centered horizontally in the
+        # element body, positioned near the bottom of the body.
+        module PackageFromParent
+          Y_OFFSET_FROM_BOTTOM = 5
+
+          module_function
+
+          def render(context)
+            pkg = context.model_element
+            return nil unless pkg.is_a?(Ea::Model::Package)
+
+            parent_name = parent_name_for(pkg, context)
+            return nil if parent_name.nil? || parent_name.empty?
+
+            subtitle = "(from #{parent_name})"
+            bounds = context.bounds
+            fill = context.theme.attribute_text_color
+            y = bounds.y + bounds.height - Y_OFFSET_FROM_BOTTOM
+            estimated_width = subtitle.length * context.size * 0.5
+            x = bounds.x + (bounds.width - estimated_width) / 2.0
+            text = TextRenderer.new(
+              content: subtitle, x: x, y: y,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, fill: fill,
+              style: "italic"
+            ).to_svg
+            wrap(text, fill)
+          end
+
+          # Resolves the package's parent's name via the model index.
+          # Returns nil when:
+          #   - the package has no parent
+          #   - the parent IS the diagram's own package (already in context)
+          #   - the parent is ALSO placed on the current diagram
+          #   - every placed Package on the diagram shares the same
+          #     parent_id (diagram is implicitly about that parent's
+          #     children — EA omits the subtitle as redundant)
+          #   - the parent's name equals the placed package's name
+          #     (e.g. an inner "3D都市モデル" nested inside an outer
+          #     "3D都市モデル" — the subtitle would be tautological)
+          #   - the diagram's name contains any placed Package's name
+          #     as a substring (the diagram is implicitly "about" that
+          #     package — subtitles would be redundant). Verified
+          #     against plateau's "3D都市モデル応用スキーマと他のスキーマとの関係"
+          #     diagram, which contains the placed name "3D都市モデル"
+          #     and renders 0 subtitles in EA's reference.
+          def parent_name_for(pkg, context)
+            parent_id = pkg.parent_id
+            return nil if parent_id.nil? || parent_id.empty?
+            return nil if parent_id == context.diagram&.package_id
+            return nil if parent_on_diagram?(parent_id, context)
+            return nil if uniform_package_parent?(context)
+            return nil if diagram_name_contains_placed_package?(context)
+
+            parent = context.model_index_for(parent_id)
+            return nil unless parent.is_a?(Ea::Model::Package)
+            return nil if parent.name.to_s == pkg.name.to_s
+
+            parent.name.to_s.empty? ? nil : parent.name
+          end
+          module_function :parent_name_for
+
+          # Returns true when the diagram has 2+ placed Packages and
+          # every placed Package shares the same parent_id. EA treats
+          # such diagrams as "children of X" overviews and suppresses
+          # the (from X) subtitle on every element.
+          def uniform_package_parent?(context)
+            diagram = context.diagram
+            return false unless diagram && context.model_index
+
+            placed_pkg_parents = (diagram.elements || []).filter_map do |el|
+              me = context.model_index[el.model_element_ref]
+              next nil unless me.is_a?(Ea::Model::Package)
+
+              me.parent_id
+            end
+            placed_pkg_parents.size > 1 && placed_pkg_parents.uniq.size == 1
+          end
+          module_function :uniform_package_parent?
+
+          def parent_on_diagram?(parent_id, context)
+            diagram = context.diagram
+            return false unless diagram
+
+            (diagram.elements || []).any? do |e|
+              e.model_element_ref == parent_id
+            end
+          end
+          module_function :parent_on_diagram?
+
+          # Returns true when the diagram's name contains any placed
+          # Package's name as a substring. EA omits all subtitles in
+          # such diagrams — the name itself signals which package is
+          # the subject, making subtitles redundant.
+          def diagram_name_contains_placed_package?(context)
+            diagram = context.diagram
+            return false unless diagram && context.model_index
+
+            name = diagram.name.to_s
+            return false if name.empty?
+
+            (diagram.elements || []).any? do |el|
+              me = context.model_index[el.model_element_ref]
+              next false unless me.is_a?(Ea::Model::Package)
+
+              pkg_name = me.name.to_s
+              !pkg_name.empty? && name.include?(pkg_name)
+            end
+          end
+          module_function :diagram_name_contains_placed_package?
+
+          def wrap(body, fill)
+            group_style = "stroke-width:1;stroke-linecap:round;" \
+                          "stroke-linejoin:bevel; fill:#{fill};" \
+                          "fill-opacity:1.00; stroke:#000000;" \
+                          " stroke-opacity:0.00"
+            %(<g style="#{group_style}">\n#{body}\n</g>)
+          end
+          module_function :wrap
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/compartment/shape.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Element shape: stroked rect for classifiers, folder
+        # silhouette for packages, note silhouette for notes.
+        module Shape
+          module_function
+
+          def render(context)
+            if legend?(context)
+              Element::LegendRenderer.render(
+                context.bounds,
+                legend: context.model_element.legend,
+                family: context.family,
+                canvas: context.canvas
+              )
+            elsif context.model_element.is_a?(Ea::Model::Package) ||
+                  context.model_element.is_a?(Ea::Model::Note)
+              label = package_label(context.model_element)
+              stereotype = package_stereotype(context.model_element)
+              Element::PackageShapeRenderer.render(
+                context.bounds,
+                fill: context.fill, stroke: context.stroke,
+                stroke_width: context.stroke_width,
+                label: label,
+                stereotype: stereotype,
+                family: context.family, size: context.size,
+                size_unit: context.size_unit,
+                text_fill: context.text_fill
+              )
+            elsif hand_draw?(context)
+              Element::HandDrawShapeRenderer.render(
+                context.bounds,
+                fill: context.fill, stroke: context.stroke,
+                stroke_width: context.stroke_width
+              )
+            else
+              Element::ShapeRenderer.render(
+                context.bounds,
+                fill: context.fill, stroke: context.stroke,
+                stroke_width: context.stroke_width
+              )
+            end
+          end
+
+          # A Text element with LegendOpts= renders as the legend
+          # block rather than a folder silhouette. Dispatch on the
+          # presence of the attached Legend payload.
+          def legend?(context)
+            context.model_element.is_a?(Ea::Model::Note) &&
+              context.model_element.legend
+          end
+
+          # HandDraw=1 in the diagram StyleEx switches every element
+          # to EA's hand-drawn wavy silhouette.
+          def hand_draw?(context)
+            context.diagram && context.diagram.hand_draw
+          end
+
+          def package_label(model_element)
+            model_element.name.to_s
+          end
+
+          # EA renders a package's applied stereotype above the name
+          # inside the tab area when one is set. Returns nil when no
+          # stereotype is applied (the common case).
+          def package_stereotype(model_element)
+            return nil unless model_element.is_a?(Ea::Model::Package)
+
+            refs = model_element.stereotype_refs
+            return nil unless refs&.any?
+
+            refs.first.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/compartment/stereotype_icon.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Stereotype decorator icon compartment. Emits the small
+        # symbolic polygon that EA renders inside an element's body
+        # when a stereotype provides a custom icon (FeatureType
+        # diamond, Type polygon, etc.). Delegates to
+        # Element::StereotypeIconRenderer.
+        #
+        # Rendered after the header so the icon sits inside the
+        # element body below the stereotype label.
+        module StereotypeIcon
+          module_function
+
+          def render(context)
+            return nil unless context.classifier
+
+            svg = Element::StereotypeIconRenderer.render(
+              classifier: context.classifier,
+              bounds: context.bounds,
+              canvas: context.canvas
+            )
+            svg.empty? ? nil : svg
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/compartment/tagged_values.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Tagged value compartment. Skipped when no tagged values
+        # or when geometry cannot fit them.
+        module TaggedValues
+          DEFAULT_TEXT_COLOR = "#000000"
+
+          module_function
+
+          def render(context)
+            return nil unless context.tagged_values.any?
+            return nil unless context.geometry.tagged_value_first_y
+
+            Element::TaggedValueRenderer.render(
+              context.tagged_values,
+              bounds: context.bounds,
+              first_y: context.geometry.tagged_value_first_y,
+              family: context.family, size: context.size,
+              fill: DEFAULT_TEXT_COLOR
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Compartment pipeline. Each Compartment is a small,
+      # single-purpose renderer that decides whether it applies to
+      # the current RenderContext and, if so, emits its SVG layer.
+      #
+      # Adding a new compartment = adding a class to `COMPARTMENTS`.
+      # The Elements orchestrator does not change — OCP-friendly.
+      module Compartment
+        autoload :Shape, "ea/svg/ea_emitter/compartment/shape"
+        autoload :NoteBody, "ea/svg/ea_emitter/compartment/note_body"
+        autoload :Header, "ea/svg/ea_emitter/compartment/header"
+        autoload :HeaderDivider, "ea/svg/ea_emitter/compartment/header_divider"
+        autoload :StereotypeIcon, "ea/svg/ea_emitter/compartment/stereotype_icon"
+        autoload :Attributes, "ea/svg/ea_emitter/compartment/attributes"
+        autoload :Operations, "ea/svg/ea_emitter/compartment/operations"
+        autoload :EnumLiterals, "ea/svg/ea_emitter/compartment/enum_literals"
+        autoload :TaggedValues, "ea/svg/ea_emitter/compartment/tagged_values"
+        autoload :Constraints, "ea/svg/ea_emitter/compartment/constraints"
+        autoload :PackageContents, "ea/svg/ea_emitter/compartment/package_contents"
+        autoload :InstanceUnderline, "ea/svg/ea_emitter/compartment/instance_underline"
+        autoload :InstanceSlots, "ea/svg/ea_emitter/compartment/instance_slots"
+        autoload :NoteText, "ea/svg/ea_emitter/compartment/note_text"
+        autoload :PackageFromParent, "ea/svg/ea_emitter/compartment/package_from_parent"
+
+        # Order matters: EA emits compartments top-to-bottom inside
+        # each element group.
+        ALL = [
+          Shape,
+          NoteBody,
+          Header,
+          HeaderDivider,
+          StereotypeIcon,
+          Attributes,
+          Operations,
+          EnumLiterals,
+          TaggedValues,
+          Constraints,
+          PackageContents,
+          InstanceSlots,
+          NoteText,
+          PackageFromParent,
+          InstanceUnderline
+        ].freeze
+
+        module_function
+
+        # Renders every applicable compartment for the context.
+        # Returns an Array of SVG strings (some may be nil; the
+        # caller compacts).
+        def render_all(context)
+          ALL.map { |compartment| compartment.render(context) }
+        end
+      end
+    end
+  end
+end

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

@@ -3,28 +3,55 @@
 module Ea
   module Svg
     module EaEmitter
-      # Emits the connectors layer: for each DiagramConnector, emits
-      # one <g> containing the <path d="M x y L x2 y2..."/> through
-      # its waypoints. Markers (arrowheads, diamonds) are emitted
-      # separately by the Markers emitter.
+      # Emits connector line `<path>` elements grouped per line-style.
+      # Returns an Array of `Layer` structs.
+      #
+      # Default mode (`grouped: true`) consolidates all same-style
+      # paths into ONE `<g>` element — matching EA's encoding for
+      # diagrams with many similarly-styled connectors.
+      #
+      # Pass `grouped: false` for per-connector grouping (one `<g>`
+      # per line, used when strict per-entity interleaving with
+      # markers is required).
       class Connectors
-        attr_reader :diagram
+        LINE_STYLE_KEY = :connector_line
 
-        def initialize(diagram)
+        attr_reader :diagram, :canvas, :grouped, :stroke_width
+
+        def initialize(diagram, canvas: nil, grouped: true, stroke_width: 2)
           @diagram = diagram
+          @canvas = canvas
+          @grouped = grouped
+          @stroke_width = stroke_width
         end
 
-        def render
+        def layers
           paths = visible_connectors.filter_map { |c| path_for(c) }
-          return "" if paths.empty?
+          return [] if paths.empty?
+
+          if grouped
+            [Layer.new(style_key: LINE_STYLE_KEY, style: line_style,
+                       body: paths.join("\n  "))]
+          else
+            paths.map do |path|
+              Layer.new(style_key: LINE_STYLE_KEY, style: line_style, body: path)
+            end
+          end
+        end
 
-          %(<g style="stroke-width:2;stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00">\n#{paths.join("\n")}\n</g>)
+        def line_style
+          "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+        end
+
+        # Backwards-compatible render — joins all layers' `<g>`.
+        def render
+          layers.map(&:to_svg).join("\n")
         end
 
         private
 
         def visible_connectors
-          (diagram.connectors || []).reject(&:hidden)
+          (diagram.connectors || []).select(&:renderable?)
         end
 
         def path_for(connector)
@@ -32,9 +59,10 @@ module Ea
           return nil if pts.size < 2
 
           d = pts.each_with_index.map do |p, idx|
-            "#{idx.zero? ? 'M' : 'L'} #{p[0]} #{p[1]}"
+            x, y = translate_point(p)
+            "#{idx.zero? ? 'M' : 'L'} #{Canvas.coord(x)} #{Canvas.coord(y)}"
           end.join(" ")
-          %(  <path d="#{d}" shape-rendering="auto"/>)
+          %(<path d="#{d}" shape-rendering="auto"/>)
         end
 
         def waypoints_for(connector)
@@ -44,6 +72,12 @@ module Ea
             [wp.position.x, wp.position.y]
           end
         end
+
+        def translate_point(p)
+          return p unless @canvas
+
+          [@canvas.translate_x(p[0]), @canvas.translate_y(p[1])]
+        end
       end
     end
   end

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Emits the diagram frame: outer border + name tab. EA renders
+      # every diagram with a 1px black border forming a rectangle
+      # inset 6px from the canvas edge, plus a "tab" polygon in the
+      # upper-left containing the diagram type + name text.
+      #
+      # Layout:
+      #   ┌───┐
+      #   │tab│──────────────────┐
+      #   └───┘                  │
+      #                          │
+      #   (diagram contents)     │
+      #                          │
+      #   ┌──────────────────────┘
+      #
+      # Format observed in EA reference SVGs:
+      #   <g style="...stroke-width:1;stroke-linecap:square;
+      #              stroke-linejoin:miter; fill:#000000;
+      #              fill-opacity:0.00; stroke:#000000;
+      #              stroke-opacity:1.00">
+      #     <path d="M 6 6 L 6 H-6 W-6 W-6 6 L 6 6"/>
+      #   </g>
+      #   <g style="...fill:#FFFFFF;...">
+      #     <polygon points="6 26 X 26 X+13 12 X+13 6 6 6 6 26"/>
+      #   </g>
+      #   <g style="...">
+      #     <text x="11" y="19" ...>class DiagramName</text>
+      #   </g>
+      class DiagramFrame
+        attr_reader :canvas, :theme
+
+        def initialize(canvas:, theme: nil)
+          @canvas = canvas
+          @theme = theme || Ea::Theme::Registry.default
+        end
+
+        def layers(diagram)
+          return [] if canvas.nil?
+
+          [
+            border_layer(canvas),
+            tab_layer(canvas, diagram),
+            tab_label_layer(canvas, diagram)
+          ].compact
+        end
+
+        private
+
+        def border_layer(canvas)
+          d = border_path_d(canvas)
+          body = %(<path d="#{d}" shape-rendering="auto"/>)
+          Layer.new(style_key: :frame_border, style: BORDER_STYLE, body: body)
+        end
+
+        def tab_layer(canvas, diagram)
+          points = tab_points(canvas, diagram)
+          body = %(<polygon points="#{points}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+          Layer.new(style_key: :frame_tab, style: TAB_STYLE, body: body)
+        end
+
+        def tab_label_layer(canvas, diagram)
+          label = tab_label(diagram)
+          return nil unless label
+
+          body = build_label_text(label)
+          Layer.new(style_key: :frame_label, style: LABEL_STYLE, body: body)
+        end
+
+        def border_path_d(canvas)
+          inset = theme.frame.inset
+          right = canvas.width - inset
+          bottom = canvas.height - inset
+          "M #{inset} #{inset} L #{inset} #{bottom} L #{right} #{bottom} L #{right} #{inset} L #{inset} #{inset}"
+        end
+
+        def tab_points(canvas, diagram)
+          label_width = tab_label_width(diagram)
+          x1 = theme.frame.inset
+          x2 = x1 + label_width
+          x3 = x2 + theme.frame.tab_slant
+          top1 = theme.frame.inset
+          top2 = theme.frame.inset + theme.frame.tab_height
+          "#{x1} #{top2} #{x2} #{top2} #{x3} #{top1 + theme.frame.tab_height - theme.frame.tab_slant} #{x3} #{top1} #{x1} #{top1} #{x1} #{top2}"
+        end
+
+        def tab_label(diagram)
+          type = diagram_label_prefix(diagram)
+          return nil unless type
+
+          "#{type} #{diagram.name}"
+        end
+
+        def diagram_label_prefix(diagram)
+          case diagram.diagram_type&.downcase
+          when "logical" then "class"
+          when "package" then "pkg"
+          when "usecase" then "uc"
+          when "sequence" then "seq"
+          when "activity" then "act"
+          when "statechart" then "sm"
+          when "deployment" then "dep"
+          when "component" then "comp"
+          when "object" then "object"
+          when "custom", "conceptual" then nil
+          else diagram.diagram_type&.downcase
+          end
+        end
+
+        def tab_label_width(diagram)
+          label = tab_label(diagram)
+          return theme.package.default_tab_width unless label
+
+          text_width = Ea::Svg::EaEmitter::TextRenderer.estimate_width(
+            label, theme.font_size || 7, theme.text_width_factor
+          ).round
+          text_width + theme.frame.tab_padding
+        end
+
+        def build_label_text(label)
+          TextRenderer.new(
+            content: label,
+            x: theme.frame.tab_label_x, y: theme.frame.tab_label_y,
+            family: theme.font_family || "Calibri",
+            size: theme.font_size || 7,
+            weight: theme.text_weight_bold,
+            size_unit: theme.font_size_unit,
+            fill: "#000000",
+            stroke_in_text: theme.stroke_in_text_color,
+            width_factor: theme.text_width_factor
+          ).to_svg
+        end
+
+        BORDER_STYLE = "stroke-width:1;stroke-linecap:square;stroke-linejoin:miter; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
+        TAB_STYLE = "stroke-width:1;stroke-linecap:square;stroke-linejoin:miter; fill:#FFFFFF;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
+        LABEL_STYLE = "stroke-width:1;stroke-linecap:square;stroke-linejoin:miter; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:0.00"
+      end
+    end
+  end
+end