pubid-iso 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d60d5581ae205f08b23f80682735696086c753587386ab0b7bfcf7ce306e6156
-  data.tar.gz: '08d626a7cbb67820faac3fb9503dce84f21d13fcd8387671d110878de84adc4a'
+  metadata.gz: 93b04a876f8ee73e80af8c49af1efc223d1b63a4d8a6b6b679a114d77befcc73
+  data.tar.gz: c39834a8f5290dc71d8bbcd79801e3313c1c888715040a7d67fbbda116d7572e
 SHA512:
-  metadata.gz: b690e1a4d95efe0ed794ce74c1fef9e320cbb394c473650af6e7fded623ec4f986cb1d4ca463bdeab988be14d82fd14c0f7ec48f51febd8cd98d0ae2cd17a5eb
-  data.tar.gz: 33ca94206cb4b8812956fd3d1c146c77a5a5d8e24cd55e002405e6acc28b54b5433f4caf23e59bab5320b4189a4fb78c469696218995538d36600a1124abe341
+  metadata.gz: 3bef9b0e5791702f0bcf3c291639d78cb3cd0319d94345b953a0e3608b22b895f019ee75bdcc742c78007281392be6cd2d60081fbe0a81cec9109de59fc31005
+  data.tar.gz: eb469ae1abc30c718355173cab16ee1b80cf1386adc1e65fbd5ba96b493f7c7ee9abdd0cab0612ec34159214524465d8323007ba3fd344a0ec3d2b611d6718de

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/errors.rb

@@ -5,9 +5,12 @@ module Pubid::Iso
     class HarmonizedStageCodeInvalidError < 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
   end
 end

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, Symbol, String] stage, e.g. "PWI", "NP", "50.00", Stage.new(abbr: :WD)
-    # @param urn_stage [Float] numeric stage for URN rendering
     # @param iteration [Integer] document iteration, eg. "1", "2", "3"
     # @param joint_document [Identifier] joint document
     # @param supplement [Supplement] supplement
@@ -22,26 +22,30 @@ 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, **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 %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)
@@ -50,14 +54,16 @@ module Pubid::Iso
           raise Errors::IsStageIterationError, "IS stage document cannot have iteration"
         end
 
-        if @stage.abbr == "FDIS" && type == "PAS"
+        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
@@ -66,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)
@@ -78,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
@@ -102,10 +142,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 +155,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 +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, with_prf: with_prf) +
-        if @joint_document && @type != "DIR"
+        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,60 +1,71 @@
 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]
-        if %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
-          if params[:copublisher] && !params[:copublisher].empty?
-            render_base(params, "%{type}%{stage}" % params)
-          else
-            render_base(params, "%{stage}%{type}" % params)
-          end
+          "#{stage} #{type}"
         end
       else
-        render_base(params, "%{type}%{stage}" % params)
-      end +
-        "%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}%{language}" % params
+        # when only type or stage
+        "#{type}#{stage}"
+      end
     end
 
     def render_short_stage(stage)
-      (params[:copublisher] ? " " : "/") +
-        case stage
-        when "DIS"
-          "D"
-        when "FDIS"
-          "FD"
-        end
-    end
-
-    def render_type(type, opts, params)
-      if params[:copublisher] || (params[:stage] && params[:stage].abbr != "IS")
-        " #{type}"
-      else
-        "/#{type}"
+      case stage
+      when "DIS"
+        "D"
+      when "FDIS"
+        "FD"
       end
     end
 
-    def render_stage(stage, opts, params)
-      return if (stage.abbr == "PRF" and !opts[:with_prf]) || stage.abbr == "IS"
+    def render_stage(stage, opts, _params)
+      return if stage.nil? || (stage.abbr == "PRF" and !opts[:with_prf]) || stage.abbr == "IS"
 
-      if params[:copublisher]
-        " #{stage.abbr}"
-      else
-        "/#{stage.abbr}"
-      end
+      stage.abbr
     end
 
     def render_edition(edition, opts, _params)

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

@@ -2,7 +2,7 @@ module Pubid::Iso::Renderer
   class Dir < Base
 
     def render_identifier(params)
-      res = ("%{publisher}%{copublisher} DIR%{dirtype}%{number}%{year}%{supplement}%{language}" % params)
+      res = ("%{publisher}%{copublisher} DIR%{dirtype}%{number}%{year}%{supplement}" % params)
 
       if params.key?(:joint_document)
         joint_params = prerender_params(params[:joint_document].get_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

@@ -13,6 +13,28 @@ module Pubid::Iso
                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 [String, Float, HarmonizedStageCode]
     def initialize(abbr: nil, harmonized_code: nil)
@@ -70,5 +92,15 @@ module Pubid::Iso
     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

@@ -3,13 +3,14 @@ module Pubid::Iso
     attr_accessor :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"
+    # @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?(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.2.1".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.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-29 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: