pubid-iso 0.7.8 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d045ee4a48735ea6db01b791fdbf1f06da853514c74b8e728517ae5737a8dad5
-  data.tar.gz: 71b30a3fdccd9f84588ce4a8f961636cee66a720530c8f8c83b4664e6969ae85
+  metadata.gz: 51ff5f4411528d056d31e56420d5c9f34b8e896e7f29e587641e495042a81322
+  data.tar.gz: 9818b9a1c8be3b1c390bca461295e6058ebac2102a9bb0112b694b76cf1df1d8
 SHA512:
-  metadata.gz: 3d4e8b0e8d63a3458eb42fefc89ffb7c2d499a2243511b91e70cc22d152bef69c748fd830f50e560fe44ce15abb2d5151d4392e7389144ac0227bb629b7fe1fc
-  data.tar.gz: f76e1de17c0d4bf3ae302d0f5d3b9e129e32d9b7531fb6877f39b7d4e46cbd06629eaef094b9189f62e79d33d83ac86d9708c583a4f57b020d18df65365ccc7b
+  metadata.gz: 45eadb0c1cf4394f171b9a6e32e1895df9ce7e20085882521fa5c84c6e89dceb971f2abf55851eb9a4453a38926f1eddd468a383f75d0138fe2bc5bce8c2956d
+  data.tar.gz: 83546bfa875b22228644c7ae30e24fa798748dee012f48e0dd03f47d2b8c02b43081a673ca46423cf5c43197bed0a344bcbee0f66a54c9eda6dfd95d0cba11f9

data/README.adoc

@@ -154,11 +154,11 @@ to see all available options.
   language: "en"
 )
 > pubid = Pubid::Iso::Identifier.create(type: :amd, number: "1", year: "2021", stage: "DAM", base: base)
-> pubid.to_s(:ref_num_short)
+> pubid.to_s(format: :ref_num_short)
 => "ISO 8601-1:2019/DAM 1:2021(E)"
-> pubid.to_s(:ref_dated)
+> pubid.to_s(format: :ref_dated)
 => "ISO 8601-1:2019/DAM 1:2021"
-> pubid.to_s(:ref_undated)
+> pubid.to_s(format: :ref_undated)
 => "ISO 8601-1:2019/DAM 1"
 ----
 

data/lib/pubid/iso/identifier/amendment.rb

@@ -4,7 +4,7 @@ require_relative "../renderer/urn-amendment"
 module Pubid::Iso
   module Identifier
     class Amendment < Supplement
