ea 0.2.5 → 0.3.1

data/lib/ea/cli/command/svg.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Ea
+  module Cli
+    module Command
+      # `ea svg NAME FILE [--output=PATH]`
+      #
+      # Renders a single diagram from a QEA or XMI file into a
+      # standalone SVG using the umldi content (placed element
+      # bounds + connector waypoints) captured in Ea::Model::Diagram.
+      class Svg < Base
+        def call
+          diagram = find_diagram
+          svg = Ea::Svg::Renderer.new(diagram,
+                                       model_index: document.index_by_id).render
+
+          output_path = resolve_output_path(diagram)
+          FileUtils.mkdir_p(File.dirname(output_path))
+          File.write(output_path, svg)
+
+          formatter.render([[output_path]], columns: [:written_to])
+        end
+
+        private
+
+        def document
+          @document ||= build_model_document
+        end
+
+        def build_model_document
+          case File.extname(file_path).downcase
+          when ".qea"
+            Ea::Sources::Qea::Adapter.from_path(file_path)
+          when ".xmi"
+            Ea::Sources::Xmi::Adapter.from_path(file_path)
+          else
+            raise Ea::Cli::UnsupportedFormat,
+                  "Unknown file format: #{File.extname(file_path)}"
+          end
+        end
+
+        def diagram_name
+          options[:name] or raise Ea::Cli::Error, "missing required diagram name"
+        end
+
+        def find_diagram
+          match = document.diagrams.find { |d| d.name == diagram_name }
+          return match if match
+
+          raise Ea::Cli::Error,
+                "Diagram #{diagram_name.inspect} not found in #{file_path}. " \
+                "Use `ea diagrams list #{file_path}` to see names."
+        end
+
+        def resolve_output_path(diagram)
+          options[:output] || begin
+            base = File.basename(file_path, ".*")
+            dir = File.dirname(file_path)
+            safe_name = (diagram.name || "diagram").gsub(/[^\w.\-]+/, "_")
+            File.join(dir, "#{base}.#{safe_name}.svg")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli/command.rb

@@ -11,6 +11,7 @@ module Ea
       autoload :Parse, "ea/cli/command/parse"
       autoload :Convert, "ea/cli/command/convert"
       autoload :Spa, "ea/cli/command/spa"
+      autoload :Svg, "ea/cli/command/svg"
       autoload :RepositoryBuilder, "ea/cli/command/repository_builder"
     end
   end

data/lib/ea/model/annotation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # First-class annotation: comments, documentation, change notes,
+    # requirements, file references — the textual meta-content EA
+    # authors attach to model elements.
+    #
+    # Modeled as a typed concept rather than a packed string, so the
+    # SPA can show different annotation kinds with appropriate
+    # presentation (e.g. documentation gets rendered as markdown,
+    # change history goes in a sidebar).
+    class Annotation < Base
+      attribute :kind, :string # comment|documentation|change|file|requirement
+      attribute :body, :string
+      attribute :author, :string
+      attribute :modified_date, :string
+      attribute :language, :string
+
+      json do
+        map "kind", to: :kind
+        map "body", to: :body
+        map "author", to: :author
+        map "modifiedDate", to: :modified_date
+        map "language", to: :language
+      end
+    end
+  end
+end

data/lib/ea/model/association.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # An Association between two classifiers. Each end carries its
+    # own role name, multiplicity, aggregation kind, and
+    # navigability. Source and target are referenced by id.
+    class Association < Relationship
+      attribute :source_id, :string
+      attribute :target_id, :string
+      attribute :source_role_name, :string
+      attribute :target_role_name, :string
+      attribute :source_multiplicity_lower, :integer
+      attribute :source_multiplicity_upper, :integer
+      attribute :target_multiplicity_lower, :integer
+      attribute :target_multiplicity_upper, :integer
+      attribute :source_aggregation, :string, default: -> { "none" }
+      attribute :target_aggregation, :string, default: -> { "none" }
+      attribute :source_navigable, :boolean, default: true
+      attribute :target_navigable, :boolean, default: true
+
+      attribute :relationship_kind, :string, default: -> { "association" }
+
+      json do
+        map "sourceId", to: :source_id
+        map "targetId", to: :target_id
+        map "sourceRoleName", to: :source_role_name
+        map "targetRoleName", to: :target_role_name
+        map "sourceMultiplicityLower", to: :source_multiplicity_lower
+        map "sourceMultiplicityUpper", to: :source_multiplicity_upper
+        map "targetMultiplicityLower", to: :target_multiplicity_lower
+        map "targetMultiplicityUpper", to: :target_multiplicity_upper
+        map "sourceAggregation", to: :source_aggregation, render_default: true
+        map "targetAggregation", to: :target_aggregation, render_default: true
+        map "sourceNavigable", to: :source_navigable, render_default: true
+        map "targetNavigable", to: :target_navigable, render_default: true
+      end
+    end
+  end
+end

