ea 0.3.1 → 0.5.0

data/lib/ea/svg/parity/checker.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module Ea
+  module Svg
+    module Parity
+      # Compares an emitted SVG against one EA reference SVG across
+      # element counts, font-family, viewBox, and text overlap.
+      class Checker
+        ELEMENT_TYPES = %i[rect path polygon text group].freeze
+
+        attr_reader :ours, :reference
+
+        def initialize(ours:, reference:)
+          @ours = ours
+          @reference = reference
+        end
+
+        def report
+          Report.new(
+            rect: count_diff("rect"),
+            path: count_diff("path"),
+            polygon: count_diff("polygon"),
+            text: count_diff("text"),
+            group: top_level_group_diff,
+            font_family: font_family_match,
+            view_box: view_box_match,
+            text_overlap: text_overlap_ratio
+          )
+        end
+
+        private
+
+        def our_doc
+          @our_doc ||= Nokogiri::XML(@ours)
+        end
+
+        def ref_doc
+          @ref_doc ||= Nokogiri::XML(@reference)
+        end
+
+        def count_diff(selector)
+          Diff.new(ours: our_doc.css(selector).size,
+                   reference: ref_doc.css(selector).size)
+        end
+
+        def top_level_group_diff
+          Diff.new(ours: our_doc.css("svg > g").size,
+                   reference: ref_doc.css("svg > g").size)
+        end
+
+        def font_family_match
+          our_family = first_text_style(our_doc)[/font-family:([^;]+)/, 1]
+          ref_family = first_text_style(ref_doc)[/font-family:([^;]+)/, 1]
+          our_family == ref_family
+        end
+
+        def view_box_match
+          our_doc.root["viewBox"] == ref_doc.root["viewBox"]
+        end
+
+        def text_overlap_ratio
+          our_set = our_doc.css("text").map(&:text).map(&:strip).to_set
+          ref_set = ref_doc.css("text").map(&:text).map(&:strip).to_set
+          return 1.0 if our_set.empty? && ref_set.empty?
+          return 0.0 if our_set.empty? || ref_set.empty?
+
+          (our_set & ref_set).size.to_f / (our_set | ref_set).size.to_f
+        end
+
+        def first_text_style(doc)
+          first = doc.css("text").first
+          first ? (first["style"] || "") : ""
+        end
+
+        Diff = Struct.new(:ours, :reference, keyword_init: true) do
+          def delta
+            ours - reference
+          end
+
+          def within?(tolerance)
+            delta.abs <= tolerance
+          end
+        end
+
+        Report = Struct.new(:rect, :path, :polygon, :text, :group,
+                            :font_family, :view_box, :text_overlap,
+                            keyword_init: true) do
+          def shape_delta_total
+            [rect, path, polygon].sum(&:delta).abs
+          end
+
+          def text_delta
+            text.delta
+          end
+
+          def shape_within?(tolerance)
+            [rect, path, polygon].all? { |d| d.within?(tolerance) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/parity/source.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "ea"
+require "xmi"
+require "ea/sources/xmi/adapter"
+
+module Ea
+  module Svg
+    module Parity
+      # Loads an EA model Document from any supported source file
+      # (`.qea`, `.xmi`). Used by the bench task to keep file-format
+      # dispatch in one place.
+      class Source
+        EXTENSIONS = {
+          ".qea" => :qea,
+          ".xmi" => :xmi
+        }.freeze
+
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def self.detect(path)
+          ext = File.extname(path).downcase
+          EXTENSIONS[ext] ||
+            raise(ArgumentError, "unsupported source: #{path} (ext=#{ext})")
+        end
+
+        def load
+          case self.class.detect(path)
+          when :qea then load_qea
+          when :xmi then load_xmi
+          end
+        end
+
+        def document
+          load
+        end
+
+        def format
+          self.class.detect(path)
+        end
+
+        private
+
+        def load_qea
+          raise NotImplementedError, "QEA Document loading not yet wired into bench"
+        end
+
+        def load_xmi
+          root = ::Xmi::Sparx::Root.parse_xml(File.read(path))
+          Ea::Sources::Xmi::Adapter.new(root, path).to_document
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/parity/suite.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "ea/svg/parity/checker"
+
+module Ea
+  module Svg
+    module Parity
+      # Drives Parity::Checker across every diagram in a Document
+      # that has a matching reference SVG. Drives from any source
+      # the Document supports (qea or xmi) since the Document is
+      # format-agnostic.
+      class Suite
+        ELEMENT_TYPES = %i[rect polygon path text].freeze
+
+        attr_reader :document, :ref_dir
+
+        def initialize(document, ref_dir)
+          @document = document
+          @ref_dir = ref_dir
+        end
+
+        def measure
+          per_diagram = diagrams_with_references.map { |d| measure_one(d) }
+          Report.new(per_diagram: per_diagram)
+        end
+
+        private
+
+        def diagrams_with_references
+          document.diagrams.select { |d| reference_path_for(d) }
+        end
+
+        def reference_path_for(diagram)
+          # XMI sources already use the EAID_... filename. QEA
+          # sources use the GUID form ("F4C23F9E-..."); try both.
+          paths = [
+            File.join(ref_dir, "#{diagram.id}.svg"),
+            File.join(ref_dir, "#{Ea::Sources::Qea::IdNormalizer.to_eaid(diagram.id)}.svg")
+          ]
+          paths.find { |p| File.exist?(p) }
+        end
+
+        def measure_one(diagram)
+          ref_path = reference_path_for(diagram)
+          ours = Ea::Svg::EaEmitter::Document.new(diagram,
+                                                  model_index: document.index_by_id,
+                                                  document: document).render
+          reference = File.read(ref_path)
+          checker = Checker.new(ours: ours, reference: reference)
+          DiagramReport.new(diagram: diagram, report: checker.report)
+        end
+
+        DiagramReport = Struct.new(:diagram, :report, keyword_init: true) do
+          def id
+            diagram.id
+          end
+
+          def name
+            diagram.name
+          end
+
+          def type
+            diagram.diagram_type
+          end
+        end
+
+        class Report
+          attr_reader :per_diagram
+
+          def initialize(per_diagram:)
+            @per_diagram = per_diagram
+          end
+
+          def total
+            per_diagram.size
+          end
+
+          def matched(shape_tolerance: 5)
+            per_diagram.count { |dr| dr.report.shape_delta_total <= shape_tolerance }
+          end
+
+          def aggregate_shape_counts
+            ours = { rect: 0, polygon: 0, path: 0, text: 0 }
+            ref = { rect: 0, polygon: 0, path: 0, text: 0 }
+            per_diagram.each do |dr|
+              ours[:rect] += dr.report.rect.ours
+              ours[:polygon] += dr.report.polygon.ours
+              ours[:path] += dr.report.path.ours
+              ours[:text] += dr.report.text.ours
+              ref[:rect] += dr.report.rect.reference
+              ref[:polygon] += dr.report.polygon.reference
+              ref[:path] += dr.report.path.reference
+              ref[:text] += dr.report.text.reference
+            end
+            { ours: ours, reference: ref }
+          end
+
+          def text_overlap_avg
+            return 0.0 if per_diagram.empty?
+
+            overlaps = per_diagram.map(&:report).map(&:text_overlap)
+            overlaps.sum / overlaps.size.to_f
+          end
+
+          def outliers(shape_tolerance: 5)
+            per_diagram.select { |dr| dr.report.shape_delta_total > shape_tolerance }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/svg/parity.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ea
+  module Svg
+    # Render-fidelity measurement. Compares emitted SVG against
+    # EA-produced reference SVGs so parity can be scored on any
+    # source format (.qea or .xmi) from specs or a rake task.
+    module Parity
+      autoload :Checker, "ea/svg/parity/checker"
+      autoload :Suite, "ea/svg/parity/suite"
+      autoload :Source, "ea/svg/parity/source"
+    end
+  end
+end

data/lib/ea/svg/stereotype_color_resolver.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Ea
+  module Svg
+    # Resolves a classifier's stereotype to a fill color. Looks up
+    # a YAML config (config/stereotype_colors.yml) by lowercase
+    # stereotype name. Falls back to a default white when no match.
+    #
+    # Loading the YAML is memoized at the class level via a
+    # class instance variable accessor method (no instance_variable_set).
+    class StereotypeColorResolver
+      DEFAULT_FILL = "#FFFFFF"
+      DEFAULT_CONFIG_PATH = File.expand_path("../../../config/stereotype_colors.yml", __dir__)
+
+      class << self
+        # Memoize the loaded default map. Re-reading from disk is
+        # expensive; load once per process.
+        def default_map
+          @default_map ||= load_yaml(DEFAULT_CONFIG_PATH)
+        end
+
+        # Test hook: clear the memo to force a reload.
+        def reset_default_map
+          @default_map = nil
+        end
+
+        def load_yaml(path)
+          return {} unless File.exist?(path)
+
+          YAML.safe_load(File.read(path)) || {}
+        end
+      end
+
+      attr_reader :color_map, :default
+
+      def initialize(color_map: self.class.default_map, default: DEFAULT_FILL)
+        @color_map = color_map
+        @default = default
+      end
+
+      def fill_for(stereotype_name)
+        return default if stereotype_name.nil? || stereotype_name.empty?
+
+        color_map[stereotype_name.downcase] || default
+      end
+    end
+  end
+end

data/lib/ea/svg.rb

@@ -1,21 +1,10 @@
 # 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"
+    autoload :StereotypeColorResolver, "ea/svg/stereotype_color_resolver"
+    autoload :ConnectorRouter, "ea/svg/connector_router"
+    autoload :EaEmitter, "ea/svg/ea_emitter"
+    autoload :Parity, "ea/svg/parity"
   end
 end

data/lib/ea/theme/definition.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Ea
+  module Theme
+    # Immutable value object describing a complete EA diagram theme.
+    #
+    # Bundles ALL appearance values that EA's SVG renderer needs:
+    # fonts, colors, strokes, canvas insets, compartment spacing,
+    # marker geometry, etc. No renderer hardcodes appearance
+    # numbers — every value comes from the active Definition.
+    class Definition
+      Geometry = Struct.new(:inset_left, :inset_right, :inset_top, :inset_bottom,
+                             keyword_init: true)
+      FrameSpec = Struct.new(:inset, :tab_height, :tab_slant, :tab_label_x,
+                              :tab_label_y, :tab_padding, keyword_init: true)
+      CompartmentSpec = Struct.new(:header_top_padding, :header_line_offset,
+                                    :divider_offset, :attr_line_offset,
+                                    :attr_first_offset, :op_line_offset,
+                                    keyword_init: true)
+      AttrSpec = Struct.new(:visibility_x_offset, :content_x_offset, keyword_init: true)
+      MarkerSpec = Struct.new(:diamond_half_width, :diamond_half_height,
+                               :triangle_half_base, :triangle_height,
+                               :arrow_half_base, :arrow_height, keyword_init: true)
+      PackageSpec = Struct.new(:tab_height, :tab_label_padding, :default_tab_width,
+                                keyword_init: true)
+      NoteSpec = Struct.new(:fold_size, :text_x_offset, :text_y_offset,
+                             :line_height, keyword_init: true)
+
+      attr_reader :id, :name,
+                  :font_family, :font_size, :font_size_unit,
+                  :text_weight_normal, :text_weight_bold,
+                  :element_font_size, :element_font_unit,
+                  :text_color, :attribute_text_color, :method_text_color,
+                  :border_color, :fill_color, :background_color,
+                  :stroke_in_text_color,
+                  :element_border_width, :connector_line_width,
+                  :divider_stroke_width, :marker_stroke_width,
+                  :text_width_factor,
+                  :geometry, :frame, :compartments, :attribute_spec,
+                  :markers, :package, :note, :fills
+
+      DEFAULT_GEOMETRY = Geometry.new(inset_left: 35, inset_right: 50,
+                                       inset_top: 40, inset_bottom: 57).freeze
+      DEFAULT_FRAME = FrameSpec.new(inset: 6, tab_height: 20, tab_slant: 13,
+                                     tab_label_x: 11, tab_label_y: 19,
+                                     tab_padding: 7).freeze
+      DEFAULT_COMPARTMENTS = CompartmentSpec.new(header_top_padding: 9,
+                                                   header_line_offset: 6,
+                                                   divider_offset: 8,
+                                                   attr_line_offset: 4,
+                                                   attr_first_offset: 7,
+                                                   op_line_offset: 4).freeze
+      DEFAULT_ATTR = AttrSpec.new(visibility_x_offset: 5,
+                                    content_x_offset: 20).freeze
+      DEFAULT_MARKERS = MarkerSpec.new(diamond_half_width: 5,
+                                         diamond_half_height: 10,
+                                         triangle_half_base: 6,
+                                         triangle_height: 11,
+                                         arrow_half_base: 6,
+                                         arrow_height: 11).freeze
+      DEFAULT_PACKAGE = PackageSpec.new(tab_height: 20,
+                                          tab_label_padding: 10,
+                                          default_tab_width: 105).freeze
+      DEFAULT_NOTE = NoteSpec.new(fold_size: 12, text_x_offset: 5,
+                                    text_y_offset: 12, line_height: 12).freeze
+
+      def initialize(id:, name: nil, font_family: nil, font_size: nil,
+                     font_size_unit: "pt", text_weight_normal: 400,
+                     text_weight_bold: 700,
+                     element_font_size: 9, element_font_unit: "pt",
+                     text_color: "#000000", attribute_text_color: nil,
+                     method_text_color: nil, border_color: "#000000",
+                     fill_color: "#FFFFFF", background_color: "#FFFFFF",
+                     stroke_in_text_color: "#000000",
+                     element_border_width: 2, connector_line_width: 2,
+                     divider_stroke_width: 2, marker_stroke_width: 2,
+                     text_width_factor: 0.65,
+                     geometry: nil, frame: nil, compartments: nil,
+                     attribute_spec: nil, markers: nil, package: nil,
+                     note: nil, fills: {})
+        @id = id.to_s
+        @name = name
+        @font_family = font_family
+        @font_size = font_size
+        @font_size_unit = font_size_unit
+        @text_weight_normal = text_weight_normal
+        @text_weight_bold = text_weight_bold
+        @element_font_size = element_font_size
+        @element_font_unit = element_font_unit
+        @text_color = text_color
+        @attribute_text_color = attribute_text_color
+        @method_text_color = method_text_color
+        @border_color = border_color
+        @fill_color = fill_color
+        @background_color = background_color
+        @stroke_in_text_color = stroke_in_text_color
+        @element_border_width = element_border_width
+        @connector_line_width = connector_line_width
+        @divider_stroke_width = divider_stroke_width
+        @marker_stroke_width = marker_stroke_width
+        @text_width_factor = text_width_factor
+        @geometry = geometry || DEFAULT_GEOMETRY.dup
+        @frame = frame || DEFAULT_FRAME.dup
+        @compartments = compartments || DEFAULT_COMPARTMENTS.dup
+        @attribute_spec = attribute_spec || DEFAULT_ATTR.dup
+        @markers = markers || DEFAULT_MARKERS.dup
+        @package = package || DEFAULT_PACKAGE.dup
+        @note = note || DEFAULT_NOTE.dup
+        @fills = fills.dup.freeze
+      end
+
+      def themed?
+        id != "default"
+      end
+
+      def fill_for(classifier)
+        return nil if classifier.nil?
+
+        fills[classifier.class.name]
+      end
+
+      def with(**overrides)
+        Definition.new(**to_h.merge(overrides))
+      end
+
+      def ==(other)
+        other.is_a?(Definition) && id == other.id
+      end
+
+      def hash
+        id.hash
+      end
+
+      alias eql? ==
+
+      # Backward-compatible aliases for renamed attributes.
+      def stroke_width
+        element_border_width
+      end
+
+      def attribute_color
+        attribute_text_color
+      end
+
+      def method_color
+        method_text_color
+      end
+
+      def to_h
+        {
+          id: id, name: name,
+          font_family: font_family, font_size: font_size,
+          font_size_unit: font_size_unit,
+          text_weight_normal: text_weight_normal,
+          text_weight_bold: text_weight_bold,
+          element_font_size: element_font_size,
+          element_font_unit: element_font_unit,
+          text_color: text_color,
+          attribute_text_color: attribute_text_color,
+          method_text_color: method_text_color,
+          border_color: border_color, fill_color: fill_color,
+          background_color: background_color,
+          stroke_in_text_color: stroke_in_text_color,
+          element_border_width: element_border_width,
+          connector_line_width: connector_line_width,
+          divider_stroke_width: divider_stroke_width,
+          marker_stroke_width: marker_stroke_width,
+          text_width_factor: text_width_factor,
+          geometry: geometry, frame: frame, compartments: compartments,
+          attribute_spec: attribute_spec, markers: markers,
+          package: package, note: note, fills: fills
+        }
+      end
+    end
+  end
+end

data/lib/ea/theme/loader.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Ea
+  module Theme
+    # Loads theme Definition objects from YAML files.
+    #
+    # YAML format (see config/themes/119.yml):
+    #
+    #   id: "119"
+    #   name: EA White Theme
+    #   font: { family: Carlito, size: 7, unit: pt, weight_normal: 400, ... }
+    #   element_font: { size: 9, unit: pt }
+    #   colors: { text: "#000000", attribute_text: "#66413F", ... }
+    #   strokes: { element_border: 2, connector_line: 2, ... }
+    #   text_metrics: { width_factor: 0.65 }
+    #   canvas: { inset_left: 35, inset_right: 50, ... }
+    #   frame: { inset: 6, tab_height: 20, ... }
+    #   compartments: { header_line_offset: 4, ... }
+    #   attribute: { visibility_x_offset: 5, content_x_offset: 20 }
+    #   markers: { diamond_half_width: 5, ... }
+    #   package: { tab_height: 20, ... }
+    #   note: { fold_size: 12, ... }
+    #   fills: {}
+    #
+    class Loader
+      class << self
+        def load_file(path)
+          data = YAML.load_file(path)
+          from_hash(data)
+        end
+
+        def load_dir(dir)
+          Dir.glob(File.join(dir, "*.yml")).map { |f| load_file(f) }
+        end
+
+        private
+
+        def from_hash(data)
+          font = data["font"] || {}
+          elem_font = data["element_font"] || {}
+          colors = data["colors"] || {}
+          strokes = data["strokes"] || {}
+          text_metrics = data["text_metrics"] || {}
+          canvas = data["canvas"] || {}
+          frame = data["frame"] || {}
+          comps = data["compartments"] || {}
+          attr_cfg = data["attribute"] || {}
+          marker_cfg = data["markers"] || {}
+          pkg_cfg = data["package"] || {}
+          note_cfg = data["note"] || {}
+
+          Definition.new(
+            id: data["id"],
+            name: data["name"],
+            font_family: font["family"],
+            font_size: font["size"],
+            font_size_unit: font["unit"] || "pt",
+            text_weight_normal: font["weight_normal"] || 400,
+            text_weight_bold: font["weight_bold"] || 700,
+            element_font_size: elem_font["size"] || 9,
+            element_font_unit: elem_font["unit"] || "pt",
+            text_color: colors["text"] || "#000000",
+            attribute_text_color: colors["attribute_text"],
+            method_text_color: colors["method_text"],
+            border_color: colors["border"] || "#000000",
+            fill_color: colors["fill"] || "#FFFFFF",
+            background_color: colors["background"] || "#FFFFFF",
+            stroke_in_text_color: colors["stroke_in_text"] || "#000000",
+            element_border_width: strokes["element_border"] || 2,
+            connector_line_width: strokes["connector_line"] || 2,
+            divider_stroke_width: strokes["divider"] || 2,
+            marker_stroke_width: strokes["marker"] || 2,
+            text_width_factor: text_metrics["width_factor"] || 0.65,
+            geometry: canvas.empty? ? nil : Definition::Geometry.new(
+              inset_left: canvas["inset_left"] || 35,
+              inset_right: canvas["inset_right"] || 50,
+              inset_top: canvas["inset_top"] || 40,
+              inset_bottom: canvas["inset_bottom"] || 57
+            ),
+            frame: frame.empty? ? nil : Definition::FrameSpec.new(
+              inset: frame["inset"] || 6,
+              tab_height: frame["tab_height"] || 20,
+              tab_slant: frame["tab_slant"] || 13,
+              tab_label_x: frame["tab_label_x"] || 11,
+              tab_label_y: frame["tab_label_y"] || 19,
+              tab_padding: frame["tab_padding"] || 7
+            ),
+            compartments: comps.empty? ? nil : Definition::CompartmentSpec.new(
+              header_top_padding: comps["header_top_padding"] || 9,
+              header_line_offset: comps["header_line_offset"] || 6,
+              divider_offset: comps["divider_offset"] || 8,
+              attr_line_offset: comps["attr_line_offset"] || 4,
+              attr_first_offset: comps["attr_first_offset"] || 7,
+              op_line_offset: comps["op_line_offset"] || 4
+            ),
+            attribute_spec: attr_cfg.empty? ? nil : Definition::AttrSpec.new(
+              visibility_x_offset: attr_cfg["visibility_x_offset"] || 5,
+              content_x_offset: attr_cfg["content_x_offset"] || 26
+            ),
+            markers: marker_cfg.empty? ? nil : Definition::MarkerSpec.new(
+              diamond_half_width: marker_cfg["diamond_half_width"] || 5,
+              diamond_half_height: marker_cfg["diamond_half_height"] || 10,
+              triangle_half_base: marker_cfg["triangle_half_base"] || 6,
+              triangle_height: marker_cfg["triangle_height"] || 11,
+              arrow_half_base: marker_cfg["arrow_half_base"] || 6,
+              arrow_height: marker_cfg["arrow_height"] || 11
+            ),
+            package: pkg_cfg.empty? ? nil : Definition::PackageSpec.new(
+              tab_height: pkg_cfg["tab_height"] || 20,
+              tab_label_padding: pkg_cfg["tab_label_padding"] || 10,
+              default_tab_width: pkg_cfg["default_tab_width"] || 105
+            ),
+            note: note_cfg.empty? ? nil : Definition::NoteSpec.new(
+              fold_size: note_cfg["fold_size"] || 12,
+              text_x_offset: note_cfg["text_x_offset"] || 5,
+              text_y_offset: note_cfg["text_y_offset"] || 12,
+              line_height: note_cfg["line_height"] || 12
+            ),
+            fills: data["fills"] || {}
+          )
+        end
+      end
+    end
+  end
+end