pubid-iso 0.1.12 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e97d39eae4c4c0962361910084b0ba9ed9613a01761214d2f4a0750e0c71fe39
-  data.tar.gz: 0b41fc99349db1c5c5672e690305561e01dac3503d7c226b049bada4fcf857b7
+  metadata.gz: 93b04a876f8ee73e80af8c49af1efc223d1b63a4d8a6b6b679a114d77befcc73
+  data.tar.gz: c39834a8f5290dc71d8bbcd79801e3313c1c888715040a7d67fbbda116d7572e
 SHA512:
-  metadata.gz: 7859c8ac83fc94369f1fab9fc6d4c7529cc49d35a5a09c2fa34dda3b95b2d21d1cd5917e277e6c63bbf96ec174496494ca328f8fff0d995e59ae160423d0ba01
-  data.tar.gz: 7a104ec181c49142996ef2133648a9145a2c0a0d01a05348abddf362285327d915e59d0b283913113b03bd343ee44f5f5de5265ba111ad21ed2da25bffee2ef8
+  metadata.gz: 3bef9b0e5791702f0bcf3c291639d78cb3cd0319d94345b953a0e3608b22b895f019ee75bdcc742c78007281392be6cd2d60081fbe0a81cec9109de59fc31005
+  data.tar.gz: eb469ae1abc30c718355173cab16ee1b80cf1386adc1e65fbd5ba96b493f7c7ee9abdd0cab0612ec34159214524465d8323007ba3fd344a0ec3d2b611d6718de

data/README.adoc

@@ -12,8 +12,7 @@ identifiers.
 . generate language specific PubID
 . generate dated vs undated PubIDs
 
-=== Usage
-
+=== Usage samples
 
 [source,ruby]
 ----
@@ -25,12 +24,143 @@ pubid.to_s
 => "ISO 1234"
 ----
 
-Available attributes:
+==== With coopublisher
+
+[source,ruby]
+----
+pubid = Pubid::Iso::Identifier.new(publisher: "ISO", copublisher: "IEC", number: 123)
+pubid.to_s
+
+=> "ISO/IEC 1234"
+----
+
+==== With document type
+
+[source,ruby]
+----
+pubid = Pubid::Iso::Identifier.new(publisher: "ISO", type: "TR", number: 123)
+pubid.to_s
+
+=> "ISO/TR 1234"
+----
+
+==== With stage
+
+[source,ruby]
+----
+pubid = Pubid::Iso::Identifier.new(publisher: "ISO", stage: :WD, number: 123)
+pubid.to_s
+
+=> "ISO/WD 1234"
+----
+
+==== With part number
+
+[source,ruby]
+----
+pubid = Pubid::Iso::Identifier.new(publisher: "ISO", number: 123, part: 1)
+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]
+----
+> pubid = Pubid::Iso::Identifier.new(
+  number: "8601",
+  part: "1",
+  year: 2019,
+  edition: 1,
+  amendment: {number: "1", year: "2021", stage: "DIS"}
+)
+> pubid.to_s(:ref_num_short)
+=> "ISO 8601-1:2019/DAM 1:2021(E)"
+> pubid.to_s(:ref_num_long)
+=> "ISO 8601-1:2019/DAmd 1:2021(en)"
+> pubid.to_s(:ref_dated)
+=> "ISO 8601-1:2019/DAM 1:2021"
+> pubid.to_s(:ref_dated_long)
+=> "ISO 8601-1:2019/DAmd 1:2021"
+> pubid.to_s(:ref_undated)
+=> "ISO 8601-1:2019/DAM 1"
+> pubid.to_s(:ref_undated_long)
+=> "ISO 8601-1:2019/DAmd 1"
+----
+
+==== Using language specific rendering
+[source,ruby]
+----
+> pubid = Pubid::Iso::Identifier.parse("ISO/FDIS 26000:2010(ru)")
+> pubid.to_s(format: :ref_num_long, lang: :russian)
+=> "ИСО/ОПМС 26000:2010(ru)"
+> pubid = Pubid::Iso::Identifier.parse("ISO/IEC Guide 71:2001(fr)")
+> pubid.to_s(format: :ref_num_long, lang: :french)
+=> "Guide ISO/CEI 71:2001(fr)"
+----
+
+==== Rendering URN identifier
+[source,ruby]
+----
+> pubid = Pubid::Iso::Identifier.new(
+  number: "8601",
+  part: "1",
+  year: 2019,
+  edition: 1,
+  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"
+----
 
-`number`, `publisher`, `copublisher`, `part`, `type`, `year`, `edition`, `language`, `amendments`,
-`corrigendums`, `stage`, `substage`, `iteration`, `supplements`, `amendment_stage`, `corrigendum_stage`,
-`joint_document`, `tctype`, `sctype`, `wgtype`, `tcnumber`, `scnumber`, `wgnumber`, `urn_stage`,
-`dir`, `dirtype`, `supplement`
+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/errors.rb

@@ -3,9 +3,14 @@ module Pubid::Iso
     class ParseError < StandardError; end
     class PublishedIterationError < StandardError; end
     class HarmonizedStageCodeInvalidError < StandardError; end
-    class CodeInvalidError < StandardError; end
+    class StageInvalidError < StandardError; end
     class IsStageIterationError < StandardError; end
+    class IterationWithoutStageError < StandardError; end
     class WrongFormat < StandardError; end
-    class SupplementWithoutYearError < 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
   end
 end

data/lib/pubid/iso/harmonized_stage_code.rb

@@ -53,22 +53,36 @@ module Pubid::Iso
     }
 
     STAGES_NAMES = {
-      approval: "50"
-    }
+      preliminary: "00",
+      proposal: "10",
+      preparatory: "20",
+      committee: "30",
+      enquiry: "40",
+      approval: "50",
+      publication: "60",
+      review: "90",
+      withdrawal: "95",
+    }.freeze
 
     SUBSTAGES_NAMES = {
-      registration: "00"
-    }
+      registration: "00",
+      start_of_main_action: "20",
+      completion_of_main_action: "60",
+      repeat_an_earlier_phase: "92",
+      repeat_current_phase: "93",
+      abandon: "98",
+      proceed: "99",
+    }.freeze
 
-    def initialize(stage, substage = nil)
+    def initialize(stage, substage = "00")
       # when stage is stage name
       if STAGES_NAMES.key?(stage)
         @stage = STAGES_NAMES[stage]
         @substage = SUBSTAGES_NAMES[substage]
       else
         # stage is number
-        validate_stage(stage, substage)
         @stage, @substage = stage, substage
+        validate_stage(stage, substage)
       end
     end
 
@@ -77,8 +91,7 @@ module Pubid::Iso
       raise Errors::HarmonizedStageCodeInvalidError if Integer(stage).nil?
 
       # raise an error when substage wrong
-      raise Errors::HarmonizedStageCodeInvalidError if stage == "90" && substage == "00"
-      # raise Errors::HarmonizedStageCodeNotValidError if stage.to_i
+      raise Errors::HarmonizedStageCodeInvalidError unless DESCRIPTIONS.key?(to_s)
     end
 
     def to_s

data/lib/pubid/iso/identifier.rb

@@ -3,15 +3,15 @@ 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
 
     # Creates new identifier from options provided, includes options from
     # Pubid::Core::Identifier#initialize
     #
-    # @param stage [Stage] stage
-    # @param urn_stage [Float] numeric stage for URN rendering
+    # @param stage [Stage, Symbol, String] stage, e.g. "PWI", "NP", "50.00", Stage.new(abbr: :WD)
     # @param iteration [Integer] document iteration, eg. "1", "2", "3"
     # @param joint_document [Identifier] joint document
     # @param supplement [Supplement] supplement
@@ -22,33 +22,48 @@ 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, **opts)
+                   corrigendums: nil, type: nil, base: nil, **opts)
       super(**opts.merge(number: number, publisher: publisher, year: year,
                          amendments: amendments, corrigendums: corrigendums))
 
-      if (amendments || corrigendums) && year.nil?
-        raise Errors::SupplementWithoutYearError, "Cannot apply supplement to document without edition year"
+      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?(Symbol) || stage.is_a?(String)) ? Stage.new(abbr: stage) : stage
+        @stage = stage.is_a?(Stage) ? stage : Stage.parse(stage)
+
         if @stage.abbr == "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"
+        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
@@ -57,6 +72,8 @@ 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
+      @type = type.is_a?(Type) ? type : Type.new(type) unless type.nil?
     end
 
     def self.parse_from_title(title)
@@ -69,6 +86,38 @@ 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
+
+        supplement = nil
+
+        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
+        end
+
+
+        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) }))
+        end
+
+
+        return supplement if supplement
+
+        new(**identifier_params)
+      end
+
       def get_amendment_class
         Pubid::Iso::Amendment
       end
@@ -90,39 +139,62 @@ module Pubid::Iso
       end
     end
 
+    # Render URN identifier
+    # @return [String] URN identifier
     def urn
-      (@tctype && Renderer::UrnTc || @type == "DIR" && Renderer::UrnDir || Pubid::Iso::Renderer::Urn).new(get_params).render
-    end
-
-    def formatted(format)
-      case format
-      when :ref_num_short
-        to_s(with_language_code: :single, stage_format_long: false)
-      when :ref_num_long
-        to_s(with_language_code: :iso, stage_format_long: true)
-      when :ref_dated
-        to_s(with_language_code: :none, stage_format_long: false)
-      when :ref_dated_long
-        to_s(with_language_code: :none, stage_format_long: true)
-      when :ref_undated
-        to_s(with_language_code: :none, stage_format_long: false, with_date: false)
-      when :ref_undated_long
-        to_s(with_language_code: :none, stage_format_long: true, with_date: false)
-      else
-        raise Errors::WrongFormat, "#{format} is not available"
+      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
     end
 
     # Renders pubid identifier
     #
     # @param lang [:french,:russian] use language specific renderer
     # @param with_date [Boolean] render identifier with date
-    # @param with_language_code [:iso,:single] use iso format or single language code for rendering
     # @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
+    #   :ref_dated -- reference dated: no language code + short form (DAM) + dated
+    #   :ref_dated_long -- reference dated long: no language code + short form (DAM) + dated
+    #   :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_date: true, with_language_code: :iso,
-             with_edition: true, stage_format_long: true)
+    def to_s(lang: nil, with_date: true,
+             with_edition: false, with_prf: false,
+             format: :ref_dated_long)
+      with_language_code = nil
+      stage_format_long = nil
+      if format
+        case format
+        when :ref_num_short
+          with_language_code = :single
+          stage_format_long = false
+        when :ref_num_long
+          with_language_code = :iso
+          stage_format_long = true
+        when :ref_dated
+          with_language_code = :none
+          stage_format_long = false
+        when :ref_dated_long
+          with_language_code = :none
+          stage_format_long = true
+        when :ref_undated
+          with_language_code = :none
+          stage_format_long = false
+          with_date = false
+        when :ref_undated_long
+          with_language_code = :none
+          stage_format_long = true
+          with_date = false
+        else
+          raise Errors::WrongFormat, "#{format} is not available"
+        end
+      end
       case lang
       when :french
         Renderer::French.new(get_params)
@@ -131,16 +203,27 @@ module Pubid::Iso
       else
         if @tctype
           Renderer::Tc.new(get_params)
-        elsif @type == "DIR"
+        elsif @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) +
-        if @joint_document && @type != "DIR"
+                 stage_format_long: stage_format_long, with_prf: with_prf) +
+        if @joint_document && @type != :dir
           "|#{@joint_document}"
         end.to_s
     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]
+    end
+
+    # Return typed stage name, eg. "Final Draft Technical Report" for "FDTR"
+    def typed_stage_name
+      "#{stage.short_name} #{type.to_s(:long)}"
+    end
   end
 end

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

@@ -1,24 +1,56 @@
 module Pubid::Iso::Renderer
   class Base < Pubid::Core::Renderer::Base
+    attr_accessor :prerendered_params
+
+    TYPE_VALUES = {
+      tr: "TR",
+      ts: "TS",
+      isp: "ISP",
+      guide: "Guide",
+      pas: "PAS",
+      dpas: "DPAS",
+    }.freeze
+
+    # Prerender parameters
+    def prerender(with_edition: true, **args)
+      @params[:type_stage] = @params.slice(:stage, :type) if @params[:stage] || @params[:type]
+      super
+    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)
-      params = prerender_params(@params,
-                                { with_edition: with_edition }.merge(args))
-      # render empty string when the key is not exist
-      params.default = ""
-
-      render_identifier(params)
+      super(**args.merge({ with_edition: with_edition }))
     end
 
     def render_identifier(params)
-      if @params[:type] && @params[:stage] && %w(DIS FDIS).include?(@params[:stage].abbr)
-        render_base(params, " #{render_short_stage(@params[:stage].abbr)}#{@params[:type]}")
+      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) +
+        ("%{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
-        render_base(params, "%{type}%{stage}" % params)
-      end +
-        "%{part}%{iteration}%{year}%{edition}%{amendments}%{corrigendums}%{language}" % params
+        # when only type or stage
+        "#{type}#{stage}"
+      end
     end
 
     def render_short_stage(stage)
@@ -30,20 +62,10 @@ module Pubid::Iso::Renderer
       end
     end
 
-    def render_type(type, opts, params)
-      if params[:copublisher]
-        " #{type}"
-      else
-        "/#{type}"
-      end
-    end
+    def render_stage(stage, opts, _params)
+      return if stage.nil? || (stage.abbr == "PRF" and !opts[:with_prf]) || stage.abbr == "IS"
 
-    def render_stage(stage, opts, params)
-      if params[:copublisher]
-        " #{stage.abbr}"
-      else
-        "/#{stage.abbr}"
-      end
+      stage.abbr
     end
 
     def render_edition(edition, opts, _params)

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

@@ -1,8 +1,16 @@
 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
+    end
+
     def render_identifier(params)
-      if params[:type] == " Guide"
-        params[:type] = ""
+      if params[:type] == :guide
+        params[:type] = nil
         "Guide #{super(params)}"
       else
         super

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

@@ -18,9 +18,17 @@ 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
+    end
+
     def render_identifier(params)
-      if params[:type] == " Guide"
-        params[:type] = ""
+      if params[:type] == :guide
+        params[:type] = nil
         "Руководство #{super(params)}"
       else
         super
@@ -43,11 +51,7 @@ module Pubid::Iso::Renderer
     end
 
     def render_stage(stage, _opts, params)
-      if params[:copublisher]
-        " #{STAGE[stage.abbr]}"
-      else
-        "/#{STAGE[stage.abbr]}"
-      end
+      STAGE[stage.abbr] unless stage.nil?
     end
 
     def render_corrigendums(corrigendums, _opts, _params)

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

@@ -10,13 +10,33 @@ module Pubid::Iso::Renderer
                PRF: 50,
                IS: 60 }.freeze
 
+    def prerender(with_edition: true, **args)
+      @params[:type_stage] = @params.slice(:stage, :type) if @params[:stage] || @params[:type]
+      super
+    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 }))
+    end
+
     def render_identifier(params)
       render_base(params) + "%{stage}"\
-      "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}%{language}" % params
+      "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}" % params
     end
 
     def render_stage(stage, _opts, params)
       ":stage-#{stage.harmonized_code}"
     end
+
+    def render_type(type, _, _)
+      ":#{type.to_s.downcase}"
+    end
+
+    def render_year(year, _opts, _params)
+      ":#{year}"
+    end
   end
 end

data/lib/pubid/iso/stage.rb

@@ -4,30 +4,103 @@ module Pubid::Iso
 
     STAGES = { PWI: "00.00",
                NP: "10.00",
-               AWI: "20.00",
-               WD: "20.20",
+               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: "50.00",
-               IS: "60.00" }.freeze
+               PRF: "60.00",
+               IS: "60.60" }.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
-    # @param harmonized_code [HarmonizedStageCode]
+    # @param harmonized_code [String, Float, HarmonizedStageCode]
     def initialize(abbr: nil, harmonized_code: nil)
-      @abbr = abbr
-      @harmonized_code = harmonized_code
+      @abbr = abbr&.to_s
 
       if harmonized_code
-        # @abbr = STAGES.select { |k,v| v == @harmonized_code.to_s }.first&.first
-        @abbr ||= STAGES.key(@harmonized_code.to_s)
+        @harmonized_code = if harmonized_code.is_a?(HarmonizedStageCode)
+                             harmonized_code
+                           else
+                             HarmonizedStageCode.new(*harmonized_code.to_s.split("."))
+                           end
+        @abbr ||= lookup_abbr(@harmonized_code.to_s) || lookup_abbr("#{@harmonized_code.stage}.00")
       end
 
       if abbr
-        raise Errors::CodeInvalidError, "#{abbr} is not valid stage" unless STAGES.key?(abbr.to_sym)
+        raise Errors::StageInvalidError, "#{abbr} is not valid stage" unless STAGES.key?(abbr.to_sym)
+
+        @harmonized_code ||= HarmonizedStageCode.new(*lookup_code(abbr).split("."))
+      end
+    end
 
-        @harmonized_code ||= HarmonizedStageCode.new(*STAGES[abbr.to_sym].split("."))
+    # Lookup for abbreviated code by numeric stage code
+    # @param lookup_code [String] stage code, e.g. "00.00", "20.20"
+    def lookup_abbr(lookup_code)
+      STAGES.each do |abbr, codes|
+        case codes
+        when Array
+          codes.each do |code|
+            return abbr if code == lookup_code
+          end
+        when lookup_code
+          return abbr
+        end
       end
+
+      nil
+    end
+
+    def lookup_code(lookup_abbr)
+      code = STAGES[lookup_abbr.to_sym]
+      code.is_a?(Array) ? code.first : code
+    end
+
+    def self.parse(stage)
+      if /\A[\d.]+\z/.match?(stage)
+        Stage.new(harmonized_code: stage)
+      else
+        raise Errors::StageInvalidError unless stage.is_a?(Symbol) || stage.is_a?(String)
+
+        Stage.new(abbr: stage)
+      end
+    end
+
+    # Compares one stage with another
+    def ==(other)
+      other&.harmonized_code == harmonized_code
+    end
+
+    # Return stage name, eg. "Draft International Standard" for "DIS"
+    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

@@ -2,14 +2,15 @@ module Pubid::Iso
   class Supplement < Pubid::Core::Supplement
     attr_accessor :stage, :publisher, :edition, :iteration
 
-    # @param stage [Stage] stage, e.g. "PWI", "NP"
-    # @param publisher [String] publisher, e.g. "ISO", "IEC"
+    # @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)
       super(**args)
-      @stage = (stage.is_a?(Symbol) || stage.is_a?(String)) ? Stage.new(abbr: stage) : stage
+      @stage = stage.is_a?(Stage) ? stage : Stage.parse(stage) if stage
+      # for DIR identifiers only
       @publisher = publisher.to_s
       @edition = edition&.to_i
       @iteration = iteration&.to_i

data/lib/pubid/iso/transformer.rb

@@ -44,21 +44,26 @@ module Pubid::Iso
 
     rule(type: simple(:type)) do
       russian_type = Renderer::Russian::TYPE.key(type.to_s)
-      { type: russian_type&.to_s ||
-        case type
-        # XXX: can't put 2 alternative Russian translations to dictionary, temporary hack
-        when "GUIDE", "Руководства"
-          "Guide"
-        when "ТС"
-          "TS"
-        when "ТО"
-          "TR"
-        when "Directives Part", "Directives, Part", "Directives,"
-          "DIR"
-        else
-          type
-        end
-      }
+      { type: Type.new(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
+                        when "PAS"
+                          :pas
+                        when "DPAS"
+                          :dpas
+                        when "DIR"
+                          :dir
+                        else
+                          type
+                        end) }
     end
 
     rule(copublisher: simple(:copublisher)) do

data/lib/pubid/iso/type.rb

@@ -0,0 +1,71 @@
+module Pubid::Iso
+  class Type
+    attr_accessor :type
+
+    TYPE_NAMES = {
+      tr: {
+        long: "Technical Report",
+        short: "TR",
+      },
+      ts: {
+        long: "Technical Specification",
+        short: "TS",
+      },
+      is: {
+        long: "International Standard",
+        short: "IS",
+      },
+      pas: {
+        long: "Publicly Available Specification",
+        short: "PAS",
+      },
+      isp: {
+        long: "International Standardized Profiles",
+        short: "ISP",
+      },
+      guide: {
+        long: "Guide",
+        short: "Guide",
+      },
+      dir: {
+        long: "Directives",
+        short: "DIR",
+      },
+      dpas: {
+        long: "Publicly Available Specification Draft",
+        short: "DPAS",
+      },
+      cor: {
+        short: "Cor",
+      },
+      amd: {
+        short: "Amd",
+      },
+    }.freeze
+
+    # Create new type
+    # @param type [Symbol]
+    def initialize(type)
+      raise Errors::WrongTypeError, "#{type} type is not available" unless TYPE_NAMES.key?(type)
+
+      @type = type
+    end
+
+    def self.parse(type_string)
+      TYPE_NAMES.each do |type, values|
+        return new(type) if values[:short] == type_string
+      end
+      raise Errors::ParseTypeError, "Cannot parse '#{type_string}' type"
+    end
+
+    def to_s(format = :short)
+      TYPE_NAMES[type][format]
+    end
+
+    def ==(other)
+      return type == other if other.is_a?(Symbol)
+
+      type == other.type
+    end
+  end
+end

data/lib/pubid/iso/version.rb

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

data/lib/pubid/iso.rb

@@ -11,6 +11,7 @@ end
 require "pubid-core"
 require_relative "iso/errors"
 require_relative "iso/stage"
+require_relative "iso/type"
 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.1.12
+  version: 0.2.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-19 00:00:00.000000000 Z
+date: 2022-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -138,6 +138,7 @@ files:
 - lib/pubid/iso/stage.rb
 - lib/pubid/iso/supplement.rb
 - lib/pubid/iso/transformer.rb
+- lib/pubid/iso/type.rb
 - lib/pubid/iso/version.rb
 homepage: https://github.com/metanorma/pubid-iso
 licenses: