ea 0.4.0 → 0.5.0

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Instance-name underline for object diagrams. EA draws a
+        # short horizontal line just below each instance name to
+        # denote that it is an instance (UML convention). Rendered
+        # only when the diagram's `diagram_type` is "Object".
+        module InstanceUnderline
+          Y_OFFSET = 2
+          WIDTH_FACTOR = 0.65
+
+          module_function
+
+          def render(context)
+            return nil unless context.diagram
+            return nil unless object_diagram?(context)
+            return nil if context.header_lines.empty?
+
+            name_line = context.header_lines.last
+            text = name_line.first.to_s
+            return nil if text.empty?
+
+            underline_path(context, text)
+          end
+
+          def object_diagram?(context)
+            context.diagram && context.diagram.diagram_type == "Object"
+          end
+          module_function :object_diagram?
+
+          def underline_path(context, text)
+            bounds = context.bounds
+            text_width = TextRenderer.estimate_width(text, context.size,
+                                                     WIDTH_FACTOR)
+            x_start = bounds.x + (bounds.width - text_width) / 2.0
+            y_pos = context.geometry.header_first_y + Y_OFFSET
+            build_path_tag(x_start, y_pos, text_width)
+          end
+          module_function :underline_path
+
+          def build_path_tag(x_start, y_pos, text_width)
+            x_end = x_start + text_width
+            coords = format_coords(x_start, y_pos, x_end)
+            d = "M #{coords[:x1]} #{coords[:y1]} L #{coords[:x2]} #{coords[:y1]}"
+            style = "stroke-width:1;stroke-linecap:square;" \
+                    "stroke-linejoin:miter; fill:none; stroke:#000000;" \
+                    " stroke-opacity:1.00"
+            %(<g style="#{style}">\n  <path d="#{d}" shape-rendering="auto"/>\n</g>)
+          end
+          module_function :build_path_tag
+
+          def format_coords(x_start, y_pos, x_end)
+            {
+              x1: Ea::Svg::EaEmitter::Canvas.coord(x_start),
+              x2: Ea::Svg::EaEmitter::Canvas.coord(x_end),
+              y1: Ea::Svg::EaEmitter::Canvas.coord(y_pos)
+            }
+          end
+          module_function :format_coords
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Note body text wrapped inside a Note element's bounds.
+        # Renders only when the host element is a Note with a
+        # non-empty body.
+        module NoteBody
+          module_function
+
+          def render(context)
+            return nil if context.model_element.is_a?(Ea::Model::Note) &&
+                          context.model_element.legend
+
+            body = context.note_body
+            return nil unless body
+
+            text_blocks = wrapped_lines(context, body)
+            %(<g style="#{group_style(context)}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          def wrapped_lines(context, body)
+            max_chars = [(context.bounds.width / (context.size * 0.6)).floor, 10].max
+            body.to_s.split(/\n/).flat_map do |para|
+              para.gsub(/(.{1,#{max_chars}})(\s+|$)/, "\\1\n").strip.split(/\n/)
+            end.each_with_index.map do |line, idx|
+              y = context.bounds.y + context.theme.note.text_y_offset +
+                  (idx * context.theme.note.line_height)
+              TextRenderer.new(
+                content: line,
+                x: context.bounds.x + context.theme.note.text_x_offset,
+                y: y,
+                family: context.family, size: context.size, size_unit: context.size_unit,
+                fill: context.theme.text_color,
+                stroke_in_text: context.theme.stroke_in_text_color,
+                width_factor: context.theme.text_width_factor
+              ).to_svg
+            end
+          end
+
+          def group_style(context)
+            "stroke-width:1;stroke-linecap:round;stroke-linejoin:bevel; " \
+              "fill:#{context.theme.text_color};fill-opacity:1.00; " \
+              "stroke:#000000; stroke-opacity:0.00"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Note text compartment. When diagram.show_notes is true,
+        # renders the classifier's documentation note (from
+        # t_object.Note) as wrapped text lines in the element body.
+        # Lines are estimated by character width and split at word
+        # boundaries to fit the element bounds.
+        module NoteText
+          X_PADDING = 5
+          Y_FIRST_OFFSET = 15
+          LINE_OFFSET = 13
+          CHAR_WIDTH_FACTOR = 0.55
+
+          module_function
+
+          def render(context)
+            return nil unless show_notes?(context)
+            return nil unless context.classifier&.is_a?(Ea::Model::Classifier)
+
+            notes = note_bodies(context.classifier)
+            return nil if notes.empty?
+
+            first_y = context.geometry.attr_first_y + Y_FIRST_OFFSET
+            bounds = context.bounds
+            fill = context.theme.attribute_text_color
+            usable_width = bounds.width - (X_PADDING * 2)
+            max_chars = (usable_width / (context.size * CHAR_WIDTH_FACTOR)).floor
+
+            texts = []
+            y = first_y
+            notes.each do |body|
+              wrapped_lines(body, max_chars).each do |line|
+                texts << build_text(line, bounds.x + X_PADDING, y, context, fill)
+                y += LINE_OFFSET
+              end
+            end
+            wrap_group(texts.join("\n"), fill)
+          end
+
+          def show_notes?(context)
+            context.diagram && context.diagram.show_notes
+          end
+          module_function :show_notes?
+
+          def note_bodies(classifier)
+            (classifier.annotations || []).filter_map do |a|
+              body = a.body.to_s.strip
+              body.empty? ? nil : body
+            end
+          end
+          module_function :note_bodies
+
+          # Word-wrap text at max_chars, preserving word boundaries.
+          def wrapped_lines(text, max_chars)
+            return [text] if text.length <= max_chars
+
+            words = text.split(" ")
+            lines = []
+            current = ""
+            words.each do |word|
+              if current.empty?
+                current = word
+              elsif (current + " " + word).length <= max_chars
+                current = "#{current} #{word}"
+              else
+                lines << current
+                current = word
+              end
+            end
+            lines << current unless current.empty?
+            lines
+          end
+          module_function :wrapped_lines
+
+          def build_text(content, x_pos, y_pos, context, fill)
+            TextRenderer.new(
+              content: content,
+              x: x_pos, y: y_pos,
+              family: context.family, size: context.size,
+              size_unit: context.size_unit, fill: fill,
+              style: "italic"
+            ).to_svg
+          end
+          module_function :build_text
+
+          def wrap_group(body, fill)
+            style = "stroke-width:1;stroke-linecap:round;" \
+                    "stroke-linejoin:bevel; fill:#{fill};" \
+                    "fill-opacity:1.00; stroke:#000000;" \
+                    " stroke-opacity:0.00"
+            %(<g style="#{style}">\n#{body}\n</g>)
+          end
+          module_function :wrap_group
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Compartment
+        # Operation compartment: divider line + operation signatures.
+        # Skipped when no operations or when geometry cannot fit them.
+        module Operations
+          module_function
+
+          def render(context)
+            return nil unless context.op_lines.any?
+            return nil unless context.geometry.op_first_y
+            return nil unless context.classifier
+
+            parts = []
+            if context.attr_lines.any?
+              parts << Element::DividerRenderer.render(
+                context.bounds,
+                y: context.geometry.op_divider_y,
+                stroke: context.stroke,
+                stroke_width: context.stroke_width
+              )
+            end
+            parts << Element::OperationRenderer.render(
+              context.classifier.operations,
+              bounds: context.bounds,
+              first_y: context.geometry.op_first_y,
+              family: context.family, size: context.size
+            )
+            parts.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

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/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,58 @@
+# 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 :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,
+          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