stepmod-utils 0.6.10.pre.alpha.1 → 0.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8b65cef0a5a325ab2e28a21e5dcd38be81535e4cac5662b2dd4bc4244ce1d40
-  data.tar.gz: 8259f12eb5f6f2e4df159be483c36335e7b715aad8793943ea61a60523e812f8
+  metadata.gz: 9af636493e609c32af652ba4c7ba9c27bcf544b2b050f166d046d320cc951c3e
+  data.tar.gz: 721483a250021b902ccb6f9c13848ac9b2eb9679ca419c3a4c041badffc10533
 SHA512:
-  metadata.gz: a8b84ea4e01a4c46c105c3be24bac8aedccb38ba41bb1bc0a60f43cd12f53a64895714c70824cc7cec4d82261135e38eef82871bd7e2c0df3c0124730c1b53e7
-  data.tar.gz: f1fabfe7cf7da21378c85563996da2d262a950c951936a530db0d650b32b8188a36f929429f986a90a30c7f43c2267e180bd3cead1450aead8765b921aa8916e
+  metadata.gz: 572cb2422c959eb5dee160ecac7e35d32c3533ab8368aa60a9051a2a834c6a41297809539154caa63e08884b0cca17e7c4bb19c7ae28be5843d938e12ad02910
+  data.tar.gz: 87ca83a2d9413b9de293bc2857d749ad3ef437b61cc7aba90e2f1ec0760d2053746684ff1aa6393f5afb3c2c2b33000aa387187b523b81b671016e819b625050

data/.rubocop.yml

@@ -10,4 +10,4 @@ Style/MultilineMethodCallIndentation:
   EnforcedStyle: aligned
 
 AllCops:
-  TargetRubyVersion: 3.1
+  TargetRubyVersion: 3.3

data/README.adoc

@@ -30,6 +30,10 @@ Or include it in your gemspec.
 This command uses Expressir to validate all EXPRESS schemas listed in the
 `{stepmod}/repository_index.xml` file.
 
+Validation parses each file separately so that a broken schema is reported
+without preventing validation of the remaining files. It does not build the
+shared repository used for concept extraction.
+
 There is a `SHOULD_REWRITE` constant that can be switched in the code which
 allows overwriting of the EXPRESS schemas into a pretty-printed format.
 
@@ -68,6 +72,10 @@ SCHEMA: data/resources/geometric_model_schema/geometric_model_schema.exp
 This command takes the STEPmod directory and parses its XML to synthesize
 with the target EXPRESS schemas to migrate into Annotated EXPRESS schemas.
 
+Annotation parses each input file to determine its schema name before combining
+it with the XML descriptions. It does not resolve references across schemas;
+repository-wide parsing happens when extracting concepts from the annotated files.
+
 Given the following schemas:
 
 * Simple EXPRESS schema: `{stepmod-root-dir}/data/resources/action_schema/action_schema.exp`
@@ -119,6 +127,15 @@ $ bundle exec stepmod-annotate-all --stepmod-dir iso-10303-stepmod-wg12 --output
 
 === ISO 10303-2 concepts extraction
 
+Concept extraction passes the complete selected set of annotated EXPRESS files to
+`Expressir::Express::Parser.from_files` once, producing a shared repository for
+cross-schema references as requested in
+https://github.com/metanorma/stepmod-utils/issues/136[issue #136]. The set contains
+existing ARM and MIM files for published, non-withdrawn modules and existing
+schemas for published, non-withdrawn resources listed in `repository_index.xml`.
+ISO 13584 schemas are excluded. BOMs and application protocols do not contribute
+Clause 3 terms and are excluded from concept extraction.
+
 [source,sh]
 ----
 $ bundle exec stepmod-extract-concepts \
@@ -256,6 +273,56 @@ End!
 [stepmod-utils] ******************************
 ----
 
