ea 0.3.1 → 0.5.0

data/lib/ea/sources/qea/xref/parser.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Pure parser for EA's `t_xref.Description` mini-language.
+        # Stateless — every call returns a fresh `Xref::Record`.
+        #
+        # Supported formats:
+        #   @STEREO;Name=X;FQName=Y;@ENDSTEREO;
+        #   @PROP=@NAME=..@ENDNAME;@TYPE=..@ENDTYPE;@VALU=..@ENDVALU;@PRMT=..@ENDPRMT;@ENDPROP;
+        #   <key>=<value>;<key>=<value>;
+        #
+        # Unknown formats fall through to key=value parsing.
+        module Parser
+          module_function
+
+          # Parse one Description string into a typed Record.
+          # @param description [String, nil]
+          # @return [Ea::Sources::Qea::Xref::Record]
+          def parse(description)
+            return Record.new if description.nil? || description.empty?
+
+            Record.new(
+              stereotype: parse_stereotype(description),
+              properties: parse_properties(description),
+              legends: parse_legends(description),
+              key_values: parse_key_values(description),
+              raw: description
+            )
+          end
+
+          # -- per-format extractors ----------------------------------
+
+          # Matches both legacy `@STEREO;Name=X;GUID={..};` and the
+          # plateau form `@STEREO;Name=X;FQName=Y;@ENDSTEREO;`.
+          STEREO_REGEX = /
+            @STEREO;
+            (.*?)
+            (?:@ENDSTEREO;|\z)
+          /mx.freeze
+
+          def parse_stereotype(description)
+            match = description.match(STEREO_REGEX)
+            return nil unless match
+
+            fields = parse_semicolon_fields(match[1])
+            StereotypeApplication.new(
+              name: fields["Name"],
+              fqname: fields["FQName"]
+            )
+          end
+
+          # One Description can carry multiple @PROP=...@ENDPROP; blocks.
+          # Split, then classify each as PropertyDefinition or LegendDefinition.
+          PROP_REGEX = /
+            @PROP=
+            (.*?)
+            @ENDPROP;
+          /mx.freeze
+
+          def parse_properties(description)
+            blocks = description.scan(PROP_REGEX).flatten
+            blocks.each_with_object([]) do |block, acc|
+              record = build_prop_record(block)
+              acc << record if record
+            end
+          end
+
+          def parse_legends(description)
+            parse_properties(description).select do |prop|
+              prop.is_a?(LegendDefinition)
+            end
+          end
+
+          def build_prop_record(block)
+            name = extract_tagged_value(block, "NAME")
+            type = extract_tagged_value(block, "TYPE")
+            value = extract_tagged_value(block, "VALU")
+            parameter = extract_tagged_value(block, "PRMT")
+
+            if type&.start_with?("LEGEND_")
+              LegendDefinition.new(
+                name: name,
+                legend_type: type,
+                colors: parse_color_value(value),
+                parameter: parameter
+              )
+            else
+              PropertyDefinition.new(
+                name: name,
+                type: type,
+                value: value,
+                parameter: parameter
+              )
+            end
+          end
+
+          # Extracts the content between @TAG=...@ENDTAG; markers.
+          # Returns nil when the tag is absent.
+          def extract_tagged_value(block, tag)
+            pattern = /@#{tag}=(.*?)@END#{tag};/m.freeze
+            match = block.match(pattern)
+            match ? match[1] : nil
+          end
+
+          # EA encodes legend VALU as `#key#=value;` pairs.
+          # Returns a hash keyed by underscored symbol.
+          def parse_color_value(value)
+            return {} if value.nil? || value.empty?
+
+            value.scan(/#([^#=]+)#=([^;]*);/).each_with_object({}) do |(k, v), acc|
+              acc[k.downcase.to_sym] = v
+            end
+          end
+
+          # Legacy `Key=Value;Key=Value;` parsing. Skips content that
+          # looks like @STEREO or @PROP blocks to avoid noise.
+          def parse_key_values(description)
+            stripped = description
+                       .gsub(/@STEREO;.*?(?:@ENDSTEREO;|\z)/m, "")
+                       .gsub(/@PROP=.*?@ENDPROP;/m, "")
+            pairs = stripped.split(";").map { |s| s.split("=", 2) }
+            pairs.each_with_object({}) do |(k, v), acc|
+              next if k.nil? || k.empty? || v.nil?
+
+              acc[k.downcase.to_sym] = v
+            end
+          end
+
+          # Parse `Key=Value;Key=value;` into a string-keyed hash.
+          # Used internally for the @STEREO body fields.
+          def parse_semicolon_fields(body)
+            body.split(";").each_with_object({}) do |part, acc|
+              key, value = part.split("=", 2)
+              next if key.nil? || key.empty? || value.nil?
+
+              # Strip @END* terminators that may be attached when the
+              # body wasn't cleanly split (defensive — usually already
+              # consumed by STEREO_REGEX).
+              cleaned = value.sub(/@END\w+\z/, "")
+              acc[key] = cleaned
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/qea/xref/property_definition.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Tagged-value / property definition record. Produced when the
+        # Description contains one or more `@PROP=@NAME=..@ENDNAME;`
+        # blocks for non-legend properties.
+        #
+        # Example source:
+        #   @PROP=@NAME=isActive@ENDNAME;@TYPE=Boolean@ENDTYPE;
+        #         @VALU=@ENDVALU;@PRMT=@ENDPRMT;@ENDPROP;
+        PropertyDefinition = Struct.new(:name, :type, :value, :parameter,
+                                        keyword_init: true) do
+          # @return [Boolean] true when the value field is non-empty
+          def default_value?
+            !value.nil? && !value.empty?
+          end
+
+          # @return [Boolean] true when the property is declared as Boolean
+          def boolean?
+            type == "Boolean"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/qea/xref/record.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Parsed t_xref.Description. Holds typed records for each block
+        # found in the source string. One Description can carry multiple
+        # records (e.g., several `@PROP=` blocks defining a stereotype's
+        # tagged-value set).
+        #
+        # Consumers branch on record type without re-parsing strings.
+        Record = Struct.new(:stereotype, :properties, :legends,
+                            :key_values, :raw, keyword_init: true) do
+          def initialize(*)
+            super
+            self.properties ||= []
+            self.legends ||= []
+            self.key_values ||= {}
+          end
+
+          # @return [Boolean] true when a stereotype application is present
+          def stereotype?
+            !stereotype.nil?
+          end
+
+          # @return [Boolean] true when at least one legend is present
+          def legend?
+            !legends.empty?
+          end
+
+          # Convenience: first legend's name (the legend's title).
+          # @return [String, nil]
+          def legend_title
+            legends.first&.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/qea/xref/stereotype_application.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      module Xref
+        # Stereotype application record. Produced when the Description
+        # starts with `@STEREO;`. Captures the short name and the
+        # fully-qualified `tech::Stereo` form when present.
+        #
+        # Example source:
+        #   @STEREO;Name=FeatureType;FQName=GML::FeatureType;@ENDSTEREO;
+        StereotypeApplication = Struct.new(:name, :fqname, keyword_init: true) do
+          # Returns the technology prefix from FQName, or nil.
+          # @return [String, nil]
+          def technology
+            return nil unless fqname
+
+            idx = fqname.index("::")
+            idx ? fqname[0, idx] : nil
+          end
+
+          # Returns the stereotype name without technology prefix.
+          # Falls back to +name+ when FQName is absent.
+          # @return [String, nil]
+          def unqualified_name
+            if fqname && fqname.include?("::")
+              fqname.split("::", 2).last
+            else
+              name
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Namespace for parsing EA's `t_xref.Description` mini-language.
+      #
+      # EA encodes semi-structured metadata in a custom format combining:
+      #
+      # - Stereotype application: `@STEREO;Name=X;FQName=Y;@ENDSTEREO;`
+      # - Property definitions: `@PROP=@NAME=..@ENDNAME;@TYPE=..@ENDTYPE;...`
+      # - Legend definitions:    `@PROP=@NAME=..;@TYPE=LEGEND_OBJECTSTYLE;...`
+      # - Legacy key=value:      `aggregation=composite;direction=source;`
+      #
+      # The parser returns a typed `Xref::Record` value object so consumers
+      # can branch on record type without re-parsing strings (OCP/MECE).
+      module Xref
+        autoload :Parser, "ea/sources/qea/xref/parser"
+        autoload :Record, "ea/sources/qea/xref/record"
+        autoload :StereotypeApplication,
+                 "ea/sources/qea/xref/stereotype_application"
+        autoload :PropertyDefinition, "ea/sources/qea/xref/property_definition"
+        autoload :LegendDefinition, "ea/sources/qea/xref/legend_definition"
+      end
+    end
+  end
+end

data/lib/ea/sources/qea.rb

@@ -22,9 +22,13 @@ module Ea
       autoload :RelationshipBuilder, "ea/sources/qea/relationship_builder"
       autoload :StereotypeBuilder, "ea/sources/qea/stereotype_builder"
       autoload :TaggedValueBuilder, "ea/sources/qea/tagged_value_builder"
+      autoload :NoteBuilder, "ea/sources/qea/note_builder"
       autoload :AnnotationBuilder, "ea/sources/qea/annotation_builder"
+      autoload :InstanceBuilder, "ea/sources/qea/instance_builder"
+      autoload :LegendBuilder, "ea/sources/qea/legend_builder"
       autoload :DiagramBuilder, "ea/sources/qea/diagram_builder"
       autoload :DiagramStyleParser, "ea/sources/qea/diagram_style_parser"
+      autoload :Xref, "ea/sources/qea/xref"
       autoload :Adapter, "ea/sources/qea/adapter"
     end
   end

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

@@ -25,18 +25,92 @@ module Ea
         end
 
         def to_document
-          Ea::Model::Document.new(
+          doc = Ea::Model::Document.new(
             metadata: metadata,
             packages: packages,
             classifiers: classifiers,
             relationships: relationships,
             stereotypes: [],
+            notes: notes,
             diagrams: diagrams
           )
+          apply_tagged_values(doc)
+          apply_stereotypes(doc)
+          resolve_type_names(doc)
+          doc
         end
 
         private
 
+        # Attach stereotypes parsed from <xmi:Extension>/<elements>
+        # to their owning classifiers and packages.
+        def apply_stereotypes(doc)
+          grouped = StereotypeBuilder.new(root).grouped_by_element
+          return if grouped.empty?
+
+          doc.classifiers.each do |c|
+            next unless c.id
+
+            refs = grouped[c.id]
+            next unless refs
+
+            c.stereotype_refs = refs
+          end
+          doc.packages.each do |p|
+            next unless p.id
+
+            refs = grouped[p.id] || grouped["EAID_#{p.id[5..]}"]
+            next unless refs
+
+            p.stereotype_refs = refs
+          end
+        end
+
+        # Attach tagged values parsed from the <xmi:Extension><tags>
+        # block to their owning classifiers and packages.
+        def apply_tagged_values(doc)
+          grouped = TagBuilder.new(xmi_path).grouped_by_model_element
+          return if grouped.empty?
+
+          doc.classifiers.each do |c|
+            next unless c.id
+
+            tags = grouped[c.id]
+            next unless tags
+
+            c.tagged_values = tags
+          end
+          doc.packages.each do |p|
+            next unless p.id
+
+            tags = grouped[p.id] || grouped["EAID_#{p.id[5..]}"]
+            next unless tags
+
+            p.tagged_values = tags
+          end
+        end
+
+        def resolve_type_names(doc)
+          # In the XMI, the <type xmi:idref=...> is the type
+          # classifier's GUID. The property's type_name was
+          # pre-populated by PropertyBuilder with the same idref;
+          # we replace it with the in-model qualified name when
+          # the referenced classifier is loaded.
+          qualified_by_id = doc.classifiers.each_with_object({}) do |c, acc|
+            acc[c.id] = c.qualified_name if c.id && c.qualified_name
+          end
+
+          doc.classifiers.each do |classifier|
+            (classifier.properties || []).each do |prop|
+              ref = prop.type_ref
+              next if ref.nil? || ref.empty?
+
+              resolved = qualified_by_id[ref]
+              prop.type_name = resolved if resolved
+            end
+          end
+        end
+
         def metadata
           @metadata ||= MetadataBuilder.new(root, xmi_path).build
         end
@@ -54,7 +128,11 @@ module Ea
         end
 
         def diagrams
-          @diagrams ||= DiagramBuilder.new(root).build_all
+          @diagrams ||= DiagramBuilder.new(root, xmi_path).build_all
+        end
+
+        def notes
+          @notes ||= NoteBuilder.new(root).build_all
         end
       end
     end

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

@@ -23,7 +23,7 @@ module Ea
         end
 
         def self.from_comments(comments, owner_id, kind: "documentation")
-          Array(comments).map { |c| new(owner_id).build(kind, c.body) }
+          Array(comments).map { |c| new(owner_id).build(kind, c.body_element || c.body_attribute) }
         end
 
         def self.comments_on(element)

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

@@ -73,8 +73,17 @@ module Ea
         end
 
         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?
           pkg_name = containing_package&.name
-          pkg_name ? "#{pkg_name}::#{element.name}" : element.name
+          pkg_name ? "#{pkg_name}::#{simple}" : simple
         end
 
         def boolean(value)