suma 0.2.5 → 0.3.0

data/lib/suma/cli.rb

@@ -1,108 +1,18 @@
 # frozen_string_literal: true
 
-require "thor"
-require_relative "thor_ext"
-require_relative "cli/validate"
-require "expressir"
-require "expressir/cli"
-
 module Suma
   module Cli
-    # Core command class for handling CLI entrypoints
-    class Core < Thor
-      extend ThorExt::Start
-
-      desc "build METANORMA_SITE_MANIFEST",
-           "Build collection specified in site manifest (`metanorma*.yml`)"
-      option :compile, type: :boolean, default: true,
-                       desc: "Compile or skip compile of collection"
-      option :schemas_all_path, type: :string, aliases: "-s",
-                                desc: "Generate file that contains all " \
-                                      "schemas in the collection."
-      def build(_site_manifest)
-        require_relative "cli/build"
-        Cli::Build.start
-      end
-
-      desc "generate-schemas METANORMA_MANIFEST_FILE SCHEMA_MANIFEST_FILE",
-           "Generate EXPRESS schema manifest file from Metanorma site manifest"
-      option :exclude_paths, type: :string, default: nil, aliases: "-e",
-                             desc: "Exclude schemas paths by pattern " \
-                                   "(e.g. `*_lf.exp`)"
-      def generate_schemas(_metanorma_manifest_file, _schema_manifest_file)
-        require_relative "cli/generate_schemas"
-        Cli::GenerateSchemas.start
-      end
-
-      desc "reformat EXPRESS_FILE_PATH",
-           "Reformat EXPRESS files"
-      option :recursive, type: :boolean, default: false, aliases: "-r",
-                         desc: "Reformat EXPRESS files under the specified " \
-                               "path recursively"
-      def reformat(_express_file_path)
-        require_relative "cli/reformat"
-        Cli::Reformat.start
-      end
-
-      desc "extract-terms SCHEMA_MANIFEST_FILE GLOSSARIST_OUTPUT_PATH",
-           "Extract terms from SCHEMA_MANIFEST_FILE into " \
-           "Glossarist v2 format"
-      option :language_code, type: :string, default: "eng", aliases: "-l",
-                             desc: "Language code for the Glossarist"
-      def extract_terms(_schema_manifest_file, _glossarist_output_path)
-        require_relative "cli/extract_terms"
-        Cli::ExtractTerms.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)
-        require_relative "cli/convert_jsdai"
-        Cli::ConvertJsdai.start
-      end
-
-      desc "export *FILES",
-           "Export EXPRESS schemas from manifest files or " \
-           "standalone EXPRESS files"
-      option :output, type: :string, aliases: "-o", required: true,
-                      desc: "Output directory path"
-      option :annotations, type: :boolean, default: false,
-                           desc: "Include annotations (remarks/comments)"
-      option :zip, type: :boolean, default: false,
-                   desc: "Create ZIP archive of exported schemas"
-      def export(*_files)
-        require_relative "cli/export"
-        Cli::Export.start
-      end
-
-      desc "compare TRIAL_SCHEMA REFERENCE_SCHEMA",
-           "Compare EXPRESS schemas using eengine and generate Change YAML"
-      option :output, type: :string, aliases: "-o",
-                      desc: "Output Change YAML file path"
-      option :version, type: :string, aliases: "-v", required: true,
-                       desc: "Version number for this change version"
-      option :mode, type: :string, default: "resource",
-                    desc: "Schema comparison mode (resource/module)"
-      option :trial_stepmod, type: :string,
-                             desc: "Override auto-detected trial repo root"
-      option :reference_stepmod, type: :string,
-                                 desc: "Override auto-detected reference repo root"
-      option :verbose, type: :boolean, default: false,
-                       desc: "Enable verbose output"
-      def compare(_trial_schema, _reference_schema)
-        require_relative "cli/compare"
-        Cli::Compare.start
-      end
-
-      desc "validate SUBCOMMAND ...ARGS", "Validate express documents"
-      subcommand "validate", Cli::Validate
-
-      desc "expressir SUBCOMMAND ...ARGS", "Expressir commands"
-      subcommand "expressir", Expressir::Cli
-
-      def self.exit_on_failure?
-        true
-      end
-    end
+    autoload :Core,             "suma/cli/core"
+    autoload :Build,            "suma/cli/build"
+    autoload :CheckSvgQuality,  "suma/cli/check_svg_quality"
+    autoload :Compare,          "suma/cli/compare"
+    autoload :ConvertJsdai,     "suma/cli/convert_jsdai"
+    autoload :Export,           "suma/cli/export"
+    autoload :ExtractTerms,     "suma/cli/extract_terms"
+    autoload :GenerateRegister, "suma/cli/generate_register"
+    autoload :GenerateSchemas,  "suma/cli/generate_schemas"
+    autoload :Reformat,         "suma/cli/reformat"
+    autoload :Validate,         "suma/cli/validate"
+    autoload :ValidateLinks,    "suma/cli/validate_links"
   end
 end

data/lib/suma/collection_config.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "utils"
 require "lutaml/model"
-require_relative "collection_manifest"
 require "metanorma"
 
 module Suma

data/lib/suma/collection_manifest.rb

@@ -4,11 +4,17 @@ require "metanorma"
 require "expressir"
 
 module Suma
+  # Pure data model for one node of a Metanorma collection manifest.
+  #
+  # CollectionManifest extends the Metanorma config manifest to add the
+  # `schemas_only` flag and an `entry` sub-collection. It owns only state:
+  # attributes, YAML mappings, and the `schema_config` slot populated by
+  # SchemaDiscovery. Tree-walking logic lives in ManifestTraverser; schema
+  # I/O lives in SchemaDiscovery.
   class CollectionManifest < Metanorma::Collection::Config::Manifest
     attribute :schemas_only, Lutaml::Model::Type::Boolean
     attribute :entry, CollectionManifest, collection: true,
                                           initialize_empty: true
-    # attribute :schema_source, Lutaml::Model::Type::String
     attr_accessor :schema_config
 
     yaml do
@@ -33,115 +39,5 @@ module Suma
     def docref_from_yaml(model, value)
       model.entry = CollectionManifest.from_yaml(value.to_yaml)
     end
-
-    # Recursively exports schema configuration by traversing collection manifests.
-    #
-    # This method builds an EXPRESS Schema Manifest (Expressir::SchemaManifest) by:
-    # 1. Starting with an empty or existing Expressir::SchemaManifest
-    # 2. Recursively traversing child entries to collect schemas
-    # 3. Using Expressir::SchemaManifest#concat to combine manifests
-    #
-    # The actual schema manifest operations (creation, concatenation, serialization)
-    # are handled by Expressir's SchemaManifest class, keeping the logic DRY.
-    #
-    # @param path [String] Base path for resolving relative schema paths
-    # @return [Expressir::SchemaManifest] Combined schema manifest
-    def export_schema_config(path)
-      export_config = @schema_config || Expressir::SchemaManifest.new
-      return export_config unless entry
-
-      entry.each do |x|
-        child_config = x.export_schema_config(path)
-        # Use Expressir's concat method to combine schema manifests
-        export_config.concat(child_config) if child_config
-      end
-
-      export_config
-    end
-
-    def lookup(attr_sym, match)
-      results = entry.select { |e| e.send(attr_sym) == match }
-      results << self if send(attr_sym) == match
-      results
-    end
-
-    def process_entry(schema_output_path)
-      return [self] unless entry
-
-      ret = entry.each_with_object([]) do |e, m|
-        add = e.expand_schemas_only(schema_output_path)
-        m.concat(add)
-      end
-
-      self.entry = ret
-      [self]
-    end
-
-    def expand_schemas_only(schema_output_path)
-      return process_entry(schema_output_path) unless file
-
-      update_schema_config
-
-      return process_entry(schema_output_path) unless schemas_only
-
-      # If we are going to keep the schemas-only file and compile it, we can't
-      # have it showing up in output.
-      self.index = false
-
-      [self, added_collection_manifest(schema_output_path)]
-    end
-
-    def remove_schemas_only_sources
-      ret = entry.each_with_object([]) do |e, m|
-        e.schemas_only or m << e
-      end
-      self.entry = ret
-    end
-
-    def entries(schema_output_path)
-      @schema_config.schemas.map do |schema|
-        fname = [File.basename(schema.path, ".exp"), ".xml"].join
-
-        CollectionManifest.new(
-          identifier: schema.id,
-          title: schema.id,
-          file: File.join(schema_output_path, schema.id, "doc_#{fname}"),
-          # schema_source: schema.path
-        )
-      end
-    end
-
-    def added_collection_manifest(schema_output_path)
-      doc = CollectionConfig.from_file(file)
-      doc_id = doc.bibdata.id
-
-      # we need to separate this file from the following new entries
-      added = CollectionManifest.new(
-        title: "Collection",
-        type: "collection",
-        identifier: "#{identifier}_",
-      )
-
-      added.entry = [
-        CollectionManifest.new(
-          title: doc_id,
-          type: "document",
-          entry: entries(schema_output_path),
-        ),
-      ]
-
-      added
-    end
-
-    def update_schema_config
-      # If there is collection.yml, this is a document collection, we process
-      # schemas.yaml.
-      if File.basename(file) == "collection.yml"
-        schemas_yaml_path = File.join(File.dirname(file), "schemas.yaml")
-        if schemas_yaml_path && File.exist?(schemas_yaml_path)
-          @schema_config = Expressir::SchemaManifest.from_file(schemas_yaml_path)
-        end
-      end
-    end
   end
 end

