suma 0.2.5 → 0.2.6

data/lib/suma/schema_comparer.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+require_relative "eengine/wrapper"
+require_relative "eengine_converter"
+
+module Suma
+  class SchemaComparer
+    attr_reader :trial_schema, :reference_schema, :options
+
+    def initialize(trial_schema, reference_schema, options = {})
+      @trial_schema = trial_schema
+      @reference_schema = reference_schema
+      @options = options
+    end
+
+    def compare
+      validate_inputs
+
+      trial_stepmod = options[:trial_stepmod] || detect_repo_root(trial_schema)
+      reference_stepmod = options[:reference_stepmod] || detect_repo_root(reference_schema)
+
+      out_dir = Dir.mktmpdir("eengine-compare-")
+
+      result = Eengine::Wrapper.compare(
+        trial_schema,
+        reference_schema,
+        mode: options[:mode] || "resource",
+        trial_stepmod: trial_stepmod,
+        reference_stepmod: reference_stepmod,
+        out_dir: out_dir,
+      )
+
+      unless result[:has_changes]
+        FileUtils.rm_rf(out_dir) if File.directory?(out_dir)
+        return nil
+      end
+
+      raise Suma::CompilationError, "XML output not found" unless result[:xml_path]
+
+      convert_to_change_yaml(result[:xml_path], out_dir)
+    ensure
+      FileUtils.rm_rf(out_dir) if out_dir && File.directory?(out_dir)
+    end
+
+    private
+
+    def validate_inputs
+      unless File.exist?(trial_schema)
+        raise Suma::SchemaNotFoundError,
+              "Trial schema not found: #{trial_schema}"
+      end
+
+      unless File.exist?(reference_schema)
+        raise Suma::SchemaNotFoundError,
+              "Reference schema not found: #{reference_schema}"
+      end
+
+      unless Eengine::Wrapper.available?
+        raise Suma::EengineNotAvailableError,
+              "eengine not found in PATH. Install from:\n  " \
+              "macOS: https://github.com/expresslang/homebrew-eengine\n  " \
+              "Linux: https://github.com/expresslang/eengine-releases"
+      end
+    end
+
+    def detect_repo_root(schema_path)
+      current = File.expand_path(File.dirname(schema_path))
+
+      loop do
+        return current if File.directory?(File.join(current, ".git"))
+
+        parent = File.dirname(current)
+        break if parent == current
+
+        current = parent
+      end
+
+      File.dirname(schema_path)
+    end
+
+    def convert_to_change_yaml(xml_path, _out_dir)
+      schema_name = extract_schema_name(trial_schema)
+      output_path = determine_output_path
+
+      existing_schema = nil
+      if File.exist?(output_path)
+        require "expressir/changes"
+        existing_schema = Expressir::Changes::SchemaChange.from_file(output_path)
+      end
+
+      converter = EengineConverter.new(xml_path, schema_name)
+      change_schema = converter.convert(
+        version: options[:version],
+        existing_change_schema: existing_schema,
+      )
+
+      change_schema.to_file(output_path)
+      output_path
+    end
+
+    def extract_schema_name(path)
+      basename = File.basename(path, ".exp")
+      basename.sub(/_\d+$/, "")
+    end
+
+    def determine_output_path
+      options[:output] || begin
+        base = extract_schema_name(trial_schema)
+        dir = File.dirname(trial_schema)
+        File.join(dir, "#{base}.changes.yaml")
+      end
+    end
+  end
+end

data/lib/suma/schema_document.rb

@@ -85,24 +85,10 @@ module Suma
       HEREDOC
     end
 
-    #  ////
-    #   TODO:
-    #   % render "templates/entities", schema: schema, schema_id: schema.id, things: schema.entities, thing_prefix: root_thing_prefix, depth: 2 %
-    #
-    #   % render "templates/subtype_constraints", schema_id: schema.id, things: schema.subtype_constraints, thing_prefix: root_thing_prefix, depth: 2 %
-    #
-    #   % render "templates/functions", schema_id: schema.id, things: schema.functions, thing_prefix: root_thing_prefix, depth: 2 %
-    #
-    #   % render "templates/procedures", schema_id: schema.id, things: schema.procedures, thing_prefix: root_thing_prefix, depth: 2 %
-    #
-    #   % render "templates/rules", schema_id: schema.id, things: schema.rules, thing_prefix: root_thing_prefix, depth: 2 %
-    #   ////
-
     def output_extensions
       "xml"
     end
 
