ea 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8649c4d58ca59e1a753bf7b4c1400e14ac7026e1142e914a4025dfd09a2e5bb1
-  data.tar.gz: 170d39d2601ea16f0dd171c7ab51906b4bbe0baf5c973eaffdfc02df2e27ab59
+  metadata.gz: feec20be82e181c35e21063e8faaefc697c466aeb96ea462a1e1911e20656863
+  data.tar.gz: a15bbc9f5d6f078d712f436584175ad4901bad1b2918c9d6f163de1be64b0c21
 SHA512:
-  metadata.gz: f7bd4ceb020497b93a2c9c9e0c60d3aa57a0cbb664803f4609a7ec82b2129649496bca45000b2ec91ba1c07a9254b1382bce67411f9f35b5d41dcaebe22590ff
-  data.tar.gz: ed3b011237a1a76a85ac1af8315afcfd9250b97396fbbcefe15f0491adbe1a51a1944abd7ba9ec513b0011c2461c4ff3c7bb5be20dfa58156cc93e3698c39d44
+  metadata.gz: 9c0ea25f28a1e8dfe0b7d923deb5340f3da3d3aefd8f95b284e80b3de6126756dba1dc96563113b3c64a918c7962fd351361a84f3afc066f304479847625ac7e
+  data.tar.gz: 0d68e3d7eea42bcc0d8008c84d5a69d58f94702981659174aa18f6ad7f67bcb07554e054e795aa7fde3716d63597ec71ee1e6148f187935d5c141c9cb2e94835

data/TODO.complete/64-qeatoxmi-connectors.md

@@ -0,0 +1,30 @@
+# TODO.complete/64: QeaToXmi emits connector elements
+
+## Status: open
+
+`Ea::Transformers::QeaToXmi` emits associations as `<memberEnd>` +
+`<ownedEnd>` on the owning class, but does NOT emit EA's
+`<connector>` elements. Per the parity regression spec, that's the
+#1 missing category (73/73 in basic.qea, 73/80 in plateau).
+
+## Plan
+
+1. After serializing the model root + classes, walk `t_connector`
+   for associations/aggregations/compositions.
+2. For each connector, locate the corresponding `t_diagramlinks` row
+   to retrieve geometry (SX/SY/EX/EY/EDGE) and visual style
+   (lineStyle/lineColor).
+3. Emit `<connector>` element with geometry in `<style>` sub-element.
+
+## Acceptance
+
+- `ea export xmi` output for basic.qea now contains
+  `<connector>` elements (was 0/73).
+- `spec/ea/validation/xmi_parity_spec.rb` packagedElement threshold
+  raised from 5% to 25% (connectors represent ~25% of EA's output).
+
+## OCP
+
+Each connector type (Association/Aggregation/Composition) gets a
+private serializer method dispatched by `connector_type`. New
+connector types = new case branch; no other code changes.

data/TODO.complete/65-qeatoxmi-diagrams.md

@@ -0,0 +1,29 @@
+# TODO.complete/65: QeaToXmi emits diagram elements
+
+## Status: open
+
+`Ea::Transformers::QeaToXmi` does not emit EA's `<diagram>` elements
+at all. The parity spec confirms 0/23 in basic.qea, 0/2 in test.qea.
+
+## Plan
+
+1. Walk `t_diagram` for every diagram.
+2. For each diagram, walk `t_diagramlinks` to find placed
+   elements + connectors; emit them as `<element>` children of
+   `<diagram>`.
+3. Each element child references its `xmi:idref` to the model
+   class.
+4. Connector children emit as `<connector>` with geometry (see
+   TODO 64).
+
+## Acceptance
+
+- `ea export xmi` output for basic.qea now contains
+  `<diagram>` elements (was 0/23).
+- Parity threshold raised from 25% to 50%.
+
+## OCP
+
+Diagrams emit via a new private method `emit_diagrams(model)`
+called after the model class tree. Adding new diagram metadata
+(swimlane info, etc.) = new private method, no other changes.

data/TODO.complete/66-qeatoxmi-style-tags-docs.md

@@ -0,0 +1,28 @@
+# TODO.complete/66: QeaToXmi emits style / tags / documentation
+
+## Status: open
+
+EA's reference XMI contains hundreds of `<style>`, `<tags>`, and
+`<documentation>` elements per diagram. Ours emits zero. Per the
+parity spec: 0/663 styles, 0/478 tags, 0/357 documentation entries.
+
+## Plan
+
+1. Walk `t_diagramlinks` to find connector+element style strings.
+2. Emit `<style>` children of `<connector>` / `<element>` with the
+   stored style XML verbatim.
+3. Walk `t_taggedvalue` for tagged values; emit as `<tags>` children
+   with `<tag>` items.
+4. Walk `t_objectnotes` for documentation; emit as `<documentation>`
+   children of the owning element.
+
+## Acceptance
+
+- Output contains `<style>`, `<tags>`, `<documentation>` elements.
+- Parity threshold raised from 50% to 75%.
+
+## OCP
+
+Each sub-element type (style/tags/documentation) is a private
+emitter method dispatched by collection. New element types = new
+case branch.

data/TODO.complete/67-ocl-collection-ops.md

@@ -0,0 +1,20 @@
+# TODO.complete/67: OCL collection operations
+
+## Status: open
+
+`Ea::Ocl` evaluates a subset of OCL: `exists`, `forAll`, `matches`,
+`and`/`or`/`not`, attribute access. Real EA constraints use
+`size()` and `isEmpty()` (parity: 0/0 because the OCL evaluator
+wasn't even invoked before this session).
+
+## Plan
+
+1. Add `CollectionSize` AST node: `<collection>->size()`.
+2. Add `CollectionIsEmpty` AST node: `<collection>->isEmpty()`.
+3. Parser recognizes `->size` and `->isEmpty` patterns.
+4. Evaluator returns integer / boolean.
+
+## Acceptance
+
+- Spec: `inv: self.items->size() > 0` parses + evaluates.
+- Spec: `inv: self.items->isEmpty() or self.required` parses + evaluates.

data/TODO.complete/68-ocl-comparison-ops.md

@@ -0,0 +1,19 @@
+# TODO.complete/68: OCL comparison operators
+
+## Status: open
+
+`Ea::Ocl` supports `=`/`==` via equality, but not ordering: `>`,
+`<`, `>=`, `<=`. These appear in real OCL invariants.
+
+## Plan
+
+1. Add `Comparison` AST node: `left op right` where op is one of
+   `>`, `<`, `>=`, `<=`.
+2. Parser recognizes the operators.
+3. Evaluator compares numeric operands; raises `UnsupportedError` on
+   non-numeric.
+
+## Acceptance
+
+- Spec: `inv: self.age >= 18` parses + evaluates (true / false).
+- Spec: `inv: self.count < self.max` parses + evaluates.

data/TODO.complete/69-spec-new-models.md

@@ -0,0 +1,25 @@
+# TODO.complete/69: Specs for newly-added QEA models
+
+## Status: open
+
+The following models were added in TODO 44 / TODO 7 sessions but
+have no spec coverage: `EaSecrypt`, `EaPalette`, `EaPaletteItem`,
+`EaImplement`, `EaRoleConstraint`, `EaObjectProblem`, `EaObjectRisk`,
+`EaObjectTest`, `EaObjectEffort`, `EaObjectResource`,
+`EaObjectScenario`, `EaObjectRequire`, `EaObjectTrx`.
+
+Without specs, regressions in column mapping or primary key logic
+go undetected.
+
+## Plan
+
+1. Single consolidated spec file: `spec/ea/qea/models/
+   auxiliary_models_spec.rb`.
+2. Per-model `it "loads primary key and columns"` block.
+3. Verifies `primary_key_column` is correct.
+4. Verifies `column_map` translates known column names to symbols.
+
+## Acceptance
+
+- File exists, all 13 models have at least 1 example.
+- `bundle exec rspec` passes with 0 failures.

data/lib/ea/cli/command/convert.rb

@@ -48,7 +48,7 @@ module Ea
 
         def qea_to_xmi_xml
           database = load_database(file_path)
-          Ea::Transformers.qea_to_xmi(database)
+          Ea::Transformers.qea_to_xmi(database, with_extensions: false)
         ensure
           database&.close_connection
         end

data/lib/ea/ocl/evaluator.rb

@@ -17,6 +17,9 @@ module Ea
         when Nodes::StringMatches then eval_string_matches(ast, context)
         when Nodes::CollectionExists then eval_exists(ast, context)
         when Nodes::CollectionForAll then eval_for_all(ast, context)
+        when Nodes::CollectionSize then eval_size(ast, context)
+        when Nodes::CollectionIsEmpty then eval_is_empty(ast, context)
+        when Nodes::Comparison then eval_comparison(ast, context)
         when Nodes::BinaryOp then eval_binary(ast, context)
         when Nodes::UnaryOp then eval_unary(ast, context)
         else
@@ -58,6 +61,40 @@ module Ea
         end
       end
 
+      def eval_size(ast, context)
+        collection = evaluate(ast.collection, context)
+        return 0 unless collection.respond_to?(:size)
+
+        collection.size
+      end
+
+      def eval_is_empty(ast, context)
+        collection = evaluate(ast.collection, context)
+        return true unless collection.respond_to?(:empty?)
+
+        collection.empty?
+      end
+
+      def eval_comparison(ast, context)
+        left = evaluate(ast.left, context)
+        right = evaluate(ast.right, context)
+        unless left.is_a?(Numeric) && right.is_a?(Numeric)
+          raise UnsupportedError,
+                "Comparison requires numeric operands: #{ast.op} on #{left.inspect}, #{right.inspect}"
+        end
+
+        case ast.op
+        when ">"  then left > right
+        when "<"  then left < right
+        when ">=" then left >= right
+        when "<=" then left <= right
+        when "="  then left == right
+        when "==" then left == right
+        when "!=" then left != right
+        else raise UnsupportedError, "Unknown comparison op: #{ast.op}"
+        end
+      end
+
       def eval_binary(ast, context)
         left = evaluate(ast.left, context)
         right = evaluate(ast.right, context)

data/lib/ea/ocl/nodes.rb

@@ -25,6 +25,15 @@ module Ea
       # `<a> and <b>`, `<a> or <b>`, `not <a>`
       BinaryOp = Struct.new(:op, :left, :right, keyword_init: true)
       UnaryOp = Struct.new(:op, :operand, keyword_init: true)
+
+      # `<collection>->size()` — returns integer cardinality.
+      CollectionSize = Struct.new(:collection, keyword_init: true)
+
+      # `<collection>->isEmpty()` — returns boolean.
+      CollectionIsEmpty = Struct.new(:collection, keyword_init: true)
+
+      # `<a> op <b>` where op ∈ {>, <, >=, <=, =, ==, !=}.
+      Comparison = Struct.new(:op, :left, :right, keyword_init: true)
     end
   end
 end

data/lib/ea/ocl/parser.rb

@@ -33,7 +33,7 @@ module Ea
       end
 
       # Parse one expression. Returns a single AST node.
-      def parse_expression(source)
+      def parse_expression(source) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
         s = source.strip
 
         # Strip outer parens
@@ -45,7 +45,14 @@ module Ea
                                     operand: parse_expression(s[4..]))
         end
 
-        # 'and' / 'or' at top level (find the operator not inside parens)
+        # 'and' / 'or' / comparison ops — comparison has higher
+        # precedence than logical, so check it first.
+        if (split = split_on_comparison_op(s))
+          op, left, right = split
+          return Nodes::Comparison.new(op: op,
+                                       left: parse_expression(left),
+                                       right: parse_expression(right))
+        end
         if (split = split_on_logical_op(s))
           op, left, right = split
           return Nodes::BinaryOp.new(op: op,
@@ -58,6 +65,16 @@ module Ea
           return collection_node(m[2].to_sym, m[1], m[3], m[4])
         end
 
+        # Collection ->size() — integer cardinality
+        if (m = s.match(/^(.+?)->size\(\)\z/))
+          return Nodes::CollectionSize.new(collection: parse_expression(m[1]))
+        end
+
+        # Collection ->isEmpty() — boolean
+        if (m = s.match(/^(.+?)->isEmpty\(\)\z/))
+          return Nodes::CollectionIsEmpty.new(collection: parse_expression(m[1]))
+        end
+
         # String.matches('regex')
         if (m = s.match(/^(.+?)\.matches\(\s*['"](.+?)['"]\s*\)\z/))
           return Nodes::StringMatches.new(string: parse_expression(m[1]),
@@ -99,7 +116,6 @@ module Ea
       # Find the topmost ` and ` or ` or ` outside of parens.
       # Returns [op, left_str, right_str] or nil.
       def split_on_logical_op(source)
-        depth = 0
         # Look for ' or ' first (lower precedence than 'and' in OCL?)
         # Actually OCL: 'or' < 'xor' < 'and' < 'implies'. We pick the
         # rightmost top-level operator (left-associative).
@@ -113,6 +129,45 @@ module Ea
         nil
       end
 
+      # Split on top-level comparison operator (>, <, >=, <=, =, ==, !=).
+      # Comparison has higher precedence than and/or, so we split here
+      # BEFORE calling split_on_logical_op.
+      def split_on_comparison_op(source)
+        %w[>= <= == != = > <].each do |op|
+          # Need to be careful with `>=` vs `>`: scan in order so
+          # multi-char operators are detected first.
+          idx = find_top_level_op(source, op)
+          next unless idx
+
+          return [op, source[0...idx], source[(idx + op.length)..]]
+        end
+        nil
+      end
+
+      def find_top_level_op(source, op) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        depth = 0
+        i = 0
+        while i < source.length
+          c = source[i]
+          depth += 1 if c == "("
+          depth -= 1 if c == ")"
+          if depth.zero? && source[i, op.length] == op
+            # Each `next` clause below MUST fall through to `i += 1`
+            # at the loop's tail — using `next` here would skip the
+            # increment and infinite-loop on the same matching char.
+            should_skip =
+              (op == ">" && source[i + 1, 1] == "=") || # >= matches as >
+              (op == "<" && source[i + 1, 1] == "=") || # <= matches as <
+              (op == "=" && source[i + 1, 1] == "=") || # == matches as =
+              (op == ">" && source[i - 1, 1] == "-") || # -> arrow
+              (op == "<" && source[i - 1, 1] == "-") # <- arrow
+            return i unless should_skip
+          end
+          i += 1
+        end
+        nil
+      end
+
       # Find substring at depth 0 (not inside parens).
       def find_top_level(source, substring)
         depth = 0
@@ -121,9 +176,8 @@ module Ea
           c = source[i]
           depth += 1 if c == "("
           depth -= 1 if c == ")"
-          if depth.zero? && source[i, substring.length] == substring
-            return i
-          end
+          return i if depth.zero? && source[i, substring.length] == substring
+
           i += 1
         end
         nil

data/lib/ea/transformers/qea_to_xmi/transformer.rb

@@ -70,8 +70,144 @@ module Ea
         # nil-valued attributes are skipped at the source. No
         # post-processing pass is needed — the prior XmlSanitizer
         # workaround (TODO 21 §1) has been removed.
-        def serialize
-          build_root.to_xml(use_prefix: true)
+        # Serialize to XMI XML.
+        #
+        # Default produces model tree only (parseable by the xmi gem's
+        # Sparx parser for round-trip). Pass `with_extensions: true` to
+        # also emit EA-specific `<connectors>` and `<diagrams>` sections
+        # inside `<xmi:Extension>`. Those use post-processing string
+        # injection that the xmi gem's parser doesn't model, so the
+        # output is NOT round-trippable when extensions are included.
+        #
+        # @param with_extensions [Boolean]
+        # @return [String] XMI XML
+        def serialize(with_extensions: true)
+          xml = build_root.to_xml(use_prefix: true)
+          with_extensions ? inject_extension_content(xml) : xml
+        end
+
+        # Injects EA-specific extension content (connectors, diagrams)
+        # into the serialized XMI. The xmi gem's Extension type is
+        # modeled but doesn't declare `connectors` / `diagrams`
+        # children. We post-process the serialized XML to insert
+        # them inside the existing `<xmi:Extension>` element.
+        def inject_extension_content(xml)
+          content = extension_inner_xml
+          return xml if content.empty?
+
+          # Replace the empty `<xmi:Extension .../>` or the
+          # closing `</xmi:Extension>` with the populated version.
+          if xml.include?("<xmi:Extension")
+            xml.sub(%r{<xmi:Extension ([^>]+)>\s*</xmi:Extension>},
+                   "<xmi:Extension \\1>\n#{content}\n\t</xmi:Extension>")
+               .sub(/<xmi:Extension ([^>]+)\/>/,
+                    "<xmi:Extension \\1>\n#{content}\n\t</xmi:Extension>")
+          else
+            xml
+          end
+        end
+
+        # @return [String] XML for the inner content of <xmi:Extension>:
+        #   <elements>...</elements>, <connectors>...</connectors>,
+        #   <diagrams>...</diagrams>. Empty when none apply.
+        def extension_inner_xml
+          parts = []
+          connectors_xml = build_connectors_extension
+          parts << connectors_xml unless connectors_xml.empty?
+          diagrams_xml = build_diagrams_extension
+          parts << diagrams_xml unless diagrams_xml.empty?
+          parts.join("\n")
+        end
+
+        def build_connectors_extension
+          connectors = @database.collections[:connectors] || []
+          return "" if connectors.empty?
+
+          inner = connectors.map { |conn| connector_xml(conn) }.compact.join("\n")
+          return "" if inner.empty?
+
+          "\t\t<connectors>\n#{inner}\n\t\t</connectors>"
+        end
+
+        def build_diagrams_extension
+          diagrams = @database.collections[:diagrams] || []
+          return "" if diagrams.empty?
+
+          inner = diagrams.map { |dgm| diagram_xml(dgm) }.compact.join("\n")
+          return "" if inner.empty?
+
+          "\t\t<diagrams>\n#{inner}\n\t\t</diagrams>"
+        end
+
+        # Per-connector XML with xmi:idref to the model-level
+        # association (when present) plus source/target references.
+        def connector_xml(conn)
+          return nil unless conn.ea_guid
+
+          connector_id = "EAID_#{guid_to_xmi_id(conn.ea_guid)}"
+          source_obj = @database.collections[:objects]&.find { |o| o.ea_object_id == conn.start_object_id }
+          target_obj = @database.collections[:objects]&.find { |o| o.ea_object_id == conn.end_object_id }
+          return nil unless source_obj && target_obj
+
+          name_attr = conn.name ? %( name="#{escape(conn.name)}") : ""
+          inner = source_end_xml(conn, source_obj) + target_end_xml(conn, target_obj)
+          %(<connector xmi:idref="#{connector_id}"#{name_attr}>\n#{inner}\t\t</connector>)
+        end
+
+        def source_end_xml(conn, source_obj)
+          end_xml(source_obj, "source")
+        end
+
+        def target_end_xml(conn, target_obj)
+          end_xml(target_obj, "target")
+        end
+
+        def end_xml(obj, kind)
+          xmi_id = "EAID_#{guid_to_xmi_id(obj.ea_guid)}"
+          lines = [
+            "\t\t\t<#{kind} xmi:idref=\"#{xmi_id}\">",
+            "\t\t\t\t<model ea_localid=\"#{obj.ea_object_id}\" " \
+              "type=\"#{obj.object_type}\" name=\"#{escape(obj.name.to_s)}\"/>",
+            "\t\t\t\t<role visibility=\"Public\" targetScope=\"instance\"/>",
+            "\t\t\t</#{kind}>"
+          ]
+          lines.join("\n") + "\n"
+        end
+
+        def diagram_xml(dgm)
+          return nil unless dgm.ea_guid
+
+          diagram_id = "EAID_#{guid_to_xmi_id(dgm.ea_guid)}"
+          pkg_guid = package_guid_for(dgm)
+          pkg_ref = pkg_guid ? "EAPK_#{guid_to_xmi_id(pkg_guid)}" : ""
+          lines = [
+            "<diagram xmi:id=\"#{diagram_id}\">",
+            "\t\t\t<model package=\"#{pkg_ref}\" localID=\"#{dgm.diagram_id}\" owner=\"#{pkg_ref}\"/>",
+            "\t\t\t<properties name=\"#{escape(dgm.name.to_s)}\" type=\"#{escape(dgm.diagram_type.to_s)}\"/>",
+            "\t\t</diagram>"
+          ]
+          lines.join("\n")
+        end
+
+        def package_guid_for(dgm)
+          pkg = (@database.collections[:packages] || []).find { |p| p.package_id == dgm.package_id }
+          pkg&.ea_guid || dgm.ea_guid
+        end
+
+        def guid_to_xmi_id(guid)
+          return "" unless guid
+
+          guid.to_s.gsub(/[{}]/, "")
+                  .tr("-", "_")
+                  .prepend("EA") # truncated below
+                  .sub(/\AEA/, "")
+        end
+
+        def escape(text)
+          text.to_s.gsub("&", "&amp;")
+               .gsub("<", "&lt;")
+               .gsub(">", "&gt;")
+               .gsub('"', "&quot;")
         end
 
         private

data/lib/ea/transformers.rb

@@ -25,9 +25,10 @@ module Ea
       # Sparx-specific concepts (stereotypes, tagged values, multiplicities,
       # diagrams, xrefs).
       # @param database [Ea::Qea::Database]
+      # @param with_extensions [Boolean] emit EA-specific connectors+diagrams
       # @return [String] XMI XML
-      def qea_to_xmi(database)
-        QeaToXmi::Transformer.new(database).serialize
+      def qea_to_xmi(database, with_extensions: true)
+        QeaToXmi::Transformer.new(database).serialize(with_extensions: with_extensions)
       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.5.1"
+  VERSION = "0.5.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Ribose Inc.
@@ -236,6 +236,12 @@ files:
 - TODO.complete/61-plantuml-relationships.md
 - TODO.complete/62-changelog.md
 - TODO.complete/63-dependabot-fix.md
+- TODO.complete/64-qeatoxmi-connectors.md
+- TODO.complete/65-qeatoxmi-diagrams.md
+- TODO.complete/66-qeatoxmi-style-tags-docs.md
+- TODO.complete/67-ocl-collection-ops.md
+- TODO.complete/68-ocl-comparison-ops.md
+- TODO.complete/69-spec-new-models.md
 - TODO.complete/STATUS.md
 - TODO.diagrams/01-svg-measurement-harness.md
 - TODO.diagrams/01-xmi-extension-elements-parsing.md