ea 0.4.0 → 0.5.1

data/lib/ea/sources/xmi/umldi_keyword_extractor.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Reads UMLDI `<ownedElement>` blocks from the XMI source and
+      # returns the keyword text EA emitted for each modeled element.
+      #
+      # The xmi gem's typed parser does not surface umldi: keyword
+      # labels, but EA encodes them as
+      # `<ownedElement xmi:type="umldi:UMLKeywordLabel" text="Type"/>`.
+      # This class pre-parses the raw XML once and indexes by the
+      # referenced classifier ID.
+      #
+      # Returned text is the raw keyword ("Type", "FeatureType",
+      # "dataType"). The emitter wraps it in «...» when rendering.
+      class UmldiKeywordExtractor
+        # Sparx EA 6.5 declares umldi: as the 20161101 namespace on
+        # the XMI root. Older EAs use the 20131001 version. Try both.
+        UMLDI_NAMESPACES = [
+          "http://www.omg.org/spec/UML/20161101/UMLDI",
+          "http://www.omg.org/spec/UML/20131001/UMLDI"
+        ].freeze
+
+        attr_reader :xmi_path
+
+        def initialize(xmi_path)
+          @xmi_path = xmi_path
+        end
+
+        # Returns { classifier_id => keyword_text } for every
+        # umldi:UMLKeywordLabel found, scoped to the given diagram.
+        def keywords_for_diagram(diagram_id)
+          return {} unless File.exist?(xmi_path)
+
+          keywords_by_diagram[diagram_id] || {}
+        end
+
+        private
+
+        def doc
+          @doc ||= Nokogiri::XML(File.read(xmi_path))
+        end
+
+        def keywords_by_diagram
+          @keywords_by_diagram ||= begin
+            result = {}
+            # The Sparx XMI export declares the umldi: namespace
+            # but the elements inside Diagram have lost their
+            # prefix binding once parsed by Nokogiri — the
+            # element name resolves to local-name "ownedElement"
+            # and the umldi:UMLClassifierShape type information
+            # lives in the literal `type` attribute. We therefore
+            # match shape children by the presence of `modelElement`
+            # and the keyword label by its `text` attribute.
+            doc.xpath("//*[local-name()=\"Diagram\"]").each do |diagram|
+              diagram_id = diagram["id"] || diagram["xmi:id"]
+              next unless diagram_id
+
+              keywords = {}
+              diagram.xpath("./ownedElement[@modelElement]").each do |shape|
+                model_id = shape["modelElement"]
+                next unless model_id
+
+                # Keyword label is the first ownedElement child
+                # with a non-empty `text` attribute. The name
+                # label follows it.
+                shape.xpath("./ownedElement[@text]").each do |child|
+                  text = child["text"]
+                  next if text.nil? || text.empty?
+                  next if text.start_with?("«") # safety
+
+                  keywords[model_id] = text
+                  break
+                end
+              end
+              result[diagram_id] = keywords unless keywords.empty?
+            end
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/sources/xmi.rb

@@ -22,10 +22,14 @@ module Ea
       autoload :OperationBuilder, "ea/sources/xmi/operation_builder"
       autoload :RelationshipBuilder, "ea/sources/xmi/relationship_builder"
       autoload :AnnotationBuilder, "ea/sources/xmi/annotation_builder"
+      autoload :TagBuilder, "ea/sources/xmi/tag_builder"
+      autoload :NoteBuilder, "ea/sources/xmi/note_builder"
+      autoload :StereotypeBuilder, "ea/sources/xmi/stereotype_builder"
       autoload :DiagramBuilder, "ea/sources/xmi/diagram_builder"
       autoload :ExtensionElements, "ea/sources/xmi/extension_elements"
       autoload :ExtensionGeometryParser, "ea/sources/xmi/extension_geometry_parser"
       autoload :ExtensionStyleParser, "ea/sources/xmi/extension_style_parser"
+      autoload :UmldiKeywordExtractor, "ea/sources/xmi/umldi_keyword_extractor"
       autoload :Adapter, "ea/sources/xmi/adapter"
     end
   end

data/lib/ea/spa/output/sharded_multi_file_strategy.rb

@@ -6,11 +6,14 @@ module Ea
   module Spa
     module Output
       # Sharded layout: directory with skeleton.json, search.json,
-      # and one JSON file per entity under data/. The frontend
-      # loads skeleton + search upfront and fetches shards on
-      # demand. This is the layout for large models.
+      # one JSON file per entity under data/, the pre-built SPA
+      # bundle (app.js + style.css), and an index.html shell that
+      # ties them together. The frontend loads skeleton + search
+      # upfront and fetches shards on demand. Suitable for large
+      # models that won't fit comfortably in a single HTML file.
       class ShardedMultiFileStrategy < Strategy
         def render(projector)
+          assert_frontend_bundle!
           FileUtils.mkdir_p(output_path)
           FileUtils.mkdir_p(File.join(output_path, "data"))
 
@@ -19,6 +22,7 @@ module Ea
           write_json(File.join(output_path, "search.json"),
                      projector.search_index)
           write_shards(projector)
+          write_assets
           write_index_html(skeleton)
 
           output_path
@@ -42,6 +46,15 @@ module Ea
           end
         end
 
+        # Copy the pre-built JS + CSS bundles next to index.html so
+        # the shell can <script src="app.js"> them. Assets are always
+        # the same bytes for every generation, so a plain file copy
+        # is both simplest and fastest.
+        def write_assets
+          FileUtils.cp(FRONTEND_APP_JS,    File.join(output_path, "app.js"))
+          FileUtils.cp(FRONTEND_STYLE_CSS, File.join(output_path, "style.css"))
+        end
+
         def write_index_html(skeleton)
           title = skeleton.view_extras&.dig("ui", "title") ||
                   skeleton.metadata&.fetch("title", nil) ||
@@ -53,6 +66,7 @@ module Ea
               <meta charset="UTF-8">
               <meta name="viewport" content="width=device-width, initial-scale=1.0">
               <title>#{title}</title>
+              <link rel="stylesheet" href="style.css">
             </head>
             <body>
               <div id="app"></div>
@@ -61,6 +75,7 @@ module Ea
               window.__SPA_SEARCH_URL__ = 'search.json';
               window.__SPA_SHARD_BASE__ = 'data/';
               </script>
+              <script src="app.js" defer></script>
             </body>
             </html>
           HTML

data/lib/ea/spa/output/single_file_strategy.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "json"
 
 module Ea
   module Spa
     module Output
-      # Embeds skeleton + search + every shard in one HTML file
-      # (data inlined as a JSON blob). Suitable for small models
+      # Embeds skeleton + search + every shard AND the pre-built SPA
+      # bundle (JS + CSS) in one HTML file. Suitable for small models
       # only; not appropriate when shard count or total payload is
       # large.
       class SingleFileStrategy < Strategy
         def render(projector)
+          assert_frontend_bundle!
           FileUtils.mkdir_p(File.dirname(output_path))
 
           skeleton = projector.skeleton
@@ -33,6 +35,8 @@ module Ea
           title = payload.dig(:viewExtras, "ui", "title") ||
                   payload[:metadata]&.fetch("title", nil) ||
                   "Ea::Spa"
+          css = frontend_style_css || ""
+          js  = frontend_app_js || ""
           <<~HTML
             <!DOCTYPE html>
             <html lang="en">
@@ -40,12 +44,14 @@ module Ea
               <meta charset="UTF-8">
               <meta name="viewport" content="width=device-width, initial-scale=1.0">
               <title>#{title}</title>
+              <style>#{css}</style>
             </head>
             <body>
               <div id="app"></div>
               <script>
               window.__SPA_DATA__ = #{payload.to_json};
               </script>
+              <script>#{js}</script>
             </body>
             </html>
           HTML

data/lib/ea/spa/output/strategy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fileutils"
+
 module Ea
   module Spa
     module Output
@@ -13,6 +15,14 @@ module Ea
       class Strategy
         SIZE_THRESHOLD_BYTES = 2 * 1024 * 1024 # 2 MB
 
+        # Path to the pre-built Vue IIFE bundle shipped with the gem.
+        # Built from frontend/ via `npm run build`; committed so the
+        # gem never needs npm at install time. Resolved lazily so a
+        # missing bundle raises a clear error pointing at frontend/.
+        FRONTEND_DIST_DIR = File.expand_path("../../../../frontend/dist", __dir__)
+        FRONTEND_APP_JS   = File.join(FRONTEND_DIST_DIR, "app.iife.js")
+        FRONTEND_STYLE_CSS = File.join(FRONTEND_DIST_DIR, "style.css")
+
         attr_reader :output_path
 
         def initialize(output_path)
@@ -24,6 +34,30 @@ module Ea
                 "#{self.class} must implement #render"
         end
 
+        protected
+
+        # The pre-built SPA application source as a String, for
+        # embedding directly into a single-file output. Returns nil
+        # if the bundle has not been built (e.g. running from a
+        # source checkout before `npm run build`).
+        def frontend_app_js
+          return nil unless File.exist?(FRONTEND_APP_JS)
+          File.read(FRONTEND_APP_JS)
+        end
+
+        def frontend_style_css
+          return nil unless File.exist?(FRONTEND_STYLE_CSS)
+          File.read(FRONTEND_STYLE_CSS)
+        end
+
+        def assert_frontend_bundle!
+          unless File.exist?(FRONTEND_APP_JS) && File.exist?(FRONTEND_STYLE_CSS)
+            raise Ea::Error,
+                  "SPA frontend bundle not found under #{FRONTEND_DIST_DIR}. " \
+                  "Run `cd frontend && npm install && npm run build`."
+          end
+        end
+
         private
 
         def write_json(path, data)

