ea 0.2.5 → 0.3.0

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

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Translates XMI relationship elements (uml:Association,
+      # uml:Generalization, uml:Realization, uml:Dependency) into
+      # the appropriate Ea::Model::Relationship subclass.
+      class RelationshipBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def build_all
+          relationships = []
+          walk(root.model) do |element|
+            next unless RelationshipTypeMap.relationship_type?(element.type)
+
+            rel = build_one(element)
+            relationships << rel if rel
+          end
+          relationships
+        end
+
+        def build_one(element)
+          klass = RelationshipTypeMap.class_for(element.type)
+          args = common_args(element)
+          args.merge!(specific_args_for(klass, element))
+          klass.new(**args)
+        end
+
+        private
+
+        def walk(element, &block)
+          yield element if block
+          element.packaged_element.each { |inner| walk(inner, &block) }
+        end
+
+        def common_args(element)
+          id = IdNormalizer.from_xmi_id(element.id)
+          {
+            id: id,
+            name: element.name || element.type&.split(":")&.last&.downcase,
+            qualified_name: element.name,
+            annotations: AnnotationBuilder.from_element(element, id)
+          }
+        end
+
+        def specific_args_for(klass, element)
+          case klass.name
+          when "Ea::Model::Association" then association_args(element)
+          when "Ea::Model::Generalization" then generalization_args(element)
+          when "Ea::Model::Realization" then realization_args(element)
+          when "Ea::Model::Dependency" then dependency_args(element)
+          else {}
+          end
+        end
+
+        def association_args(element)
+          ends = element.member_ends.to_a
+          source_id = ends.first&.idref
+          target_id = ends.last&.idref
+          owned_ends = element.owned_end.to_a
+          source_end = owned_ends.first
+          target_end = owned_ends.last
+          {
+            source_id: source_id,
+            target_id: target_id,
+            source_role_name: source_end&.name,
+            target_role_name: target_end&.name,
+            source_multiplicity_lower: parse_lower(source_end),
+            source_multiplicity_upper: parse_upper(source_end),
+            target_multiplicity_lower: parse_lower(target_end),
+            target_multiplicity_upper: parse_upper(target_end),
+            source_aggregation: source_end&.aggregation || "none",
+            target_aggregation: target_end&.aggregation || "none",
+            source_navigable: navigable?(source_end),
+            target_navigable: navigable?(target_end)
+          }
+        end
+
+        def generalization_args(element)
+          # PackagedElement#generalization is a collection of
+          # AssociationGeneralization rows. The "specific" (child)
+          # is the owning element; "general" (parent) is the
+          # referenced id on each generalization row.
+          gen = element.generalization.first
+          {
+            specific_id: IdNormalizer.from_xmi_id(element.id),
+            general_id: gen&.general
+          }
+        end
+
+        def realization_args(element)
+          {
+            realizing_id: element.client,
+            contract_id: element.supplier
+          }
+        end
+
+        def dependency_args(element)
+          {
+            client_id: element.client,
+            supplier_id: element.supplier
+          }
+        end
+
+        def parse_lower(end_element)
+          return 1 unless end_element
+
+          value = end_element.lower_value
+          return 1 unless value
+
+          Integer(value.value) rescue 1
+        end
+
+        def parse_upper(end_element)
+          return 1 unless end_element
+
+          value = end_element.upper_value
+          return 1 unless value
+
+          raw = value.value
+          return -1 if raw.to_s == "*"
+
+          Integer(raw) rescue 1
+        end
+
+        def navigable?(end_element)
+          return true unless end_element
+
+          # XMI represents non-navigable ends with aggregation=none
+          # and no role name; treat presence of role name or any
+          # aggregation as navigable. Default: navigable.
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Maps XMI's `xmi:type` discriminator for relationship-shaped
+      # packaged elements (uml:Association, uml:Generalization,
+      # etc.) to the concrete Ea::Model::Relationship subclass.
+      module RelationshipTypeMap
+        module_function
+
+        LOOKUP = {
+          "uml:Association" => "Ea::Model::Association",
+          "uml:Generalization" => "Ea::Model::Generalization",
+          "uml:Realization" => "Ea::Model::Realization",
+          "uml:Dependency" => "Ea::Model::Dependency",
+          "uml:Usage" => "Ea::Model::Dependency",
+          "uml:Abstraction" => "Ea::Model::Dependency",
+        }.freeze
+
+        def class_for(xmi_type)
+          name = LOOKUP[xmi_type]
+          return nil unless name
+
+          Object.const_get(name)
+        end
+
+        def relationship_type?(xmi_type)
+          LOOKUP.key?(xmi_type)
+        end
+      end
+    end
+  end
+end