pubid-iso 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93b04a876f8ee73e80af8c49af1efc223d1b63a4d8a6b6b679a114d77befcc73
-  data.tar.gz: c39834a8f5290dc71d8bbcd79801e3313c1c888715040a7d67fbbda116d7572e
+  metadata.gz: 418f8b225027cf9b50cb2ec43aad7d043b3bfd0db87733366c6021df8f92f940
+  data.tar.gz: fd9a028a0cb2721b4422b2f515aa46263c7d713da57e02c8fc1ed4c54c22f737
 SHA512:
-  metadata.gz: 3bef9b0e5791702f0bcf3c291639d78cb3cd0319d94345b953a0e3608b22b895f019ee75bdcc742c78007281392be6cd2d60081fbe0a81cec9109de59fc31005
-  data.tar.gz: eb469ae1abc30c718355173cab16ee1b80cf1386adc1e65fbd5ba96b493f7c7ee9abdd0cab0612ec34159214524465d8323007ba3fd344a0ec3d2b611d6718de
+  metadata.gz: bf1f97bde499237e29b24b793d7e9fe115e03e42a92471a549f90aea9c416ddc357fcfd95079a97bff4b200b4fe8c93f786fc8e3c8256ad3275f2365f9c946e8
+  data.tar.gz: d4b53365fc22d587b204a7c38fcaf362e7f85b5cc5a07767ecb4f97fe5c7a3b8c70c3e24c8c30b63166321bd4f757f7d6658df154a4ccab4715ae94c62e8f17e

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,6 +3,7 @@ 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
@@ -12,5 +13,9 @@ module Pubid::Iso
     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

@@ -6,12 +6,14 @@ module Pubid::Iso
                   :dirtype,
                   # supplement for DIR type identifiers
                   :supplement,
-                  :base
+                  :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 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
@@ -39,23 +41,48 @@ module Pubid::Iso
                    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, base: nil, **opts)
+                   corrigendums: nil, type: nil, base: nil, supplements: nil, **opts)
       super(**opts.merge(number: number, publisher: publisher, year: year,
                          amendments: amendments, corrigendums: corrigendums))
 
+      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"
@@ -73,7 +100,6 @@ module Pubid::Iso
       @dir = dir.to_s if dir
       @dirtype = dirtype.to_s if dirtype
       @base = base if base
-      @type = type.is_a?(Type) ? type : Type.new(type) unless type.nil?
     end
 
     def self.parse_from_title(title)
@@ -86,34 +112,49 @@ module Pubid::Iso
     end
 
     class << self
-      def transform(params)
-        identifier_params = params.map do |k, v|
-          get_transformer_class.new.apply(k => v).to_a.first
-        end.to_h
+      def supplements_has_type?(supplements, type)
+        supplements.any? do |supplement|
+          supplement.typed_stage.type == type
+        end
+      end
 
-        supplement = nil
+      def supplement_by_type(supplements, type)
+        supplements.select { |supplement| supplement.type == type }.first
+      end
 
-        if identifier_params[:amendments]
-          identifier_params[:amendments].first.tap do |amendment|
-            supplement = new(type: :amd, number: amendment.number, year: amendment.year,
-                     stage: amendment.stage, edition: amendment.edition,
-                     iteration: amendment.iteration,
-                     base: new(**identifier_params.dup.tap { |h| h.delete(:amendments); h.delete(:corrigendums) }))
-          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
 
-        if identifier_params[:corrigendums]
-          corrigendum = identifier_params[:corrigendums].first
-          return new(type: :cor, number: corrigendum.number, year: corrigendum.year,
-                     stage: corrigendum.stage, edition: corrigendum.edition,
-                     iteration: corrigendum.iteration,
-                     base: supplement ? supplement :
-                             new(**identifier_params.dup.tap { |h| h.delete(:amendments); h.delete(:corrigendums) }))
+        # 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 supplement
+        # 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
@@ -142,10 +183,10 @@ module Pubid::Iso
     # Render URN identifier
     # @return [String] URN identifier
     def urn
-      if %i(amd cor).include?(@type&.type) && (@base.base.nil? && !@base.edition || (!@base.base.nil? && !@base.base.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
@@ -203,27 +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
-      renderer = self.class.get_renderer_class.new(get_params).prerender
-      renderer.prerendered_params[:type_stage]
+      typed_stage.to_s
     end
 
     # Return typed stage name, eg. "Final Draft Technical Report" for "FDTR"
     def typed_stage_name
-      "#{stage.short_name} #{type.to_s(:long)}"
+      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))

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

@@ -17,42 +17,86 @@ module Pubid::Iso::Renderer
       super
     end
 
+    def render_supplement(supplement_params, **args)
+      if supplement_params[:base].type == :amd
+        # render inner amendment (cor -> amd -> base)
+        render_supplement(supplement_params[:base].get_params, **args)
+      else
+        self.class.new(supplement_params[:base].get_params).render_base_identifier(
+          # always render year for identifiers with supplement
+          **args.merge({ with_date: true }),
+          )
+      end +
+        case supplement_params[:typed_stage].type.type
+        when :amd
+          render_amendments(
+            [Pubid::Iso::Amendment.new(**supplement_params.slice(:number, :year, :typed_stage, :edition, :iteration))],
+            args,
+            nil,
+            )
+        when :cor
+          render_corrigendums(
+            [Pubid::Iso::Corrigendum.new(**supplement_params.slice(:number, :year, :typed_stage, :edition, :iteration))],
+            args,
+            nil,
+            )
+          # copy parameters from Identifier only supported by Corrigendum
+        end +
+        (supplement_params[:base].language ? render_language(supplement_params[:base].language, args, nil) : "")
+    end
+
     # Render identifier
     # @param with_edition [Boolean] include edition in output
     # @see Pubid::Core::Renderer::Base for another options
-    def render(with_edition: true, **args)
-      super(**args.merge({ with_edition: with_edition }))
+    def render(with_edition: true, with_language_code: :iso, with_date: true, **args)
+      # super(**args.merge({ with_edition: with_edition }))
+      if %i(amd cor).include? @params[:typed_stage]&.type&.type
+        render_supplement(@params, **args.merge({ with_date: with_date,
+                                                  with_language_code: with_language_code,
+                                                  with_edition: with_edition }))
+      else
+        render_base_identifier(**args.merge({ with_date: with_date,
+                                              with_language_code: with_language_code,
+                                              with_edition: with_edition })) +
+          @prerendered_params[:language].to_s
+      end
+
     end
 
     def render_identifier(params)
-      type_stage = if params[:type_stage] && !params[:type_stage].empty?
-                     ((params[:copublisher] && !params[:copublisher].empty?) ? " " : "/") + params[:type_stage]
-                   else
-                     ""
-                   end
-      render_base(params, type_stage) +
+      # typed_stage = if params[:typed_stage] && params[:typed_stage] != ""
+      #                 ((params[:copublisher] && !params[:copublisher].empty?) ? " " : "/") + params[:typed_stage].to_s
+      #               else
+      #                 ""
+      #               end
+      render_base(params, params[:typed_stage]) +
         ("%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}" % params)
     end
 
-    def render_type_stage(values, opts, params)
-      # prerender stage and type before
-      stage = render_stage(values[:stage], opts, params)
-      type = values[:type]&.to_s
-      return unless type || stage
-
-      if type && stage
-        # don't add prefix for pdf format
-        if %w(DIS FDIS).include?(stage)
-          "#{render_short_stage(stage)}#{type}"
-        else
-          "#{stage} #{type}"
-        end
-      else
-        # when only type or stage
-        "#{type}#{stage}"
-      end
+    def render_typed_stage(typed_stage, _opts, params)
+      (params[:copublisher] ? " " : "/") + typed_stage.to_s
     end
 
+    # def render_type_stage(values, opts, params)
+    #
+    #   # prerender stage and type before
+    #   stage = render_stage(values[:stage], opts, params)
+    #   type = values[:type]&.to_s
+    #   return unless type || stage
+    #
+    #   if type && stage
+    #     # don't add prefix for pdf format
+    #     if %w(DIS FDIS).include?(stage)
+    #       "#{render_short_stage(stage)}#{type}"
+    #     else
+    #       "#{stage} #{type}"
+    #     end
+    #   else
+    #     # when only type or stage
+    #     "#{type}#{stage}"
+    #   end
+    # end
+
     def render_short_stage(stage)
       case stage
       when "DIS"

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

@@ -1,16 +1,13 @@
 module Pubid::Iso::Renderer
   class French < Base
-    def render_type_stage(values, opts, params)
-      if values[:type] == :guide
-        super(values.slice(:stage), opts, params)
-      else
-        super
-      end
+    def render_typed_stage(typed_stage, opts, params)
+      return nil if typed_stage.type == :guide
+
+      super
     end
 
     def render_identifier(params)
-      if params[:type] == :guide
-        params[:type] = nil
+      if @params[:typed_stage]&.type == :guide
         "Guide #{super(params)}"
       else
         super

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

@@ -18,17 +18,16 @@ module Pubid::Iso::Renderer
              "ISP" => "ИСП",
     }.freeze
 
-    def render_type_stage(values, opts, params)
-      if values[:type] == :guide
-        super(values.slice(:stage), opts, params)
-      else
-        super
-      end
+    def render_typed_stage(typed_stage, opts, params)
+      return nil if typed_stage.type == :guide
+
+      return (params[:copublisher] ? " " : "/") + STAGE[typed_stage.to_s] if STAGE.key?(typed_stage.to_s)
+
+      super
     end
 
     def render_identifier(params)
-      if params[:type] == :guide
-        params[:type] = nil
+      if @params[:typed_stage]&.type == :guide
         "Руководство #{super(params)}"
       else
         super

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

@@ -19,20 +19,29 @@ module Pubid::Iso::Renderer
     # @param with_edition [Boolean] include edition in output
     # @see Pubid::Core::Renderer::Base for another options
     def render(with_edition: true, **args)
+      # copy type from typed stage
+      @params[:type] = @params[:typed_stage].type if @params[:typed_stage] && @params[:typed_stage].type
       super(**args.merge({ with_edition: with_edition }))
     end
 
     def render_identifier(params)
-      render_base(params) + "%{stage}"\
+      render_base(params) + "%{typed_stage}"\
       "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}" % params
     end
 
-    def render_stage(stage, _opts, params)
-      ":stage-#{stage.harmonized_code}"
+    def render_typed_stage(typed_stage, _opts, _params)
+      ":stage-#{typed_stage.stage.harmonized_code}" if typed_stage.stage
+    end
+    # def render_stage(stage, _opts, params)
+    #   ":stage-#{stage.harmonized_code}"
+    # end
+
+    def render_iteration(iteration, _opts, params)
+      ".v#{iteration}" if params[:typed_stage]&.stage
     end
 
     def render_type(type, _, _)
-      ":#{type.to_s.downcase}"
+      ":#{type.to_s.downcase}" unless type == :is
     end
 
     def render_year(year, _opts, _params)

data/lib/pubid/iso/stage.rb

@@ -2,37 +2,20 @@ module Pubid::Iso
   class Stage
     attr_accessor :abbr, :harmonized_code
 
-    STAGES = { PWI: "00.00",
-               NP: "10.00",
+    STAGES = { PWI: %w[00.00 00.20 00.60 00.98 00.99],
+               NP: %w[10.00 10.20 10.60 10.98 10.92],
                AWI: %w[20.00 10.99],
                WD: %w[20.20 20.60 20.98 20.99],
-               CD: "30.00",
-               DIS: "40.00",
-               FDIS: "50.00",
-               PRF: "60.00",
-               IS: "60.60" }.freeze
+               CD: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+               PRF: "60.00" }.freeze
 
 
     STAGE_NAMES = {
-      FDIS: "Final Draft International Standard",
-      DIS: "Draft International Standard",
       WD: "Working Draft",
       PWI: "Preliminary Work Item",
       NP: "New Proposal",
       CD: "Committee Draft",
       PRF: "Proof of a new International Standard",
-      IS: "International Standard",
-    }.freeze
-
-    STAGE_NAMES_SHORT = {
-      FDIS: "Final Draft",
-      DIS: "Draft",
-      WD: "Working Draft",
-      PWI: "Preliminary Work Item",
-      NP: "New Proposal",
-      CD: "Committee Draft",
-      PRF: "Proof of a new International Standard",
-      IS: "International Standard",
     }.freeze
 
     # @param abbr [String, Symbol] abbreviation eg. :PWI, :WD