+=== Converting the STEPmod bibliography to a Relaton collection
+
+STEPmod keeps the shared references for `normref.inc` and `bibitem.inc` in
+`data/basic/normrefs.xml` and `data/basic/bibliography.xml`. This command
+converts both lists into one Relaton collection, so that Metanorma can cite any
+entry by its id.
+
+[source,sh]
+----
+# from a STEPmod checkout
+$ stepmod-convert-bibliography -s {stepmod-directory} -o stepmod-bibliography.xml
+
+# or from the two files directly (either one can be left out)
+$ stepmod-convert-bibliography --normrefs normrefs.xml \
+    --bibliography bibliography.xml -o stepmod-bibliography.xml
+----
+
+Without `-o`, the collection is written to standard output. `-t` sets the
+collection title.
+
+The output is a `<relaton-collection>` with one `<relation type="partOf">` per
+entry, each holding a Relaton `<bibitem>`:
+
+* The item id is the STEPmod id with the prefix `normref_` or `bibitem_` (for
+example `bibitem_ref8824-1`), the anchor form that the migrated ISO 10303
+documents use. The raw STEPmod id is kept as a `docidentifier` of type
+`STEPmod-id`.
+* The primary `docidentifier` is `orgname` + `stdnumber` for a normref (for
+example `ISO 31-0`), the `stdnumber` for a bibliography entry, and
+`report-type` + `number` for a technical report.
+* `bibitem` and `normref` become `standard`, `bibitem.techreport` becomes
+`techreport`, and `bibitem.book` becomes `book`.
+* `<term>` children of a normref are not bibliographic data and are skipped.
+* A duplicate id in one list is skipped with a warning. An unknown named
+entity is kept as text with a warning.
+
+From Ruby:
+
+[source,ruby]
+----
+require "stepmod/utils/bibliography_converter"
+
+converter = Stepmod::Utils::BibliographyConverter.new(
+  normrefs: "data/basic/normrefs.xml",
+  bibliography: "data/basic/bibliography.xml",
+)
+converter.items  # => Array<Relaton::Bib::ItemData>
+converter.to_xml # => relaton-collection XML
+----
+
 == Conversion of STEPmod descriptions.xml into adoc
 
 [source,sh]

data/exe/stepmod-convert-bibliography

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+
+# resolve bin path, ignoring symlinks
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+require "bundler/setup"
+require "optparse"
+require "stepmod/utils/bibliography_converter"
+
+def log(message)
+  warn "[stepmod-utils] #{message}"
+end
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options]\n\n" \
+                "Convert STEPmod normrefs.xml and bibliography.xml into " \
+                "one Relaton collection."
+
+  opts.on("-s", "--stepmod DIR",
+          "STEPmod root; reads data/basic/normrefs.xml and " \
+          "data/basic/bibliography.xml") do |dir|
+    options[:stepmod] = dir
+  end
+
+  opts.on("--normrefs PATH", "Path to normrefs.xml") do |path|
+    options[:normrefs] = path
+  end
+
+  opts.on("--bibliography PATH", "Path to bibliography.xml") do |path|
+    options[:bibliography] = path
+  end
+
+  opts.on("-o", "--output PATH",
+          "Output collection XML (default: standard output)") do |path|
+    options[:output] = path
+  end
+
+  opts.on("-t", "--title TITLE", "Title of the collection") do |title|
+    options[:title] = title
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+begin
+  parser.parse!
+rescue OptionParser::ParseError => e
+  warn e.message
+  warn parser
+  exit 1
+end
+
+unless ARGV.empty?
+  warn "Unexpected argument: #{ARGV.join(' ')}"
+  warn parser
+  exit 1
+end
+
+if options[:stepmod]
+  basic = File.join(options[:stepmod], "data", "basic")
+  options[:normrefs] ||= File.join(basic, "normrefs.xml")
+  options[:bibliography] ||= File.join(basic, "bibliography.xml")
+end
+
+inputs = options.values_at(:normrefs, :bibliography).compact
+if inputs.empty?
+  warn "Give --stepmod DIR, or --normrefs PATH and/or --bibliography PATH."
+  warn parser
+  exit 1
+end
+
+missing = inputs.reject { |path| File.file?(path) }
+unless missing.empty?
+  warn "File not found: #{missing.join(', ')}"
+  exit 1
+end
+
+converter = Stepmod::Utils::BibliographyConverter.new(
+  normrefs: options[:normrefs],
+  bibliography: options[:bibliography],
+  title: options[:title],
+)
+xml = converter.to_xml
+
+if options[:output]
+  File.write(options[:output], xml, encoding: "UTF-8")
+  log "#{converter.items.size} items written to #{options[:output]}"
+else
+  $stdout.write(xml)
+end

data/lib/stepmod/utils/bibliography_converter.rb

@@ -0,0 +1,294 @@
+require "date"
+require "nokogiri"
+require "relaton/bib"
+
+module Stepmod
+  module Utils
+    # Converts the STEPmod shared reference lists, data/basic/normrefs.xml
+    # and data/basic/bibliography.xml, into one Relaton collection, so that
+    # Metanorma can cite any entry by its id.
+    #
+    # Each entry becomes a Relaton::Bib::ItemData. Its id is the STEPmod id
+    # with the list prefix the migrated documents use ("normref_",
+    # "bibitem_"), and the raw STEPmod id is kept as a docidentifier of type
+    # "STEPmod-id".
+    class BibliographyConverter
+      COLLECTION_NS = "https://open.ribose.com/relaton-xml".freeze
+      DEFAULT_TITLE = "STEPmod bibliography".freeze
+      AUTHOR = "ISO/TC 184/SC 4".freeze
+
+      XML_ENTITIES = %w[amp lt gt quot apos].freeze
+      DASHES = /\A[\s—–-]+|[\s—–-]+\z/
+      ITEM_TYPES = {
+        "normref" => "standard",
+        "bibitem" => "standard",
+        "bibitem.techreport" => "techreport",
+        "bibitem.book" => "book",
+      }.freeze
+
+      Bib = Relaton::Bib
+
+      attr_reader :title
+
+      # @param normrefs [String, nil] path to normrefs.xml
+      # @param bibliography [String, nil] path to bibliography.xml
+      # @param title [String, nil] title of the collection
+      def initialize(normrefs: nil, bibliography: nil, title: nil)
+        @normrefs = normrefs
+        @bibliography = bibliography
+        @title = title || DEFAULT_TITLE
+      end
+
+      # @return [Array<Relaton::Bib::ItemData>]
+      def items
+        @items ||= read_list(@normrefs, "normref", "//normref") +
+          read_list(@bibliography, "bibitem",
+                    "//bibitem | //bibitem.techreport | //bibitem.book")
+      end
+
+      # @return [String] a relaton-collection XML document
+      def to_xml
+        doc = Nokogiri::XML::Document.new
+        doc.encoding = "UTF-8"
+        root = doc.add_child(doc.create_element("relaton-collection",
+                                                xmlns: COLLECTION_NS))
+        root.add_child(doc.create_element("title", title))
+        root.add_child(author_node(doc))
+        items.each do |item|
+          relation = root.add_child(doc.create_element("relation",
+                                                       type: "partOf"))
+          relation.add_child(Nokogiri::XML(item.to_xml, &:noblanks).root)
+        end
+        doc.to_xml
+      end
+
+      private
+
+      def author_node(doc)
+        contributor = doc.create_element("contributor")
+        contributor.add_child(doc.create_element("role", type: "author"))
+        org = contributor.add_child(doc.create_element("organization"))
+        org.add_child(doc.create_element("name", AUTHOR))
+        contributor
+      end
+
+      def read_list(path, prefix, xpath)
+        return [] unless path
+
+        seen = {}
+        parse(path).xpath(xpath).filter_map do |node|
+          raw_id = node["id"]
+          id = "#{prefix}_#{sanitize_id(raw_id)}"
+          if seen[id]
+            log(path, "duplicate id #{raw_id.inspect} skipped")
+            next
+          end
+
+          seen[id] = true
+          build_item(node, id, raw_id)
+        end
+      end
+
+      def log(path, message)
+        warn "[stepmod-utils] #{path}: #{message}"
+      end
+
+      # The DTD that declares the HTML entities is not available, so resolve
+      # them before the parse.
+      # An unknown entity would be dropped silently by the parser, so it is
+      # reported and kept as text.
+      def parse(path)
+        xml = File.read(path, encoding: "UTF-8")
+        xml = xml.gsub(/&([a-zA-Z][a-zA-Z0-9]*);/) do |match|
+          name = Regexp.last_match(1)
+          next match if XML_ENTITIES.include?(name)
+
+          resolve_entity(name) || unknown_entity(path, match)
+        end
+        Nokogiri::XML(xml, &:nonet)
+      end
+
+      def resolve_entity(name)
+        codepoint = entity_lookup[name]
+        [codepoint].pack("U") if codepoint
+      end
+
+      def unknown_entity(path, match)
+        log(path, "unknown entity #{match} kept as text")
+        "&amp;#{match[1..]}"
+      end
+
+      def entity_lookup
+        @entity_lookup ||= Nokogiri::HTML4::EntityLookup.new
+      end
+
+      def sanitize_id(raw_id)
+        raw_id.to_s.gsub(/[^\w.-]+/, "_")
+      end
+
+      def build_item(node, id, raw_id)
+        ref = node.at("./stdref") || node
+        Bib::ItemData.new(
+          id: id,
+          type: ITEM_TYPES[node.name],
+          docidentifier: docidentifiers(node, ref, raw_id),
+          title: titles(node, ref),
+          date: dates(ref),
+          contributor: contributors(node, ref),
+          place: places(node),
+          source: sources(node),
+          note: notes(node),
+        )
+      end
+
+      def docidentifiers(node, ref, raw_id)
+        primary = primary_identifier(node, ref)
+        stepmod_id = Bib::Docidentifier.new(content: raw_id,
+                                            type: "STEPmod-id")
+        primary ? [primary, stepmod_id] : [stepmod_id]
+      end
+
+      # A normref stdnumber is the bare number ("31-0"). A bibliography
+      # stdnumber is already the full identifier ("ISO 286-1", "RFC 3986").
+      def primary_identifier(node, ref)
+        orgname = text(ref, "orgname")
+        number = text(ref, "stdnumber")
+        if number
+          content = node.name == "normref" ? prefixed(orgname, number) : number
+          type = docid_type(orgname)
+        elsif (number = text(node, "number"))
+          content = prefixed(text(node, "report-type"), number)
+          type = "STEPmod"
+        end
+        return unless content
+
+        Bib::Docidentifier.new(content: content, type: type, primary: true)
+      end
+
+      def prefixed(prefix, value)
+        return value if prefix.nil? || value.start_with?(prefix)
+
+        "#{prefix} #{value}"
+      end
+
+      def docid_type(orgname)
+        case orgname
+        when /\AISO/ then "ISO"
+        when /\AIEC/ then "IEC"
+        else "STEPmod"
+        end
+      end
+
+      # A normref subtitle continues the title ("— Part 1: ..."). A
+      # bibliography subtitle is free text, so it becomes a note instead.
+      def titles(node, ref)
+        main = strip_dashes(text(ref, "stdtitle"))
+        return [] unless main
+
+        subtitle = node.name == "normref" && strip_dashes(text(ref, "subtitle"))
+        return [title_of(main, "main")] unless subtitle
+
+        result = [title_of(join_title(main, subtitle), "main"),
+                  title_of(main, "title-main")]
+        part = subtitle.start_with?("Part")
+        result << title_of(subtitle, "title-part") if part
+        result
+      end
+
+      # Some subtitles continue the sentence (", corrected and reprinted
+      # in 1995", "(OMG-UML VER 1.3)"); the others are title components.
+      def join_title(main, subtitle)
+        case subtitle
+        when /\A[,;.]/ then "#{main}#{subtitle}"
+        when /\A\(/ then "#{main} #{subtitle}"
+        else "#{main} — #{subtitle}"
+        end
+      end
+
+      def title_of(content, type)
+        Bib::Title.new(content: content, type: type, language: "en",
+                       script: "Latn")
+      end
+
+      def strip_dashes(value)
+        stripped = value&.gsub(DASHES, "")
+        stripped unless stripped.nil? || stripped.empty?
+      end
+
+      def notes(node)
+        return [] if node.name == "normref"
+
+        subtitle = text(node, "subtitle")
+        subtitle ? [Bib::Note.new(content: subtitle)] : []
+      end
+
+      # STEPmod dates are "YYYY", "YYYY-MM-DD", or free text such as
+      # "January 1992". Free text is kept as the date text. A value without
+      # a year ("—", "-", "CHECK DATE") means "undated" and is dropped, and
+      # so is a future date ("To be published in 2018").
+      def dates(ref)
+        value = text(ref, "pubdate")
+        return [] unless value
+
+        if value.match?(/\A\d{4}(-\d{2}){0,2}\z/)
+          return [Bib::Date.new(type: "published", at: value)]
+        end
+
+        year = value[/\b(\d{4})\b/, 1]
+        return [] if year.nil? || value.match?(/to be published/i)
+
+        [Bib::Date.new(type: "published", at: year, text: value)]
+      end
+
+      def contributors(node, ref)
+        authors = texts(node, "primary-responsibility").map do |name|
+          Bib::Contributor.new(role: [role("author")], person: person(name))
+        end
+        publishers = %w[orgname institution publisher].flat_map do |tag|
+          texts(tag == "orgname" ? ref : node, tag)
+        end
+        authors + publishers.uniq.map do |name|
+          Bib::Contributor.new(role: [role("publisher")],
+                               organization: organization(name))
+        end
+      end
+
+      def role(type)
+        Bib::Contributor::Role.new(type: type)
+      end
+
+      def person(name)
+        Bib::Person.new(
+          name: Bib::FullName.new(
+            completename: Bib::LocalizedString.new(content: name),
+          ),
+        )
+      end
+
+      def organization(name)
+        Bib::Organization.new(
+          name: [Bib::TypedLocalizedString.new(content: name)],
+        )
+      end
+
+      def places(node)
+        texts(node, "place").map { |p| Bib::Place.new(formatted_place: p) }
+      end
+
+      def sources(node)
+        texts(node, "ulink").map { |u| Bib::Uri.new(type: "src", content: u) }
+      end
+
+      def text(node, tag)
+        texts(node, tag).first
+      end
+
+      def texts(node, tag)
+        node.xpath("./#{tag}").filter_map do |el|
+          value = el.text.gsub(/\s+/, " ").strip
+          value unless value.empty?
+        end
+      end
+    end
+  end
+end

data/lib/stepmod/utils/cleaner.rb

@@ -12,7 +12,8 @@ module Stepmod
       # Find non-asterisk content that is enclosed by two or
       # more asterisks. Ensure that only one whitespace occurs
       # in the border area.
-      # Same for underscores and brackets.
+      # Same for underscores and brackets. A missing border is added, except
+      # next to a word character: unconstrained markup may sit inside a word.
       def clean_tag_borders(string)
         patterns = {
           /\s?\*{2,}.*?\*{2,}\s?/ => "**",
@@ -23,8 +24,7 @@ module Stepmod
         result = string.dup
         patterns.each do |pattern, value|
           result = result.gsub(pattern) do |match|
-            preserve_border_whitespaces(match,
-                                        default_border: Coradoc::Input::Html.config.tag_border) do
+            border_tags(match, Regexp.last_match) do
               match.strip.sub(" #{value}", value).sub("#{value} ", value)
             end
           end
@@ -37,6 +37,26 @@ module Stepmod
         end
         result
       end
+
+      private
+
+      # Like preserve_border_whitespaces, but a border is only invented where
+      # the neighbouring character is not part of a word.
+      def border_tags(match, matched)
+        return match if /\A\s*\Z/.match?(match)
+
+        invent = !/[\[(\])]/.match?(match)
+        start = match[/\A\s*/]
+        finish = match[/\s*\Z/]
+        start = border(matched.pre_match[-1]) if start.empty? && invent
+        finish = border(matched.post_match[0]) if finish.empty? && invent
+
+        start + yield + finish
+      end
+
+      def border(neighbour)
+        neighbour&.match?(/\w/) ? "" : Coradoc::Input::Html.config.tag_border
+      end
     end
   end
 end

data/lib/stepmod/utils/converters/a.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "figure"
+
 module Stepmod
   module Utils
     module Converters
@@ -18,6 +20,7 @@ module Stepmod
             "[[#{id}]]"
           elsif href.to_s.start_with?("#")
             href = href.sub(/^#/, "").gsub(/\s/, "").gsub(/__+/, "_")
+            href = figure_anchor(href, state) || href
             if name.empty? || number_with_optional_prefix?(name)
               "<<#{href}>>"
             else
@@ -36,6 +39,17 @@ module Stepmod
 
         private
 
+        # A reference to a figure must use the id the figure is given by
+        # Figure.pattern, or the link does not resolve.
+        def figure_anchor(href, state)
+          return unless state[:schema_and_entity] || state[:schema_name]
+
+          figure_id = href[/\Afigure[_-](.+)\z/, 1]
+          figure_id = href if figure_id.nil? &&
+            Array(state[:figure_ids]).include?(href)
+          Figure.pattern(state, figure_id) if figure_id
+        end
+
         def number_with_optional_prefix?(name)
           /.*?\s*\(?\d+\)?/.match(name)
         end

data/lib/stepmod/utils/converters/em_express_description.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require_relative "strong"
+
 module Stepmod
   module Utils
     module Converters
       class Em < Stepmod::Utils::Converters::Base
+        BOLD_TAGS = %w[b strong].freeze
+
         def convert(node, state = {})
           italic_converted(node, state)
         end
@@ -15,6 +19,11 @@ module Stepmod
         private
 
         def italic_converted(node, state)
+          bold = sole_bold_child(node)
+          if bold && !state[:already_italic]
+            return bold_italic(node, bold, state)
+          end
+
           cloned_node = node.clone
           equations = extract_equations(cloned_node)
           content = treat_children(cloned_node,
@@ -34,6 +43,26 @@ module Stepmod
           [content, equation_content].compact.join("")
         end
 
+        # <i><b>x</b></i> is written bold outside, italic inside: `*_x_*`.
+        def bold_italic(node, bold, state)
+          content = treat_children(bold, state.merge(already_italic: true))
+          return content if content.strip.empty?
+
+          lead = content[/^\s*/]
+          trail = content[/\s*$/]
+          Strong.new.mark_up(node, "#{lead}_#{content.strip}_#{trail}", state)
+        end
+
+        def sole_bold_child(node)
+          return unless node.element_children.one?
+          return if node.children.any? { |c| c.text? && !c.text.strip.empty? }
+
+          bold = node.element_children.first
+          return unless BOLD_TAGS.include?(bold.name)
+
+          bold unless bold.element_children.any? { |c| c.name == "eqn" }
+        end
+
         def extract_equations(node)
           equations = []
 

data/lib/stepmod/utils/converters/figure.rb

@@ -7,11 +7,12 @@ module Stepmod
     module Converters
       class Figure < Coradoc::Input::Html::Converters::Figure
         def self.pattern(state, id)
-          if state[:schema_and_entity].nil?
+          schema_and_entity = state[:schema_and_entity] || state[:schema_name]
+          if schema_and_entity.nil?
             raise StandardError.new("[figure]: no state given, #{id}")
           end
 
-          schema = state[:schema_and_entity].split(".").first
+          schema = schema_and_entity.split(".").first
           "figure-#{schema}-#{id}"
         end
 

data/lib/stepmod/utils/converters/strong.rb

@@ -10,8 +10,36 @@ module Stepmod
           bold_converted(node, state)
         end
 
+        # Wraps already converted +content+ in AsciiDoc bold markup, as
+        # +node+ (a <b>, or an element standing in for one) would.
+        def mark_up(node, content, state)
+          return content if content.strip.empty? || state[:already_strong] ||
+            state[:equation]
+
+          strong_tag = unconstrained?(node, content, state) ? "**" : "*"
+          leading = content[0, content.length - content.lstrip.length]
+          trailing = content[content.rstrip.length..]
+          handle_express_escape_seq(
+            node,
+            "#{leading}#{strong_tag}#{content.strip}#{strong_tag}#{trailing}",
+          )
+        end
+
         private
 
+        # Constrained bold (`*x*`) is not recognised inside a word, so
+        # unconstrained markup is needed whenever a word character touches it.
+        def unconstrained?(node, content, state)
+          return true if state[:non_flanking_whitesapce]
+
+          (content.match?(/\A\S/) && word_sibling?(node.previous, /\w\z/)) ||
+            (content.match?(/\S\z/) && word_sibling?(node.next, /\A\w/))
+        end
+
+        def word_sibling?(sibling, pattern)
+          sibling&.text? && sibling.text.match?(pattern)
+        end
+
         def bold_converted(node, state)
           cloned_node = node.clone
           equations = extract_equations(cloned_node)
@@ -23,14 +51,8 @@ module Stepmod
 
           content = if state[:equation] && state[:convert_bold_and_italics]
                       "bb(#{content.strip})"
-                    elsif content.strip.empty? || state[:already_strong] || state[:equation]
-                      content
                     else
-                      strong_tag = state[:non_flanking_whitesapce] ? "**" : "*"
-                      handle_express_escape_seq(
-                        node,
-                        "#{content[/^\s*/]}#{strong_tag}#{content.strip}#{strong_tag}#{content[/\s*$/]}",
-                      )
+                      mark_up(node, content, state)
                     end
 
           [content, equation_content].compact.join("")

data/lib/stepmod/utils/express_bibdata.rb

@@ -1,3 +1,5 @@
+require "pubid"
+
 module Stepmod
   module Utils
     class ExpressBibdata
@@ -22,7 +24,7 @@ module Stepmod
           @pubid = Pubid::Iso::Identifier.parse(published_info)
 
           @part = pubid.part&.to_i
-          @version = pubid.edition&.to_i
+          @version = pubid.edition&.number&.to_i
           @pub_year = pubid.year&.to_i
         elsif !schema.version.nil?
           @part = schema.version.items.find { |i| i.name == "part" }.value&.to_i

data/lib/stepmod/utils/stepmod_file_annotator.rb

@@ -87,7 +87,7 @@ module Stepmod
         # TODO there are schemas with only arm, mim, mim_lf:
         # schemas/modules/limited_length_or_area_indicator_assignment/mim_lf.exp
         part = @identifier.part
-        edition = @identifier.edition
+        edition = @identifier.edition&.number
         schema_or_object = (schema_type == :module) ? "schema" : "object"
 
         "\nSCHEMA #{@schema_name} '{ " \
@@ -246,6 +246,11 @@ processed_images_cache)
           examples = description.xpath("example")
           figures = description.xpath("figure")
           tables = description.xpath("table")
+          state = {
+            schema_and_entity: description["linkend"],
+            descriptions_file: descriptions_file,
+            figure_ids: figures.map { |f| f["id"] || f["number"] },
+          }
 
           converted_description = <<~DESCRIPTION
 
@@ -253,6 +258,7 @@ processed_images_cache)
               wrapper,
               no_notes_examples: true,
               descriptions_file: descriptions_file,
+              figure_ids: state[:figure_ids],
             )}
           DESCRIPTION
 
