ea 0.4.0 → 0.5.0

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

@@ -23,7 +23,8 @@ module Ea
             italic: truthy?(kv["italic"]),
             underline: truthy?(kv["ul"]),
             black: truthy?(kv["black"]),
-            hide_icon: truthy?(kv["HideIcon"]),
+            hide_icon: tri_state_icon(kv["HideIcon"]),
+            show_tagged_values: truthy?(kv["Tag"]),
             duid: kv["DUID"],
             soid: kv["SOID"],
             eoid: kv["EOID"],
@@ -34,6 +35,17 @@ module Ea
           )
         end
 
+        # HideIcon tri-state: "1" → :hidden, "0" → :shown,
+        # missing → nil (use the diagram default, which EA treats
+        # as hidden in practice).
+        def tri_state_icon(value)
+          return nil if value.nil? || value.empty?
+          return :hidden if value == "1" || value == "true" || value == "-1"
+          return :shown if value == "0"
+
+          nil
+        end
+
         def split_pairs(str)
           str.split(";").filter_map do |pair|
             next nil unless pair.include?("=")
@@ -59,7 +71,7 @@ module Ea
           return 13 if value.nil? || value.empty?
 
           pct = int(value)
-          return 13 if pct.nil?
+          return 13 if pct.nil? || pct.zero?
 
           (pct * 13 / 100).round
         end
@@ -68,6 +80,7 @@ module Ea
           :background_color, :line_color, :line_width,
           :font_family, :font_size,
           :bold, :italic, :underline, :black, :hide_icon,
+          :show_tagged_values,
           :duid, :soid, :eoid, :mode, :color, :hidden,
           :raw,
           keyword_init: true

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Sources
+    module Xmi
+      # Extracts Note elements from EA's XMI extension block.
+      # Notes are documentation entries (`<element xmi:type="uml:Note">`)
+      # inside `<xmi:Extension>/<elements>`. Each carries a
+      # `<properties documentation="..."/>` child with the body text.
+      #
+      # The xmi gem parses Note elements as part of the extension
+      # block; we walk them and project to Ea::Model::Note.
+      class NoteBuilder
+        attr_reader :root
+
+        def initialize(root)
+          @root = root
+        end
+
+        def build_all
+          elements = root.extension&.elements
+          return [] unless elements
+
+          elements.element.to_a.filter_map { |e| build_one(e) }
+        end
+
+        private
+
+        def build_one(ext_element)
+          type = ext_element.type
+          return nil unless type == "uml:Note"
+
+          props = ext_element.properties
+          Ea::Model::Note.new(
+            id: ext_element.idref,
+            name: ext_element.name,
+            body: props&.documentation,
+            note_type: "Note"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,7 @@ module Ea
             id: id,
             name: attr.name,
             owner_id: owner.id,
+            type_ref: type_ref_for(attr),
             type_name: type_name_for(attr),
             qualified_name: "#{owner.name}::#{attr.name}",
             multiplicity_lower: parse_lower(attr),
@@ -29,6 +30,7 @@ module Ea
             is_ordered: boolean(attr.is_ordered),
             is_unique: boolean(attr.is_unique),
             aggregation: attr.aggregation || "none",
+            association_id: IdNormalizer.from_xmi_id(attr.association),
             visibility: attr.visibility,
             annotations: AnnotationBuilder.from_element(attr, id)
           )
@@ -44,6 +46,13 @@ module Ea
           attr.uml_type&.idref
         end
 
+        def type_ref_for(attr)
+          # XMI <type xmi:idref=...> is the type classifier's GUID.
+          # The adapter's resolve_type_names walks this against the
+          # model to attach the in-model qualified name.
+          attr.uml_type&.idref
+        end
+
         def parse_lower(attr)
           value = attr.lower_value
           return 1 unless value

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