@@ -44,27 +27,38 @@ module Pubid::Iso
         @harmonized_code = if harmonized_code.is_a?(HarmonizedStageCode)
                              harmonized_code
                            else
-                             HarmonizedStageCode.new(*harmonized_code.to_s.split("."))
+                             HarmonizedStageCode.new(harmonized_code)
                            end
-        @abbr ||= lookup_abbr(@harmonized_code.to_s) || lookup_abbr("#{@harmonized_code.stage}.00")
+        @abbr ||= lookup_abbr(@harmonized_code.stages)
+        # unless @harmonized_code.fuzzy?
+        #   @abbr ||= lookup_abbr(@harmonized_code.to_s) || lookup_abbr("#{@harmonized_code.stage}.00")
+        # end
       end
 
       if abbr
         raise Errors::StageInvalidError, "#{abbr} is not valid stage" unless STAGES.key?(abbr.to_sym)
 
-        @harmonized_code ||= HarmonizedStageCode.new(*lookup_code(abbr).split("."))
+        @harmonized_code ||= HarmonizedStageCode.new(lookup_code(abbr))
       end
     end
 
     # Lookup for abbreviated code by numeric stage code
-    # @param lookup_code [String] stage code, e.g. "00.00", "20.20"
+    # @param lookup_code [String, Array] stage code or array of stage codes,
+    #   e.g. "00.00", "20.20", ["00.00", "00.20"]
     def lookup_abbr(lookup_code)
+      lookup_code = lookup_code.first if lookup_code.is_a?(Array) && lookup_code.count == 1
+
       STAGES.each do |abbr, codes|
         case codes
         when Array
-          codes.each do |code|
-            return abbr if code == lookup_code
+          if lookup_code.is_a?(Array)
+            return abbr if codes == lookup_code
+          else
+            return abbr if codes.include?(lookup_code)
           end
+          # codes.each do |code|
+          #   return abbr if code == lookup_code
+          # end
         when lookup_code
           return abbr
         end
@@ -74,8 +68,8 @@ module Pubid::Iso
     end
 
     def lookup_code(lookup_abbr)
-      code = STAGES[lookup_abbr.to_sym]
-      code.is_a?(Array) ? code.first : code
+      STAGES[lookup_abbr.to_sym]
+      # code.is_a?(Array) ? code.first : code
     end
 
     def self.parse(stage)
@@ -88,6 +82,14 @@ module Pubid::Iso
       end
     end
 
+    def self.has_stage?(stage)
+      if stage.is_a?(Stage)
+        STAGES.key?(stage.abbr.to_sym)
+      else
+        STAGES.key?(stage.to_sym) || /\A[\d.]+\z/.match?(stage)
+      end
+    end
+
     # Compares one stage with another
     def ==(other)
       other&.harmonized_code == harmonized_code
@@ -97,10 +99,5 @@ module Pubid::Iso
     def name
       STAGE_NAMES[abbr.to_sym]
     end
-
-    # Return short stage name, eg. "Draft" for "DIS"
-    def short_name
-      STAGE_NAMES_SHORT[abbr.to_sym]
-    end
   end
 end

data/lib/pubid/iso/supplement.rb

@@ -1,35 +1,36 @@
 module Pubid::Iso
   class Supplement < Pubid::Core::Supplement
-    attr_accessor :stage, :publisher, :edition, :iteration
+    attr_accessor :typed_stage, :publisher, :edition, :iteration
 
     # @param stage [Stage, Symbol, String] stage, e.g. "PWI", "NP", "50.00", Stage.new(abbr: :WD)
     # @param publisher [String] publisher, e.g. "ISO", "IEC" (only for DIR documents)
     # @param edition [Integer] edition, e.g. 1, 2, 3
     # @param iteration [Integer] iteration, e.g. 1, 2, 3
     # @see Pubid::Core::Supplement for other options
-    def initialize(stage: nil, publisher: nil, edition: nil, iteration: nil, **args)
+    def initialize(typed_stage: nil, publisher: nil, edition: nil, iteration: nil, **args)
       super(**args)
-      @stage = stage.is_a?(Stage) ? stage : Stage.parse(stage) if stage
+      @typed_stage = TypedStage.parse(typed_stage) if typed_stage
       # for DIR identifiers only
       @publisher = publisher.to_s
       @edition = edition&.to_i
       @iteration = iteration&.to_i
 
-      if @iteration && @stage.nil?
+      if @iteration && @typed_stage.nil?
         raise Errors::PublishedIterationError.new("cannot assign iteration to published supplement")
       end
     end
 
     def render_pubid_stage
-      ((@stage && @stage.abbr != "IS" && @stage.abbr) || "")
+      # @typed_stage.stage.abbr != "IS" &&
+      ((@typed_stage && @typed_stage.to_s) || "")
     end
 
     def render_urn_stage
-      ((@stage && ":stage-#{@stage.harmonized_code}") || "")
+      ((@typed_stage&.stage && ":stage-#{@typed_stage.stage.harmonized_code}") || "")
     end
 
     def <=>(other)
-      (super == 0) && ((stage.nil? || stage == other.stage) && 0 || -1) || super
+      (super == 0) && ((typed_stage.nil? || typed_stage == other.typed_stage) && 0 || -1) || super
     end
 
     def render_iteration

data/lib/pubid/iso/transformer.rb

@@ -8,13 +8,47 @@ module Pubid::Iso
       { stage: convert_stage(context[:stage]) }
     end
 
+    rule(supplements: subtree(:supplements)) do |context|
+      context[:supplements] =
+        context[:supplements].map do |supplement|
+          supplement[:typed_stage] = case supplement[:typed_stage]
+                                     when "PDAM"
+                                       "CD Amd"
+                                     when "pDCOR"
+                                       "CD Cor"
+                                     when "FCOR"
+                                       "FDCor"
+                                     when "FPDAM"
+                                       "DAmd"
+                                     when "FDAM"
+                                       "FDAmd"
+                                     else
+                                       supplement[:typed_stage]
+                                     end
+    #       Supplement.new(
+    #         number: supplement[:number],
+    #         year: supplement[:year],
+    #         typed_stage:
+    #           case supplement[:typed_stage]
+    #           when "FCOR"
+    #             "FDCor"
+    #           else
+    #             supplement[:typed_stage]
+    #           end,
+    #         iteration: supplement[:iteration]
+    #       )
+          supplement
+        end
+      context
+    end
+
     rule(amendments: subtree(:amendments)) do |context|
       context[:amendments] =
         context[:amendments].map do |amendment|
           Amendment.new(
             number: amendment[:number],
             year: amendment[:year],
-            stage: amendment[:stage] && convert_stage(amendment[:stage]),
+            typed_stage: amendment[:stage] && convert_stage(amendment[:stage]),
             iteration: amendment[:iteration])
         end
       context
@@ -26,7 +60,7 @@ module Pubid::Iso
           Corrigendum.new(
             number: corrigendum[:number],
             year: corrigendum[:year],
-            stage: corrigendum[:stage] && convert_stage(corrigendum[:stage]),
+            typed_stage: corrigendum[:stage] && convert_stage(corrigendum[:stage]),
             iteration: corrigendum[:iteration])
         end
       context
@@ -124,12 +158,17 @@ module Pubid::Iso
                "FDIS"
              when "Fpr"
                "PRF"
-             when "pD", "PD"
-               "CD"
+             # when "pD", "PD"
+             #   "CD"
+             when "PDTR"
+               "CD TR"
+             when "PDTS"
+               "CD TS"
              else
                code
              end
-      Stage.new(abbr: (russian_code || code))
+      russian_code || code
+      # Stage.new(abbr: (russian_code || code))
     end
 
     def self.convert_language(code)

data/lib/pubid/iso/type.rb

@@ -67,5 +67,11 @@ module Pubid::Iso
 
       type == other.type
     end
+
+    def self.has_type?(type)
+      TYPE_NAMES.any? do |_, v|
+        v[:short] == type
+      end
+    end
   end
 end

data/lib/pubid/iso/typed_stage.rb

