suma 0.2.5 → 0.2.6

data/lib/suma/express_schema.rb

@@ -6,6 +6,42 @@ 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 +52,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 +79,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 +91,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_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

@@ -4,9 +4,3 @@ module Suma
 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,203 @@
+# frozen_string_literal: true
+
+require_relative "schema_index"
+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 { |a| a.id.downcase == part.downcase }
+
+          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 { |e| e.id.downcase == part.downcase }
+
+            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 { |e| e.id.downcase == element_name.downcase }
+        return element if element
+      end
+
+      nil
+    end
+  end
+end

data/lib/suma/processor.rb

@@ -8,107 +8,81 @@ require "metanorma"
 
 module Suma
   class Processor
-    class << self
-      # rubocop:disable Metrics/MethodLength
-      def run(metanorma_yaml_path:, schemas_all_path:, compile:,
-output_directory: "_site")
-        Utils.log "Current directory: #{Dir.getwd}, writing #{schemas_all_path}..."
-
-        # Generate EXPRESS Schema Manifest by traversing Metanorma Site Manifest
-        # This uses Expressir::SchemaManifest for all manifest operations
-        collection_config = export_schema_config(metanorma_yaml_path,
-                                                 schemas_all_path)
-
-        unless compile
-          Utils.log "No compile option set. Skipping schema compilation."
-          return nil
-        end
-
-        Utils.log "Compiling schema collection..."
-        compile_schema(schemas_all_path, collection_config)
-
-        Utils.log "Compiling complete collection..."
-        compile_collection(collection_config, output_directory)
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      private
-
-      # Generates EXPRESS Schema Manifest from Metanorma Site Manifest structure.
-      #
-      # This method:
-      # 1. Reads the Metanorma site manifest to discover collection files
-      # 2. Traverses collection manifests to find individual schemas.yaml files
-      # 3. Uses Expressir::SchemaManifest to aggregate and manage schema entries
-      # 4. Saves the unified schema manifest using Expressir's to_file method
-      #
-      # @param metanorma_yaml_path [String] Path to Metanorma site manifest
-      # @param schemas_all_path [String] Output path for unified schema manifest
-      # @return [CollectionConfig] The loaded collection configuration
-      # rubocop:disable Metrics/MethodLength
-      def export_schema_config(metanorma_yaml_path, schemas_all_path)
-        # This reads the metanorma.yml file
-        site_config = Suma::SiteConfig::Config.from_file(metanorma_yaml_path)
-
-        # TODO: only reading the first file, which is a collection.yml, which is a hack...
-        collection_config_path = site_config.metanorma.source.files.first
-        collection_config = Suma::CollectionConfig.from_file(collection_config_path)
-        collection_config.path = collection_config_path
-        collection_config.manifest.expand_schemas_only("schema_docs")
-
-        # Recursively traverse collection manifests to build unified schema manifest
-        # Uses Expressir::SchemaManifest methods (concat, to_file) for operations
-        exported_schema_config = collection_config.manifest.export_schema_config(schemas_all_path)
-        exported_schema_config.path = schemas_all_path
-
-        # Save using Expressir's SchemaManifest#to_file method
-        exported_schema_config.to_file
-
-        collection_config
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      def compile_schema(schemas_all_path, collection_config)
-        # now get rid of the source documents for schema sources
-        col = Suma::SchemaCollection.new(
-          config_yaml: schemas_all_path,
-          manifest: collection_config.manifest,
-          output_path_docs: "schema_docs",
-          output_path_schemas: "plain_schemas",
-        )
-
-        col.compile
-      end
-
-      def compile_collection(collection_config, output_directory)
-        metanorma_collection, collection_opts = build_collection(
-          collection_config, output_directory
-        )
-
-        metanorma_collection.render(collection_opts)
-
-        # TODO: Temporarily disable removal of XML files
-        Dir.glob(File.join(Dir.getwd, output_directory,
-                           "*.xml")).each do |file|
-          puts "NOT DELETING ANY FILE #{file.inspect}"
-          # File.delete(file)
-        end
-      end
-
-      def build_collection(collection_config, output_directory)
-        new_collection_config_path = "collection-output.yaml"
-        collection_config.manifest.remove_schemas_only_sources
-        collection_config.to_file(new_collection_config_path)
-
-        collection = Metanorma::Collection.parse(new_collection_config_path)
-
-        collection_opts = {
-          output_folder: output_directory,
-          compile: { install_fonts: false },
-          coverpage: collection_config.coverpage || "cover.html",
-        }
-        [collection, collection_opts]
-      end
+    attr_reader :metanorma_yaml_path, :output_directory, :schemas_all_path,
+                :compile_flag
+
+    def initialize(metanorma_yaml_path:, schemas_all_path:, compile: true,
+                   output_directory: "_site")
+      @metanorma_yaml_path = metanorma_yaml_path
+      @schemas_all_path = schemas_all_path
+      @compile_flag = compile
+      @output_directory = output_directory
+    end
+
+    def run
+      Utils.log "Current directory: #{Dir.getwd}, writing #{schemas_all_path}..."
+
+      collection_config = export_schema_config
+
+      return nil unless @compile_flag
+
+      Utils.log "Compiling schema collection..."
+      compile_schema(schemas_all_path, collection_config)
+
+      Utils.log "Compiling complete collection..."
+      compile_collection(collection_config, output_directory)
+    end
+
+    private
+
+    def export_schema_config
+      site_config = Suma::SiteConfig::Config.from_file(metanorma_yaml_path)
+
+      collection_config_path = site_config.metanorma.source.files.first
+      collection_config = Suma::CollectionConfig.from_file(collection_config_path)
+      collection_config.path = collection_config_path
+      collection_config.manifest.expand_schemas_only("schema_docs")
+
+      exported_schema_config = collection_config.manifest.export_schema_config(schemas_all_path)
+      exported_schema_config.path = schemas_all_path
+
+      exported_schema_config.to_file
+
+      collection_config
+    end
+
+    def compile_schema(schemas_all_path, collection_config)
+      col = Suma::SchemaCollection.new(
+        config_yaml: schemas_all_path,
+        manifest: collection_config.manifest,
+        output_path_docs: "schema_docs",
+        output_path_schemas: "plain_schemas",
+      )
+
+      col.compile
+    end
+
+    def compile_collection(collection_config, output_directory)
+      metanorma_collection, collection_opts = build_collection(
+        collection_config, output_directory
+      )
+
+      metanorma_collection.render(collection_opts)
+    end
+
+    def build_collection(collection_config, output_directory)
+      new_collection_config_path = "collection-output.yaml"
+      collection_config.manifest.remove_schemas_only_sources
+      collection_config.to_file(new_collection_config_path)
+
+      collection = Metanorma::Collection.parse(new_collection_config_path)
+
+      collection_opts = {
+        output_folder: output_directory,
+        compile: { install_fonts: false },
+        coverpage: collection_config.coverpage || "cover.html",
+      }
+      [collection, collection_opts]
     end
   end
 end

data/lib/suma/schema_attachment.rb

@@ -50,15 +50,12 @@ module Suma
       relative_path = Pathname.new(filename_adoc).relative_path_from(Dir.pwd)
       Utils.log "Save EXPRESS adoc: #{relative_path}"
 
-      # return if File.exist?(filename_adoc)
       FileUtils.mkdir_p(File.dirname(filename_adoc))
 
-      relative_path = Pathname.new(filename_config)
+      config_relative = Pathname.new(filename_config)
         .relative_path_from(Pathname.new(File.dirname(filename_adoc)))
 
-      # Utils.log "relative_path #{relative_path}"
-
-      File.write(filename_adoc, to_adoc(relative_path))
+      File.write(filename_adoc, to_adoc(config_relative))
     end
 
     def filename_config
@@ -66,7 +63,6 @@ module Suma
     end
 
     def to_config(path: nil)
-      # return @config unless @config
       @config = Expressir::SchemaManifest.new
       @config.schemas << Expressir::SchemaManifestEntry.new(
         id: @schema.id,
@@ -81,8 +77,6 @@ module Suma
       relative_path = Pathname.new(filename_config).relative_path_from(Dir.pwd)
       Utils.log "Save schema config: #{relative_path}"
 
-      # Still overwrite even if the file exists
-      # return if File.exist?(filename_config)
       FileUtils.mkdir_p(File.dirname(filename_config))
 
       to_config.save_to_path(filename_config)
@@ -90,10 +84,6 @@ module Suma
 
     # Compile Metanorma adoc per EXPRESS schema
     def compile
-      # TODO: Clean artifacts after compiling
-      # I am commenting out because I'm playing with the schemas-only status
-      # return self if File.exist?(output_xml_path)
-
       save_config
       save_adoc
 
@@ -103,28 +93,11 @@ module Suma
                                                     install_fonts: false)
       Utils.log "Compiling schema (id: #{id}, type: #{self.class}) => #{relative_path}... done!"
 
-      # clean_artifacts
-
-      # filename_adoc('xml')
       self
     end
 
     def output_xml_path
       filename_adoc("xml")
     end
-
-    def clean_artifacts
-      [
-        filename_config,
-        filename_adoc,
-        filename_adoc("presentation.xml"),
-        filename_adoc("adoc.lutaml.log.txt"),
-        filename_adoc("err.html"),
-      ].each do |filename|
-        FileUtils.rm_rf(filename)
-      end
-    end
-
-    def output_folder; end
   end
 end

data/lib/suma/schema_collection.rb

@@ -52,24 +52,20 @@ module Suma
     end
 
     def finalize
-      # Process each schema in @config.schemas
       process_schemas(@config.schemas, SchemaAttachment)
 
-      manifest_entry = @manifest.lookup(:schemas_only, true)
+      manifest_entry = @manifest.lookup_schemas_only
 
       manifest_entry.each do |entry|
         next unless entry.schema_config
 
-        # Process each schema in entry.schema_config.schemas
         process_schemas(entry.schema_config.schemas, SchemaDocument)
       end
     end
 
-    # rubocop:disable Metrics/MethodLength
     def compile
       finalize
 
-      # Use SchemaExporter for schema export
       exporter = SchemaExporter.new(
         schemas: @config.schemas,
         output_path: @output_path_schemas,
@@ -80,33 +76,6 @@ module Suma
       docs.each_pair do |_schema_id, entry|
         entry.compile
       end
-
-      # TODO: make this parallel
-      # Utils.log"Starting Ractor processing"
-      # pool = Ractor.new do
-      #   loop do
-      #     Ractor.yield(Ractor.receive)
-      #   end
-      # end
-      # workers = (1..4).map do |i|
-      #   Ractor.new(pool, name: "r#{i}") do |p|
-      #     loop do
-      #       input = p.take
-      #       Utils.log"compiling in ractor for #{input.filename_adoc}"
-      #       output_value = input.compile
-      #       Ractor.yield(output_value)
-      #     end
-      #   end
-      # end
-      # docs.each do |doc|
-      #   pool.send(doc)
-      # end
-      # results = []
-      # docs.size.times do
-      #   results << Ractor.select(*workers)
-      # end
-      # pp results
     end
-    # rubocop:enable Metrics/MethodLength
   end
 end