ea 0.4.0 → 0.5.0

data/lib/ea/theme/registry.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Ea
+  module Theme
+    # Central registry for theme Definitions. Lookup by ID returns
+    # a fully configured Definition object. Adding a new theme =
+    # registering it (OCP) — no existing code modified.
+    #
+    # Built-in themes are auto-loaded from `config/themes/*.yml` on
+    # first access.
+    #
+    # Usage:
+    #
+    #   Ea::Theme::Registry.lookup(":119")  # → Definition
+    #   Ea::Theme::Registry.register(my_def)
+    #   Ea::Theme::Registry.all             # → [Definition, ...]
+    #
+    class Registry
+      CONFIG_DIR = File.expand_path("../../../config/themes", __dir__)
+
+      class << self
+        # Returns all registered themes.
+        # @return [Array<Ea::Theme::Definition>]
+        def all
+          themes.values
+        end
+
+        # Look up a theme by ID. Returns the default theme when
+        # the ID is nil, empty, or unknown.
+        #
+        # EA stores theme IDs with a leading colon (":119"). The
+        # lookup normalizes by stripping the colon.
+        #
+        # @param theme_id [String, Symbol, nil] theme identifier
+        # @return [Ea::Theme::Definition]
+        def lookup(theme_id)
+          ensure_loaded
+          return default if theme_id.nil? || theme_id.to_s.empty?
+
+          key = normalize_key(theme_id)
+          @themes[key] || default
+        end
+
+        # Register a new theme. Adding a theme does NOT modify
+        # existing code (OCP).
+        #
+        # @param definition [Ea::Theme::Definition]
+        def register(definition)
+          ensure_loaded
+          @themes[definition.id] = definition
+        end
+
+        # The default theme (no overrides, element-stored values).
+        # @return [Ea::Theme::Definition]
+        def default
+          ensure_loaded
+          @themes["default"]
+        end
+
+        # Load themes from a directory of YAML files. Each .yml
+        # file produces one Definition.
+        # @param dir [String] directory path
+        def load_dir(dir)
+          ensure_loaded
+          Loader.load_dir(dir).each { |d| @themes[d.id] = d }
+        end
+
+        private
+
+        def ensure_loaded
+          return if @loaded
+
+          @themes = {}
+          @loaded = true
+          load_builtin_themes
+        end
+
+        def load_builtin_themes
+          return unless Dir.exist?(CONFIG_DIR)
+
+          Loader.load_dir(CONFIG_DIR).each { |d| @themes[d.id] = d }
+        end
+
+        def normalize_key(theme_id)
+          cleaned = theme_id.to_s.gsub(/^:/, "")
+          cleaned.empty? ? "default" : cleaned
+        end
+
+        def themes
+          ensure_loaded
+          @themes
+        end
+      end
+    end
+  end
+end

data/lib/ea/theme.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ea
+  # Ea::Theme is the domain-level concept of diagram visual themes.
+  #
+  # A Theme bundles the visual style settings that EA applies
+  # uniformly across a diagram: font family, font size, text
+  # color, border color, stroke width, and per-classifier-type
+  # fill colors.
+  #
+  # Themes are looked up by ID from {Registry}. The ID comes from
+  # the diagram's `t_diagram.StyleEx` field (e.g., `Theme=:119`).
+  #
+  # Built-in themes (loaded from `config/themes/*.yml`):
+  #   :default — no overrides, uses element-stored values
+  #   "119"    — Carlito 7pt, gray text, purple-gray borders
+  #
+  # Users can create custom themes:
+  #
+  #   custom = Ea::Theme::Definition.new(
+  #     id: "custom", name: "My Theme",
+  #     font_family: "Arial", font_size: 12,
+  #     text_color: "#000000", border_color: "#333333",
+  #     stroke_width: 1
+  #   )
+  #   diagram.theme = custom
+  #
+  # Or load from a YAML file:
+  #
+  #   Ea::Theme::Registry.load_dir("path/to/themes/")
+  #
+  module Theme
+    autoload :Definition, "ea/theme/definition"
+    autoload :Registry, "ea/theme/registry"
+    autoload :Loader, "ea/theme/loader"
+  end
+end

data/lib/ea/transformations.rb

@@ -1,38 +1,12 @@
 # frozen_string_literal: true
 
 module Ea
+  # Transformations is the legacy entry point for parse and to_uml.
+  # Both methods now delegate directly to Ea::Qea, Ea::Xmi, and
+  # Ea::Bridge — the per-format parsers and the UML bridge are
+  # reached without an intermediate engine layer.
   module Transformations