data/lib/ea/model/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Common base for every Ea::Model type.
+    #
+    # Every model element has a stable identity (`id`) used to
+    # reference it from other elements (e.g. a Property refers to its
+    # type by id, a Relationship refers to its ends by id). Source
+    # adapters normalize the source-specific identifier (xmi:id,
+    # ea_guid, etc.) into this `id` field.
+    class Base < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :name, :string
+
+      json do
+        map "id", to: :id
+        map "name", to: :name
+      end
+
+      yaml do
+        map "id", to: :id
+        map "name", to: :name
+      end
+    end
+  end
+end

data/lib/ea/model/bounds.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Rectangular bounds in diagram pixel coordinates. Used by
+    # DiagramElement to record where a classifier is placed on a
+    # diagram.
+    class Bounds < Base
+      attribute :x, :integer
+      attribute :y, :integer
+      attribute :width, :integer
+      attribute :height, :integer
+
+      json do
+        map "x", to: :x
+        map "y", to: :y
+        map "width", to: :width
+        map "height", to: :height
+      end
+    end
+  end
+end

data/lib/ea/model/classifier.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Abstract base for Class, DataType, Enumeration, Interface,
+    # PrimitiveType — anything that can be a type of a Property, an
+    # end of an Association, etc.
+    #
+    # Concrete subclasses live in their own files and add their own
+    # specific attributes (e.g. Enumeration#literals). Source
+    # adapters dispatch on the source's type discriminator
+    # (t_object.Object_Type, xmi:type) to pick the right subclass.
+    class Classifier < Base
+      attribute :qualified_name, :string
+      attribute :package_id, :string # containing package
+      attribute :is_abstract, :boolean, default: false
+      attribute :visibility, :string
+      attribute :model_kind, :string, default: -> { "classifier" }
+      attribute :properties, Property, collection: true, initialize_empty: true
+      attribute :operations, Operation, collection: true, initialize_empty: true
+      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 "qualifiedName", to: :qualified_name
+        map "packageId", to: :package_id
+        map "isAbstract", to: :is_abstract, render_default: true
+        map "visibility", to: :visibility
+        map "modelKind", to: :model_kind, render_default: true
+        map "properties", to: :properties, render_empty: true
+        map "operations", to: :operations, render_empty: true
+        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/data_type.rb

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

data/lib/ea/model/dependency.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Dependency: client depends on supplier. No semantic
+    # implication beyond "client references supplier".
+    class Dependency < Relationship
+      attribute :client_id, :string
+      attribute :supplier_id, :string
+
+      attribute :relationship_kind, :string, default: -> { "dependency" }
+
+      json do
+        map "clientId", to: :client_id
+        map "supplierId", to: :supplier_id
+      end
+    end
+  end
+end

data/lib/ea/model/diagram.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A diagram: an ordered set of placed elements and connectors.
+    # The diagram references the package it belongs to (by id) and
+    # owns its elements/connectors compositionally.
+    class Diagram < Base
+      attribute :package_id, :string
+      attribute :diagram_type, :string  # logical|class|sequence|use_case|...
+      attribute :bounds, Bounds         # canvas size
+      attribute :elements, DiagramElement, collection: true, initialize_empty: true
+      attribute :connectors, DiagramConnector, collection: true, initialize_empty: true
+      attribute :annotations, Annotation, collection: true, initialize_empty: true
+
+      json do
+        map "id", to: :id
+        map "name", to: :name
+        map "packageId", to: :package_id
+        map "diagramType", to: :diagram_type
+        map "bounds", to: :bounds
+        map "elements", to: :elements, render_empty: true
+        map "connectors", to: :connectors, render_empty: true
+        map "annotations", to: :annotations, render_empty: true
+      end
+    end
+  end
+end

data/lib/ea/model/diagram_connector.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A connector drawn on a diagram between two DiagramElements.
+    # References the underlying Relationship (by id) and the source
+    # and target DiagramElements (by id). Carries ordered waypoints
+    # for routing.
+    class DiagramConnector < Base
+      attribute :diagram_id, :string
+      attribute :relationship_ref, :string
+      attribute :source_element_ref, :string
+      attribute :target_element_ref, :string
+      attribute :waypoints, Waypoint, collection: true, initialize_empty: true
+      attribute :label, :string
+      attribute :style, :hash, default: -> { {} }
+
+      json do
+        map "id", to: :id
+        map "diagramId", to: :diagram_id
+        map "relationshipRef", to: :relationship_ref
+        map "sourceElementRef", to: :source_element_ref
+        map "targetElementRef", to: :target_element_ref
+        map "waypoints", to: :waypoints, render_empty: true
+        map "label", to: :label
+        map "style", to: :style
+      end
+    end
+  end
+end

data/lib/ea/model/diagram_element.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A single placed element on a diagram. References the model
+    # element it visualizes (by id), carries pixel bounds and a
+    # parsed style map (fill color, line color, font, etc.).
+    class DiagramElement < Base
+      attribute :diagram_id, :string
+      attribute :model_element_ref, :string # id of Classifier/Package/etc.
+      attribute :bounds, Bounds
+      attribute :style, :hash, default: -> { {} } # parsed style fields
+
+      json do
+        map "id", to: :id
+        map "diagramId", to: :diagram_id
+        map "modelElementRef", to: :model_element_ref
+        map "bounds", to: :bounds
+        map "style", to: :style
+      end
+    end
+  end
+end

data/lib/ea/model/document.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Discriminator → subclass maps for polymorphic Classifier and
+    # Relationship collections. Defined here (rather than autoloaded)
+    # because lutaml-model needs them at class-evaluation time, and
+    # autoload only triggers on first constant reference.
+    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
+
+    # Root container for a harmonized model. Source adapters build
+    # one of these; consumer adapters read from it.
+    #
+    # Element identity is global within the document: every package,
+    # classifier, relationship, diagram, and diagram element has a
+    # unique `id`. References between elements are by id, so the
+    # document can be sharded cheaply (no need to walk a tree to
+    # resolve a reference).
+    class Document < Base
+      attribute :metadata, Metadata
+      attribute :packages, Package, collection: true, initialize_empty: true
+      attribute :classifiers, Classifier, collection: true, initialize_empty: true,
+                                          polymorphic: CLASSIFIER_POLYMORPHIC_MAP
+      attribute :relationships, Relationship, collection: true, initialize_empty: true,
+                                              polymorphic: RELATIONSHIP_POLYMORPHIC_MAP
+      attribute :stereotypes, Stereotype, collection: true, initialize_empty: true
+      attribute :diagrams, Diagram, collection: true, initialize_empty: true
+
+      # Flat lookup indexes, built lazily by consumers. Not
+      # serialized — they're derived from the element collections.
+      def index_by_id
+        @index_by_id ||= begin
+          idx = {}
+          packages.each { |p| idx[p.id] = p }
+          classifiers.each { |c| idx[c.id] = c }
+          relationships.each { |r| idx[r.id] = r }
+          stereotypes.each { |s| idx[s.id] = s }
+          diagrams.each { |d| idx[d.id] = d }
+          diagrams.each do |d|
+            d.elements.each { |e| idx[e.id] = e }
+            d.connectors.each { |c| idx[c.id] = c }
+          end
+          idx
+        end
+      end
+
+      def root_packages
+        packages.select { |p| p.parent_id.nil? }
+      end
+
+      def classifiers_in_package(package_id)
+        classifiers.select { |c| c.package_id == package_id }
+      end
+
+      def relationships_for(classifier_id)
+        relationships.select do |r|
+          case r
+          when Association
+            r.source_id == classifier_id || r.target_id == classifier_id
+          when Generalization
+            r.specific_id == classifier_id || r.general_id == classifier_id
+          when Realization
+            r.realizing_id == classifier_id || r.contract_id == classifier_id
+          when Dependency
+            r.client_id == classifier_id || r.supplier_id == classifier_id
+          else
+            false
+          end
+        end
+      end
+
+      def reset_indexes
+        @index_by_id = nil
+      end
+
+      json do
+        map "metadata", to: :metadata
+        map "packages", to: :packages, render_empty: true
+        map "classifiers", to: :classifiers, render_empty: true,
+                           polymorphic: CLASSIFIER_POLYMORPHIC_MAP
+        map "relationships", to: :relationships, render_empty: true,
+                             polymorphic: RELATIONSHIP_POLYMORPHIC_MAP
+        map "stereotypes", to: :stereotypes, render_empty: true
+        map "diagrams", to: :diagrams, render_empty: true
+      end
+    end
+  end
+end

data/lib/ea/model/enumeration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    class Enumeration < Classifier
+      attribute :model_kind, :string, default: -> { "enumeration" }
+      attribute :literals, EnumerationLiteral, collection: true,
+                                               initialize_empty: true
+
+      json do
+        map "literals", to: :literals, render_empty: true
+      end
+    end
+  end
+end

data/lib/ea/model/enumeration_literal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A single literal of an Enumeration.
+    class EnumerationLiteral < Base
+      attribute :value, :string
+      attribute :ordinal, :integer
+
+      json do
+        map "value", to: :value
+        map "ordinal", to: :ordinal
+      end
+    end
+  end
+end

data/lib/ea/model/generalization.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Generalization (inheritance): specific (child) extends
+    # general (parent).
+    class Generalization < Relationship
+      attribute :specific_id, :string  # child
+      attribute :general_id, :string   # parent
+
+      attribute :relationship_kind, :string, default: -> { "generalization" }
+
+      json do
+        map "specificId", to: :specific_id
+        map "generalId", to: :general_id
+      end
+    end
+  end
+end

data/lib/ea/model/interface.rb

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

data/lib/ea/model/klass.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Named `Klass` (not `Class`) to avoid collision with Ruby's
+    # built-in Class. Represents a UML Class.
+    class Klass < Classifier
+      attribute :model_kind, :string, default: -> { "class" }
+      attribute :is_active, :boolean, default: false
+
+      json do
+        map "isActive", to: :is_active, render_default: true
+      end
+    end
+  end
+end

data/lib/ea/model/metadata.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # Document-level metadata. Captured during source adaptation;
+    # surfaced by the SPA as project info.
+    class Metadata < Base
+      attribute :title, :string
+      attribute :version, :string
+      attribute :author, :string
+      attribute :company, :string
+      attribute :created_date, :string
+      attribute :modified_date, :string
+      attribute :source_format, :string  # "qea" | "xmi"
+      attribute :source_tool, :string    # e.g. "Sparx EA 16.0"
+      attribute :source_path, :string
+
+      json do
+        map "title", to: :title
+        map "version", to: :version
+        map "author", to: :author
+        map "company", to: :company
+        map "createdDate", to: :created_date
+        map "modifiedDate", to: :modified_date
+        map "sourceFormat", to: :source_format
+        map "sourceTool", to: :source_tool
+        map "sourcePath", to: :source_path
+      end
+    end
+  end
+end

data/lib/ea/model/operation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # An Operation on a Classifier (method). Parameters are owned
+    # composition-style.
+    class Operation < Base
+      attribute :owner_id, :string
+      attribute :qualified_name, :string
+      attribute :return_type_name, :string
+      attribute :is_static, :boolean, default: false
+      attribute :is_abstract, :boolean, default: false
+      attribute :visibility, :string
+      attribute :parameters, Parameter, collection: true, initialize_empty: true
+      attribute :stereotype_refs, :string, 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 "qualifiedName", to: :qualified_name
+        map "returnTypeName", to: :return_type_name
+        map "isStatic", to: :is_static, render_default: true
+        map "isAbstract", to: :is_abstract, render_default: true
+        map "visibility", to: :visibility
+        map "parameters", to: :parameters, render_empty: true
+        map "stereotypeRefs", to: :stereotype_refs, render_empty: true
+        map "annotations", to: :annotations, render_empty: true
+      end
+    end
+  end
+end

data/lib/ea/model/package.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A Package: hierarchical container for sub-packages and
+    # classifiers. References children by id (flat index in the
+    # Document) rather than nesting, so the same model is cheap to
+    # serialize, shard, and walk from any entry point.
+    class Package < Base
+      attribute :parent_id, :string # nil for root
+      attribute :qualified_name, :string
+      attribute :sub_package_ids, :string, collection: true,
+                                           initialize_empty: true
+      attribute :classifier_ids, :string, collection: true,
+                                          initialize_empty: true
+      attribute :diagram_ids, :string, collection: true,
+                                       initialize_empty: true
+      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 "parentId", to: :parent_id
+        map "qualifiedName", to: :qualified_name
+        map "subPackageIds", to: :sub_package_ids, render_empty: true
+        map "classifierIds", to: :classifier_ids, render_empty: true
+        map "diagramIds", to: :diagram_ids, render_empty: true
+        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/parameter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ea
+  module Model
+    # A single parameter of an Operation.
+    class Parameter < Base
+      attribute :ordinal, :integer
+      attribute :direction, :string, default: -> { "in" } # in|out|inout|return
+      attribute :type_name, :string
+      attribute :multiplicity_lower, :integer
+      attribute :multiplicity_upper, :integer
+      attribute :default_value, :string
+
+      json do
+        map "ordinal", to: :ordinal
+        map "direction", to: :direction
+        map "typeName", to: :type_name
+        map "multiplicityLower", to: :multiplicity_lower
+        map "multiplicityUpper", to: :multiplicity_upper
+        map "defaultValue", to: :default_value
+      end
+    end
+  end
+end