-      def_delegators 'Pubid::Iso::Identifier::Amendment', :type
+      def_delegators "Pubid::Iso::Identifier::Amendment", :type
 
       TYPED_STAGES = {
         damd: {

data/lib/pubid/iso/identifier/base.rb

@@ -1,4 +1,4 @@
-require 'forwardable'
+require "forwardable"
 require_relative "../renderer/urn"
 require_relative "../renderer/urn-tc"
 
@@ -114,46 +114,55 @@ module Pubid::Iso
           supplements.select { |supplement| supplement.type[:key] == type }.first
         end
 
-        def transform_supplements(supplements_params, base_params)
-          supplements = supplements_params.map do |supplement|
-            Identifier.create(number: supplement[:number], year: supplement[:year],
-                month: supplement[:month],
-                stage: supplement[:typed_stage], edition: supplement[:edition],
-                iteration: supplement[:iteration], type: (supplement[:type] || !supplement[:typed_stage] && :sup),
-                publisher: supplement[:publisher], base: Identifier.create(**base_params))
-          end
+        def transform_supplements(supplements_params, base_params) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          all_parts = base_params.delete(:all_parts)
 
-          return supplements.first if supplements.count == 1
+          supplements = create_supplements supplements_params, base_params
 
+          if supplements.count == 1
+            supplement = supplements.first
           # update corrigendum base to amendment
-          if supplements_has_type?(supplements, :cor) &&
+          elsif supplements_has_type?(supplements, :cor) &&
               (supplements_has_type?(supplements, :amd) ||
                 supplements_has_type?(supplements, :sup)) && supplements.count == 2
 
             supplement = supplement_by_type(supplements, :cor)
-            supplement.base = supplement_by_type(supplements, :amd) ||
-              supplement_by_type(supplements, :sup)
-            supplement
+            supplement.base = supplement_by_type(supplements, :amd) || supplement_by_type(supplements, :sup)
           else
             raise Errors::SupplementRenderingError, "don't know how to render provided supplements"
           end
+
+          supplement.all_parts = all_parts if all_parts
+          supplement
+        end
+
+        def create_supplements(params, base_params)
+          params.map do |supplement|
+            Identifier.create(
+              number: supplement[:number], year: supplement[:year],
+              month: supplement[:month],
+              stage: supplement[:typed_stage], edition: supplement[:edition],
+              iteration: supplement[:iteration], type: supplement[:type] || !supplement[:typed_stage] && :sup,
+              publisher: supplement[:publisher], base: Identifier.create(**base_params)
+            )
+          end
         end
 
-        def transform(params)
-          identifier_params = params.map do |k, v|
-            get_transformer_class.new.apply(k => v)
-          end.inject({}, :merge)
+        def transform(params) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          transformer = get_transformer_class.new
+          params = transformer.apply(root: params)
+          identifier_params = params.map { |k, v| transformer.apply(k => v) }.inject({}, :merge)
 
           # return supplement if supplements applied
-          if identifier_params[:supplements] && identifier_params[:supplements].is_a?(Array)
+          if identifier_params[:supplements].is_a?(Array)
             return transform_supplements(
               identifier_params[:supplements],
-              identifier_params.dup.tap { |h| h.delete(:supplements) }
+              identifier_params.dup.tap { |h| h.delete(:supplements) },
             )
           end
 
           if identifier_params[:extract]
-            base_parameters = params.reject { |k, _| k == :extract }
+            base_parameters = identifier_params.reject { |k, _| k == :extract }
 
             return Identifier.create(base: Identifier.create(**base_parameters),
                                      type: :ext, **identifier_params[:extract])
@@ -256,24 +265,26 @@ module Pubid::Iso
       #   :ref_undated -- reference undated: no language code + short form (DAM) + undated
       #   :ref_undated_long -- reference undated long: 1 letter language code + long form (DAmd) + undated
       # @return [String] pubid identifier
-      def to_s(lang: nil, with_edition: false, with_prf: false,
-               format: :ref_dated_long)
-
+      def to_s(lang: nil, with_edition: false, with_prf: false, format: :ref_dated_long)
         options = resolve_format(format)
         options[:with_edition] = with_edition
         options[:with_prf] = with_prf
         options[:language] = lang
 
         self.class.get_renderer_class.new(to_h(deep: false)).render(**options) +
-          if @joint_document
-            render_joint_document(@joint_document)
-          end.to_s
+          render_joint_document(@joint_document) + render_all_parts
       end
 
       def render_joint_document(joint_document)
+        return "" if joint_document.nil? || joint_document.to_s.empty?
+
         "|#{@joint_document}"
       end
 
+      def render_all_parts
+        all_parts ? " (all parts)" : ""
+      end
+
       # Return typed stage abbreviation, eg. "FDTR", "DIS", "TR"
       # returns root identifier
       def root

data/lib/pubid/iso/identifier/international_standard.rb

@@ -19,10 +19,29 @@ module Pubid::Iso
           name: "Final Draft International Standard",
           harmonized_stages: %w[50.00 50.20 50.60 50.92 50.98 50.99],
         },
+        wdr: {
+          abbr: "WDR",
+          name: "Proposed for Withdrawal",
+          harmonized_stages: %w[90.92],
+        },
+        wda: {
+          abbr: "WDA",
+          name: "Withdrawal Approved",
+          harmonized_stages: %w[90.93],
+        },
+        wdar: {
+          abbr: "WDAR",
+          name: "Withdrawal Archived",
+          harmonized_stages: %w[95.99],
+        },
+        is: {
+          abbr: "IS",
+          name: "International Standard",
+          harmonized_stages: %w[60.00 60.60],
+        },
       }.freeze
 
       def initialize(stage: nil, iteration: nil, **opts)
-
         if iteration && stage.nil?
           raise Errors::IsStageIterationError, "IS stage document cannot have iteration"
         end

data/lib/pubid/iso/identifier/supplement.rb

@@ -4,7 +4,7 @@ require_relative "../renderer/urn-supplement"
 module Pubid::Iso
   module Identifier
     class Supplement < Base
-      def_delegators 'Pubid::Iso::Identifier::Supplement', :type
+      def_delegators "Pubid::Iso::Identifier::Supplement", :type
 
       TYPED_STAGES = {
         dsuppl: {

data/lib/pubid/iso/parser.rb

@@ -1,8 +1,11 @@
 require_relative "identifier/base"
 require_relative "renderer/base"
+require_relative "parser_urn"
 
 module Pubid::Iso
   class Parser < Pubid::Core::Parser
+    include Pubid::Iso::ParserUrn
+
     STAGES = %w[NP NWIP WD CD FCD PRF AWI PWI FPD].freeze
     TYPES = %w[DATA ISP IWA R TTA TS TR IS PAS Guide GUIDE DIR].freeze
     # TYPED_STAGES = %w[DIS FDIS DPAS FDTR FDTS DTS DTR PDTR PDTS].freeze
@@ -118,7 +121,7 @@ module Pubid::Iso
     rule(:supplement) do
       ((str("/") | space).maybe >>
         (((stage.as(:typed_stage) >> space).maybe >> supplements.as(:type)) |
-          (staged_supplement).as(:typed_stage)) >>
+          staged_supplement.as(:typed_stage)) >>
         (space | str(".")).repeat(1).maybe >>
         digits.as(:number).maybe >>
         (str(".") >> digits.as(:iteration)).maybe >>
@@ -129,7 +132,7 @@ module Pubid::Iso
       (
         (((str("/") >> (str("Add") | str("ADD")).as(:type)) | (str(" — ") >> str("Addendum").as(:type))) |
          (str("/") >> staged_addenda.as(:typed_stage))) >>
-          space >> digits.as(:number) >> ((str(":")) >> digits.as(:year)).maybe
+          space >> digits.as(:number) >> (str(":") >> digits.as(:year)).maybe
       ).repeat(1).as(:supplements)
     end
 
@@ -166,6 +169,10 @@ module Pubid::Iso
       space >> (str("Edition") | str("Ed")) >> space >> digits.as(:edition)
     end
 
+    rule(:all_parts) do
+      space >> str("(all parts)").as(:all_parts)
+    end
+
     rule(:dir_document_body) do
       ((str("DIR") | str("Directives Part") | str("Directives, Part") | str("Directives,")).as(:type) >> space).maybe >>
         (str("JTC").as(:dirtype) >> space).maybe >>
@@ -177,7 +184,6 @@ module Pubid::Iso
           dir_supplement_edition.maybe).repeat(1).as(:supplements)).maybe >>
           # parse identifiers with publisher at the end, e.g. "ISO/IEC DIR 2 ISO"
           (space >> organization.as(:publisher) >> (str(":") >> year).maybe).as(:edition).maybe
-
     end
 
     rule(:std_document_body) do
@@ -189,11 +195,13 @@ module Pubid::Iso
         (str("|") >> (str("IDF").as(:publisher) >> space >> digits.as(:number)).as(:joint_document)).maybe >>
         part.maybe >> iteration.maybe >>
         (space? >> (str(":") | dash) >> year).maybe >>
+        edition.maybe >>
         supplement.maybe >>
         extract.maybe >>
         addendum.maybe >>
         edition.maybe >>
-        language.maybe
+        language.maybe >>
+        all_parts.maybe
     end
 
     rule(:identifier) do
@@ -209,6 +217,6 @@ module Pubid::Iso
           (str(" + ") >> (originator >> space >> dir_document_body).as(:dir_joint_document)).maybe))
     end
 
-    rule(:root) { identifier }
+    rule(:root) { identifier | urn_identifier }
   end
 end

data/lib/pubid/iso/parser_urn.rb

@@ -0,0 +1,88 @@
+module Pubid
+  module Iso
+    module ParserUrn
+      LANGUAGES = %w[en fr ru other].freeze
+      SUPPLEMENTS = %w[amd cor sup].freeze
+
+      def self.included(base) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        base.class_eval do # rubocop:disable Metrics/BlockLength
+          rule(:colon) { str(":") }
+
+          rule(:urn_organization) do
+            array_to_str(Parser::ORGANIZATIONS.map(&:downcase))
+          end
+
+          rule(:urn_publisher_copublisher) do
+            urn_organization.as(:publisher) >> (dash >> urn_organization.as(:copublisher)).repeat >> colon
+          end
+
+          rule(:urn_type) do
+            (array_to_str(Parser::TYPES.map(&:downcase)).as(:type) >> colon).maybe
+          end
+
+          rule(:urn_part) { (colon >> part).maybe }
+
+          rule(:urn_iteration) do
+            (str(".v") >> digits.as(:iteration)).maybe
+          end
+
+          rule(:stage_digits) do
+            match('\d').repeat(2, 2) >> str(".") >> match('\d').repeat(2, 2)
+          end
+
+          rule(:urn_stage_prefix) do
+            colon >> str("stage-")
+          end
+
+          rule(:urn_draft) do
+            str("draft") | str("published") | stage_digits
+          end
+
+          rule(:urn_stage) do
+            (urn_stage_prefix >> urn_draft.as(:stage) >> urn_iteration).maybe
+          end
+
+          rule(:urn_edition) do
+            (colon >> (str("ed-") >> digits.as(:edition))).maybe
+          end
+
+          rule(:urn_typed_stage) do
+            (urn_stage_prefix >> urn_draft.as(:typed_stage)).maybe
+          end
+
+          rule(:urn_supplement) do
+            (urn_typed_stage >>
+              colon >> (array_to_str(SUPPLEMENTS).as(:type) >>
+              (colon >> year_digits.as(:year)).maybe >>
+              (colon >> ((digits.as(:number) >> str(":v1")) | str("v") >> digits.as(:number))).maybe)
+            ).repeat(1).as(:supplements).maybe
+          end
+
+          rule(:urn_extract) do
+            ((urn_stage_prefix >> urn_draft).maybe >>
+              colon >> str("ext") >> colon >> year_digits.as(:year) >>
+              (colon >> str("v") >> digits.as(:number))).as(:extract).maybe
+          end
+
+          rule(:languages) do
+            array_to_str(LANGUAGES)
+          end
+
+          rule(:urn_language) do
+            (colon >> (languages >> (str(",") >> languages).repeat).as(:language)).maybe
+          end
+
+          rule(:urn_all_parts) do
+            (colon >> str("ser").as(:all_parts)).maybe
+          end
+
+          rule(:urn_identifier) do
+            str("urn:iso:std:") >> urn_publisher_copublisher >> urn_type >>
+              digits.as(:number) >> urn_part >> urn_stage >> urn_edition >>
+              urn_supplement >> urn_extract >> urn_language >> urn_all_parts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iso/renderer/base.rb

@@ -39,10 +39,9 @@ module Pubid::Iso::Renderer
         @prerendered_params[:language].to_s
     end
 
-    def render_base(_base, _opts, _params)
-    end
+    def render_base(_base, _opts, _params); end
 
-    def render_type_prefix(params, opts)
+    def render_type_prefix(params, opts) # rubocop:disable Metrics/AbcSize
       result = params[:stage].nil? || !params[:stage].is_a?(Pubid::Core::TypedStage) ? self.class::TYPE : ""
 
       if params[:stage] != "" && !params[:stage].to_s(with_prf: opts[:with_prf]).empty? && !result.empty?
@@ -54,10 +53,12 @@ module Pubid::Iso::Renderer
 
     def render_identifier(params, opts)
       stage = params.key?(:stage) ? postrender_stage(params[:stage], opts, params) : ""
-      "%{publisher}#{stage}#{render_type_prefix(params, opts)} %{number}%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{addendum}%{edition}" % params
+      type = render_type_prefix(params, opts)
+      "%<publisher>s#{stage}#{type} %<number>s%<part>s%<iteration>s%<year>s%" \
+      "<amendments>s%<corrigendums>s%<addendum>s%<edition>s" % params
     end
 
-    def render_copublisher_string(publisher, copublishers, opts)
+    def render_copublisher_string(publisher, copublishers, opts) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       case copublishers
       when String
         if opts[:language]
@@ -83,8 +84,7 @@ module Pubid::Iso::Renderer
       (stage.nil? || stage.empty_abbr?(with_prf: opts[:with_prf])) && typed_stage.nil?
     end
 
-    def render_publisher(publisher, opts, params)
-
+    def render_publisher(publisher, opts, params) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
       if opts[:language]
         publisher = TRANSLATION[opts[:language]][:publisher][publisher] || publisher
       end
@@ -113,7 +113,7 @@ module Pubid::Iso::Renderer
 
       # With copublisher but not IS
       # ISO/IEC TR xxx
-      publisher_string + " "
+      "#{publisher_string} "
     end
 
     def render_typed_stage(typed_stage, opts, params)
@@ -130,12 +130,12 @@ module Pubid::Iso::Renderer
       stage
     end
 
-    def postrender_stage(stage, opts, params)
+    def postrender_stage(stage, opts, _params)
       return if stage.empty_abbr?(with_prf: opts[:with_prf])
 
       if opts[:language]
         return TRANSLATION[opts[:language]][:stage][stage.to_s(with_prf: opts[:with_prf])] ||
-          stage.to_s(with_prf: opts[:with_prf])
+            stage.to_s(with_prf: opts[:with_prf])
       end
 
       stage.to_s(with_prf: opts[:with_prf])
@@ -151,15 +151,17 @@ module Pubid::Iso::Renderer
 
     def render_language(language, opts, _params)
       return if opts[:with_language_code] == :none
+
       super
     end
 
     def render_year(year, opts, params)
       return ":#{year}" if params[:amendments] || params[:corrigendums]
+
       opts[:with_date] && ":#{year}" || ""
     end
 
-    def render_part(part, opts, _params)
+    def render_part(part, _opts, _params)
       "-#{part}"
     end
 

data/lib/pubid/iso/renderer/supplement.rb

@@ -7,7 +7,7 @@ module Pubid::Iso::Renderer
     # Render identifier
     # @param with_edition [Boolean] include edition in output
     # @see Pubid::Core::Renderer::Base for another options
-    def render(with_edition: true, with_language_code: :iso, with_date: true, **args)
+    def render(with_edition: true, with_language_code: :iso, with_date: true, **args) # rubocop:disable Metrics/MethodLength
       @params[:base].to_s(lang: args[:language], with_edition: with_edition) +
         super(
           with_edition: with_edition, with_language_code: with_language_code, with_date: with_date,
@@ -22,7 +22,7 @@ module Pubid::Iso::Renderer
         end
     end
 
-    def render_identifier(params, opts)
+    def render_identifier(params, opts) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       type_prefix = params[:stage].nil? || !params[:stage].is_a?(Pubid::Core::TypedStage) ? self.class::TYPE : ""
 
       stage = params[:stage]
@@ -32,14 +32,14 @@ module Pubid::Iso::Renderer
         stage = params[:stage].to_s(with_prf: opts[:with_prf])
       end
 
-      if self.class == Supplement
+      if instance_of?(Supplement)
         if opts[:base_type] == :dir
-          "%{stage}%{publisher} SUP%{number}%{part}%{iteration}%{year}%{month}%{edition}" % params
+          "%<stage>s%<publisher>s SUP%<number>s%<part>s%<iteration>s%<year>s%<month>s%<edition>s" % params
         else
-          "/#{stage}#{type_prefix}%{number}%{part}%{iteration}%{year}%{edition}" % params
+          "/#{stage}#{type_prefix}%<number>s%<part>s%<iteration>s%<year>s%<edition>s" % params
         end
       else
-        "/#{stage}#{type_prefix}%{number}%{part}%{iteration}%{year}%{edition}" % params
+        "/#{stage}#{type_prefix}%<number>s%<part>s%<iteration>s%<year>s%<edition>s" % params
       end
     end
 

data/lib/pubid/iso/renderer/urn-amendment.rb

@@ -5,8 +5,8 @@ module Pubid::Iso::Renderer
     TYPE = "amd".freeze
 
     def render_identifier(params)
-      "%{base}%{stage}:amd%{year}%{number}%{edition}" \
-      "#{@params[:base].language ? (':' + @params[:base].language) : ''}" % params
+      "%<base>s%<stage>s:amd%<year>s%<number>s%<edition>s" \
+      "#{@params[:base].language ? ":#{@params[:base].language}" : ''}%<all_parts>s" % params
     end
   end
 end

data/lib/pubid/iso/renderer/urn-corrigendum.rb

@@ -5,8 +5,8 @@ module Pubid::Iso::Renderer
     TYPE = "cor".freeze
 
     def render_identifier(params)
-      "%{base}%{stage}:cor%{year}%{number}%{edition}" \
-      "#{@params[:base].language ? (':' + @params[:base].language) : ''}" % params
+      "%<base>s%<stage>s:cor%<year>s%<number>s%<edition>s" \
+      "#{@params[:base].language ? ":#{@params[:base].language}" : ''}%<all_parts>s" % params
     end
   end
 end

data/lib/pubid/iso/renderer/urn-dir.rb

@@ -2,23 +2,22 @@ require_relative "urn"
 
 module Pubid::Iso::Renderer
   class UrnDir < Urn
-
-    def render_identifier(params)
-      res = ("urn:iso:doc:%{publisher}%{copublisher}:dir%{dirtype}%{number}%{year}%{supplement}" % params)
+    def render_identifier(params) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      res = ("urn:iso:doc:%<publisher>s%<copublisher>s:dir%<dirtype>s%<number>s%<year>s%<supplement>s" % params)
 
       if params.key?(:joint_document)
         if params[:joint_document].is_a?(Pubid::Iso::Identifier::Supplement)
           joint_params = params[:joint_document].to_h(deep: false)
-          res += ":#{joint_params[:base].publisher.downcase}:sup:%{year}" % joint_params
+          res += ":#{joint_params[:base].publisher.downcase}:sup:%<year>s" % joint_params
         else
           joint_params = prerender_params(params[:joint_document].to_h(deep: false), {})
           joint_params.default = ""
-          res += (":%{publisher}%{copublisher}%{dirtype}%{number}%{supplement}" % joint_params)
+          res += (":%<publisher>s%<copublisher>s%<dirtype>s%<number>s%<supplement>s" % joint_params)
         end
 
       end
 
-      res
+      res + params[:all_parts]
     end
 
     def render_number(number, _opts, _params)
@@ -29,7 +28,7 @@ module Pubid::Iso::Renderer
       ":#{dirtype.downcase}"
     end
 
-    def render_supplement(supplement, _opts, _params)
+    def render_supplement(supplement, _opts, _params) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       if supplement.publisher && supplement.publisher != ""
         ":sup:#{supplement.publisher.downcase}"
       else

data/lib/pubid/iso/renderer/urn-extract.rb

@@ -3,8 +3,8 @@ require_relative "urn"
 module Pubid::Iso::Renderer
   class UrnExtract < Urn
     def render_identifier(params)
-      "%{base}%{stage}:ext%{year}%{number}%{edition}" \
-        "#{@params[:base].language ? (':' + @params[:base].language) : ''}" % params
+      "%<base>s%<stage>s:ext%<year>s%<number>s%<edition>s" \
+        "#{@params[:base].language ? ":#{@params[:base].language}" : ''}%<all_parts>s" % params
     end
 
     def render_base(base, _opts, _params)

data/lib/pubid/iso/renderer/urn-supplement.rb

@@ -5,8 +5,8 @@ module Pubid::Iso::Renderer
     TYPE = "sup".freeze
 
     def render_identifier(params)
-      "%{base}%{stage}:#{self.class::TYPE}%{publisher}%{year}%{number}%{edition}" \
-      "#{@params[:base].language ? (':' + @params[:base].language) : ''}" % params
+      "%<base>s%<stage>s:#{self.class::TYPE}%<publisher>s%<year>s%<number>s%<edition>s" \
+      "#{@params[:base].language ? ":#{@params[:base].language}" : ''}%<all_parts>s" % params
     end
 
     def render_base(base, _opts, _params)

data/lib/pubid/iso/renderer/urn-tc.rb

@@ -2,9 +2,9 @@ require_relative "urn"
 
 module Pubid::Iso::Renderer
   class UrnTc < Urn
-
     def render_identifier(params)
-      "urn:iso:doc:%{publisher}%{copublisher}:%{tctype}:%{tcnumber}%{sctype}%{wgtype}:%{number}" % params
+      "urn:iso:doc:%<publisher>s%<copublisher>s:%<tctype>s:%<tcnumber>s" \
+      "%<sctype>s%<wgtype>s:%<number>s%<all_parts>s" % params
     end
 
     def render_tctype(tctype, _opts, _params)

data/lib/pubid/iso/renderer/urn.rb

@@ -26,12 +26,12 @@ module Pubid::Iso::Renderer
     end
 
     def render_prefix(params)
-      "urn:iso:std:%{publisher}%{copublisher}%{type}:%{number}%{part}" % params
+      "urn:iso:std:%<publisher>s%<copublisher>s%<type>s:%<number>s%<part>s" % params
     end
 
     def render_identifier(params)
-      render_prefix(params) + "%{stage}"\
-      "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}" % params
+      render_prefix(params) + "%<stage>s%<corrigendum_stage>s%<iteration>s" \
+      "%<edition>s%<amendments>s%<corrigendums>s%<all_parts>s" % params
     end
 
     # def render_typed_stage(typed_stage, _opts, _params)
@@ -59,5 +59,9 @@ module Pubid::Iso::Renderer
 
       ":-#{part}"
     end
+
+    def render_all_parts(value, _opts, _params)
+      ":ser" if value == true
+    end
   end
 end

data/lib/pubid/iso/transformer.rb

@@ -3,6 +3,13 @@ require_relative "renderer/base"
 
 module Pubid::Iso
   class Transformer < Pubid::Core::Transformer
+    rule(root: subtree(:root)) do |context|
+      if context[:root][:stage] == "draft"
+        context[:root][:stage] = convert_urn_stage context[:root][:type]
+      end
+      context[:root]
+    end
+
     rule(edition: "Ed") do
       { edition: "1" }
     end
@@ -14,27 +21,25 @@ module Pubid::Iso
       context
     end
 
-    rule(supplements: subtree(:supplements)) do |context|
+    rule(supplements: subtree(:supplements)) do |context| # rubocop:disable Metrics/BlockLength
       if context[:supplements].is_a?(Array)
         context[:supplements] =
           context[:supplements].map do |supplement|
             if supplement[:typed_stage]
               supplement.merge(
                 case supplement[:typed_stage]
-                when "PDAM"
-                  { typed_stage: "CD", type: "Amd" }
-                when "pDCOR"
-                  { typed_stage: "CD", type: "Cor" }
-                else
-                  {}
-                end
+                when "PDAM" then { typed_stage: "CD", type: "Amd" }
+                when "pDCOR" then { typed_stage: "CD", type: "Cor" }
+                # when "DAD" then { typed_stage: "WD", type: "Amd" }
+                when "draft" then convert_urn_sup_draft_type supplement[:type]
+                else convert_urn_sup_stage_code(supplement)
+                end,
               )
             else
               case supplement[:type]
-              when "Addendum"
-                supplement.merge({ type: "Add" })
-              else
-                supplement
+              when "Addendum" then supplement.merge({ type: "Add" })
+              when "sup" then supplement.merge({ type: "Suppl" })
+              else supplement
               end
             end
           end
@@ -52,28 +57,9 @@ module Pubid::Iso
       end
     end
 
-    rule(type: simple(:type)) do
-      russian_type = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:type].key(type.to_s)
-      { type: russian_type&.downcase&.to_sym ||
-                        case type
-                        # XXX: can't put 2 alternative Russian translations to dictionary, temporary hack
-                        when "GUIDE", "Guide", "Руководство"
-                          :guide
-                        when "ТС", "TS"
-                          :ts
-                        when "ТО", "TR"
-                          :tr
-                        when "Directives Part", "Directives, Part", "Directives,", "DIR"
-                          :dir
-                        when "PAS"
-                          :pas
-                        when "DPAS"
-                          :dpas
-                        when "R"
-                          :r
-                        else
-                          type
-                        end }
+    rule(type: simple(:type)) do |context|
+      russian_type = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:type].key(context[:type].to_s)
+      { type: russian_type&.downcase&.to_sym || convert_type(context[:type]) }
     end
 
     rule(tctype: subtree(:tctype))  do |context|
@@ -81,21 +67,20 @@ module Pubid::Iso
       context
     end
 
-    rule(copublisher: simple(:copublisher)) do
-      russian_copublisher = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:publisher].key(copublisher.to_s)
-      { copublisher: russian_copublisher&.to_s ||
-        case copublisher
-        when "CEI"
-          "IEC"
-        else
-          copublisher.to_s
-        end
-      }
+    rule(copublisher: sequence(:copublisher)) do |context|
+      copublishers = context[:copublisher].map! do |publisher|
+        convert_copublisher(publisher)
+      end
+
+      { copublisher: copublishers }
+    end
+
+    rule(copublisher: simple(:copublisher)) do |context|
+      { copublisher: convert_copublisher(context[:copublisher]) }
     end
 
-    rule(publisher: simple(:publisher)) do
-      russian_publisher = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:publisher].key(publisher.to_s)
-      { publisher: russian_publisher&.to_s || publisher }
+    rule(publisher: simple(:publisher)) do |context|
+      { publisher: convert_publisher(context[:publisher]) }
     end
 
     rule(part: sequence(:part)) do
@@ -110,8 +95,8 @@ module Pubid::Iso
 
     rule(dir_joint_document: subtree(:dir_joint_document)) do |context|
       context[:joint_document] =
-        Identifier::Base.transform(**(context[:dir_joint_document].merge(type: :dir)))
-      context.select { |k, v| k != :dir_joint_document }
+        Identifier::Base.transform(**context[:dir_joint_document].merge(type: :dir))
+      context.reject { |k, _| k == :dir_joint_document }
     end
 
     rule(jtc_dir: simple(:jtc_dir)) do |context|
@@ -119,42 +104,104 @@ module Pubid::Iso
       context
     end
 
-    def self.convert_stage(code)
+    def self.convert_publisher(publisher)
+      pblsh = publisher.to_s.upcase
+      Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:publisher].key(pblsh) || pblsh
+    end
+
+    def self.convert_copublisher(copublisher)
+      copblsh = convert_publisher copublisher
+      Pubid::Iso::Renderer::Base::TRANSLATION[:french][:publisher].key(copblsh) || copblsh
+    end
+
+    rule(all_parts: simple(:all_parts)) do
+      ["(all parts)", "ser"].include?(all_parts) ? { all_parts: true } : {}
+    end
+
+    # Convert ISO stage to Russian and other formats if needed
+    # @param code [String] ISO stage code
+    # @return [Hash] a hash with keys :stage and optionally :type
+    def self.convert_stage(code) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
       russian_code = Pubid::Iso::Renderer::Base::TRANSLATION[:russian][:stage].key(code.to_s)
       return { stage: russian_code } if russian_code
 
       case code
-      when "NWIP"
-        { stage: "NP" }
-      when "D", "FPD"
-        { stage: "DIS" }
-      when "FD", "F"
-        { stage: "FDIS" }
-      when "Fpr"
-        { stage: "PRF" }
-      when "PDTR"
-        { stage: "CD", type: "TR" }
-      when "PDTS"
-        { stage: "CD", type: "TS" }
-      when "preCD"
-        { stage: "PreCD" }
-      else
-        { stage: code }
+      when "NWIP" then { stage: "NP" }
+      when "D", "FPD" then { stage: "DIS" }
+      when "FD", "F" then { stage: "FDIS" }
+      when "Fpr" then { stage: "PRF" }
+      when "PDTR" then { stage: "CD", type: "TR" }
+      when "PDTS" then { stage: "CD", type: "TS" }
+      when "preCD" then { stage: "PreCD" }
+      when "published" then { stage: "IS" }
+      # when "draft" then { stage: "WD" }
+      else { stage: convert_stage_code(code.to_s) }
+      end
+    end
+
+    def self.convert_urn_sup_stage_code(sup)
+      stage_type = convert_urn_sup_type(sup[:type])
+      abbr = convert_stage_code(sup[:typed_stage])
+      stage_type[:typed_stage] = abbr if abbr
+      stage_type
+    end
+
+    def self.convert_urn_sup_type(type)
+      case type
+      when "sup" then { type: "Suppl" }
+      when String, Parslet::Slice then { type: type.to_s }
+      else {}
+      end
+    end
+
+    def self.convert_stage_code(code)
+      Identifier::InternationalStandard::TYPED_STAGES.each_value do |v|
+        return v[:abbr] if v[:harmonized_stages].include?(code)
       end
+
+      code
     end
 
     def self.convert_language(code)
       case code
-      when "R"
-        "ru"
-      when "F"
-        "fr"
-      when "E"
-        "en"
-      when "A"
-        "ar"
+      when "R" then "ru"
+      when "F" then "fr"
+      when "E" then "en"
+      when "A" then "ar"
+      else code
+      end
+    end
+
+    def self.convert_urn_sup_draft_type(type)
+      if type == "sup"
+        { typed_stage: "DSuppl", type: "Suppl" }
       else
-        code
+        { typed_stage: "WD" }
+      end
+    end
+
+    def self.convert_urn_stage(type)
+      case type
+      when "tr" then "DTR"
+      when "ts" then "DTS"
+      when "iwa" then "DIWA"
+      when "pas" then "DPAS"
+      when "guide" then "DGuide"
+      else "D"
+      end
+    end
+
+    def self.convert_type(type) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+      case type
+      # XXX: can't put 2 alternative Russian translations to dictionary, temporary hack
+      when "GUIDE", "Guide", "Руководство" then :guide
+      when "ТС", "TS" then :ts
+      when "ТО", "TR" then :tr
+      when "Directives Part", "Directives, Part", "Directives,", "DIR" then :dir
+      when "PAS" then :pas
+      when "DPAS" then :dpas
+      when "R" then :r
+      else type
       end
     end
   end

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.7.8".freeze
+    VERSION = "0.8.0".freeze
   end
 end

data/stages.yaml

@@ -7,6 +7,10 @@ abbreviations:
   CD: ["30.00", "30.20", "30.60", "30.92", "30.98", "30.99"]
   FCD: ["40.00", "40.20", "40.60", "40.92", "40.98", "40.99"]
   PRF: ["50.00", "50.20", "50.60", "50.92", "50.98", "50.99"]
+  WDR: ["90.92"]
+  WDA: ["90.93"]
+  WDAR: ["95.99"]
+  IS: ["60.00", "60.60"]
 
 names:
   WD: Working Draft

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-iso
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.8.0
 platform: ruby
 authors:
 - Ribose Inc.
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-31 00:00:00.000000000 Z
+date: 2025-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.5
+        version: 1.13.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.12.5
+        version: 1.13.0
 description: Library to generate, parse and manipulate ISO PubID.
 email:
 - open.source@ribose.com
@@ -100,6 +100,7 @@ files:
 - lib/pubid/iso/identifier/technical_specification.rb
 - lib/pubid/iso/identifier/technology_trends_assessments.rb
 - lib/pubid/iso/parser.rb
+- lib/pubid/iso/parser_urn.rb
 - lib/pubid/iso/renderer/addendum.rb
 - lib/pubid/iso/renderer/amendment.rb
 - lib/pubid/iso/renderer/base.rb
@@ -133,7 +134,7 @@ homepage: https://github.com/metanorma/pubid-iso
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,15 +142,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Library to generate, parse and manipulate ISO PubID.
 test_files: []