@@ -0,0 +1,204 @@
+module Pubid::Iso
+  class TypedStage
+    attr_accessor :type, :stage, :typed_stage
+
+    TYPED_STAGES = {
+      dtr: {
+        abbr: "DTR",
+        type: :tr,
+        name: "Draft Technical Report",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
+      },
+      dis: {
+        abbr: "DIS",
+        type: :is,
+        name: "Draft International Standard",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93],
+      },
+      dts: {
+        abbr: "DTS",
+        type: :ts,
+        name: "Draft Technical Specification",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
+      },
+      fdts: {
+        abbr: "FDTS",
+        type: :ts,
+        name: "Final Draft Technical Specification",
+        harmonized_stages: %w[50.00 50.20 50.60 50.92],
+      },
+      fdtr: {
+        abbr: "FDTR",
+        type: :tr,
+        name: "Final Draft Technical Report",
+        harmonized_stages: %w[50.00 50.20 50.60 50.92],
+      },
+      fdis: {
+        abbr: "FDIS",
+        type: :is,
+        name: "Final Draft International Standard",
+        harmonized_stages: %w[50.00 50.20 50.60 50.92],
+      },
+      dpas: {
+        abbr: "DPAS",
+        type: :pas,
+        name: "Publicly Available Specification Draft",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
+      },
+      damd: {
+        abbr: { short: "DAM", long: "DAmd" },
+        type: :amd,
+        name: "Draft Amendment",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
+      },
+      dcor: {
+        abbr: { short: "DCOR", long: "DCor" },
+        type: :cor,
+        name: "Draft Corrigendum",
+        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
+      },
+      fdamd: {
+        abbr: { short: "FDAM", long: "FDAmd" },
+        type: :amd,
+        name: "Final Draft Amendment",
+        harmonized_stages: %w[50.00 50.20 50.60 50.92],
+      },
+      fdcor: {
+        abbr: { short: "FDCOR", long: "FDCor" },
+        type: :cor,
+        name: "Final Draft Corrigendum",
+        harmonized_stages: %w[50.00 50.20 50.60 50.92],
+      },
+    }.freeze
+
+    # @param type [Symbol,Type] eg. :tr, Type.new(:tr)
+    # @param stage [Symbol,Stage] eg. :CD, Stage.new(abbr: :CD)
+    def initialize(abbr: nil, type: nil, stage: nil)
+      @type = type.is_a?(Type) ? type : Type.new(type) if type
+      @stage = stage.is_a?(Stage) ? stage : Stage.new(abbr: stage) if stage
+
+      if abbr
+        raise Errors::TypeStageInvalidError, "#{abbr} is not valid typed stage" unless TYPED_STAGES.key?(abbr)
+        assign_abbreviation(abbr)
+      elsif !@stage.nil?
+        # lookup for typed stage
+        @typed_stage = lookup_typed_stage
+      end
+    end
+
+    def lookup_typed_stage
+      return nil unless @stage
+
+      TYPED_STAGES.each do |typed_stage, values|
+        if values[:harmonized_stages].include?(@stage.harmonized_code.to_s) && values[:type] == @type&.type
+          return typed_stage
+        end
+      end
+      nil
+    end
+
+    # Assigns type and stage according to provided typed stage abbreviation
+    # @param abbr [Symbol] eg. :dtr, :damd, :dis
+    def assign_abbreviation(abbr)
+      @typed_stage = if TYPED_STAGES.key?(abbr.downcase.to_sym)
+                       abbr.downcase.to_sym
+                     else
+                       TYPED_STAGES.select do |_, v|
+                         if v[:abbr].is_a?(Hash)
+                           v[:abbr].values.include?(abbr)
+                         else
+                           v[:abbr] == abbr
+                         end
+                       end.keys.first
+                     end
+
+      @type = Type.new(TYPED_STAGES[@typed_stage][:type])
+      @stage = Stage.new(harmonized_code: HarmonizedStageCode.new(TYPED_STAGES[@typed_stage][:harmonized_stages]))
+    end
+
+    # Render typed stage
+    # @param stage_format_long [Boolean] render stage in long or short format
+    def to_s(stage_format_long = true)
+      # return "" if @type == :amd || @type == :cor
+      if @typed_stage
+        if TYPED_STAGES[@typed_stage][:abbr].is_a?(Hash)
+          return TYPED_STAGES[@typed_stage][:abbr][stage_format_long ? :long : :short]
+        else
+          return TYPED_STAGES[@typed_stage][:abbr]
+        end
+      end
+
+      result = (@stage && @stage.abbr != "IS") ? "#{@stage.abbr}" : ""
+      result += " " if !result.empty? && @type && stage_format_long
+      result + if stage_format_long
+                 "#{@type&.to_s}"
+               else
+                 if @type == :amd
+                   "AM"
+                 elsif @type == :cor
+                   "COR"
+                 else
+                   "#{@type&.to_s}"
+                 end
+               end
+    end
+
+    # Check if typed stage listed in TYPED_STAGES constant
+    # @param typed_stage [String,Symbol] typed stage abbreviation, eg. "DTS", :dts, "DAmd", :damd
+    def self.has_typed_stage?(typed_stage)
+      return true if TYPED_STAGES.key?(typed_stage)
+
+      TYPED_STAGES.any? do |_, v|
+        if v[:abbr].is_a?(Hash)
+          v[:abbr].values.include?(typed_stage)
+        else
+          v[:abbr] == typed_stage
+        end
+      end
+    end
+
+    # Assigns stage or type or typed stage or stage and type depending on provided string
+    # @param stage_or_typed_stage [String, Stage] eg. "DTR", "CD", Stage.new(:CD), "TR", "CD Amd", :dtr
+    def parse_stage(stage_or_typed_stage)
+      if self.class.has_typed_stage?(stage_or_typed_stage)
+        return assign_abbreviation(stage_or_typed_stage)
+      end
+
+      if stage_or_typed_stage.is_a?(Stage)
+        @stage = stage_or_typed_stage
+      elsif stage_or_typed_stage.is_a?(String) && stage_or_typed_stage.split.count == 2 &&
+          Stage.has_stage?(stage_or_typed_stage.split.first)
+        # stage and type ("CD Amd")
+        @stage = Stage.parse(stage_or_typed_stage.split.first)
+        @type = Type.parse(stage_or_typed_stage.split.last)
+      elsif Type.has_type?(stage_or_typed_stage)
+        @type = Type.parse(stage_or_typed_stage)
+      elsif Stage.has_stage?(stage_or_typed_stage)
+        @stage = Stage.parse(stage_or_typed_stage.to_s)
+      else
+        raise Errors::TypeStageParseError, "cannot parse typed stage or stage"
+      end
+      @typed_stage = lookup_typed_stage
+    end
+
+    # Parse stage or typed stage
+    # @return [TypedStage] typed stage object with parsed stage and typed stage
+    def self.parse(stage_or_typed_stage)
+      return stage_or_typed_stage if stage_or_typed_stage.is_a?(TypedStage)
+
+      typed_stage = new
+      typed_stage.parse_stage(stage_or_typed_stage)
+      typed_stage
+    end
+
+    def name
+      TYPED_STAGES[@typed_stage][:name]
+    end
+
+    def ==(other)
+      return false if other.nil?
+
+      type == other.type && typed_stage == other.typed_stage && stage == other.stage
+    end
+  end
+end

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.2.2".freeze
+    VERSION = "0.3.0".freeze
   end
 end

data/lib/pubid/iso.rb

@@ -12,6 +12,7 @@ require "pubid-core"
 require_relative "iso/errors"
 require_relative "iso/stage"
 require_relative "iso/type"
+require_relative "iso/typed_stage"
 require_relative "iso/harmonized_stage_code"
 require_relative "iso/parser"
 require_relative "iso/transformer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-iso
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-26 00:00:00.000000000 Z
+date: 2022-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
 description: Library to generate, parse and manipulate ISO PubID.
 email:
 - open.source@ribose.com
@@ -139,6 +139,7 @@ files:
 - lib/pubid/iso/supplement.rb
 - lib/pubid/iso/transformer.rb
 - lib/pubid/iso/type.rb
+- lib/pubid/iso/typed_stage.rb
 - lib/pubid/iso/version.rb
 homepage: https://github.com/metanorma/pubid-iso
 licenses: