ea 0.1.0 → 0.1.4

data/lib/ea/cli/output/yaml_formatter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Ea
+  module Cli
+    module Output
+      class YamlFormatter < Formatter
+        def render(rows, columns: [])
+          data = rows.map do |row|
+            normalize_row(row, columns)
+          end
+          puts data.to_yaml
+        end
+      end
+    end
+  end
+end
+
+Ea::Cli::Output.register(:yaml, Ea::Cli::Output::YamlFormatter)

data/lib/ea/cli/output.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Ea
+  module Cli
+    # Output formatters for the CLI. Each formatter self-registers via
+    # `Ea::Cli::Output.register(:name, Class)` at file-load time. Lookup via
+    # `Ea::Cli::Output.for(:name)` triggers autoloads on first access.
+    module Output
+      autoload :Formatter, "ea/cli/output/formatter"
+      autoload :TableFormatter, "ea/cli/output/table_formatter"
+      autoload :JsonFormatter, "ea/cli/output/json_formatter"
+      autoload :YamlFormatter, "ea/cli/output/yaml_formatter"
+
+      @formatters = {}
+      @formatters_loaded = false
+
+      class << self
+        def register(name, klass)
+          @formatters[name.to_sym] = klass
+        end
+
+        def for(name)
+          ensure_formatters_loaded
+          klass = @formatters[name.to_sym]
+          klass ||
+            raise(ArgumentError,
+                  "No output formatter '#{name}'. " \
+                  "Registered: #{@formatters.keys.join(', ')}")
+        end
+
+        # Convenience: returns a fresh formatter instance for `name`.
+        def instance_for(name)
+          self.for(name).new
+        end
+
+        def registered_formats
+          ensure_formatters_loaded
+          @formatters.keys
+        end
+
+        private
+
+        # Trigger autoload of each known formatter so its self-register
+        # block runs. Referencing the constant is enough.
+        def ensure_formatters_loaded
+          return if @formatters_loaded
+
+          TableFormatter
+          JsonFormatter
+          YamlFormatter
+          @formatters_loaded = true
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ea
+  module Cli
+    autoload :App, "ea/cli/app"
+    autoload :Command, "ea/cli/command"
+    autoload :Output, "ea/cli/output"
+
+    # All error classes live in ea/cli/error.rb — declare each so any
+    # reference (not just Ea::Cli::Error) triggers the autoload.
+    autoload :Error, "ea/cli/error"
+    autoload :FileNotFound, "ea/cli/error"
+    autoload :UnsupportedFormat, "ea/cli/error"
+    autoload :MissingUmlDependency, "ea/cli/error"
+    autoload :UnknownAction, "ea/cli/error"
+  end
+end

data/lib/ea/diagram/configuration.rb

