ea 0.6.30 → 0.6.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0b7f42f300df411de328df0ab9c076927ef919fbe723cf262310107f1c324ba
-  data.tar.gz: 27d5559ae59009bb83a9fcf3d806354fe4300c52e7dc736820d798823fb578f4
+  metadata.gz: 6e23a708761ca82e0a23584e7c5ee557251532481defbd16712c676963ad7fbe
+  data.tar.gz: dfaeae3624f35848cf7d801e5fdf9c1bf990fa162514838353b98b282da76e51
 SHA512:
-  metadata.gz: '09b19a0e6f50428e7840bd962f741753b8512cc9d41cd00954a86467cf6e4965e2016e903a9f496162d63bc98415ab7c3b74b9c8e81c371e027a4074c48c7222'
-  data.tar.gz: eaa09bf8b99d624cb785581fa5c674c9cd2f37cbfac9a7554d4cfd21859f84edfe9643a6cc8ad1863b358b74c46bf656cf7ec4be5549796ed4f1f275c36d1f1d
+  metadata.gz: 8efc865e83d8c43843f276c3307158b90ea6674bdf252f39804c48f8cab7c98c765536f1b382773efe2a4a6fd629f97acb6e35d37fd545cdcd5a70f18b98f387
+  data.tar.gz: 9eee4896484462b96f7060de2700e893ab4cd2a76b6d4ee7217e1908d5003767914d4e80a9c06a9cea8723ca609f2bae965b903a86660000d2690d39ca442e92

data/lib/ea/sources/qea/diagram_builder.rb

@@ -165,8 +165,8 @@ module Ea
           target = diagram_object_placement(diagram_row.diagram_id, target_id)
           return nil unless source && target
 
-          source_bounds = bounds_from_rect(source)
-          target_bounds = bounds_from_rect(target)
+          source_bounds = drawn_bounds_for(source)
+          target_bounds = drawn_bounds_for(target)
           waypoints = if source_id == target_id
                         self_loop_waypoints(source_bounds)
                       else
@@ -224,8 +224,8 @@ module Ea
           target_placement = diagram_object_placement(diagram_row.diagram_id, target_id)
           return nil unless source_placement && target_placement
 
-          source_bounds = bounds_from_rect(source_placement)
-          target_bounds = bounds_from_rect(target_placement)
+          source_bounds = drawn_bounds_for(source_placement)
+          target_bounds = drawn_bounds_for(target_placement)
           waypoints = direct_waypoints(source_bounds, target_bounds)
           Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic("xc", diagram_row.diagram_id, object_id),
@@ -247,10 +247,15 @@ module Ea
         # renders as a straight line between the two element edges,
         # with SourceRole labels and appropriate markers.
         #
-        # Only Association and Aggregation types produce phantom
-        # connectors. Generalization, Dependency, and Package types
-        # do NOT get phantom rendering.
-        PHANTOM_CONNECTOR_TYPES = %w[Association Aggregation].freeze
+        # Dependency AND Generalization phantoms draw: Main/
+        # 9FCDB717 renders 12 of 13 model dependencies among the
+        # placed packages (the 13th suppressed by the diagram's
+        # single Hidden link row); All/F209CE4B renders all 11
+        # row-less generalizations as white triangles. A Hidden
+        # link row suppresses; absence of a row does not.
+        PHANTOM_CONNECTOR_TYPES = %w[Association Aggregation Dependency
+                                     Generalization].freeze
+        PHANTOM_DOUBLE_BACK_TYPES = %w[Dependency].freeze
 
         def phantom_connectors(diagram_row, explicit_connectors)
           placed_ids = placed_object_ids_on(diagram_row.diagram_id)
@@ -308,7 +313,7 @@ module Ea
             target_stereotype: conn.deststereotype,
             waypoints: waypoints,
             label_boxes: DEFAULT_LABEL_BOXES,
-            style: {},
+            style: PHANTOM_DOUBLE_BACK_TYPES.include?(conn.connector_type) ? { direct: true } : {},
             hidden: false,
             has_geometry_offsets: false
           )
@@ -378,7 +383,33 @@ module Ea
                                             connector.end_object_id)
           return [] unless source && target
 
-          direct_waypoints(bounds_from_rect(source), bounds_from_rect(target))
+          direct_waypoints(drawn_bounds_for(source),
+                           drawn_bounds_for(target))
+        end
+
+        # The outline EA clips connector rays against: the DRAWN
+        # autosized box, not the stored logical rect. Packages draw
+        # narrower than their stored rect (body = autosized tab +
+        # 15), so their docks land on the drawn edges (E58034A3:
+        # supplier right-edge dock 155 drawn vs 121 stored). All
+        # other element kinds draw at the stored rect.
+        PACKAGE_BODY_EXTRA = 15
+
+        def drawn_bounds_for(placement)
+          logical = bounds_from_rect(placement)
+          obj = database.find_object(placement.ea_object_id.to_i)
+          return logical unless obj && obj.object_type == "Package"
+
+          tab = ::Ea::Svg::EaEmitter::Element::PackageShapeRenderer
+                .autosized_tab_width(label: obj.name.to_s,
+                                     stereotype: obj.stereotype.to_s,
+                                     size: 7)
+          Ea::Model::Bounds.new(
+            x: logical.x,
+            y: logical.y,
+            width: tab + PACKAGE_BODY_EXTRA,
+            height: logical.height
+          )
         end
 
         # Straight-line waypoints between the two box-outline

data/lib/ea/sources/qea/relationship_builder.rb

@@ -62,9 +62,8 @@ module Ea
             target_multiplicity_upper: parse_upper(row.destcard),
             source_multiplicity_raw: raw_card(row.sourcecard),
             target_multiplicity_raw: raw_card(row.destcard),
-            source_aggregation: ConnectorRelationshipMap
-                                .source_aggregation_for(row.connector_type),
-            target_aggregation: aggregation_from(row.destaccess),
+            source_aggregation: source_aggregation_for(row),
+            target_aggregation: aggregation_from(row.destisaggregate),
             source_navigable: navigable?(row.sourceaccess, row.direction,
                                          :source),
             target_navigable: navigable?(row.destaccess, row.direction, :target)
@@ -112,15 +111,27 @@ module Ea
           end
         end
 
-        def aggregation_from(access_value)
-          case access_value.to_s
-          when "0" then "none"
-          when "1" then "shared"
-          when "2" then "composite"
+        # EA stores the aggregate end in t_connector.SourceIsAggregate/
+        # DestIsAggregate (0 none, 1 shared, 2 composite) — NOT in
+        # DestAccess, which carries the accessibility string
+        # ("Public"). The connector TYPE only implies a source-side
+        # aggregation when the flags are silent (legacy
+        # Connector_Type encoding).
+        def aggregation_from(flag_value)
+          case flag_value.to_i
+          when 1 then "shared"
+          when 2 then "composite"
           else "none"
           end
         end
 
+        def source_aggregation_for(row)
+          flagged = aggregation_from(row.sourceisaggregate)
+          return flagged if flagged != "none"
+
+          ConnectorRelationshipMap.source_aggregation_for(row.connector_type)
+        end
+
         def navigable?(_access, direction, end_label)
           # EA's navigability is messy. Treat unspecified direction
           # as bidirectional, "Source -> Destination" as target-only

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

@@ -58,17 +58,23 @@ module Ea
           pts = waypoints_for(connector)
           return nil if pts.size < 2
 
-          d = pts.each_with_index.map do |p, idx|
-            x, y = translate_point(p)
-            "#{idx.zero? ? 'M' : 'L'} #{Canvas.coord(x)} #{Canvas.coord(y)}"
-          end.join(" ")
-          # EA writes a trailing zero-length "M <start>" repeat for
-          # DIRECT (auto-routed straight) connectors — verified on
-          # context diagrams where every line carries it (B6847577,
-          # E58034A3, 8CF27BE8).
+          # DIRECT (auto-routed straight) connectors: EA writes the
+          # segment TARGET-FIRST with a trailing zero-length repeat —
+          # "M target L source M target" (B6847577, E58034A3,
+          # 8CF27BE8). Same pixels as source-first; only the byte
+          # order differs, so reversal lives here at the emitter and
+          # the marker anchoring (source = first waypoint) is
+          # untouched.
           if pts.size == 2 && direct?(connector)
-            x, y = translate_point(pts.first)
-            d = "#{d} M #{Canvas.coord(x)} #{Canvas.coord(y)}"
+            x1, y1 = translate_point(pts.first)
+            x2, y2 = translate_point(pts.last)
+            d = "M #{Canvas.coord(x2)} #{Canvas.coord(y2)} L #{Canvas.coord(x1)} #{Canvas.coord(y1)} " \
+                "M #{Canvas.coord(x2)} #{Canvas.coord(y2)}"
+          else
+            d = pts.each_with_index.map do |p, idx|
+              x, y = translate_point(p)
+              "#{idx.zero? ? 'M' : 'L'} #{Canvas.coord(x)} #{Canvas.coord(y)}"
+            end.join(" ")
           end
           %(<path d="#{d}" shape-rendering="auto"/>)
         end

data/lib/ea/svg/ea_emitter/marker/arrow_path.rb

@@ -16,6 +16,15 @@ module Ea
 
           def self.specs_for(connector, source, target, before_target,
                              after_source, relationship: nil)
+            # EA draws the navigability arrow on directed
+            # associations AND aggregations (333EFCCF: 6 aggregations
+            # render diamond + path arrow); Direction
+            # "Unspecified"/empty draws a plain line (EC670ED5: the
+            # single Unspecified association is arrowless;
+            # C852CC42/TransferNode: 9 Unspecified all arrowless).
+            direction = connector.direction.to_s
+            return [] if direction.empty? || direction == "Unspecified"
+
             return bidirectional_specs(source, target, before_target,
                                        after_source) if bidirectional?(connector)
 

data/lib/ea/svg/ea_emitter/marker/diamond.rb

@@ -4,49 +4,59 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # Diamond marker at the whole end of an aggregation or
-        # composition, PLUS a navigability arrow at the part end
-        # when the connector's direction is "Destination -> Source".
-        # Reference SVGs confirm EA emits BOTH markers for
-        # reverse-direction aggregations on the plateau: the diamond
-        # distinguishes aggregation from association, the arrow shows
-        # navigability direction. Forward-direction ("Source ->
-        # Destination") aggregations get the diamond only — verified
-        # against basic.qea's "Two Level Class Composition Hierarchy"
-        # diagram, where the reference SVG has 17 diamonds and 0
-        # arrows.
+        # Diamond marker at the whole end of an aggregation, plus a
+        # navigability arrow apexing at the diamond's line-side tip.
+        #
+        # WHOLE-END SELECTION: EA flags the whole end either through
+        # t_connector.DestAccess (1 shared / 2 composite -> whole at
+        # the TARGET; corpus-verified 333EFCCF: PersonalRight_E is
+        # the DestAccess=2 end and every diamond sits there) or
+        # through the Connector_Type itself ("Aggregation"/
+        # "Composition" -> whole at the SOURCE; basic.qea's
+        # composition diagram). DestAccess wins when both appear.
+        # Without relationship data the direction heuristic applies
+        # ("Destination -> Source" -> whole at target).
+        #
+        # ARROW: dest-flagged aggregations draw a base-12 height-15
+        # open arrow stacked on the diamond tip pointing into the
+        # whole (333EFCCF: 6 diamonds + 6 path arrows). Type-inferred
+        # source-side aggregations draw the diamond only (basic.qea:
+        # 17 diamonds, 0 arrows).
         class Diamond < Kind
           def self.handles?(effective_type)
             effective_type == "Aggregation" || effective_type == "Composition"
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
-            whole_end_at_source = whole_end_at_source?(connector)
-            whole_anchor = whole_end_at_source ? source : target
-            whole_base = whole_end_at_source ? after_source : before_target
+            whole_at_target = whole_at_target?(connector, relationship)
+            whole_anchor = whole_at_target ? target : source
+            whole_base = whole_at_target ? before_target : after_source
             specs = [Registry::Spec.new(shape: :diamond,
                                         anchor: whole_anchor,
                                         base: whole_base)]
-            return specs unless navigable_part_end?(connector)
+            return specs unless whole_at_target
 
-            part_anchor = whole_end_at_source ? target : source
-            part_base = whole_end_at_source ? before_target : after_source
             specs << Registry::Spec.new(shape: :arrow,
-                                        anchor: part_anchor,
-                                        base: part_base)
+                                        anchor: whole_anchor,
+                                        base: whole_base)
             specs
           end
 
-          # EA renders the navigability arrow at the part end of an
-          # aggregation only when the connector's direction is
-          # "Destination -> Source" — the conventional EA encoding
-          # for "part -> whole" with navigability back to the whole.
-          # Forward-direction aggregations ("Source -> Destination")
-          # omit the arrow: the diamond already communicates the
-          # aggregation semantic and the destination is not
-          # explicitly navigable.
-          def self.navigable_part_end?(connector)
-            connector.direction == "Destination -> Source"
+          def self.whole_at_target?(connector, relationship)
+            return true if dest_flagged?(relationship)
+            return false if source_flagged?(relationship)
+
+            !whole_end_at_source?(connector)
+          end
+
+          def self.dest_flagged?(relationship)
+            relationship &&
+              %w[shared composite].include?(relationship.target_aggregation.to_s)
+          end
+
+          def self.source_flagged?(relationship)
+            relationship &&
+              %w[shared composite].include?(relationship.source_aggregation.to_s)
           end
         end
       end

data/lib/ea/svg/ea_emitter/marker/open_triangle.rb

@@ -14,14 +14,19 @@ module Ea
         # the diagram's generalizations use polygons.
         class OpenTriangle < Kind
           def self.handles?(effective_type)
-            %w[Generalization Realization Dependency].include?(effective_type)
+            %w[Generalization Realization Realisation Dependency
+               InformationFlow NoteLink].include?(effective_type)
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
             whole_end_at_source = whole_end_at_source?(connector)
             anchor = whole_end_at_source ? target : source
             base = whole_end_at_source ? before_target : after_source
-            shape = effective_type?(connector) == "Dependency" ? :dependency_arrow : :triangle
+            shape = if %w[Dependency InformationFlow].include?(effective_type?(connector))
+                    :dependency_arrow
+                  else
+                    :triangle
+                  end
             [Registry::Spec.new(shape: shape, anchor: anchor, base: base)]
           end
 

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

@@ -44,7 +44,19 @@ module Ea
           !attr_lines.empty? || !op_lines.empty? ||
             enum_literals.any? || tagged_values.any? ||
             (constraints&.any?) ||
-            (!package_content_lines.nil? && !package_content_lines.empty?)
+            (!package_content_lines.nil? && !package_content_lines.empty?) ||
+            hidden_features_present?
+        end
+
+        # EA draws the header divider whenever the element HAS a
+        # feature compartment — even one whose rows are all hidden
+        # by visibility flags (10E3E08A: CodeList with 3 attributes
+        # toggled off still renders the divider over an empty body;
+        # only feature-less elements omit it).
+        def hidden_features_present?
+          return false unless classifier.respond_to?(:properties)
+
+          classifier.properties.any? || classifier.operations.any?
         end
       end
     end

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.30"
+  VERSION = "0.6.32"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.30
+  version: 0.6.32
 platform: ruby
 authors:
 - Ribose Inc.