ea 0.6.14 → 0.6.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80dad306c8a1e15bbabb2a01af81700b3ab4ca4010f1fd9c4d9f0e2136ccf834
-  data.tar.gz: 07a78eefd9c86ef3b025621a6b89013d1f988529a2bcd835b465cd43e0b98fa3
+  metadata.gz: a8c5868e2f18d7a28583d8e862f15f7f3f46703012ba58914d273a12f390b357
+  data.tar.gz: 61024b7e2ddb30066b9daafcad0ba9b324451e70d2344db82ab2106fc16e53e5
 SHA512:
-  metadata.gz: 274a1276005d3863049b801c9d044dd7aa4952749041b7ad6ed63b691771bb73779c0a1567a6068c436033c758c7beb59c14e39d7e95cc467058fd6b89f28065
-  data.tar.gz: 6600d5ecef1586cd5a566236237b0a6fb1692357ec41a7a7f0b887d294e8ed757611a9473b920807b75c499feb0e107ae953447d01ff5e9c0843482e7a942ede
+  metadata.gz: 76574a19dbc1a01c1add8adca00fad58dc18b436ba28869564e5bab050609fc701b5cc0874d6693d9553e670120bd19582d91477a41981e7a2ed8812dd2b45a5
+  data.tar.gz: cfe049c8be3f068b1dedc0f65dff2fb2b856b0eee9eafa63efd2fdd088ab0a71bd7894ce86693cb06d574baae6c686a7aa5afca2f507f1c60ff0e8e8d36e6b5c

data/lib/ea/model/classifier.rb

@@ -15,6 +15,8 @@ module Ea
       attribute :package_id, :string # containing package
       attribute :package_name, :string # containing package name
       attribute :is_abstract, :boolean, default: false
+      attribute :is_root, :boolean, default: false
+      attribute :is_leaf, :boolean, default: false
       attribute :visibility, :string
       attribute :model_kind, :string, default: -> { "classifier" }
       attribute :properties, Property, collection: true, initialize_empty: true
@@ -31,6 +33,8 @@ module Ea
         map "packageId", to: :package_id
         map "packageName", to: :package_name
         map "isAbstract", to: :is_abstract, render_default: true
+        map "isRoot", to: :is_root, render_default: true
+        map "isLeaf", to: :is_leaf, render_default: true
         map "visibility", to: :visibility
         map "modelKind", to: :model_kind, render_default: true
         map "properties", to: :properties, render_empty: true

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

@@ -94,6 +94,8 @@ module Ea
             package_name: package_name_for(object),
             qualified_name: qualified_name_for(object),
             is_abstract: abstract?(object),
+            is_root: object.isroot.to_i == 1,
+            is_leaf: object.isleaf.to_i == 1,
             visibility: visibility_from_scope(object.scope),
             properties: properties_for(object),
             operations: OperationBuilder.new(database).build_all_for(object),

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

@@ -377,15 +377,31 @@ module Ea
                          element_edge_point(target_placement, :target, edge_out)
 
           intermediate = intermediate_waypoints(link_row)
-          if edge_out == 2 && source_port && target_port
-            # EA computes tree routes at DRAW TIME from current
-            # element positions — the stored Path is stale for them
-            # (hand-verified: SY 8542 stored corner (271,-42) vs EA
-            # drawn (298,70)). Route: source port -> corner at
-            # (target dock x, source exit y) -> target port.
+          if edge_out == 2 && source_port && target_port &&
+             !valid_tree_path?(intermediate, source_placement)
+            # EA recomputes tree routes at DRAW TIME from current
+            # element positions when the stored Path no longer lands
+            # on the source's facing edge (hand-verified: SY 8542's
+            # stale Path vs EA-drawn route; CityObjectGroup's current
+            # Path renders byte-exact and is kept). Computed route:
+            # source port -> corner at (target dock x, source exit
+            # y) -> target port.
             points = [[source_point[0], source_point[1]],
                       [target_point[0], source_point[1]],
                       [target_point[0], target_point[1]]]
+          elsif edge_out == 2 && intermediate.size == 1
+            # Current tree Path (bend on the source's facing edge):
+            # EA's draw-time route shape — source right edge at the
+            # bend's y, corner at the bend, target facing edge at the
+            # bend's x (byte-exact on CityObjectGroup).
+            src = bounds_from_rect(source_placement)
+            tgt = bounds_from_rect(target_placement)
+            bend = intermediate.first
+            going_up = tgt.y + tgt.height <= src.y
+            target_y = going_up ? tgt.y + tgt.height : tgt.y
+            points = [[src.x + src.width, bend[1]],
+                      [bend[0], bend[1]],
+                      [bend[0], target_y]]
           elsif intermediate.any?
             points = [source_point, *intermediate, target_point]
           elsif source_port || target_port
@@ -401,6 +417,19 @@ module Ea
           end
         end
 
+        # A tree Path is current when its bend height still falls
+        # within the source element's y-range (the exit height EA
+        # records); a bend outside the element is stale and EA
+        # re-derives the route at draw time. The bend's x may sit
+        # arbitrarily far right (trunk position).
+        def valid_tree_path?(intermediate, source_placement)
+          return false if intermediate.empty?
+
+          bend = intermediate.first
+          b = bounds_from_rect(source_placement)
+          bend[1].between?(b.y - 5, b.y + b.height + 5)
+        end
+
         # Absolute connection point EA docks the connector's visible
         # endpoint at, derived from the Geometry SX/SY (source) and
         # EX/EY (target) offsets. The offsets are measured inward from

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

@@ -20,6 +20,8 @@ module Ea
           attr_reader :bounds, :size, :header_lines_count,
                       :attr_lines_count, :op_lines_count,
                       :tagged_values_count,
+                      :constraints_count,
+                      :enum_literals_count,
                       :header_top_padding, :header_line_offset,
                       :divider_offset, :attr_line_offset,
                       :attr_first_offset
@@ -27,6 +29,8 @@ module Ea
           def initialize(bounds:, size:, header_lines_count:,
                           attr_lines_count:, op_lines_count:,
                           tagged_values_count:,
+                          constraints_count: 0,
+                          enum_literals_count: 0,
                           header_top_padding: 12,
                           header_line_offset: 6,
                           divider_offset: 8,
@@ -38,6 +42,8 @@ module Ea
             @attr_lines_count = attr_lines_count
             @op_lines_count = op_lines_count
             @tagged_values_count = tagged_values_count
+            @constraints_count = constraints_count
+            @enum_literals_count = enum_literals_count
             @header_top_padding = header_top_padding
             @header_line_offset = header_line_offset
             @divider_offset = divider_offset
@@ -102,11 +108,24 @@ module Ea
           # present). EA does not emit a separate divider — the
           # italic "tags" header marks the compartment.
           def tagged_value_first_y
-            return nil unless tagged_values_count&.positive?
+            return nil unless tagged_values_count.to_i.positive? || constraints_count.to_i.positive?
 
-            base = attr_bottom_y
-            base = op_bottom_y if op_lines_count&.positive?
-            base + size + 5
+            content_bottom_y + size + 5
+          end
+
+          # The lowest content edge among attributes, enum literals,
+          # and operations — the anchor for trailing compartments.
+          def content_bottom_y
+            bottoms = [attr_bottom_y]
+            bottoms << enum_literals_bottom_y if enum_literals_count.to_i.positive?
+            bottoms << op_bottom_y if op_lines_count.to_i.positive?
+            bottoms.compact.max
+          end
+
+          def enum_literals_bottom_y
+            return nil unless enum_literal_first_y
+
+            enum_literal_first_y + ([enum_literals_count, 1].max - 1) * (size + 6)
           end
         end
       end

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

@@ -82,7 +82,9 @@ module Ea
           op_lines = (is_classifier && show_operations?) ? Element::OperationRenderer.lines_for(classifier) : []
           geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
                                            tagged_values_for(classifier).size,
-                                           header_lines)
+                                           header_lines,
+                                           constraints_count: constraints_for(classifier).size,
+                                           enum_literals_count: enum_literals_for(classifier).size)
           # EA suppresses the whole attribute compartment when it does
           # not fit the stored box height (never truncates rows) - the
           # AOS box on CityFurniture hides its association property
@@ -92,7 +94,9 @@ module Ea
             attr_lines = []
             geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
                                              tagged_values_for(classifier).size,
-                                             header_lines)
+                                             header_lines,
+                                             constraints_count: constraints_for(classifier).size,
+                                           enum_literals_count: enum_literals_for(classifier).size)
           end
           # EA suppresses the operations compartment when its rows
           # overflow the stored box height (same rule as attributes).
@@ -101,7 +105,9 @@ module Ea
             op_lines = []
             geometry = compartment_geometry(bounds, size, attr_lines, op_lines,
                                              tagged_values_for(classifier).size,
-                                             header_lines)
+                                             header_lines,
+                                             constraints_count: constraints_for(classifier).size,
+                                           enum_literals_count: enum_literals_for(classifier).size)
           end
           RenderContext.new(
             element: element,
@@ -130,12 +136,15 @@ module Ea
         end
 
         def compartment_geometry(bounds, size, attr_lines, op_lines,
-                                 tagged_count, header_lines)
+                                 tagged_count, header_lines,
+                                 constraints_count: 0, enum_literals_count: 0)
           CompartmentGeometry.new(bounds: bounds, size: size,
                                    header_lines_count: header_lines.size,
                                    attr_lines_count: attr_lines.size,
                                    op_lines_count: op_lines.size,
                                    tagged_values_count: tagged_count,
+                                   constraints_count: constraints_count,
+                                   enum_literals_count: enum_literals_count,
                                    header_top_padding: header_padding_for(header_lines),
                                    header_line_offset: theme.compartments.header_line_offset,
                                    divider_offset: theme.compartments.divider_offset,
@@ -185,7 +194,24 @@ module Ea
         def constraints_for(classifier)
           return [] unless classifier.is_a?(Ea::Model::Classifier)
 
-          classifier.constraints || []
+          marker_line = root_leaf_marker_for(classifier)
+          marker = marker_line ? [marker_constraint(marker_line)] : []
+          marker + (classifier.constraints || [])
+        end
+
+        # EA renders the element's Root/Leaf checkboxes as {root},
+        # {leaf}, or {root,leaf} first in the constraints compartment
+        # (t_object.IsRoot/IsLeaf — verified on LanguageCode boxes).
+        def root_leaf_marker_for(classifier)
+          parts = []
+          parts << "root" if classifier.is_root
+          parts << "leaf" if classifier.is_leaf
+          parts.empty? ? nil : "{#{parts.join(',')}}"
+        end
+
+        def marker_constraint(text)
+          name = text[1..-2]
+          Ea::Model::Constraint.new(name: name, kind: "Marker")
         end
 
         # EA renders the off-canvas parent classifier's name as an

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.14"
+  VERSION = "0.6.16"
 end

metadata

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