ea 0.4.0 → 0.5.0

data/lib/ea/svg/ea_emitter/element/legend_renderer.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the auto-generated legend block that EA renders from
+        # a Text element whose StyleEx carries LegendOpts=. Layout
+        # (verified against plateau reference SVGs):
+        #
+        #   ┌──────────────────────────────┐
+        #   │            凡例              │  ← title baseline 19px below top
+        #   │  ┌──┐                        │
+        #   │  └──┘  GMLに定義されたクラス  │  ← item 0 (icon top + 30px)
+        #   │  ┌──┐                        │
+        #   │  └──┘  CityGMLに定義されたクラス
+        #   │  ┌──┐                        │
+        #   │  └──┘  i-URに定義されたクラス  │
+        #   └──────────────────────────────┘
+        #
+        # Container: bounds.width × bounds.height, rx=3.
+        # Each item: 17×17 icon rect + label text on the same line.
+        # Item spacing is 19px (icon height 17 + 2 padding).
+        class LegendRenderer
+          CONTAINER_RX = 3
+          ICON_SIZE = 17
+          TITLE_Y_OFFSET = 19
+          FIRST_ITEM_Y_OFFSET = 30
+          ITEM_SPACING = 19
+          ICON_X_OFFSET = 10
+          ICON_LABEL_GAP = 22
+          LABEL_BASELINE_FROM_ICON_TOP = 12
+          DEFAULT_ITEM_FONT_SIZE = 9
+
+          def self.render(bounds, legend:, family:, canvas: nil)
+            new(bounds, legend, family, canvas).to_svg
+          end
+
+          def initialize(bounds, legend, family, canvas)
+            @bounds = bounds
+            @legend = legend
+            @family = family
+            @canvas = canvas
+          end
+
+          def to_svg
+            [container_layer, items_layer, title_layer].compact.join("\n")
+          end
+
+          private
+
+          attr_reader :bounds, :legend, :family, :canvas
+
+          def container_layer
+            body = format(
+              '<rect x="%<x>s" y="%<y>s" width="%<w>s" height="%<h>s" rx="%<r>.2f" shape-rendering="auto"  />',
+              x: fmt(bounds.x), y: fmt(bounds.y),
+              w: fmt(bounds.width), h: fmt(bounds.height),
+              r: CONTAINER_RX
+            )
+            %(<g style="#{container_style}">\n  #{body}\n</g>)
+          end
+
+          # One <g> per item — each item carries its own fill, so we
+          # cannot consolidate them into a single group.
+          def items_layer
+            return nil if legend.items.empty?
+
+            legend.items.map.with_index do |item, index|
+              icon = icon_rect(item, index)
+              label = item_label(item, index)
+              [
+                %(<g style="#{icon_style(item)}">\n  #{icon}\n</g>),
+                %(<g style="#{label_style}">\n  #{label}\n</g>)
+              ].join("\n")
+            end.join("\n")
+          end
+
+          def title_layer
+            %(<g style="#{label_style}">\n  #{title_text}\n</g>)
+          end
+
+          def container_style
+            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+              "fill:#{container_fill};fill-opacity:1.00; " \
+              "stroke:#{container_stroke}; stroke-opacity:1.00"
+          end
+
+          def icon_style(item)
+            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+              "fill:#{icon_fill(item)};fill-opacity:1.00; " \
+              "stroke:#000000; stroke-opacity:1.00"
+          end
+
+          def label_style
+            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+              "fill:#{label_fill};fill-opacity:1.00; " \
+              "stroke:#000000; stroke-opacity:0.00"
+          end
+
+          def container_fill
+            BColDecoder.to_hex(legend.background_color) || "#F0F0F0"
+          end
+
+          def container_stroke
+            BColDecoder.to_hex(legend.border_color) || "#D7D7D7"
+          end
+
+          def icon_fill(item)
+            BColDecoder.to_hex(item.background_color) || "#FFFFFF"
+          end
+
+          def label_fill
+            BColDecoder.to_hex(legend.font_color) || "#003060"
+          end
+
+          def icon_rect(_item, index)
+            x = bounds.x + ICON_X_OFFSET
+            y = item_top_y(index)
+            format(
+              '<rect x="%<x>s" y="%<y>s" width="%<w>d" height="%<h>d" rx="0.00" shape-rendering="auto"  />',
+              x: fmt(x), y: fmt(y), w: ICON_SIZE, h: ICON_SIZE
+            )
+          end
+
+          def item_label(item, index)
+            x = bounds.x + ICON_X_OFFSET + ICON_LABEL_GAP
+            y = item_top_y(index) + LABEL_BASELINE_FROM_ICON_TOP
+            build_text(item.name, x: x, y: y, size: item_font_size, weight: 0)
+          end
+
+          def title_text
+            x = bounds.x + (bounds.width / 2) - (title_text_width / 2)
+            y = bounds.y + TITLE_Y_OFFSET
+            build_text(legend.title, x: x, y: y, size: title_font_size, weight: 700)
+          end
+
+          def item_top_y(index)
+            bounds.y + FIRST_ITEM_Y_OFFSET + (index * ITEM_SPACING)
+          end
+
+          def title_font_size
+            legend.heading_size || Ea::Model::Legend::DEFAULT_HEADING_SIZE
+          end
+
+          def item_font_size
+            DEFAULT_ITEM_FONT_SIZE
+          end
+
+          def title_text_width
+            legend.title.to_s.length * title_font_size * 0.6
+          end
+
+          def build_text(content, x:, y:, size:, weight:)
+            tx, ty = translate(x, y)
+            TextRenderer.new(
+              content: content.to_s, x: tx, y: ty,
+              family: family, size: size, size_unit: "pt",
+              weight: weight, fill: label_fill,
+              text_length: (content.to_s.length * size * 0.65).round
+            ).to_svg
+          end
+
+          def translate(x, y)
+            return [x, y] unless canvas
+
+            [canvas.translate_x(x), canvas.translate_y(y)]
+          end
+
+          def fmt(value)
+            Canvas.coord(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/note_shape_renderer.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the shape `<g>` for a Note element: a folded-corner
+        # rect plus body text. EA renders every Note element as a
+        # dog-eared rectangle (top-right corner folded in) with the
+        # note text wrapped inside.
+        #
+        # Layout:
+        #
+        #   ┌──────────────────┐
+        #   │                  ┐
+        #   │ body text lines   │
+        #   │                  │
+        #   └──────────────────-┘
+        #
+        class NoteShapeRenderer
+          FOLD_SIZE = 12
+          TEXT_X_OFFSET = 5
+          TEXT_Y_OFFSET = 12
+          LINE_HEIGHT = 12
+
+          def self.render(bounds, body:, fill:, stroke:, stroke_width:, family:, size:, text_fill:)
+            new(bounds, body, fill, stroke, stroke_width, family, size, text_fill).to_svg
+          end
+
+          def initialize(bounds, body, fill, stroke, stroke_width, family, size, text_fill)
+            @bounds = bounds
+            @body = body.to_s
+            @fill = fill
+            @stroke = stroke
+            @stroke_width = stroke_width
+            @family = family
+            @size = size
+            @text_fill = text_fill
+          end
+
+          def to_svg
+            %(<g style="#{group_style}">\n  #{path_body}\n  #{fold_line}\n  #{text_block}\n</g>)
+          end
+
+          private
+
+          attr_reader :bounds, :body, :fill, :stroke, :stroke_width,
+                      :family, :size, :text_fill
+
+          def group_style
+            "stroke-width:#{stroke_width};stroke-linecap:square;stroke-linejoin:bevel; " \
+              "fill:#{fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00"
+          end
+
+          # Folded-corner body emitted as a closed <path> matching
+          # EA's encoding (not <polygon>). EA uses M..L..L..Z with
+          # stroke-linejoin=bevel for the dog-eared silhouette.
+          def path_body
+            x = bounds.x
+            y = bounds.y
+            w = bounds.width
+            h = bounds.height
+            fold = [FOLD_SIZE, w / 3, h / 3].min
+            d = "M #{Canvas.coord(x)} #{Canvas.coord(y)} " \
+                "L #{Canvas.coord(x + w - fold)} #{Canvas.coord(y)} " \
+                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + fold)} " \
+                "L #{Canvas.coord(x + w)} #{Canvas.coord(y + h)} " \
+                "L #{Canvas.coord(x)} #{Canvas.coord(y + h)} " \
+                "L #{Canvas.coord(x)} #{Canvas.coord(y)} Z"
+            %(<path d="#{d}" shape-rendering="auto"/>)
+          end
+
+          # Diagonal line marking the fold.
+          def fold_line
+            x = bounds.x
+            y = bounds.y
+            w = bounds.width
+            fold = [FOLD_SIZE, w / 3, bounds.height / 3].min
+            %(<path d="M #{Canvas.coord(x + w - fold)} #{Canvas.coord(y)} L #{Canvas.coord(x + w)} #{Canvas.coord(y + fold)}" shape-rendering="auto"/>)
+          end
+
+          def text_block
+            lines = body_lines
+            return "" if lines.empty?
+
+            texts = lines.each_with_index.map do |line, idx|
+              y = bounds.y + TEXT_Y_OFFSET + (idx * LINE_HEIGHT)
+              TextRenderer.new(content: line,
+                                x: bounds.x + TEXT_X_OFFSET,
+                                y: y,
+                                family: family,
+                                size: size,
+                                fill: text_fill).to_svg
+            end
+            texts.join("\n  ")
+          end
+
+          # Naive word-wrap based on character count. EA's actual
+          # wrapping uses GDI text metrics; this is an approximation.
+          def body_lines
+            return [] if body.empty?
+
+            max_chars = [(bounds.width / (size.to_f * 0.6)).floor, 10].max
+            body.split(/\n/).flat_map do |para|
+              para.gsub(/(.{1,#{max_chars}})(\s+|$)/, "\\1\n").strip.split(/\n/)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/operation_renderer.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the operation compartment text `<g>`. Each operation
+        # renders as TWO `<text>` elements matching EA's encoding:
+        #
+        #   <text>+ </text>
+        #   <text>methodName(params): ReturnType</text>
+        #
+        # Rendered as a third compartment below the attribute
+        # compartment for Klass / Interface classifiers.
+        class OperationRenderer
+          VISIBILITY_X_OFFSET = 5
+          CONTENT_X_OFFSET = 20
+
+          def self.render(operations, bounds:, first_y:, family:, size:)
+            line_h = size + 4
+            text_blocks = []
+            has_receptions = operations.any?(&:is_reception)
+            if has_receptions
+              text_blocks << TextRenderer.new(
+                content: "receptions",
+                x: bounds.x + (bounds.width / 2.0) - (8 * size * 0.65) / 2,
+                y: first_y,
+                family: family, size: size,
+                style: "italic", fill: "#000000"
+              ).to_svg
+            end
+            ops = has_receptions ? operations : operations
+            offset = has_receptions ? 1 : 0
+            ops.each_with_index do |op, idx|
+              y = first_y + ((idx + offset) * line_h)
+              text_blocks << build_text(bounds.x + VISIBILITY_X_OFFSET, y,
+                                         visibility_prefix(op), family, size)
+              text_blocks << build_text(bounds.x + CONTENT_X_OFFSET, y,
+                                         operation_text(op), family, size)
+            end
+            %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          # Builds display lines for a classifier's operations.
+          def self.lines_for(classifier)
+            ops = classifier.operations
+            return [] unless ops&.any?
+
+            ops.map do |op|
+              visibility = visibility_prefix(op).strip
+              params = (op.parameters || []).map { |p| "#{p.name}: #{namespace_double_colon(p.type_name)}" }.join(", ")
+              return_type = namespace_double_colon(op.return_type_name)
+              "#{visibility} #{op.name}(#{params}): #{return_type}".strip
+            end
+          end
+
+          def self.visibility_prefix(operation)
+            case operation.visibility
+            when "private"   then "- "
+            when "protected" then "# "
+            when "package"   then "~ "
+            else "+ "
+            end
+          end
+          private_class_method :visibility_prefix
+
+          def self.operation_text(operation)
+            prefix = operation.is_reception ? "«signal» " : ""
+            text = "#{prefix}#{operation.name}(#{reception_params(operation)})"
+            return text unless operation.return_type_name && !operation.is_reception
+
+            "#{text}: #{operation.return_type_name}"
+          end
+          private_class_method :operation_text
+
+          def self.namespace_double_colon(type_name)
+            return "" if type_name.nil? || type_name.empty?
+
+            type_name.to_s.gsub(/([A-Za-z0-9_]):([A-Za-z])/, '\1::\2')
+          end
+          private_class_method :namespace_double_colon
+
+          def self.reception_params(operation)
+            params = (operation.parameters || []).filter_map { |p|
+              p.type_name.to_s.empty? ? nil : p.type_name.to_s
+            }.join(", ")
+            params
+          end
+          private_class_method :reception_params
+
+          def self.build_text(x, y, content, family, size)
+            TextRenderer.new(content: content, x: x, y: y,
+                              family: family, size: size).to_svg
+          end
+          private_class_method :build_text
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/package_shape_renderer.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the shape `<g>` for a Package element: a rectangular
+        # body polygon plus a "tab" polygon on top. EA renders every
+        # Package as this folder-like silhouette regardless of diagram
+        # type.
+        #
+        # Layout (element bounds cover tab + body together):
+        #
+        #   ┌───┐
+        #   │tab│   ← top TAB_HEIGHT_SINGLE rows ABOVE element bounds;
+        #   │   │     when a stereotype is present, the tab grows to
+        #   └───┴──────────┐  TAB_HEIGHT_DOUBLE rows and extends INTO
+        #   │               │   the bounds; the name renders bold,
+        #   │     body      │   left-aligned. The body always starts
+        #   │               │   where the tab ends.
+        #   └───────────────┘
+        #
+        class PackageShapeRenderer
+          TAB_HEIGHT_SINGLE = 20
+          TAB_HEIGHT_DOUBLE = 36
+          TAB_LABEL_PADDING = 10
+          TAB_LABEL_X_OFFSET = 5
+          TAB_LABEL_Y_OFFSET = 13
+          TAB_LINE_OFFSET = 13
+          DEFAULT_TAB_WIDTH = 105
+
+          def self.render(bounds, fill:, stroke:, stroke_width:, label: nil,
+                          stereotype: nil, family: "Carlito", size: 7,
+                          size_unit: "pt", text_fill: "#000000")
+            new(bounds, fill, stroke, stroke_width, label, stereotype,
+                family, size, size_unit, text_fill).to_svg
+          end
+
+          def initialize(bounds, fill, stroke, stroke_width, label,
+                         stereotype, family, size, size_unit, text_fill)
+            @bounds = bounds
+            @fill = fill
+            @stroke = stroke
+            @stroke_width = stroke_width
+            @label = label
+            @stereotype = stereotype
+            @family = family
+            @size = size
+            @size_unit = size_unit
+            @text_fill = text_fill
+          end
+
+          def to_svg
+            parts = ["  #{body_polygon}", "  #{tab_polygon}"]
+            parts += header_text_blocks if has_label?
+            %(<g style="#{group_style}">\n#{parts.join("\n")}\n</g>)
+          end
+
+          private
+
+          attr_reader :bounds, :fill, :stroke, :stroke_width, :label,
+                      :stereotype, :family, :size, :size_unit, :text_fill
+
+          def has_label?
+            label && !label.empty?
+          end
+
+          def has_stereotype?
+            stereotype && !stereotype.empty?
+          end
+
+          def group_style
+            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; " \
+              "fill:#{fill};fill-opacity:1.00; stroke:#{stroke}; stroke-opacity:1.00"
+          end
+
+          def body_polygon
+            pts = body_points.map { |x, y| "#{Canvas.coord(x)} #{Canvas.coord(y)}" }.join(" ")
+            %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+          end
+
+          def tab_polygon
+            pts = tab_points.map { |x, y| "#{Canvas.coord(x)} #{Canvas.coord(y)}" }.join(" ")
+            %(<polygon points="#{pts}" shape-rendering="auto"   style="fill-rule:evenodd;"/>)
+          end
+
+          def header_text_blocks
+            blocks = []
+            if has_stereotype?
+              blocks << "  #{text_at(label_x, stereotype_y, "«#{stereotype}»", weight: 0)}"
+              blocks << "  #{text_at(label_x, name_y, label, weight: 700)}"
+            else
+              blocks << "  #{text_at(label_x, name_y_single, label, weight: 700)}"
+            end
+            blocks
+          end
+
+          def text_at(x, y, content, weight:)
+            TextRenderer.new(content: content,
+                              x: x, y: y,
+                              family: family, size: size, size_unit: size_unit,
+                              weight: weight, fill: text_fill,
+                              text_length: content.length * 6).to_svg
+          end
+
+          def label_x
+            bounds.x + TAB_LABEL_X_OFFSET
+          end
+
+          # Stereotype line baseline: 13px below the tab top.
+          def stereotype_y
+            tab_top_y + TAB_LABEL_Y_OFFSET
+          end
+
+          # Name baseline when stereotype is also rendered: 26px below
+          # the tab top (one line below the stereotype).
+          def name_y
+            tab_top_y + TAB_LABEL_Y_OFFSET + TAB_LINE_OFFSET
+          end
+
+          # Name baseline when only the name renders (no stereotype):
+          # 13px below the tab top.
+          def name_y_single
+            tab_top_y + TAB_LABEL_Y_OFFSET
+          end
+
+          # Tab anchored 20px above the bounds top — matches EA's
+          # folder silhouette regardless of whether the tab holds one
+          # line or two.
+          def tab_top_y
+            bounds.y - TAB_HEIGHT_SINGLE
+          end
+
+          def tab_height
+            has_stereotype? ? TAB_HEIGHT_DOUBLE : TAB_HEIGHT_SINGLE
+          end
+
+          def body_points
+            x = bounds.x
+            y = tab_top_y + tab_height
+            w = bounds.width
+            h = body_height(y)
+            [
+              [x, y],
+              [x + w, y],
+              [x + w, y + h],
+              [x, y + h],
+              [x, y]
+            ]
+          end
+
+          # Body extends from tab.bottom to (bounds.bottom - 20px
+          # bottom margin). Total body height = bounds.height -
+          # tab_height (because tab takes (tab_height - 20) from the
+          # top of the bounds plus 20 above the bounds).
+          def body_height(body_top)
+            bounds.y + bounds.height - TAB_HEIGHT_SINGLE - body_top
+          end
+
+          def tab_points
+            x = bounds.x
+            y = tab_top_y
+            w = tab_width
+            h = tab_height
+            [
+              [x, y],
+              [x + w, y],
+              [x + w, y + h],
+              [x, y + h],
+              [x, y]
+            ]
+          end
+
+          def tab_width
+            DEFAULT_TAB_WIDTH
+          end
+        end
+      end
+    end
+  end
+end