ea 0.6.132 → 0.6.134

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a542204dd94a1259f110781e2aefa2240a73ad54b382e50e23599efd1ecc81e7
-  data.tar.gz: a508d4a7764678223708a317bc624f1e3eec295317e082cc15227705deac8343
+  metadata.gz: 3320f99ef26e1639eaa88eba212fe6620cc7c25b5337681431bf1ba991c384c1
+  data.tar.gz: 3a72b42b4c3dd40b4254ec74684b3e74a25e6f35f1efc85ec8e7bb1fc59f113b
 SHA512:
-  metadata.gz: 2df081d4e9815a2006c2de93f590a748bba596f8550bc9546a5e505f8cdda94b0519a13a32d90106527123685e4432161227ab6f00c73f1d8520d305bac44a6d
-  data.tar.gz: a100a9f9fb968da363f620390edc2e72321e9129032ed616c4cce9d9e0caefac8d3ea5fcae04a406dff42e2c08bb331f7742ab9ed5fccc528970a74270897d4d
+  metadata.gz: 8ce24e25f39d48215c9dcbe03b8c86a932ffd310d64f228e6e5603448814faf84fc023f1a07dae736f4dabb926970b86d1bd478e51d640366462c1765a643796
+  data.tar.gz: 19a7f0f2e20a3985c32de44288755f7daa7f5f35e41908c6491a9ada31562059c20826e75d7482ad494b8e9c2e15ab32f5635f1801607c359f7fcdc6a455ea50

data/lib/ea/model/document.rb

@@ -58,11 +58,8 @@ module Ea
       # `model_element_ref` lookups from diagram elements resolve.
       def index_by_id
         @index_by_id ||= begin
-          idx = {}
-          packages.each do |p|
-            idx[p.id] = p
-            alias_eaid_for_package(idx, p)
-          end
+          idx = PackageAliasIndex.new
+          packages.each { |p| idx[p.id] = p }
           classifiers.each { |c| idx[c.id] = c }
           relationships.each { |r| idx[r.id] = r }
           stereotypes.each { |s| idx[s.id] = s }
@@ -98,12 +95,6 @@ module Ea
         property_index[id]
       end
 
-      def alias_eaid_for_package(idx, package)
-        return unless package.id&.start_with?("EAPK_")
-
-        idx["EAID_#{package.id[5..]}"] = package
-      end
-
       def root_packages
         packages.select { |p| p.parent_id.nil? }
       end

data/lib/ea/model/package_alias_index.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Id-keyed lookup in which a package stored under `EAPK_<guid>`
+    # also answers to `EAID_<guid>`, without a second entry: `values`
+    # lists each package once.
+    class PackageAliasIndex < Hash
+      def [](id)
+        super || package_alias(id)
+      end
+
+      private
+
+      def package_alias(id)
+        return unless id.is_a?(String) && id.start_with?("EAID_")
+
+        fetch("EAPK_#{id[5..]}", nil)
+      end
+    end
+  end
+end

data/lib/ea/model.rb

@@ -19,6 +19,7 @@ module Ea
     autoload :Base, "ea/model/base"
     autoload :Metadata, "ea/model/metadata"
     autoload :Point, "ea/model/point"
+    autoload :PackageAliasIndex, "ea/model/package_alias_index"
     autoload :Bounds, "ea/model/bounds"
     autoload :Waypoint, "ea/model/waypoint"
     autoload :Annotation, "ea/model/annotation"

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

@@ -182,6 +182,7 @@ module Ea
           def correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
             return model if context
             return notelink_stored_ray(model, link_row, diagram_row, geom) if model.connector_type == "NoteLink"
+            return package_stored_ray(model, link_row, diagram_row, geom) if model.connector_type == "Package"
             return model unless stored_ray_candidate?(model, link_row, geom)
 
             source, target = stored_ray_boxes(link_row, diagram_row)
@@ -199,6 +200,42 @@ module Ea
             model
           end
 
+          # An empty custom-line package import has no authored bend. When
+          # its stored mathematical origins share a row inside both boxes,
+          # clip that ray instead of the computed EDGE2 port jog.
+          def package_stored_ray(model, link_row, diagram_row, geom)
+            return model unless package_ray_candidate?(model, link_row, geom)
+
+            boxes = stored_ray_boxes(link_row, diagram_row)
+            origins = level_package_origins(boxes, geom)
+            return model unless origins
+
+            model.waypoints = package_ray_waypoints(boxes, origins.first.y)
+            model.source_anchor, model.target_anchor = origins
+            model
+          end
+
+          def package_ray_candidate?(model, link_row, geom)
+            model.waypoints.size == 3 && link_row.path.to_s.empty? &&
+              model.style.values_at(:mode, :lwidth, :tree) == ["3", "0", nil] &&
+              geom[:edge] == 2 && geom.values_at(:sx, :sy, :ex, :ey).all?
+          end
+
+          def level_package_origins(boxes, geom)
+            return unless horizontal_ray_gap?(*boxes)
+
+            origins = association_ray_origins(*boxes, geom, "0")
+            origins if origins && origins.first.y == origins.last.y
+          end
+
+          def package_ray_waypoints(boxes, row)
+            rightward = boxes[0].x < boxes[1].x
+            boxes.each_with_index.map do |box, index|
+              x = box.x + (rightward == index.zero? ? box.width : 0)
+              Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: row))
+            end
+          end
+
           # A straight top-docked NoteLink uses mathematical saved Y offsets,
           # like the other custom rays, while authored bends keep their ports.
           def notelink_stored_ray(model, link_row, diagram_row, geom)

data/lib/ea/sources/xmi/classifier_builder.rb

@@ -82,18 +82,14 @@ module Ea
           { literals: literals }
         end
 
+        # A name that already carries a namespace prefix
+        # (e.g. "gml:CodeType") is the qualified name as saved.
         def qualified_name(element, containing_package)
-          # The XMI's `name` attribute may already be in
-          # "ns:Class" form (e.g. "xs:string" lives in the `xs`
-          # package). Forcing the package name in front would
-          # produce "xs::xs:string". Strip the existing namespace
-          # prefix from the simple name before composing the
-          # qualified name.
-          raw = element.name.to_s
-          simple = raw.split(":").last
-          simple = raw if simple.nil? || simple.empty?
+          name = element.name.to_s
+          return name if name.include?(":")
+
           pkg_name = containing_package&.name
-          pkg_name ? "#{pkg_name}::#{simple}" : simple
+          pkg_name ? "#{pkg_name}::#{name}" : name
         end
 
         def boolean(value)

data/lib/ea/sources/xmi/diagram_builder/umldi_edges.rb

@@ -6,9 +6,10 @@ module Ea
   module Sources
     module Xmi
       class DiagramBuilder
-        # Ordered waypoints of the UMLDI edge EA exported for a connector
-        # on a diagram. A connector drawn by more than one edge in the same
-        # diagram, or by an edge with fewer than two waypoints, has no route.
+        # The UMLDI edge EA exported for a connector on a diagram: its
+        # ordered waypoints and its source/target model elements. A connector
+        # drawn by more than one edge in the same diagram has neither; an edge
+        # with fewer than two waypoints has no route.
         class UmldiEdges
           def initialize(xmi_path)
             @xmi_path = xmi_path
@@ -18,8 +19,34 @@ module Ea
             routes.dig(diagram_id, connector_id)
           end
 
+          def ends_for(diagram_id, connector_id)
+            ends.dig(diagram_id, connector_id)
+          end
+
           private
 
+          def ends
+            @ends ||= doc.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
+              [diagram["id"] || diagram["xmi:id"], diagram_ends(diagram)]
+            end
+          end
+
+          def diagram_ends(diagram)
+            unique_edges(diagram).each_with_object({}) do |(connector_id, edge), acc|
+              acc[connector_id] = [edge["source"], edge["target"]] if edge["source"] && edge["target"]
+            end
+          end
+
+          # Edges keyed by connector, keeping only connectors drawn by exactly
+          # one edge of the diagram, whatever that edge carries.
+          def unique_edges(diagram)
+            diagram.xpath("./ownedElement[@modelElement]")
+                   .select { |node| node.attributes["type"]&.value.to_s.end_with?("UMLEdge") }
+                   .group_by { |edge| edge["modelElement"] }
+                   .select { |_, same| same.one? }
+                   .transform_values(&:first)
+          end
+
           def routes
             @routes ||= doc.xpath("//*[local-name()=\"Diagram\"]").to_h do |diagram|
               [diagram["id"] || diagram["xmi:id"], diagram_routes(diagram)]
@@ -27,9 +54,8 @@ module Ea
           end
 
           def diagram_routes(diagram)
-            edges = diagram.xpath("./ownedElement[@modelElement][waypoint]").group_by { |edge| edge["modelElement"] }
-            edges.each_with_object({}) do |(connector_id, same), acc|
-              points = same.one? ? waypoints(same.first) : []
+            unique_edges(diagram).each_with_object({}) do |(connector_id, edge), acc|
+              points = waypoints(edge)
               acc[connector_id] = points if points.size >= 2
             end
           end

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

@@ -52,10 +52,12 @@ module Ea
             name: props&.name || ext_diagram.id,
             package_id: ext_diagram.model&.package,
             diagram_type: props&.type&.split(":")&.last&.downcase,
-            bounds: canvas_bounds(placed_elements),
+            bounds: page_bounds(ext_diagram),
             style: style_for(ext_diagram),
             style_ex: style_ex_for(ext_diagram),
             show_notes: style_ex_for(ext_diagram).to_s.include?("ShowNotes=1"),
+            show_package_contents: style_flag?(ext_diagram, "PackageContents"),
+            show_foreign: style_flag?(ext_diagram, "HighlightForeign"),
             elements: build_elements(placed_elements, id, umldi_keywords),
             connectors: build_connectors(placed_connectors,
                                           placed_elements, id),
@@ -89,18 +91,18 @@ module Ea
 
         private
 
-        def canvas_bounds(placed_elements)
-          return nil if placed_elements.empty?
+        def style_flag?(ext_diagram, key)
+          value = style_for(ext_diagram).to_s[/(?:\A|;)#{key}=(\d+)/, 1]
+          value.to_i.nonzero? ? true : false
+        end
 
-          left = placed_elements.map { |e| e.geometry.img_left || e.geometry.left }.compact.min
-          top = placed_elements.map { |e| e.geometry.img_top || e.geometry.top }.compact.min
-          right = placed_elements.map { |e| e.geometry.img_right || e.geometry.right }.compact.max
-          bottom = placed_elements.map { |e| e.geometry.img_bottom || e.geometry.bottom }.compact.max
-          return nil unless left && top && right && bottom
+        def page_bounds(ext_diagram)
+          style = style_for(ext_diagram).to_s
+          width = style[/(?:\A|;)DocSize\.cx=(\d+)/, 1]
+          height = style[/(?:\A|;)DocSize\.cy=(\d+)/, 1]
+          return nil unless width && height
 
-          Ea::Model::Bounds.new(x: 0, y: 0,
-                                 width: right - left,
-                                 height: bottom - top)
+          Ea::Model::Bounds.new(x: 0, y: 0, width: width.to_i, height: height.to_i)
         end
 
         def build_elements(placed, owner_id, umldi_keywords = {})
@@ -110,12 +112,13 @@ module Ea
         def build_element(placed, owner_id, umldi_keywords = {})
           geom = placed.geometry
           style = placed.style
+          bounds = build_bounds(geom.left, geom.top, geom.right, geom.bottom)
           Ea::Model::DiagramElement.new(
             id: IdNormalizer.synthetic_id(owner_id, "elem", placed.subject),
             diagram_id: owner_id,
             model_element_ref: placed.subject,
-            bounds: build_bounds(geom.left, geom.top, geom.right, geom.bottom),
-            image_bounds: build_bounds(geom.img_left, geom.img_top, geom.img_right, geom.img_bottom),
+            bounds: bounds,
+            image_bounds: (build_bounds(geom.img_left, geom.img_top, geom.img_right, geom.img_bottom) unless bounds),
             background_color: style.background_color,
             line_color: style.line_color,
             line_width: style.line_width,
@@ -146,17 +149,19 @@ module Ea
           by_duid = placed_elements.each_with_object({}) do |pe, acc|
             acc[pe.style.duid] = pe if pe.style.duid
           end
+          by_subject = placed_elements.group_by { |pe| guid_key(pe.subject) }
 
           placed_connectors.each_with_index.map do |placed, index|
-            build_connector(placed, by_duid, owner_id, index)
+            build_connector(placed, by_duid, by_subject, owner_id, index)
           end
         end
 
-        def build_connector(placed, by_duid, owner_id, rank)
+        def build_connector(placed, by_duid, by_subject, owner_id, rank)
           geom = placed.geometry
           style = placed.style
-          source = by_duid[style.soid]
-          target = by_duid[style.eoid]
+          edge_source, edge_target = umldi_ends(owner_id, placed)
+          source = by_duid[style.soid] || sole_placement(by_subject, edge_source)
+          target = by_duid[style.eoid] || sole_placement(by_subject, edge_target)
           ext_meta = connector_meta(placed.subject)
           route = connector_route(placed, source, target, owner_id, ext_meta[:ea_type])
           Ea::Model::DiagramConnector.new(
@@ -234,6 +239,23 @@ module Ea
           route&.map { |x, y| Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y)) }
         end
 
+        def umldi_ends(diagram_id, placed)
+          return unless xmi_path
+
+          umldi_edges.ends_for(diagram_id, placed.subject)
+        end
+
+        def sole_placement(by_subject, subject)
+          placements = by_subject[guid_key(subject)]
+          placements.first if placements&.one?
+        end
+
+        # EA spells one GUID with an EAID_ or EAPK_ prefix and mixed case
+        # depending on the element kind.
+        def guid_key(subject)
+          subject&.sub(/\AEA(?:ID|PK)_/, "")&.upcase
+        end
+
         def umldi_edges
           @umldi_edges ||= UmldiEdges.new(xmi_path)
         end

data/lib/ea/sources/xmi/legend_builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Builds an `Ea::Model::Legend` from the `value` of an element's
+      # `<xrefs>` element. The CustomProperties description inside it
+      # uses the same `@PROP=...@ENDPROP;` encoding as the QEA t_xref
+      # row, so parsing is delegated to the QEA legend builder.
+      #
+      # Returns nil when the value carries no legend properties.
+      class LegendBuilder
+        CLIENT = "xmi-element"
+
+        XrefRow = Struct.new(:name, :description)
+
+        # Answers the one CustomProperties xref lookup the QEA builder makes.
+        class SingleElementXrefs
+          def initialize(description)
+            @rows = [XrefRow.new(Qea::LegendBuilder::LEGEND_XREF_NAME, description)]
+          end
+
+          def xrefs_for_client(_guid)
+            @rows
+          end
+        end
+
+        def initialize(xrefs_value)
+          @xrefs_value = xrefs_value
+        end
+
+        def build
+          return nil if @xrefs_value.to_s.empty?
+
+          Qea::LegendBuilder.new(SingleElementXrefs.new(@xrefs_value)).build_for(CLIENT)
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/xmi/note_builder.rb

@@ -10,9 +10,12 @@ module Ea
       # inside `<xmi:Extension>/<elements>`. Each carries a
       # `<properties documentation="..."/>` child with the body text.
       #
-      # The xmi gem parses Note elements as part of the extension
-      # block; we walk them and project to Ea::Model::Note.
+      # `uml:Text` elements are projected the same way; those whose
+      # CustomProperties xref carries legend configuration also
+      # get an `Ea::Model::Legend` payload.
       class NoteBuilder
+        NOTE_TYPES = { "uml:Note" => "Note", "uml:Text" => "Text" }.freeze
+
         attr_reader :root
 
         def initialize(root)
@@ -29,17 +32,23 @@ module Ea
         private
 
         def build_one(ext_element)
-          type = ext_element.type
-          return nil unless type == "uml:Note"
+          note_type = NOTE_TYPES[ext_element.type]
+          return nil unless note_type
 
-          props = ext_element.properties
           Ea::Model::Note.new(
             id: ext_element.idref,
             name: ext_element.name,
-            body: props&.documentation,
-            note_type: "Note"
+            body: ext_element.properties&.documentation,
+            note_type: note_type,
+            legend: legend_for(ext_element, note_type)
           )
         end
+
+        def legend_for(ext_element, note_type)
+          return nil unless note_type == "Text"
+
+          LegendBuilder.new(ext_element.xrefs&.value).build
+        end
       end
     end
   end

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

@@ -9,6 +9,8 @@ module Ea
       class RelationshipBuilder
         # Connector types that imply an aggregation on the source end
         # when the end itself records none.
+        CONNECTOR_STEREOTYPE = /(?<=@STEREO;Name=)[^;]+/
+
         AGGREGATION_FOR_CONNECTOR_TYPE = {
           "Aggregation" => "shared",
           "Composition" => "composite"
@@ -28,7 +30,7 @@ module Ea
             rel = build_one(element)
             relationships << rel if rel
           end
-          relationships
+          relationships + package_import_relationships(relationships)
         end
 
         def build_one(element)
@@ -40,6 +42,30 @@ module Ea
 
         private
 
+        def package_import_relationships(built)
+          built_ids = built.to_set(&:id)
+          connector_index.filter_map do |id, connector|
+            next if built_ids.include?(id) || connector.properties&.ea_type != "Package"
+
+            package_import_relationship(id, connector)
+          end
+        end
+
+        def connector_stereotype(connector)
+          connector&.xrefs&.value.to_s[CONNECTOR_STEREOTYPE]
+        end
+
+        def package_import_relationship(id, connector)
+          Ea::Model::Association.new(
+            id: id,
+            stereotype: connector_stereotype(connector),
+            source_id: connector.source&.idref,
+            target_id: connector.target&.idref,
+            source_navigable: navigable?(id, :source),
+            target_navigable: navigable?(id, :target)
+          )
+        end
+
         def walk(element, &block)
           yield element if block
           element.packaged_element.each { |inner| walk(inner, &block) }
@@ -51,6 +77,7 @@ module Ea
             id: id,
             name: element.name,
             qualified_name: element.name,
+            stereotype: connector_stereotype(connector_index[id]),
             annotations: AnnotationBuilder.from_element(element, id)
           }
         end
@@ -88,8 +115,8 @@ module Ea
             target_multiplicity_raw: raw_card(target.type&.multiplicity),
             source_aggregation: source_aggregation(connector),
             target_aggregation: target.type&.aggregation || "none",
-            source_navigable: navigable?(element, :source),
-            target_navigable: navigable?(element, :target)
+            source_navigable: navigable?(element.id, :source),
+            target_navigable: navigable?(element.id, :target)
           }
         end
 
@@ -118,8 +145,8 @@ module Ea
             target_multiplicity_upper: parse_upper(target_end),
             source_aggregation: source_end&.aggregation || "none",
             target_aggregation: target_end&.aggregation || "none",
-            source_navigable: navigable?(element, :source),
-            target_navigable: navigable?(element, :target)
+            source_navigable: navigable?(element.id, :source),
+            target_navigable: navigable?(element.id, :target)
           }
         end
 
@@ -197,8 +224,8 @@ module Ea
           end
         end
 
-        def navigable?(element, endpoint)
-          connector = connector_index[element.id]
+        def navigable?(id, endpoint)
+          connector = connector_index[id]
           end_element = connector&.public_send(endpoint)
           flag = end_element&.modifiers&.is_navigable
           flag.nil? || flag

data/lib/ea/sources/xmi.rb

@@ -25,6 +25,7 @@ module Ea
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
       autoload :TagBuilder, "ea/sources/xmi/tag_builder"
+      autoload :LegendBuilder, "ea/sources/xmi/legend_builder"
       autoload :NoteBuilder, "ea/sources/xmi/note_builder"
       autoload :StereotypeBuilder, "ea/sources/xmi/stereotype_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"

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.132"
+  VERSION = "0.6.134"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.132
+  version: 0.6.134
 platform: ruby
 authors:
 - Ribose Inc.
@@ -680,6 +680,7 @@ files:
 - lib/ea/model/note.rb
 - lib/ea/model/operation.rb
 - lib/ea/model/package.rb
+- lib/ea/model/package_alias_index.rb
 - lib/ea/model/parameter.rb
 - lib/ea/model/point.rb
 - lib/ea/model/polymorphic_maps.rb
@@ -858,6 +859,7 @@ files:
 - lib/ea/sources/xmi/extension_types.rb
 - lib/ea/sources/xmi/id_normalizer.rb
 - lib/ea/sources/xmi/instance_builder.rb
+- lib/ea/sources/xmi/legend_builder.rb
 - lib/ea/sources/xmi/metadata_builder.rb
 - lib/ea/sources/xmi/note_builder.rb
 - lib/ea/sources/xmi/operation_builder.rb