data/lib/ea/svg/connector_router.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    class ConnectorRouter
+      # Empirically determined offset EA adds to top-edge
+      # attachment points: connector starts ~9 px below the
+      # element's logical top edge (matches header height).
+      EDGE_TOP_OFFSET = 9
+
+      attr_reader :source_bounds, :target_bounds, :edge_code,
+                  :source_delta, :target_delta, :bend_path
+
+      def initialize(source_bounds:, target_bounds:,
+                     edge_code: nil,
+                     source_delta: [0, 0], target_delta: [0, 0],
+                     bend_path: nil)
+        @source_bounds = source_bounds
+        @target_bounds = target_bounds
+        @edge_code = edge_code
+        @source_delta = source_delta
+        @target_delta = target_delta
+        @bend_path = bend_path || []
+      end
+
+      def waypoints
+        src_pt = source_point
+        tgt_pt = target_point
+        return [] unless src_pt && tgt_pt
+
+        # Path= values from EA are ABSOLUTE pixel positions on the
+        # diagram canvas (verified against reference SVGs). Use them
+        # as-is — do not offset by src_pt.
+        return [src_pt, *bend_path, tgt_pt] if bend_path.any?
+
+        points = [src_pt]
+        bend = bend_point(src_pt, tgt_pt)
+        points << bend if bend
+        points << tgt_pt
+        points
+      end
+
+      private
+
+      def source_point
+        return nil unless source_bounds
+        pt = if @edge_code && @edge_code != 0
+               edge_point(source_bounds, @edge_code)
+             else
+               primary_edge(source_bounds, target_bounds)
+             end
+        return nil unless pt
+
+        offset_by_delta(pt, source_delta)
+      end
+
+      def target_point
+        return nil unless target_bounds
+        pt = if @edge_code && @edge_code != 0
+               opposite_edge_point(source_bounds, target_bounds, @edge_code)
+             else
+               primary_edge(target_bounds, source_bounds)
+             end
+        return nil unless pt
+
+        offset_by_delta(pt, target_delta)
+      end
+
+      def offset_by_delta(point, delta)
+        return point if delta.nil?
+
+        [point[0] + (delta[0] || 0), point[1] + (delta[1] || 0)]
+      end
+
+      def edge_point(bounds, code)
+        case code
+        when 1 then [center_x(bounds), bounds.y + EDGE_TOP_OFFSET]
+        when 2 then [bounds.x + bounds.width, center_y(bounds)]
+        when 3 then [center_x(bounds), bounds.y + bounds.height]
+        when 4 then [bounds.x, center_y(bounds)]
+        else      [center_x(bounds), center_y(bounds)]
+        end
+      end
+
+      def opposite_edge_point(source, target, code)
+        case code
+        when 1 then [center_x(target), target.y + target.height]
+        when 2 then [target.x, center_y(target)]
+        when 3 then [center_x(target), target.y]
+        when 4 then [target.x + target.width, center_y(target)]
+        else      [center_x(target), center_y(target)]
+        end
+      end
+
+      def primary_edge(bounds, other)
+        return nil unless bounds && other
+
+        dx = center_x(bounds) - center_x(other)
+        dy = center_y(bounds) - center_y(other)
+
+        if dx.abs > dy.abs
+          dx.positive? ? [bounds.x, center_y(bounds)] : [bounds.x + bounds.width, center_y(bounds)]
+        else
+          dy.positive? ? [center_x(bounds), bounds.y] : [center_x(bounds), bounds.y + bounds.height]
+        end
+      end
+
+      def bend_point(src, tgt)
+        return nil if src == tgt
+        return nil if src[0] == tgt[0] || src[1] == tgt[1]
+
+        if horizontal_exit?
+          [tgt[0], src[1]]
+        else
+          [src[0], tgt[1]]
+        end
+      end
+
+      def horizontal_exit?
+        return false unless source_bounds && @edge_code
+
+        @edge_code == 2 || @edge_code == 4
+      end
+
+      def center_x(bounds)
+        bounds.x + (bounds.width / 2.0)
+      end
+
+      def center_y(bounds)
+        bounds.y + (bounds.height / 2.0)
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/background.rb

@@ -1,14 +1,13 @@
-# frozen_string_literal: true
+# frozen_string_string: true
 
 module Ea
   module Svg
     module EaEmitter
-      # Emits the background layer: white rect over the full canvas.
       module Background
         module_function
 
         def render(canvas)
-          %(<g style="fill:#FFFFFF;fill-opacity:1.00;">\n  <rect x="#{canvas.min_x}" y="#{canvas.min_y}" width="#{canvas.width}" height="#{canvas.height}" shape-rendering="auto"/>\n</g>)
+          %(<g style="fill:#FFFFFF;fill-opacity:1.00;">\n  <rect x="0" y="0" width="#{canvas.width}" height="#{canvas.height}" shape-rendering="auto"/>\n</g>)
         end
       end
     end

data/lib/ea/svg/ea_emitter/bounds_calculator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      # Computes the (min_x, min_y, width, height) tuple for a
+      # Diagram's canvas. Encapsulates the union rules so Canvas
+      # stays a small value-object with just coordinate translation
+      # and formatting concerns.
+      #
+      # Sources contributing to the bounds:
+      #   - ElementBounds:    logical x-extent, logical+image y-extent
+      #   - ConnectorBounds:  waypoint positions
+      #   - MarkerExtent:     MARKER_EXTENT padding around end points
+      #   - PackageTabExtent: extra space above Package elements for
+      #                       the tab polygon (which sits above the
+      #                       element's logical top).
+      #
+      # Each source is a method returning an Array<[x, y]> points.
+      # Composing new sources = adding a method, no modification of
+      # existing ones (OCP).
+      class BoundsCalculator
+        MARKER_EXTENT = 15
+        PACKAGE_TAB_HEIGHT = 20
+        # EA's canvas includes non-uniform frame insets around the
+        # element content. Reverse-engineered from reference SVG
+        # byte-diff: maintenance diagram has element 169x80 at
+        # logical (0,0), ref canvas is 254x177 with element at
+        # (35, 40). So:
+        #   canvas_width  = element_width + INSET_LEFT + INSET_RIGHT
+        #   canvas_height = element_height + INSET_TOP + INSET_BOTTOM
+        # The top inset accommodates the frame tab + label space
+        # above the element.
+        INSET_LEFT = 35
+        INSET_RIGHT = 50
+        INSET_TOP = 40
+        INSET_BOTTOM = 57
+
+        attr_reader :diagram, :model_index
+
+        def initialize(diagram, model_index: nil)
+          @diagram = diagram
+          @model_index = model_index
+        end
+
+        def compute
+          points = []
+          points.concat(element_points)
+          points.concat(connector_points)
+          points.concat(marker_points)
+          points.concat(package_tab_points)
+          return [0, 0, 1, 1] if points.empty?
+
+          xs = points.map(&:first)
+          ys = points.map(&:last)
+          min_x = xs.min || 0
+          min_y = ys.min || 0
+          [
+            min_x,
+            min_y,
+            (xs.max - min_x) + INSET_LEFT + INSET_RIGHT,
+            (ys.max - min_y) + INSET_TOP + INSET_BOTTOM
+          ]
+        end
+
+        private
+
+        # Element x-extent: logical bounds only (matches EA's canvas
+        # left/right exactly).
+        # Element y-extent: union of logical + image_bounds (image
+        # extends below bounds for shadow / image padding).
+        def element_points
+          pts = []
+          (diagram.elements || []).each do |e|
+            primary = e.bounds || e.image_bounds
+            if primary
+              pts << [primary.x, primary.y]
+              pts << [primary.x + primary.width, primary.y + primary.height]
+            end
+            if e.bounds && e.image_bounds
+              ib = e.image_bounds
+              pts << [ib.x, ib.y]
+              pts << [ib.x + ib.width, ib.y + ib.height]
+            end
+          end
+          pts
+        end
+
+        # Package elements render with a tab polygon ABOVE the
+        # element's logical top edge (height PACKAGE_TAB_HEIGHT).
+        # Include those points so the canvas reserves space.
+        def package_tab_points
+          return [] if model_index.nil?
+
+          pts = []
+          (diagram.elements || []).each do |e|
+            ref = e.model_element_ref
+            next unless ref
+
+            candidate = model_index[ref]
+            next unless candidate.is_a?(Ea::Model::Package)
+
+            primary = e.bounds || e.image_bounds
+            next unless primary
+
+            pts << [primary.x, primary.y - PACKAGE_TAB_HEIGHT]
+            pts << [primary.x + primary.width, primary.y]
+          end
+          pts
+        end
+
+        def connector_points
+          pts = []
+          (diagram.connectors || []).each do |c|
+            (c.waypoints || []).each do |wp|
+              next unless wp.position
+
+              pts << [wp.position.x, wp.position.y]
+            end
+          end
+          pts
+        end
+
+        def marker_points
+          pts = []
+          (diagram.connectors || []).each do |c|
+            waypoints = (c.waypoints || []).map(&:position).compact
+            next unless waypoints.size >= 2
+
+            source = waypoints.first
+            target = waypoints.last
+            pts << [source.x - MARKER_EXTENT, source.y - MARKER_EXTENT]
+            pts << [source.x + MARKER_EXTENT, source.y + MARKER_EXTENT]
+            pts << [target.x - MARKER_EXTENT, target.y - MARKER_EXTENT]
+            pts << [target.x + MARKER_EXTENT, target.y + MARKER_EXTENT]
+          end
+          pts
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/ea_emitter/canvas.rb

@@ -3,44 +3,47 @@
 module Ea
   module Svg
     module EaEmitter
