suma 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8560abb88a9afd280a88d4671dc2aa2e674279765c5909ddba83df1e47c695c
-  data.tar.gz: 8aff2c39d4d9d380a5f685ac49823afd195a6862d16921301fc43a24448b820a
+  metadata.gz: b0cee8119660d33e2592a44875f218ff7cad624c0c5ff89430c5f97eda5f593e
+  data.tar.gz: 9fdc83bc1383b931d0907d9f31e4d94986a7922b55ef4f82ae437b4a52833f08
 SHA512:
-  metadata.gz: 9e920d236b6df4c74fd6c52ae3c4d24403575d10f14b41f893560962d1531c5bb6ff6798efaa7d010c5fd346cf2e820e120eafbe8cea3d6b15a80f53d9f14030
-  data.tar.gz: fdb19a5151df97eba81e0c23382f9c5c6f7ee082bb1d7b447a25e927626f47391c658f1afd32ac20ecc66fb5064af12f3e3f1263a65daadb59962ae8ccf7533c
+  metadata.gz: d2e87931a5396a1b42245c0d3156345e539b6d1f11bb82b6fcc9537603cec0f1d084e7636705d5eae87b180bc1618a77330e616b714ed1b94ae25f910a7209a6
+  data.tar.gz: 80eebf4ce42b572fb812a8729d6a71e9a96ed08d7d2d2c04b9b9884d721adf70075a6c2ccc6d400bdbc94573edc44f273baec9c9adcb7517134a6473cbabfdf4

data/.github/workflows/rake.yml

@@ -0,0 +1,15 @@
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+name: rake
+
+on:
+  push:
+    branches: [ master, main ]
+    tags: [ v* ]
+  pull_request:
+
+jobs:
+  rake:
+    uses: metanorma/ci/.github/workflows/generic-rake.yml@main
+    secrets:
+      pat_token: ${{ secrets.METANORMA_CI_PAT_TOKEN }}

data/.github/workflows/release.yml

@@ -0,0 +1,25 @@
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+name: release
+
+on:
+  workflow_dispatch:
+    inputs:
+      next_version:
+        description: |
+          Next release version. Possible values: x.y.z, major, minor, patch (or pre|rc|etc).
+          Also, you can pass 'skip' to skip 'git tag' and do 'gem push' for the current version
+        required: true
+        default: 'skip'
+  repository_dispatch:
+    types: [ do-release ]
+
+jobs:
+  release:
+    uses: metanorma/ci/.github/workflows/rubygems-release.yml@main
+    with:
+      next_version: ${{ github.event.inputs.next_version }}
+    secrets:
+      rubygems-api-key: ${{ secrets.METANORMA_CI_RUBYGEMS_API_KEY }}
+      pat_token: ${{ secrets.METANORMA_CI_PAT_TOKEN }}
+

data/.rubocop.yml

@@ -1,8 +1,10 @@
-AllCops:
-  TargetRubyVersion: 3.0
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+inherit_from:
+  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
 
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
+# local repo-specific modifications
+# ...
 
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes
+AllCops:
+  TargetRubyVersion: 3.4

data/lib/suma/collection_config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "utils"
+require "shale"
+require_relative "collection_manifest"
+require "metanorma/cli"
+require "metanorma/cli/collection"
+require "metanorma/collection/collection"
+
+module Suma
+  class CollectionConfig < Metanorma::Collection::Config::Config
+    attribute :manifest, ::Suma::CollectionManifest
+
+    def self.from_file(path)
+      from_yaml(File.read(path))
+    end
+
+    def to_file(path)
+      File.open(path, "w") { |f| f.write to_yaml }
+    end
+  end
+end

data/lib/suma/collection_manifest.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "metanorma/cli"
+require "metanorma/cli/collection"
+require "metanorma/collection/collection"
+
+module Suma
+  class CollectionManifest < Metanorma::Collection::Config::Manifest
+    attribute :schemas_only, Shale::Type::Boolean
+    attribute :entry, CollectionManifest, collection: true
+    # attribute :schema_source, Shale::Type::String
+    attr_accessor :schema_config
+
+    yaml do
+      map "identifier", to: :identifier
+      map "type", to: :type
+      map "level", using: { from: :level_from_yaml, to: :nop_to_yaml }
+      map "title", to: :title
+      map "url", to: :url
+      map "attachment", to: :attachment
+      map "sectionsplit", to: :sectionsplit
+      map "schemas-only", to: :schemas_only
+      map "index", to: :index
+      map "file", to: :file
+      map "fileref", using: { from: :fileref_from_yaml, to: :nop_to_yaml }
+      map "entry", to: :entry
+      map "docref", using: { from: :docref_from_yaml, to: :nop_to_yaml }
+      map "manifest", using: { from: :docref_from_yaml, to: :nop_to_yaml }
+      map "bibdata", using: { from: :bibdata_from_yaml,
+                              to: :bibdata_to_yaml }
+    end
+
+    def docref_from_yaml(model, value)
+      model.entry = CollectionManifest.from_yaml(value.to_yaml)
+    end
+
+    def export_schema_config(path)
+      export_config = @schema_config || Suma::SchemaConfig::Config.new
+      return export_config unless entry
+
+      entry.each do |x|
+        child_config = x.export_schema_config(path)
+        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
+
+      # 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 = Suma::SchemaConfig::Config.from_file(schemas_yaml_path)
+        end
+      end
+
+      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
+
+      doc = CollectionConfig.from_file(file)
+      doc_id = doc.bibdata.id
+
+      entries = @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
+
+      # we need to separate this file from the following new entries
+      added = CollectionManifest.new(
+        title: "Collection",
+        type:  "collection",
+        identifier: self.identifier + "_"
+      )
+
+      added.entry = [
+        CollectionManifest.new(
+          title: doc_id,
+          type: "document",
+          entry: entries,
+        ),
+      ]
+
+      [self, added]
+    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
+  end
+end

data/lib/suma/express_schema.rb

@@ -8,12 +8,9 @@ module Suma
   class ExpressSchema
     attr_accessor :path, :id, :parsed, :output_path
 
-    def initialize(path:, output_path:)
+    def initialize(id:, path:, output_path:)
       @path = Pathname.new(path).expand_path
-      @parsed = Expressir::Express::Parser.from_file(@path.to_s)
-      Utils.log "Loaded EXPRESS schema: #{path}"
-
-      @id = @parsed.schemas.first.id
+      @id = id
       @output_path = output_path
     end
 
@@ -28,8 +25,17 @@ module Suma
       end
     end
 
+    def parsed
+      return @parsed if @parsed
+
+      @parsed = Expressir::Express::Parser.from_file(@path.to_s)
+      Utils.log "Loaded EXPRESS schema: #{path}"
+      @id = @parsed.schemas.first.id
+      @parsed
+    end
+
     def to_plain
-      @parsed.to_s(no_remarks: true)
+      parsed.to_s(no_remarks: true)
     end
 
     def filename_plain

data/lib/suma/processor.rb

@@ -3,8 +3,8 @@
 require_relative "schema_config"
 require_relative "schema_collection"
 require_relative "utils"
-require_relative "to_replace/collection_config"
-require_relative "to_replace/site_config"
+require_relative "collection_config"
+require_relative "site_config"
 require "metanorma/cli"
 require "metanorma/cli/collection"
 require "metanorma/collection/collection"
@@ -12,43 +12,33 @@ require "metanorma/collection/collection"
 module Suma
   class Processor
     class << self
-      # Can move to schema_config.rb
-      def write_all_schemas(schemas_all_path, document_paths)
-        all_schemas = Suma::SchemaConfig::Config.new(path: schemas_all_path)
-
-        document_paths.each do |path|
-          schemas_yaml = File.join(File.dirname(path), "schemas.yaml")
-          next unless File.exist?(schemas_yaml)
-
-          schemas_config = Suma::SchemaConfig::Config.from_file(schemas_yaml)
-          all_schemas.concat(schemas_config)
-        end
-
-        Utils.log "Writing #{schemas_all_path}..."
-        all_schemas.to_file
-        Utils.log "Done."
-      end
 
       def run(metanorma_yaml_path:, schemas_all_path:, compile:, output_directory: "_site")
         Utils.log "Current directory: #{Dir.getwd}"
 
         # This reads the metanorma.yml file
