stepmod-utils 0.3.18 → 0.3.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d666c11f9282db59fefb04c07c40a88f6167cd214d316f2b1a14ae7117ce898
-  data.tar.gz: fe07f66170d74a97a95003b0f5e3594c5f2bbeaa3d431b716ce52f01d13d418d
+  metadata.gz: 0d50ed47ffc263b007aa9f2bda3bf5535d9cf84dbc56f1fc87c63d4255ed3f02
+  data.tar.gz: 3572d73a116953f337ac8add7bb47133f33ab3244daa6f3ee58e9901f26cb5f1
 SHA512:
-  metadata.gz: 7b2fea45d8a30e633e393afac572894481d7de3bf5a33cd19043b6b55cb5b2c948666eb705b4cc9e69a12fe7b43217ca80f8f9a47d7aab4507b1b00c4136476e
-  data.tar.gz: 8e5334b99ece0ad5bff37d8ffd7cd70c64fd4998c3e0f4da58825802420f8537493a7858a6158b00ffcfdb3907a532e44067ab4ba07f7cc8f6091b5bb7912517
+  metadata.gz: 5263394029779a53cca0c8f41171eb5bbc8e2490de14041c4e6ae56f8880a0f4eff49c1235d43d69f0d34501e5ae372a4c77bbfeb459147765fd87f81014d7dd
+  data.tar.gz: 6aab6c46a9023e194fe278cedd353807d070eba8c61949777af13ff63a26d3f652a304575cfc56873b54fd57187347a1321df40d7527905320689664da89991c

data/exe/stepmod-extract-terms

@@ -153,10 +153,13 @@ end
 
 log "INFO: written summary file to: 04x-stepmod-entities-resources.adoc"
 
-part_modules.each do |(bibdata, part_modules_arm, part_modules_mim)|
+part_modules.sort_by do |(bibdata, part_modules_arm, part_modules_mim)|
+  bibdata.part.to_i
+end.each do |(bibdata, part_modules_arm, part_modules_mim)|
   fn = "05x-stepmod-entities-modules-#{bibdata.part}.adoc"
   File.open(fn, "w") do |file|
     file.puts("")
+
     unless part_modules_arm.empty?
       schema_name = part_modules_arm.first.first
       concepts = part_modules_arm.first.last.to_a.map do |n|
@@ -181,6 +184,7 @@ part_modules.each do |(bibdata, part_modules_arm, part_modules_mim)|
       file.puts(replace_images(concepts.map(&:to_mn_adoc).join("\n")))
     end
   end
+
   log "INFO: written to: #{fn}"
 end
 

data/lib/stepmod/utils/concept.rb

@@ -10,6 +10,8 @@ module Stepmod
         file_path
       )
 
+      # TODO: converted_definition is not supposed to be an attribute, it is
+      # supposed to be a method!
       class << self
         def parse(definition_xml, reference_anchor:, reference_clause:, file_path:, language_code: "en")
           converted_definition = Stepmod::Utils::StepmodDefinitionConverter.convert(
@@ -35,6 +37,8 @@ module Stepmod
             ).strip
           end
 
+          # TODO: `designations:` should include the `alt:[...]` terms here,
+          # they are now only included in definition_xml_converted_definition.
           new(
             designations: [designation],
             definition: definition,

data/lib/stepmod/utils/terms_extractor.rb

@@ -26,7 +26,8 @@ module Stepmod
                   :part_concepts,
                   :part_resources,
                   :part_modules,
-                  :stdout
+                  :stdout,
+                  :git_rev
 
       def self.call(stepmod_dir, index_path, stdout = $stdout)
         new(stepmod_dir, index_path, stdout).call
@@ -65,6 +66,12 @@ module Stepmod
         log "INFO: STEPmod directory set to #{stepmod_dir}."
         log "INFO: Detecting paths..."
 
+        # Run `cvs status` to find out version
+        log "INFO: Detecting Git SHA..."
+        Dir.chdir(stepmod_path) do
+          @git_rev = `git rev-parse HEAD` || nil
+        end
+
         repo_index = Nokogiri::XML(File.read(@index_path)).root
 
         files = []
@@ -134,8 +141,8 @@ module Stepmod
           end
 
           unless ACCEPTED_STAGES.include? bibdata.doctype
-            log "INFO: skipped #{bibdata.docid} as it is not \
-              one of (#{ACCEPTED_STAGES.join(', ')})."
+            log "INFO: skipped #{bibdata.docid} as it is not " \
+              "one of (#{ACCEPTED_STAGES.join(', ')})."
             next
           end
 
@@ -145,23 +152,9 @@ module Stepmod
             next
           end
 
-          revision_string = ""
-
-          # Run `cvs status` to find out version
-          log "INFO: Detecting Git SHA..."
-          Dir.chdir(stepmod_path) do
-            git_sha = `git rev-parse HEAD`
-
-            unless git_sha.empty?
-              revision_string = "\n// Git: SHA #{git_sha}"
-            end
-          end
-
           # read definitions
           current_part_concepts = Glossarist::Collection.new
-          definition_index = 0
-          current_document.xpath("//definition").each do |definition|
-            definition_index += 1
+          current_document.xpath("//definition").each.with_index(1) do |definition, definition_index|
             term_id = definition["id"]
             unless term_id.nil?
               if encountered_terms[term_id]
@@ -178,7 +171,7 @@ module Stepmod
               definition,
               reference_anchor: bibdata.anchor,
               reference_clause: ref_clause,
-              file_path: fpath + revision_string,
+              file_path: fpath,
             )
             next unless concept
 
@@ -197,10 +190,10 @@ module Stepmod
           current_part_modules_arm = {}
           current_part_modules_mim = {}
 
-          log "INFO: FILE PATH IS #{file_path}"
+          # log "INFO: FILE PATH IS #{file_path}"
           case file_path.to_s
           when /resource.xml$/
-            log "INFO: Processing resource.xml for #{file_path}"
+            log "INFO: Processing resource.xml for #{fpath}"
 
             current_document.xpath("//schema").each do |schema_node|
               schema_name = schema_node["name"]
@@ -259,7 +252,7 @@ module Stepmod
             end
 
           when /module.xml$/
-            log "INFO: Processing module.xml for #{file_path}"
+            log "INFO: Processing module.xml for #{fpath}"
             # Assumption: every schema is only linked by a single module document.
             # puts current_document.xpath('//module').length
             schema_name = current_document.xpath("//module").first["name"]
@@ -272,101 +265,36 @@ module Stepmod
               parsed_schema_names[schema_name] = file_path
             end
 
-            exp_annotated_path =
-              "#{stepmod_path}/modules/#{schema_name}/arm_annotated.exp"
-
-            log "INFO: Processing modules schema #{exp_annotated_path}"
-
-            if File.exists?(exp_annotated_path)
-              repo = Expressir::Express::Parser.from_file(exp_annotated_path)
-
-              repo.schemas.each do |schema|
-                schema.entities.each do |entity|
-                  old_definition = entity.remarks.first
-
-                  domain = "application module: #{schema.id}"
-                  entity_definition = generate_entity_definition(entity, domain, old_definition)
-
-                  reference_anchor = bibdata.anchor
-                  reference_clause = nil
-
-                  concept = Stepmod::Utils::Concept.new(
-                    designations: [entity.id],
-                    definition: old_definition,
-                    converted_definition: entity_definition,
-                    id: "#{reference_anchor}.#{reference_clause}",
-                    reference_anchor: reference_anchor,
-                    reference_clause: reference_clause,
-                    file_path: Pathname.new(exp_annotated_path)
-                                .relative_path_from(stepmod_path),
-                    language_code: "en",
-                  )
-
-                  next unless concept
+            arm_schema, arm_concepts = parse_annotated_module(
+              type: :arm,
+              stepmod_path: stepmod_path,
+              path: "modules/#{schema_name}/arm_annotated.exp",
+              bibdata: bibdata
+            )
 
-                  current_part_modules_arm[schema.id] ||=
-                    Glossarist::Collection.new
-                  find_or_initialize_concept(
-                    current_part_modules_arm[schema.id], concept
-                  )
+            mim_schema, mim_concepts = parse_annotated_module(
+              type: :mim,
+              stepmod_path: stepmod_path,
+              path: "modules/#{schema_name}/mim_annotated.exp",
+              bibdata: bibdata
+            )
 
-                  # puts part_modules_arm.inspect
-                  parsed_bibliography << bibdata
-                end
-              end
+            if arm_concepts.to_a.size > 0
+              current_part_modules_arm[arm_schema] = arm_concepts
             end
 
-            mim_exp_annotated_path = "#{stepmod_path}/modules/#{schema_name}/mim_annotated.exp"
-
-            log "INFO: Processing modules schema #{mim_exp_annotated_path}"
-
-            if File.exists?(mim_exp_annotated_path)
-              repo = Expressir::Express::Parser.from_file(mim_exp_annotated_path)
-
-              repo.schemas.each do |schema|
-                schema.entities.each do |entity|
-                  old_definition = entity.remarks.first
-
-                  domain = "application module: #{schema.id}"
-                  definition = generate_entity_definition(entity, domain, old_definition)
-
-                  reference_anchor = bibdata.anchor
-                  reference_clause = nil
-
-                  concept = Stepmod::Utils::Concept.new(
-                    designations: [entity.id],
-                    definition: old_definition,
-                    converted_definition: definition,
-                    id: "#{reference_anchor}.#{reference_clause}",
-                    reference_anchor: reference_anchor,
-                    reference_clause: reference_clause,
-                    file_path: Pathname.new(exp_annotated_path)
-                                .relative_path_from(stepmod_path),
-                    language_code: "en",
-                  )
-
-                  next unless concept
-
-                  current_part_modules_mim[schema.id] ||=
-                    Glossarist::Collection.new
-                  find_or_initialize_concept(
-                    current_part_modules_mim[schema.id], concept
-                  )
-
-                  parsed_bibliography << bibdata
-                end
-              end
+            if mim_concepts.to_a.size > 0
+              current_part_modules_mim[mim_schema] = mim_concepts
             end
-
           end
 
           log "INFO: Completed processing XML file #{fpath}"
           if current_part_concepts.to_a.empty?
-            log "INFO: Skipping #{fpath} (#{bibdata.docid}) \
-              because it contains no concepts."
+            log "INFO: Skipping #{fpath} (#{bibdata.docid}) " \
+              "because it contains no concepts."
           elsif current_part_concepts.to_a.length < 3
-            log "INFO: Skipping #{fpath} (#{bibdata.docid}) \
-              because it only has #{current_part_concepts.to_a.length} terms."
+            log "INFO: Skipping #{fpath} (#{bibdata.docid}) " \
+              "because it only has #{current_part_concepts.to_a.length} terms."
 
             current_part_concepts.to_a.each do |x|
               general_concepts.store(x)
@@ -377,23 +305,85 @@ module Stepmod
                                 current_part_concepts]
             end
           end
+
           unless current_part_resources.to_a.empty?
             part_resources << [bibdata,
                                current_part_resources]
           end
+
           if (current_part_modules_arm.to_a.size +
               current_part_modules_mim.to_a.size).positive?
+
             part_modules << [bibdata, current_part_modules_arm,
                              current_part_modules_mim]
+            parsed_bibliography << bibdata
           end
+
         end
       end
 
-      def find_or_initialize_concept(collection, localized_concept)
-        concept_id = SecureRandom.uuid
+      def parse_annotated_module(type:, stepmod_path:, path:, bibdata:)
+        log "INFO: parse_annotated_module: Processing modules schema #{path}"
+
+        fpath = File.join(stepmod_path, path)
+
+        unless File.exists?(fpath)
+          log "ERROR: parse_annotated_module: No module schema exists at #{fpath}."
+          return
+        end
+
+        repo = Expressir::Express::Parser.from_file(fpath)
+
+        unless repo
+          log "ERROR: parse_annotated_module: failed to parse EXPRESS file at #{path}."
+          return
+        end
+
+        # See: metanorma/iso-10303-2#90
+        domain_prefix = case type
+        when :mim
+          "application module"
+        when :arm
+          "application object"
+        end
 
+        if repo.schemas.length > 1
+          raise StandardError.new(
+            "ERROR: FATAL: #{fpath} contains more than one schema:" +
+            "#{repo.schemas.map(&:id).join(", ")} (not supposed to happen!!)"
+          )
+        end
+
+        schema = repo.schemas.first
+        collection = Glossarist::Collection.new
+        domain = "#{domain_prefix}: #{schema.id}"
+
+        schema.entities.each do |entity|
+          old_definition = entity.remarks.first
+          new_definition = generate_entity_definition(entity, domain, old_definition)
+
+          concept = Stepmod::Utils::Concept.new(
+            designations: [entity.id],
+            definition: old_definition,
+            converted_definition: new_definition,
+            # TODO: Find a proper ID for this
+            id: "#{bibdata.anchor}.",
+            reference_anchor: bibdata.anchor,
+            reference_clause: nil,
+            file_path: path,
+            language_code: "en",
+          )
+
+          next unless concept
+          find_or_initialize_concept(collection, concept)
+        end
+
+        [schema.id, collection]
+      end
+
+      def find_or_initialize_concept(collection, localized_concept)
         concept = collection
-          .store(Glossarist::Concept.new(id: concept_id))
+          .store(Glossarist::Concept.new(id: SecureRandom.uuid))
         concept.add_l10n(localized_concept)
       end
 
@@ -454,7 +444,9 @@ module Stepmod
         combined.gsub!(/\n\/\/.*?\n/, "\n")
         combined.strip!
 
-        combined
+        express_reference_to_mention(combined)
+
+        # combined
         # # TODO: If the definition contains a list immediately after the first paragraph, don't split
         # return definition if definition =~ /\n\* /
 
@@ -471,19 +463,58 @@ module Stepmod
         # end
       end
 
+      # Replace `<<express:{schema}.{entity},{render}>>` with {{entity,render}}
+      def express_reference_to_mention(description)
+        # TODO: Use Expressir to check whether the "entity" is really an
+        # EXPRESS ENTITY. If not, skip the mention.
+        description.gsub(/<<express:([^,]+),([^>]+)>>/) do |match|
+          "{{#{Regexp.last_match[1].split('.').last},#{Regexp.last_match[2]}}}"
+        end
+      end
+
+      def entity_name_to_text(entity_id)
+        entity_id.downcase.gsub(/_/, " ")
+      end
 
       # rubocop:disable Layout/LineLength
       def generate_entity_definition(entity, domain, old_definition)
         return "" if entity.nil?
 
-        entity_text = if entity.subtype_of.size.zero?
-                        "entity data type that represents " +
-                        entity.id.indefinite_article + " **#{entity.id}** entity"
-                      else
-                        "entity data type that is a type of "+
-                        "**#{entity.subtype_of.map(&:id).join('** and **')}** that represents " +
-                        entity.id.indefinite_article + " **#{entity.id}** entity"
-                      end
+        # See: metanorma/iso-10303-2#90
+        # TODO: This is not DRY in case we have to further customize
+        entity_text = if domain_type = domain.match(/\A(application object):/)
+
+          entity_ref = if entity.id == entity_name_to_text(entity.id)
+            "{{#{entity.id}}}"
+          else
+            "{{#{entity.id},#{entity_name_to_text(entity.id)}}}"
+          end
+
+          if entity.subtype_of.size.zero?
+            "#{domain_type[1]} that represents the " + entity_ref + " entity"
+          else
+            entity_subtypes = entity.subtype_of.map do |e|
+              "{{#{e.id},#{entity_name_to_text(e.id)}}}"
+            end
+            "#{domain_type[1]} that is a type of " +
+            "#{entity_subtypes.join(' and ')} that represents the " +
+            entity_ref + " entity"
+          end
+
+        else
+
+          # Not "application object"
+          if entity.subtype_of.size.zero?
+            "entity data type that represents the {{#{entity.id}}} entity"
+          else
+            entity_subtypes = entity.subtype_of.map do |e|
+              "{{#{e.id}}}"
+            end
+            "entity data type that is a type of " +
+            "#{entity_subtypes.join(' and ')} that represents the " +
+            "{{#{entity.id}}} entity"
+          end
+        end
 
         definition = <<~DEFINITION
           === #{entity.id}
@@ -493,6 +524,7 @@ module Stepmod
 
         DEFINITION
 
+        # If there is a definition, we add it as the first NOTE
         unless old_definition.nil? || old_definition.blank?
           old_definition = trim_definition(old_definition)
 

data/lib/stepmod/utils/version.rb

@@ -1,5 +1,5 @@
 module Stepmod
   module Utils
-    VERSION = "0.3.18".freeze
+    VERSION = "0.3.21".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stepmod-utils
 version: !ruby/object:Gem::Version
-  version: 0.3.18
+  version: 0.3.21
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-08 00:00:00.000000000 Z
+date: 2022-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby