ea 0.2.5 → 0.3.0

data/lib/ea/spa/search_index.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ea
+  module Spa
+    class SearchIndex < Lutaml::Model::Serializable
+      attribute :version, :string, default: -> { "1.0" }
+      attribute :fields, :string, collection: true,
+                                  default: -> { %w[name qualifiedName kind package content] }
+      attribute :entries, SearchEntry, collection: true, initialize_empty: true
+
+      json do
+        map "version", to: :version, render_default: true
+        map "fields", to: :fields, render_default: true
+        map "entries", to: :entries, render_empty: true
+      end
+    end
+  end
+end

data/lib/ea/spa/shard.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ea
+  module Spa
+    # Per-entity detail payload. Plain Ruby value object (not a
+    # lutaml-model type) because the payload is an arbitrary JSON
+    # blob whose shape depends on the model element's kind — we
+    # don't want the framework's hash-type cast getting in the way.
+    Shard = Struct.new(:id, :kind, :payload, keyword_init: true) do
+      def to_h
+        { "id" => id, "kind" => kind, "payload" => payload }
+      end
+
+      def to_json(*args)
+        JSON.generate(to_h, *args)
+      end
+    end
+  end
+end

data/lib/ea/spa/skeleton.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Ea
+  module Spa
+    # Top-level SPA skeleton. Plain Struct (not a lutaml-model
+    # type) because it's a thin transport wrapper around typed
+    # sub-objects (PackageTree, SkeletonEntry) plus a raw metadata
+    # hash extracted from the model.
+    Skeleton = Struct.new(:metadata, :package_tree, :entries, :view_extras,
+                          keyword_init: true) do
+      def to_json(*args)
+        payload = {
+          "metadata" => metadata,
+          "packageTree" => package_tree,
+          "entries" => entries
+        }
+        payload["viewExtras"] = view_extras unless view_extras.nil? || view_extras.empty?
+        JSON.generate(payload, *args)
+      end
+    end
+  end
+end

data/lib/ea/spa/skeleton_entry.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Ea
+  module Spa
+    # One row in the SPA skeleton: the minimal info needed to
+    # render the sidebar, do name searches, and route to a shard.
+    # Everything else (properties, operations, etc.) lives in the
+    # per-entity Shard.
+    class SkeletonEntry < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :name, :string
+      attribute :kind, :string            # class|enumeration|data_type|...
+      attribute :package_id, :string
+      attribute :qualified_name, :string
+      attribute :shard_url, :string       # where to fetch the full Shard
+
+      json do
+        map "id", to: :id
+        map "name", to: :name
+        map "kind", to: :kind
+        map "packageId", to: :package_id
+        map "qualifiedName", to: :qualified_name
+        map "shardUrl", to: :shard_url
+      end
+    end
+  end
+end

data/lib/ea/spa.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Ea
+  # Ea::Spa is the SPA consumer adapter — a one-way projection of
+  # Ea::Model into view-shaped artifacts (Skeleton, Shard,
+  # SearchIndex, PackageTree) suitable for a browser frontend.
+  #
+  # Projection vs. modeling: the SPA does not redefine what a Class
+  # is. It owns view-shaped types that refer to model elements by
+  # id and add browsing-specific metadata (shard URLs, lazy refs,
+  # search content, navigation tree position).
+  #
+  # Output strategies (single-file vs sharded) live under
+  # Ea::Spa::Output and project the same artifacts to disk.
+  module Spa
+    autoload :SkeletonEntry, "ea/spa/skeleton_entry"
+    autoload :Skeleton, "ea/spa/skeleton"
+    autoload :PackageTreeNode, "ea/spa/package_tree_node"
+    autoload :PackageTree, "ea/spa/package_tree"
+    autoload :SearchEntry, "ea/spa/search_entry"
+    autoload :SearchIndex, "ea/spa/search_index"
+    autoload :Shard, "ea/spa/shard"
+    autoload :LazyRef, "ea/spa/lazy_ref"
+    autoload :Projector, "ea/spa/projector"
+    autoload :Output, "ea/spa/output"
+    autoload :Generator, "ea/spa/generator"
+    autoload :Configuration, "ea/spa/configuration"
+  end
+end

