ea 0.3.1 → 0.5.0

data/lib/ea/cli/command/export.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ea
+  module Cli
+    module Command
+      # `ea export SUB FILE` where SUB ∈ {xmi, json, plantuml, xsd}.
+      #
+      # Routes to the appropriate Exporter based on `sub`. Each
+      # exporter lives under Ea::Export::* and implements
+      # `call(model, **opts) → String`. Adding a new format = adding
+      # a new exporter (OCP), no changes to this command.
+      class Export < Base
+        COLUMNS = %i[format bytes_written path].freeze
+
+        def call
+          validate_file!(file_path)
+          output = exporter.call(model, **exporter_options)
+          path = write_output(output, default_name: default_name)
+          formatter.render([[sub, output.bytesize, path]], columns: COLUMNS)
+        end
+
+        private
+
+        def sub
+          options[:sub].to_sym
+        end
+
+        def exporter
+          @exporter ||= EXPORTERS.fetch(sub) do
+            raise Ea::Cli::Error,
+                  "Unknown export format: #{sub}. " \
+                  "Valid: #{EXPORTERS.keys.join(", ")}"
+          end
+        end
+
+        # Each value is a callable taking (model, **opts) and returning
+        # a string. New formats add a new entry here without touching
+        # this class body. Lambdas lazy-resolve autoloaded namespaces.
+        EXPORTERS = {
+          xmi: ->(model, **o) { Ea::Export::Xmi::Generator.call(model, **o) },
+          json: ->(model, **o) { Ea::Export::Json::Generator.call(model, **o) },
+          "json-schema": ->(model, **o) { Ea::Export::JsonSchema::Generator.call(model, **o) },
+          plantuml: ->(model, **o) { Ea::Export::PlantUml::Generator.call(model, **o) },
+          xsd: ->(model, **o) { Ea::Export::Xsd::Generator.call(model, **o) }
+        }.freeze
+
+        def exporter_options
+          opts = {}
+          opts[:target_namespace] = options[:target_namespace] if options[:target_namespace]
+          opts[:prefix] = options[:prefix] if options[:prefix]
+          opts
+        end
+
+        def model
+          @model ||= load_database(file_path)
+        end
+
+        def default_name
+          base = File.basename(file_path, ".*")
+          dir = File.dirname(file_path)
+          ext = exporter_extension
+          File.join(dir, "#{base}.#{ext}")
+        end
+
+        def exporter_extension
+          case sub
+          when :xmi then "xmi"
+          when :json then "json"
+          when :"json-schema" then "schema.json"
+          when :plantuml then "puml"
+          when :xsd then "xsd"
+          else sub.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli/command/info.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ea
+  module Cli
+    module Command
+      # `ea info NAME FILE` — show details of one element by name.
+      class Info < Base
+        COLUMNS = %i[field value].freeze
+
+        def call
+          element = find_element
+          unless element
+            warn "Element #{name.inspect} not found"
+            exit(1)
+          end
+
+          rows = build_info(element)
+          formatter.render(rows, columns: COLUMNS)
+        end
+
+        private
+
+        def name
+          options[:name]
+        end
+
+        def model
+          @model ||= load_database(file_path)
+        end
+
+        def find_element
+          (model.collections[:objects] || []).find { |o| o.name == name }
+        end
+
+        def build_info(element)
+          rows = [
+            ["id", element.object_id],
+            ["name", element.name],
+            ["type", element.object_type],
+            ["author", element.author],
+            ["version", element.version],
+            ["package", package_name_for(element)],
+            ["stereotypes", stereotypes_for(element).join(", ")],
+            ["notes", (element.note || "")[0, 100]]
+          ]
+
+          attrs = attributes_for(element)
+          rows.concat(attrs.each_with_index.map do |a, i|
+            ["attr[#{i}]", "#{a.name}: #{a.type || 'void'}"]
+          end)
+
+          rows
+        end
+
+        def attributes_for(element)
+          (model.collections[:attributes] || [])
+            .select { |a| a.object_id == element.object_id }
+        end
+
+        def package_name_for(element)
+          pkg = (model.collections[:packages] || []).find { |p| p.package_id == element.package_id }
+          pkg&.name || "-"
+        end
+
+        def stereotypes_for(element)
+          xrefs = model.collections[:xrefs] || []
+          stereo_xrefs = xrefs.select do |xr|
+            xr.client == element.ea_guid && xr.description&.include?("@STEREO")
+          end
+          stereo_xrefs.map { |xr| xr.description[/Name=([^;]+)/, 1] }.compact
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli/command/lint.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Ea
+  module Cli
+    module Command
+      # `ea lint FILE [--rule=NAME] [--severity=error|warning]`
+      #
+      # Runs the Ea::Lint::Engine over a parsed model and reports
+      # offenses. Exit 1 when errors are found.
+      class Lint < Base
+        COLUMNS = %i[severity rule entity_name message].freeze
+
+        def call
+          offenses = engine.run(model)
+          offenses = filter_by_rule(offenses)
+          offenses = filter_by_severity(offenses)
+          rows = offenses.map { |o| [o.severity, o.rule, o.entity_name, o.message] }
+          formatter.render(rows, columns: COLUMNS)
+          exit(1) if offenses.any?(&:error?)
+        end
+
+        private
+
+        def engine
+          @engine ||= Ea::Lint::Engine.new
+        end
+
+        def model
+          @model ||= load_database(file_path)
+        end
+
+        def filter_by_rule(offenses)
+          return offenses unless options[:rule]
+
+          rule_filter = options[:rule].to_s
+          offenses.select { |o| o.rule.to_s.downcase.include?(rule_filter.downcase) }
+        end
+
+        def filter_by_severity(offenses)
+          return offenses unless options[:severity]
+
+          sev = options[:severity].to_sym
+          offenses.select { |o| o.severity == sev }
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli/command/mdg.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Ea
+  module Cli
+    module Command
+      # `ea mdg ACTION [ARG]`
+      #
+      # Actions:
+      #   list                 — list registered technologies
+      #   show NAME            — show stereotype details
+      #   stereotypes          — list all stereotypes across technologies
+      class Mdg < Base
+        COLUMNS = %i[name version stereotypes].freeze
+
+        def call
+          case action
+          when "list" then list_technologies
+          when "show" then show_stereotype(arg)
+          when "stereotypes" then list_stereotypes
+          else
+            raise Ea::Cli::Error,
+                  "Unknown mdg action: #{action}. " \
+                  "Valid: list | show NAME | stereotypes"
+          end
+        end
+
+        private
+
+        def action
+          options[:action]
+        end
+
+        def arg
+          options[:arg]
+        end
+
+        def registry
+          @registry ||= build_registry
+        end
+
+        def build_registry
+          registry = Ea::Mdg::Registry.new
+          Dir.glob("spec/fixtures/mdg/**/*.xml").each do |path|
+            begin
+              doc = Ea::Mdg::Loader.from_path(path).document
+              registry.register(doc)
+            rescue StandardError => e
+              warn "Skipped #{path}: #{e.message}" if ENV["EA_DEBUG"]
+            end
+          end
+          registry
+        end
+
+        def list_technologies
+          rows = registry.documents.map do |doc|
+            [doc.technology_name, "-", (doc.stereotypes || []).size]
+          end
+          formatter.render(rows, columns: COLUMNS)
+        end
+
+        def list_stereotypes
+          rows = []
+          registry.documents.each do |doc|
+            (doc.stereotypes || []).each do |st|
+              rows << [doc.technology_name, st.name, st.applies_to.join(",")]
+            end
+          end
+          formatter.render(rows, columns: %i[technology name applies_to])
+        end
+
+        def show_stereotype(name)
+          return unless name
+
+          found = nil
+          registry.documents.each do |doc|
+            st = (doc.stereotypes || []).find { |s| s.name == name }
+            next unless st
+
+            found = { technology: doc.technology_name, stereo: st }
+            break
+          end
+
+          if found
+            formatter.render(
+              [[found[:technology], found[:stereo].name,
+                found[:stereo].applies_to.join(","),
+                (found[:stereo].tagged_values || []).size]],
+              columns: %i[technology name applies_to tagged_values]
+            )
+          else
+            warn "Stereotype #{name.inspect} not found"
+            exit(1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli/command/query.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Ea
+  module Cli
+    module Command
+      # `ea query FILE [--type=T] [--package=NAME] [--stereo=NAME]`
+      #
+      # Wraps Ea::Query::Builder for CLI consumption.
+      class Query < Base
+        COLUMNS = %i[id type name package].freeze
+
+        def call
+          builder = Ea::Query::Builder.new(model)
+          builder = builder.with_type(options[:type]) if options[:type]
+          builder = builder.in_package(options[:package]) if options[:package]
+          builder = builder.with_stereotype(options[:stereotype]) if options[:stereotype]
+          rows = builder.call.map { |o| [o.object_id, o.object_type, o.name, package_name_for(o)] }
+          formatter.render(rows, columns: COLUMNS)
+        end
+
+        private
+
+        def model
+          @model ||= load_database(file_path)
+        end
+
+        def package_name_for(obj)
+          pkg = (model.collections[:packages] || []).find { |p| p.package_id == obj.package_id }
+          pkg&.name || "-"
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli/command/render.rb

@@ -0,0 +1,135 @@
+# frozen_string: true
+
+require "fileutils"
+
+module Ea
+  module Cli
+    module Command
+      # `ea render NAME FILE [--format=svg|png|pdf]`
+      # `ea render --all FILE [--output-dir=PATH]`
+      #
+      # Unified rendering command. Currently supports SVG; PNG and PDF
+      # are routed through SVG intermediate (planned: rsvg-convert /
+      # headless chrome). The original `ea svg` command is preserved
+      # as a backward-compatible alias.
+      class Render < Base
+        def call
+          return render_all if options[:all]
+
+          render_one
+        end
+
+        private
+
+        def render_one
+          diagram = find_diagram
+          write_diagram(diagram, resolve_output_path(diagram))
+        end
+
+        def render_all
+          out_dir = options[:output_dir] || default_output_dir
+          FileUtils.mkdir_p(out_dir)
+          paths = document.diagrams.map do |diagram|
+            path = File.join(out_dir, "#{diagram.id}.#{format_ext}")
+            write_diagram(diagram, path)
+            path
+          end
+          formatter.render(paths.map { |p| [p] }, columns: [:written_to])
+        end
+
+        def write_diagram(diagram, output_path)
+          FileUtils.mkdir_p(File.dirname(output_path))
+          svg = render_svg(diagram)
+
+          case requested_format
+          when :svg
+            File.write(output_path, svg)
+          when :png
+            File.binwrite(output_path, svg_to_png(svg))
+          when :pdf
+            File.binwrite(output_path, svg_to_pdf(svg))
+          else
+            raise Ea::Cli::Error, "Unknown format: #{requested_format.inspect}"
+          end
+        end
+
+        def render_svg(diagram)
+          emitter_for_mode.new(diagram,
+                               model_index: document.index_by_id,
+                               document: document).render
+        end
+
+        def svg_to_png(svg)
+          Ea::Render::ImageConverter
+            .new(svg).to_png
+        end
+
+        def svg_to_pdf(svg)
+          Ea::Render::ImageConverter
+            .new(svg).to_pdf
+        end
+
+        def requested_format
+          (options[:format] || :svg).to_sym
+        end
+
+        def format_ext
+          case requested_format
+          when :svg then "svg"
+          when :png then "png"
+          when :pdf then "pdf"
+          else "svg"
+          end
+        end
+
+        def default_output_dir
+          base = File.basename(file_path, ".*")
+          dir = File.dirname(file_path)
+          File.join(dir, "#{base}.renders")
+        end
+
+        def emitter_for_mode
+          Ea::Svg::EaEmitter::Document
+        end
+
+        def document
+          @document ||= build_model_document
+        end
+
+        def build_model_document
+          case File.extname(file_path).downcase
+          when ".qea"
+            Ea::Sources::Qea::Adapter.from_path(file_path)
+          when ".xmi"
+            Ea::Sources::Xmi::Adapter.from_path(file_path)
+          else
+            raise Ea::Cli::UnsupportedFormat,
+                  "Unknown file format: #{File.extname(file_path)}"
+          end
+        end
+
+        def diagram_name
+          options[:name] or raise Ea::Cli::Error, "missing required diagram name"
+        end
+
+        def find_diagram
+          match = document.diagrams.find { |d| d.name == diagram_name }
+          return match if match
+
+          raise Ea::Cli::Error,
+                "Diagram #{diagram_name.inspect} not found in #{file_path}. " \
+                "Use `ea diagrams list #{file_path}` to see names."
+        end
+
+        def resolve_output_path(diagram)
+          options[:output] || begin
+            base = File.basename(file_path, ".*")
+            dir = File.dirname(file_path)
+            safe_name = (diagram.name || "diagram").gsub(/[^\w.\-]+/, "_")
+            File.join(dir, "#{base}.#{safe_name}.#{format_ext}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/cli/command/svg.rb

@@ -6,15 +6,29 @@ module Ea
   module Cli
     module Command
       # `ea svg NAME FILE [--output=PATH]`
+      # `ea svg --all FILE [--output-dir=PATH]`
       #
-      # Renders a single diagram from a QEA or XMI file into a
-      # standalone SVG using the umldi content (placed element
-      # bounds + connector waypoints) captured in Ea::Model::Diagram.
+      # Renders one (NAME) or every (--all) diagram from a QEA or
+      # XMI file into standalone SVG using the umldi content
+      # (placed element bounds + connector waypoints) captured in
+      # Ea::Model::Diagram.
+      #
+      # Default emitter is EaEmitter::Document which mirrors EA's SVG
+      # structure (DOCTYPE, layered groups, EA-style markers).
       class Svg < Base
         def call
+          return render_all if options[:all]
+
+          render_one
+        end
+
+        private
+
+        def render_one
           diagram = find_diagram
-          svg = Ea::Svg::Renderer.new(diagram,
-                                       model_index: document.index_by_id).render
+          svg = emitter_for_mode.new(diagram,
+                                       model_index: document.index_by_id,
+                                       document: document).render
 
           output_path = resolve_output_path(diagram)
           FileUtils.mkdir_p(File.dirname(output_path))
@@ -23,7 +37,30 @@ module Ea
           formatter.render([[output_path]], columns: [:written_to])
         end
 
-        private
+        def render_all
+          out_dir = options[:output_dir] || default_output_dir
+          FileUtils.mkdir_p(out_dir)
+          paths = document.diagrams.map do |diagram|
+            svg = emitter_for_mode.new(diagram,
+                                         model_index: document.index_by_id,
+                                         document: document).render
+            path = File.join(out_dir, "#{diagram.id}.svg")
+            File.write(path, svg)
+            path
+          end
+
+          formatter.render(paths.map { |p| [p] }, columns: [:written_to])
+        end
+
+        def default_output_dir
+          base = File.basename(file_path, ".*")
+          dir = File.dirname(file_path)
+          File.join(dir, "#{base}.svgs")
+        end
+
+        def emitter_for_mode
+          Ea::Svg::EaEmitter::Document
+        end
 
         def document
           @document ||= build_model_document

data/lib/ea/cli/command.rb

@@ -12,7 +12,14 @@ module Ea
       autoload :Convert, "ea/cli/command/convert"
       autoload :Spa, "ea/cli/command/spa"
       autoload :Svg, "ea/cli/command/svg"
+      autoload :Render, "ea/cli/command/render"
+      autoload :Export, "ea/cli/command/export"
+      autoload :Mdg, "ea/cli/command/mdg"
       autoload :RepositoryBuilder, "ea/cli/command/repository_builder"
+      autoload :Diff, "ea/cli/command/diff"
+      autoload :Lint, "ea/cli/command/lint"
+      autoload :Query, "ea/cli/command/query"
+      autoload :Info, "ea/cli/command/info"
     end
   end
 end