@@ -263,7 +269,7 @@ processed_images_cache)
           converted_figures = figures.map do |figure|
             Stepmod::Utils::Converters::ExpressFigure
               .new
-              .convert(figure, schema_and_entity: description["linkend"], descriptions_file: descriptions_file)
+              .convert(figure, state)
           end.join
 
           converted_tables = tables.map do |table|
@@ -275,13 +281,13 @@ processed_images_cache)
           converted_notes = notes.map do |note|
             Stepmod::Utils::Converters::ExpressNote
               .new
-              .convert(note, schema_and_entity: description["linkend"], descriptions_file: descriptions_file)
+              .convert(note, state)
           end.join
 
           converted_examples = examples.map do |example|
             Stepmod::Utils::Converters::ExpressExample
               .new
-              .convert(example, schema_and_entity: description["linkend"], descriptions_file: descriptions_file)
+              .convert(example, state)
           end.join
 
           [
@@ -402,16 +408,12 @@ processed_images_cache)
         year = "" if year == "tbd"
         edition = bib.attributes["version"].value
 
-        pubid = Pubid::Iso::Identifier.create(
-          publisher: "ISO",
-          number: 10303,
-        )
-
-        pubid.part = part if part && !part.empty?
-        pubid.year = year.split("-").first if year && !year.empty?
-        pubid.edition = edition if edition && !edition.empty?
+        attrs = { number: 10303 }
+        attrs[:part] = part if part && !part.empty?
+        attrs[:date] = { year: year.split("-").first } if year && !year.empty?
+        attrs[:edition] = { number: edition } if edition && !edition.empty?
 
