stepmod-utils 0.3.23 → 0.3.25

data/lib/stepmod/utils/changes_extractor.rb

@@ -0,0 +1,194 @@
+require "nokogiri"
+require "stepmod/utils/change_collection"
+require "stepmod/utils/smrl_description_converter"
+
+module Stepmod
+  module Utils
+    class ChangesExtractor
+      MODULE_TYPES = %w[arm mim arm_longform mim_longform].freeze
+
+      attr_accessor :stepmod_dir
+
+      def self.call(stepmod_dir:, stdout: $stdout)
+        new(stepmod_dir: stepmod_dir, stdout: stdout).call
+      end
+
+      def initialize(stepmod_dir:, stdout: $stdout)
+        @stdout = stdout
+        @stepmod_dir = stepmod_dir
+        @collection = Stepmod::Utils::ChangeCollection.new(
+          stepmod_dir: stepmod_dir,
+        )
+      end
+
+      def call
+        all_resource_changes_files.each do |resource_change_file|
+          xml_changes = Nokogiri::XML(File.read(resource_change_file)).root
+          add_resource_changes_to_collection(xml_changes, @collection)
+        end
+
+        all_modules_changes_files.each do |module_change_file|
+          xml_changes = Nokogiri::XML(File.read(module_change_file)).root
+          schema_name = Pathname.new(module_change_file).parent.basename.to_s
+          add_module_changes_to_collection(xml_changes, @collection, schema_name)
+        end
+
+        @collection
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def add_resource_changes_to_collection(xml_data, collection)
+        xml_data.xpath("//changes").each do |changes_node|
+          changes_node.xpath("change_edition").each do |change_edition_node|
+            options = {
+              version: change_edition_node.attr("version"),
+              description: Stepmod::Utils::SmrlDescriptionConverter.convert(
+                change_edition_node.at("description"),
+              ),
+            }
+
+            add_resource_changes(
+              collection,
+              change_edition_node,
+              options,
+            )
+          end
+        end
+      end
+
+      def add_module_changes_to_collection(xml_data, collection, schema_name)
+        xml_data.xpath("//changes").each do |changes_node|
+          changes_node.xpath("change").each do |change_node|
+            options = {
+              schema_name: schema_name,
+              version: change_node.attr("version"),
+              description: converted_description(change_node.at("description")),
+            }
+
+            MODULE_TYPES.each do |type|
+              add_module_changes(
+                collection,
+                change_node,
+                options,
+                type,
+              )
+            end
+          end
+        end
+      end
+
+      def add_resource_changes(collection, change_node, options)
+        change_node.xpath("schema.changes").each do |changes|
+          schema_name = correct_schema_name(changes.attr("schema_name"))
+          change = collection.fetch_or_initialize(schema_name, "schema")
+
+          change_edition = extract_change_edition(changes, options)
+          change.add_change_edition(change_edition)
+        end
+      end
+
+      def add_module_changes(collection, change_node, options, type)
+        options[:type] = type
+        # assuming there will only be one change related to a type in the
+        # same version.
+        changes = change_node.xpath("#{type}.changes").first
+        schema_name = options[:schema_name]
+        change = collection.fetch_or_initialize(schema_name, type)
+
+        change_edition = extract_change_edition(changes, options)
+        change.add_change_edition(change_edition)
+
+        if type == "arm"
+          add_mapping_changes(collection, change_node, options)
+        end
+      end
+
+      def add_mapping_changes(collection, change_node, options)
+        change_edition = collection
+                         .fetch_or_initialize(options[:schema_name], "arm")
+                         .change_editions
+                         .fetch_or_initialize(options[:version])
+
+        change_edition.mapping = extract_mapping_changes(change_node)
+      end
+
+      def extract_mapping_changes(change_node)
+        mappings = []
+
+        change_node.xpath("mapping.changes").each do |changes|
+          changes.xpath("mapping.change").each do |change|
+            mappings << { "change" => change.text }
+          end
+
+          changes.xpath("description").each do |change|
+            mappings << { "description" => change.text }
+          end
+        end
+
+        mappings
+      end
+
+      def extract_change_edition(schema_changes, options)
+        type = options[:type] || "schema"
+        addition_nodes = schema_changes&.xpath("#{type}.additions") || []
+        modification_nodes = schema_changes&.xpath("#{type}.modifications") || []
+        deletion_nodes = schema_changes&.xpath("#{type}.deletions") || []
+
+        {
+          version: options[:version],
+          description: options[:description],
+          additions: extract_modified_objects(addition_nodes),
+          modifications: extract_modified_objects(modification_nodes),
+          deletions: extract_modified_objects(deletion_nodes),
+        }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def extract_modified_objects(nodes)
+        nodes.map do |node|
+          node.xpath("modified.object").map do |object|
+            {
+              type: object.attr("type"),
+              name: object.attr("name"),
+              description: converted_description(object.at("description")),
+              interfaced_items: object.attr("interfaced.items"),
+            }.compact
+          end
+        end.flatten
+      end
+
+      def converted_description(description)
+        return if description.to_s.empty?
+
+        Stepmod::Utils::SmrlDescriptionConverter.convert(description)
+      end
+
+      def all_resource_changes_files
+        Dir.glob(
+          File.join(stepmod_dir, "data", "resource_docs", "*", "resource.xml"),
+        )
+      end
+
+      def all_modules_changes_files
+        Dir.glob(
+          File.join(stepmod_dir, "data", "modules", "*", "module.xml"),
+        )
+      end
+
+      # rubocop:disable Layout/LineLength
+      def correct_schema_name(schema_name)
+        schema_name_corrector = {
+          "material_property_definition" => "material_property_definition_schema",
+          "qualified_measure" => "qualified_measure_schema",
+          "material_property_representation" => "material_property_representation_schema",
+          "annotated_3d_model_data_quality_criteria" => "annotated_3d_model_data_quality_criteria_schema",
+        }
+
+        schema_name_corrector[schema_name] || schema_name
+      end
+      # rubocop:enable Layout/LineLength
+    end
+  end
+end

data/lib/stepmod/utils/concept.rb

@@ -8,6 +8,10 @@ module Stepmod
         reference_anchor
         converted_definition
         file_path
+        schema
+        part
+        domain
+        document
       )
 
       # TODO: converted_definition is not supposed to be an attribute, it is
@@ -40,8 +44,8 @@ module Stepmod
           # TODO: `designations:` should include the `alt:[...]` terms here,
           # they are now only included in definition_xml_converted_definition.
           new(
-            designations: [designation],
-            definition: definition,
+            designations: designation,
+            definition: [definition],
             converted_definition: converted_definition,
             id: "#{reference_anchor}.#{reference_clause}",
             reference_anchor: reference_anchor,
@@ -65,11 +69,16 @@ module Stepmod
               definition_xml.xpath(".//term").first
             )
 
-          {
-            # [4..-1] because we want to skip the initial `=== {title}`
-            accepted: term[4..-1],
-            alt: alts,
-          }
+          # [4..-1] because we want to skip the initial `=== {title}`
+          designations = [
+            { "designation" => term[4..-1], "type" => "expression", "normative_status" => "preferred" },
+          ]
+
+          alts.each do |alt|
+            designations << { "designation" => alt, "type" => "expression" }
+          end
+
+          designations
         end
 
         def definition_xml_definition(definition_xml, reference_anchor)
@@ -95,12 +104,24 @@ module Stepmod
         end
 
         def definition_xml_converted_definition(designation, definition)
-          if designation[:alt].length.positive?
-            alt_notation = "alt:[#{designation[:alt].map(&:strip).join(',')}]"
+          accepted_designation = designation.select do |des|
+            des["normative_status"] == "preferred"
+          end
+
+          alt_designations = designation.reject do |des|
+            des["normative_status"] == "preferred"
+          end
+
+          if alt_designations.length.positive?
+            alt_designations_text = alt_designations.map do |d|
+              d["designation"].strip
+            end.join(",")
+
+            alt_notation = "alt:[#{alt_designations_text}]"
           end
 
           result = <<~TEXT
-            === #{designation[:accepted].strip}
+            === #{accepted_designation.map { |d| d['designation'].strip }.join(',')}
           TEXT
 
           if alt_notation
@@ -117,6 +138,15 @@ module Stepmod
         end
       end
 
+      def to_h
+        super.merge({
+          "domain" => domain,
+          "part" => part,
+          "schema" => schema,
+          "document" => document,
+        }.compact)
+      end
+
       def to_mn_adoc
         <<~TEXT
           // STEPmod path:#{file_path.empty? ? '' : " #{file_path}"}

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Stepmod
+  module Utils
+    module Converters
+      class Description < ReverseAdoc::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
+
+      ReverseAdoc::Converters.register :description, Description.new
+    end
+  end
+end

data/lib/stepmod/utils/express_bibdata.rb

@@ -0,0 +1,111 @@
+module Stepmod
+  module Utils
+    class ExpressBibdata
+      DOCNUMBER = 10303
+
+      attr_accessor *%w(
+        type doctype part title_en version pub_year pubid published_info number
+      )
+
+      def initialize(schema:)
+        # module, resource, application_protocol, business_object_model
+        # @type = document.name
+
+        # raise "UnknownFileError" unless %w(module resource
+        #                                    application_protocol business_object_model).include?(@type)
+
+        @published_info = schema.find("__published_in")&.remarks&.first
+        @number = schema.find("__identifier")&.remarks&.first&.split("N")&.last
+        @schema = schema
+
+        if !published_info.nil?
+          @pubid = Pubid::Iso::Identifier.parse(published_info)
+
+          @part = pubid.part
+          @version = pubid.edition
+          @pub_year = pubid.year
+        elsif !schema.version.nil?
+          @part = schema.version.items.find { |i| i.name == "part" }.value
+          @version = schema.version.items.find { |i| i.name == "part" }.value
+          @pub_year = schema.version.items.find { |i| i.name == "part" }.value
+        else
+          raise "PublishedInfoNotFound"
+        end
+
+        @doctype = schema.find("__status")&.remarks&.first
+        self
+      end
+
+      def title_en
+        @title_en ||= @schema.find("__title")
+                             .remarks
+                             .first
+                             .gsub("_", " ")
+                             .capitalize
+                             .gsub("2d", "2D")
+                             .gsub("3d", "3D")
+      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 "FDIS"
+                    "ISO/FDIS #{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/smrl_description_converter.rb

@@ -6,6 +6,7 @@ require "stepmod/utils/converters/blockquote"
 require "stepmod/utils/converters/br"
 require "stepmod/utils/converters/bypass"
 require "stepmod/utils/converters/code"
+require "stepmod/utils/converters/description"
 require "stepmod/utils/converters/drop"
 require "stepmod/utils/converters/em_express_description"
 require "stepmod/utils/converters/example"