data/lib/ea/svg/bounds_calculator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    # Computes the actual drawing-area bounding box of an
+    # Ea::Model::Diagram. EA stores bounds in pixel space with two
+    # quirks: element rects can be inverted (rectbottom < recttop,
+    # producing negative height), and elements/connectors can sit
+    # outside the canvas bounds. The drawing area is the union of
+    # all element rects and connector waypoint positions.
+    class BoundsCalculator
+      attr_reader :diagram
+
+      def initialize(diagram)
+        @diagram = diagram
+      end
+
+      def compute
+        points = all_points
+        return fallback_bounds if points.empty?
+
+        xs = points.map(&:first)
+        ys = points.map(&:last)
+        Bounds.new(x: xs.min, y: ys.min, width: xs.max - xs.min,
+                    height: ys.max - ys.min)
+      end
+
+      private
+
+      def all_points
+        points = []
+        diagram.elements.each do |elem|
+          next unless elem.bounds
+
+          b = normalize_bounds(elem.bounds)
+          points << [b.x, b.y]
+          points << [b.x + b.width, b.y + b.height]
+        end
+        diagram.connectors.each do |conn|
+          conn.waypoints.each do |wp|
+            next unless wp.position
+
+            points << [wp.position.x, wp.position.y]
+          end
+        end
+        points
+      end
+
+      # EA occasionally stores inverted rects (rectbottom < recttop).
+      # Normalize so width/height are non-negative.
+      def normalize_bounds(bounds)
+        x = bounds.x
+        y = bounds.y
+        w = bounds.width
+        h = bounds.height
+        x, w = x + w, -w if w.negative?
+        y, h = y + h, -h if h.negative?
+        Bounds.new(x: x, y: y, width: w, height: h)
+      end
+
+      def fallback_bounds
+        return Bounds.new(x: 0, y: 0, width: 1, height: 1) unless diagram.bounds
+
+        Bounds.new(x: diagram.bounds.x, y: diagram.bounds.y,
+                    width: diagram.bounds.width.abs,
+                    height: diagram.bounds.height.abs)
+      end
+
+      # Internal value type — keep private to avoid polluting the
+      # Ea::Svg namespace.
+      Bounds = Struct.new(:x, :y, :width, :height, keyword_init: true)
+    end
+  end
+end

data/lib/ea/svg/connector_path.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    # Renders one DiagramConnector as an SVG <polyline> through
+    # its waypoints. Arrowheads and per-direction routing are
+    # future work; today we emit a straight-segment polyline
+    # matching the source layout.
+    class ConnectorPath
+      attr_reader :connector
+
+      def initialize(connector)
+        @connector = connector
+      end
+
+      def render
+        points = waypoints
+        return "" if points.empty?
+
+        <<~SVG.chomp
+          <polyline points="#{points.join(' ')}"
+                    fill="none" stroke="#{stroke_color}"
+                    stroke-width="#{stroke_width}"/>
+        SVG
+      end
+
+      private
+
+      def waypoints
+        connector.waypoints.filter_map do |wp|
+          next unless wp.position
+
+          "#{wp.position.x},#{wp.position.y}"
+        end
+      end
+
+      def stroke_color
+        StyleResolver.new(connector.style).stroke_color
+      end
+
+      def stroke_width
+        StyleResolver.new(connector.style).stroke_width
+      end
+    end
+  end
+end

data/lib/ea/svg/element_box.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module Ea
+  module Svg
+    # Renders one DiagramElement as an SVG <g> containing the rect
+    # and a name label. Class-shape rendering (with attribute /
+    # operation compartments) is future work; for now we emit a
+    # simple labeled box that mirrors EA's logical placement.
+    class ElementBox
+      attr_reader :element, :model_index
+
+      def initialize(element, model_index:)
+        @element = element
+        @model_index = model_index
+      end
+
+      def render
+        return "" unless element.bounds
+
+        b = normalize_bounds(element.bounds)
+        style = StyleResolver.new(element.style)
+        label_text = model_element_name
+
+        <<~SVG.chomp
+          <g class="element" data-element-id="#{escape(element.id)}">
+            <rect x="#{b.x}" y="#{b.y}" width="#{b.width}" height="#{b.height}"
+                  fill="#{style.fill_color}" stroke="#{style.stroke_color}"
+                  stroke-width="#{style.stroke_width}"/>
+            <text x="#{b.x + (b.width / 2.0)}"
+                  y="#{b.y + (b.height / 2.0)}"
+                  text-anchor="middle" dominant-baseline="middle"
+                  fill="#{style.font_color}"
+                  font-family="sans-serif" font-size="14">#{escape(label_text)}</text>
+          </g>
+        SVG
+      end
+
+      private
+
+      def model_element_name
+        ref = element.model_element_ref
+        return "(unbound)" unless ref
+
+        model = model_index[ref]
+        model&.name || "(missing #{ref})"
+      end
+
+      def normalize_bounds(bounds)
+        x = bounds.x
+        y = bounds.y
+        w = bounds.width
+        h = bounds.height
+        x, w = x + w, -w if w.negative?
+        y, h = y + h, -h if h.negative?
+        OpenStruct.new(x: x, y: y, width: w, height: h)
+      end
+
+      def escape(text)
+        return "" if text.nil?
+
+        text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub("\"", "&quot;")
+      end
+    end
+  end
+end

