ea 0.2.5 → 0.3.1

data/lib/ea/model/point.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # 2D point in diagram pixel coordinates.
+    class Point < Base
+      attribute :x, :integer
+      attribute :y, :integer
+
+      json do
+        map "x", to: :x
+        map "y", to: :y
+      end
+    end
+  end
+end

data/lib/ea/model/polymorphic_maps.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Polymorphic dispatch maps for collections that hold subclasses
+    # of an abstract base. The discriminator field carries the
+    # concrete subclass name on every instance; lutaml-model uses
+    # this map to pick the right class on deserialize.
+    CLASSIFIER_POLYMORPHIC_MAP = {
+      attribute: "modelKind",
+      class_map: {
+        "class" => "Ea::Model::Klass",
+        "data_type" => "Ea::Model::DataType",
+        "primitive_type" => "Ea::Model::PrimitiveType",
+        "enumeration" => "Ea::Model::Enumeration",
+        "interface" => "Ea::Model::Interface"
+      }
+    }.freeze
+
+    RELATIONSHIP_POLYMORPHIC_MAP = {
+      attribute: "relationshipKind",
+      class_map: {
+        "association" => "Ea::Model::Association",
+        "generalization" => "Ea::Model::Generalization",
+        "realization" => "Ea::Model::Realization",
+        "dependency" => "Ea::Model::Dependency"
+      }
+    }.freeze
+  end
+end

data/lib/ea/model/primitive_type.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    class PrimitiveType < Classifier
+      attribute :model_kind, :string, default: -> { "primitive_type" }
+    end
+  end
+end

data/lib/ea/model/property.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A Property is a typed slot on a Classifier (attribute or
+    # navigable association end). References its type by id when
+    # possible (model-internal), falling back to `type_name` for
+    # primitives or external types.
+    class Property < Base
+      attribute :owner_id, :string              # classifier that owns it
+      attribute :type_ref, :string              # id of Classifier (nil if external)
+      attribute :type_name, :string             # name shown when type is external/primitive
+      attribute :qualified_name, :string
+      attribute :multiplicity_lower, :integer
+      attribute :multiplicity_upper, :integer   # -1 means "many"
+      attribute :default_value, :string
+      attribute :is_derived, :boolean, default: false
+      attribute :is_readonly, :boolean, default: false
+      attribute :is_ordered, :boolean, default: false
+      attribute :is_unique, :boolean, default: true
+      attribute :aggregation, :string, default: -> { "none" } # none|shared|composite
+      attribute :visibility, :string # public|protected|private|package
+      attribute :stereotype_refs, :string, collection: true, initialize_empty: true
+      attribute :tagged_values, TaggedValue, collection: true, initialize_empty: true
+      attribute :annotations, Annotation, collection: true, initialize_empty: true
+
+      json do
+        map "id", to: :id
+        map "name", to: :name
+        map "ownerId", to: :owner_id
+        map "typeRef", to: :type_ref
+        map "typeName", to: :type_name
+        map "qualifiedName", to: :qualified_name
+        map "multiplicityLower", to: :multiplicity_lower
+        map "multiplicityUpper", to: :multiplicity_upper
+        map "defaultValue", to: :default_value
+        map "isDerived", to: :is_derived, render_default: true
+        map "isReadonly", to: :is_readonly, render_default: true
+        map "isOrdered", to: :is_ordered, render_default: true
+        map "isUnique", to: :is_unique, render_default: true
+        map "aggregation", to: :aggregation, render_default: true
+        map "visibility", to: :visibility
+        map "stereotypeRefs", to: :stereotype_refs, render_empty: true
+        map "taggedValues", to: :tagged_values, render_empty: true
+        map "annotations", to: :annotations, render_empty: true
+      end
+    end
+  end
+end

data/lib/ea/model/realization.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Realization: a classifier implements the contract defined by
+    # an interface.
+    class Realization < Relationship
+      attribute :realizing_id, :string
+      attribute :contract_id, :string
+
+      attribute :relationship_kind, :string, default: -> { "realization" }
+
+      json do
+        map "realizingId", to: :realizing_id
+        map "contractId", to: :contract_id
+      end
+    end
+  end
+end

data/lib/ea/model/relationship.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Abstract base for typed relationships between classifiers.
+    # Concrete subclasses: Association, Generalization, Realization,
+    # Dependency. The discriminator (`relationship_kind`) lets
+    # consumers dispatch without `is_a?` ladders.
+    class Relationship < Base
+      attribute :qualified_name, :string
+      attribute :relationship_kind, :string, default: -> { "relationship" }
+
+      json do
+        map "id", to: :id
+        map "name", to: :name
+        map "qualifiedName", to: :qualified_name
+        map "relationshipKind", to: :relationship_kind, render_default: true
+      end
+    end
+  end
+end

data/lib/ea/model/stereotype.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A Stereotype declaration. Stereotypes carry a name, optional
+    # profile, and may declare a schema of tagged-value keys.
+    #
+    # A classifier/property/operation "has" a stereotype by
+    # reference (stereotype_ref on the element or its tagged values).
+    class Stereotype < Base
+      attribute :qualified_name, :string
+      attribute :profile, :string
+      attribute :declared_tagged_value_keys, :string, collection: true,
+                                                      initialize_empty: true
+
+      json do
+        map "qualifiedName", to: :qualified_name
+        map "profile", to: :profile
+        map "declaredTaggedValueKeys", to: :declared_tagged_value_keys,
+                                       render_empty: true
+      end
+    end
+  end
+end

data/lib/ea/model/tagged_value.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A tagged value: key/value metadata attached to a model element.
+    # Optionally scoped to a Stereotype application via
+    # `stereotype_ref`.
+    class TaggedValue < Base
+      attribute :key, :string
+      attribute :value, :string
+      attribute :stereotype_ref, :string
+
+      json do
+        map "key", to: :key
+        map "value", to: :value
+        map "stereotypeRef", to: :stereotype_ref
+      end
+    end
+  end
+end

data/lib/ea/model/waypoint.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A single waypoint on a DiagramConnector's path. Connectors
+    # route between source and target diagram elements through zero
+    # or more waypoints; the source adapter parses the EA `SeqNo`
+    # packed list into ordered Waypoints.
+    class Waypoint < Base
+      attribute :position, Point
+      attribute :routing, :string, default: -> { "line" }
+
+      json do
+        map "position", to: :position
+        map "routing", to: :routing
+      end
+    end
+  end
+end

data/lib/ea/model.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ea
+  # Ea::Model is the canonical domain model for what Sparx Enterprise
+  # Architect models.
+  #
+  # It is intentionally independent of any source format. QEA and XMI
+  # are translated into Ea::Model by source adapters
+  # (Ea::Sources::Qea, Ea::Sources::Xmi). Consumers (Ea::Spa, future
+  # exporters, validators, differs) project from Ea::Model — they do
+  # not redefine the modeling types.
+  #
+  # Architectural principle: Hexagonal / Ports & Adapters. Ea::Model
+  # is the hexagon. Source adapters are driving ports; consumer
+  # adapters are driven ports. Dependencies point inward only.
+  module Model
+    autoload :Base, "ea/model/base"
+    autoload :Metadata, "ea/model/metadata"
+    autoload :Point, "ea/model/point"
+    autoload :Bounds, "ea/model/bounds"
+    autoload :Waypoint, "ea/model/waypoint"
+    autoload :Annotation, "ea/model/annotation"
+    autoload :TaggedValue, "ea/model/tagged_value"
+    autoload :Stereotype, "ea/model/stereotype"
+    autoload :EnumerationLiteral, "ea/model/enumeration_literal"
+    autoload :Parameter, "ea/model/parameter"
+    autoload :Property, "ea/model/property"
+    autoload :Operation, "ea/model/operation"
+    autoload :Classifier, "ea/model/classifier"
+    autoload :Klass, "ea/model/klass"
+    autoload :DataType, "ea/model/data_type"
+    autoload :PrimitiveType, "ea/model/primitive_type"
+    autoload :Interface, "ea/model/interface"
+    autoload :Enumeration, "ea/model/enumeration"
+    autoload :Package, "ea/model/package"
+    autoload :Relationship, "ea/model/relationship"
+    autoload :Association, "ea/model/association"
+    autoload :Generalization, "ea/model/generalization"
+    autoload :Realization, "ea/model/realization"
+    autoload :Dependency, "ea/model/dependency"
+    autoload :DiagramElement, "ea/model/diagram_element"
+    autoload :DiagramConnector, "ea/model/diagram_connector"
+    autoload :Diagram, "ea/model/diagram"
+    autoload :Document, "ea/model/document"
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Driving port: produces an Ea::Model::Document from a parsed
+      # Ea::Qea::Database. Walks the SQLite-derived collections once
+      # and delegates to per-domain builders (OCP/MECE — new model
+      # types or source columns touch one builder).
+      class Adapter
+        attr_reader :database, :qea_path
+
+        def initialize(database, qea_path = nil)
+          @database = database
+          @qea_path = qea_path
+        end
+
+        # Convenience: build a document directly from a .qea file
+        # path. The file is parsed via the existing Ea::Qea pipeline.
+        def self.from_path(qea_path)
+          new(Ea.parse(qea_path), qea_path).to_document
+        end
+
+        def to_document
+          Ea::Model::Document.new(
+            metadata: metadata,
+            packages: packages,
+            classifiers: classifiers,
+            relationships: relationships,
+            stereotypes: stereotypes,
+            diagrams: diagrams
+          )
+        end
+
+        private
+
+        def metadata
+          @metadata ||= MetadataBuilder.new(database, qea_path).build
+        end
+
+        def packages
+          @packages ||= PackageBuilder.new(database).build_all
+        end
+
+        def classifiers
+          @classifiers ||= ClassifierBuilder.new(database).build_all
+        end
+
+        def relationships
+          @relationships ||= RelationshipBuilder.new(database).build_all
+        end
+
+        def stereotypes
+          @stereotypes ||= StereotypeBuilder.new(database).build_all
+        end
+
+        def diagrams
+          @diagrams ||= DiagramBuilder.new(database).build_all
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Builds Ea::Model::Annotation instances from EA Note text and
+      # t_document rows. EA stores most documentation as a Note
+      # field directly on the element (t_object.Note, t_package.notes,
+      # t_connector.notes, t_attribute.notes, etc.); we lift each
+      # non-empty note into a typed Annotation.
+      class AnnotationBuilder
+        attr_reader :owner_guid
+
+        def initialize(owner_guid)
+          @owner_guid = owner_guid
+        end
+
+        def self.from_note(note_text, owner_guid, kind: "documentation")
+          return [] if note_text.nil? || note_text.empty?
+
+          [new(owner_guid).build(kind, note_text)]
+        end
+
+        def build(kind, body, author: nil, modified_date: nil)
+          Ea::Model::Annotation.new(
+            id: IdNormalizer.synthetic("annotation", owner_guid, kind),
+            kind: kind,
+            body: body,
+            author: author,
+            modified_date: modified_date
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Translates EA t_object rows (filtered to classifier types)
+      # into the appropriate Ea::Model::Classifier subclass. Uses
+      # ObjectClassifierMap for dispatch (OCP — new classifier
+      # kinds need no edit here).
+      class ClassifierBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all
+          classifiers = []
+          each_classifier_object do |object|
+            classifiers << build_one(object)
+          end
+          classifiers
+        end
+
+        def build_one(object)
+          klass = ObjectClassifierMap.class_for(object.object_type)
+          args = common_args(object)
+          args.merge!(enumeration_args(object)) if klass == Ea::Model::Enumeration
+          klass.new(**args)
+        end
+
+        private
+
+        def each_classifier_object
+          objects = database.collections[:objects] || []
+          objects.each do |obj|
+            next unless classifier_type?(obj.object_type)
+
+            yield obj
+          end
+        end
+
+        def classifier_type?(object_type)
+          ObjectClassifierMap::LOOKUP.key?(object_type)
+        end
+
+        def common_args(object)
+          {
+            id: IdNormalizer.from_guid(object.ea_guid),
+            name: object.name,
+            package_id: package_id_for(object),
+            qualified_name: qualified_name_for(object),
+            is_abstract: abstract?(object),
+            visibility: visibility_from_scope(object.scope),
+            properties: PropertyBuilder.new(database).build_all_for(object),
+            operations: OperationBuilder.new(database).build_all_for(object),
+            stereotype_refs: stereotype_refs_for(object),
+            tagged_values: TaggedValueBuilder.new(database).for_object(object.ea_guid),
+            annotations: AnnotationBuilder.from_note(object.note, object.ea_guid,
+                                                     kind: "documentation")
+          }
+        end
+
+        def enumeration_args(object)
+          literals = enumeration_literals_for(object)
+          { literals: literals }
+        end
+
+        def enumeration_literals_for(object)
+          # EA stores enum literals as attributes with no type, or as
+          # child t_object rows tagged as Literal. We pick them up
+          # from attributes where type is empty/nil and treat the
+          # attribute name as the literal value.
+          attrs = database.attributes_for_object(object.ea_object_id) || []
+          attrs.map.with_index do |attr, idx|
+            Ea::Model::EnumerationLiteral.new(
+              id: IdNormalizer.from_guid(attr.ea_guid),
+              name: attr.name,
+              value: attr.default || attr.name,
+              ordinal: idx
+            )
+          end
+        end
+
+        def package_id_for(object)
+          pkg = database.find_package(object.package_id)
+          return nil unless pkg
+
+          IdNormalizer.from_guid(pkg.ea_guid)
+        end
+
+        def qualified_name_for(object)
+          pkg = database.find_package(object.package_id)
+          pkg_prefix = pkg&.xmlpath || pkg&.name
+          pkg_prefix ? "#{pkg_prefix}::#{object.name}" : object.name
+        end
+
+        def abstract?(object)
+          %w[1 true].include?(object.abstract.to_s)
+        end
+
+        def visibility_from_scope(scope)
+          case scope.to_s
+          when "Public" then "public"
+          when "Protected" then "protected"
+          when "Private" then "private"
+          else "public"
+          end
+        end
+
+        def stereotype_refs_for(object)
+          refs = []
+          refs << object.stereotype if object.stereotype && !object.stereotype.empty?
+          refs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Maps EA's `t_connector.Connector_Type` discriminator to the
+      # concrete Ea::Model::Relationship subclass. Adds new
+      # relationship kinds by registering here (OCP).
+      module ConnectorRelationshipMap
+        module_function
+
+        LOOKUP = {
+          "Association" => "Ea::Model::Association",
+          "Aggregation" => "Ea::Model::Association",
+          "Composition" => "Ea::Model::Association",
+          "Generalization" => "Ea::Model::Generalization",
+          "Realization" => "Ea::Model::Realization",
+          "Usage" => "Ea::Model::Dependency",
+          "Dependency" => "Ea::Model::Dependency",
+          "Abstraction" => "Ea::Model::Dependency"
+        }.freeze
+
+        # Some connector types imply specific aggregation values on
+        # the source end (EA stores them as separate Connector_Type
+        # values rather than as an attribute on the connector).
+        AGGREGATION_FOR = {
+          "Aggregation" => "shared",
+          "Composition" => "composite"
+        }.freeze
+
+        def class_for(connector_type)
+          name = LOOKUP[connector_type] || "Ea::Model::Association"
+          Object.const_get(name)
+        end
+
+        def source_aggregation_for(connector_type)
+          AGGREGATION_FOR[connector_type] || "none"
+        end
+      end
+    end
+  end
+end