@@ -0,0 +1,379 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Ea
+  module Diagram
+    # Configuration management for diagram styling
+    #
+    # This class provides hierarchical style resolution with the
+    # following priority:
+    # 1. EA Data (QEA/XMI) - Highest priority
+    # 2. Class-specific overrides (user config)
+    # 3. Package-based styling (wildcard support)
+    # 4. Stereotype-based styling
+    # 5. Global defaults - Lowest priority
+    #
+    # @example
+    #   config = Configuration.new("config/diagram_styles.yml")
+    #   fill_color = config.style_for(element, "colors.fill")
+    #   font_family = config.style_for(element, "fonts.class_name.family")
+    class Configuration
+      attr_reader :config_data
+
+      # Default configuration file paths in order of preference
+      DEFAULT_CONFIG_PATHS = [
+        "config/diagram_styles.yml",
+        File.expand_path("~/.lutaml/diagram_styles.yml"),
+      ].freeze
+
+      # Initialize configuration with optional custom path
+      #
+      # @param config_path [String, nil] Path to custom configuration file
+      def initialize(config_path = nil)
+        @config_data = load_configuration(config_path)
+      end
+
+      # Get style for a specific element
+      #
+      # @param element [Lutaml::Uml::TopElement, Object] UML element
+      # @param property [String] Style property path (e.g., "colors.fill")
+      # @return [Object] Style value
+      def style_for(element, property) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        return nil if property.nil? || property.empty?
+
+        # Priority: Class-specific > Package > Stereotype > Defaults
+        value = nil
+
+        # 1. Try class-specific override (highest priority)
+        if element.is_a?(Lutaml::Uml::TopElement) && element.name
+          class_config = dig_config("classes.#{element.name}.#{property}")
+          value = class_config if class_config
+        end
+
+        # 2. Try package-based styling
+        if !value &&
+            element.is_a?(Lutaml::Uml::Diagram) && element.package_name
+          # Support wildcards: "CityGML::*"
+          package_configs = config_data["packages"] || {}
+          package_configs.each do |pattern, pkg_config|
+            if matches_package?(element.package_name, pattern)
+              pkg_value = dig_hash(pkg_config, property)
+              value = pkg_value if pkg_value
+              break
+            end
+          end
+        end
+
+        # 3. Try stereotype-based styling
+        if !value && element.is_a?(Lutaml::Uml::TopElement) && element.stereotype
+          stereotypes = Array(element.stereotype)
+          stereotypes.each do |stereo|
+            stereo_value = dig_config("stereotypes.#{stereo}.#{property}")
+            if stereo_value
+              value = stereo_value
+              break
+            end
+          end
+        end
+
+        # 4. Fall back to defaults (lowest priority)
+        # Handle property name aliases
+        # (e.g., "colors.fill" -> "colors.default_fill")
+        unless value
+          value = dig_config("defaults.#{property}")
+
+          # If not found, try with "default_" prefix for certain properties
+          unless value
+            if property.start_with?("colors.fill")
+              value = dig_config("defaults.colors.default_fill")
+            elsif property.start_with?("colors.stroke") &&
+                !property.include?("stroke_")
+              value = dig_config("defaults.colors.default_stroke")
+            end
+          end
+        end
+
+        value
+      end
+
+      # Get connector style
+      #
+      # @param connector_type [String]
+      # Type of connector (generalization, association, etc.)
+      # @param property [String] Style property path
+      # @return [Object] Style value
+      def connector_style(connector_type, property)
+        dig_config("connectors.#{connector_type}.#{property}")
+      end
+
+      # Get legend configuration
+      #
+      # @return [Hash] Legend configuration
+      def legend_config
+        config_data["legend"] || {}
+      end
+
+      # Get the entire configuration data
+      #
+      # @return [Hash] Complete configuration data
+      def to_h
+        config_data
+      end
+
+      # Navigate hash using dot notation
+      #
+      # @param hash [Hash] Hash to navigate
+      # @param path [String] Path with dot notation
+      # @return [Object] Value at path
+      def dig_hash(hash, path) # rubocop:disable Metrics/CyclomaticComplexity
+        return nil if path.nil? || path.empty?
+        return nil unless hash.is_a?(Hash)
+
+        keys = path.split(".")
+        return nil if keys.empty?
+
+        keys.reduce(hash) do |h, key|
+          return nil unless h.is_a?(Hash)
+
+          h[key]
+        end
+      end
+
+      # Check if package name matches pattern (supports wildcards)
+      #
+      # @param package_name [String] Package name to test
+      # @param pattern [String] Pattern with wildcards (e.g., "CityGML::*")
+      # @return [Boolean] True if matches
+      def matches_package?(package_name, pattern)
+        return false unless package_name && pattern
+
+        # Support wildcards: "CityGML::*" matches "CityGML::Core"
+        regex_pattern = pattern.gsub("*", ".*")
+        Regexp.new("^#{regex_pattern}$").match?(package_name)
+      rescue RegexpError => e
+        warn "Warning: Invalid package pattern '#{pattern}': #{e.message}"
+        false
+      end
+
+      # Deep merge two hashes
+      #
+      # @param hash1 [Hash] Base hash
+      # @param hash2 [Hash] Hash to merge in
+      # @return [Hash] Merged hash
+      def deep_merge(hash1, hash2)
+        hash1.merge(hash2) do |_key, old_val, new_val|
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            deep_merge(old_val, new_val)
+          else
+            new_val
+          end
+        end
+      end
+
+      private
+
+      # Load configuration from files
+      #
+      # @param custom_path [String, nil] Custom configuration path
+      # @return [Hash] Merged configuration data
+      def load_configuration(custom_path = nil) # rubocop:disable Metrics/MethodLength
+        paths = custom_path ? [custom_path] : DEFAULT_CONFIG_PATHS
+        merged_config = default_config
+
+        paths.each do |path|
+          next unless File.exist?(path)
+
+          begin
+            user_config = YAML.load_file(path)
+            if user_config.is_a?(Hash)
+              merged_config = deep_merge(merged_config, user_config)
+            end
+          rescue Psych::SyntaxError, Errno::ENOENT, Errno::EACCES,
+                 IOError => e
+            warn "Warning: Failed to load configuration from " \
+                 "#{path}: #{e.message}"
+          end
+        end
+
+        merged_config
+      end
+
+      # Built-in default configuration (minimal, as fallback)
+      #
+      # @return [Hash] Default configuration data
+      def default_config # rubocop:disable Metrics/MethodLength
+        {
+          "defaults" => {
+            "colors" => {
+              "background" => "#FFFFFF",
+              "default_fill" => "#E0E0E0",
+              "default_stroke" => "#000000",
+              "text" => "#000000",
+            },
+            "fonts" => {
+              "default" => {
+                "family" => "Carlito, Arial, sans-serif",
+                "size" => 9,
+                "weight" => 400,
+                "style" => "normal",
+              },
+              "class_name" => {
+                "family" => "Carlito, Arial, sans-serif",
+                "size" => 9,
+                "weight" => 700,
+                "style" => "normal",
+              },
+              "stereotype" => {
+                "family" => "Carlito, Arial, sans-serif",
+                "size" => 9,
+                "weight" => 400,
+                "style" => "normal",
+              },
+            },
+            "box" => {
+              "stroke_width" => 2,
+              "stroke_linecap" => "round",
+              "stroke_linejoin" => "bevel",
+              "corner_radius" => 0,
+              "padding" => 5,
+            },
+            "text" => {
+              "visibility_public" => "+",
+              "visibility_private" => "-",
+              "visibility_protected" => "#",
+              "visibility_package" => "~",
+              "cardinality_format" => "[%s]",
+              "stereotype_format" => "«%s»",
+            },
+          },
+          "stereotypes" => {
+            "DataType" => {
+              "colors" => {
+                "fill" => "#FFCCFF",
+                "stroke" => "#000000",
+              },
+              "fonts" => {
+                "class_name" => {
+                  "weight" => 700,
+                  "style" => "italic",
+                },
+              },
+            },
+            "FeatureType" => {
+              "colors" => {
+                "fill" => "#FFFFCC",
+                "stroke" => "#000000",
+              },
+            },
+            "GMLType" => {
+              "colors" => {
+                "fill" => "#CCFFCC",
+                "stroke" => "#000000",
+              },
+            },
+            "Interface" => {
+              "colors" => {
+                "fill" => "#FFFFEE",
+                "stroke" => "#000000",
+              },
+              "fonts" => {
+                "class_name" => {
+                  "style" => "italic",
+                },
+              },
+            },
+          },
+          "connectors" => {
+            "generalization" => {
+              "arrow" => {
+                "type" => "hollow_triangle",
+                "size" => 10,
+              },
+              "line" => {
+                "stroke_width" => 1,
+                "stroke" => "#000000",
+              },
+            },
+            "association" => {
+              "arrow" => {
+                "type" => "open_arrow",
+                "size" => 8,
+              },
+              "line" => {
+                "stroke_width" => 1,
+                "stroke" => "#000000",
+              },
+              "labels" => {
+                "show_role_names" => true,
+                "show_cardinality" => true,
+                "font" => {
+                  "family" => "Carlito, Arial, sans-serif",
+                  "size" => 8,
+                },
+              },
+            },
+            "dependency" => {
+              "arrow" => {
+                "type" => "open_arrow",
+                "size" => 8,
+              },
+              "line" => {
+                "stroke_width" => 1,
+                "stroke" => "#000000",
+                "stroke_dasharray" => "5,5",
+              },
+            },
+            "aggregation" => {
+              "arrow" => {
+                "type" => "diamond",
+                "size" => 10,
+              },
+              "line" => {
+                "stroke_width" => 1,
+                "stroke" => "#000000",
+              },
+            },
+            "composition" => {
+              "arrow" => {
+                "type" => "filled_diamond",
+                "size" => 10,
+              },
+              "line" => {
+                "stroke_width" => 1,
+                "stroke" => "#000000",
+              },
+            },
+          },
+          "legend" => {
+            "enabled" => true,
+            "position" => "bottom_right",
+            "title" => "Legend",
+            "entries" => [
+              {
+                "label" => "i-UR DataTypes",
+                "color" => "#FFCCFF",
+              },
+              {
+                "label" => "CityGML FeatureTypes",
+                "color" => "#FFFFCC",
+              },
+              {
+                "label" => "GML Types",
+                "color" => "#CCFFCC",
+              },
+            ],
+          },
+        }
+      end
+
+      # Navigate configuration using dot notation
+      #
+      # @param path [String] Configuration path (e.g., "colors.fill")
+      # @return [Object] Configuration value
+      def dig_config(path)
+        dig_hash(config_data, path)
+      end
+    end
+  end
+end

