pubid-iso 0.1.12 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e97d39eae4c4c0962361910084b0ba9ed9613a01761214d2f4a0750e0c71fe39
-  data.tar.gz: 0b41fc99349db1c5c5672e690305561e01dac3503d7c226b049bada4fcf857b7
+  metadata.gz: d60d5581ae205f08b23f80682735696086c753587386ab0b7bfcf7ce306e6156
+  data.tar.gz: '08d626a7cbb67820faac3fb9503dce84f21d13fcd8387671d110878de84adc4a'
 SHA512:
-  metadata.gz: 7859c8ac83fc94369f1fab9fc6d4c7529cc49d35a5a09c2fa34dda3b95b2d21d1cd5917e277e6c63bbf96ec174496494ca328f8fff0d995e59ae160423d0ba01
-  data.tar.gz: 7a104ec181c49142996ef2133648a9145a2c0a0d01a05348abddf362285327d915e59d0b283913113b03bd343ee44f5f5de5265ba111ad21ed2da25bffee2ef8
+  metadata.gz: b690e1a4d95efe0ed794ce74c1fef9e320cbb394c473650af6e7fded623ec4f986cb1d4ca463bdeab988be14d82fd14c0f7ec48f51febd8cd98d0ae2cd17a5eb
+  data.tar.gz: 33ca94206cb4b8812956fd3d1c146c77a5a5d8e24cd55e002405e6acc28b54b5433f4caf23e59bab5320b4189a4fb78c469696218995538d36600a1124abe341

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,96 @@ 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"
+----
+
+==== 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,
+  amendment: {number: "1", year: "2021", stage: "DIS"}
+)
+> pubid.urn
+=> "urn:iso:std:iso:8601:-1:ed-1:amd:2021:v1"
+----
 
-`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,11 @@ 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 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
   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

@@ -10,7 +10,7 @@ module Pubid::Iso
     # Creates new identifier from options provided, includes options from
     # Pubid::Core::Identifier#initialize
     #
-    # @param stage [Stage] stage
+    # @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
@@ -22,6 +22,10 @@ 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"
+    # @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
     # @see Supplement
     # @see Identifier
     # @see Pubid::Core::Identifier
@@ -32,18 +36,23 @@ module Pubid::Iso
                    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, **opts)
       super(**opts.merge(number: number, publisher: publisher, year: year,
-                         amendments: amendments, corrigendums: corrigendums))
+                         amendments: amendments, corrigendums: corrigendums, type: type))
 
-      if (amendments || corrigendums) && year.nil?
-        raise Errors::SupplementWithoutYearError, "Cannot apply supplement to document without edition year"
+      if (amendments || corrigendums) && (year.nil? && stage.nil?)
+        raise Errors::SupplementWithoutYearOrStageError, "Cannot apply supplement to document without edition 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
       end
       @iteration = iteration.to_i if iteration
       @supplement = supplement if supplement
@@ -90,39 +99,61 @@ 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 (@amendments || @corrigendums) && !@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
+    # 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)
@@ -137,7 +168,7 @@ module Pubid::Iso
           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) +
+                 stage_format_long: stage_format_long, with_prf: with_prf) +
         if @joint_document && @type != "DIR"
           "|#{@joint_document}"
         end.to_s

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

@@ -13,25 +13,34 @@ module Pubid::Iso::Renderer
     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]}")
+      if @params[:type] && @params[:stage]
+        if %w(DIS FDIS).include?(@params[:stage].abbr)
+          render_base(params, "#{render_short_stage(@params[:stage].abbr)}#{@params[:type]}")
+        else
+          if params[:copublisher] && !params[:copublisher].empty?
+            render_base(params, "%{type}%{stage}" % params)
+          else
+            render_base(params, "%{stage}%{type}" % params)
+          end
+        end
       else
         render_base(params, "%{type}%{stage}" % params)
       end +
-        "%{part}%{iteration}%{year}%{edition}%{amendments}%{corrigendums}%{language}" % params
+        "%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}%{language}" % params
     end
 
     def render_short_stage(stage)
-      case stage
-      when "DIS"
-        "D"
-      when "FDIS"
-        "FD"
-      end
+      (params[:copublisher] ? " " : "/") +
+        case stage
+        when "DIS"
+          "D"
+        when "FDIS"
+          "FD"
+        end
     end
 
     def render_type(type, opts, params)
-      if params[:copublisher]
+      if params[:copublisher] || (params[:stage] && params[:stage].abbr != "IS")
         " #{type}"
       else
         "/#{type}"
@@ -39,6 +48,8 @@ module Pubid::Iso::Renderer
     end
 
     def render_stage(stage, opts, params)
+      return if (stage.abbr == "PRF" and !opts[:with_prf]) || stage.abbr == "IS"
+
       if params[:copublisher]
         " #{stage.abbr}"
       else

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}" % params)
+      res = ("%{publisher}%{copublisher} DIR%{dirtype}%{number}%{year}%{supplement}%{language}" % params)
 
       if params.key?(:joint_document)
         joint_params = prerender_params(params[:joint_document].get_params, {})

data/lib/pubid/iso/stage.rb

@@ -4,30 +4,71 @@ 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
+
 
     # @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
   end
 end

data/lib/pubid/iso/supplement.rb

@@ -2,14 +2,14 @@ module Pubid::Iso
   class Supplement < Pubid::Core::Supplement
     attr_accessor :stage, :publisher, :edition, :iteration
 
-    # @param stage [Stage] stage, e.g. "PWI", "NP"
+    # @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 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
       @publisher = publisher.to_s
       @edition = edition&.to_i
       @iteration = iteration&.to_i

data/lib/pubid/iso/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-iso
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-19 00:00:00.000000000 Z
+date: 2022-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake