stepmod-utils 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d46a471013b96ac232688535ff7384c7044d166987ae53dd2e1fefd0009a73fb
-  data.tar.gz: 39a320ba1cd3b7d05fcb34f17077d12ac036b1de3ed0db730af214f0127ceea0
+  metadata.gz: 46b71314210eb0f813efd1fe7862b3e5bc061133e2cfe7f32df95a77e5f4e290
+  data.tar.gz: c6fffa6edd1e0565127f2da4872c624bd2c501be27afabd456b50379a5904a05
 SHA512:
-  metadata.gz: 723e010d940375916081ed59592c413219f5b0fce10df237bf6504a8be5a40c7405a8b057ec8fe692f2307fcddaecf763cb23dd1a152d1ed1a7e07087e0f49a0
-  data.tar.gz: ada92ea7ec12cbe80509a6f9d5a45d354211b9f9aa5a5f18e5dc2e86de58569a63572d65937ccba26917931a7315c016fa4bdd8f660602d46085cb190b1cd61b
+  metadata.gz: 7fb0a8b89aed9d4db7c1aaa2e0d7f8881b0b5c0869019f287d6d50f472795356830d7b4f3751c163adc59db3ac5ec567516f92ebfa029fa29f85eb05b42671c4
+  data.tar.gz: f2b1717966c60aa636bd79e90df18c28b1a1829c7277ece5adb19180a63c01842756497b6004ff38b48350bc5b7c704117c7ecd7e12b4ad07e9755add899fdb5

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+Gemfile.lock

data/Gemfile

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in stepmod-utils.gemspec
 gemspec
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"

data/README.adoc

@@ -10,11 +10,7 @@ image:https://img.shields.io/github/commits-since/metanorma/stepmod-utils/latest
 
 == Purpose
 
-The stepmod-utils Ruby gem is a wrapper around the Java https://github.com/metanorma/stepmod-utils[stepmod-utils]
-which converts NISO STS and ISOSTS into Metanorma XML and AsciiDoc files.
-
-This gem is used to provide stepmod-utils.jar with mirrored version numbers, to allow
-Ruby code to easily refer to the desired stepmod-utils version as dependencies.
+The stepmod-utils Ruby gem provides a number of tools to work with the STEPmod repository/
 
 == Installation
 
@@ -27,34 +23,18 @@ Or include it in your gemspec.
 
 == Usage
 
-[source,ruby]
+[source,sh]
 ----
-require 'stepmod-utils'
-Sts2mn.convert(input: 'test/sts.xml')
-# => generates 'test/sts.adoc', in Metanorma AsciiDoc
-
-Sts2mn.convert(input: 'test/sts.xml', output: 'another/path/mn.xml', format: 'xml')
-# => generates 'another/path/mn.xml' in Metanorma XML
+# Extracts from current directory
+$ stepmod-extract-terms
 
-Sts2mn.convert(input: 'test/sts.xml', output: 'another/path/mn.adoc', format: 'adoc')
-# => generates 'another/path/mn.adoc' in Metanorma AsciiDoc
-
-Sts2mn.split_bibdata('test/sts.xml')
-# => generates 'test/sts.rxl' (Relaton XML) and 'test/mn.adoc' (Metanorma AsciiDoc)
+# Extracts from specified stepmod/ or stepmod/data/ directory
+$ stepmod-extract-terms {stepmod-data-directory}
 ----
 
-== Updating the gem
-
-Update `lib/stepmod-utils/version.rb` to the desired version of https://github.com/metanorma/stepmod-utils[stepmod-utils].
-
-Run `rake` to download the `bin/stepmod-utils.jar` file:
-
-[source,ruby]
-----
-rm -f bin/stepmod-utils.jar
-rake bin/stepmod-utils.jar
-----
+Then these files will be created:
 
-Then release the gem with `rake release`.
+* `031-generated-terms.adoc` all terms extracted
+* `991-generated-bibliography.adoc` all bibliographic sources where the terms come from
 
 

