stepmod-utils 0.3.23 → 0.3.25

data/lib/stepmod/utils/stepmod_file_annotator.rb

@@ -5,38 +5,69 @@ require "stepmod/utils/converters/express_note"
 require "stepmod/utils/converters/express_example"
 require "stepmod/utils/converters/express_figure"
 require "stepmod/utils/converters/express_table"
+require "expressir"
+require "expressir/express/parser"
+require "pubid-iso"
 
 module Stepmod
   module Utils
     class StepmodFileAnnotator
-      attr_reader :express_file, :resource_docs_cache_file, :stepmod_dir
+      attr_reader :express_file, :resource_docs_cache, :stepmod_dir
 
       # @param express_file [String] path to the exp file needed to annotate
-      # @param resource_docs_cache_file [String] output of ./stepmod-build-resource-docs-cache
-      def initialize(express_file:, resource_docs_cache_file:, stepmod_dir: nil)
+      # @param resource_docs_cache [String] output of ./stepmod-build-resource-docs-cache
+      def initialize(express_file:, stepmod_dir: nil)
         @express_file = express_file
-        @resource_docs_cache_file = resource_docs_cache_file
+        @resource_docs_cache = resource_docs_schemas(stepmod_dir)
         @stepmod_dir = stepmod_dir || Dir.pwd
+        @added_bibdata = {}
+
+        @schema_name = Expressir::Express::Parser.from_file(express_file)
+                                                 .schemas
+                                                 .first
+                                                 .id
+      end
+
+      def resource_docs_schemas(stepmod_dir)
+        filepath = File.join(stepmod_dir, "data/resource_docs/*/resource.xml")
+
+        schemas = {}
+        Dir.glob(filepath).each do |resource_docs_file|
+          match = resource_docs_file.match("data/resource_docs/([^/]+)/resource.xml")
+          resource_docs_dir = match.captures[0]
+
+          resource_docs = Nokogiri::XML(File.read(resource_docs_file)).root
+          resource_docs.xpath("schema").each do |schema|
+            schemas[schema["name"]] = resource_docs_dir
+          end
+        end
+
+        schemas
       end
 
       def call
         match = File.basename(express_file).match('^(arm|mim|bom)\.exp$')
         descriptions_base = match ? "#{match.captures[0]}_descriptions.xml" : "descriptions.xml"
+
         descriptions_file = File.join(File.dirname(express_file),
                                       descriptions_base)
+
         output_express = File.read(express_file)
-        resource_docs_cache = JSON.parse(File.read(resource_docs_cache_file))
+        converted_description = ""
+        base_linked = ""
 
-        if File.exists?(descriptions_file)
+        if File.exist?(descriptions_file)
           descriptions = Nokogiri::XML(File.read(descriptions_file)).root
           added_resource_descriptions = {}
+
           descriptions.xpath("ext_description").each do |description|
             # Add base resource from linked path if exists, eg "language_schema.language.wr:WR1" -> "language_schema"
             base_linked = description["linkend"].to_s.split(".").first
+
             if added_resource_descriptions[base_linked].nil?
               base_reource_doc_dir = resource_docs_cache[description["linkend"].to_s.split(".").first]
               if base_reource_doc_dir
-                output_express << convert_from_resource_file(
+                converted_description << convert_from_resource_file(
                   base_reource_doc_dir, stepmod_dir, base_linked, descriptions_file
                 )
               end
@@ -47,7 +78,7 @@ module Stepmod
             # when a schema description is available from resource.xml and also descriptions.xml, the description from resource.xml is only used.
             # https://github.com/metanorma/annotated-express/issues/32#issuecomment-792609078
             if description.text.strip.length.positive? && resource_docs_dir.nil?
-              output_express << convert_from_description_text(
+              converted_description << convert_from_description_text(
                 descriptions_file, description
               )
             end
@@ -60,7 +91,28 @@ module Stepmod
           end
         end
 
-        output_express
+        bib_file_name = extract_bib_file_name(match, resource_docs_cache[@schema_name || ""])
+        bib_file = if match
+                     File.join(File.dirname(express_file), bib_file_name)
+                   else
+                     resource_docs_file_path(stepmod_dir, bib_file_name)
+                   end
+
+        output_express << if bib_file && File.exist?(bib_file)
+                            prepend_bibdata(
+                              converted_description || "",
+                              # bib_file will not be present for resouces
+                              # that are not in resource_docs cache.
+                              # e.g hierarchy_schema
+                              bib_file,
+                              @schema_name,
+                              match,
+                            )
+                          else
+                            converted_description
+                          end
+
+        sanitize(output_express)
       rescue StandardError => e
         puts "[ERROR]!!! #{e.message}"
         puts e.backtrace
@@ -68,6 +120,10 @@ module Stepmod
 
       private
 
+      def sanitize(file_content)
+        file_content.gsub("(*)", "(`*`)")
+      end
+
       def convert_from_description_text(descriptions_file, description)
         Dir.chdir(File.dirname(descriptions_file)) do
           wrapper = "<ext_descriptions>#{description}</ext_descriptions>"
@@ -119,10 +175,146 @@ module Stepmod
         end
       end
 
+      def prepend_bibdata(description, bibdata_file, schema_and_entity, match)
+        bib = Nokogiri::XML(File.read(bibdata_file)).root
+        bibdata = extract_bib_data(match, bib, schema_and_entity)
+
+        return description.to_s if @added_bibdata[schema_and_entity]
+
+        published_in = <<~PUBLISHED_IN
+
+          (*"#{schema_and_entity}.__published_in"
+          #{bibdata[:identifier]}
+          *)
+        PUBLISHED_IN
+
+        identifier = <<~IDENTIFIER if bibdata[:number]
+          (*"#{schema_and_entity}.__identifier"
+          ISO/TC 184/SC 4/WG 12 N#{bibdata[:number]}
+          *)
+        IDENTIFIER
+
+        supersedes = <<~SUPERSEDES if bibdata[:supersedes_concept]
+          (*"#{schema_and_entity}.__supersedes"
+          ISO/TC 184/SC 4/WG 12 N#{bibdata[:supersedes_concept]}
+          *)
+        SUPERSEDES
+
+        status = <<~STATUS if bibdata[:status]
+          (*"#{schema_and_entity}.__status"
+          #{bibdata[:status]}
+          *)
+        STATUS
+
+        title = <<~TITLE if bibdata[:title]
+          (*"#{schema_and_entity}.__title"
+          #{bibdata[:title]}
+          *)
+        TITLE
+
+        document = <<~DOCUMENT if bibdata_file
+          (*"#{schema_and_entity}.__schema_file"
+          #{Pathname(bibdata_file).relative_path_from(@stepmod_dir)}
+          *)
+        DOCUMENT
+
+        @added_bibdata[schema_and_entity] = true
+
+        [
+          published_in,
+          identifier,
+          supersedes,
+          status,
+          title,
+          description,
+          document,
+        ].compact.join("\n")
+      end
+
+      def module?(match)
+        match && %w[arm mim].include?(match.captures[0])
+      end
+
+      def bom?(match)
+        match && %w[bom].include?(match.captures[0])
+      end
+
+      def extract_bib_file_name(match, default_file_name = "")
+        return default_file_name || "" unless match
+
+        if %w[arm mim].include?(match.captures[0])
+          "module.xml"
+        else
+          "business_object_model.xml"
+        end
+      end
+
+      def extract_bib_data(match, bib, schema_and_entity)
+        return resource_bib_data(bib, schema_and_entity) unless match
+
+        if module?(match)
+          module_bib_data(bib, match.captures[0])
+        elsif bom?(match)
+          bom_bib_data(bib)
+        end
+      end
+
+      def identifier(bib)
+        part = bib.attributes["part"].value
+        year = bib.attributes["publication.year"].value
+
+        # year="tbd" in data/modules/geometric_tolerance/module.xml and
+        # probabaly in some other places as well
+        year = "" if year == "tbd"
+        edition = bib.attributes["version"].value
+
+        pubid = Pubid::Iso::Identifier.new(
+          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?
+
+        pubid.to_s(with_edition: true)
+      end
+
+      def resource_bib_data(bib, schema_and_entity)
+        schema = bib.xpath("schema[@name='#{schema_and_entity}']").first
+
+        {
+          identifier: identifier(bib),
+          number: schema.attributes["number"],
+          supersedes_concept: schema.attributes["number.supersedes"],
+          status: bib.attributes["status"],
+          title: bib.attributes["title"] || bib.attributes["name"],
+        }
+      end
+
+      def module_bib_data(bib, type)
+        {
+          identifier: identifier(bib),
+          number: bib.attributes["wg.number.#{type}"],
+          supersedes_concept: bib.attributes["wg.number.#{type}.supersedes"],
+          status: bib.attributes["status"],
+          title: bib.attributes["title"] || bib.attributes["name"],
+        }
+      end
+
+      def bom_bib_data(bib)
+        {
+          identifier: identifier(bib),
+          number: bib.attributes["wg.number.bom.exp"],
+          supersedes_concept: bib.attributes["wg.number.bom.supersedes"],
+          status: bib.attributes["status"],
+          title: bib.attributes["title"] || bib.attributes["name"],
+        }
+      end
+
       def convert_from_resource_file(resource_docs_dir, stepmod_dir, linked, descriptions_file)
-        resource_docs_file = File.join(stepmod_dir, "data/resource_docs",
-                                       resource_docs_dir, "resource.xml")
-        # puts(resource_docs_file)
+        resource_docs_file = resource_docs_file_path(stepmod_dir, resource_docs_dir)
+
         resource_docs = Nokogiri::XML(File.read(resource_docs_file)).root
         schema = resource_docs.xpath("schema[@name='#{linked}']")
 
@@ -133,11 +325,20 @@ module Stepmod
             wrapper,
             {
               no_notes_examples: false,
-              schema_and_entity: linked
-            }
+              schema_and_entity: linked,
+            },
           )
         end
       end
+
+      def resource_docs_file_path(stepmod_dir, resource_docs_dir)
+        File.join(
+          stepmod_dir,
+          "data/resource_docs",
+          resource_docs_dir,
+          "resource.xml",
+        )
+      end
     end
   end
 end

data/lib/stepmod/utils/term.rb

@@ -7,9 +7,9 @@ module Stepmod
       attr_accessor :acronym
 
       def to_mn_adoc
-        mn_adoc = ["=== #{definition}"]
+        mn_adoc = ["=== #{definition.map(&:content).join}"]
         mn_adoc << "\nalt:[#{acronym}]" if acronym
-        mn_adoc << "\n\n#{designations.join(", ")}" if designations&.any?
+        mn_adoc << "\n\n#{designations.map(&:designation).join(", ")}" if designations&.any?
 
         mn_adoc.join
       end
@@ -18,15 +18,28 @@ module Stepmod
         def from_h(hash)
           _, definition, acronym = treat_acronym(hash["definition"])
 
-          hash["definition"] = definition
+          hash["definition"] = [definition]
+
           hash["acronym"] = acronym.gsub(/\(|\)/, "") if acronym
-          hash["designations"] = hash["synonyms"]
+          add_designations(hash, hash["synonyms"]) if hash["synonyms"]
 
-          super(hash.reject { |k, _| k == "synonyms" })
+          new(hash.reject { |k, _| k == "synonyms" })
         end
 
         private
 
+        def add_designations(hash, synonyms)
+          hash["designations"] ||= []
+          hash["designations"] << designation_hash(synonyms) if synonyms
+        end
+
+        def designation_hash(value, type = "expression")
+          {
+            "designation" => value,
+            "type" => type,
+          }
+        end
+
         def treat_acronym(term_def)
           return [nil, term_def.strip, nil] unless term_def.match?(/.+\(.+?\)$/)