ea 0.2.5 → 0.3.1

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

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Qea
+      # Translates EA t_diagram + t_diagramlinks + t_diagramobjects
+      # into Ea::Model::Diagram with placed DiagramElements and
+      # DiagramConnectors (including pixel coordinates and parsed
+      # styles).
+      class DiagramBuilder
+        attr_reader :database
+
+        def initialize(database)
+          @database = database
+        end
+
+        def build_all
+          diagrams = database.collections[:diagrams] || []
+          diagrams.map { |row| build_one(row) }
+        end
+
+        def build_one(diagram_row)
+          Ea::Model::Diagram.new(
+            id: IdNormalizer.from_guid(diagram_row.ea_guid),
+            name: diagram_row.name,
+            package_id: package_id_for(diagram_row),
+            diagram_type: diagram_row.diagram_type,
+            bounds: bounds_for(diagram_row),
+            elements: build_elements(diagram_row),
+            connectors: build_connectors(diagram_row),
+            annotations: AnnotationBuilder.from_note(diagram_row.notes,
+                                                     diagram_row.ea_guid,
+                                                     kind: "documentation")
+          )
+        end
+
+        private
+
+        def build_elements(diagram_row)
+          objs = database.diagram_objects_for(diagram_row.diagram_id) || []
+          objs.map { |obj_row| build_element(obj_row, diagram_row) }
+        end
+
+        def build_element(obj_row, diagram_row)
+          Ea::Model::DiagramElement.new(
+            id: IdNormalizer.synthetic("de", diagram_row.diagram_id,
+                                       obj_row.instance_id),
+            diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
+            model_element_ref: ref_for_object(obj_row),
+            bounds: bounds_from_rect(obj_row),
+            style: DiagramStyleParser.parse(obj_row.objectstyle)
+          )
+        end
+
+        def build_connectors(diagram_row)
+          links = database.diagram_links_for(diagram_row.diagram_id) || []
+          links.map { |link_row| build_connector(link_row, diagram_row) }
+        end
+
+        def build_connector(link_row, diagram_row)
+          Ea::Model::DiagramConnector.new(
+            id: IdNormalizer.synthetic("dc", diagram_row.diagram_id,
+                                       link_row.instance_id),
+            diagram_id: IdNormalizer.from_guid(diagram_row.ea_guid),
+            relationship_ref: ref_for_connector(link_row),
+            waypoints: waypoints_for_link(link_row, diagram_row),
+            style: DiagramStyleParser.parse(link_row.style)
+          )
+        end
+
+        # EA's t_diagramlinks.Geometry field stores connector routing
+        # in a packed format. The leading "X1,Y1,X2,Y2" pair (when
+        # present) is in a coordinate frame that does NOT match the
+        # element rect frame (elements use RectTop < RectBottom with
+        # negative y; geometry uses positive y). Rather than trust
+        # the stored absolute coords, we compute the polyline from
+        # the actual placed-element bounds + the SX/SY/EX/EY delta
+        # fields, which describe the bend routing relative to the
+        # element edges.
+        #
+        # If we can't resolve the source or target element placement
+        # for this diagram, we emit no waypoints (the connector will
+        # be invisible) — better than drawing garbage lines.
+        def waypoints_for_link(link_row, diagram_row)
+          connector = database.find_connector(link_row.connectorid)
+          return [] unless connector
+
+          source_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       connector.start_object_id)
+          target_placement = diagram_object_placement(diagram_row.diagram_id,
+                                                       connector.end_object_id)
+          return [] unless source_placement && target_placement
+
+          geom = parse_geometry_fields(link_row.geometry)
+          edge_out = geom[:edge] || 0
+
+          source_point = element_edge_point(source_placement, :source, edge_out)
+          target_point = element_edge_point(target_placement, :target, edge_out)
+          points = [source_point]
+          # SX/SY: delta from source point to first bend.
+          if geom[:sx] && geom[:sy] && (geom[:sx].nonzero? || geom[:sy].nonzero?)
+            points << [source_point[0] + geom[:sx], source_point[1] + geom[:sy]]
+          end
+          # EX/EY: delta from second bend to target point. Reverse
+          # to get from target back to the bend.
+          if geom[:ex] && geom[:ey] && (geom[:ex].nonzero? || geom[:ey].nonzero?)
+            points << [target_point[0] - geom[:ex], target_point[1] - geom[:ey]]
+          end
+          points << target_point
+
+          points.map do |x, y|
+            Ea::Model::Waypoint.new(position: Ea::Model::Point.new(x: x, y: y))
+          end
+        end
+
+        # Parse the SX, SY, EX, EY, EDGE key=value pairs out of the
+        # geometry string. Each is `KEY=<int>;`. We deliberately do
+        # NOT extract the leading X1,Y1,X2,Y2 numbers because those
+        # are in a different coordinate frame (see note above).
+        def parse_geometry_fields(geometry)
+          return {} if geometry.nil? || geometry.empty?
+
+          s = geometry.to_s
+          {
+            sx: pick_int(s, /SX=(-?\d+)/),
+            sy: pick_int(s, /SY=(-?\d+)/),
+            ex: pick_int(s, /EX=(-?\d+)/),
+            ey: pick_int(s, /EY=(-?\d+)/),
+            edge: pick_int(s, /EDGE=(-?\d+)/)
+          }
+        end
+
+        def pick_int(str, pattern)
+          match = str.match(pattern)
+          return nil unless match
+
+          Integer(match[1])
+        rescue ArgumentError
+          nil
+        end
+
+        # Find where a given EA object is placed on this diagram.
+        def diagram_object_placement(diagram_id, ea_object_id)
+          objects = database.diagram_objects_for(diagram_id) || []
+          objects.find { |o| o.ea_object_id == ea_object_id }
+        end
+
+        # Compute the connection point on an element's edge for the
+        # given side. EA's `EDGE` field on t_diagramlinks tells us
+        # which edge the connector attaches to:
+        #   1 = top (source), 2 = right, 3 = bottom, 4 = left,
+        #   plus 5/6/7/8 for diagonals (treated as the cardinal here).
+        # We use the center of the chosen edge as the connection point.
+        def element_edge_point(placement, end_kind, edge_code)
+          b = bounds_from_rect(placement)
+          case effective_edge(edge_code, end_kind)
+          when :top    then [b.x + b.width / 2, b.y]
+          when :right  then [b.x + b.width, b.y + b.height / 2]
+          when :bottom then [b.x + b.width / 2, b.y + b.height]
+          when :left   then [b.x, b.y + b.height / 2]
+          else              [b.x + b.width / 2, b.y + b.height / 2]
+          end
+        end
+
+        def effective_edge(edge_code, end_kind)
+          mapping = {
+            1 => :top, 2 => :right, 3 => :bottom, 4 => :left,
+            5 => :top, 6 => :right, 7 => :bottom, 8 => :left
+          }
+          mapping[edge_code.to_i] || :center
+        end
+
+        def package_id_for(diagram_row)
+          pkg = database.find_package(diagram_row.package_id)
+          return nil unless pkg
+
+          IdNormalizer.from_guid(pkg.ea_guid)
+        end
+
+        def bounds_for(diagram_row)
+          Ea::Model::Bounds.new(
+            x: 0,
+            y: 0,
+            width: diagram_row.cx || 0,
+            height: diagram_row.cy || 0
+          )
+        end
+
+        def bounds_from_rect(obj_row)
+          Ea::Model::Bounds.new(
+            x: obj_row.rectleft || 0,
+            y: obj_row.recttop || 0,
+            width: (obj_row.rectright || 0) - (obj_row.rectleft || 0),
+            height: (obj_row.rectbottom || 0) - (obj_row.recttop || 0)
+          )
+        end
+
+        def ref_for_object(obj_row)
+          obj = database.find_object(obj_row.ea_object_id)
+          return nil unless obj
+
+          IdNormalizer.from_guid(obj.ea_guid)
+        end
+
+        def ref_for_connector(link_row)
+          conn = database.find_connector(link_row.connectorid)
+          return nil unless conn
+
+          IdNormalizer.from_guid(conn.ea_guid)
+        end
+      end
+    end
+  end
+end

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