data/exe/stepmod-extract-terms

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# resolve bin path, ignoring symlinks
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+# Fixes https://github.com/rubygems/rubygems/issues/1420
+require "rubygems/specification"
+
+class Gem::Specification
+  def this; self; end
+end
+
+require 'bundler/setup'
+require 'stepmod/utils/stepmod_definition_converter'
+require 'stepmod/utils/bibdata'
+require 'stepmod/utils/concept'
+
+ReverseAsciidoctor.config.unknown_tags = :bypass
+
+parsed_terms = []
+parsed_bibliography = []
+encountered_terms = {}
+
+stepmod_dir = ARGV.first || Dir.pwd
+
+def log message
+  puts "[stepmod-utils] #{message}"
+end
+
+log "STEPmod directory set to #{stepmod_dir}. Detecting paths..."
+
+files = %w(
+  resource.xml
+  application_protocol.xml
+  business_object_model.xml
+  module.xml
+  ).inject([]) do |acc, t|
+    acc << Dir["#{stepmod_dir}/**/#{t}"]
+end.flatten.sort.uniq
+
+files.each do |file_path|
+  log "Processing XML file #{file_path}"
+  current_document = Nokogiri::XML(File.read(file_path)).root
+
+  bibdata = nil
+  begin
+    bibdata = Stepmod::Utils::Bibdata.new(document: current_document)
+  rescue
+    log "WARNING: Unknown file #{file_path}, skipped"
+    next
+  end
+
+  if bibdata.part.to_s.empty?
+    log "FATAL: missing `part` attribute: #{file_path}"
+  end
+
+  # read definitions
+  current_document.xpath('//definition').each.with_index(1) do |definition, index|
+
+    term_id = definition['id']
+    unless term_id.nil?
+      if encountered_terms[term_id]
+        log "FATAL: Duplicated term with id: #{term_id}, #{file_path}"
+      end
+      encountered_terms[term_id] = true
+    end
+
+    concept = Stepmod::Utils::Concept.parse(
+      definition,
+      reference_anchor: bibdata.anchor,
+      # Assume that definition is located in clause 3 of the ISO document
+      # in order. We really don't have a good reference here.
+      reference_clause: "3.#{index}"
+    )
+
+    parsed_terms << concept
+    parsed_bibliography << bibdata
+  end
+
+end
+
+parsed_bibliography.uniq!
+
+File.open('031-generated-terms.adoc', 'w') { |file|
+  file.puts(parsed_terms.map(&:to_mn_adoc).join("\n"))
+}
+
+log "written to: 031-generated-terms.adoc"
+
+File.open('991-generated-bibliography.adoc', 'w') { |file|
+  file.puts(parsed_bibliography.map(&:to_mn_adoc).join("\n"))
+}
+
+log "written to: 991-generated-bibliography.adoc"

data/lib/stepmod/utils/bibdata.rb

@@ -0,0 +1,122 @@
+module Stepmod
+  module Utils
+
+    class Bibdata
+
+      DOCNUMBER = 10303
+
+      attr_accessor *%w(
+        type doctype part title_en title_fr version language pub_year pub_date
+      )
+
+      def initialize(document:)
+        return nil unless document.is_a?(Nokogiri::XML::Element)
+
+        # module, resource, application_protocol, business_object_model
+        @type = document.name
+
+        raise 'UnknownFileError' unless %w(module resource application_protocol business_object_model).include?(@type)
+
+        @doctype = document['status']
+        @part = document['part']
+        @title_en = document['title'] ||
+          document['name'].gsub('_', ' ').capitalize.gsub('2d','2D').gsub('3d','3D')
+        @title_fr = document['name.french']
+        @version = document['version']
+        @language = document['language']
+
+        # Some publication.year contains month...
+        @pub_year = document['publication.year'].split('-').first
+        @pub_date = document['publication.date']
+
+        # puts to_mn_adoc
+
+        return self
+        # <module
+        #    name="security_classification"
+        #    name.french="Classification des s&#233;curit&#233;s"
+        #    part="1015"
+        #    wg.number="1095"
+        #    wg.number.supersedes="720"
+        #    wg.number.arm.supersedes="1096"
+        #    wg.number.arm="3221"
+        #    wg.number.mim="1097"
+        #    checklist.internal_review="2133"
+        #    checklist.project_leader="2134"
+        #    checklist.convener="2135"
+        #    version="1"
+        #    status="TS"
+        #    language="E"
+        #    publication.year="2004"
+        #     publication.date="2004-12-01"
+        #    published="y"
+        #    rcs.date="$Date: 2009/11/02 10:59:35 $"
+        #    rcs.revision="$Revision: 1.26 $"
+        #   development.folder="dvlp"
+        # >
+
+      end
+
+      def docid
+        no_date = case doctype
+        when "IS"
+          "ISO #{DOCNUMBER}-#{part}"
+        when "WD"
+          "ISO/WD #{DOCNUMBER}-#{part}"
+        when "CD"
+          "ISO/CD #{DOCNUMBER}-#{part}"
+        when "DIS"
+          "ISO/DIS #{DOCNUMBER}-#{part}"
+        when "TS"
+          "ISO/TS #{DOCNUMBER}-#{part}"
+        when "CD-TS"
+          "ISO/CD TS #{DOCNUMBER}-#{part}"
+        else
+          "UNKNOWN DOCTYPE: (#{doctype})"
+        end
+
+        if pub_year
+          "#{no_date}:#{pub_year}"
+        else
+          no_date
+        end
+      end
+
+      def part_title
+        case part
+        when [200..299]
+          "Application protocol: #{title_en}"
+        when [300..399]
+          "Abstract test suite: #{title_en}"
+        when [400..499]
+          "Application module: #{title_en}"
+        when [500..599]
+          "Application interpreted construct: #{title_en}"
+        when [1000..1799]
+          "Application module: #{title_en}"
+        else
+          title_en
+        end
+      end
+
+      def full_title
+        "Industrial automation systems and integration -- Product data representation and exchange -- Part #{part}: #{part_title}"
+      end
+
+      def anchor
+        docid.gsub('/', '-').gsub(' ', '_').gsub(':', '_')
+      end
+
+      def to_mn_adoc
+        if title_en
+          "* [[[#{anchor},#{docid}]]], _#{full_title}_"
+        else
+          "* [[[#{anchor},#{docid}]]]"
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/stepmod/utils/concept.rb

@@ -0,0 +1,32 @@
+module Stepmod
+  module Utils
+
+    class Concept
+      attr_accessor *%w(designation definition reference_anchor reference_clause examples notes synonym converted_definition)
+
+      def initialize(options)
+        options.each_pair do |k, v|
+          send("#{k}=", v)
+        end
+      end
+
+      def self.parse(definition_xml, reference_anchor:, reference_clause:)
+        new(
+          converted_definition: Stepmod::Utils::StepmodDefinitionConverter.convert(definition_xml),
+          reference_anchor: reference_anchor,
+          reference_clause: reference_clause
+        )
+      end
+
+      def to_mn_adoc
+        <<~TEXT
+          #{converted_definition}
+
+          [.source]
+          <<#{reference_anchor},clause=#{reference_clause}>>
+        TEXT
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class ClauseRef < ReverseAsciidoctor::Converters::Base
+        def convert(node, _state = {})
+          " term:[#{normalized_ref(node['linkend'])}] "
+        end
+
+        private
+
+        def normalized_ref(ref)
+          return unless ref || ref.empty?
+
+          ref.to_s.split(':').last.squeeze(' ').strip
+        end
+      end
+      ReverseAsciidoctor::Converters.register :clause_ref, ClauseRef.new
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+
+module Stepmod
+  module Utils
+    module Converters
+      class Def < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          node = node.dup
+          "#{additional_block(node)}#{treat_children(node, state)}"
+        end
+
+        private
+
+        def treat_children(node, state)
+          converted = node.children.each_with_object({}) do |child, res|
+                        content = treat(child, state).strip
+                        next if content.empty?
+
+                        res[child] = content
+                      end
+          previous = nil
+          result = ''
+          converted.each.with_index do |(child, content), i|
+            if i == 0 || !block_tag?(child, previous)
+              result += " #{content}"
+            else
+              result += "\n\n#{content}"
+            end
+            previous = child
+          end
+          result.strip
+        end
+
+        def block_tag?(child, previous)
+          %w[ul example note alt p].include?(child.name) ||
+            (child.previous && %w[ul example note alt p].include?(child.previous.name))
+        end
+
+        def additional_block(node)
+          # Treat first `p` tag as an `alt` block, metanorma/stepmod-utils#9
+          first_child_tag = node
+                              .children
+                              .find { |n| n.is_a?(Nokogiri::XML::Element) }
+          return unless can_transform_to_alt?(first_child_tag)
+
+          result = Stepmod::Utils::Converters::Synonym
+                    .new
+                    .convert(first_child_tag)
+          first_child_tag.remove
+          "#{result}\n\n"
+        end
+
+        # metanorma/stepmod-utils#18 when para is the only text doe snot transform it
+        def can_transform_to_alt?(first_child_tag)
+          return false unless first_child_tag&.name == 'p' &&
+                                defined?(Stepmod::Utils::Converters::Synonym)
+
+          next_sibling = first_child_tag.next
+          while next_sibling
+            return true if !next_sibling.text.to_s.strip.empty? && %w[p text].include?(next_sibling.name)
+            next_sibling = next_sibling.next
+          end
+          false
+        end
+      end
+
+      ReverseAsciidoctor::Converters.register :def, Def.new
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Definition < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          treat_children(node, state)
+        end
+
+        private
+
+        def treat_children(node, state)
+          res = node.children.map { |child| treat(child, state) }
+          res.map(&:strip).reject(&:empty?).join("\n\n")
+        end
+      end
+
+      ReverseAsciidoctor::Converters.register :definition, Definition.new
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Em < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          content = treat_children(node, state.merge(already_italic: true))
+          if content.strip.empty? || state[:already_italic]
+            content
+          else
+            "#{content[/^\s*/]}_#{content.strip}_#{content[/\s*$/]}"
+          end
+        end
+      end
+
+      ReverseAsciidoctor::Converters.register :em, Em.new
+      ReverseAsciidoctor::Converters.register :cite,  Em.new
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Example < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          <<~TEMPLATE
+            [example]
+            ====
+            #{treat_children(node, state).strip}
+            ====
+          TEMPLATE
+        end
+      end
+      ReverseAsciidoctor::Converters.register :example, Example.new
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class ExpressRef < ReverseAsciidoctor::Converters::Base
+        def convert(node, _state = {})
+          "*#{node['linkend'].to_s.split('.').last}*"
+        end
+      end
+      ReverseAsciidoctor::Converters.register :express_ref, ExpressRef.new
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class ModuleRef < ReverseAsciidoctor::Converters::Base
+        def convert(node, _state = {})
+          ref = node['linkend']
+          # #23:
+          # In this case when we see this:
+
+          # <module_ref linkend="product_as_individual:3_definition">individual products</module_ref>
+          # We take the text value of the element and convert to this:
+
+          # term:[individual products]
+          if node['linkend'].split(':').length > 1
+            ref = node.text
+          end
+          " term:[#{normalized_ref(ref)}] "
+        end
+
+        private
+
+        def normalized_ref(ref)
+          return unless ref || ref.empty?
+
+          ref.squeeze(' ').strip
+        end
+      end
+      ReverseAsciidoctor::Converters.register :module_ref, ModuleRef.new
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Note < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          <<~TEMPLATE
+            [NOTE]
+            --
+            #{treat_children(node, state).strip}
+            --
+          TEMPLATE
+        end
+      end
+      ReverseAsciidoctor::Converters.register :note, Note.new
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Ol < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          id = node['id']
+          anchor = id ? "[[#{id}]]\n" : ""
+          ol_count = state.fetch(:ol_count, 0) + 1
+          attrs = ol_attrs(node)
+          res = "\n#{anchor}#{attrs}#{treat_children(node, state.merge(ol_count: ol_count))}"
+          res = "\n" + res if node.parent && node.parent.name == 'note'
+          res
+        end
+
+        def number_style(node)
+          style = case node["style"]
+                  when "1" then "arabic"
+                  when "A" then "upperalpha"
+                  when "a" then "loweralpha"
+                  when "I" then "upperroman"
+                  when "i" then "lowerroman"
+                  else
+                    nil
+                  end
+        end
+
+        def ol_attrs(node)
+          style = number_style(node)
+          reversed = "%reversed" if node["reversed"]
+          start = "start=#{node['start']}" if node["start"]
+          type = "type=#{node['type']}" if node["type"]
+          attrs = []
+          attrs << style if style
+          attrs << reversed if reversed
+          attrs << start if start
+          attrs << type if type
+          if attrs.empty?
+            ""
+          else
+            "[#{attrs.join(',')}]\n"
+          end
+        end
+      end
+
+      ReverseAsciidoctor::Converters.register :ol, Ol.new
+      ReverseAsciidoctor::Converters.register :ul, Ol.new
+      ReverseAsciidoctor::Converters.register :dir, Ol.new
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'stepmod/utils/converters/em'
+
+module Stepmod
+  module Utils
+    module Converters
+      class Stem < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          return Em.new.convert(node, state) if node.text.strip.length > 8
+
+          " stem:[#{node.text.strip}] "
+        end
+      end
+
+      ReverseAsciidoctor::Converters.register :i, Stem.new
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Synonym < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          "alt:[#{node.text.strip}]"
+        end
+      end
+
+      ReverseAsciidoctor::Converters.register :synonym, Synonym.new
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'stepmod/utils/converters/synonym'
+
+module Stepmod
+  module Utils
+    module Converters
+      class Term < ReverseAsciidoctor::Converters::Base
+        def convert(node, state = {})
+          first_child = node.children.find do |child|
+                          child.name == 'text' && !child.text.to_s.strip.empty?
+                        end
+          unless first_child &&
+                  node.text.split(';').length == 2 &&
+                  defined?(Stepmod::Utils::Converters::Synonym)
+            return "=== #{treat_children(node, state).strip}"
+          end
+
+          term_def, alt = node.text.split(';')
+          alt_xml = Nokogiri::XML::Text.new(alt, Nokogiri::XML::Document.new)
+          converted_alt = Stepmod::Utils::Converters::Synonym.new.convert(alt_xml)
+          "=== #{term_def}\n\n#{converted_alt}"
+        end
+      end
+
+      ReverseAsciidoctor::Converters.register :term, Term.new
+    end
+  end
+end

data/lib/stepmod/utils/stepmod_definition_converter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'reverse_asciidoctor'
+require 'stepmod/utils/converters/clause_ref'
+require 'stepmod/utils/converters/express_ref'
+require 'stepmod/utils/converters/module_ref'
+require 'stepmod/utils/converters/def'
+require 'stepmod/utils/converters/definition'
+require 'stepmod/utils/converters/em'
+require 'stepmod/utils/converters/example'
+require 'stepmod/utils/converters/note'
+require 'stepmod/utils/converters/ol'
+require 'stepmod/utils/converters/stem'
+require 'stepmod/utils/converters/term'
+require 'stepmod/utils/converters/synonym'
+
+require 'reverse_asciidoctor/converters/a'
+require 'reverse_asciidoctor/converters/blockquote'
+require 'reverse_asciidoctor/converters/bypass'
+require 'reverse_asciidoctor/converters/br'
+require 'reverse_asciidoctor/converters/code'
+require 'reverse_asciidoctor/converters/drop'
+require 'reverse_asciidoctor/converters/head'
+require 'reverse_asciidoctor/converters/hr'
+require 'reverse_asciidoctor/converters/ignore'
+require 'reverse_asciidoctor/converters/li'
+require 'reverse_asciidoctor/converters/p'
+require 'reverse_asciidoctor/converters/pass_through'
+require 'reverse_asciidoctor/converters/q'
+require 'reverse_asciidoctor/converters/strong'
+require 'reverse_asciidoctor/converters/sup'
+require 'reverse_asciidoctor/converters/sub'
+require 'reverse_asciidoctor/converters/text'
+
+
+module Stepmod
+  module Utils
+    class StepmodDefinitionConverter
+      def self.convert(input, options = {})
+        root = if input.is_a?(String)
+                  then Nokogiri::XML(input).root
+                elsif input.is_a?(Nokogiri::XML::Document)
+                  then input.root
+                elsif input.is_a?(Nokogiri::XML::Node)
+                  then input
+                end
+
+        root || (return '')
+
+        ReverseAsciidoctor.config.with(options) do
+          result = ReverseAsciidoctor::Converters.lookup(root.name).convert(root)
+          ReverseAsciidoctor.cleaner.tidy(result)
+        end
+      end
+    end
+  end
+end

data/lib/stepmod/utils/version.rb

@@ -1,5 +1,5 @@
 module Stepmod
   module Utils
-    VERSION = "0.1.0"
+    VERSION = "0.1.5"
   end
 end

data/resource_example.xml

@@ -0,0 +1,302 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- $Id: resource.xml,v 1.22 2009/11/02 11:00:33 lothartklein Exp $ -->
+<!DOCTYPE resource SYSTEM "../../../dtd/res_doc/resource.dtd">
+<!-- Generated by mkresource.js, Eurostep Limited, http://www.eurostep.com -->
+<!--
+     To view the resource in IExplorer, open: sys/1_scope.xml
+      -->
+<resource
+  name="classification_and_set_theory"
+  name.french="Classification et théorie des ensembles"
+  part="54"
+  version="1"
+  wg.number="3212"
+  wg.number.supersedes="1509"
+  wg.number.express="3213"
+  wg.number.express.supersedes="1510"
+  checklist.internal_review="3215"
+  checklist.project_leader="3216"
+  checklist.convener="3217"
+  sc4.working_group="12"
+  status="IS"
+  language="E"
+  publication.date="2005-03-15"
+  publication.year="2005"
+  published="n"
+  development.folder="dvlp"
+  rcs.date="$Date: 2009/11/02 11:00:33 $"
+  rcs.revision="$Revision: 1.22 $">
+
+  <keywords>
+    resource, STEP, 10303, integrated resources, set theory, class, classification, specialisation, subset, superset,
+    union, intersection, complement power set
+  </keywords>
+  <!-- the abstract for the resource. If not provided, the XSL will use the inscope -->
+  <abstract>
+    <p>ISO 10303-54 specifies:</p>
+    <ul>
+      <li>that an object is a member of a set, and can define a finite set by enumerating all its members;</li>
+      <li>that the relationship between two sets is proper subset, subset, or equal;</li>
+      <li>that a set is result of a union, intersection, complement or powerset operation.</li>
+    </ul>
+  </abstract>
+  <!-- the abstract for the resource. If not provided, the XSL will use the in scope
+ <abstract>
+   <li>a specification that an object is a member of a set;</li>
+   <li>a specification of all the members of a finite set;</li>
+   <li>a specification that one set is a proper subset of, is a
+   subset of, or is equal to another;</li>
+   <li>a specification that a set is result of a union,
+   intersection, complement or powerset operation.</li>
+ </abstract>
+ -->
+  <!-- Reference to contacts detailed in stepmod/data/basic/contacts.xml -->
+  <contacts>
+    <projlead ref="ap221.projlead" />
+    <editor ref="ap221.projeditor" />
+  </contacts>
+
+  <!-- Introduction -->
+  <!-- The introduction should start as shown: -->
+  <purpose>
+    <p>
+      This part of ISO 10303 specifies an application resource for the
+      representation of classes or sets and classification relationships. This part of ISO 10303 also supports the
+      following set theory relationships:</p>
+    <ul>
+      <li>complement;</li>
+      <li>intersection;</li>
+      <li>power set;</li>
+      <li>proper subset;</li>
+      <li>same membership (that is, set equality);</li>
+      <li>subset;</li>
+      <li>union.</li>
+    </ul>
+  </purpose>
+
+  <!-- Schema Interface express-g diagrams  -->
+  <!-- refer to p41ed2 as example  -->
+  <schema_diag>
+    <express-g>
+      <imgfile title="Relationship between schemas in ISO 10303-54" file="schema_diagexpg1.xml" />
+    </express-g>
+  </schema_diag>
+
+  <!-- Items in scope -->
+  <inscope>
+    <li>the existence of a class or set;</li>
+    <li>the distinction between a class or set that is defined by abstract criteria, and a class or set that is defined
+      by enumerating its members;</li>
+
+
+    <li>the classification relationship between a class or set and a member;</li>
+
+    <li>the complete enumeration of the members for a class or set;</li>
+    <li> the representation of set theory relationships between classes or sets;</li>
+
+    <li>the following set theory relationships:
+      <ul>
+        <li>complement;</li>
+        <li>equivalence;</li>
+        <li>intersection;</li>
+        <li>power set;</li>
+        <li>proper subset;</li>
+        <li>subset;</li>
+        <li>union.</li>
+      </ul>
+    </li>
+  </inscope>
+
+  <!-- Items out of scope -->
+  <outscope>
+    <li>mappings between sets or classes;</li>
+    <li>relationships that are not classification or set theory relationships; </li>
+    <li>entities and relationships specific to continuous sets.
+      <note number="1">
+        <p>All the entities and relationships within this part of ISO 10303 are equally valid for discrete and
+          continuous sets.</p>
+      </note>
+      <note number="2">
+        <p>Entities and relationships for continuous sets can be created in anntotated EXPRESS schemas that use or
+          specialize entities in this part of ISO 10303, as follows:</p>
+        <ul>
+          <li><b>discrete_class_by_intension</b> and <b>continuous_set</b> can be disjoint subtypes of
+            <express_ref linkend="classification_and_set_theory:ir:classification_schema.class_by_intension" />;</li>
+          <li><b>open_set</b> and <b>closed_set</b> can be disjoint subtypes of <b>continuous_set</b>;</li>
+          <li><b>closure</b> can be the relationship between an <b>open_set</b> and the <b>closed_set</b> that is its
+            <b>boundary</b>.</li>
+        </ul>
+      </note>
+    </li>
+  </outscope>
+
+  <normrefs>
+    <normref.inc normref="ref10303-41" />
+  </normrefs>
+
+  <definition>
+    <term id="set">set
+    </term>
+    <synonym>class</synonym>
+    <def>
+      <p>number of things considered together</p>
+      <note number="1"> A set that is defined by enumerating its members is a 'class by intension'.</note>
+      <note number="2">A set that is defined by means of criteria that do not enumerate the members is a 'class by
+        extension'.</note>
+    </def>
+  </definition>
+  <!--
+ <abbreviations/>
+-->
+
+  <schema name="classification_schema" version="1">
+    <!-- Note schema EXPRESS are in ..\resources\resource_name name_of_schema.xml -->
+    <introduction>The classification_schema specifies a class, and a classification relationship between a class and a
+      member of a class.
+    </introduction>
+    <fund_cons>
+      <p>For many different entity types defined within ISO 10303, an instance may stand for a class or set of things.
+        The fact that an instance stands for a class or set of things can be made explicit by creating a compound
+        instance of:</p>
+      <ul>
+        <li>the entity type class defined in this part of ISO 10303, and</li>
+        <li>
+          another entity type defined in ISO 10303. </li>
+      </ul>
+      <p>Members can be specified for an instance of the entity type class. An instance of the entity type class can be
+        involved in set theory relationships, such as union or intersection, with other instances of the entity type
+        class.</p>
+      <note>Instances of the entity types product, product_definition_formation and product_definition in ISO 10303-41
+        can be classes. In order to allow set theory relationships for these classes, an application protocol or
+        application module can define a subtype of:</note>
+      <ul>
+        <li>product_definition_formation (from ISO 10303-41);</li>
+        <li>class (from this part of ISO 10303).</li>
+      </ul>
+      <example number="1">
+        Pump model 'XYZ_123' is a product_definition_formation and a class. This class is a class_by_extension.
+      </example>
+
+      <example number="2">The set of pumps enumerated in maintenance contract '98/1234' is a class. This class is a
+        class_by_intension.</example>
+
+      <example number="3">The relationship between individual pump 'X/85/4567' and pump model 'XYZ_123', that indicates
+        the model of the pump, is a classification.</example>
+      <example number="4">The relationship between individual pump 'X/85/4567' and the set of pumps enumerated in
+        maintenance contract '98/1234', that indicates it is one of the set, is a classification. The complete set of
+        pumps covered by the contract can be defined by an instance of the entity type complete_membership.
+      </example>
+      <example number="5">The set of pumps that are both within maintenance contract '98/1234' and of pump model
+        'XYZ_123' can be defined by the set theory relationship intersection.</example>
+    </fund_cons>
+
+    <!-- EXPRESS-G -->
+    <express-g>
+      <imgfile file="classification_schemaexpg2.xml" />
+    </express-g>
+  </schema>
+  <schema name="set_theory_schema" version="1">
+    <!-- Note schema EXPRESS are in ..\resources\resource_name name_of_schema.xml -->
+    <introduction>The set_theory_schema specifies the following relationships between classes:
+      <ul>
+        <li>complement;</li>
+        <li>intersection;</li>
+        <li>power set;</li>
+        <li>proper subset;</li>
+        <li>same membership (that is, set equality);</li>
+        <li>subset;</li>
+        <li>union.</li>
+      </ul>
+    </introduction>
+    <fund_cons>
+      <p>The set theory schema defines set theory relationship between classes or sets.</p>
+
+      <note number="1">In this part of ISO 10303, the terms class and set are synonyms.</note>
+
+      <p>In order to use this schema the entity that records the class or set shall be
+        <express_ref linkend="classification_and_set_theory:ir:classification_schema.class" /> or a subtype of
+        <express_ref linkend="classification_and_set_theory:ir:classification_schema.class" />.</p>
+      <example number="1">
+        <p>Consider the following instances of
+          <express_ref linkend="classification_and_set_theory:ir:classification_schema.class" />:</p>
+        <ul>
+          <li>
+            pump model 'XYZ_123', which is a
+            <express_ref
+              linkend="product_definition_schema:ir_express:product_definition_schema.product_definition_formation" />
+
+            and a
+            <express_ref linkend="classification_and_set_theory:ir:classification_schema.class" />; and </li>
+          <li>
+            the set of pumps enumerated in maintenance contract '98/1234'.
+          </li>
+        </ul>
+        <p>An instance of the relationship
+          <express_ref linkend="classification_and_set_theory:ir:set_theory_schema.subset" />
+
+          indicates that each of the set of pumps enumerated in maintenance contract '98/1234' is of pump model
+          'XYZ_123'.
+        </p>
+      </example>
+
+      <example number="2">
+        <p>An organization has pumps of type A and type B. Some pumps handle radioactive fluids. There are the following
+          classes of activity:</p>
+        <ul>
+          <li>
+            SA - service pump type A;</li>
+          <li>
+            SB - service pump type B;</li>
+          <li>
+            DR - service equipment that has handled radioactive fluids.
+          </li>
+        </ul>
+        <p>For workflow management purposes, the following derived class of activity is defined:</p>
+        <ul>
+          <li>
+            DRS - service pump that has handled radioactive fluids.
+          </li>
+        </ul>
+        <p>This class is the
+          <express_ref linkend="classification_and_set_theory:ir:set_theory_schema.intersection" />
+
+          of class DR with the
+          <express_ref linkend="classification_and_set_theory:ir:set_theory_schema.union" />
+
+          of classes SA and SB.</p>
+      </example>
+    </fund_cons>
+
+    <!-- EXPRESS-G -->
+    <express-g>
+      <imgfile file="set_theory_schemaexpg2.xml" />
+    </express-g>
+  </schema>
+
+
+  <shortnames>
+    <shortname entity="class" name="CLASS" />
+    <shortname entity="class_by_extension" name="CLBYEX" />
+    <shortname entity="class_by_intension" name="CLBYIN" />
+    <shortname entity="classification" name="CLSSFC" />
+    <shortname entity="complete_membership" name="CMPMMB" />
+    <shortname entity="complete_membership_of_empty_set" name="CMOES" />
+    <shortname entity="complete_membership_of_non_empty_set" name="CMONES" />
+    <shortname entity="complement" name="CMPLMN" />
+    <shortname entity="intersection" name="INTRSC" />
+    <shortname entity="power_set" name="PWRST" />
+    <shortname entity="proper_subset" name="PRPSBS" />
+    <shortname entity="same_membership" name="SMMMB" />
+    <shortname entity="subset" name="SUBSET" />
+    <shortname entity="union" name="UNION" />
+    <shortname entity="union_of_all_members" name="UOAM" />
+  </shortnames>
+  <!--
+ <tech_discussion/>
+
+ <examples/>
+
+ <add_scope/>
+-->
+  <!-- <bibliography/> -->
+</resource>

data/stepmod-utils.gemspec

@@ -6,11 +6,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ribose Inc."]
   spec.email         = ["open.source@ribose.com"]
 
-  spec.summary       = "stepmod-utils converts NISO STS XML into Metanorma XML."
+  spec.summary       = "Stepmod-utils is a toolkit that works on STEPmod data."
   spec.description   = <<~DESCRIPTION
-    stepmod-utils converts NISO STS XML into Metanorma XML.
-    This gem is a wrapper around stepmod-utils.jar available from
-    https://github.com/metanorma/stepmod-utils, with versions matching the JAR file.
+    Stepmod-utils is a toolkit that works on STEPmod data.
   DESCRIPTION
 
   spec.homepage      = "https://github.com/metanorma/stepmod-utils"
@@ -31,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "thor", "~> 1.0"
+  spec.add_runtime_dependency "thor", ">= 0.20.3"
   spec.add_runtime_dependency "reverse_adoc", "~> 0.2"
+  spec.add_development_dependency "byebug", "~> 11.1"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: stepmod-utils
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-01 00:00:00.000000000 Z
+date: 2020-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 0.20.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 0.20.3
 - !ruby/object:Gem::Dependency
   name: reverse_adoc
   requirement: !ruby/object:Gem::Requirement
@@ -38,13 +38,27 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
-description: |
-  stepmod-utils converts NISO STS XML into Metanorma XML.
-  This gem is a wrapper around stepmod-utils.jar available from
-  https://github.com/metanorma/stepmod-utils, with versions matching the JAR file.
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.1'
+description: 'Stepmod-utils is a toolkit that works on STEPmod data.
+
+  '
 email:
 - open.source@ribose.com