data/lib/ea/svg/renderer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module Ea
+  module Svg
+    # Renders an Ea::Model::Diagram into a standalone SVG string.
+    # Coordinates come straight from the umldi (UML Diagram
+    # Interchange) content captured by the source adapter:
+    # DiagramElement bounds and DiagramConnector waypoints.
+    #
+    # The renderer walks the diagram once, computes the union
+    # bounding box, and emits SVG in the same coordinate space
+    # (no y-flip; SVG's +y is down, same as EA's pixel space).
+    class Renderer
+      DEFAULT_PADDING = 20
+
+      attr_reader :diagram, :model_index, :options
+
+      def initialize(diagram, model_index: {}, padding: DEFAULT_PADDING)
+        @diagram = diagram
+        @model_index = model_index
+        @options = { padding: padding }
+      end
+
+      def render
+        bounds = BoundsCalculator.new(diagram).compute
+        padded = pad(bounds)
+
+        <<~SVG
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg"
+               viewBox="#{padded.x} #{padded.y} #{padded.width} #{padded.height}"
+               width="#{padded.width}" height="#{padded.height}"
+               font-family="sans-serif">
+            <rect x="#{padded.x}" y="#{padded.y}"
+                  width="#{padded.width}" height="#{padded.height}"
+                  fill="white"/>
+            #{render_elements}
+            #{render_connectors}
+          </svg>
+        SVG
+      end
+
+      private
+
+      def render_elements
+        diagram.elements.map do |elem|
+          ElementBox.new(elem, model_index: model_index).render
+        end.join("\n            ")
+      end
+
+      def render_connectors
+        diagram.connectors.map do |conn|
+          ConnectorPath.new(conn).render
+        end.join("\n            ")
+      end
+
+      def pad(bounds)
+        p = options[:padding]
+        OpenStruct.new(
+          x: bounds.x - p,
+          y: bounds.y - p,
+          width: bounds.width + (2 * p),
+          height: bounds.height + (2 * p)
+        )
+      end
+    end
+  end
+end

data/lib/ea/svg/style_resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    # Translates the parsed style hash (from
+    # Ea::Sources::Qea::DiagramStyleParser, or the equivalent for
+    # XMI) into SVG-friendly attributes. EA packs colors as
+    # integers (e.g. 16777215 = white); we translate to CSS hex.
+    class StyleResolver
+      DEFAULT_FILL = "#ffffff"
+      DEFAULT_STROKE = "#000000"
+      DEFAULT_FONT_COLOR = "#000000"
+
+      attr_reader :style
+
+      def initialize(style_hash)
+        @style = style_hash || {}
+      end
+
+      def fill_color
+        color_from_ea(style[:bcol]) || DEFAULT_FILL
+      end
+
+      def stroke_color
+        color_from_ea(style[:lcol]) || DEFAULT_STROKE
+      end
+
+      def font_color
+        color_from_ea(style[:fcol]) || DEFAULT_FONT_COLOR
+      end
+
+      def stroke_width
+        raw = style[:lwd]
+        return 1 if raw.nil? || raw.to_s.empty?
+
+        Integer(raw)
+      rescue ArgumentError
+        1
+      end
+
+      def to_svg_attrs
+        {
+          fill: fill_color,
+          stroke: stroke_color,
+          "stroke-width": stroke_width
+        }
+      end
+
+      # EA stores colors as decimal integers in BGR byte order
+      # (low byte = red, high byte = blue). The high byte may hold
+      # alpha in some variants; we treat anything above 0xFFFFFF
+      # as opaque.
+      def color_from_ea(raw)
+        return nil if raw.nil? || raw.to_s.empty?
+
+        # Hex strings (e.g. from XMI): passthrough.
+        return "##{raw}" if raw.to_s.match?(/\A[0-9a-fA-F]{6}\z/)
+
+        Integer(raw.to_s)
+      rescue ArgumentError
+        nil
+      else
+        # Convert BGR integer → RGB hex.
+        value = Integer(raw)
+        b = (value >> 16) & 0xff
+        g = (value >> 8) & 0xff
+        r = value & 0xff
+        format("#%02X%02X%02X", r, g, b)
+      end
+    end
+  end
+end