-    autoload :Configuration, "ea/transformations/configuration"
-    autoload :FormatRegistry, "ea/transformations/format_registry"
-    autoload :TransformationEngine, "ea/transformations/transformation_engine"
-
-    module Parsers
-      autoload :BaseParser, "ea/transformations/parsers/base_parser"
-      autoload :XmiParser, "ea/transformations/parsers/xmi_parser"
-      autoload :QeaParser, "ea/transformations/parsers/qea_parser"
-    end
-
-    # Resolve a class name string to a constant
-    # @param class_name [String] Fully qualified class name (e.g. "Ea::Foo::Bar")
-    # @return [Class, nil] The resolved class constant, or nil if not found
-    def self.constantize(class_name)
-      parts = class_name.split("::")
-      constant = Object
-      parts.each { |part| constant = constant.const_get(part) }
-      constant
-    rescue NameError
-      nil
-    end
-
     class << self
-      def engine
-        @engine ||= TransformationEngine.new
-      end
-
-      def engine=(engine)
-        @engine = engine
-      end
-
       # Parse an EA file into its native representation.
       #
       # Pure entry point — does NOT require `lutaml-uml`. Returns:
@@ -40,10 +14,6 @@ module Ea
       #   .xmi → Xmi::Sparx::Root
       #
       # To get a Lutaml::Uml::Document instead, use {to_uml}.
-      #
-      # @param file_path [String] path to a .qea or .xmi file
-      # @param options [Hash] parser options (e.g. config: for QEA)
-      # @return [Ea::Qea::Database, Xmi::Sparx::Root]
       def parse(file_path, options = {})
         ext = File.extname(file_path).downcase
         case ext
@@ -62,17 +32,8 @@ module Ea
       # `Lutaml::Uml::Document`.
       #
       # Bridge entry point — requires the optional `lutaml-uml` gem.
-      # Lazy-loads the bridge code on first call.
-      #
-      # @param path_or_model [String, Ea::Qea::Database, Xmi::Sparx::Root]
-      # @param options [Hash] transformation options
-      # @return [Lutaml::Uml::Document]
       def to_uml(path_or_model, options = {})
-        model = if path_or_model.is_a?(String)
-                  parse(path_or_model, options)
-                else
-                  path_or_model
-                end
+        model = path_or_model.is_a?(String) ? parse(path_or_model, options) : path_or_model
 
         case model
         when Ea::Qea::Database
@@ -85,50 +46,6 @@ module Ea
                 "Expected Ea::Qea::Database or Xmi::Sparx::Root."
         end
       end
-
-      def detect_parser(file_path)
-        engine.detect_parser(file_path)
-      end
-
-      def supported_extensions
-        engine.supported_extensions
-      end
-
-      def supports_file?(file_path)
-        engine.supports_file?(file_path)
-      end
-
-      def statistics
-        engine.statistics
-      end
-
-      def reset_statistics
-        engine.clear_history
-      end
-
-      def validate_setup
-        engine.validate_setup
-      end
-
-      def register_parser(extension, parser_class)
-        engine.register_parser(extension, parser_class)
-      end
-
-      def load_configuration(config_path)
-        engine.configuration = Configuration.load(config_path)
-      end
-
-      def configuration
-        engine.configuration
-      end
-
-      def configuration=(config)
-        engine.configuration = config
-      end
-
-      def configure
-        yield(configuration) if block_given?
-      end
     end
   end
 end

data/lib/ea/version.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
 module Ea
-  VERSION = "0.4.0"
+  # Gem release version. Extracted to its own file so the
+  # `gem-release` tool's `gem bump` can find and update it via the
+  # standard `lib/<gem>/version.rb` convention.
+  VERSION = "0.5.0"
 end

data/lib/ea.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-# Load VERSION constant (defined in ea/version.rb per gemspec/gem-release
-# convention). Use require_relative to avoid load-path dependencies during
-# gemspec evaluation.
-require_relative "ea/version"
+# Version file. Required eagerly (not autoloaded) because gem-release
+# and the gemspec both expect VERSION to resolve on first load. See
+# lib/ea/version.rb.
+require "ea/version"
 
 module Ea
   class Error < StandardError; end
@@ -13,12 +13,22 @@ module Ea
   autoload :Sources, "ea/sources"
   autoload :Spa, "ea/spa"
   autoload :Svg, "ea/svg"
+  autoload :Theme, "ea/theme"
   autoload :Diagram, "ea/diagram"
   autoload :Transformations, "ea/transformations"
   autoload :Xmi, "ea/xmi"
   autoload :Transformers, "ea/transformers"
   autoload :Bridge, "ea/bridge"
   autoload :Cli, "ea/cli"
+  autoload :Mdg, "ea/mdg"
+  autoload :Diff, "ea/diff"
+  autoload :Image, "ea/image"
+  autoload :Export, "ea/export"
+  autoload :Render, "ea/render"
+  autoload :Shapescript, "ea/shapescript"
+  autoload :Lint, "ea/lint"
+  autoload :Query, "ea/query"
+  autoload :Ocl, "ea/ocl"
 
   class << self
     # Parse an EA file into its native representation.

data/lib/tasks/svg_bench.rake

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "ea"
+require "ea/svg/parity"
+
+namespace :svg do
+  desc "Score rendered SVG against EA reference SVGs (SOURCE.xmi or .qea + REF_DIR)"
+  task :bench, %i[source ref_dir tolerance] do |_t, args|
+    source = args[:source] || ENV["EA_BENCH_SOURCE"] ||
+             File.expand_path("~/src/mn/mn-samples-plateau/sources/xmi/plateau_all_packages_export.xmi")
+    ref_dir = args[:ref_dir] || ENV["EA_BENCH_REF_DIR"] ||
+              File.expand_path("~/src/mn/mn-samples-plateau/sources/001-mds/xmi-images")
+    tolerance = (args[:tolerance] || ENV["EA_BENCH_TOLERANCE"] || "5").to_i
+
+    abort "source not found: #{source}" unless File.exist?(source)
+    abort "ref_dir not found: #{ref_dir}" unless Dir.exist?(ref_dir)
+
+    doc = Ea::Svg::Parity::Source.new(source).load
+    suite = Ea::Svg::Parity::Suite.new(doc, ref_dir).measure
+    agg = suite.aggregate_shape_counts
+
+    puts "Source: #{source}"
+    puts "Refs:   #{ref_dir}"
+    puts "Diagrams: #{suite.total} (matched: #{suite.matched(shape_tolerance: tolerance)})"
+    %i[rect path polygon text].each do |k|
+      o = agg[:ours][k]
+      r = agg[:reference][k]
+      d = o - r
+      pct = r.zero? ? 0.0 : (d.to_f / r * 100).round(1)
+      puts "  #{k.to_s.ljust(7)} ours=#{o.to_s.rjust(6)} ref=#{r.to_s.rjust(6)} delta=#{d.to_s.rjust(5)} (#{pct}%)"
+    end
+    puts "Text overlap avg: #{(suite.text_overlap_avg * 100).round(1)}%"
+
+    outliers = suite.outliers(shape_tolerance: tolerance)
+    unless outliers.empty?
+      puts "\nOutliers (#{outliers.size}):"
+      outliers.first(20).each do |dr|
+        r = dr.report
+        puts "  #{dr.id} (#{dr.name}): shape_delta=#{r.shape_delta_total} text=#{r.text_delta}"
+      end
+    end
+  end
+
+  desc "Bench every example QEA in examples/qea against its exports/Images"
+  task :examples do
+    project_root = File.expand_path("../..", __dir__)
+    qea_dir = File.join(project_root, "examples", "qea")
+    exports_dir = File.join(project_root, "examples", "exports")
+
+    abort "examples/qea not found at #{qea_dir}" unless Dir.exist?(qea_dir)
+
+    Dir.glob("#{qea_dir}/*.qea").sort.each do |qea_path|
+      name = File.basename(qea_path, ".qea")
+      # Strip version suffixes like ".1" from names like
+      # "20251010_current_plateau_v5.1" to match the exports
+      # directory "20251010_current_plateau_v5".
+      stripped_name = name.sub(/\.\d+$/, "")
+      # Reference images live in examples/exports/<name>/images or Images
+      candidates = [
+        File.join(exports_dir, name, "images"),
+        File.join(exports_dir, name, "Images"),
+        File.join(exports_dir, stripped_name, "images"),
+        File.join(exports_dir, stripped_name, "Images")
+      ]
+      ref_dir = candidates.find { |p| Dir.exist?(p) }
+      if ref_dir.nil?
+        puts "#{name}: SKIP (no exports/images directory)"
+        next
+      end
+
+      doc = Ea::Sources::Qea::Adapter.from_path(qea_path)
+      suite = Ea::Svg::Parity::Suite.new(doc, ref_dir).measure
+      agg = suite.aggregate_shape_counts
+
+      matched = suite.matched(shape_tolerance: 5)
+      puts "#{name.ljust(40)} #{matched}/#{suite.total} matched"
+      %i[rect path polygon text].each do |k|
+        o = agg[:ours][k]
+        r = agg[:reference][k]
+        d = o - r
+        pct = r.zero? ? 0.0 : (d.to_f / r * 100).round(1)
+        puts "  #{k.to_s.ljust(7)} ours=#{o.to_s.rjust(5)} ref=#{r.to_s.rjust(5)} delta=#{d.to_s.rjust(5)} (#{pct}%)"
+      end
+      puts ""
+    end
+  end
+end