ea 0.6.96 → 0.6.98

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b98c8ee8bf786f5160291763db47b38d8213a029ef4d647df1d73c386551dba
-  data.tar.gz: 3f0ee88fdb07d831f70e1ec51f634048140887a5231baa3dc0eea778a7f60d7a
+  metadata.gz: b3c13e631927ad57c6168b6d7c02eaed8e933c89ad7dfcd0a055fb6b8a69e8e1
+  data.tar.gz: 3edb35912780be1170fce402dd141823f4c5e44c92a6f84451fa136d3eb026a8
 SHA512:
-  metadata.gz: f0297306864b343dc4bdd5cae1c6cdaabeb7a5bb043cc592c76f11c5b42cfce4e7895bbfb3e92c51a263072203ca7e46b5eb3640633856474afbdc22798db2ba
-  data.tar.gz: de6096010a2802088ea9d8cee6fa9105c1b6622f4de8b89274668a5231645fd19727ad7633c74db66fbc6be04f70009f0d4d270f8ba4440189ff282f168d1313
+  metadata.gz: 6544102e41ff1bde04737e18f93de5ea0ee657c47335f7eeb12316162ca33fbf2e0d5b0dc1572fccc5174373781b1368508d606641286c88ebe2d7f9f2232079
+  data.tar.gz: eb3cb4702ea44ba8759ab9774a1ca445684b9d6ce7043153b4823657c191fff45c6db267ee74b1ed20cdec2064248b60a0f5112827b92edfa4aaecaa495fa093

data/config/themes/39.yml

@@ -0,0 +1,8 @@
+id: "39"
+name: EA theme 39 connector labels
+font:
+  unit: px
+label_font:
+  family: Cambria
+  size: 7
+  unit: pt

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

@@ -8,6 +8,113 @@ module Ea
         module Routing
           private
 
+          # An empty custom-line Path has no authored corner to preserve.
+          # Keep normalized port routes; replace only the computed EDGE2 jog.
+          def direct_empty_path_ray(model, link_row, diagram_row, geom, context)
+            return model if context
+            return model unless empty_path_ray_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            return model unless empty_path_ray_gap?(source, target, geom)
+
+            model.waypoints = [model.source_port, model.target_port].map do |point|
+              Ea::Model::Waypoint.new(position: point)
+            end
+            set_stored_ray_origins(model, source, target, geom)
+          end
+
+          def empty_path_ray_gap?(source, target, geom)
+            return false unless source.x + source.width < target.x
+
+            [stored_ray_origin(source, geom[:sx], geom[:sy]),
+             stored_ray_origin(target, geom[:ex], geom[:ey])].all? do |origin|
+              within_height?(origin.y, source) && within_height?(origin.y, target)
+            end
+          end
+
+          def empty_path_ray_candidate?(model, link_row, geom)
+            %w[Generalization Aggregation].include?(model.connector_type) &&
+              model.waypoints.size == 3 && empty_path_ray_style?(model.style, link_row, geom) &&
+              model.has_geometry_offsets && model.source_port && model.target_port
+          end
+
+          def empty_path_ray_style?(style, link_row, geom)
+            style[:mode] == "3" && style[:lwidth] == "2" && !style[:tree] &&
+              geom[:edge] == 2 && link_row.path.to_s.empty?
+          end
+
+          # Stored SY/EY use mathematical Y; ray origins use screen Y.
+          # Computed-jog origins are already normalized to their derived ports.
+          def correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
+            return model if context
+            return model unless stored_ray_candidate?(model, link_row, geom)
+
+            source, target = stored_ray_boxes(link_row, diagram_row)
+            return model unless stored_ray_gap?(source, target, model.style[:mode], geom[:edge])
+
+            set_stored_ray_origins(model, source, target, geom)
+          end
+
+          def stored_ray_boxes(link_row, diagram_row)
+            connector = database.find_connector(link_row.connectorid)
+            [source_placement_for(connector, diagram_row),
+             target_placement_for(connector, diagram_row)].map { |placement| bounds_from_rect(placement) }
+          end
+
+          def set_stored_ray_origins(model, source, target, geom)
+            model.source_anchor = stored_ray_origin(source, geom[:sx], geom[:sy])
+            model.target_anchor = stored_ray_origin(target, geom[:ex], geom[:ey])
+            model
+          end
+
+          def stored_ray_candidate?(model, link_row, geom)
+            %w[Generalization Aggregation].include?(model.connector_type) &&
+              model.waypoints.size == 2 && stored_ray_style?(model.style, link_row) &&
+              stored_ray_geometry?(model, geom) && !normalized_port_anchors?(model)
+          end
+
+          def stored_ray_style?(style, link_row)
+            %w[1 3].include?(style[:mode]) && !style[:tree] &&
+              (style[:mode] == "1" || link_row.path.to_s.empty?)
+          end
+
+          def stored_ray_geometry?(model, geom)
+            model.has_geometry_offsets && model.source_port && model.target_port &&
+              (!geom[:sy].to_i.zero? || !geom[:ey].to_i.zero?)
+          end
+
+          def normalized_port_anchors?(model)
+            same_port_anchor?(model.source_anchor, model.source_port) &&
+              same_port_anchor?(model.target_anchor, model.target_port)
+          end
+
+          def same_port_anchor?(anchor, port)
+            anchor.x == port.x && anchor.y == port.y
+          end
+
+          def stored_ray_gap?(source, target, mode, edge)
+            return horizontal_ray_gap?(source, target) || vertical_ray_gap?(source, target) if mode == "1"
+
+            if edge == 1
+              target.y + target.height < source.y
+            elsif edge == 4
+              target.x + target.width < source.x
+            end
+          end
+
+          def horizontal_ray_gap?(source, target)
+            source.x + source.width < target.x || target.x + target.width < source.x
+          end
+
+          def vertical_ray_gap?(source, target)
+            source.y + source.height < target.y || target.y + target.height < source.y
+          end
+
+          def stored_ray_origin(bounds, x_offset, y_offset)
+            Ea::Model::Point.new(x: bounds.x + bounds.width / 2 + x_offset.to_i,
+                                 y: bounds.y + bounds.height / 2 - y_offset.to_i)
+          end
+
           # Square routing keeps the stored orthogonal trunk, even when a
           # shorter facing-edge route exists between the same boxes.
           def stored_square_route(link_row, connector, source, target)

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

@@ -16,16 +16,11 @@ module Ea
 
         attr_reader :database
 
-        # Generalizations whose EA CustomProperties carry
-        # isSubstitutable draw '{isSubstitutable=false}' at the label
-        # seat (t_xref 'connector property' rows keyed by connector
-        # guid; VALU 0/empty both mean false).
+        # This flag requests the false annotation, not the property's Boolean
+        # value. An explicit true (-1) must not request a false annotation.
         def substitutable_connector?(conn)
-          @substitutable_guids ||= database.collections[:xrefs]
-                                           .select do |x|
-            x.xref_type == "connector property" &&
-              x.name == "CustomProperties" &&
-              x.description.to_s.include?("isSubstitutable")
+          @substitutable_guids ||= database.collections[:xrefs].select do |xref|
+            false_substitutability_xref?(xref)
           end.map(&:client).to_set
           @substitutable_guids.include?(conn.ea_guid)
         end
@@ -99,6 +94,22 @@ module Ea
 
         private
 
+        def false_substitutability_xref?(xref)
+          return false unless xref.xref_type == "connector property" && xref.name == "CustomProperties"
+
+          description = xref.description.to_s
+          description.include?("isSubstitutable") && !true_substitutability_property?(description)
+        end
+
+        def true_substitutability_property?(description)
+          description.scan(/@PROP=(.*?)@ENDPROP;/m).any? do |match|
+            property = match.first
+            property.include?("@NAME=isSubstitutable@ENDNAME;") &&
+              property.include?("@TYPE=Boolean@ENDTYPE;") &&
+              property[/@VALU=(.*?)@ENDVALU;/m, 1] == "-1"
+          end
+        end
+
         def build_elements(diagram_row)
           objs = database.diagram_objects_for(diagram_row.diagram_id) || []
           objs.map { |obj_row| build_element(obj_row, diagram_row) }
@@ -385,7 +396,7 @@ module Ea
           geom = parse_geometry_fields(link_row.geometry)
           context = ContextDiagramSupport.package_context(diagram_row) ||
                     ContextDiagramSupport.element_regenerate?(diagram_row)
-          collapse_computed_jog(Ea::Model::DiagramConnector.new(
+          model = collapse_computed_jog(Ea::Model::DiagramConnector.new(
             id: IdNormalizer.synthetic("dc", diagram_row.diagram_id,
                                        link_row.instance_id),
             diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
@@ -410,6 +421,8 @@ module Ea
             has_geometry_offsets: geometry_has_offsets?(link_row.geometry),
             is_substitutable: substitutable_connector?(connector)
           ), link_row, diagram_row, geom)
+          model = direct_empty_path_ray(model, link_row, diagram_row, geom, context)
+          correct_stored_ray_origins(model, link_row, diagram_row, geom, context)
         end
 
         # Ray origin for one connector end: the element's center

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

@@ -106,7 +106,7 @@ module Ea
         def outline_connector?(connector, bounds)
           return true if %w[Generalization Aggregation].include?(connector.connector_type)
 
-          return false unless stored_association?(connector)
+          return false unless stored_association?(connector) || offset_free_association?(connector)
 
           # Diagonal Association rounding and tree docks keep their existing rules.
           pairs = clipped_pairs(bounds, [connector.source_anchor, connector.target_anchor])
@@ -122,6 +122,20 @@ module Ea
         end
         private_class_method :stored_association?
 
+        def offset_free_association?(connector)
+          style = connector.style.to_h
+          connector.connector_type == "Association" && style[:mode] == "3" && !style[:tree] &&
+            %i[direct regenerated].none? { |key| style.key?(key) } && offset_free_anchors?(connector)
+        end
+        private_class_method :offset_free_association?
+
+        def offset_free_anchors?(connector)
+          !connector.has_geometry_offsets &&
+            [connector.source_port, connector.target_port].all?(&:nil?) &&
+            [connector.source_anchor, connector.target_anchor].all?
+        end
+        private_class_method :offset_free_anchors?
+
         def clipped_pairs(bounds, anchors)
           source, target = bounds
           source_anchor, target_anchor = anchors
@@ -195,18 +209,46 @@ module Ea
                       divider_y_by_ref[target_ref]]
           return nil unless bounds.all? && dividers.all?
 
-          adjusted = row_slot_pairs(pairs, bounds, dividers)
+          preserve_source = explicit_horizontal_source_dock?(pairs, connector)
+          adjusted = row_slot_pairs(pairs, bounds, dividers, preserve_source: preserve_source)
           if stroke_outline?(connector, bounds) &&
              pairs == pairs_for(connector, diagram, model_index, bounds_map)
             original = clipped_pairs(bounds, [connector.source_anchor, connector.target_anchor])
-            original_final = row_slot_pairs(original, bounds, dividers)
+            original_final = row_slot_pairs(original, bounds, dividers, preserve_source: preserve_source)
             adjusted = original_final if original != pairs && !forward_route?(original_final, adjusted)
           end
           adjusted == pairs ? nil : adjusted
         end
 
-        def row_slot_pairs(pairs, bounds, dividers)
+        # A supplied horizontal port already specifies its row. Moving it
+        # to the next compartment row would discard that explicit coordinate.
+        def explicit_horizontal_source_dock?(pairs, connector)
+          return false unless explicit_horizontal_ray?(connector)
+
+          connector.source_anchor.y == connector.target_anchor.y &&
+            connector.source_port.y == connector.source_anchor.y &&
+            pairs.first[1] == connector.source_port.y
+        end
+        private_class_method :explicit_horizontal_source_dock?
+
+        def explicit_horizontal_ray?(connector)
+          explicit_horizontal_ray_style?(connector) && connector.has_geometry_offsets &&
+            connector.source_port && connector.target_port &&
+            connector.source_anchor && connector.target_anchor
+        end
+        private_class_method :explicit_horizontal_ray?
+
+        def explicit_horizontal_ray_style?(connector)
+          style = connector.style.to_h
+          %w[Generalization Aggregation].include?(connector.connector_type) &&
+            style[:mode] == "3" && !style[:tree] && !style[:direct] && !style[:regenerated]
+        end
+        private_class_method :explicit_horizontal_ray_style?
+
+        def row_slot_pairs(pairs, bounds, dividers, preserve_source: false)
           pairs.each_with_index.map do |(x, y), index|
+            next [x, y] if preserve_source && index.zero?
+
             row_slot?(x, y, bounds[index], dividers[index]) ? [x, y + ROW_SLOT_PITCH] : [x, y]
           end
         end

data/lib/ea/svg/ea_emitter/label/end_label.rb

@@ -86,11 +86,15 @@ module Ea
             stereo = stereo.nil? || stereo.empty? ? nil : "«#{stereo}»"
             direction = leg_direction(end_kind, heading)
             if direction && !(tree && zero_offset?(text_box, mult_box))
-              text_pos = source_property_seat(connector, direction, anchor, text_box, role) ||
+              text_pos = plain_vertical_role(connector, direction, anchor, text_box, role) ||
+                         source_property_seat(connector, direction, anchor, text_box, role) ||
                          plain_upward_seat(connector, direction, anchor, text_box, role) ||
                          role_seat(direction, anchor, text_box, role) || text_pos
               mult_pos = directional_multiplicity(connector, direction, anchor, mult_box, mult) ||
                          mult_seat(direction, anchor, mult_box) || mult_pos
+            elsif end_kind == :target && !(tree && zero_offset?(text_box, mult_box))
+              text_pos = target_upward_role(connector, heading, anchor, text_box, role) || text_pos
+              mult_pos = target_multiplicity_seat(heading, anchor, mult_box) || mult_pos
             end
 
             build_texts(role:, mult:, standalone:,
@@ -199,6 +203,36 @@ module Ea
             [x - SEAT_X_INSET - width, y - 6]
           end
 
+          def target_upward_role(connector, heading, anchor, box, role)
+            return nil unless heading && heading[0].zero? && heading[1].negative?
+
+            plain_vertical_role(connector, :target_up, anchor, box, role)
+          end
+
+          def plain_vertical_role(connector, direction, anchor, box, role)
+            return nil unless %i[down target_up].include?(direction) && plain_vertical_box?(box)
+
+            end_kind = direction == :down ? :source : :target
+            return nil unless plain_vertical_connector?(connector, end_kind)
+
+            width = Ea::Fonts::Metrics.text_length(role, font_size, family: font_family)
+            return nil unless width
+
+            x, y = seat_corner(anchor, box)
+            [x - width - 8, y + (end_kind == :source ? 15 : -7)]
+          end
+
+          def plain_vertical_box?(box)
+            seat_font? && cambria_box?(box) && [0, 1].include?(box["alignment"])
+          end
+
+          def plain_vertical_connector?(connector, end_kind)
+            style = connector.style.to_h
+            connector.connector_type == "Association" &&
+              connector_source_dest_stereotype(connector, end_kind).empty? &&
+              style[:mode] == "3" && style[:lwidth] == "0" && !style[:tree]
+          end
+
           def plain_role_route?(style)
             %w[1 3].include?(style[:mode]) && %w[0 2].include?(style[:lwidth]) &&
               [nil, "V"].include?(style[:tree])
@@ -251,6 +285,14 @@ module Ea
             [x - width - 3, y + 15] if width
           end
 
+          def target_multiplicity_seat(heading, anchor, box)
+            return nil unless seat_font?
+            return nil unless heading && heading[0].zero? && heading[1].negative?
+            return nil unless cambria_box?(box) && stored_offsets_zero?(box)
+
+            [anchor[0] + 8, anchor[1] - 7]
+          end
+
           def cambria_box?(box)
             box && default_presentation?(box) && font_family.to_s.casecmp("Cambria").zero?
           end

data/lib/ea/svg/ea_emitter/label/midpoint_label.rb

@@ -96,6 +96,9 @@ module Ea
           LINE_PITCH = 13
 
           def label_position(connector, points)
+            name_seat = stored_name_position(connector, points)
+            return name_seat if name_seat
+
             return midpoint(points) unless default_substitutable_seat?(connector) &&
                                            upward_four_point_route?(points)
 
@@ -103,6 +106,40 @@ module Ea
             [source[0] + 3, ((source[1] + bend[1]) / 2).floor - 1]
           end
 
+          # At 7pt, a centered name's stored corner is 3px below its baseline.
+          def stored_name_position(connector, points)
+            box = stored_name_box(connector)
+            return nil unless box
+
+            width = Ea::Fonts::Metrics.text_length(midpoint_content(connector), font_size, family: font_family)
+            return nil unless width
+
+            x, y = midpoint(points)
+            offset_x, offset_y = box.values_at("ox", "oy").map(&:to_i)
+            [x + offset_x - (width / 2.0).floor, y + offset_y - 3]
+          end
+
+          def stored_name_box(connector)
+            return nil unless connector.is_a?(Ea::Model::DiagramConnector) && measured_name_font?
+            return nil if connector.is_substitutable || stereotype_label(connector)
+            return nil if midpoint_content(connector).include?(": ")
+
+            box = connector.label_boxes.to_h[:lmt]
+            box if default_name_box?(box)
+          end
+
+          def measured_name_font?
+            font_family.to_s.casecmp("Cambria").zero? && font_size == 7 && font_unit == "pt"
+          end
+
+          def default_name_box?(box)
+            return false unless box && box["alignment"] == 1
+            return false unless box.values_at("ox", "oy").all?
+            return false unless [nil, 0, 1].include?(box["direction"]) && [nil, -1].include?(box["color"])
+
+            box["rotation"].to_i.zero? && box.values_at("bold", "italic", "underline", "hidden").none?
+          end
+
           def default_substitutable_seat?(connector)
             connector.is_a?(Ea::Model::DiagramConnector) && connector.is_substitutable &&
               connector.connector_type == "Generalization" && font_size == 7 &&

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

@@ -97,6 +97,7 @@ module Ea
                              mult_box: tgt_mb,
                              anchor: target_pt, connector: connector,
                              end_kind: :target, tree: tree && tree[:target],
+                             heading: stored_tgt && leg_heading(points.reverse),
                              stored_labels: stored_labels).each { |t| texts << t }
           texts
         end
@@ -112,11 +113,21 @@ module Ea
           { source: true, target: true }
         end
 
-        # Clipping can slant a stored vertical leg. Keep its label direction
-        # while the label position follows the final emitted endpoint.
+        # A diagonal clipped leg keeps the seat of its unambiguous exit face.
+        # Unknown faces retain the stored-upward fallback.
         def source_heading(connector, points)
           heading = leg_heading(points)
-          return heading unless points.size == 2 && heading[0].nonzero? && heading[1].negative?
+          return heading unless points.size == 2 && heading.none?(&:zero?)
+
+          box = source_dock_bounds(connector)
+          face = box && dock_face_heading(points.first, box)
+          return face if face && face.zip(heading).any? { |axis, delta| (axis * delta).positive? }
+
+          stored_upward_heading(connector, heading)
+        end
+
+        def stored_upward_heading(connector, heading)
+          return heading unless heading[1].negative?
 
           stored = waypoint_pairs(connector)
           return heading unless stored.size == 2
@@ -125,6 +136,49 @@ module Ea
           original[0].zero? && original[1].negative? ? original : heading
         end
 
+        def source_dock_bounds(connector)
+          return nil unless model_index && drawn_bounds
+
+          relationship = model_index[connector.relationship_ref]
+          return nil unless relationship
+
+          source, target = ConnectorRedock.end_refs(relationship)
+          return nil if source == target
+          return nil unless drawn_bounds[target]
+
+          drawn_bounds[source]
+        end
+
+        def dock_face_heading(point, box)
+          return nil unless box.width.positive? && box.height.positive?
+
+          vertical_dock_heading(point, box) || horizontal_dock_heading(point, box)
+        end
+
+        def vertical_dock_heading(point, box)
+          x, y = point
+          left = box.x
+          return nil unless x > left && x < left + box.width
+
+          top = box.y
+          return [0, -1] if [top, top - 1].include?(y)
+
+          bottom = top + box.height
+          [0, 1] if [bottom, bottom + 1].include?(y)
+        end
+
+        def horizontal_dock_heading(point, box)
+          x, y = point
+          top = box.y
+          return nil unless y > top && y < top + box.height
+
+          left = box.x
+          return [-1, 0] if [left, left - 1].include?(x)
+
+          right = left + box.width
+          [1, 0] if [right, right + 1].include?(x)
+        end
+
         def leg_heading(points)
           [points[1][0] - points[0][0], points[1][1] - points[0][1]]
         end
@@ -172,7 +226,7 @@ module Ea
             theme: theme,
             font_family: label_font_family,
             font_size: label_font_size,
-            font_unit: theme.font_size_unit
+            font_unit: theme.label_font_size_unit
           )
         end
 
@@ -182,7 +236,7 @@ module Ea
             model_index: model_index,
             font_family: label_font_family,
             font_size: label_font_size,
-            font_unit: theme.font_size_unit
+            font_unit: theme.label_font_size_unit
           )
         end
 
@@ -212,7 +266,7 @@ module Ea
         end
 
         def label_font_size
-          theme.font_size || DEFAULT_SIZE
+          theme.label_font_size || DEFAULT_SIZE
         end
       end
     end

data/lib/ea/theme/definition.rb

@@ -65,7 +65,8 @@ module Ea
                                     text_y_offset: 12, line_height: 13).freeze
 
       def initialize(id:, name: nil, font_family: nil, font_size: nil,
-                     label_font_family: nil,
+                     label_font_family: nil, label_font_size: nil,
+                     label_font_size_unit: nil,
                      font_size_unit: "pt", text_weight_normal: 400,
                      text_weight_bold: 700,
                      element_font_size: 9, element_font_unit: "pt",
@@ -83,6 +84,8 @@ module Ea
         @name = name
         @font_family = font_family
         @label_font_family = label_font_family
+        @label_font_size = label_font_size
+        @label_font_size_unit = label_font_size_unit
         @font_size = font_size
         @font_size_unit = font_size_unit
         @text_weight_normal = text_weight_normal
@@ -125,8 +128,18 @@ module Ea
         @label_font_family || font_family
       end
 
+      def label_font_size
+        @label_font_size || font_size
+      end
+
+      def label_font_size_unit
+        @label_font_size_unit || font_size_unit
+      end
+
       def with(**overrides)
-        overrides[:label_font_family] = nil if overrides.key?(:font_family) && !overrides.key?(:label_font_family)
+        clear_label_override(overrides, :font_family, :label_font_family)
+        clear_label_override(overrides, :font_size, :label_font_size)
+        clear_label_override(overrides, :font_size_unit, :label_font_size_unit)
         Definition.new(**to_h.merge(overrides))
       end
 
@@ -159,6 +172,8 @@ module Ea
           font_family: font_family, font_size: font_size,
           font_size_unit: font_size_unit,
           label_font_family: @label_font_family,
+          label_font_size: @label_font_size,
+          label_font_size_unit: @label_font_size_unit,
           text_weight_normal: text_weight_normal,
           text_weight_bold: text_weight_bold,
           element_font_size: element_font_size,
@@ -179,6 +194,12 @@ module Ea
           package: package, note: note, fills: fills
         }
       end
