ea 0.6.105 → 0.6.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 430568b3607d439af39bac818b48ee27caa207875c7f2015e3a6f5689419680b
-  data.tar.gz: dfb835e2208d50a51caa01acb96a30e2561f5ccbdf6e83a6a1c55ec368c4b5b8
+  metadata.gz: 931597d4cff3d8f491f63e12f3ed1a5ba31f8cc68d535b060222ca704388bda7
+  data.tar.gz: 70054ffff1db544c415879495386b4b45c7a1dafb88dfcc7d680325f37e4d019
 SHA512:
-  metadata.gz: ce35bed8f6b13d1f799d8c99b550ad70d19453e2f2827888c1dce54b246dc9a938baa52cfe2d24f9fb9f093ecce1a86b52c4dbecbb60b397777c592cc61ea654
-  data.tar.gz: 22747dc14774fbfaa984efba1c88078619d8ab6bc74b4d06d5276074a93957dccc071963574aad3ff272377d043e51e613723708d0fa48318acf6558ec920de1
+  metadata.gz: 8881133d7a2443adc4dcde58dd1290b532cea8c575f22b274dc818985d6540e22d11927f0aada28a5b27f5e76748be1fd2874bbde30018c09e3dd6422a3f3263
+  data.tar.gz: c91711384dc7ebefa97bdff19923697a5eacf8f22c362dfe1ee737e8d281a3c08224d63d66d411ff77ac7edb503db1245f7d40b443c82c4468d09885fa9487f8

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

@@ -10,7 +10,16 @@ module Ea
           private
 
           def restore_stored_square_ports(model, link_row, diagram_row, geom, context)
-            return model if context || !stored_square_port_style?(model, link_row, geom)
+            return model if context
+
+            model = mark_orthogonal_origin_ray(model, link_row, diagram_row, geom)
+            return model if model.style.to_h[:orthogonal_origin_ray] == true
+
+            restore_global_square_ports(model, link_row, diagram_row, geom)
+          end
+
+          def restore_global_square_ports(model, link_row, diagram_row, geom)
+            return model unless stored_square_port_style?(model, link_row, geom)
 
             connector = database.find_connector(link_row.connectorid)
             points = stored_square_port_coordinates(connector)
@@ -25,6 +34,50 @@ module Ea
             model
           end
 
+          # A square route with no stored bends uses the original mathematical
+          # ray to choose its orthogonal dock axis at render time.
+          def mark_orthogonal_origin_ray(model, link_row, diagram_row, geom)
+            return model unless orthogonal_origin_style?(model, link_row, geom)
+
+            origins = orthogonal_math_origins(link_row, diagram_row, geom)
+            return model unless origins
+
+            model.source_anchor, model.target_anchor = origins
+            model.waypoints = origins.map { |point| Ea::Model::Waypoint.new(position: point) }
+            model.style = model.style.to_h.merge(orthogonal_origin_ray: true)
+            model
+          end
+
+          def orthogonal_math_origins(link_row, diagram_row, geom)
+            connector = database.find_connector(link_row.connectorid)
+            boxes = stored_square_port_boxes(connector, diagram_row)
+            return unless boxes && orthogonal_box_gap?(*boxes)
+
+            offsets = [[geom[:sx], geom[:sy]], [geom[:ex], geom[:ey]]]
+            origins = boxes.zip(offsets).map { |box, offset| stored_ray_origin(box, *offset) }
+            origins if orthogonal_origins_inside?(origins, boxes)
+          end
+
+          def orthogonal_origins_inside?(origins, boxes)
+            origins.zip(boxes).all? { |point, box| origin_inside_outline?(point, box) }
+          end
+
+          def orthogonal_origin_style?(model, link_row, geom)
+            %w[Association Generalization].include?(model.connector_type) && link_row.path.to_s.empty? &&
+              model.style.to_h.values_at(:mode, :tree, :lwidth) == %w[3 OS 2] &&
+              %i[sx sy ex ey].all? { |key| !geom[key].nil? }
+          end
+
+          def orthogonal_box_gap?(source, target)
+            [source, target].all? { |box| box.width.positive? && box.height.positive? } &&
+              (horizontal_ray_gap?(source, target) ^ vertical_ray_gap?(source, target))
+          end
+
+          def origin_inside_outline?(point, box)
+            point.x.between?(box.x - 1, box.x + box.width + 1) &&
+              point.y.between?(box.y - 1, box.y + box.height + 1)
+          end
+
           def stored_square_port_style?(model, link_row, geom)
             style = model.style.to_h
             model.connector_type == "Association" && link_row.path.to_s.empty? &&

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

@@ -123,6 +123,7 @@ module Ea
         def build_element(obj_row, diagram_row)
           @current_obj_row = obj_row
           style_hash = DiagramStyleParser.parse(obj_row.objectstyle)
+          style_hash[:stored_attribute_order] = true
           Ea::Model::DiagramElement.new(
             id: IdNormalizer.synthetic("de", diagram_row.diagram_id,
                                        obj_row.instance_id),

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

@@ -16,7 +16,8 @@ module Ea
 
         def build_all_for(owner_object)
           attrs = database.attributes_for_object(owner_object.ea_object_id) || []
-          attrs.map { |row| build_one(row, owner_object) }
+          attrs.each_with_index.sort_by { |row, index| attribute_sort_key(row, index) }
+               .map { |row, _index| build_one(row, owner_object) }
         end
 
         def build_one(row, owner_object)
@@ -48,6 +49,15 @@ module Ea
 
         private
 
+        # Equal explicit Pos values use name order in EA's published diagrams.
+        # Missing positions retain source order before the explicit zero cohort.
+        def attribute_sort_key(row, index)
+          return [row.sort_position, 0, "", "", index] if row.pos.nil?
+
+          name = row.name.to_s
+          [row.sort_position, 1, name.downcase, name, index]
+        end
+
         # EA stores some bounds as literal text ("n"); those render
         # verbatim in attribute lines while computed-unbounded bounds
         # render as "*" (verified against EA-published SVGs).

data/lib/ea/svg/ea_emitter/compartment/constraints.rb

@@ -11,26 +11,17 @@ module Ea
         # content and suppresses them when they would overflow the
         # stored box height (never truncates rows).
         module Constraints
-          DEFAULT_TEXT_COLOR = "#000000"
-
           module_function
 
           def render(context)
             return nil unless context.constraints&.any?
-            return nil unless context.geometry.tagged_value_first_y
-
-            first_y = context.geometry.tagged_value_first_y
-            line_h = context.size + 6
-            last_y = first_y + (context.constraints.size - 1) * line_h
-            return nil if last_y + 4 > context.bounds.y + context.bounds.height
+            return nil unless context.geometry.constraints_first_y
 
-            Element::ConstraintRenderer.render(
-              context.constraints,
-              bounds: context.bounds,
-              first_y: first_y,
-              family: context.family, size: context.size,
-              fill: DEFAULT_TEXT_COLOR
+            divider = Element::DividerRenderer.render(
+              context.bounds, y: context.geometry.constraints_divider_y,
+                              stroke: context.stroke, stroke_width: context.stroke_width
             )
+            "#{divider}\n#{Element::ConstraintRenderer.render_compartment(context)}"
           end
         end
       end

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

@@ -34,6 +34,9 @@ module Ea
           return nil unless source_bounds && target_bounds
           return nil if source_ref == target_ref
 
+          square = OrthogonalRay.pairs_for(connector, source_bounds, target_bounds)
+          return square if square
+
           if lateral
             target = lateral_target(points[1], target_bounds, connector.style[:tree])
             return target && [points[0], points[1], target]
@@ -56,6 +59,7 @@ module Ea
                                   width: box.width + 2, height: box.height + 2)
           end
           candidate = clipped_pairs(outline, anchors)
+          candidate[0] = external_source_point(connector, outline.first, anchors, candidate.first)
           expanded = forward_route?(original, candidate)
           pairs = expanded ? candidate : original
           target = expanded ? outline.last : target_bounds
@@ -80,6 +84,20 @@ module Ea
         end
         private_class_method :auto_port_elbow_pairs
 
+        # An external saved ray can cross two source edges; retain its
+        # clockwise perimeter choice instead of the nearest crossing.
+        def external_source_point(connector, source, anchors, fallback)
+          style = connector.style.to_h
+          return fallback unless style[:stored_association_ray] == true && style[:lwidth] == "2"
+
+          first, last = anchors
+          return fallback if first.x.between?(source.x, source.x + source.width) &&
+                             first.y.between?(source.y, source.y + source.height)
+
+          anchor_exit(first, source, last, perimeter: true)
+        end
+        private_class_method :external_source_point
+
         # EDGE=1 explicitly seats an external source ray on the top edge;
         # its first contact can instead be the bottom when its origin is below.
         def stored_top_pairs(connector, source, pairs)
@@ -290,10 +308,9 @@ module Ea
         end
         private_class_method :forward_route?
 
-        # Exit point of the anchor-to-anchor segment through a box's
-        # outline: smallest positive t whose crossing lies on the
-        # rectangle perimeter.
-        def anchor_exit(anchor, bounds, other)
+        # Interior rays use the nearest forward exit. External saved sources
+        # can request the first intersecting edge in clockwise perimeter order.
+        def anchor_exit(anchor, bounds, other, perimeter: false)
           ax, ay = anchor.x.to_f, anchor.y.to_f
           ox, oy = other.x.to_f, other.y.to_f
           dx, dy = ox - ax, oy - ay
@@ -314,12 +331,25 @@ module Ea
             x >= bounds.x - 0.01 && x <= bounds.x + bounds.width + 0.01 &&
               y >= bounds.y - 0.01 && y <= bounds.y + bounds.height + 0.01
           end
-          best = on_perimeter.min_by(&:first)
+          best = if perimeter
+                   on_perimeter.min_by { |_t, x, y| perimeter_order(x, y, bounds) }
+                 else
+                   on_perimeter.min_by(&:first)
+                 end
           # EA floors the dock coordinates (F851A657: 297.75 -> 297,
           # 433.7 -> 433) - a rounded-up dock is a visible miss.
           best ? [best[1].floor, best[2].floor] : [ax.floor, ay.floor]
         end
 
+        def perimeter_order(point_x, point_y, bounds)
+          return 0 if point_y == bounds.y
+          return 1 if point_x == bounds.x + bounds.width
+          return 2 if point_y == bounds.y + bounds.height
+
+          3
+        end
+        private_class_method :perimeter_order
+
         # EA never docks a horizontal connector line at the header
         # divider: endpoints landing on (box side edge, divider_y)
         # move down one row slot to divider_y + 13 - the first

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

@@ -87,7 +87,7 @@ module Ea
           # Pass a `lookup` (any callable returning a Classifier for
           # an id) to enable inherited-property namespace prefixing.
           def self.lines_for(classifier, lookup: nil,
-                            exclude_association_ids: nil)
+                             exclude_association_ids: nil, stored_order: false)
             props = displayable_properties(classifier, exclude_association_ids)
             return [] unless props
 
@@ -95,19 +95,14 @@ module Ea
             if stereotypes.size == 1 && props.all? { |p| property_stereotype(p) }
               # EA renders ONE compartment stereotype header for a
               # uniformly-stereotyped attribute set (e.g. «Property»
-              # above GML property rows) and lists rows
-              # alphabetically - verified against EA-published SVGs.
+              # above GML property rows).
               header = "«#{canonical_stereotype(stereotypes.first)}»"
-              [header] + props.sort_by { |p| p.name.to_s }.map do |prop|
+              [header] + ordered_properties(props, stored_order, case_sensitive: true).map do |prop|
                 AttributeLineBuilder.new(prop, host: classifier,
                                          lookup: lookup).to_s
               end
             else
-              # EA lists attribute rows alphabetically (case-
-              # insensitive) — corpus-verified: 991 boxes strictly
-              # alphabetical vs 24 strictly stored-Pos order.
-              props.sort_by { |p| [p.name.to_s.downcase, p.name.to_s] }
-                   .flat_map do |prop|
+              ordered_properties(props, stored_order).flat_map do |prop|
                 lines = []
                 stereotype = property_stereotype(prop)
                 lines << "«#{stereotype}»" if stereotype
@@ -117,6 +112,20 @@ module Ea
             end
           end
 
+          # QEA properties arrive in stored Pos order. Association ends retain
+          # their alphabetical fallback rather than using connector Pos values.
+          def self.ordered_properties(props, stored_order, case_sensitive: false)
+            alphabetical = lambda do |prop|
+              name = prop.name.to_s
+              case_sensitive ? [name] : [name.downcase, name]
+            end
+            return props.sort_by(&alphabetical) unless stored_order
+
+            own, ends = props.partition { |prop| !prop.association_id }
+            own + ends.sort_by(&alphabetical)
+          end
+          private_class_method :ordered_properties
+
           STEREOTYPE_DISPLAY = {
             "property" => "Property",
             "featuretype" => "FeatureType",

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

@@ -150,14 +150,30 @@ module Ea
             divider_y + size + (attr_first_offset || 7)
           end
 
-          # Tagged values appear after attributes (or after ops if
-          # present). EA does not emit a separate divider — the
-          # italic "tags" header marks the compartment. Constraints
-          # render ABOVE the attributes (constraints_first_y), not
-          # here.
+          # OCL constraints follow the regular content with a divider and caption.
+          # Suppress the whole compartment when its last row cannot fit.
+          def constraints_first_y
+            return nil unless constraints_count.to_i.positive?
+
+            first_y = constraints_caption_y
+            first_y if first_y + constraints_count * (size + 5) + 4 <= bounds.y + bounds.height
+          end
+
+          def constraints_caption_y
+            (regular_content_bottom_y || raw_attr_first_y) + size + 13
+          end
+
+          def constraints_divider_y
+            constraints_first_y - size - 7 if constraints_first_y
+          end
+
+          def constraints_bottom_y
+            constraints_first_y + constraints_count * (size + 5) if constraints_first_y
+          end
+
+          # Tagged values follow the last visible content compartment.
           def tagged_value_first_y
-            return nil unless tagged_values_count.to_i.positive? ||
-                              constraints_count.to_i.positive?
+            return nil unless tagged_values_count.to_i.positive?
 
             (content_bottom_y || raw_attr_first_y) + size + 5
           end
@@ -169,6 +185,10 @@ module Ea
           # the autosize gate must not treat the empty-compartment
           # anchor as content.
           def content_bottom_y
+            [regular_content_bottom_y, constraints_bottom_y].compact.max
+          end
+
+          def regular_content_bottom_y
             bottoms = []
             bottoms << attr_bottom_y if attr_lines_count.to_i.positive?
             bottoms << enum_literals_bottom_y if enum_literals_count.to_i.positive?
@@ -185,4 +205,4 @@ module Ea
       end
     end
   end
-end
+end

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

@@ -29,6 +29,34 @@ module Ea
             %(<g style="#{Style::TEXT_GROUP}">\n#{text_blocks.join("\n")}\n</g>)
           end
 
+          def self.render_compartment(context)
+            rows = context.constraints.each_with_index.map do |constraint, idx|
+              compartment_row(constraint, context, idx)
+            end
+            %(<g style="#{Style::TEXT_GROUP}">\n#{([compartment_caption(context)] + rows).join("\n")}\n</g>)
+          end
+
+          def self.compartment_row(constraint, context, index)
+            build_text(context.bounds.x + 5,
+                       context.geometry.constraints_first_y + (index + 1) * (context.size + 5),
+                       "{#{constraint.name}}", context.family, context.size, context.text_fill)
+          end
+          private_class_method :compartment_row
+
+          def self.compartment_caption(context)
+            TextRenderer.new(content: "constraints", x: caption_x(context),
+                             y: context.geometry.constraints_first_y, family: context.family,
+                             size: context.size, fill: context.text_fill, style: "italic").to_svg
+          end
+          private_class_method :compartment_caption
+
+          def self.caption_x(context)
+            width = TextRenderer.estimate_width("constraints", context.size, nil,
+                                                family: context.family, style: "italic").round
+            context.bounds.x + ((context.bounds.width - width) / 2).floor
+          end
+          private_class_method :caption_x
+
           def self.build_text(x, y, content, family, size, fill)
             TextRenderer.new(content: content, x: x, y: y,
                               family: family, size: size, fill: fill).to_svg

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

@@ -135,7 +135,8 @@ module Ea
                             classifier.properties.to_a.any? { |pr| !pr.association_id }))
                          Element::AttributeRenderer.lines_for(
                            classifier, lookup: attribute_lookup,
-                           exclude_association_ids: drawn_association_ids
+                                       exclude_association_ids: drawn_association_ids,
+                                       stored_order: element.style&.fetch(:stored_attribute_order, false)
                          )
                        else
                          []

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

@@ -4,27 +4,11 @@ module Ea
   module Svg
     module EaEmitter
       module Marker
-        # 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).
+        # EA endpoint fields select the diamond end; direction selects
+        # the arrow end for target-owned aggregations.
         class Diamond < Kind
           def self.handles?(effective_type)
-            effective_type == "Aggregation" || effective_type == "Composition"
+            %w[Aggregation Composition].include?(effective_type)
           end
 
           def self.specs_for(connector, source, target, before_target, after_source, relationship: nil)
@@ -36,10 +20,8 @@ module Ea
                                         base: whole_base)]
             return specs unless whole_at_target
 
-            specs << Registry::Spec.new(shape: :arrow,
-                                        anchor: whole_anchor,
-                                        base: whole_base)
-            specs
+            specs.concat(direction_specs(connector, source, target,
+                                         before_target, after_source))
           end
 
           def self.whole_at_target?(connector, relationship)
@@ -58,6 +40,18 @@ module Ea
             relationship &&
               %w[shared composite].include?(relationship.source_aggregation.to_s)
           end
+
+          def self.direction_specs(connector, source, target, before_target,
+                                   after_source)
+            if connector.direction == "Destination -> Source"
+              return [Registry::Spec.new(shape: :arrow, anchor: source,
+                                         base: after_source)]
+            end
+
+            [Registry::Spec.new(shape: :arrow, anchor: target,
+                                base: before_target)]
+          end
+          private_class_method :direction_specs
         end
       end
     end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Orthogonal docking from the nearer physical intersection of a stored ray.
+      module OrthogonalRay
+        module_function
+
+        def pairs_for(connector, source, target)
+          return unless eligible?(connector, source, target)
+
+          origins = [connector.source_anchor, connector.target_anchor]
+
+          boxes = [source, target]
+          physical = boxes.map { |box| outline(box) }
+          clipped = physical_intersections(origins, physical)
+          selected = nearer_origin(clipped, origins)
+          orthogonal_pairs(clipped, selected, boxes, physical, origins) unless selected.nil?
+        end
+
+        def eligible?(connector, source, target)
+          connector.style.to_h[:orthogonal_origin_ray] == true && source && target &&
+            connector.source_anchor && connector.target_anchor
+        end
+        private_class_method :eligible?
+
+        def physical_intersections(origins, physical)
+          origins.each_with_index.map do |origin, index|
+            ConnectorRedock.anchor_exit(origin, physical[index], origins[1 - index])
+          end
+        end
+        private_class_method :physical_intersections
+
+        def outline(box)
+          Ea::Model::Bounds.new(x: box.x - 1, y: box.y - 1,
+                                width: box.width + 2, height: box.height + 2)
+        end
+        private_class_method :outline
+
+        def nearer_origin(clipped, origins)
+          distances = clipped.zip(origins).map do |(x, y), origin|
+            (x - origin.x)**2 + (y - origin.y)**2
+          end
+          distances.each_with_index.min.last unless distances.first == distances.last
+        end
+        private_class_method :nearer_origin
+
+        def orthogonal_pairs(clipped, selected, boxes, physical, origins)
+          point = clipped[selected]
+          projected = project_opposite(point, physical[selected], boxes[1 - selected])
+          return unless projected && forward_projection?(point, projected, origins, selected)
+
+          selected.zero? ? [point, projected] : [projected, point]
+        end
+        private_class_method :orthogonal_pairs
+
+        def project_opposite(point, own, other)
+          case physical_edge_axis(point, own)
+          when :horizontal then horizontal_projection(point, other)
+          when :vertical then vertical_projection(point, other)
+          end
+        end
+        private_class_method :project_opposite
+
+        def physical_edge_axis(point, own)
+          horizontal = [own.y, own.y + own.height].include?(point[1])
+          vertical = [own.x, own.x + own.width].include?(point[0])
+          return unless horizontal ^ vertical
+
+          horizontal ? :horizontal : :vertical
+        end
+        private_class_method :physical_edge_axis
+
+        def horizontal_projection(point, other)
+          x, y = point
+          return unless x.between?(other.x, other.x + other.width)
+
+          edge = facing_edge(y, other.y, other.height)
+          [x, edge] if edge
+        end
+        private_class_method :horizontal_projection
+
+        def vertical_projection(point, other)
+          x, y = point
+          return unless y.between?(other.y, other.y + other.height)
+
+          edge = facing_edge(x, other.x, other.width)
+          [edge, y] if edge
+        end
+        private_class_method :vertical_projection
+
+        def facing_edge(coordinate, start, extent)
+          return start if coordinate < start
+          return start + extent if coordinate > start + extent
+
+          nil
+        end
+        private_class_method :facing_edge
+
+        def forward_projection?(point, projected, origins, selected)
+          first, last = origins.values_at(selected, 1 - selected)
+          x, y = point
+          target_x, target_y = projected
+          ((last.x - first.x) * (target_x - x) + (last.y - first.y) * (target_y - y)).positive?
+        end
+        private_class_method :forward_projection?
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter.rb