-      # Computes the canvas dimensions for the root <svg> element.
-      # Union of all element image_bounds (the padded bounds EA
-      # uses for the visual box), with a 10 px outer margin.
-      # Emits cm dimensions (px / 28.346 at 72 DPI).
-      Canvas = Struct.new(:min_x, :min_y, :width, :height, keyword_init: true) do
-        PX_PER_CM = 28.3464567
+      # Canvas carries the diagram's computed pixel bounds plus the
+      # coordinate-translation helpers that align element (0,0) with
+      # EA's content origin (35, 40). Bound computation itself is
+      # delegated to BoundsCalculator (SRP).
+      #
+      # Promoted from a Struct.new + `do ... end` block to a proper
+      # class so the public API is explicit (attr_reader vs implicit
+      # struct fields) and behavior is named rather than implicit.
+      # Struct definitions with instance methods conflate "data" and
+      # "behavior" — a class keeps them separable while the values
+      # stay immutable.
+      class Canvas
+        # EA's diagram canvas places element (0,0) at SVG (35, 40) —
+        # the diagram's content origin inset from the canvas top-left
+        # corner. Reverse-engineered from reference SVG byte-diff
+        # against the maintenance diagram.
+        PX_PER_CM = 37.795275591
+        FRAME_INSET_LEFT = 35
+        FRAME_INSET_TOP = 40
 
-        def self.from(diagram)
-          points = []
-          (diagram.elements || []).each do |e|
-            b = e.image_bounds || e.bounds
-            next unless b
+        attr_reader :min_x, :min_y, :width, :height
 
-            points << [b.x, b.y]
-            points << [b.x + b.width, b.y + b.height]
-          end
-          (diagram.connectors || []).each do |c|
-            (c.waypoints || []).each do |wp|
-              next unless wp.position
-
-              points << [wp.position.x, wp.position.y]
-            end
-          end
-          return new(min_x: 0, min_y: 0, width: 1, height: 1) if points.empty?
+        def initialize(min_x:, min_y:, width:, height:)
+          @min_x = min_x
+          @min_y = min_y
+          @width = width
+          @height = height
+        end
 
-          xs = points.map(&:first)
-          ys = points.map(&:last)
-          margin = 10
-          new(
-            min_x: (xs.min || 0) - margin,
-            min_y: (ys.min || 0) - margin,
-            width: (xs.max - xs.min) + (2 * margin),
-            height: (ys.max - ys.min) + (2 * margin)
-          )
+        # Build a Canvas for a diagram by running the bound
+        # calculator. Defaults model_index to nil (no canvas-aware
+        # element bounds needed) for callers that only need a
+        # frame-size estimate.
+        def self.from(diagram, model_index: nil)
+          min_x, min_y, width, height =
+            BoundsCalculator.new(diagram, model_index: model_index).compute
+          new(min_x: min_x, min_y: min_y, width: width, height: height)
         end
 
         def view_box
-          "#{min_x} #{min_y} #{width} #{height}"
+          "0 0 #{width} #{height}"
         end
 
         def width_cm
@@ -51,6 +54,26 @@ module Ea
           format_cm(height)
         end
 
+        # Translate a content-space point into SVG-space. EA insets
+        # the content area from the canvas top-left by
+        # FRAME_INSET_LEFT/TOP.
+        def translate_x(x)
+          x - min_x + FRAME_INSET_LEFT
+        end
+
+        def translate_y(y)
+          y - min_y + FRAME_INSET_TOP
+        end
+
+        # Compact coordinate formatter. Integers lose the decimal
+        # point; floats keep up to two digits with trailing zeros
+        # stripped (matches EA's emitted numeric format).
+        def self.coord(value)
+          return value.to_i.to_s if value == value.to_i
+
+          format("%.2f", value).sub(/\.?0+$/, "")
+        end
+
         private
 
         def format_cm(px)
@@ -62,4 +85,4 @@ module Ea
       end
     end
   end
-end
+end