+
+      private
+
+      def clear_label_override(overrides, global_key, label_key)
+        overrides[label_key] = nil if overrides.key?(global_key) && !overrides.key?(label_key)
+      end
     end
   end
 end

data/lib/ea/theme/loader.rb

@@ -10,7 +10,7 @@ module Ea
     #   name: EA White Theme
     #   font: { family: Carlito, size: 7, unit: pt, weight_normal: 400, ... }
     #   element_font: { size: 9, unit: pt }
-    #   label_font: { family: Cambria }
+    #   label_font: { family: Cambria, size: 7, unit: pt }
     #   colors: { text: "#000000", attribute_text: "#66413F", ... }
     #   strokes: { element_border: 2, connector_line: 2, ... }
     #   text_metrics: { width_factor: 0.65 }
@@ -56,6 +56,8 @@ module Ea
             name: data["name"],
             font_family: font["family"],
             label_font_family: label_font["family"],
+            label_font_size: label_font["size"],
+            label_font_size_unit: label_font["unit"],
             font_size: font["size"],
             font_size_unit: font["unit"] || "pt",
             text_weight_normal: font["weight_normal"] || 400,

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.96"
+  VERSION = "0.6.98"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.96
+  version: 0.6.98
 platform: ruby
 authors:
 - Ribose Inc.
@@ -501,6 +501,7 @@ files:
 - config/qea_schema.yml
 - config/stereotype_colors.yml
 - config/themes/119.yml
+- config/themes/39.yml
 - config/themes/default.yml
 - docs/ea_to_uml_type_mapping.md
 - docs/xmi_qea_conversion_capabilities.md