ea 0.2.4 → 0.3.0

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Parses EA's packed `objectstyle` / `style` / `styleex`
+      # strings into a Hash with typed keys. EA packs visual style
+      # as `DUID=...;BCol=...;FCol=...;` etc. — semicolon-separated
+      # key=value pairs with non-standard escaping.
+      module DiagramStyleParser
+        module_function
+
+        def parse(style_string)
+          return {} if style_string.nil? || style_string.empty?
+
+          style_string.to_s
+                      .split(";")
+                      .filter_map { |pair| parse_pair(pair) }
+                      .to_h
+        end
+
+        def parse_pair(pair)
+          return nil unless pair.include?("=")
+
+          key, value = pair.split("=", 2)
+          return nil if key.nil? || key.empty?
+
+          [normalize_key(key), normalize_value(value)]
+        end
+
+        def normalize_key(key)
+          key.strip.downcase.to_sym
+        end
+
+        def normalize_value(value)
+          return "" if value.nil?
+
+          value.strip
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Normalizes EA's identifier formats into stable strings used
+      # as Ea::Model element ids. EA represents identity as
+      # `{GUID}` strings. We strip the braces to give the bare GUID.
+      module IdNormalizer
+        module_function
+
+        def from_guid(ea_guid)
+          return nil if ea_guid.nil? || ea_guid.empty?
+
+          ea_guid.to_s.gsub(/[{}]/, "")
+        end
+
+        def synthetic(prefix, *parts)
+          "#{prefix}:#{parts.join(":")}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Builds an Ea::Model::Metadata from the QEA database. Pulls
+      # project-level info (model name, version, tool, source path)
+      # from the root package and the QEA file path.
+      class MetadataBuilder
+        attr_reader :database, :qea_path
+
+        def initialize(database, qea_path)
+          @database = database
+          @qea_path = qea_path
+        end
+
+        def build
+          root_pkg = root_package
+          Ea::Model::Metadata.new(
+            id: "metadata",
+            title: root_pkg&.name,
+            version: root_pkg&.version,
+            created_date: root_pkg&.createddate,
+            modified_date: root_pkg&.modifieddate,
+            author: root_pkg&.pkgowner,
+            source_format: "qea",
+            source_tool: "Sparx Enterprise Architect",
+            source_path: qea_path
+          )
+        end
+
+        private
+
+        def root_package
+          @root_package ||= database.collections[:packages]&.find do |pkg|
+            pkg.parent_id.nil? || pkg.parent_id.zero?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Maps EA's `t_object.Object_Type` discriminator to the
+      # concrete Ea::Model::Classifier subclass that should be
+      # produced. New classifier kinds = one entry here, nothing
+      # else changes (OCP).
+      module ObjectClassifierMap
+        module_function
+
+        # EA Object_Type → Model class. Unknown types default to
+        # Klass — the most generic classifier.
+        LOOKUP = {
+          "Class" => "Ea::Model::Klass",
+          "DataType" => "Ea::Model::DataType",
+          "Enumeration" => "Ea::Model::Enumeration",
+          "Interface" => "Ea::Model::Interface",
+          "PrimitiveType" => "Ea::Model::PrimitiveType",
+          "Primitive" => "Ea::Model::PrimitiveType"
+        }.freeze
+
+        def class_for(object_type)
+          name = LOOKUP[object_type] || "Ea::Model::Klass"
+          Object.const_get(name)
+        end
+
+        def model_kind_for(object_type)
+          cls = class_for(object_type)
+          cls.new.model_kind
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Translates EA t_operation + t_operationparams rows into
+      # Ea::Model::Operation instances with owned Parameters.
+      class OperationBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all_for(owner_object)
+          ops = database.operations_for_object(owner_object.ea_object_id) || []
+          ops.map { |row| build_one(row, owner_object) }
+        end
+
+        def build_one(row, owner_object)
+          Ea::Model::Operation.new(
+            id: IdNormalizer.from_guid(row.ea_guid),
+            name: row.name,
+            owner_id: IdNormalizer.from_guid(owner_object.ea_guid),
+            qualified_name: "#{owner_object.name}::#{row.name}",
+            return_type_name: row.type,
+            visibility: visibility_from_scope(row.scope),
+            is_static: boolean(row.isstatic),
+            is_abstract: boolean(row.abstract),
+            parameters: build_parameters(row),
+            annotations: AnnotationBuilder.from_note(row.notes, row.ea_guid,
+                                                     kind: "documentation")
+          )
+        end
+
+        private
+
+        def build_parameters(operation_row)
+          params = database.operation_params_for(operation_row.operationid) || []
+          params.map.with_index do |p, idx|
+            Ea::Model::Parameter.new(
+              id: IdNormalizer.from_guid(p.ea_guid),
+              name: p.name,
+              ordinal: p.pos || idx,
+              direction: direction_from_kind(p.kind),
+              type_name: p.type,
+              default_value: p.default
+            )
+          end
+        end
+
+        def direction_from_kind(kind)
+          case kind.to_s
+          when "1", "out" then "out"
+          when "2", "inout" then "inout"
+          when "3", "return" then "return"
+          else "in"
+          end
+        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 boolean(value)
+          case value.to_s
+          when "1", "true", "TRUE" then true
+          else false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Translates EA t_package rows into Ea::Model::Package
+      # instances. References to parent and child packages are by
+      # model id (normalized GUID), not by EA's integer Package_ID.
+      class PackageBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all
+          packages = database.collections[:packages] || []
+          packages.map { |pkg| build_one(pkg) }
+        end
+
+        def build_one(pkg)
+          Ea::Model::Package.new(
+            id: IdNormalizer.from_guid(pkg.ea_guid),
+            name: pkg.name,
+            parent_id: parent_id_for(pkg),
+            qualified_name: pkg.xmlpath,
+            annotations: AnnotationBuilder.from_note(pkg.notes, pkg.ea_guid)
+          )
+        end
+
+        private
+
+        def parent_id_for(pkg)
+          return nil if pkg.parent_id.nil? || pkg.parent_id.zero?
+
+          parent = database.find_package(pkg.parent_id)
+          return nil unless parent
+
+          IdNormalizer.from_guid(parent.ea_guid)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Translates EA t_attribute rows into Ea::Model::Property
+      # instances. Multiplicity is parsed from EA's `LowerBound` /
+      # `UpperBound` columns (with `*` represented as -1 in the
+      # model).
+      class PropertyBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all_for(owner_object)
+          attrs = database.attributes_for_object(owner_object.ea_object_id) || []
+          attrs.map { |row| build_one(row, owner_object) }
+        end
+
+        def build_one(row, owner_object)
+          Ea::Model::Property.new(
+            id: IdNormalizer.from_guid(row.ea_guid),
+            name: row.name,
+            owner_id: IdNormalizer.from_guid(owner_object.ea_guid),
+            type_name: row.type,
+            qualified_name: "#{owner_object.name}::#{row.name}",
+            multiplicity_lower: parse_lower(row),
+            multiplicity_upper: parse_upper(row),
+            default_value: row.default,
+            is_ordered: boolean(row.isordered),
+            is_unique: !boolean(row.allowduplicates),
+            visibility: visibility_from_scope(row.scope),
+            aggregation: "none",
+            stereotype_refs: stereotype_refs(row),
+            tagged_values: TaggedValueBuilder.new(database).for_attribute(row),
+            annotations: AnnotationBuilder.from_note(row.notes, row.ea_guid,
+                                                     kind: "documentation")
+          )
+        end
+
+        private
+
+        def parse_lower(row)
+          Integer(row.lowerbound || 1)
+        rescue StandardError
+          1
+        end
+
+        def parse_upper(row)
+          return -1 if row.upperbound.to_s == "*"
+
+          begin
+            Integer(row.upperbound || 1)
+          rescue StandardError
+            1
+          end
+        end
+
+        def boolean(value)
+          case value.to_s
+          when "1", "true", "TRUE" then true
+          else false
+          end
+        end
+
+        def visibility_from_scope(scope)
+          case scope.to_s
+          when "Public" then "public"
+          when "Protected" then "protected"
+          when "Private" then "private"
+          when "Package" then "package"
+          else "public"
+          end
+        end
+
+        def stereotype_refs(row)
+          refs = []
+          refs << row.stereotype if row.stereotype && !row.stereotype.empty?
+          refs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Translates EA t_connector rows into the appropriate
+      # Ea::Model::Relationship subclass. Dispatches on
+      # `Connector_Type` via ConnectorRelationshipMap.
+      class RelationshipBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all
+          connectors = database.collections[:connectors] || []
+          connectors.filter_map { |row| build_one(row) }
+        end
+
+        def build_one(row)
+          klass = ConnectorRelationshipMap.class_for(row.connector_type)
+          args = common_args(row)
+          args.merge!(association_args(row)) if klass == Ea::Model::Association
+          klass.new(**args)
+        end
+
+        private
+
+        def common_args(row)
+          {
+            id: IdNormalizer.from_guid(row.ea_guid),
+            name: row.name,
+            qualified_name: row.name,
+            annotations: AnnotationBuilder.from_note(row.notes, row.ea_guid,
+                                                     kind: "documentation")
+          }
+        end
+
+        def association_args(row)
+          {
+            source_id: id_for_object_id(row.start_object_id),
+            target_id: id_for_object_id(row.end_object_id),
+            source_role_name: row.sourcerole,
+            target_role_name: row.destrole,
+            source_multiplicity_lower: parse_lower(row.sourcecard),
+            source_multiplicity_upper: parse_upper(row.sourcecard),
+            target_multiplicity_lower: parse_lower(row.destcard),
+            target_multiplicity_upper: parse_upper(row.destcard),
+            source_aggregation: ConnectorRelationshipMap
+                                .source_aggregation_for(row.connector_type),
+            target_aggregation: aggregation_from(row.destaccess),
+            source_navigable: navigable?(row.sourceaccess, row.direction,
+                                         :source),
+            target_navigable: navigable?(row.destaccess, row.direction, :target)
+          }
+        end
+
+        def id_for_object_id(ea_object_id)
+          obj = database.find_object(ea_object_id)
+          return nil unless obj
+
+          IdNormalizer.from_guid(obj.ea_guid)
+        end
+
+        def parse_lower(cardinality)
+          return 1 if cardinality.nil? || cardinality.empty?
+
+          # EA format: "1", "0..*", "1..1", etc. Take the first number.
+          begin
+            Integer(cardinality.split("..").first)
+          rescue StandardError
+            1
+          end
+        end
+
+        def parse_upper(cardinality)
+          return 1 if cardinality.nil? || cardinality.empty?
+
+          upper = cardinality.split("..").last
+          return -1 if upper == "*"
+
+          begin
+            Integer(upper)
+          rescue StandardError
+            1
+          end
+        end
+
+        def aggregation_from(access_value)
+          case access_value.to_s
+          when "0" then "none"
+          when "1" then "shared"
+          when "2" then "composite"
+          else "none"
+          end
+        end
+
+        def navigable?(_access, direction, end_label)
+          # EA's navigability is messy. Treat unspecified direction
+          # as bidirectional, "Source -> Destination" as target-only
+          # navigable, etc. Conservative default: both ends navigable.
+          case direction.to_s
+          when "<->", "" then true
+          when "->" then end_label == :target
+          when "<-" then end_label == :source
+          else true
+          end
+        end
+      end
+    end
+  end
+end

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