pubid-iso 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d60d5581ae205f08b23f80682735696086c753587386ab0b7bfcf7ce306e6156
-  data.tar.gz: '08d626a7cbb67820faac3fb9503dce84f21d13fcd8387671d110878de84adc4a'
+  metadata.gz: 418f8b225027cf9b50cb2ec43aad7d043b3bfd0db87733366c6021df8f92f940
+  data.tar.gz: fd9a028a0cb2721b4422b2f515aa46263c7d713da57e02c8fc1ed4c54c22f737
 SHA512:
-  metadata.gz: b690e1a4d95efe0ed794ce74c1fef9e320cbb394c473650af6e7fded623ec4f986cb1d4ca463bdeab988be14d82fd14c0f7ec48f51febd8cd98d0ae2cd17a5eb
-  data.tar.gz: 33ca94206cb4b8812956fd3d1c146c77a5a5d8e24cd55e002405e6acc28b54b5433f4caf23e59bab5320b4189a4fb78c469696218995538d36600a1124abe341
+  metadata.gz: bf1f97bde499237e29b24b793d7e9fe115e03e42a92471a549f90aea9c416ddc357fcfd95079a97bff4b200b4fe8c93f786fc8e3c8256ad3275f2365f9c946e8
+  data.tar.gz: d4b53365fc22d587b204a7c38fcaf362e7f85b5cc5a07767ecb4f97fe5c7a3b8c70c3e24c8c30b63166321bd4f757f7d6658df154a4ccab4715ae94c62e8f17e

data/README.adoc

@@ -64,6 +64,31 @@ pubid.to_s
 => "ISO 1234-1"
 ----
 
+==== Iteration
+
+[source,ruby]
+----
+pubid = Pubid::Iso::Identifier.new(publisher: "ISO", number: 123, part: 1, stage: :DIS, iteration: 1)
+pubid.to_s
+
+=> "ISO/DIS 1234-1.1"
+----
+To apply iteration to document stage should be provided as well.
+Without stage error will be raised.
+
+==== Amendment and Corrigendum
+[source,ruby]
+----
+> pubid = Pubid::Iso::Identifier.new(publisher: "ISO", number: 123, part: 1, year: 2019, amendments: [{ number: "1", year: "2021", stage: :WD }])
+> pubid.to_s
+=> "ISO 1234-1:2019/WD Amd 1:2021"
+
+> pubid = Pubid::Iso::Identifier.new(publisher: "ISO", number: 123, part: 1, year: 2019, corrigendums: [{ number: "1", year: "2021", stage: :WD }])
+> pubid.to_s
+=> "ISO 1234-1:2019/WD Cor 1:2021"
+----
+See documentation on https://rubydoc.info/gems/pubid-iso/Pubid%2FIso%2FSupplement:initialize[PubId::Iso::Supplement#initialize] and https://rubydoc.info/gems/pubid-core/Pubid%2FCore%2FSupplement:initialize[Pubid::Core::Supplement#initialize] to see all available options.
+
 ==== Using format options
 [source,ruby]
 ----
@@ -107,12 +132,34 @@ pubid.to_s
   part: "1",
   year: 2019,
   edition: 1,
-  amendment: {number: "1", year: "2021", stage: "DIS"}
+  amendments: {number: "1", year: "2021", stage: "DIS"}
 )
 > pubid.urn
 => "urn:iso:std:iso:8601:-1:ed-1:amd:2021:v1"
 ----
 
+==== Typed stage abbreviation
+[source,ruby]
+----
+> pubid = Pubid::Iso::Identifier.parse("ISO/FDIS 26000:2010")
+> pubid.typed_stage_abbrev
+=> "FDIS"
+> pubid.typed_stage_name
+=> "Final Draft"
+
+> pubid = Pubid::Iso::Identifier.parse("ISO/FDTR 26000:2010")
+> pubid.typed_stage_abbrev
+=> "FDTR"
+> pubid.typed_stage_name
+=> "Final Draft Technical Report"
+
+> pubid = Pubid::Iso::Identifier.parse("ISO/WD TR 26000:2010")
+> pubid.typed_stage_abbrev
+=> "WD TR"
+> pubid.typed_stage_name
+=> "Working Draft Technical Report"
+----
+
 See documentation (https://www.rubydoc.info/gems/pubid-iso/Pubid/Iso/Identifier#initialize-instance_method[Pubid::Iso::Identifier] and https://www.rubydoc.info/gems/pubid-core/Pubid/Core/Identifier#initialize-instance_method[Pubid::Core::Identifier]) for all available attributes and options.
 
 == Elements of the PubID

data/lib/pubid/iso/amendment.rb

@@ -3,32 +3,9 @@ module Pubid::Iso
     # @param stage_format_long [Boolean] long or short format for stage rendering
     # @param with_date [Boolean] include date
     def render_pubid(stage_format_long = true, with_date = true)
-      stage = render_pubid_stage
       pubid_number = render_pubid_number(with_date: with_date)
-      case stage.to_s
-      when "DIS"
-        if stage_format_long
-          "/DAmd #{pubid_number}"
-        else
-          "/DAM #{pubid_number}"
-        end
-      when "FDIS"
-        if stage_format_long
-          "/FDAmd #{pubid_number}"
-        else
-          "/FDAM #{pubid_number}"
-        end
-      when "CD"
-        if stage_format_long
-          "/CD Amd #{pubid_number}"
-        else
-          "/CDAM #{pubid_number}"
-        end
-      when ""
-        "/Amd #{pubid_number}"
-      else
-        "/#{stage} Amd #{pubid_number}"
-      end
+
+      "/#{@typed_stage.to_s(stage_format_long)} #{pubid_number}"
     end
 
     def render_urn

data/lib/pubid/iso/corrigendum.rb

@@ -1,26 +1,27 @@
 module Pubid::Iso
   class Corrigendum < Supplement
     def render_pubid(stage_format_long = true, with_date = true)
-      stage = render_pubid_stage
+      # stage = render_pubid_stage
       pubid_number = render_pubid_number(with_date: with_date)
-      case stage.to_s
-      when "DIS"
-        if stage_format_long
-          "/DCor #{pubid_number}"
-        else
-          "/DCOR #{pubid_number}"
-        end
-      when "FDIS"
-        if stage_format_long
-          "/FDCor #{pubid_number}"
-        else
-          "/FDCOR #{pubid_number}"
-        end
-      when ""
-        "/Cor #{pubid_number}"
-      else
-        "/#{stage} Cor #{pubid_number}"
-      end
+      "/#{@typed_stage.to_s(stage_format_long)} #{pubid_number}"
+      # case stage.to_s
+      # when "DIS"
+      #   if stage_format_long
+      #     "/DCor #{pubid_number}"
+      #   else
+      #     "/DCOR #{pubid_number}"
+      #   end
+      # when "FDIS"
+      #   if stage_format_long
+      #     "/FDCor #{pubid_number}"
+      #   else
+      #     "/FDCOR #{pubid_number}"
+      #   end
+      # when ""
+      #   "/Cor #{pubid_number}"
+      # else
+      #   "/#{stage} Cor #{pubid_number}"
+      # end
     end
 
     def render_urn

data/lib/pubid/iso/errors.rb

@@ -3,11 +3,19 @@ module Pubid::Iso
     class ParseError < StandardError; end
     class PublishedIterationError < StandardError; end
     class HarmonizedStageCodeInvalidError < StandardError; end
+    class HarmonizedStageRenderingError < StandardError; end
     class StageInvalidError < StandardError; end
     class IsStageIterationError < StandardError; end
+    class IterationWithoutStageError < StandardError; end
     class WrongFormat < StandardError; end
     # Error raised when supplement applied to base document without publication year or stage
     class SupplementWithoutYearOrStageError < StandardError; end
     class NoEditionError < StandardError; end
+    class WrongTypeError < StandardError; end
+    class ParseTypeError < StandardError; end
+    class TypeStageInvalidError < StandardError; end
+    class TypeStageParseError < StandardError; end
+
+    class SupplementRenderingError < StandardError; end
   end
 end

data/lib/pubid/iso/harmonized_stage_code.rb

@@ -1,7 +1,8 @@
 module Pubid::Iso
   class HarmonizedStageCode
     include Comparable
-    attr_accessor :stage, :substage
+    # attr_accessor :stage, :substage
+    attr_accessor :stages
 
     DESCRIPTIONS = {
       "00.00" => "Proposal for new project received",
@@ -50,7 +51,15 @@ module Pubid::Iso
       "95.60" => "Close of voting",
       "95.92" => "Decision not to withdraw International Standard",
       "95.99" => "Withdrawal of International Standard"
-    }
+    }.freeze
+
+    DRAFT_STAGES = %w[00.00 00.20 00.60 00.99 10.00 10.20 10.60 10.92 10.99 20.00 20.20 20.60 20.99 30.00
+                      30.20 30.60 30.92 30.99 40.00 40.20 40.60 40.92 40.93 40.99 50.00 50.20 50.60
+                      50.92 50.99].freeze
+
+    CANCELED_STAGES = %w[00.98 10.98 20.98 30.98 40.98 50.98 95.99].freeze
+
+    PUBLISHED_STAGES = %w[60.00 60.60 90.20 90.60 90.92 90.93 90.99 95.20 95.60 95.92].freeze
 
     STAGES_NAMES = {
       preliminary: "00",
@@ -74,32 +83,63 @@ module Pubid::Iso
       proceed: "99",
     }.freeze
 
-    def initialize(stage, substage = "00")
-      # when stage is stage name
-      if STAGES_NAMES.key?(stage)
-        @stage = STAGES_NAMES[stage]
-        @substage = SUBSTAGES_NAMES[substage]
+    # @param stage_or_code [String,Array<String>] stage number or whole harmonized code with substage
+    #   or list or stages for fuzzy stages eg. "10", 10, "20.20", ["10.20", "20.20"]
+    # @param substage [Integer, String] eg. "00", 0
+    def initialize(stage_or_code, substage = "00")
+      @stages = if stage_or_code.is_a?(Array)
+                  stage_or_code
+                elsif stage_or_code.is_a?(String) && DESCRIPTIONS.key?(stage_or_code)
+                  [stage_or_code]
+                # when stage is stage name
+                elsif STAGES_NAMES.key?(stage_or_code)
+                  ["#{STAGES_NAMES[stage_or_code]}.#{SUBSTAGES_NAMES[substage]}"]
+                else
+                  # stage is number
+                  ["#{stage_or_code}.#{substage}"]
+                end
+      validate_stages
+    end
+
+    def validate_stages
+      @stages.each do |stage|
+        # raise an error when stage is wrong
+        raise Errors::HarmonizedStageCodeInvalidError unless DESCRIPTIONS.key?(stage)
+      end
+    end
+
+    def to_s
+      if fuzzy?
+        return "draft" if @stages.all? { |s| DRAFT_STAGES.include?(s) || CANCELED_STAGES.include?(s) }
+
+        return "published" if @stages.all? { |s| PUBLISHED_STAGES.include?(s) }
+
+        raise Errors::HarmonizedStageRenderingError, "cannot render fuzzy stages"
       else
-        # stage is number
-        @stage, @substage = stage, substage
-        validate_stage(stage, substage)
+        @stages.first
       end
     end
 
-    def validate_stage(stage, substage)
-      # raise an error if stage is not number
-      raise Errors::HarmonizedStageCodeInvalidError if Integer(stage).nil?
+    def ==(other)
+      (stages & other.stages) == other.stages
+    end
 
-      # raise an error when substage wrong
-      raise Errors::HarmonizedStageCodeInvalidError unless DESCRIPTIONS.key?(to_s)
+    def fuzzy?
+      @stages.length > 1
     end
 
-    def to_s
-      "#{stage}.#{substage}"
+    def stage
+      raise Errors::HarmonizedStageRenderingError, "cannot render stage for fuzzy stages" if fuzzy?
+
+      return nil if @stages.empty?
+
+      @stages.first.split(".").first
     end
 
-    def ==(other)
-      stage == other.stage && substage == other.substage
+    def substage
+      raise Errors::HarmonizedStageRenderingError, "cannot render substage for fuzzy stages" if fuzzy?
+
+      @stages.first.split(".").last
     end
 
     def description

data/lib/pubid/iso/identifier.rb

@@ -3,15 +3,17 @@ module Pubid::Iso
     attr_accessor :stage,
                   :iteration, :joint_document,
                   :tctype, :sctype, :wgtype, :tcnumber, :scnumber, :wgnumber,
-                  :urn_stage, :dirtype,
+                  :dirtype,
                   # supplement for DIR type identifiers
-                  :supplement
+                  :supplement,
+                  :base,
+                  :typed_stage,
+                  :supplements
 
     # Creates new identifier from options provided, includes options from
     # Pubid::Core::Identifier#initialize
     #
-    # @param stage [Stage, Symbol, String] stage, e.g. "PWI", "NP", "50.00", Stage.new(abbr: :WD)
-    # @param urn_stage [Float] numeric stage for URN rendering
+    # @param stage [Stage, TypedStage, Symbol, String] stage or typed stage, e.g. "PWI", "NP", "50.00", Stage.new(abbr: :WD), "DTR"
     # @param iteration [Integer] document iteration, eg. "1", "2", "3"
     # @param joint_document [Identifier] joint document
     # @param supplement [Supplement] supplement
@@ -22,42 +24,73 @@ module Pubid::Iso
     # @param scnumber [Integer] Subsommittee number, eg. "1", "2"
     # @param wgnumber [Integer] Working group number, eg. "1", "2"
     # @param dirtype [String] Directives document type, eg. "JTC"
+    # @param base [Identifier] base document for supplement's identifier
+    # @param type [nil, :tr, :ts, :amd, :cor, :guide, :dir, :tc, Type] document's type, eg. :tr, :ts, :amd, :cor, Type.new(:tr)
     # @raise [Errors::SupplementWithoutYearOrStageError] when trying to apply
     #   supplement to the document without edition year or stage
     # @raise [Errors::IsStageIterationError] when trying to apply iteration
     #   to document with IS stage
+    # @raise [Errors::IterationWithoutStageError] when trying to applu iteration
+    #   to document without stage
     # @see Supplement
     # @see Identifier
     # @see Pubid::Core::Identifier
     # @see Parser
     #
     def initialize(publisher: "ISO", number: nil, stage: nil, iteration: nil, supplement: nil,
-                   joint_document: nil, urn_stage: nil,
-                   tctype: nil, sctype: nil, wgtype: nil, tcnumber: nil,
+                   joint_document: nil, tctype: nil, sctype: nil, wgtype: nil, tcnumber: nil,
                    scnumber: nil, wgnumber:nil,
                    dir: nil, dirtype: nil, year: nil, amendments: nil,
-                   corrigendums: nil, type: nil, **opts)
+                   corrigendums: nil, type: nil, base: nil, supplements: nil, **opts)
       super(**opts.merge(number: number, publisher: publisher, year: year,
-                         amendments: amendments, corrigendums: corrigendums, type: type))
+                         amendments: amendments, corrigendums: corrigendums))
 
-      if (amendments || corrigendums) && (year.nil? && stage.nil?)
-        raise Errors::SupplementWithoutYearOrStageError, "Cannot apply supplement to document without edition year or stage"
+      if supplements
+        @supplements = supplements.map do |supplement|
+          if supplement.is_a?(Hash)
+            self.class.get_transformer_class.new.apply(:supplements => [supplement])[:supplements].first
+          else
+            supplement
+          end
+        end
+      end
+
+      if %i(amd cor).include?(type) && (base.year.nil? && base.stage.nil?)
+        raise Errors::SupplementWithoutYearOrStageError,
+              "Cannot apply supplement to document without base identifieredition year or stage"
       end
-      if stage
-        @stage = stage.is_a?(Stage) ? stage : Stage.parse(stage)
 
-        if @stage.abbr == "IS" && iteration
+      if stage.is_a?(TypedStage)
+        @typed_stage = stage
+        # add type to typed stage when missing (case for amendment with stage, eg. "CD Amd")
+        @typed_stage.type = Type.new(type) if @typed_stage.type.nil? && type
+      elsif stage || type
+        @typed_stage = if type
+                         TypedStage.new(type: type.is_a?(Type) ? type : Type.new(type))
+                       else
+                         TypedStage.new
+                       end
+
+        if @typed_stage.type == :is && iteration
           raise Errors::IsStageIterationError, "IS stage document cannot have iteration"
         end
 
-        if @stage.abbr == "FDIS" && type == "PAS"
-          raise Errors::StageInvalidError, "PAS type cannot have FDIS stage"
+        if stage
+          provided_type = @typed_stage.type
+
+          @typed_stage.parse_stage(stage.is_a?(Parslet::Slice) ? stage.to_s : stage)
+          if !provided_type.nil? && @typed_stage.type != provided_type
+            raise Errors::StageInvalidError,
+                  "cannot assign typed stage for document with different type (#{provided_type} vs #{@typed_stage.type})"
+          end
         end
+      elsif iteration
+        raise Errors::IterationWithoutStageError, "Document without stage cannot have iteration"
       end
+
       @iteration = iteration.to_i if iteration
       @supplement = supplement if supplement
       @joint_document = joint_document if joint_document
-      @urn_stage = urn_stage if urn_stage
       @tctype = tctype if tctype
       @sctype = sctype.to_s if sctype
       @wgtype = wgtype.to_s if wgtype
@@ -66,6 +99,7 @@ module Pubid::Iso
       @wgnumber = wgnumber.to_s if wgnumber
       @dir = dir.to_s if dir
       @dirtype = dirtype.to_s if dirtype
+      @base = base if base
     end
 
     def self.parse_from_title(title)
@@ -78,6 +112,53 @@ module Pubid::Iso
     end
 
     class << self
+      def supplements_has_type?(supplements, type)
+        supplements.any? do |supplement|
+          supplement.typed_stage.type == type
+        end
+      end
+
+      def supplement_by_type(supplements, type)
+        supplements.select { |supplement| supplement.type == type }.first
+      end
+
+      def transform_supplements(supplements_params, base_params)
+        supplements = supplements_params.map do |supplement|
+          new(number: supplement[:number], year: supplement[:year],
+              stage: supplement[:typed_stage], edition: supplement[:edition],
+              iteration: supplement[:iteration],
+              base: new(**base_params))
+        end
+
+        return supplements.first if supplements.count == 1
+
+        # update corrigendum base to amendment
+        if supplements_has_type?(supplements, :cor) &&
+            supplements_has_type?(supplements, :amd) && supplements.count == 2
+
+          supplement = supplement_by_type(supplements, :cor)
+          supplement.base = supplement_by_type(supplements, :amd)
+          supplement
+        else
+          raise Errors::SupplementRenderingError, "don't know how to render provided supplements"
+        end
+      end
+
+      def transform(params)
+        identifier_params = params.map do |k, v|
+          get_transformer_class.new.apply(k => v).to_a.first
+        end.to_h
+
+        # return supplement if supplements applied
+        if identifier_params[:supplements]
+          return transform_supplements(
+            identifier_params[:supplements],
+            identifier_params.dup.tap { |h| h.delete(:supplements) })
+        end
+
+        new(**identifier_params)
+      end
+
       def get_amendment_class
         Pubid::Iso::Amendment
       end
@@ -102,10 +183,10 @@ module Pubid::Iso
     # Render URN identifier
     # @return [String] URN identifier
     def urn
-      if (@amendments || @corrigendums) && !@edition
+      if %i(amd cor).include?(type&.type) && (@base.base.nil? && !@base.edition || (!@base.base.nil? && !@base.base.edition))
         raise Errors::NoEditionError, "Base document must have edition"
       end
-      (@tctype && Renderer::UrnTc || @type == "DIR" && Renderer::UrnDir || Pubid::Iso::Renderer::Urn).new(get_params).render
+      (@tctype && Renderer::UrnTc || type == :dir && Renderer::UrnDir || Pubid::Iso::Renderer::Urn).new(get_params).render
     end
 
     # Renders pubid identifier
@@ -115,6 +196,7 @@ module Pubid::Iso
     # @param with_edition [Boolean] render identifier with edition
     # @param stage_format_long [Boolean] render with long or short stage format
     # @param format [:ref_num_short,:ref_num_long,:ref_dated,:ref_dated_long,:ref_undated,:ref_undated_long] create reference with specified format
+    # @param with_prf [Boolean] include PRF stage in output
     # Format options are:
     #   :ref_num_short -- instance reference number: 1 letter language code + short form (DAM) + dated
     #   :ref_num_long -- instance reference number long: 2 letter language code + long form (DAmd) + dated
@@ -162,16 +244,38 @@ module Pubid::Iso
       else
         if @tctype
           Renderer::Tc.new(get_params)
-        elsif @type == "DIR"
+        elsif @typed_stage&.type == :dir
           Renderer::Dir.new(get_params)
         else
           self.class.get_renderer_class.new(get_params)
         end
       end.render(with_date: with_date, with_language_code: with_language_code, with_edition: with_edition,
                  stage_format_long: stage_format_long, with_prf: with_prf) +
-        if @joint_document && @type != "DIR"
+        if @joint_document && @typed_stage&.type != :dir
           "|#{@joint_document}"
         end.to_s
     end
+
+    def stage
+      typed_stage&.stage
+    end
+
+    def type
+      typed_stage&.type
+    end
+
+    # Return typed stage abbreviation, eg. "FDTR", "DIS", "TR"
+    def typed_stage_abbrev
+      typed_stage.to_s
+    end
+
+    # Return typed stage name, eg. "Final Draft Technical Report" for "FDTR"
+    def typed_stage_name
+      typed_stage.name
+    end
+
+    def ==(other)
+      get_params == other.get_params
+    end
   end
 end

data/lib/pubid/iso/parser.rb

@@ -1,7 +1,10 @@
 module Pubid::Iso
   class Parser < Pubid::Core::Parser
-    STAGES = %w[NP NWIP WD CD DIS FDIS PRF IS AWI PWI FPD pD PD FD D F].freeze
-    TYPES = %w[DATA ISP IWA R TTA TS TR PAS Guide GUIDE DIR].freeze
+    STAGES = %w[NP NWIP WD CD 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
+    SUPPLEMENTS = %w[Amd Cor AMD COR]
+    STAGED_SUPPLEMENTS = %w[DAmd DAM DCor FDAmd FDCor DCOR FCOR FDCOR FDAM PDAM pDCOR FPDAM]
 
     TCTYPES = ["TC", "JTC", "PC", "IT", "CAB", "CASCO", "COPOLCO",
       "COUNCIL", "CPSG", "CS", "DEVCO", "GA", "GAAB", "INFCO",
@@ -21,6 +24,18 @@ module Pubid::Iso
       array_to_str(Renderer::Russian::STAGE.values) | array_to_str(STAGES)
     end
 
+    rule(:typed_stage) do
+      array_to_str(TYPED_STAGES)
+    end
+
+    rule(:staged_supplement) do
+      array_to_str(STAGED_SUPPLEMENTS)
+    end
+
+    rule(:supplements) do
+      array_to_str(SUPPLEMENTS)
+    end
+
     rule(:type) do
       (array_to_str(Renderer::Russian::TYPE.values) | array_to_str(TYPES)).as(:type)
     end
@@ -56,24 +71,13 @@ module Pubid::Iso
       str(".") >> digits.as(:iteration)
     end
 
-    rule(:amendment) do
-      ((str("/") >> stage.as(:stage)).maybe >>
-      (str("/") | space).maybe >>
-        (str("Amd") | str("AMD") | str("AM")) >>
-        (space | str(".")).repeat(1).maybe >>
-        digits.as(:number) >>
-        (str(".") >> digits.as(:iteration)).maybe >>
-        ((str(":") | str("-")) >> digits.as(:year)).maybe).repeat(1).as(:amendments)
-    end
-
-    rule(:corrigendum) do
-      ((str("/") >> stage.as(:stage)).maybe >>
-      (str("/") | space).maybe >>
-        (str("Cor") | str("COR")) >>
+    rule(:supplement) do
+      ((str("/") | space).maybe >>
+        (staged_supplement | (stage >> space).maybe >> supplements).as(:typed_stage) >>
         (space | str(".")).repeat(1).maybe >>
         digits.as(:number) >>
         (str(".") >> digits.as(:iteration)).maybe >>
-        ((str(":") | str("-")) >> digits.as(:year)).maybe).repeat(1).as(:corrigendums)
+        ((str(":") | str("-")) >> digits.as(:year)).maybe).repeat(1).as(:supplements)
     end
 
     rule(:language) do
@@ -117,7 +121,7 @@ module Pubid::Iso
     rule(:std_document_body) do
       (type | stage.as(:stage)).maybe >>
         # for ISO/IEC WD TS 25025
-        space? >> ((stage.as(:stage) | type) >> space).maybe >>
+        space? >> ((stage.as(:stage) | typed_stage.as(:stage) | type) >> space).maybe >>
         digits.as(:number) >>
         # for identifiers like ISO 5537/IDF 26
         (str("|") >> (str("IDF").as(:publisher) >> space >> digits.as(:number)).as(:joint_document)).maybe >>
@@ -126,7 +130,7 @@ module Pubid::Iso
         # stage before amendment
         (
           # stage before corrigendum
-          ((amendment >> corrigendum.maybe) | corrigendum).maybe) >>
+          (supplement).maybe) >>
         edition.maybe >>
         language.maybe
     end
@@ -138,6 +142,7 @@ module Pubid::Iso
         # for French and Russian PubIDs starting with Guide type
         (guide_prefix.as(:type) >> space).maybe >>
         (stage.as(:stage) >> space).maybe >>
+        (typed_stage.as(:stage) >> space).maybe >>
         originator >> (space | str("/")) >>
         (tc_document_body | std_document_body | (dir_document_body >>
           (str(" + ") >> (originator >> space >> dir_document_body).as(:joint_document)).maybe))