ea 0.3.1 → 0.5.0

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts per-element stereotype applications from EA's
+      # `<xmi:Extension>/<elements>` block. EA stores stereotype
+      # info in `<element xmi:idref="EAID_...">/<properties
+      # stereotype="X"/>`. The uml:Model packaged elements carry
+      # type info but not stereotypes.
+      #
+      # Returns a Hash{element_id => Array<String>} of stereotype
+      # names applied to that element.
+      class StereotypeBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def grouped_by_element
+          @grouped ||= begin
+            elements = root.extension&.elements
+            return {} unless elements
+
+            elements.element.each_with_object({}) do |ext_element, acc|
+              id = ext_element.idref
+              next unless id
+
+              stereotypes = stereotypes_for(ext_element)
+              next if stereotypes.empty?
+
+              acc[id] = stereotypes
+            end
+          end
+        end
+
+        private
+
+        # The `<properties stereotype="X"/>` attribute holds the
+        # primary stereotype. Additional stereotypes from `<xrefs>`
+        # are not captured here — that would require parsing the
+        # packed XREFPROP string format.
+        def stereotypes_for(ext_element)
+          props = ext_element.properties
+          value = props&.stereotype
+          return [] if value.nil? || value.to_s.empty?
+
+          [value.to_s]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts tagged values from the `<xmi:Extension><tags><tag/>`
+      # block. The xmi gem does not expose Sparx tags directly, so we
+      # parse the raw XML once and group tags by their
+      # `modelElement` attribute. Each tag's value is truncated at
+      # the first `#` (EA encodes notes after that marker).
+      class TagBuilder
+        attr_reader :xmi_path
+
+        def initialize(xmi_path)
+          @xmi_path = xmi_path
+        end
+
+        # Returns Hash{model_element_id => Array<Ea::Model::TaggedValue>}
+        def grouped_by_model_element
+          return {} if xmi_path.nil?
+
+          @grouped ||= begin
+            doc = Nokogiri::XML(File.read(xmi_path))
+            # <tags><tag/></tags> lives inside per-element <element>
+            # blocks within <xmi:Extension>. The element itself is in
+            # no XML namespace; match by local-name to be safe.
+            doc.xpath(%(//*[local-name()="tags"]/*[local-name()="tag"]))
+              .each_with_object({}) do |node, acc|
+              me = node["modelElement"]
+              next unless me
+
+              key = node["name"].to_s
+              value = node["value"].to_s.split("#", 2).first
+              next if key.empty?
+
+              (acc[me] ||= []) << Ea::Model::TaggedValue.new(key: key, value: value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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,7 +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

@@ -0,0 +1,15 @@
+# frozen_string_string: true
+
+module Ea
+  module Svg
+    module EaEmitter
+      module Background
+        module_function
+
+        def render(canvas)
+          %(<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
+  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