ea 0.3.1 → 0.5.0

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Predicate: should this element be rendered, or is it a
+        # diagram-frame placeholder that EA skips?
+        class Filter
+          attr_reader :model_index
+
+          def initialize(model_index:)
+            @model_index = model_index
+          end
+
+          # Returns true if the element should be SKIPPED.
+          # EA emits a "diagram frame placeholder" Classifier with
+          # no name and no properties on some diagrams — those get
+          # dropped. Packages and named Classifiers are always kept.
+          def skip?(element)
+            return false unless element.background_color == -1
+
+            classifier = classifier_for(element)
+            return false unless classifier
+
+            classifier.name.to_s.strip.empty? && (classifier.properties.nil? || classifier.properties.empty?)
+          end
+
+          private
+
+          def classifier_for(element)
+            ref = element.model_element_ref
+            return nil unless ref
+
+            candidate = model_index[ref]
+            return nil unless candidate.is_a?(Ea::Model::Classifier)
+
+            candidate
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits a hand-drawn style shape `<path>` for elements on
+        # diagrams that have HandDraw=1 in their StyleEx. EA renders
+        # each element as a closed `<path>` with cubic beziers per
+        # side (slight wave) instead of a clean `<rect>`. Used by
+        # Domain Model diagrams.
+        class HandDrawShapeRenderer
+          WAVE_AMPLITUDE = 2
+          WAVE_LENGTH = 70
+
+          def self.render(bounds, fill:, stroke:, stroke_width:)
+            new(bounds, fill, stroke, stroke_width).to_svg
+          end
+
+          def initialize(bounds, fill, stroke, stroke_width)
+            @bounds = bounds
+            @fill = fill
+            @stroke = stroke
+            @stroke_width = stroke_width
+          end
+
+          def to_svg
+            %(<g style="#{group_style}">\n  #{shape_path}\n</g>)
+          end
+
+          private
+
+          attr_reader :bounds, :fill, :stroke, :stroke_width
+
+          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
+
+          # Approximation of EA's hand-drawn border. Each side is a
+          # cubic bezier from one corner to the next, with control
+          # points pulled slightly inward to give a wavy silhouette.
+          # The exact ref encoding uses many short S-curves; this
+          # emits 4 C commands (one per side) which is shape-count
+          # compatible.
+          def shape_path
+            x1 = bounds.x.to_f
+            y1 = bounds.y.to_f
+            x2 = x1 + bounds.width.to_f
+            y2 = y1 + bounds.height.to_f
+            cx1 = x1 + bounds.width.to_f / 2
+            cy1 = y1 + bounds.height.to_f / 2
+            d = "M #{coord(x1)} #{coord(y1)} " \
+                "C #{coord(x1 + WAVE_LENGTH)} #{coord(y1 - WAVE_AMPLITUDE)} " \
+                "#{coord(cx1 + WAVE_LENGTH / 2)} #{coord(y1 + WAVE_AMPLITUDE)} " \
+                "#{coord(x2)} #{coord(y1)} " \
+                "C #{coord(x2 + WAVE_AMPLITUDE)} #{coord(y1 + WAVE_LENGTH)} " \
+                "#{coord(x2 - WAVE_AMPLITUDE)} #{coord(cy1 + WAVE_LENGTH / 2)} " \
+                "#{coord(x2)} #{coord(y2)} " \
+                "C #{coord(x2 - WAVE_LENGTH)} #{coord(y2 + WAVE_AMPLITUDE)} " \
+                "#{coord(cx1 - WAVE_LENGTH / 2)} #{coord(y2 - WAVE_AMPLITUDE)} " \
+                "#{coord(x1)} #{coord(y2)} " \
+                "C #{coord(x1 - WAVE_AMPLITUDE)} #{coord(y2 - WAVE_LENGTH)} " \
+                "#{coord(x1 + WAVE_AMPLITUDE)} #{coord(cy1 - WAVE_LENGTH / 2)} " \
+                "#{coord(x1)} #{coord(y1)} Z"
+            %(<path d="#{d}" shape-rendering="auto"/>)
+          end
+
+          def coord(value)
+            Ea::Svg::EaEmitter::Canvas.coord(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # OCP-friendly header line pipeline. Each contributor is a
+        # stateless provider that appends 0+ lines to the output.
+        # New behaviors add a new provider to PROVIDERS without
+        # modifying existing ones.
+        #
+        # Context (Struct) carries everything a provider might need:
+        #   classifier, diagram_package_id, visually_nested,
+        #   umldi_keyword, bounds_width, font_size,
+        #   off_canvas_parent_name
+        #
+        # Each provider implements:
+        #   def self.call(context)  →  Array<[[text, style], ...]>
+        module HeaderLinePipeline
+          Context = Struct.new(:classifier, :diagram_package_id,
+                               :visually_nested, :umldi_keyword,
+                               :bounds_width, :font_size,
+                               :off_canvas_parent_name,
+                               keyword_init: true)
+
+          PROVIDERS = [
+            HeaderLineProvider::ParentGhost,
+            HeaderLineProvider::InstanceSpec,
+            HeaderLineProvider::StereotypeLabel,
+            HeaderLineProvider::Name
+          ].freeze
+
+          # @param classifier [Ea::Model::Classifier, Ea::Model::InstanceSpecification]
+          # @return [Array<Array(String, Symbol)>] list of [text, style] pairs
+          def self.for(classifier, **opts)
+            context = Context.new(classifier: classifier, **opts)
+            PROVIDERS.flat_map { |provider| provider.call(context) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/header_line_provider/instance_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        module HeaderLineProvider
+          # InstanceSpecification: short-circuits the pipeline. The
+          # entire header for an instance is "name: Classifier" on
+          # one bold line. No stereotype, no wrap, no parent ghost.
+          class InstanceSpec
+            def self.call(context)
+              inst = context.classifier
+              return [] unless inst.is_a?(Ea::Model::InstanceSpecification)
+
+              label = inst.name.to_s
+              if inst.classifier_name && !inst.classifier_name.empty?
+                label = "#{label}: #{inst.classifier_name}"
+              end
+              [[label, :bold]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/header_line_provider/name.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        module HeaderLineProvider
+          # Emits the classifier's display name, with these behaviors:
+          #
+          # - Bold-italic for abstract Klass; bold otherwise.
+          # - Qualified name wrap when the rendered width exceeds the
+          #   element bounds. EA splits "pkg::Class" across two lines
+          #   when the combined width is too wide.
+          #
+          # InstanceSpecification returns [] (InstanceSpec provider
+          # already emitted the full label).
+          class Name
+            QUALIFIED_WRAP_WIDTH_FACTOR = 0.55
+            QUALIFIED_WRAP_PADDING = 8
+
+            def self.call(context)
+              classifier = context.classifier
+              return [] if classifier.is_a?(Ea::Model::InstanceSpecification)
+
+              weight = weight_for(classifier)
+              wrapped_name_lines(classifier, context, weight)
+            end
+
+            # @param classifier [Ea::Model::Classifier]
+            # @return [Symbol] :bold_italic for abstract, :bold otherwise
+            def self.weight_for(classifier)
+              classifier.is_a?(Ea::Model::Klass) && classifier.is_abstract ? :bold_italic : :bold
+            end
+
+            def self.wrapped_name_lines(classifier, context, weight)
+              name = display_name(classifier, context.diagram_package_id,
+                                  context.visually_nested)
+              unless context.bounds_width && name.include?("::") &&
+                     name_exceeds_bounds?(name, context.bounds_width,
+                                           context.font_size || 9)
+                return [[name, weight]]
+              end
+
+              qualifier, base = name.split("::", 2)
+              [["#{qualifier}::", weight], [base, weight]]
+            end
+
+            def self.name_exceeds_bounds?(name, bounds_width, font_size)
+              TextRenderer.estimate_width(name, font_size,
+                                          QUALIFIED_WRAP_WIDTH_FACTOR) >
+                (bounds_width - QUALIFIED_WRAP_PADDING)
+            end
+
+            def self.display_name(classifier, diagram_package_id = nil,
+                                  _visually_nested = false)
+              name = if classifier.is_a?(Ea::Model::Classifier)
+                       (classifier.qualified_name || classifier.name).to_s
+                     else
+                       classifier.name.to_s
+                     end
+              return name if diagram_package_id.nil?
+              return name unless name.include?("::")
+
+              if classifier.is_a?(Ea::Model::Classifier) &&
+                 classifier.package_id == diagram_package_id
+                name.split("::").last
+              else
+                name
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/header_line_provider/parent_ghost.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        module HeaderLineProvider
+          # Emits the off-canvas parent classifier name as the first
+          # italic line. EA renders this when HideParents=0 and the
+          # classifier's generalization parent is not placed on the
+          # diagram.
+          class ParentGhost
+            # @param context [HeaderLinePipeline::Context]
+            def self.call(context)
+              name = context.off_canvas_parent_name
+              return [] unless name
+
+              [[name, :italic]]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/element/header_line_provider/stereotype_label.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        module HeaderLineProvider
+          # Emits the stereotype label `«name»` for classifiers with
+          # an explicit stereotype, OR a type-derived fallback
+          # («enumeration», «dataType», etc.) for non-Klass classifiers.
+          #
+          # Plain Klass with no stereotype gets no label — EA's
+          # behavior.
+          #
+          # InstanceSpecification is excluded (it owns its own header).
+          class StereotypeLabel
+            def self.call(context)
+              classifier = context.classifier
+              return [] if classifier.is_a?(Ea::Model::InstanceSpecification)
+
+              label = label_for(classifier, context.umldi_keyword)
+              return [] unless label
+
+              [[label, :normal]]
+            end
+
+            # @return [String, nil] «name» label or nil
+            def self.label_for(classifier, umldi_keyword)
+              return "«#{umldi_keyword}»" if umldi_keyword && !umldi_keyword.empty?
+
+              explicit = explicit_stereotype(classifier)
+              return explicit if explicit
+
+              case classifier
+              when Ea::Model::Klass, Ea::Model::Package, Ea::Model::Note
+                nil
+              else
+                fallback = fallback_name(classifier)
+                fallback ? "«#{fallback}»" : nil
+              end
+            end
+
+            def self.explicit_stereotype(classifier)
+              return nil unless classifier.is_a?(Ea::Model::Classifier) ||
+                                 classifier.is_a?(Ea::Model::Package)
+
+              refs = classifier.stereotype_refs
+              return nil unless refs&.any?
+
+              "«#{refs.first}»"
+            end
+
+            def self.fallback_name(classifier)
+              case classifier
+              when Ea::Model::Enumeration then "enumeration"
+              when Ea::Model::DataType then "dataType"
+              when Ea::Model::PrimitiveType then "primitive"
+              when Ea::Model::Interface then "interface"
+              when Ea::Model::Signal then "signal"
+              else "DataType"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Namespace for HeaderLinePipeline providers. Each provider
+        # owns ONE contribution to the header. Adding a new line type
+        # (e.g. legend symbol) = adding a new provider here.
+        module HeaderLineProvider
+          autoload :ParentGhost, "ea/svg/ea_emitter/element/header_line_provider/parent_ghost"
+          autoload :InstanceSpec, "ea/svg/ea_emitter/element/header_line_provider/instance_spec"
+          autoload :StereotypeLabel, "ea/svg/ea_emitter/element/header_line_provider/stereotype_label"
+          autoload :Name, "ea/svg/ea_emitter/element/header_line_provider/name"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Legacy entry point preserved for backward compatibility.
+        # Delegates to HeaderLinePipeline — the OCP-friendly provider
+        # chain that replaces this module. New code should call
+        # HeaderLinePipeline directly.
+        module HeaderLines
+          module_function
+
+          def for(classifier, **opts)
+            HeaderLinePipeline.for(classifier, **opts)
+          end
+
+          # Delegate to the Name provider so historical callers and
+          # specs that test display_name keep working.
+          def display_name(classifier, diagram_package_id = nil, *_)
+            HeaderLineProvider::Name.display_name(classifier, diagram_package_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the header text `<g>` containing stereotype + class
+        # name lines. Lines + styling computed by HeaderLines.
+        #
+        # EA centers header text within the element bounds (computing
+        # the left edge from text-width approximation since SVG text
+        # x= is the start position, not the center).
+        class HeaderRenderer
+          def self.render(lines, bounds:, first_y:, family:,
+                          size:, size_unit: "pt",
+                          fill: "#000000", weight_normal: 400, weight_bold: 700,
+                          stroke_in_text: "#000000", width_factor: 0.65,
+                          line_offset: 6)
+            line_h = size + line_offset
+            text_blocks = lines.each_with_index.map do |(text, style), idx|
+              weight = case style
+                       when :bold, :bold_italic then weight_bold
+                       else weight_normal
+                       end
+              font_style = (style == :italic || style == :bold_italic) ? "italic" : "normal"
+              y = first_y + (idx * line_h)
+              centered_x = center_x_for(text, bounds, size, width_factor)
+              TextRenderer.new(
+                content: text,
+                x: centered_x, y: y,
+                family: family, size: size, size_unit: size_unit,
+                weight: weight, style: font_style, fill: fill,
+                stroke_in_text: stroke_in_text, width_factor: width_factor
+              ).to_svg
+            end
+            %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
+          end
+
+          def self.center_x_for(text, bounds, size, width_factor)
+            text_width = Ea::Svg::EaEmitter::TextRenderer.estimate_width(text, size, width_factor)
+            bounds.x + (bounds.width - text_width) / 2.0
+          end
+          private_class_method :center_x_for
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Element
+        # Emits the small "folded paper" classifier-type icon at the
+        # top-right corner of an element box. EA renders this when
+        # the element's style does NOT set HideIcon=1.
+        #
+        # The icon is two `<path>` elements:
+        #
+        #   1. Outer outline (closed): a 9×11 rectangle with the
+        #      top-right corner "folded" (a 3×4 triangular cut).
+        #   2. Folded corner detail (open): the L-shape indicating
+        #      the fold.
+        #
+        # Style:
+        #   - Outer:    fill=#DCF8F0, stroke=#577AC1
+        #   - Corner:   fill=transparent, stroke=#577AC1
+        #   - stroke-width=1, stroke-linecap=square, linejoin=bevel
+        class IconRenderer
+          OUTER_FILL = "#DCF8F0"
+          OUTER_STROKE = "#577AC1"
+          CORNER_FILL = "##{0.to_s.rjust(6, '0')}" # transparent black
+          WIDTH = 9
+          HEIGHT = 11
+          FOLD_WIDTH = 3
+          FOLD_HEIGHT = 4
+          X_INSET = 13
+          Y_OFFSET = 3
+
+          attr_reader :bounds, :canvas
+
+          def initialize(bounds:, canvas: nil)
+            @bounds = bounds
+            @canvas = canvas
+          end
+
+          def self.render(bounds:, canvas: nil, family: nil, size: nil)
+            new(bounds: bounds, canvas: canvas).to_svg
+          end
+
+          # Returns the two `<path>` elements joined as a single
+          # String. Returns "" if bounds is nil.
+          def to_svg
+            return "" unless bounds
+
+            "#{outer_path}\n#{corner_path}"
+          end
+
+          private
+
+          def outer_path
+            x, y = top_left
+            right = x + WIDTH
+            bottom = y + HEIGHT
+            fold_x = right - FOLD_WIDTH
+            fold_y = y + FOLD_HEIGHT
+            d = "M #{coord(x)} #{coord(y)} " \
+                "L #{coord(fold_x)} #{coord(y)} " \
+                "L #{coord(right)} #{coord(fold_y)} " \
+                "L #{coord(right)} #{coord(bottom)} " \
+                "L #{coord(x)} #{coord(bottom)} " \
+                "L #{coord(x)} #{coord(y)} Z"
+            %(<g style="#{outer_style}">\n  <path d="#{d}" shape-rendering="auto"/>\n</g>)
+          end
+
+          def corner_path
+            x, y = top_left
+            right = x + WIDTH
+            fold_x = right - FOLD_WIDTH
+            fold_y = y + FOLD_HEIGHT
+            d = "M #{coord(fold_x)} #{coord(y)} " \
+                "L #{coord(fold_x)} #{coord(fold_y)} " \
+                "L #{coord(right)} #{coord(fold_y)}"
+            %(<g style="#{corner_style}">\n  <path d="#{d}" shape-rendering="auto"/>\n</g>)
+          end
+
+          def outer_style
+            "stroke-width:1;stroke-linecap:square;stroke-linejoin:bevel; " \
+              "fill:#{OUTER_FILL};fill-opacity:1.00; stroke:#{OUTER_STROKE}; stroke-opacity:1.00"
+          end
+
+          def corner_style
+            "stroke-width:1;stroke-linecap:square;stroke-linejoin:bevel; " \
+              "fill:#000000;fill-opacity:0.00; stroke:#{OUTER_STROKE}; stroke-opacity:1.00"
+          end
+
+          # Top-left of the icon: x = bounds.right - X_INSET,
+          # y = bounds.top + Y_OFFSET.
+          def top_left
+            tx = bounds.x + bounds.width - X_INSET
+            ty = bounds.y + Y_OFFSET
+            if canvas
+              [canvas.translate_x(tx), canvas.translate_y(ty)]
+            else
+              [tx, ty]
+            end
+          end
+
+          def coord(value)
+            Ea::Svg::EaEmitter::Canvas.coord(value)
+          end
+        end
+      end
+    end
+  end
+end