suma 0.2.6 → 0.4.0

data/lib/suma/cli/check_svg_quality.rb

@@ -1,25 +1,22 @@
 # frozen_string_literal: true
 
 require "pathname"
-require_relative "../svg_quality"
-require_relative "../svg_quality/report"
-require_relative "../svg_quality/batch_report"
-require_relative "../svg_quality/formatters/terminal_formatter"
-require_relative "../svg_quality/formatters/json_formatter"
-require_relative "../svg_quality/formatters/yaml_formatter"
 
 module Suma
   module Cli
-    # Check SVG quality using svg_conform Validator API - thin CLI wrapper
+    # Check SVG quality. Thin adapter around +Suma::SvgQuality::Scanner+:
+    # argument parsing, file discovery, sorting, filtering, output
+    # formatting. The deep scanner module owns validation orchestration
+    # and is reachable from specs without invoking Thor.
     class CheckSvgQuality
       DATA_PATH = "schemas"
       DEFAULT_PATTERN = "**/*.svg"
       DEFAULT_PROFILE = :metanorma
 
       def initialize(pattern: DEFAULT_PATTERN, profile: DEFAULT_PROFILE,
-                    format: "terminal", output: nil, min_errors: nil,
-                    summary_only: false, progress: false, limit: nil,
-                    sort: "errors")
+                     format: "terminal", output: nil, min_errors: nil,
+                     summary_only: false, progress: false, limit: nil,
+                     sort: "errors")
         @options = {
           pattern: pattern,
           profile: profile,
@@ -37,71 +34,42 @@ module Suma
         require "svg_conform"
 
         path_obj = Pathname.new(path).expand_path
-
-        # Enable progress by default when outputting to terminal
         show_progress = options[:progress] || ($stdout.tty? && !options[:output])
-        if show_progress
-          $stdout.sync = true
-          $stderr.sync = true
-        end
-
-        if path_obj.file?
-          # Single file mode - show detailed errors
-          analyze_single_file(path_obj)
-        else
-          # Directory mode - show batch report
-          svg_files = find_svg_files(path_obj)
-
-          if svg_files.empty?
-            puts "No SVG files found in #{path}"
-            return
-          end
+        sync_stdio! if show_progress
 
-          puts "🔍 Scanning #{svg_files.size} SVG files..."
-          puts
+        files = discover_files(path_obj)
+        return if files.empty?
 
-          reports = analyze_files_one_by_one(svg_files, show_progress)
-          batch_report = SvgQuality::BatchReport.new(reports)
-          sorted_report = sort_report(batch_report)
-          output_report(sorted_report)
+        if single_file?(path_obj, files)
+          print_single_report(scan_single(files.first))
+        else
+          scan_and_output(files, show_progress)
         end
       end
 
-      def analyze_single_file(path)
-        validator = SvgConform::Validator.new
-        result = validator.validate_file(path.to_s, profile: options[:profile])
-
-        puts "📄 SVG Quality Report: #{path}"
-        puts ""
-        puts "  Valid: #{result.valid? ? 'YES ✅' : 'NO ❌'}"
-        puts "  Errors: #{result.error_count}"
-        puts ""
+      private
 
-        if result.errors.any?
-          puts "  📋 Error Details"
-          puts ""
+      attr_reader :options
 
-          # Group errors by requirement_id
-          by_req = result.errors.group_by(&:requirement_id)
-
-          by_req.each do |req_id, errors|
-            puts "  #{req_id} (#{errors.size} occurrences)"
-            errors.first(5).each do |e|
-              puts "    - #{e.message}"
-            end
-            if errors.size > 5
-              puts "    ... and #{errors.size - 5} more"
-            end
-            puts ""
-          end
-        end
+      def single_file?(path_obj, files)
+        path_obj.file? && files.size == 1
       end
 
-      private
+      def scan_and_output(files, show_progress)
+        puts "🔍 Scanning #{files.size} SVG files..." if show_progress
+        batch = SvgQuality::Scanner.new(
+          profile: options[:profile],
+          progress: progress_adapter(show_progress),
+        ).scan(files)
+        output_report(sort_report(batch))
+      end
 
-      attr_reader :options
+      def sync_stdio!
+        $stdout.sync = true
+        $stderr.sync = true
+      end
 
-      def find_svg_files(path)
+      def discover_files(path)
         if path.directory?
           Pathname.glob(path.join(options[:pattern])).select(&:file?)
         elsif path.file? && path.extname == ".svg"
@@ -111,34 +79,47 @@ module Suma
         end
       end
 
-      def analyze_files_one_by_one(files, show_progress = false)
-        validator = SvgConform::Validator.new
-        reports = []
-
-        files.each_with_index do |file, index|
-          result = validator.validate_file(file.to_s,
-                                           profile: options[:profile])
-          report = SvgQuality::Report.new(file.to_s, result)
-          reports << report
-
-          if show_progress
-            tier = report.quality_tier
-            status = report.valid? ? "✅" : "❌"
-            msg = "  [#{index + 1}/#{files.size}] #{tier[:emoji]} #{report.error_count} errors #{status} #{shorten_path(file)}\n"
-            $stderr.print msg
-            $stderr.flush
-          end
+      def scan_single(path)
+        SvgQuality::Scanner.new(profile: options[:profile]).scan_file(path)
+      end
+
+      def print_single_report(report)
+        result = report
+        puts "📄 SVG Quality Report: #{result.file_path}"
+        puts ""
+        puts "  Valid: #{result.valid? ? 'YES ✅' : 'NO ❌'}"
+        puts "  Errors: #{result.error_count}"
+        puts ""
+
+        return unless result.errors.any?
+
+        puts "  📋 Error Details"
+        puts ""
+        by_req = result.errors.group_by(&:requirement_id)
+        by_req.each do |req_id, errors|
+          puts "  #{req_id} (#{errors.size} occurrences)"
+          errors.first(5).each { |e| puts "    - #{e.message}" }
+          puts "    ... and #{errors.size - 5} more" if errors.size > 5
+          puts ""
         end
+      end
+
+      def progress_adapter(enabled)
+        return SvgQuality::Scanner::NullProgress.new unless enabled
 
-        reports
+        ->(_index, _total, report) do
+          tier = report.quality_tier
+          status = report.valid? ? "✅" : "❌"
+          $stderr.print "  #{tier[:emoji]} #{report.error_count} errors " \
+                        "#{status} #{shorten_path(report.file_path)}\n"
+          $stderr.flush
+        end
       end
 
       def sort_report(batch_report)
         case options[:sort]
-        when :quality
-          batch_report.sort_by_quality
-        else
-          batch_report.sort_by_errors
+        when :quality then batch_report.sort_by_quality
+        else batch_report.sort_by_errors
         end
       end
 
@@ -146,21 +127,25 @@ module Suma
         filtered = batch_report.filter_by_min_errors(options[:min_errors])
         limited = filtered.limit(options[:limit])
 
-        formatter = case options[:format].to_sym
-                    when :json
-                      SvgQuality::Formatters::JsonFormatter.new(limited,
-                                                                output: options[:output])
-                    when :yaml
-                      SvgQuality::Formatters::YamlFormatter.new(limited,
-                                                                output: options[:output])
-                    else
-                      SvgQuality::Formatters::TerminalFormatter.new(limited,
-                                                                    output: options[:output], sort: options[:sort])
-                    end
-
+        formatter = formatter_for(limited)
         puts formatter.format
       end
 
+      def formatter_for(batch_report)
+        case options[:format].to_sym
+        when :json
+          SvgQuality::Formatters::JsonFormatter.new(batch_report,
+                                                    output: options[:output])
+        when :yaml
+          SvgQuality::Formatters::YamlFormatter.new(batch_report,
+                                                    output: options[:output])
+        else
+          SvgQuality::Formatters::TerminalFormatter.new(batch_report,
+                                                        output: options[:output],
+                                                        sort: options[:sort])
+        end
+      end
+
       def shorten_path(path)
         p = Pathname.new(path)
         if p.absolute?

data/lib/suma/cli/compare.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../schema_comparer"
 
 module Suma
   module Cli

data/lib/suma/cli/convert_jsdai.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../thor_ext"
-require_relative "../jsdai"
 require "fileutils"
 
 module Suma

data/lib/suma/cli/core.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "thor"
+require "expressir"
+require "expressir/cli"
+
+module Suma
+  module Cli
+    # Top-level CLI entrypoint.
+    #
+    # Each command delegates to a dedicated Thor class under +Suma::Cli::+,
+    # which reparses ARGV and therefore owns the canonical +option+
+    # declarations. Re-declaring options here would duplicate the inner
+    # classes' declarations and cause help text and validation logic to
+    # drift. Options are declared in exactly one place (the inner class).
+    #
+    # The exception is +check_svg_quality+, which constructs its analyzer
+    # inline (no inner Thor class), so its options belong here.
+    class Core < Thor
+      extend ThorExt::Start
+
+      desc "build METANORMA_SITE_MANIFEST",
+           "Build collection specified in site manifest (`metanorma*.yml`)"
+      def build(_site_manifest)
+        Cli::Build.start
+      end
+
+      desc "generate-schemas METANORMA_MANIFEST_FILE SCHEMA_MANIFEST_FILE",
+           "Generate EXPRESS schema manifest file from Metanorma site manifest"
+      def generate_schemas(_metanorma_manifest_file, _schema_manifest_file)
+        Cli::GenerateSchemas.start
+      end
+
+      desc "reformat EXPRESS_FILE_PATH",
+           "Reformat EXPRESS files"
+      def reformat(_express_file_path)
+        Cli::Reformat.start
+      end
+
+      desc "extract-terms SCHEMA_MANIFEST_FILE GLOSSARIST_OUTPUT_PATH",
+           "Extract terms from SCHEMA_MANIFEST_FILE into " \
+           "Glossarist v3 format"
+      def extract_terms(_schema_manifest_file, _glossarist_output_path)
+        Cli::ExtractTerms.start
+      end
+
+      desc "generate-register SCHEMA_MANIFEST_FILE OUTPUT_PATH",
+           "Generate a Glossarist register.yaml with hierarchical sections"
+      def generate_register(_schema_manifest_file, _output_path)
+        Cli::GenerateRegister.start
+      end
+
+      desc "convert-jsdai XML_FILE IMAGE_FILE OUTPUT_DIR",
+           "Convert JSDAI XML and image files to SVG and EXP files"
+      def convert_jsdai(_xml_file, _image_file, _output_dir)
+        Cli::ConvertJsdai.start
+      end
+
+      desc "export *FILES",
+           "Export EXPRESS schemas from manifest files or " \
+           "standalone EXPRESS files"
+      def export(*_files)
+        Cli::Export.start
+      end
+
+      desc "compare TRIAL_SCHEMA REFERENCE_SCHEMA",
+           "Compare EXPRESS schemas using eengine and generate Change YAML"
+      def compare(_trial_schema, _reference_schema)
+        Cli::Compare.start
+      end
+
+      desc "validate SUBCOMMAND ...ARGS", "Validate express documents"
+      subcommand "validate", Cli::Validate
+
+      desc "check_svg_quality [PATH]",
+           "Check SVG quality and sort by severity (critical files first)"
+      option :pattern, type: :string, default: Cli::CheckSvgQuality::DEFAULT_PATTERN,
+                       desc: "Glob pattern for finding SVG files"
+      option :profile, type: :string,
+                       default: Cli::CheckSvgQuality::DEFAULT_PROFILE,
+                       desc: "Validation profile to use (metanorma, svg_1_2_rfc, etc.)"
+      option :format, type: :string, default: "terminal",
+                      desc: "Output format: terminal, yaml, json"
+      option :output, type: :string, aliases: "-o",
+                      desc: "Output file path"
+      option :min_errors, type: :numeric,
+                          desc: "Minimum error count threshold"
+      option :limit, type: :numeric, default: nil,
+                     desc: "Maximum number of files to show (default: unlimited)"
+      option :sort, type: :string, default: "errors",
+                    desc: "Sort by: errors (most errors first) or quality (lowest scores first)"
+      option :progress, type: :boolean, default: false,
+                        desc: "Show progress during processing"
+      option :summary_only, type: :boolean, default: false,
+                            desc: "Show only summary"
+      def check_svg_quality(path = Cli::CheckSvgQuality::DATA_PATH)
+        analyzer = Cli::CheckSvgQuality.new(
+          pattern: options[:pattern],
+          profile: options[:profile],
+          format: options[:format],
+          output: options[:output],
+          min_errors: options[:min_errors],
+          summary_only: options[:summary_only],
+          progress: options[:progress],
+          limit: options[:limit],
+          sort: options[:sort],
+        )
+        analyzer.run(path)
+      end
+
+      desc "expressir SUBCOMMAND ...ARGS", "Expressir commands"
+      subcommand "expressir", Expressir::Cli
+
+      def self.exit_on_failure?
+        true
+      end
+    end
+  end
+end

data/lib/suma/cli/export.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../thor_ext"
+require "pathname"
 
 module Suma
   module Cli
-    # Export command for exporting EXPRESS schemas from a manifest
+    # Export command. Thin Thor adapter that constructs
+    # +Suma::ExpressSchema+ instances from manifest entries or
+    # standalone +.exp+ files, then delegates the actual writing to
+    # +Suma::SchemaExporter+.
+    #
+    # The schema-type → output-subdirectory mapping lives in
+    # +Suma::SchemaCategory+, the single source of truth. The exporter
+    # itself never classifies — it consumes loaded ExpressSchema
+    # objects whose output paths were set by this adapter.
     class Export < Thor
       desc "export *FILES",
            "Export EXPRESS schemas from manifest files or " \
@@ -18,8 +26,6 @@ module Suma
                    desc: "Create ZIP archive of exported schemas"
 
       def export(*files)
-        require_relative "../schema_exporter"
-        require_relative "../utils"
         require "expressir"
 
         validate_files(files)
@@ -41,7 +47,7 @@ module Suma
       end
 
       def run(files, options)
-        schemas = load_schemas_from_files(files)
+        schemas = files.flat_map { |file| build_schemas(file) }
 
         exporter = SchemaExporter.new(
           schemas: schemas,
@@ -55,22 +61,12 @@ module Suma
         exporter.export
       end
 
-      def load_schemas_from_files(files)
-        all_schemas = []
-
-        files.each do |file|
-          all_schemas += process_file(file)
-        end
-
-        all_schemas
-      end
-
-      def process_file(file)
+      def build_schemas(file)
         case File.extname(file).downcase
         when ".yml", ".yaml"
-          load_manifest_schemas(file)
+          build_from_manifest(file)
         when ".exp"
-          [create_schema_from_exp_file(file)]
+          [build_standalone(file)]
         else
           raise ArgumentError, "Unsupported file type: #{file}. " \
                                "Only .yml, .yaml, and .exp files are " \
@@ -78,13 +74,32 @@ module Suma
         end
       end
 
-      def load_manifest_schemas(file)
+      def build_from_manifest(file)
         manifest = Expressir::SchemaManifest.from_file(file)
-        manifest.schemas
+        manifest.schemas.map { |entry| build_from_manifest_entry(entry) }
+      end
+
+      def build_from_manifest_entry(entry)
+        category = SchemaCategory.for_schema(id: entry.id, path: entry.path)
+        ExpressSchema.new(
+          id: entry.id,
+          path: entry.path.to_s,
+          output_path: output_root.join(category.directory).to_s,
+          is_standalone_file: false,
+        )
+      end
+
+      def build_standalone(exp_file)
+        ExpressSchema.new(
+          id: nil,
+          path: File.expand_path(exp_file),
+          output_path: output_root.to_s,
+          is_standalone_file: true,
+        )
       end
 
-      def create_schema_from_exp_file(exp_file)
-        Struct.new(:id, :path).new(nil, File.expand_path(exp_file))
+      def output_root
+        Pathname.new(options[:output]).expand_path
       end
 
       def self.exit_on_failure?

data/lib/suma/cli/extract_terms.rb

@@ -1,28 +1,25 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../thor_ext"
-require_relative "../term_extractor"
 
 module Suma
   module Cli
     class ExtractTerms < Thor
       desc "extract_terms SCHEMA_MANIFEST_FILE GLOSSARIST_OUTPUT_PATH",
            "Extract terms from SCHEMA_MANIFEST_FILE into " \
-           "Glossarist v2 format"
+           "Glossarist v3 format"
       option :language_code, type: :string, default: "eng", aliases: "-l",
                              desc: "Language code for the Glossarist"
+      option :urn, type: :string, required: true, aliases: "-u",
+                   desc: "URN for the dataset source " \
+                         "(used for section references)"
 
       def extract_terms(schema_manifest_file, output_path)
-        unless File.exist?(File.expand_path(schema_manifest_file))
-          raise Errno::ENOENT, "Specified SCHEMA_MANIFEST_FILE " \
-                               "`#{schema_manifest_file}` not found."
-        end
-
         TermExtractor.new(
           schema_manifest_file,
           output_path,
           language_code: options[:language_code],
+          urn: options[:urn],
         ).call
       end
     end

data/lib/suma/cli/generate_register.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Suma
+  module Cli
+    class GenerateRegister < Thor
+      desc "generate_register SCHEMA_MANIFEST_FILE OUTPUT_PATH",
+           "Generate a Glossarist register.yaml with hierarchical sections"
+      option :language_code, type: :string, default: "eng", aliases: "-l",
+                             desc: "Language code for section names"
+      option :urn, type: :string, required: true, aliases: "-u",
+                   desc: "URN prefix for the dataset"
+      option :id, type: :string, required: true,
+                  desc: "Dataset identifier (e.g. iso10303-2-express)"
+      option :ref, type: :string, required: true,
+                   desc: "Human-readable reference label"
+      option :owner, type: :string, default: Suma::RegisterManifestGenerator::DEFAULT_OWNER,
+                     desc: "Owner of the dataset (e.g. 'ISO/TC 184/SC 4')"
+
+      def generate_register(schema_manifest_file, output_path)
+        RegisterManifestGenerator.new(
+          schema_manifest_file,
+          output_path,
+          urn: options[:urn],
+          id: options[:id],
+          ref: options[:ref],
+          language_code: options[:language_code],
+          owner: options[:owner],
+        ).generate
+      end
+    end
+  end
+end

data/lib/suma/cli/generate_schemas.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "../thor_ext"
-require_relative "../schema_manifest_generator"
 
 module Suma
   module Cli