-        site_config = Suma::ToReplace::SiteConfig::Config.from_file(metanorma_yaml_path)
+        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::ToReplace::CollectionConfig::Config.from_file(collection_config_path)
+        collection_config = Suma::CollectionConfig.from_file(collection_config_path)
         collection_config.path = collection_config_path
+        collection_config.manifest.expand_schemas_only("schema_docs")
 
-        # Gather all the inner (per-document) collection.yml files
-        document_paths = collection_config.manifest.docref.map(&:file)
+        exported_schema_config = collection_config.manifest.export_schema_config(schemas_all_path)
+        exported_schema_config.path = schemas_all_path
 
-        write_all_schemas(schemas_all_path, document_paths)
+        Utils.log "Writing #{schemas_all_path}..."
+        exported_schema_config.to_file
+        Utils.log "Done."
+
+        # 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"
+          output_path_schemas: "plain_schemas",
         )
 
         if compile
@@ -58,6 +48,10 @@ module Suma
           Utils.log "No compile option set. Skipping schema compilation."
         end
 
+        new_collection_config_path = "collection-output.yaml"
+        collection_config.manifest.remove_schemas_only_sources
+        collection_config.to_file(new_collection_config_path)
+
         # TODO: Do we still need this?
         # Define Proc to resolve fileref
         my_fileref_proc = proc do |ref_folder, fileref|
@@ -97,16 +91,17 @@ module Suma
         if compile
           Utils.log "Compiling complete collection..."
 
-          metanorma_collection = Metanorma::Collection.parse(collection_config_path)
+          # TODO: Why will defining a collection immediately compile??
+          metanorma_collection = Metanorma::Collection.parse(new_collection_config_path)
 
           # TODO: Somehow this is no longer used
           collection_opts = {
             format: [:html],
             output_folder: output_directory,
             compile: {
-              no_install_fonts: true
+              install_fonts: false,
             },
-            coverpage: "cover.html"
+            coverpage: "cover.html",
           }
           metanorma_collection.render(collection_opts)
 

data/lib/suma/{schema_doc.rb → schema_attachment.rb}

@@ -5,28 +5,33 @@ require "fileutils"
 require_relative "schema_config"
 
 module Suma
-  class SchemaDoc
-    attr_accessor :schema, :output_path, :config
+  class SchemaAttachment
+    attr_accessor :schema, :output_path, :config, :id
 
     def initialize(schema:, output_path:)
       @schema = schema
+      @id = schema.id
       @output_path = output_path
     end
 
+    def output_extensions
+      "xml,html"
+    end
+
     def to_adoc(path_to_schema_yaml)
       <<~HEREDOC
-        = #{@schema.id}
+        = #{@id}
         :lutaml-express-index: schemas; #{path_to_schema_yaml};
         :bare: true
         :mn-document-class: iso
-        :mn-output-extensions: xml,html
+        :mn-output-extensions: #{output_extensions}
 
         [lutaml,schemas,context]
         ----
         {% for schema in context.schemas %}
 
         [%unnumbered]
-        == #{@schema.id}
+        == #{@id}
 
         [source%unnumbered]
         --
@@ -88,19 +93,20 @@ module Suma
 
     # Compile Metanorma adoc per EXPRESS schema
     def compile
-      return self if File.exist?(output_xml_path)
+      # 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
 
       relative_path = Pathname.new(filename_adoc).relative_path_from(Dir.pwd)
-      Utils.log "Compiling schema #{relative_path}..."
+      Utils.log "Compiling schema (id: #{id}, type: #{self.class}) => #{relative_path}"
       Metanorma::Compile.new.compile(
         filename_adoc,
         agree_to_terms: true,
-        no_install_fonts: true
+        install_fonts: false
       )
-      Utils.log "Compiling schema #{filename_adoc}...done!"
+      Utils.log "Compiling schema (id: #{id}, type: #{self.class}) => #{relative_path}... done!"
 
       # clean_artifacts
 

data/lib/suma/schema_collection.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 require_relative "express_schema"
-require_relative "schema_doc"
+require_relative "schema_attachment"
+require_relative "schema_document"
 require_relative "schema_config"
 require_relative "utils"
 
 module Suma
   class SchemaCollection
-    attr_accessor :config, :schemas, :docs, :output_path_docs, :output_path_schemas
+    attr_accessor :config, :schemas, :docs, :output_path_docs, :output_path_schemas,
+      :manifest
 
-    def initialize(config: nil, config_yaml: nil, output_path_docs: nil, output_path_schemas: nil)
-      @schemas = []
-      @docs = []
+    def initialize(config: nil, config_yaml: nil, output_path_docs: nil, output_path_schemas: nil, manifest: nil)
+      @schemas = {}
+      @docs = {}
       @schema_name_to_docs = {}
       @output_path_docs = if output_path_docs
                             Pathname.new(output_path_docs).expand_path
@@ -30,34 +32,60 @@ module Suma
                   SchemaConfig::Config.from_file(config_yaml)
                 end
 
-      return self unless @config
+      @manifest = manifest
+    end
+
+    def doc_from_schema_name(schema_name)
+      @schema_name_to_docs[schema_name]
+    end
 
-      @config.schemas.each do |config_schema|
+    def process_schemas(schemas, klass)
+      schemas.each do |config_schema|
         s = ExpressSchema.new(
-          path: config_schema.path,
-          output_path: @output_path_schemas
+          id: config_schema.id,
+          path: config_schema.path.to_s,
+          output_path: @output_path_schemas.to_s
         )
-        doc = SchemaDoc.new(
+
+        doc = klass.new(
           schema: s,
           output_path: @output_path_docs.join(s.id)
         )
-        @docs << doc
-        @schemas << s
+
+        @docs[s.id] = doc
+        @schemas[s.id] = s
         @schema_name_to_docs[s.id] = doc
       end
     end
 
-    def doc_from_schema_name(schema_name)
-      @schema_name_to_docs[schema_name]
+    def finalize
+      # Process each schema in @config.schemas
+      process_schemas(@config.schemas, SchemaAttachment)
+
+      manifest_entry = @manifest.lookup(:schemas_only, true)
+
+      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
 
     def compile
-      schemas.map(&:save_exp)
+      finalize
+      schemas.each_pair do |schema_id, entry|
+        entry.save_exp
+      end
 
-      docs.each(&:compile)
+      # DISABLING FOLLOWING CODE AS MISCONCEIVED. THE SCHEMA DOCUMENTS
+      # BELONG IN THE MAIN COLLECTION NOT HERE
+      docs.each_pair do |schema_id, entry|
+        entry.compile
+      end
 
       # TODO: make this parallel
-      # puts "Starting Ractor processing"
+      # Utils.log"Starting Ractor processing"
       # pool = Ractor.new do
       #   loop do
       #     Ractor.yield(Ractor.receive)
@@ -67,7 +95,7 @@ module Suma
       #   Ractor.new(pool, name: "r#{i}") do |p|
       #     loop do
       #       input = p.take
-      #       puts "compiling in ractor for #{input.filename_adoc}"
+      #       Utils.log"compiling in ractor for #{input.filename_adoc}"
       #       output_value = input.compile
       #       Ractor.yield(output_value)
       #     end

data/lib/suma/schema_config/config.rb

@@ -8,10 +8,10 @@ module Suma
   module SchemaConfig
     class Config < Shale::Mapper
       attribute :schemas, Schema, collection: true
-      attr_accessor :base_path, :path
+      attribute :path, Shale::Type::String
 
-      def initialize(path: nil, **args)
-        @path = path
+      def initialize(**args)
+        @path = path_relative_to_absolute(path) if path
         super(**args)
       end
 
@@ -25,7 +25,7 @@ module Suma
 
       def self.from_file(path)
         from_yaml(File.read(path)).tap do |x|
-          x.path = path
+          x.set_initial_path(path)
         end
       end
 
@@ -35,19 +35,61 @@ module Suma
         end
       end
 
+      def set_initial_path(new_path)
+        @path = path_relative_to_absolute(new_path)
+        schemas.each do |schema|
+          schema.path = path_relative_to_absolute(schema.path)
+        end
+      end
+
       def schemas_from_yaml(model, value)
         model.schemas = value.map do |k, v|
-          Schema.new(id: k, path: v["path"])
+          Schema.new(id: k, path: path_relative_to_absolute(v["path"]))
         end
       end
 
+      # TODO: I can't get the relative path working. The schemas-*.yaml file is
+      # meant to contain the "path" key, which is a relative path to its
+      # location, then sets the base path to each schema path, which is supposed
+      # to be relative to "path" key. Somehow, the @path variable is always
+      # missing in to_yaml...
       def schemas_to_yaml(model, doc)
+        # puts "^"*30
+        # pp self
+        # pp @path
         doc["schemas"] = model.schemas.sort_by(&:id).to_h do |schema|
-          [schema.id, { "path" => schema.path }]
+          [schema.id, { "path" => path_absolute_to_relative(schema.path) }]
         end
       end
 
+      def path_relative_to_absolute(relative_path)
+        eval_path = Pathname.new(relative_path)
+        return relative_path if eval_path.absolute?
+
+        # Or based on current working directory?
+        return relative_path unless @path
+
+        Pathname.new(File.dirname(@path)).join(eval_path).expand_path.to_s
+      end
+
+      def path_absolute_to_relative(absolute_path)
+        # puts "path_absolute_to_relative 1 #{absolute_path}"
+        # pp self
+        # pp path
+        # pp @hello
+        return absolute_path unless @path
+
+        relative_path = Pathname.new(absolute_path).relative_path_from(Pathname.new(@path).dirname).to_s
+        # puts "path_absolute_to_relative x #{relative_path}"
+        relative_path
+      end
+
       def update_path(new_path)
+        if @path.nil?
+          @path = new_path
+          return @path
+        end
+
         old_base_path = File.dirname(@path)
         new_base_path = File.dirname(new_path)
 
@@ -68,8 +110,8 @@ module Suma
           raise StandardError, "Can only concatenate a non SchemaConfig::Config object."
         end
 
-        # We need to update the relative paths
-        if path != another_config.path
+        # We need to update the relative paths when paths exist
+        if path && another_config.path && path != another_config.path
           new_config = another_config.dup
           new_config.update_path(path)
         end

data/lib/suma/schema_config/schema.rb

@@ -7,6 +7,7 @@ module Suma
     class Schema < Shale::Mapper
       attribute :id, Shale::Type::String
       attribute :path, Shale::Type::String
+      # attribute :schemas_only, Shale::Type::Boolean
     end
   end
 end

data/lib/suma/schema_document.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "schema_attachment"
+
+module Suma
+  class SchemaDocument < SchemaAttachment
+    def bookmark(anchor)
+      a = anchor.gsub(/\}\}/, ' | replace: "\", "-"}}')
+      "[[#{@id}.#{a}]]"
+    end
+
+    def schema_anchors
+      <<~HEREDOC
+        // _fund_cons.liquid
+        [[#{@id}_funds]]
+
+        // _constants.liquid
+        {% if schema.constants.size > 0 %}
+        #{bookmark("constants")}
+        {% for thing in schema.constants %}
+        #{bookmark("{{thing.id}}")}
+        {% endfor %}
+        {% endif %}
+
+        // _types.liquid
+        {% if schema.types.size > 0 %}
+        #{bookmark("types")}
+        // _type.liquid
+        {% for thing in schema.types %}
+        #{bookmark("{{thing.id}}")}
+        {% if thing.items.size > 0 %}
+        // _type_items.liquid
+        #{bookmark("{{thing.id}}.items")}
+        {% for item in thing.items %}
+        #{bookmark("{{thing.id}}.items.{{item.id}}")}
+        {% endfor %}
+        {% endif %}
+        {% endfor %}
+        {% endif %}
+
+        // _entities.liquid
+        {% if schema.entities.size > 0 %}
+        #{bookmark("entities")}
+        {% for thing in schema.entities %}
+        // _entity.liquid
+        #{bookmark("{{thing.id}}")}
+        {% endfor %}
+        {% endif %}
+      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}
+        :lutaml-express-index: schemas; #{path_to_schema_yaml};
+        :bare: true
+        :mn-document-class: iso
+        :mn-output-extensions: xml,html
+
+        [lutaml,schemas,context]
+        ----
+        {% for schema in context.schemas %}
+
+        [[#{@id}]]
+        [%unnumbered,type=express]
+        == #{@id} #{schema_anchors.gsub(%r{//[^\r\n]+}, "").gsub(/[\n\r]+/, "").gsub(/^[\n\r]/, "")}
+
+        [source%unnumbered]
+        --
+        {{ schema.formatted }}
+        --
+        {% endfor %}
+        ----
+
+      HEREDOC
+    end
+  end
+end

data/lib/suma/site_config.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "shale"
+
+module Suma
+  module SiteConfig
+    class SiteInfo < Shale::Mapper
+      attribute :organization, Shale::Type::String
+      attribute :name, Shale::Type::String
+    end
+
+    class Sources < Shale::Mapper
+      attribute :files, Shale::Type::String, collection: true
+    end
+
+    class Base < Shale::Mapper
+      attribute :source, Sources
+      attribute :collection, SiteInfo
+    end
+
+    class Config < Shale::Mapper
+      attribute :metanorma, Base
+
+      def self.from_file(path)
+        from_yaml(File.read(path))
+      end
+    end
+  end
+end

data/lib/suma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Suma
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: suma
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ribose Inc.
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-07 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: expressir
@@ -118,7 +118,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/main.yml"
+- ".github/workflows/rake.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -131,16 +132,18 @@ files:
 - exe/suma
 - lib/suma.rb
 - lib/suma/cli.rb
+- lib/suma/collection_config.rb
+- lib/suma/collection_manifest.rb
 - lib/suma/express_schema.rb
 - lib/suma/processor.rb
+- lib/suma/schema_attachment.rb
 - lib/suma/schema_collection.rb
 - lib/suma/schema_config.rb
 - lib/suma/schema_config/config.rb
 - lib/suma/schema_config/schema.rb
-- lib/suma/schema_doc.rb
+- lib/suma/schema_document.rb
+- lib/suma/site_config.rb
 - lib/suma/thor_ext.rb
-- lib/suma/to_replace/collection_config.rb
-- lib/suma/to_replace/site_config.rb
 - lib/suma/utils.rb
 - lib/suma/version.rb
 - sig/suma.rbs
@@ -149,7 +152,7 @@ homepage: https://github.com/metanorma/suma
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -164,8 +167,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.3.27
+signing_key: 
 specification_version: 4
 summary: Utility for SUMA (STEP Unified Model-Based Standards Architecture)
 test_files: []

data/.github/workflows/main.yml

@@ -1,27 +0,0 @@
-name: Ruby
-
-on:
-  push:
-    branches:
-      - main
-
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    name: Ruby ${{ matrix.ruby }}
-    strategy:
-      matrix:
-        ruby:
-          - '3.2.2'
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{ matrix.ruby }}
-        bundler-cache: true
-    - name: Run the default task
-      run: bundle exec rake

data/lib/suma/to_replace/collection_config.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../utils"
-require "shale"
-
-module Suma
-  module ToReplace
-    module CollectionConfig
-      class CompileOptions < Shale::Mapper
-        attribute :no_install_fonts, Shale::Type::Boolean, default: -> { true }
-        attribute :agree_to_terms, Shale::Type::Boolean, default: -> { true }
-      end
-
-      class BibdataTitle < Shale::Mapper
-        attribute :language, Shale::Type::String
-        attribute :content, Shale::Type::String
-      end
-
-      class BibdataDocid < Shale::Mapper
-        attribute :type, Shale::Type::String
-        attribute :id, Shale::Type::String
-      end
-
-      class BibdataContributor < Shale::Mapper
-        attribute :name, Shale::Type::String
-        attribute :abbreviation, Shale::Type::String
-      end
-
-      class BibdataCopyright < Shale::Mapper
-        attribute :owner, BibdataContributor
-        attribute :from, Shale::Type::String
-      end
-
-      class Bibdata < Shale::Mapper
-        attribute :title, BibdataTitle, collection: true
-        attribute :type, Shale::Type::String
-        attribute :docid, BibdataDocid
-        attribute :edition, Shale::Type::Integer
-        attribute :copyright, BibdataCopyright
-      end
-
-      class ManifestItem < Shale::Mapper
-        attribute :identifier, Shale::Type::String
-        attribute :level, Shale::Type::String
-        attribute :title, Shale::Type::String
-        attribute :attachment, Shale::Type::Boolean
-        attribute :sectionsplit, Shale::Type::Boolean
-        attribute :file, Shale::Type::String
-        attribute :docref, ManifestItem, collection: true
-
-        yaml do
-          map "identifier", to: :identifier
-          map "level", to: :level
-          map "title", to: :title
-          map "attachment", to: :attachment
-          map "sectionsplit", to: :sectionsplit
-          map "file", to: :file
-          map "fileref", to: :fileref
-          map "docref", to: :docref
-          map "fileref", using: { from: :fileref_from_yaml, to: :fileref_to_yaml }
-        end
-
-        def fileref_from_yaml(model, value)
-          # Utils.log "model #{model}, value #{value}"
-          # file_from_yaml(model, value)
-          model.file ||= value
-        end
-
-        def fileref_to_yaml(_model, _doc)
-          nil
-        end
-      end
-
-      class Manifest < Shale::Mapper
-        attribute :level, Shale::Type::String
-        attribute :title, Shale::Type::String
-        attribute :sectionsplit, Shale::Type::Boolean
-        attribute :docref, ManifestItem, collection: true
-
-        def attachments
-          docref.detect do |ref|
-            ref.level == "attachments"
-          end&.docref
-        end
-
-        def documents
-          docref.detect do |ref|
-            ref.level == "document"
-          end&.docref
-        end
-      end
-
-      class Config < Shale::Mapper
-        attr_accessor :path
-
-        attribute :directives, Shale::Type::String, collection: true
-        attribute :bibdata, Bibdata
-        attribute :manifest, Manifest
-        attribute :format, Shale::Type::String, collection: true, default: -> { [:html] }
-        attribute :output_folder, Shale::Type::String
-        attribute :coverpage, Shale::Type::String, default: -> { "cover.html" }
-        attribute :compile, CompileOptions
-        attribute :prefatory_content, Shale::Type::String
-        attribute :final_content, Shale::Type::String
-
-        def self.from_file(path)
-          from_yaml(File.read(path))
-        end
-      end
-    end
-  end
-end

data/lib/suma/to_replace/site_config.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "shale"
-
-module Suma
-  module ToReplace
-    module SiteConfig
-      class SiteInfo < Shale::Mapper
-        attribute :organization, Shale::Type::String
-        attribute :name, Shale::Type::String
-      end
-
-      class Sources < Shale::Mapper
-        attribute :files, Shale::Type::String, collection: true
-      end
-
-      class Base < Shale::Mapper
-        attribute :source, Sources
-        attribute :collection, SiteInfo
-      end
-
-      class Config < Shale::Mapper
-        attribute :metanorma, Base
-
-        def self.from_file(path)
-          from_yaml(File.read(path))
-        end
-      end
-    end
-  end
-end