ea 0.2.5 → 0.3.1

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Builds Ea::Model::Stereotype instances from EA's
+      # t_stereotypes table and from the `stereotype` column on
+      # individual elements. EA's stereotype storage is messy — a
+      # stereotype can be declared globally and applied per-element
+      # by name. We treat each distinct applied stereotype name as
+      # an instance and reference it from the applying element.
+      class StereotypeBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all
+          stereotypes = database.collections[:stereotypes] || []
+          stereotypes.map { |st| build_one(st) }
+        end
+
+        def build_one(stereotype_row)
+          name = stereotype_row.stereotype
+          Ea::Model::Stereotype.new(
+            id: IdNormalizer.from_guid(stereotype_row.ea_guid) ||
+                IdNormalizer.synthetic("stereotype", name),
+            name: name,
+            qualified_name: name,
+            profile: stereotype_row.appliesto
+          )
+        end
+
+        # Apply references: which stereotypes apply to a given EA object.
+        def refs_for_object(object)
+          refs = []
+          refs << object.stereotype if object.stereotype && !object.stereotype.empty?
+          refs.uniq
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Builds Ea::Model::TaggedValue instances from EA's
+      # t_objectproperties (and t_attributetags for attribute-level
+      # tagged values). Each row is one key/value pair; we keep the
+      # optional stereotype scope if EA recorded one.
+      class TaggedValueBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def for_object(ea_guid)
+          rows = database.tagged_values_for_element(ea_guid) || []
+          rows.map { |row| build_from_row(row, ea_guid) }
+        end
+
+        def for_attribute(attribute_row)
+          return [] unless attribute_row.respond_to?(:ea_guid)
+
+          rows = database.tagged_values_for_element(attribute_row.ea_guid) || []
+          rows.map { |row| build_from_row(row, attribute_row.ea_guid) }
+        end
+
+        def build_from_row(row, owner_guid)
+          Ea::Model::TaggedValue.new(
+            id: IdNormalizer.synthetic("tv", owner_guid, row.property&.gsub(/\W+/, "_")),
+            key: row.property,
+            value: row.value
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/qea.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    # QEA source adapter. Produces an Ea::Model::Document from a
+    # parsed Ea::Qea::Database by walking the SQLite-derived tables
+    # once and translating each row into a model instance.
+    #
+    # Structure: Adapter coordinates per-domain Builders. Each
+    # Builder owns one source table → model type translation, so
+    # new model types or new source columns only touch one Builder
+    # (OCP/MECE).
+    module Qea
+      autoload :IdNormalizer, "ea/sources/qea/id_normalizer"
+      autoload :ObjectClassifierMap, "ea/sources/qea/object_classifier_map"
+      autoload :ConnectorRelationshipMap, "ea/sources/qea/connector_relationship_map"
+      autoload :MetadataBuilder, "ea/sources/qea/metadata_builder"
+      autoload :PackageBuilder, "ea/sources/qea/package_builder"
+      autoload :ClassifierBuilder, "ea/sources/qea/classifier_builder"
+      autoload :PropertyBuilder, "ea/sources/qea/property_builder"
+      autoload :OperationBuilder, "ea/sources/qea/operation_builder"
+      autoload :RelationshipBuilder, "ea/sources/qea/relationship_builder"
+      autoload :StereotypeBuilder, "ea/sources/qea/stereotype_builder"
+      autoload :TaggedValueBuilder, "ea/sources/qea/tagged_value_builder"
+      autoload :AnnotationBuilder, "ea/sources/qea/annotation_builder"
+      autoload :DiagramBuilder, "ea/sources/qea/diagram_builder"
+      autoload :DiagramStyleParser, "ea/sources/qea/diagram_style_parser"
+      autoload :Adapter, "ea/sources/qea/adapter"
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Driving port: produces an Ea::Model::Document from a parsed
+      # Xmi::Sparx::Root. Walks the UML model tree once and
+      # delegates to per-domain builders. The result is structurally
+      # identical to what the QEA adapter produces for the same
+      # conceptual source — that's the "single way" promise.
+      class Adapter
+        attr_reader :root, :xmi_path
+
+        def initialize(root, xmi_path = nil)
+          @root = root
+          @xmi_path = xmi_path
+        end
+
+        # Convenience: build a document directly from an .xmi file
+        # path. Parses via Xmi::Sparx::Root.parse_xml.
+        def self.from_path(xmi_path)
+          require "xmi"
+          root = ::Xmi::Sparx::Root.parse_xml(File.read(xmi_path))
+          new(root, xmi_path).to_document
+        end
+
+        def to_document
+          Ea::Model::Document.new(
+            metadata: metadata,
+            packages: packages,
+            classifiers: classifiers,
+            relationships: relationships,
+            stereotypes: [],
+            diagrams: diagrams
+          )
+        end
+
+        private
+
+        def metadata
+          @metadata ||= MetadataBuilder.new(root, xmi_path).build
+        end
+
+        def packages
+          @packages ||= PackageBuilder.new(root).build_all
+        end
+
+        def classifiers
+          @classifiers ||= ClassifierBuilder.new(root).build_all
+        end
+
+        def relationships
+          @relationships ||= RelationshipBuilder.new(root).build_all
+        end
+
+        def diagrams
+          @diagrams ||= DiagramBuilder.new(root).build_all
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Builds Ea::Model::Annotation instances from XMI owned_comment
+      # elements. Each non-empty comment body becomes one Annotation.
+      class AnnotationBuilder
+        attr_reader :owner_id
+
+        def initialize(owner_id)
+          @owner_id = owner_id
+        end
+
+        # Extract comments from a source element. Only PackagedElement-
+        # derived types (Class, Package, Association, etc.) carry
+        # owned_comment in the XMI schema; attribute/operation/literal
+        # do not. We dispatch on type rather than poking at the
+        # method, so unknown element types just yield no annotations.
+        def self.from_element(element, owner_id, kind: "documentation")
+          comments = comments_on(element)
+          from_comments(comments, owner_id, kind: kind)
+        end
+
+        def self.from_comments(comments, owner_id, kind: "documentation")
+          Array(comments).map { |c| new(owner_id).build(kind, c.body) }
+        end
+
+        def self.comments_on(element)
+          return [] unless element.is_a?(::Xmi::Uml::PackagedElement)
+
+          element.owned_comment
+        end
+
+        def build(kind, body, author: nil, modified_date: nil)
+          return nil if body.nil? || body.empty?
+
+          Ea::Model::Annotation.new(
+            id: IdNormalizer.synthetic_id(owner_id, kind),
+            kind: kind,
+            body: body,
+            author: author,
+            modified_date: modified_date
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Translates XMI classifier elements (uml:Class, uml:DataType,
+      # uml:Enumeration, uml:Interface, uml:PrimitiveType) into the
+      # appropriate Ea::Model::Classifier subclass. Uses
+      # TypeClassifierMap for dispatch (OCP).
+      class ClassifierBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def build_all
+          classifiers = []
+          walk(root.model) do |element, parent_pkg|
+            next unless TypeClassifierMap.classifier_type?(element.type)
+
+            classifiers << build_one(element, parent_pkg)
+          end
+          classifiers
+        end
+
+        def build_one(element, containing_package)
+          klass = TypeClassifierMap.class_for(element.type)
+          args = common_args(element, containing_package)
+          args.merge!(enumeration_args(element)) if klass == Ea::Model::Enumeration
+          klass.new(**args)
+        end
+
+        private
+
+        # Depth-first walk of the packaged_element tree. Yields each
+        # element with its containing uml:Package (or nil at the
+        # model root).
+        def walk(element, parent_pkg = nil, &block)
+          yield element, parent_pkg if block
+          element.packaged_element.each do |inner|
+            new_parent = inner.type == "uml:Package" ? inner : parent_pkg
+            walk(inner, new_parent, &block)
+          end
+        end
+
+        def common_args(element, containing_package)
+          id = IdNormalizer.from_xmi_id(element.id)
+          {
+            id: id,
+            name: element.name,
+            package_id: containing_package && IdNormalizer.from_xmi_id(containing_package.id),
+            qualified_name: qualified_name(element, containing_package),
+            is_abstract: boolean(element.is_abstract),
+            visibility: element.visibility,
+            properties: PropertyBuilder.new.build_all_for(element),
+            operations: OperationBuilder.new.build_all_for(element),
+            annotations: AnnotationBuilder.from_element(element, id)
+          }
+        end
+
+        def enumeration_args(element)
+          literals = element.owned_literal.map.with_index do |lit, idx|
+            Ea::Model::EnumerationLiteral.new(
+              id: IdNormalizer.from_xmi_id(lit.id) ||
+                  IdNormalizer.synthetic_id(element.id, "literal", idx.to_s),
+              name: lit.name,
+              value: lit.name,
+              ordinal: idx
+            )
+          end
+          { literals: literals }
+        end
+
+        def qualified_name(element, containing_package)
+          pkg_name = containing_package&.name
+          pkg_name ? "#{pkg_name}::#{element.name}" : element.name
+        end
+
+        def boolean(value)
+          case value
+          when true, "true" then true
+          else false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Translates XMI uml:Diagram elements into Ea::Model::Diagram
+      # instances. Coordinates come from the UML-DI owned_element
+      # bounds; element references come from the model_element
+      # attribute.
+      class DiagramBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def build_all
+          diagrams = Array(root.model.diagram)
+          diagrams.map { |d| build_one(d) }
+        end
+
+        def build_one(diagram)
+          id = IdNormalizer.from_xmi_id(diagram.id)
+          ext_diagram = extension_diagram_for(id)
+          Ea::Model::Diagram.new(
+            id: id,
+            name: ext_diagram&.properties&.name,
+            package_id: ext_diagram&.model&.package,
+            diagram_type: ext_diagram&.properties&.type&.split(":")&.last&.downcase,
+            bounds: bounds_for(diagram),
+            elements: build_elements(diagram, id),
+            connectors: [],
+            annotations: AnnotationBuilder.from_element(diagram, id)
+          )
+        end
+
+        private
+
+        def extension_diagram_for(diagram_id)
+          return nil unless root.extension&.diagrams
+
+          root.extension.diagrams.diagram.find { |d| d.id == diagram_id }
+        end
+
+        def bounds_for(diagram)
+          first_bounds = diagram.owned_element.flat_map(&:bounds).first
+          return nil unless first_bounds
+
+          Ea::Model::Bounds.new(
+            x: first_bounds.x || 0,
+            y: first_bounds.y || 0,
+            width: first_bounds.width || 0,
+            height: first_bounds.height || 0
+          )
+        end
+
+        def build_elements(diagram, owner_diagram_id)
+          diagram.owned_element.flat_map do |oe|
+            oe.bounds.each_with_index.map do |bnd, idx|
+              build_element(oe, bnd, owner_diagram_id, idx)
+            end
+          end
+        end
+
+        def build_element(owned_element, bounds, diagram_id, idx)
+          Ea::Model::DiagramElement.new(
+            id: IdNormalizer.synthetic_id(diagram_id, "elem", idx.to_s),
+            diagram_id: diagram_id,
+            model_element_ref: IdNormalizer.from_xmi_id(owned_element.model_element),
+            bounds: Ea::Model::Bounds.new(
+              x: bounds.x || 0,
+              y: bounds.y || 0,
+              width: bounds.width || 0,
+              height: bounds.height || 0
+            ),
+            style: {}
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Normalizes XMI identifiers (xmi:id strings, often EAID_...
+      # or GUID-shaped) into stable model ids. Pass-through for
+      # real ids; synthetic ids for derived elements that have no
+      # xmi:id (annotations, waypoints).
+      module IdNormalizer
+        module_function
+
+        def from_xmi_id(xmi_id)
+          return nil if xmi_id.nil? || xmi_id.empty?
+
+          xmi_id.to_s
+        end
+
+        def synthetic_id(owner_id, kind, suffix = nil)
+          parts = ["#{owner_id}:#{kind}"]
+          parts << suffix if suffix
+          parts.join(":")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      class MetadataBuilder
+        attr_reader :root, :xmi_path
+
+        def initialize(root, xmi_path)
+          @root = root
+          @xmi_path = xmi_path
+        end
+
+        def build
+          model = root.model
+          documentation = root.documentation
+          Ea::Model::Metadata.new(
+            id: "metadata",
+            title: model&.name,
+            version: documentation&.exporter_version,
+            author: documentation&.exporter,
+            created_date: nil,
+            modified_date: documentation&.timestamp&.first&.iso8601,
+            source_format: "xmi",
+            source_tool: documentation&.exporter,
+            source_path: xmi_path
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Translates XMI OwnedOperation elements (with their
+      # OwnedParameter children) into Ea::Model::Operation instances.
+      class OperationBuilder
+        def build_all_for(classifier)
+          classifier.owned_operation.map { |op| build_one(op, classifier) }
+        end
+
+        def build_one(op, owner)
+          id = IdNormalizer.from_xmi_id(op.id) ||
+               IdNormalizer.synthetic_id(owner.id, "op", op.name)
+          Ea::Model::Operation.new(
+            id: id,
+            name: op.name,
+            owner_id: owner.id,
+            qualified_name: "#{owner.name}::#{op.name}",
+            return_type_name: return_type_name_for(op),
+            visibility: op.visibility,
+            is_static: boolean(op.is_static),
+            is_abstract: boolean(op.is_abstract),
+            parameters: build_parameters(op, id),
+            annotations: AnnotationBuilder.from_element(op, id)
+          )
+        end
+
+        private
+
+        def build_parameters(op, owner_op_id)
+          op.owned_parameter.map.with_index do |param, idx|
+            direction = param.direction || (idx.zero? ? "return" : "in")
+            Ea::Model::Parameter.new(
+              id: IdNormalizer.from_xmi_id(param.id) ||
+                  IdNormalizer.synthetic_id(owner_op_id, "param", idx.to_s),
+              name: param.name || direction,
+              ordinal: idx,
+              direction: direction,
+              type_name: param.type
+            )
+          end
+        end
+
+        def return_type_name_for(op)
+          op.owned_parameter.find { |p| p.direction == "return" }&.type
+        end
+
+        def boolean(value)
+          case value
+          when true, "true" then true
+          else false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Translates XMI uml:Package elements into Ea::Model::Package
+      # instances. Walks the packaged_element tree recursively so
+      # nested packages are picked up.
+      class PackageBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def build_all
+          packages = []
+          walk_packages(root.model, nil) do |pe, parent_id|
+            packages << build_one(pe, parent_id: parent_id)
+          end
+          packages
+        end
+
+        def walk_packages(element, parent_id, &block)
+          element.packaged_element.each do |inner|
+            next unless inner.type == "uml:Package"
+
+            id = IdNormalizer.from_xmi_id(inner.id)
+            yield inner, parent_id
+            walk_packages(inner, id, &block)
+          end
+        end
+
+        def build_one(packaged_element, parent_id:)
+          id = IdNormalizer.from_xmi_id(packaged_element.id)
+          Ea::Model::Package.new(
+            id: id,
+            name: packaged_element.name,
+            parent_id: parent_id,
+            qualified_name: packaged_element.name,
+            sub_package_ids: child_package_ids(packaged_element),
+            classifier_ids: child_classifier_ids(packaged_element),
+            annotations: AnnotationBuilder.from_element(packaged_element, id)
+          )
+        end
+
+        private
+
+        def packages_for(model_element)
+          return [] unless model_element
+
+          model_element.packaged_element.select { |pe| pe.type == "uml:Package" }
+        end
+
+        def child_package_ids(packaged_element)
+          packaged_element.packaged_element
+                          .select { |pe| pe.type == "uml:Package" }
+                          .map { |pe| IdNormalizer.from_xmi_id(pe.id) }
+                          .compact
+        end
+
+        def child_classifier_ids(packaged_element)
+          packaged_element.packaged_element
+                          .filter_map do |pe|
+                            next unless TypeClassifierMap.classifier_type?(pe.type)
+
+                            IdNormalizer.from_xmi_id(pe.id)
+                          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Translates XMI OwnedAttribute elements into Ea::Model::Property
+      # instances. Multiplicity comes from lower_value / upper_value
+      # (LiteralInteger / LiteralUnlimitedNatural polymorphic
+      # children).
+      class PropertyBuilder
+        def build_all_for(classifier)
+          classifier.owned_attribute.map { |attr| build_one(attr, classifier) }
+        end
+
+        def build_one(attr, owner)
+          id = IdNormalizer.from_xmi_id(attr.id) ||
+               IdNormalizer.synthetic_id(owner.id, "attr", attr.name)
+          Ea::Model::Property.new(
+            id: id,
+            name: attr.name,
+            owner_id: owner.id,
+            type_name: type_name_for(attr),
+            qualified_name: "#{owner.name}::#{attr.name}",
+            multiplicity_lower: parse_lower(attr),
+            multiplicity_upper: parse_upper(attr),
+            default_value: default_value_for(attr),
+            is_derived: boolean(attr.is_derived),
+            is_readonly: boolean(attr.is_read_only),
+            is_ordered: boolean(attr.is_ordered),
+            is_unique: boolean(attr.is_unique),
+            aggregation: attr.aggregation || "none",
+            visibility: attr.visibility,
+            annotations: AnnotationBuilder.from_element(attr, id)
+          )
+        end
+
+        private
+
+        def type_name_for(attr)
+          # OwnedAttribute#type is the xmi:type discriminator
+          # (e.g. "uml:Property"); the actual data type reference is
+          # on the child <type xmi:idref=...> element, exposed via
+          # uml_type.idref.
+          attr.uml_type&.idref
+        end
+
+        def parse_lower(attr)
+          value = attr.lower_value
+          return 1 unless value
+
+          Integer(value.value) rescue 1
+        end
+
+        def parse_upper(attr)
+          value = attr.upper_value
+          return 1 unless value
+
+          raw = value.value
+          return -1 if raw.to_s == "*"
+
+          Integer(raw) rescue 1
+        end
+
+        def default_value_for(attr)
+          attr.default_value&.value
+        end
+
+        def boolean(value)
+          case value
+          when true, "true" then true
+          else false
+          end
+        end
+      end
+    end
+  end
+end