ea 0.5.1 → 0.6.0

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

@@ -62,7 +62,7 @@ module Ea
         # Backwards-compatible API: count of marker bodies emitted.
         def count_for(connector)
           return 0 if connector.hidden
-          return 0 unless connector.waypoints&.any? { |w| w.position }
+          return 0 unless connector.waypoints&.any?(&:position)
 
           entries_for(connector).size
         end
@@ -85,15 +85,51 @@ module Ea
           end
         end
 
+        # OCP registries for marker shapes. Adding a new marker shape
+        # = adding one entry to SHAPE_REGISTRY, not editing 3 case/when
+        # branches. Each entry carries the style_key and a render
+        # lambda that knows how to draw the shape.
+        #
+        # Style keys (:diamond_filled, :triangle_open, :connector_line)
+        # map to CSS strings via STYLE_MAP below.
+        SHAPE_REGISTRY = {
+          diamond: {
+            style_key: :diamond_filled,
+            render: ->(m, anchor, base) { m.diamond_polygon(anchor, base) }
+          },
+          triangle: {
+            style_key: :triangle_open,
+            render: ->(m, anchor, base) { m.triangle_polygon(anchor, base) }
+          },
+          plus: {
+            style_key: :connector_line,
+            render: ->(m, anchor, _base) { m.plus_path(anchor) }
+          },
+          arrow: {
+            style_key: :connector_line,
+            render: ->(m, anchor, base) { m.arrow_path(anchor, base) }
+          },
+          package_anchor: {
+            style_key: :connector_line,
+            render: ->(m, anchor, base) { m.package_anchor_path(anchor, base) }
+          }
+        }.freeze
+
+        # Style key → (fill, opacity) pair. The common stroke prefix
+        # is shared, so only the fill and opacity vary.
+        STYLE_MAP = {
+          diamond_filled: { fill: "#000000", opacity: "1.00" },
+          triangle_open: { fill: "#FFFFFF", opacity: "1.00" },
+          connector_line: { fill: "#000000", opacity: "0.00" }
+        }.freeze
+
         def style_for(key)
-          case key
-          when :diamond_filled
-            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
-          when :triangle_open
-            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#FFFFFF;fill-opacity:1.00; stroke:#000000; stroke-opacity:1.00"
-          when :connector_line
-            "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; fill:#000000;fill-opacity:0.00; stroke:#000000; stroke-opacity:1.00"
-          end
+          spec = STYLE_MAP[key]
+          return nil unless spec
+
+          "stroke-width:#{stroke_width};stroke-linecap:round;stroke-linejoin:bevel; " \
+            "fill:#{spec[:fill]};fill-opacity:#{spec[:opacity]}; " \
+            "stroke:#000000; stroke-opacity:1.00"
         end
 
         def visible_connectors
@@ -210,13 +246,7 @@ module Ea
         end
 
         def style_key_for(spec)
-          case spec.shape
-          when :diamond  then :diamond_filled
-          when :triangle then :triangle_open
-          when :plus     then :connector_line # shares style with line <g>
-          when :arrow    then :connector_line # share with line <g>
-          when :package_anchor then :connector_line
-          end
+          SHAPE_REGISTRY.dig(spec.shape, :style_key)
         end
 
         # Rounded [x, y] of the marker's tip (anchor) in canvas
@@ -227,13 +257,10 @@ module Ea
         end
 
         def render_shape(spec)
-          case spec.shape
-          when :diamond  then diamond_polygon(spec.anchor, spec.base)
-          when :triangle then triangle_polygon(spec.anchor, spec.base)
-          when :plus     then plus_path(spec.anchor)
-          when :arrow    then arrow_path(spec.anchor, spec.base)
-          when :package_anchor then package_anchor_path(spec.anchor, spec.base)
-          end
+          entry = SHAPE_REGISTRY[spec.shape]
+          return nil unless entry
+
+          entry[:render].call(self, spec.anchor, spec.base)
         end
 
         # Plus marker: two crossed line segments at the anchor.
@@ -384,6 +411,8 @@ module Ea
 
           [dx / len, dy / len]
         end
+        public :diamond_polygon, :triangle_polygon, :plus_path,
+               :arrow_path, :package_anchor_path
 
         def translate_point(p)
           return p unless @canvas

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

@@ -81,10 +81,7 @@ module Ea
         end
 
         def escaped_content
-          content.gsub("&", "&")
-                 .gsub("<", "&lt;")
-                 .gsub(">", "&gt;")
-                 .gsub("\"", "&quot;")
+          XmlEscape.call(content)
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Maps UML visibility strings to EA's single-character symbols.
+      #
+      # Centralised so that adding a new visibility level (e.g.
+      # "implementation" in Java) changes one hash entry, not three
+      # case/when branches across separate renderer files.
+      #
+      # EA's convention:
+      #   +  public
+      #   -  private
+      #   #  protected
+      #   ~  package
+      module VisibilitySymbol
+        SYMBOLS = {
+          "public" => "+",
+          "private" => "-",
+          "protected" => "#",
+          "package" => "~"
+        }.freeze
+
+        # @param visibility [String, nil] EA scope string ("Public",
+        #   "Private", etc.). Case-insensitive; nil defaults to public.
+        # @param with_space [Boolean] append a trailing space (used
+        #   by operation renderers: "+ method", not "+method").
+        # @return [String] the UML visibility symbol
+        def self.for(visibility, with_space: false)
+          symbol = SYMBOLS[(visibility || "public").downcase] || "+"
+          with_space ? "#{symbol} " : symbol
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter.rb

@@ -46,6 +46,7 @@ module Ea
       autoload :Label, "ea/svg/ea_emitter/label"
       autoload :Compartment, "ea/svg/ea_emitter/compartment"
       autoload :RenderContext, "ea/svg/ea_emitter/render_context"
+      autoload :VisibilitySymbol, "ea/svg/ea_emitter/visibility_symbol"
     end
   end
 end

data/lib/ea/svg/parity/source.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "ea"
 require "xmi"
-require "ea/sources/xmi/adapter"
 
 module Ea
   module Svg

data/lib/ea/svg/parity/suite.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "nokogiri"
-require "ea/svg/parity/checker"
 
 module Ea
   module Svg

data/lib/ea/transformers/qea_to_xmi/cardinality.rb

@@ -13,21 +13,42 @@ module Ea
       # `<upperValue value="M"/>`) — never a range string. This module
       # translates the EA form to a `{ lower:, upper: }` pair.
       #
-      # Default-when-empty: EA's "no bound specified" maps to UML's
-      # unspecified multiplicity, which Sparx renders as
-      # `<lowerValue value="0"/>` and `<upperValue value="-1"/>`.
-      # Always emitting both is required for round-trip parity with
-      # real Sparx XMI (see TODO 26).
+      # Default-when-empty: blank input maps to UML's unspecified
+      # multiplicity, `{ lower: "0", upper: "*" }`. Whether those
+      # bounds reach the document is the caller's call — EA leaves an
+      # association end bare when its card field is blank.
       module Cardinality
         # Tokens EA uses for "unbounded". Matched case-insensitively.
-        UNLIMITED_TOKENS = %w[* *-1 unbounded].freeze
+        UNLIMITED_TOKENS = %w[* *-1 -1 unbounded].freeze
 
-        # UML defaults when EA carries no explicit bound.
+        # UML defaults when EA carries no explicit bound. EA's wire
+        # form for unlimited is "*" (never "-1" — the reference
+        # exports contain no value="-1" at all).
         DEFAULT_LOWER = "0"
-        DEFAULT_UPPER = "-1"
+        DEFAULT_UPPER = "*"
+
+        # EA writes an explicit 1..1 for a Property whose t_attribute
+        # bound columns are BOTH blank, rather than falling back to the
+        # UML unspecified multiplicity.
+        DEFAULT_ATTRIBUTE_BOUNDS = { lower: "1", upper: "1" }.freeze
 
         module_function
 
+        # The bound pair for a t_attribute row. The 1..1 default is a
+        # property of the PAIR — with one column set, the missing side
+        # keeps the normal UML fallback, so `2` and a blank upper is
+        # 2..* rather than the invalid 2..1.
+        #
+        # @param lower [String, Integer, nil] t_attribute.lowerbound
+        # @param upper [String, Integer, nil] t_attribute.upperbound
+        # @return [Hash{Symbol=>String}] `{ lower:, upper: }`
+        def attribute_bounds(lower, upper)
+          both_blank = lower.to_s.strip.empty? && upper.to_s.strip.empty?
+          return DEFAULT_ATTRIBUTE_BOUNDS if both_blank
+
+          { lower: normalize_lower(lower), upper: normalize_upper(upper) }.freeze
+        end
+
         # @param raw [String, nil] e.g. "1..*", "0..1", "1", "*", nil
         # @return [Hash{Symbol=>String}] `{ lower:, upper: }` always
         #   populated; never nil. Empty/nil input returns the UML default.
@@ -38,17 +59,14 @@ module Ea
           return parse_range(stripped) if stripped.include?("..")
 
           # Bare unlimited token (e.g. "*") means "many" — lower bound
-          # is unspecified, which UML renders as 0..-1. Returning
-          # `{ lower: "-1", upper: "-1" }` here would be invalid:
-          # LiteralInteger cannot hold -1.
+          # is unspecified, which renders as 0..*.
           return defaults if UNLIMITED_TOKENS.include?(stripped.downcase)
 
-          single = normalize_bound(stripped)
-          { lower: single, upper: single }
+          { lower: stripped, upper: stripped }
         end
 
-        # Normalise an upper-bound token: `*` / `unbounded` → `-1`
-        # (UML LiteralUnlimitedNatural wire form).
+        # Normalise an upper-bound token: `*` / `unbounded` → `*`
+        # (the LiteralUnlimitedNatural wire form EA also uses).
         # @param raw [String, Integer, nil]
         # @return [String]
         def normalize_upper(raw)
@@ -57,17 +75,21 @@ module Ea
           stripped = raw.to_s.strip
           return DEFAULT_UPPER if stripped.empty?
 
-          UNLIMITED_TOKENS.include?(stripped.downcase) ? "-1" : stripped
+          UNLIMITED_TOKENS.include?(stripped.downcase) ? "*" : stripped
         end
 
         # Normalise a lower-bound token: empty/nil → "0" (UML default).
+        # Unlimited tokens also → "0" — a lower bound serializes as
+        # uml:LiteralInteger, which cannot hold `*` or `-1`.
         # @param raw [String, Integer, nil]
         # @return [String]
         def normalize_lower(raw)
           return DEFAULT_LOWER if raw.nil?
 
           stripped = raw.to_s.strip
-          stripped.empty? ? DEFAULT_LOWER : stripped
+          return DEFAULT_LOWER if stripped.empty?
+
+          UNLIMITED_TOKENS.include?(stripped.downcase) ? DEFAULT_LOWER : stripped
         end
 
         # ---- Internal helpers ----
@@ -78,17 +100,7 @@ module Ea
 
         def parse_range(stripped)
           lower, upper = stripped.split("..", 2)
-          { lower: normalize_bound(lower), upper: normalize_bound(upper) }
-        end
-
-        # A single bound token (one side of `..` or a bare scalar).
-        # Empty / `*` → UML unlimited (`-1`).
-        def normalize_bound(token)
-          return "-1" if token.nil?
-          return "-1" if token.strip.empty?
-
-          stripped = token.strip
-          UNLIMITED_TOKENS.include?(stripped.downcase) ? "-1" : stripped
+          { lower: normalize_lower(lower), upper: normalize_upper(upper) }
         end
       end
     end

data/lib/ea/transformers/qea_to_xmi/context.rb

@@ -9,6 +9,11 @@ module Ea
       # - ID-derivation helpers (`xmi_id_for`, `end_xmi_id_for`) backed by
       #   {GuidFormat}
       # - delegated database lookups (objects, packages, attributes, etc.)
+      # - the walk's position ordering (`sorted_by_position`), applied at
+      #   the lookup for operation parameters so the UML tree and the
+      #   extension block cannot disagree about their order. Attributes
+      #   and operations are deliberately left for their callers to
+      #   order — see `attributes_for`.
       #
       # The {Ea::Qea::Database} already maintains its own lookup indexes
       # (object-by-id, connectors-by-object, attributes-by-object, etc.).
@@ -33,6 +38,17 @@ module Ea
           GuidFormat.ea_guid_to_xmi_id(record.ea_guid, prefix: prefix)
         end
 
+        # Whether a record can anchor a synthesized id. EA derives a
+        # synthesized id's tail from its owner's GUID, so an owner
+        # without one yields a tailless id. Both the UML tree and the
+        # extension block ask this, so they cannot disagree about
+        # whether to emit the thing that id would have named.
+        # @param record [#ea_guid]
+        # @return [Boolean]
+        def identifiable?(record)
+          !record&.ea_guid.to_s.strip.empty?
+        end
+
         # @param connector_xmi_id [String]
         # @param side [Symbol] :source or :destination
         # @return [String]
@@ -66,6 +82,11 @@ module Ea
           database.objects_in_package(package_id)
         end
 
+        # Deliberately NOT ordered here, unlike params_for_operation:
+        # the extension block emits attributes in database order while
+        # the LI-bound preallocation sorts them by name, so each caller
+        # orders for itself. Sorting at this lookup would move export
+        # bytes.
         # @param object_id [Integer]
         # @return [Array<Ea::Qea::Models::EaAttribute>]
         def attributes_for(object_id)
@@ -78,10 +99,23 @@ module Ea
           database.operations_for_object(object_id)
         end
 
+        # t_operationparams is loaded with an unordered SELECT, and both
+        # the UML tree and the extension block emit parameters in Pos
+        # order. Ordering here means no caller can obtain them unordered.
         # @param operation_id [Integer]
         # @return [Array<Ea::Qea::Models::EaOperationParam>]
         def params_for_operation(operation_id)
-          database.operation_params_for(operation_id)
+          sorted_by_position(database.operation_params_for(operation_id))
+        end
+
+        # ---- Ordering -----------------------------------------------------
+
+        # EA emits a record's children in tree-position order (TPos / Pos),
+        # ties broken by name.
+        # @param records [Array<Ea::Qea::Models::BaseModel>]
+        # @return [Array<Ea::Qea::Models::BaseModel>]
+        def sorted_by_position(records)
+          records.sort_by { |record| [record.sort_position, record.name.to_s] }
         end
 
         # Connectors where the object is on either side.