data/lib/suma/eengine/wrapper.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "open3"
-require_relative "errors"
 
 module Suma
   module Eengine

data/lib/suma/eengine.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Suma
+  module Eengine
+    autoload :Errors,  "suma/eengine/errors"
+    autoload :Wrapper, "suma/eengine/wrapper"
+  end
+end

data/lib/suma/express_schema.rb

@@ -1,11 +1,46 @@
 # frozen_string_literal: true
 
-require_relative "utils"
 require "fileutils"
 require "expressir"
 
 module Suma
   class ExpressSchema
+    module Type
+      RESOURCE              = :resource
+      MODULE_ARM            = :module_arm
+      MODULE_MIM            = :module_mim
+      BUSINESS_OBJECT_MODEL = :business_object_model
+      CORE_MODEL            = :core_model
+      STANDALONE            = :standalone
+
+      ID_SUFFIXES = {
+        "_arm" => :MODULE_ARM,
+        "_mim" => :MODULE_MIM,
+        "_bom" => :BUSINESS_OBJECT_MODEL,
+      }.freeze
+
+      PATH_SEGMENTS = {
+        "/resources/" => :RESOURCE,
+        "/modules/" => :MODULE_ARM,
+        "/core_model/" => :CORE_MODEL,
+      }.freeze
+
+      def self.classify(id:, path:)
+        name = id&.downcase || ""
+
+        ID_SUFFIXES.each do |suffix, type|
+          return const_get(type) if name.end_with?(suffix)
+        end
+
+        path_str = path.to_s
+        PATH_SEGMENTS.each do |segment, type|
+          return const_get(type) if path_str.include?(segment)
+        end
+
+        STANDALONE
+      end
+    end
+
     attr_accessor :path, :id, :parsed, :output_path, :is_standalone_file
 
     def initialize(id:, path:, output_path:, is_standalone_file: false)
@@ -16,14 +51,7 @@ module Suma
     end
 
     def type
-      path_str = @path.to_s
-      if path_str.include?("/resources/")
-        "resources"
-      elsif path_str.include?("/modules/")
-        "modules"
-      else
-        "unknown_type"
-      end
+      @type ||= classify
     end
 
     def parsed
@@ -50,11 +78,8 @@ module Suma
 
     def build_output_filename
       if @is_standalone_file
-        # For standalone files, output directly to output_path
         File.join(@output_path, "#{@id}.exp")
       else
-        # For manifest schemas, preserve directory structure
-        # Note: @output_path already contains the category (resources/modules)
         parent_dir = File.basename(File.dirname(@path))
         File.join(@output_path, parent_dir, File.basename(@path))
       end
@@ -65,29 +90,16 @@ module Suma
       schema_type = with_annotations ? "annotated" : "plain"
       Utils.log "Save #{schema_type} schema: #{relative_path}"
 
-      # return if File.exist?(filename_plain)
       FileUtils.mkdir_p(File.dirname(filename_plain))
 
       content = with_annotations ? parsed.to_s(no_remarks: false) : to_plain
       File.write(filename_plain, content)
     end
-  end
-end
-
-# col = Suma::SchemaCollection.new(
-#         config_yaml: 'suma-schemas.yaml',
-#         output_path_docs: 'schema_docs',
-#         output_path_schemas: 'plain_schemas'
-#       )
-
-# docs = col.compile
 
-# paths = col.schemas.map do |schema|
-#   {
-#     plain_schema_path: schema.filename_plain,
-#     schema_doc_path: col.doc_from_schema_name(schema.id).output_xml_path
-#   }
-# end
+    private
 
-# Utils.log "COMPILED FILES ARE AT:"
-# pp paths
+    def classify
+      Type.classify(id: @id, path: @path)
+    end
+  end
+end

data/lib/suma/jsdai/figure.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "figure_xml"
-require_relative "figure_image"
-
 module Suma
   module Jsdai
     # Main class for JSDAI figure conversion

data/lib/suma/jsdai/figure_xml.rb

@@ -11,10 +11,11 @@ module Suma
       attribute :href, :string
 
       xml do
-        root "img.area"
-        map_attribute "shape", to: :shape
-        map_attribute "coords", to: :coords
-        map_attribute "href", to: :href
+        element "img.area"
+        ordered
+        map_attribute "shape", to: :shape, render_empty: true
+        map_attribute "coords", to: :coords, render_empty: true
+        map_attribute "href", to: :href, render_empty: true
       end
     end
 
@@ -24,8 +25,9 @@ module Suma
       attribute :areas, FigureXmlImageArea, collection: true
 
       xml do
-        root "img"
-        map_attribute "src", to: :src
+        element "img"
+        ordered
+        map_attribute "src", to: :src, render_empty: true
         map_element "img.area", to: :areas
       end
     end
@@ -37,9 +39,10 @@ module Suma
       attribute :img, FigureXmlImage
 
       xml do
-        root "imgfile.content"
-        map_attribute "module", to: :module
-        map_attribute "file", to: :file
+        element "imgfile.content"
+        ordered
+        map_attribute "module", to: :module, render_empty: true
+        map_attribute "file", to: :file, render_empty: true
         map_element "img", to: :img
       end
     end

data/lib/suma/jsdai.rb

@@ -1,12 +1,9 @@
+# frozen_string_literal: true
+
 module Suma
   module Jsdai
+    autoload :Figure,      "suma/jsdai/figure"
+    autoload :FigureImage, "suma/jsdai/figure_image"
+    autoload :FigureXml,   "suma/jsdai/figure_xml"
   end
 end
-
-require_relative "jsdai/figure"
-
-# Configure XML adapter to Nokogiri because Ox goes into a "stack level too
-# deep" error, for unknown reasons
-Lutaml::Model::Config.configure do |config|
-  config.xml_adapter_type = :nokogiri
-end