-    # #.gsub(/[\n\r]{2,}/, '')
     def to_adoc(path_to_schema_yaml)
       <<~HEREDOC
         = #{@schema.id}

data/lib/suma/schema_exporter.rb

@@ -2,13 +2,21 @@
 
 require_relative "express_schema"
 require_relative "utils"
-require_relative "export_standalone_schema"
 require "fileutils"
 
 module Suma
   # SchemaExporter exports EXPRESS schemas from a manifest
   # with configurable options for annotations and ZIP packaging
   class SchemaExporter
+    CATEGORY_MAP = {
+      ExpressSchema::Type::RESOURCE => "resources",
+      ExpressSchema::Type::MODULE_ARM => "modules",
+      ExpressSchema::Type::MODULE_MIM => "modules",
+      ExpressSchema::Type::BUSINESS_OBJECT_MODEL => "business_object_models",
+      ExpressSchema::Type::CORE_MODEL => "core_model",
+      ExpressSchema::Type::STANDALONE => ".",
+    }.freeze
+
     attr_reader :schemas, :output_path, :options
 
     def initialize(schemas:, output_path:, options: {})
@@ -43,52 +51,32 @@ module Suma
     end
 
     def export_single_schema(schema)
-      # Check if this is a standalone EXPRESS file
-      # (not from a manifest structure)
-      is_standalone_file = schema.is_a?(ExportStandaloneSchema)
-      schema_output_path = determine_output_path(schema, is_standalone_file)
+      is_standalone = !schema.is_a?(Expressir::SchemaManifestEntry)
+      schema_output_path = determine_output_path(schema, is_standalone)
 
       express_schema = ExpressSchema.new(
         id: schema.id,
         path: schema.path.to_s,
         output_path: schema_output_path,
-        is_standalone_file: is_standalone_file,
+        is_standalone_file: is_standalone,
       )
 
       express_schema.save_exp(with_annotations: options[:annotations])
     end
 
-    def determine_output_path(schema, is_standalone_file)
-      if is_standalone_file
-        # For standalone files, output directly to the root
+    def determine_output_path(schema, is_standalone)
+      if is_standalone
         output_path.to_s
       else
-        # For manifest schemas, preserve directory structure
         category = categorize_schema(schema)
         output_path.join(category).to_s
       end
     end
 
-    # rubocop:disable Metrics/MethodLength
     def categorize_schema(schema)
-      path = schema.path.to_s
-
-      # Check if this is from a manifest structure or a standalone EXPRESS file
-      case path
-      when %r{/resources/}
-        "resources"
-      when %r{/modules/}
-        "modules"
-      when %r{/business_object_models/}
-        "business_object_models"
-      when %r{/core_model/}
-        "core_model"
-      else
-        # standalone EXPRESS file not from a manifest structure
-        "standalone"
-      end
+      type = ExpressSchema::Type.classify(id: schema.id, path: schema.path)
+      CATEGORY_MAP.fetch(type, "standalone")
     end
-    # rubocop:enable Metrics/MethodLength
 
     # rubocop:disable Metrics/MethodLength
     def create_zip_archive

data/lib/suma/schema_index.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "expressir"
+
+module Suma
+  # Pre-built index for O(1) schema and element lookup.
+  # Build once from a parsed repo, then query by name.
+  class SchemaIndex
+    def initialize(repo)
+      @schemas_by_name = {}
+      @elements_by_schema = {}
+
+      repo.schemas.each do |schema|
+        key = schema.id.downcase
+        @schemas_by_name[key] = schema
+        @elements_by_schema[key] = build_element_index(schema)
+      end
+    end
+
+    def find_schema(name)
+      @schemas_by_name[name.downcase]
+    end
+
+    def find_element(schema_name, element_name)
+      elements = @elements_by_schema[schema_name.downcase]
+      elements&.[](element_name.downcase)
+    end
+
+    private
+
+    def build_element_index(schema)
+      index = {}
+
+      element_collections(schema).each do |collection|
+        collection&.each { |e| index[e.id.downcase] = e }
+      end
+
+      index
+    end
+
+    def element_collections(schema)
+      [
+        schema.entities,
+        schema.types,
+        schema.constants,
+        schema.functions,
+        schema.rules,
+        schema.procedures,
+        schema.subtype_constraints,
+      ]
+    end
+  end
+end

data/lib/suma/schema_manifest_generator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+require_relative "utils"
+
+module Suma
+  class SchemaManifestGenerator
+    YAML_FILE_EXTENSIONS = [".yaml", ".yml"].freeze
+
+    def initialize(metanorma_manifest_file, schema_manifest_file, exclude_paths: nil)
+      @metanorma_manifest_file = File.expand_path(metanorma_manifest_file)
+      @schema_manifest_file = schema_manifest_file
+      @exclude_paths = exclude_paths
+    end
+
+    def generate
+      validate_inputs
+      metanorma_data = load_yaml(@metanorma_manifest_file)
+      collection_files = metanorma_data["metanorma"]["source"]["files"]
+      manifest_files = load_manifest_files(collection_files)
+      all_schemas = load_project_schemas(manifest_files)
+      all_schemas["schemas"] = all_schemas["schemas"].sort.to_h
+      write_output(all_schemas)
+    end
+
+    private
+
+    def validate_inputs
+      raise Errno::ENOENT, "Specified file `#{@metanorma_manifest_file}` not found." unless File.exist?(@metanorma_manifest_file)
+
+      raise ArgumentError, "Specified path `#{@metanorma_manifest_file}` is not a file." unless File.file?(@metanorma_manifest_file)
+
+      [@metanorma_manifest_file, @schema_manifest_file].each do |file|
+        unless YAML_FILE_EXTENSIONS.include?(File.extname(file))
+          raise ArgumentError, "Specified file `#{file}` is not a YAML file."
+        end
+      end
+    end
+
+    def load_yaml(file_path)
+      YAML.safe_load(File.read(file_path, encoding: "UTF-8"), aliases: true)
+    end
+
+    def load_manifest_files(collection_files)
+      collection_files.map do |c|
+        collection_data = load_yaml(c)
+        collection_data["manifest"]["docref"].map { |docref| docref["file"] }
+      end.flatten
+    end
+
+    def load_project_schemas(manifest_files)
+      all_schemas = { "schemas" => {} }
+
+      manifest_files.each do |file|
+        schemas_file_path = File.expand_path(file.gsub("collection.yml", "schemas.yaml"))
+
+        unless File.exist?(schemas_file_path)
+          Utils.log "Schemas file not found: #{schemas_file_path}"
+          next
+        end
+
+        schemas_data = load_yaml(schemas_file_path)
+
+        if schemas_data["schemas"]
+          schemas_data["schemas"] = fix_path(schemas_data, schemas_file_path)
+          all_schemas["schemas"].merge!(schemas_data["schemas"])
+        end
+
+        if @exclude_paths
+          all_schemas["schemas"].delete_if do |_key, value|
+            value["path"].match?(
+              Regexp.new(@exclude_paths.gsub("*", "(.*){1,999}")),
+            )
+          end
+        end
+      end
+
+      all_schemas
+    end
+
+    def fix_path(schemas_data, schemas_file_path)
+      schema_manifest_path = File.expand_path(@schema_manifest_file, Dir.pwd)
+
+      schemas_data["schemas"].each do |key, value|
+        path_in_schema = File.expand_path(value["path"], File.dirname(schemas_file_path))
+
+        fixed_path = Pathname.new(path_in_schema).relative_path_from(
+          Pathname.new(File.dirname(schema_manifest_path)),
+        )
+
+        { key => value.merge!("path" => fixed_path.to_s) }
+      end
+
+      schemas_data["schemas"]
+    end
+
+    def write_output(all_schemas)
+      output_path = File.expand_path(@schema_manifest_file)
+      Utils.log "Writing the Schemas YAML file to #{output_path}..."
+      File.write(output_path, all_schemas.to_yaml)
+      Utils.log "Writing the Schemas YAML file to #{output_path}...Done"
+    end
+  end
+end