-        pubid
+        Pubid::Iso::Identifier.new(**attrs)
       end
 
       def resource_bib_data(bib, schema_and_entity)

data/lib/stepmod/utils/terms_extractor.rb

@@ -541,12 +541,12 @@ document:)
                         raise Error.new("[stepmod-utils] encountered unsupported schema_type")
                       end
 
-        if entity.subtype_of.empty?
+        if entity.subtype_of.to_a.empty?
           "#{entity_type} " \
             "that represents the " \
             "#{entity_name_to_text(entity.id)} {{entity}}"
         else
-          entity_subtypes = entity.subtype_of.map do |e|
+          entity_subtypes = entity.subtype_of.to_a.map do |e|
             "{{#{e.id}}}"
           end
 

data/lib/stepmod/utils/version.rb

@@ -1,5 +1,5 @@
 module Stepmod
   module Utils
-    VERSION = "0.6.10.pre.alpha.1".freeze
+    VERSION = "0.6.10".freeze
   end
 end

data/stepmod-utils.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.3.0")
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -42,7 +42,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency "ptools"
   # The pubid monogem ships Pubid::Iso itself; the separate pubid-iso
   # gem is superseded and its lib/pubid/iso.rb shadows the monogem's.
-  spec.add_dependency "pubid", "~> 2.0.0.pre.alpha"
+  spec.add_dependency "pubid", "~> 2.0"
+  spec.add_dependency "relaton", "~> 3.0"
   spec.add_dependency "shale"
   spec.add_dependency "thor", ">= 0.20"
   spec.add_dependency "unitsml"

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stepmod-utils
 version: !ruby/object:Gem::Version
-  version: 0.6.10.pre.alpha.1
+  version: 0.6.10
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -141,14 +142,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.pre.alpha
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: relaton
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.pre.alpha
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: shale
   requirement: !ruby/object:Gem::Requirement
@@ -198,6 +213,7 @@ email:
 - open.source@ribose.com
 executables:
 - stepmod-annotate-all
+- stepmod-convert-bibliography
 - stepmod-convert-express-description
 - stepmod-convert-express-resource
 - stepmod-extract-changes
@@ -221,6 +237,7 @@ files:
 - bin/console
 - bin/setup
 - exe/stepmod-annotate-all
+- exe/stepmod-convert-bibliography
 - exe/stepmod-convert-express-description
 - exe/stepmod-convert-express-resource
 - exe/stepmod-extract-changes
@@ -229,6 +246,7 @@ files:
 - exe/stepmod-validate-express
 - lib/stepmod/utils.rb
 - lib/stepmod/utils/bibdata.rb
+- lib/stepmod/utils/bibliography_converter.rb
 - lib/stepmod/utils/change.rb
 - lib/stepmod/utils/change_collection.rb
 - lib/stepmod/utils/change_edition.rb
@@ -346,6 +364,7 @@ homepage: https://github.com/metanorma/stepmod-utils
 licenses:
 - BSD-2-Clause
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -353,14 +372,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Stepmod-utils is a toolkit that works on STEPmod data.
 test_files: []