data/lib/suma/link_validator.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "expressir"
+
+module Suma
+  LinkValidationResult = Struct.new(:file, :line, :link, :reason,
+                                    keyword_init: true)
+
+  class LinkValidator
+    def initialize(index)
+      @index = index
+    end
+
+    def validate(links_by_file)
+      unresolved = []
+
+      links_by_file.each do |file, links|
+        line_index = build_link_line_index(file)
+        validate_file(file, links, line_index, unresolved)
+      end
+
+      unresolved
+    end
+
+    private
+
+    def build_link_line_index(file)
+      content = File.read(file)
+      index = {}
+      content.lines.each_with_index do |line, idx|
+        line.scan(/<<express:([^,>]+)(?:,[^>]+)?>>/).flatten.each do |link|
+          index[link] ||= idx
+        end
+      end
+      index
+    end
+
+    def validate_file(file, links, line_index, unresolved)
+      links.each do |link|
+        line_idx = line_index[link]
+        next unless line_idx
+
+        parts = link.split(".")
+
+        if parts.size == 1
+          validate_schema_only(parts[0], file, line_idx, link, unresolved)
+        else
+          validate_element(parts, file, line_idx, link, unresolved)
+        end
+      end
+    end
+
+    def validate_schema_only(schema_name, file, line_idx, link, unresolved)
+      schema = @index.find_schema(schema_name)
+
+      return if schema
+
+      unresolved << LinkValidationResult.new(
+        file: file,
+        line: line_idx + 1,
+        link: link,
+        reason: "Schema '#{schema_name}' not found",
+      )
+    end
+
+    def validate_element(parts, file, line_idx, link, unresolved)
+      schema_name = parts[0]
+      element_name = parts[1]
+
+      schema = @index.find_schema(schema_name)
+
+      unless schema
+        unresolved << LinkValidationResult.new(
+          file: file,
+          line: line_idx + 1,
+          link: link,
+          reason: "Schema '#{schema_name}' not found",
+        )
+        return
+      end
+
+      element = @index.find_element(schema_name, element_name)
+
+      unless element
+        unresolved << LinkValidationResult.new(
+          file: file,
+          line: line_idx + 1,
+          link: link,
+          reason: "Element '#{element_name}' not found in schema '#{schema_name}'",
+        )
+        return
+      end
+
+      return unless parts.size > 2
+
+      error = validate_deep_path(schema, element, parts[2..], file, line_idx,
+                                 link)
+      unresolved << error if error
+    end
+
+    def validate_deep_path(schema, element, path_parts, file, line_idx,
+full_link)
+      current = element
+      current_path = "#{schema.id}.#{element.id}"
+
+      path_parts.each do |part|
+        case current
+        when Expressir::Model::Declarations::Entity
+          attribute = current.attributes&.find do |a|
+            a.id.downcase == part.downcase
+          end
+
+          unless attribute
+            return LinkValidationResult.new(
+              file: file,
+              line: line_idx + 1,
+              link: full_link,
+              reason: "Attribute '#{part}' not found in entity '#{current_path}'",
+            )
+          end
+
+          current = attribute
+          current_path += ".#{part}"
+
+        when Expressir::Model::Declarations::Type
+          underlying = current.underlying_type
+
+          if underlying.is_a?(Expressir::Model::DataTypes::Enumeration)
+            enum_value = underlying.items.find do |e|
+              e.id.downcase == part.downcase
+            end
+
+            unless enum_value
+              return LinkValidationResult.new(
+                file: file,
+                line: line_idx + 1,
+                link: full_link,
+                reason: "Enumeration value '#{part}' not found in type '#{current_path}'",
+              )
+            end
+
+            current = enum_value
+            current_path += ".#{part}"
+
+          elsif underlying
+            base_type = find_base_type(schema, underlying)
+
+            unless base_type
+              return LinkValidationResult.new(
+                file: file,
+                line: line_idx + 1,
+                link: full_link,
+                reason: "Base type not found for '#{current_path}'",
+              )
+            end
+
+            current = base_type
+
+          else
+            return LinkValidationResult.new(
+              file: file,
+              line: line_idx + 1,
+              link: full_link,
+              reason: "Cannot navigate deeper from type '#{current_path}'",
+            )
+          end
+
+        else
+          return LinkValidationResult.new(
+            file: file,
+            line: line_idx + 1,
+            link: full_link,
+            reason: "Cannot navigate deeper from '#{current_path}'",
+          )
+        end
+      end
+
+      nil
+    end
+
+    def find_base_type(schema, type_ref)
+      return nil if %w[INTEGER REAL STRING BOOLEAN NUMBER BINARY
+                       LOGICAL].include?(type_ref.to_s.upcase)
+
+      if type_ref.is_a?(String)
+        find_schema_element(schema, type_ref)
+      elsif type_ref.is_a?(Expressir::Model::ModelElement)
+        type_ref
+      end
+    end
+
+    def find_schema_element(schema, element_name)
+      [
+        schema.entities,
+        schema.types,
+        schema.constants,
+        schema.functions,
+        schema.rules,
+        schema.procedures,
+        schema.subtype_constraints,
+      ].each do |collection|
+        element = collection&.find do |e|
+          e.id.downcase == element_name.downcase
+        end
+        return element if element
+      end
+
+      nil
+    end
+  end
+end