data/lib/ea/diagram/element_renderers/base_renderer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Ea
+  module Diagram
+    module ElementRenderers
+      # Base renderer for diagram elements
+      class BaseRenderer
+        include Ea::Diagram::Util
+
+        attr_reader :element, :style_resolver
+
+        def initialize(element, style_resolver)
+          @element = element
+          @style_resolver = style_resolver
+        end
+
+        # Render the element as SVG
+        # @return [String] SVG content for the element
+        def render
+          style = style_resolver.resolve_element_style(element)
+
+          <<~SVG
+            <g class="lutaml-diagram-element lutaml-diagram-#{element[:type]}"
+               data-element-id="#{element[:id]}"
+               data-element-type="#{element[:type]}">
+              #{render_shape(style)}
+              #{render_label(style)}
+            </g>
+          SVG
+        end
+
+        def render_shape(_style)
+          ""
+        end
+
+        def render_label(style) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          return "" unless element[:name]
+
+          x = element[:x] || 0
+          y = element[:y] || 0
+          width = element[:width] || 120
+          height = element[:height] || 80
+
+          # Center the label
+          text_x = x + (width / 2)
+          # Slight vertical offset for better centering
+          text_y = y + (height / 2) + 5
+
+          <<~SVG
+            <text x="#{text_x}"
+                  y="#{text_y}"
+                  text-anchor="middle"
+                  dominant-baseline="middle"
+                  font-family="#{style[:font_family]}"
+                  font-size="#{style[:font_size]}"
+                  font-weight="#{style[:font_weight] || 'normal'}"
+                  fill="#{style[:text_color] || '#000000'}"
+                  class="lutaml-diagram-label">
+              #{escape_text(element[:name])}
+            </text>
+          SVG
+        end
+
+        def escape_text(text)
+          return "" unless text
+
+          text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&apos;")
+        end
+      end
+    end
+  end
+end