@@ -45,6 +45,9 @@ module Ea
       autoload :Document, "ea/svg/ea_emitter/document"
       autoload :Label, "ea/svg/ea_emitter/label"
       autoload :Compartment, "ea/svg/ea_emitter/compartment"
+      autoload :OrthogonalRay, "ea/svg/ea_emitter/orthogonal_ray"
+      private_constant :OrthogonalRay
+
       autoload :ConnectorRedock, "ea/svg/ea_emitter/connector_redock"
       autoload :RenderContext, "ea/svg/ea_emitter/render_context"
       autoload :VisibilitySymbol, "ea/svg/ea_emitter/visibility_symbol"

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.105"
+  VERSION = "0.6.107"
 end

data/memory/deviations.md

@@ -0,0 +1,3 @@
+# Focused Ruby deviations
+
+- Issue 135 attribute ordering: RuboCop Metrics/MethodLength flags the 14-line real-QEA fixture builder, and Metrics/BlockLength flags its six-example public pipeline regression group. Keep the fixture together and the directly related controls in one group; splitting them would obscure the input collections and ordering contract.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.105
+  version: 0.6.107
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -950,6 +950,7 @@ files:
 - lib/ea/svg/ea_emitter/marker/plus.rb
 - lib/ea/svg/ea_emitter/marker/registry.rb
 - lib/ea/svg/ea_emitter/markers.rb
+- lib/ea/svg/ea_emitter/orthogonal_ray.rb
 - lib/ea/svg/ea_emitter/render_context.rb
 - lib/ea/svg/ea_emitter/style.rb
 - lib/ea/svg/ea_emitter/text_renderer.rb
@@ -1011,6 +1012,7 @@ files:
 - lib/ea/xml_escape.rb
 - lib/tasks/fonts.rake
 - lib/tasks/svg_bench.rake
+- memory/deviations.md
 - reference-docs/enterprise-architect-appearance-dialogs/appearance-1-diagram-1-themes-list.png
 - reference-docs/enterprise-architect-appearance-dialogs/appearance-1-diagram-1-themes.png
 - reference-docs/enterprise-architect-appearance-dialogs/appearance-1-diagram-2-gradients.png