data/lib/ea/svg.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ea
+  # Ea::Svg is a consumer adapter of Ea::Model::Diagram — it
+  # projects the umldi (UML Diagram Interchange) content of a
+  # diagram into standalone SVG. Coordinates are taken straight
+  # from the source: EA's pixel space (rectleft, recttop,
+  # rectright, rectbottom, t_diagramlinks.geometry) or XMI's
+  # uml:Diagram owned_element bounds.
+  #
+  # Distinct from Ea::Diagram::SvgRenderer which operates on the
+  # legacy Lutaml::Uml::Document pipeline. This module consumes
+  # the canonical Ea::Model types only.
+  module Svg
+    autoload :BoundsCalculator, "ea/svg/bounds_calculator"
+    autoload :StyleResolver, "ea/svg/style_resolver"
+    autoload :ElementBox, "ea/svg/element_box"
+    autoload :ConnectorPath, "ea/svg/connector_path"
+    autoload :Renderer, "ea/svg/renderer"
+  end
+end

data/lib/ea/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ea
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end

data/lib/ea.rb

@@ -9,6 +9,10 @@ module Ea
   class Error < StandardError; end
 
   autoload :Qea, "ea/qea"
+  autoload :Model, "ea/model"
+  autoload :Sources, "ea/sources"
+  autoload :Spa, "ea/spa"
+  autoload :Svg, "ea/svg"
   autoload :Diagram, "ea/diagram"
   autoload :Transformations, "ea/transformations"
   autoload :Xmi, "ea/xmi"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-18 00:00:00.000000000 Z
+date: 2026-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -234,6 +234,18 @@ files:
 - TODO.next/38-xmi-parser-feature-parity.md
 - TODO.next/39-ea-spa-cli-command.md
 - TODO.next/40-drop-lur-only-check-in-diagrams-extract.md
+- TODO.refactor/01-ea-model-domain-layer.md
+- TODO.refactor/02-ea-model-qea-source-adapter.md
+- TODO.refactor/03-ea-model-xmi-source-adapter.md
+- TODO.refactor/04-ea-model-annotations-tagged-values.md
+- TODO.refactor/05-ea-model-diagrams-coordinates.md
+- TODO.refactor/06-spa-projection-layer.md
+- TODO.refactor/07-spa-sharded-output-strategy.md
+- TODO.refactor/08-spa-build-time-search-index.md
+- TODO.refactor/09-spa-frontend-data-contract.md
+- TODO.refactor/10-spa-cli-command-rework.md
+- TODO.refactor/11-spa-perf-benchmark.md
+- TODO.refactor/12-lutaml-uml-static-site-deprecation.md
 - TODO.release/01-release-lutaml-uml-030.md
 - TODO.release/02-fix-lutaml-meta-gem-requires.md
 - TODO.release/03-release-lutaml-0110.md
@@ -281,6 +293,7 @@ files:
 - lib/ea/cli/command/repository_builder.rb
 - lib/ea/cli/command/spa.rb
 - lib/ea/cli/command/stats.rb
+- lib/ea/cli/command/svg.rb
 - lib/ea/cli/command/validate.rb
 - lib/ea/cli/error.rb
 - lib/ea/cli/output.rb
@@ -302,6 +315,36 @@ files:
 - lib/ea/diagram/style_resolver.rb
 - lib/ea/diagram/svg_renderer.rb
 - lib/ea/diagram/util.rb
+- lib/ea/model.rb
+- lib/ea/model/annotation.rb
+- lib/ea/model/association.rb
+- lib/ea/model/base.rb
+- lib/ea/model/bounds.rb
+- lib/ea/model/classifier.rb
+- lib/ea/model/data_type.rb
+- lib/ea/model/dependency.rb
+- lib/ea/model/diagram.rb
+- lib/ea/model/diagram_connector.rb
+- lib/ea/model/diagram_element.rb
+- lib/ea/model/document.rb
+- lib/ea/model/enumeration.rb
+- lib/ea/model/enumeration_literal.rb
+- lib/ea/model/generalization.rb
+- lib/ea/model/interface.rb
+- lib/ea/model/klass.rb
+- lib/ea/model/metadata.rb
+- lib/ea/model/operation.rb
+- lib/ea/model/package.rb
+- lib/ea/model/parameter.rb
+- lib/ea/model/point.rb
+- lib/ea/model/polymorphic_maps.rb
+- lib/ea/model/primitive_type.rb
+- lib/ea/model/property.rb
+- lib/ea/model/realization.rb
+- lib/ea/model/relationship.rb
+- lib/ea/model/stereotype.rb
+- lib/ea/model/tagged_value.rb
+- lib/ea/model/waypoint.rb
 - lib/ea/qea.rb
 - lib/ea/qea/benchmark.rb
 - lib/ea/qea/database.rb
@@ -390,6 +433,58 @@ files:
 - lib/ea/qea/verification/document_verifier.rb
 - lib/ea/qea/verification/element_comparator.rb
 - lib/ea/qea/verification/structure_matcher.rb
+- lib/ea/sources.rb
+- lib/ea/sources/qea.rb
+- lib/ea/sources/qea/adapter.rb
+- lib/ea/sources/qea/annotation_builder.rb
+- lib/ea/sources/qea/classifier_builder.rb
+- lib/ea/sources/qea/connector_relationship_map.rb
+- lib/ea/sources/qea/diagram_builder.rb
+- lib/ea/sources/qea/diagram_style_parser.rb
+- lib/ea/sources/qea/id_normalizer.rb
+- lib/ea/sources/qea/metadata_builder.rb
+- lib/ea/sources/qea/object_classifier_map.rb
+- lib/ea/sources/qea/operation_builder.rb
+- lib/ea/sources/qea/package_builder.rb
+- lib/ea/sources/qea/property_builder.rb
+- lib/ea/sources/qea/relationship_builder.rb
+- lib/ea/sources/qea/stereotype_builder.rb
+- lib/ea/sources/qea/tagged_value_builder.rb
+- lib/ea/sources/xmi.rb
+- lib/ea/sources/xmi/adapter.rb
+- lib/ea/sources/xmi/annotation_builder.rb
+- lib/ea/sources/xmi/classifier_builder.rb
+- lib/ea/sources/xmi/diagram_builder.rb
+- lib/ea/sources/xmi/id_normalizer.rb
+- lib/ea/sources/xmi/metadata_builder.rb
+- lib/ea/sources/xmi/operation_builder.rb
+- lib/ea/sources/xmi/package_builder.rb
+- lib/ea/sources/xmi/property_builder.rb
+- lib/ea/sources/xmi/relationship_builder.rb
+- lib/ea/sources/xmi/relationship_type_map.rb
+- lib/ea/sources/xmi/type_classifier_map.rb
+- lib/ea/spa.rb
+- lib/ea/spa/configuration.rb
+- lib/ea/spa/generator.rb
+- lib/ea/spa/lazy_ref.rb
+- lib/ea/spa/output.rb
+- lib/ea/spa/output/sharded_multi_file_strategy.rb
+- lib/ea/spa/output/single_file_strategy.rb
+- lib/ea/spa/output/strategy.rb
+- lib/ea/spa/package_tree.rb
+- lib/ea/spa/package_tree_node.rb
+- lib/ea/spa/projector.rb
+- lib/ea/spa/search_entry.rb
+- lib/ea/spa/search_index.rb
+- lib/ea/spa/shard.rb
+- lib/ea/spa/skeleton.rb
+- lib/ea/spa/skeleton_entry.rb
+- lib/ea/svg.rb
+- lib/ea/svg/bounds_calculator.rb
+- lib/ea/svg/connector_path.rb
+- lib/ea/svg/element_box.rb
+- lib/ea/svg/renderer.rb
+- lib/ea/svg/style_resolver.rb
 - lib/ea/transformations.rb
 - lib/ea/transformations/configuration.rb
 - lib/ea/transformations/format_registry.rb