-executables: []
+executables:
+- stepmod-extract-terms
 extensions: []
 extra_rdoc_files: []
 files:
@@ -60,8 +74,25 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- exe/stepmod-extract-terms
 - lib/stepmod/utils.rb
+- lib/stepmod/utils/bibdata.rb
+- lib/stepmod/utils/concept.rb
+- lib/stepmod/utils/converters/clause_ref.rb
+- lib/stepmod/utils/converters/def.rb
+- lib/stepmod/utils/converters/definition.rb
+- lib/stepmod/utils/converters/em.rb
+- lib/stepmod/utils/converters/example.rb
+- lib/stepmod/utils/converters/express_ref.rb
+- lib/stepmod/utils/converters/module_ref.rb
+- lib/stepmod/utils/converters/note.rb
+- lib/stepmod/utils/converters/ol.rb
+- lib/stepmod/utils/converters/stem.rb
+- lib/stepmod/utils/converters/synonym.rb
+- lib/stepmod/utils/converters/term.rb
+- lib/stepmod/utils/stepmod_definition_converter.rb
 - lib/stepmod/utils/version.rb
+- resource_example.xml
 - stepmod-utils.gemspec
 homepage: https://github.com/metanorma/stepmod-utils
 licenses:
@@ -85,5 +116,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: stepmod-utils converts NISO STS XML into Metanorma XML.
+summary: Stepmod-utils is a toolkit that works on STEPmod data.
 test_files: []