data/lib/suma/svg_quality/batch_report.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "report"
+
+module Suma
+  module SvgQuality
+    # Batch report wrapping multiple SVG quality reports
+    class BatchReport
+      attr_reader :reports
+
+      def initialize(reports)
+        @reports = reports
+      end
+
+      def total_files
+        @reports.size
+      end
+
+      def successful
+        @reports.count(&:valid?)
+      end
+
+      def failed
+        total_files - successful
+      end
+
+      def avg_quality_score
+        return 0 if @reports.empty?
+
+        @reports.sum(&:quality_score).to_f / total_files
+      end
+
+      def total_errors
+        @reports.sum(&:error_count)
+      end
+
+      def avg_error_count
+        return 0 if @reports.empty?
+
+        total_errors.to_f / total_files
+      end
+
+      def quality_distribution
+        dist = Hash.new(0)
+        @reports.each do |r|
+          dist[r.quality_tier[:name].to_s] += 1
+        end
+        dist
+      end
+
+      def sort_by_quality
+        self.class.new(@reports.sort_by(&:quality_score))
+      end
+
+      def sort_by_errors
+        self.class.new(@reports.sort_by { |r| -r.error_count })
+      end
+
+      def limit(count)
+        return self if count.nil?
+
+        self.class.new(@reports.first(count))
+      end
+
+      def filter_by_min_errors(min)
+        return self if min.nil?
+
+        self.class.new(@reports.select { |r| r.error_count >= min })
+      end
+
+      def to_json(*_args)
+        JSON.pretty_generate(@reports.map(&:to_h))
+      end
+
+      def to_yaml
+        YAML.dump(@reports.map(&:to_h))
+      end
+    end
+  end
+end

data/lib/suma/svg_quality/formatters/json_formatter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Suma
+  module SvgQuality
+    module Formatters
+      # JSON output formatter
+      class JsonFormatter
+        def initialize(batch_report, output: nil)
+          @batch_report = batch_report
+          @output = output
+        end
+
+        def format
+          write_output(@batch_report.to_json)
+        end
+
+        private
+
+        def write_output(content)
+          if @output
+            File.write(@output, content)
+            "[suma] Results written to #{@output}"
+          else
+            content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/suma/svg_quality/formatters/terminal_formatter.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Suma
+  module SvgQuality
+    module Formatters
+      # Terminal output formatter with ASCII art and emojis
+      class TerminalFormatter
+        BORDER = "─"
+        BOX_WIDTH = 80
+
+        def initialize(batch_report, output: nil, sort: :quality)
+          @batch_report = batch_report
+          @output = output
+          @sort = sort.to_sym
+        end
+
+        def format
+          output_content = [
+            header,
+            "",
+            summary_section,
+            "",
+            distribution_section,
+            "",
+            files_by_tier_section,
+            "",
+            footer,
+          ].join("\n")
+
+          write_output(output_content)
+        end
+
+        private
+
+        attr_reader :batch_report
+
+        def header
+          sort_label = case @sort
+                       when :errors then "error count (most first)"
+                       else "quality score (lowest first)"
+                       end
+
+          "╔#{'═' * (BOX_WIDTH - 2)}╗\n" \
+            "║  🔍 SVG Quality Report    Sorted by #{sort_label.ljust(33)}║\n" \
+            "╚#{'═' * (BOX_WIDTH - 2)}╝"
+        end
+
+        def summary_section
+          lines = []
+          lines << "  📊 OVERVIEW"
+          lines << ""
+          lines << "    ● Total Files   : #{batch_report.total_files}"
+          lines << "    ● Valid         : #{batch_report.successful} ✅"
+          lines << "    ● Invalid      : #{batch_report.failed} ❌"
+          lines << "    ● Avg Score    : #{batch_report.avg_quality_score.round(1)}/100"
+          lines << "    ● Total Errors : #{batch_report.total_errors}"
+          lines << "    ● Avg Errors   : #{batch_report.avg_error_count.round(1)}/file"
+          lines << ""
+
+          if (worst = batch_report.reports.first)
+            tier = worst.quality_tier
+            lines << "  🚨 WORST OFFENDER"
+            lines << ""
+            lines << "    #{tier[:emoji]} #{shorten_path(worst.file_path)}"
+            lines << "    Score: #{worst.quality_score}/100 | Errors: #{worst.error_count} | #{tier[:name].to_s.upcase}"
+          end
+
+          lines.join("\n")
+        end
+
+        def distribution_section
+          lines = []
+          lines << "  📈 QUALITY DISTRIBUTION"
+          lines << ""
+
+          total = batch_report.total_files
+          dist = batch_report.quality_distribution
+
+          QualityTiers::ALL.each do |tier|
+            count = dist[tier[:name].to_s].to_i
+            pct = total.positive? ? (count.to_f / total * 100) : 0
+            bar_len = (count.to_f / total * 40).round
+            bar = bar_len.positive? ? "█" * bar_len : ""
+            empty = "░" * (40 - bar_len)
+
+            lines << "    #{tier[:emoji]} #{tier[:name].to_s.upcase.ljust(9)} #{bar}#{empty} #{count.to_s.rjust(4)} (#{sprintf(
+              '%.1f', pct
+            )}%)"
+          end
+
+          lines.join("\n")
+        end
+
+        def files_by_tier_section
+          lines = []
+
+          if @sort == :errors
+            # When sorting by errors, show flat list (worst offenders first)
+            lines << ""
+            lines << "  📋 ALL FILES (sorted by error count, worst first)"
+            lines << ""
+
+            batch_report.reports.each do |report|
+              lines << format_file_line(report)
+            end
+          else
+            # When sorting by quality, group by tier - iterate CRITICAL first (worst first)
+            reports_by_tier = batch_report.reports.group_by do |r|
+              r.quality_tier[:name]
+            end
+
+            QualityTiers::ALL.each do |tier|
+              tier_reports = reports_by_tier[tier[:name]]
+              next unless tier_reports&.any?
+
+              lines << ""
+              lines << "  #{tier[:emoji]} #{tier[:name].to_s.upcase} QUALITY (#{tier_reports.size} files)"
+              lines << ""
+
+              tier_reports.each do |report|
+                lines << format_file_line(report)
+              end
+            end
+          end
+
+          lines.join("\n")
+        end
+
+        def format_file_line(report)
+          path = shorten_path(report.file_path)
+          score = report.quality_score.to_i.to_s.rjust(3)
+          errors = report.error_count.to_s.rjust(5)
+          valid_str = report.valid? ? "✓" : "✗"
+
+          "    #{valid_str} #{score}/100  #{errors} errors  #{path}"
+        end
+
+        def shorten_path(path)
+          p = Pathname.new(path)
+          if p.absolute?
+            begin
+              p.relative_path_from(Pathname.pwd)
+            rescue StandardError
+              p
+            end
+          else
+            p
+          end.to_s
+        end
+
+        def footer
+          BORDER * BOX_WIDTH
+        end
+
+        def write_output(content)
+          if @output
+            File.write(@output, content)
+            "[suma] Results written to #{@output}"
+          else
+            content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/suma/svg_quality/formatters/yaml_formatter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Suma
+  module SvgQuality
+    module Formatters
+      # YAML output formatter
+      class YamlFormatter
+        def initialize(batch_report, output: nil)
+          @batch_report = batch_report
+          @output = output
+        end
+
+        def format
+          write_output(@batch_report.to_yaml)
+        end
+
+        private
+
+        def write_output(content)
+          if @output
+            File.write(@output, content)
+            "[suma] Results written to #{@output}"
+          else
+            content
+          end
+        end
+      end
+    end
+  end
+end