pubid-iso 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb49fb09056ae2a808d1fef9f8c1bd107285095fdf3496fad1a2bc9b929d3555
-  data.tar.gz: dfe7c869035871233c2d318bc2eb3b9baa98208cc29ac7e59ac538402850a91a
+  metadata.gz: 5970af41e67f70e22e928d11ac1eabd71d42ca1855f5d3d6254dea8f98844aab
+  data.tar.gz: fface01211f338c08b5ab853be7a48573400e4ca8c290bca9f52e9f6d9361c89
 SHA512:
-  metadata.gz: af2a0127f4cebfa368c26b6e55b651c70dce70d25af68d9d6af8e0e1f56487ec7a73dbadc0abb423d6bb4da26d013754ae7b65e38d897ab8cd79a4c0250fa3f4
-  data.tar.gz: 0afe6817acab2cf6f32164669038e1ab96cbd34763921191f43d8e96606bac0355f000c825b01799ff70aeca8bb1f8539d4a7a5f5b057c4259dec23bc25f07b2
+  metadata.gz: 7b4431cc30c76062a19fc1531ad3e2b57ec2b31b0fc9604672ad9a6a3a5908fc756c256f5552d94b0165b36f5032df084250b68fe7c884435339e6628ec365ba
+  data.tar.gz: b0d2a810b02ceff7044fe35a88a81e3ef2c5feb0a39a8592655136d4b9f0bd6d3ab01e3fb325a743843e057cc816930bfeb09f6cb0d0b45c586b6a8f127bee9d

data/README.adoc

@@ -12,6 +12,25 @@ identifiers.
 . generate language specific PubID
 . generate dated vs undated PubIDs
 
+=== Usage
+
+
+[source,ruby]
+----
+require "pubid-iso"
+
+pubid = Pubid::Iso::Identifier.new(publisher: "ISO", number: 123)
+pubid.to_s
+
+=> "ISO 1234"
+----
+
+Available attributes:
+
+`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`
 
 == Elements of the PubID
 

data/lib/pubid/iso/amendment.rb

@@ -1,9 +1,34 @@
 module Pubid::Iso
   class Amendment < Supplement
-    def render_pubid
+    # @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
-      stage += " " unless stage.size == 0
-      "/#{stage}Amd #{render_pubid_number}"
+      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
     end
 
     def render_urn

data/lib/pubid/iso/corrigendum.rb

@@ -1,9 +1,26 @@
 module Pubid::Iso
   class Corrigendum < Supplement
-    def render_pubid
+    def render_pubid(stage_format_long = true, with_date = true)
       stage = render_pubid_stage
-      stage += " " unless stage.size == 0
-      "/#{stage}Cor #{render_pubid_number}"
+      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
     end
 
     def render_urn

data/lib/pubid/iso/errors.rb

@@ -1,5 +1,11 @@
 module Pubid::Iso
   module Errors
     class ParseError < StandardError; end
+    class PublishedIterationError < StandardError; end
+    class HarmonizedStageCodeInvalidError < StandardError; end
+    class CodeInvalidError < StandardError; end
+    class IsStageIterationError < StandardError; end
+    class WrongFormat < StandardError; end
+    class SupplementWithoutYearError < StandardError; end
   end
 end

data/lib/pubid/iso/harmonized_stage_code.rb

@@ -0,0 +1,96 @@
+module Pubid::Iso
+  class HarmonizedStageCode
+    include Comparable
+    attr_accessor :stage, :substage
+
+    DESCRIPTIONS = {
+      "00.00" => "Proposal for new project received",
+      "00.20" => "Proposal for new project under review",
+      "00.60" => "Close of review",
+      "00.98" => "Proposal for new project abandoned",
+      "00.99" => "Approval to ballot proposal for new project",
+      "10.00" => "Proposal for new project registered",
+      "10.20" => "New project ballot initiated",
+      "10.60" => "Close of voting",
+      "10.92" => "Proposal returned to submitter for further definition",
+      "10.98" => "New project rejected",
+      "10.99" => "New project approved",
+      "20.00" => "New project registered in TC/SC work programme",
+      "20.20" => "Working draft (WD) study initiated",
+      "20.60" => "Close of comment period",
+      "20.98" => "Project deleted",
+      "20.99" => "WD approved for registration as CD",
+      "30.00" => "Committee draft (CD) registered",
+      "30.20" => "CD study/ballot initiated",
+      "30.60" => "Close of voting/ comment period",
+      "30.92" => "CD referred back to Working Group",
+      "30.98" => "Project deleted",
+      "30.99" => "CD approved for registration as DIS",
+      "40.00" => "DIS registered",
+      "40.20" => "DIS ballot initiated: 12 weeks",
+      "40.60" => "Close of voting",
+      "40.92" => "Full report circulated: DIS referred back to TC or SC",
+      "40.93" => "Full report circulated: decision for new DIS ballot",
+      "40.98" => "Project deleted",
+      "40.99" => "Full report circulated: DIS approved for registration as FDIS",
+      "50.00" => "Final text received or FDIS registered for formal approval",
+      "50.20" => "Proof sent to secretariat or FDIS ballot initiated: 8 weeks",
+      "50.60" => "Close of voting. Proof returned by secretariat",
+      "50.92" => "FDIS or proof referred back to TC or SC",
+      "50.98" => "Project deleted",
+      "50.99" => "FDIS or proof approved for publication",
+      "60.00" => "International Standard under publication",
+      "60.60" => "International Standard published",
+      "90.20" => "International Standard under systematic review",
+      "90.60" => "Close of review",
+      "90.92" => "International Standard to be revised",
+      "90.93" => "International Standard confirmed",
+      "90.99" => "Withdrawal of International Standard proposed by TC or SC",
+      "95.20" => "Withdrawal ballot initiated",
+      "95.60" => "Close of voting",
+      "95.92" => "Decision not to withdraw International Standard",
+      "95.99" => "Withdrawal of International Standard"
+    }
+
+    STAGES_NAMES = {
+      approval: "50"
+    }
+
+    SUBSTAGES_NAMES = {
+      registration: "00"
+    }
+
+    def initialize(stage, substage = nil)
+      # 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
+      end
+    end
+
+    def validate_stage(stage, substage)
+      # raise an error if stage is not number
+      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
+    end
+
+    def to_s
+      "#{stage}.#{substage}"
+    end
+
+    def ==(other)
+      stage == other.stage && substage == other.substage
+    end
+
+    def description
+      DESCRIPTIONS[to_s]
+    end
+  end
+end

data/lib/pubid/iso/identifier.rb

@@ -1,18 +1,62 @@
 module Pubid::Iso
   class Identifier < Pubid::Core::Identifier
-    attr_accessor :stage, :substage,
-                  :iteration, :supplements,
-                  :amendment_stage, :corrigendum_stage, :joint_document,
+    attr_accessor :stage,
+                  :iteration, :joint_document,
                   :tctype, :sctype, :wgtype, :tcnumber, :scnumber, :wgnumber,
-                  :urn_stage, :dir, :dirtype, :supplement
+                  :urn_stage, :dirtype,
+                  # supplement for DIR type identifiers
+                  :supplement
 
-    def initialize(**opts)
-      super
-      # if supplement
-      #   @supplement = Supplement.new(number: supplement[:year],
-      #                                publisher: supplement[:publisher],
-      #                                edition: supplement[:edition])
-      # end
+    # 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 iteration [Integer] document iteration, eg. "1", "2", "3"
+    # @param joint_document [Identifier] joint document
+    # @param supplement [Supplement] supplement
+    # @param tctype [String] Technical Committee type, eg. "TC", "JTC"
+    # @param sctype [String] TC subsommittee, eg. "SC"
+    # @param wgtype [String] TC working group type, eg. "AG", "AHG"
+    # @param tcnumber [Integer] Technical Committee number, eg. "1", "2"
+    # @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"
+    # @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,
+                   scnumber: nil, wgnumber:nil,
+                   dir: nil, dirtype: nil, year: nil, amendments: nil,
+                   corrigendums: 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"
+      end
+      if stage
+        if stage.abbr == "IS" && iteration
+          raise Errors::IsStageIterationError, "IS stage document cannot have iteration"
+        end
+        @stage = stage
+      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
+      @tcnumber = tcnumber.to_s if tcnumber
+      @scnumber = scnumber.to_s if scnumber
+      @wgnumber = wgnumber.to_s if wgnumber
+      @dir = dir.to_s if dir
+      @dirtype = dirtype.to_s if dirtype
     end
 
     def self.parse_from_title(title)
@@ -40,14 +84,45 @@ module Pubid::Iso
       def get_transformer_class
         Transformer
       end
+
+      def get_renderer_class
+        Renderer::Base
+      end
     end
 
     def urn
-      (@tctype && Renderer::UrnTc || @dir && Renderer::UrnDir || Pubid::Core::Renderer::Urn).new(get_params).render
+      (@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"
+      end
     end
 
-    def to_s(lang: nil, with_date: true, with_language_code: :iso)
-      # @pubid_language = lang
+    # 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
+    # @return [String] pubid identifier
+    def to_s(lang: nil, with_date: true, with_language_code: :iso,
+             with_edition: true, stage_format_long: true)
       case lang
       when :french
         Renderer::French.new(get_params)
@@ -56,13 +131,14 @@ module Pubid::Iso
       else
         if @tctype
           Renderer::Tc.new(get_params)
-        elsif @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) +
-        if @joint_document && !@dir
+      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"
           "|#{@joint_document}"
         end.to_s
     end

data/lib/pubid/iso/parser.rb

@@ -1,36 +1,33 @@
 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
+
+    TCTYPES = ["TC", "JTC", "PC", "IT", "CAB", "CASCO", "COPOLCO",
+      "COUNCIL", "CPSG", "CS", "DEVCO", "GA", "GAAB", "INFCO",
+      "ISOlutions", "ITN", "REMCO", "TMB", "TMBG", "WMO",
+      "DMT", "JCG", "SGPM", "ATMG", "CCCC", "CCCC-TG", "JDMT",
+      "JSAG", "JSCTF-TF", "JTCG", "JTCG-TF", "SAG_Acc", "SAG_CRMI",
+      "SAG_CRMI_CG", "SAG_ESG", "SAG_ESG_CG", "SAG_MRS", "SAG SF", "SAG SF_CG",
+      "SMCC", "STMG", "MENA STAR"].freeze
+    
+    WGTYPES = ["AG", "AHG", "AhG", "WG", "JWG", "QC", "TF",
+      "PPC", "CAG", "WG SGDG", "WG SR", "STAR", "STTF", "TIG",
+      "CPAG", "CSC", "ITSAG", "CSC/FIN", "CSC/NOM", "CSC/OVE",
+      "CSC/SP", "CSC/FIN", "JAG"].freeze
+
+    ORGANIZATIONS = %w[IEC IEEE CIW SAE CIE ASME ASTM OECD ISO IWA HL7 CEI].freeze
     rule(:stage) do
-      Renderer::Russian::STAGE.values.reduce(
-        # other stages
-        str("NP") | str("NWIP") |
-        str("WD") | str("CD") | str("DIS") | str("FDIS") | str("PRF") |
-        str("IS") | str("AWI") | str("PWI") |
-        # AMD and COR stages
-        str("FPD") | str("pD") | str("PD") | str("FD") | str("D")) do |acc, stage|
-        acc | str(stage)
-      end
+      array_to_str(Renderer::Russian::STAGE.values) | array_to_str(STAGES)
     end
 
     rule(:type) do
-      (
-        Renderer::Russian::TYPE.values.reduce(
-          str("DATA") | str("ISP") | str("IWA") | str("R") | str("TTA") |
-          str("TS") | str("TR") | str("PAS") | str("Guide") | str("GUIDE")) do |acc, type|
-          acc | str(type)
-        end
-      ).as(:type)
+      (array_to_str(Renderer::Russian::TYPE.values) | array_to_str(TYPES)).as(:type)
     end
 
     rule(:tctype) do
       # tc-types
-      str("TC") | str("JTC") | str("PC") | str("IT") | str("CAB") | str("CASCO") | str("COPOLCO") |
-        str("COUNCIL") | str("CPSG") | str("CS") | str("DEVCO") | str("GA") | str("GAAB") | str("INFCO") |
-        str("ISOlutions") | str("ITN") | str("REMCO") | str("TMB") | str("TMBG") | str("WMO") |
-        str("DMT") | str("JCG") | str("SGPM") | str("ATMG") | str("CCCC") | str("CCCC-TG") | str("JDMT") |
-        str("JSAG") | str("JSCTF-TF") | str("JTCG") | str("JTCG-TF") | str("SAG_Acc") | str("SAG_CRMI") |
-        str("SAG_CRMI_CG") | str("SAG_ESG") | str("SAG_ESG_CG") | str("SAG_MRS") | str("SAG SF") | str("SAG SF_CG") |
-        str("SMCC") | str("STMG") | str("MENA STAR")
+      array_to_str(TCTYPES)
     end
 
     rule(:sctype) do
@@ -38,10 +35,7 @@ module Pubid::Iso
     end
 
     rule(:wgtype) do
-      str("AG") | str("AHG") | str("AhG") | str("WG") | str("JWG") | str("QC") | str("TF") |
-        str("PPC") | str("CAG") | str("WG SGDG") | str("WG SR") | str("STAR") | str("STTF") | str("TIG") |
-        str("CPAG") | str("CSC") | str("ITSAG") | str("CSC/FIN") | str("CSC/NOM") | str("CSC/OVE") |
-        str("CSC/SP") | str("CSC/FIN") | str("JAG")
+      array_to_str(WGTYPES)
     end
 
     rule(:part) do
@@ -50,12 +44,7 @@ module Pubid::Iso
     end
 
     rule(:organization) do
-      Renderer::Russian::PUBLISHER.values.reduce(
-        str("IEC") | str("IEEE") | str("CIW") | str("SAE") |
-        str("CIE") | str("ASME") | str("ASTM") | str("OECD") | str("ISO") |
-        str("IWA") | str("HL7") | str("CEI")) do |acc, publisher|
-        acc | str(publisher)
-      end
+      array_to_str(Renderer::Russian::PUBLISHER.values) | array_to_str(ORGANIZATIONS)
     end
 
     rule(:edition) do
@@ -72,8 +61,9 @@ module Pubid::Iso
       (str("/") | space).maybe >>
         (str("Amd") | str("AMD") | str("AM")) >>
         (space | str(".")).repeat(1).maybe >>
-        digits.as(:version) >>
-        ((str(":") | str("-")) >> digits.as(:number)).maybe).as(:amendments)
+        digits.as(:number) >>
+        (str(".") >> digits.as(:iteration)).maybe >>
+        ((str(":") | str("-")) >> digits.as(:year)).maybe).as(:amendments)
     end
 
     rule(:corrigendum) do
@@ -81,8 +71,9 @@ module Pubid::Iso
       (str("/") | space).maybe >>
         (str("Cor") | str("COR")) >>
         (space | str(".")).repeat(1).maybe >>
-        digits.as(:version) >>
-        ((str(":") | str("-")) >> digits.as(:number)).maybe).as(:corrigendums)
+        digits.as(:number) >>
+        (str(".") >> digits.as(:iteration)).maybe >>
+        ((str(":") | str("-")) >> digits.as(:year)).maybe).as(:corrigendums)
     end
 
     rule(:language) do
@@ -115,7 +106,7 @@ module Pubid::Iso
     end
 
     rule(:dir_document_body) do
-      ((str("DIR") | str("Directives Part") | str("Directives, Part") | str("Directives,")).as(:dir) >> space).maybe >>
+      ((str("DIR") | str("Directives Part") | str("Directives, Part") | str("Directives,")).as(:type) >> space).maybe >>
         (str("JTC").as(:dirtype) >> space).maybe >>
         (digits.as(:number) >> (str(":") >> year).maybe).maybe >>
         (str(" -- Consolidated").maybe >> (space? >> (organization.as(:publisher) >> space).maybe >>
@@ -129,7 +120,7 @@ module Pubid::Iso
         space? >> ((stage.as(:stage) | type) >> space).maybe >>
         digits.as(:number) >>
         # for identifiers like ISO 5537/IDF 26
-        (str("|") >> (str("IDF") >> space >> digits).as(:joint_document)).maybe >>
+        (str("|") >> (str("IDF").as(:publisher) >> space >> digits.as(:number)).as(:joint_document)).maybe >>
         part.maybe >> iteration.maybe >>
         (space? >> (str(":") | str("-")) >> year).maybe >>
         # stage before amendment

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

@@ -0,0 +1,75 @@
+module Pubid::Iso::Renderer
+  class Base < Pubid::Core::Renderer::Base
+    # 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)
+    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]}")
+      else
+        render_base(params, "%{type}%{stage}" % params)
+      end +
+        "%{part}%{iteration}%{year}%{edition}%{amendments}%{corrigendums}%{language}" % params
+    end
+
+    def render_short_stage(stage)
+      case stage
+      when "DIS"
+        "D"
+      when "FDIS"
+        "FD"
+      end
+    end
+
+    def render_type(type, opts, params)
+      if params[:copublisher]
+        " #{type}"
+      else
+        "/#{type}"
+      end
+    end
+
+    def render_stage(stage, opts, params)
+      if params[:copublisher]
+        " #{stage.abbr}"
+      else
+        "/#{stage.abbr}"
+      end
+    end
+
+    def render_edition(edition, opts, _params)
+      " ED#{edition}" if opts[:with_edition]
+    end
+
+    def render_iteration(iteration, _opts, _params)
+      ".#{iteration}"
+    end
+
+    def render_amendments(amendments, opts, _params)
+      amendments.sort.map { |amendment| amendment.render_pubid(opts[:stage_format_long], opts[:with_date]) }.join("+")
+    end
+
+    def render_corrigendums(corrigendums, opts, _params)
+      corrigendums.sort.map { |corrigendum| corrigendum.render_pubid(opts[:stage_format_long], opts[:with_date]) }.join("+")
+    end
+
+    def render_language(language, opts, _params)
+      return if opts[:with_language_code] == :none
+      super
+    end
+
+    def render_year(year, opts, params)
+      return ":#{year}" if params[:amendments] || params[:corrigendums]
+      opts[:with_date] && ":#{year}" || ""
+    end
+  end
+end

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

@@ -1,11 +1,11 @@
 module Pubid::Iso::Renderer
-  class Dir < Pubid::Core::Renderer::Base
+  class Dir < Base
 
     def render_identifier(params)
       res = ("%{publisher}%{copublisher} DIR%{dirtype}%{number}%{year}%{supplement}" % params)
 
       if params.key?(:joint_document)
-        joint_params = prerender_params(params[:joint_document], {})
+        joint_params = prerender_params(params[:joint_document].get_params, {})
         joint_params.default = ""
         res += (" + %{publisher}%{copublisher}%{dirtype}%{number}%{year}%{supplement}" % joint_params)
       end
@@ -26,7 +26,7 @@ module Pubid::Iso::Renderer
         " #{supplement.publisher} SUP"
       else
         " SUP"
-      end + (supplement.number && ":#{supplement.number}" || "") +
+      end + (supplement.year && ":#{supplement.year}" || "") +
         (supplement.edition && " Edition #{supplement.edition}" || "")
     end
   end

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

@@ -1,5 +1,5 @@
 module Pubid::Iso::Renderer
-  class French < Pubid::Core::Renderer::Base
+  class French < Base
     def render_identifier(params)
       if params[:type] == " Guide"
         params[:type] = ""
@@ -10,7 +10,7 @@ module Pubid::Iso::Renderer
     end
 
     def render_copublisher(copublisher, opts, params)
-      "/#{copublisher.sub("IEC", "CEI")}"
+      "/#{copublisher.to_s.sub("IEC", "CEI")}"
     end
 
     def render_corrigendums(corrigendums, _opts, _params)

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

@@ -1,5 +1,5 @@
 module Pubid::Iso::Renderer
-  class Russian < Pubid::Core::Renderer::Base
+  class Russian < Base
     PUBLISHER = { "ISO" => "ИСО", "IEC" => "МЭК" }.freeze
     STAGE = { "FDIS" => "ОПМС",
               "DIS" => "ПМС",
@@ -44,9 +44,9 @@ module Pubid::Iso::Renderer
 
     def render_stage(stage, _opts, params)
       if params[:copublisher]
-        " #{STAGE[stage]}"
+        " #{STAGE[stage.abbr]}"
       else
-        "/#{STAGE[stage]}"
+        "/#{STAGE[stage.abbr]}"
       end
     end
 

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

@@ -1,12 +1,12 @@
 module Pubid::Iso::Renderer
-  class Tc < Pubid::Core::Renderer::Base
+  class Tc < Base
 
     def render_identifier(params)
       "%{publisher}%{copublisher} %{tctype} %{tcnumber}%{sctype}%{wgtype} N%{number}" % params
     end
 
     def render_tctype(tctype, _opts, _params)
-      tctype.is_a?(Array) && tctype.join("/") || tctype
+      tctype.is_a?(Array) && tctype.join("/") || tctype.to_s
     end
 
     # TC 184/SC/WG 4 - no wg number

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

@@ -1,13 +1,11 @@
 module Pubid::Iso::Renderer
-  class UrnDir < Pubid::Core::Renderer::Urn
+  class UrnDir < Urn
 
     def render_identifier(params)
       res = ("urn:iso:doc:%{publisher}%{copublisher}:dir%{dirtype}%{number}%{year}%{supplement}" % params)
 
       if params.key?(:joint_document)
-        joint_params = prerender_params(
-          params[:joint_document].transform_values { |value| value.is_a?(Parslet::Slice) && value.to_s || value }, {}
-        )
+        joint_params = prerender_params(params[:joint_document].get_params, {})
         joint_params.default = ""
         res += (":%{publisher}%{copublisher}%{dirtype}%{number}%{supplement}" % joint_params)
       end
@@ -28,7 +26,7 @@ module Pubid::Iso::Renderer
         ":sup:#{supplement.publisher.downcase}"
       else
         ":sup"
-      end + (supplement.number && ":#{supplement.number}" || "") +
+      end + (supplement.year && ":#{supplement.year}" || "") +
         (supplement.edition && ":ed-#{supplement.edition}" || "")
     end
   end

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

@@ -1,12 +1,12 @@
 module Pubid::Iso::Renderer
-  class UrnTc < Pubid::Core::Renderer::Urn
+  class UrnTc < Urn
 
     def render_identifier(params)
       "urn:iso:doc:%{publisher}%{copublisher}:%{tctype}:%{tcnumber}%{sctype}%{wgtype}:%{number}" % params
     end
 
     def render_tctype(tctype, _opts, _params)
-      (tctype.is_a?(Array) && tctype.join(":") || tctype).downcase
+      (tctype.is_a?(Array) && tctype.join(":") || tctype.to_s).downcase
     end
 
     def render_sctype(sctype, _opts, params)

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

@@ -0,0 +1,22 @@
+module Pubid::Iso::Renderer
+  class Urn < Pubid::Core::Renderer::Urn
+    STAGES = { PWI: 0,
+               NP: 10,
+               AWI: 20,
+               WD: 20.20,
+               CD: 30,
+               DIS: 40,
+               FDIS: 50,
+               PRF: 50,
+               IS: 60 }.freeze
+
+    def render_identifier(params)
+      render_base(params) + "%{stage}"\
+      "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}%{language}" % params
+    end
+
+    def render_stage(stage, _opts, params)
+      ":stage-#{stage.harmonized_code}"
+    end
+  end
+end

data/lib/pubid/iso/stage.rb

@@ -0,0 +1,33 @@
+module Pubid::Iso
+  class Stage
+    attr_accessor :abbr, :harmonized_code
+
+    STAGES = { PWI: "00.00",
+               NP: "10.00",
+               AWI: "20.00",
+               WD: "20.20",
+               CD: "30.00",
+               DIS: "40.00",
+               FDIS: "50.00",
+               PRF: "50.00",
+               IS: "60.00" }.freeze
+
+    # @param abbr [String, Symbol] abbreviation eg. :PWI, :WD
+    # @param harmonized_code [HarmonizedStageCode]
+    def initialize(abbr: nil, harmonized_code: nil)
+      @abbr = abbr
+      @harmonized_code = harmonized_code
+
+      if harmonized_code
+        # @abbr = STAGES.select { |k,v| v == @harmonized_code.to_s }.first&.first
+        @abbr ||= STAGES.key(@harmonized_code.to_s)
+      end
+
+      if abbr
+        raise Errors::CodeInvalidError, "#{abbr} is not valid stage" unless STAGES.key?(abbr.to_sym)
+
+        @harmonized_code ||= HarmonizedStageCode.new(*STAGES[abbr.to_sym].split("."))
+      end
+    end
+  end
+end

data/lib/pubid/iso/supplement.rb

@@ -1,24 +1,54 @@
 module Pubid::Iso
   class Supplement < Pubid::Core::Supplement
-    attr_accessor :stage, :publisher, :edition
+    attr_accessor :stage, :publisher, :edition, :iteration
 
-    def initialize(stage: nil, version: nil, publisher: nil, edition: nil, **args)
-      super(version: version, **args)
+    # @param stage [Stage] stage, e.g. "PWI", "NP"
+    # @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
       @publisher = publisher.to_s
-      @edition = edition
+      @edition = edition&.to_i
+      @iteration = iteration&.to_i
+
+      if @iteration && @stage.nil?
+        raise Errors::PublishedIterationError.new("cannot assign iteration to published supplement")
+      end
     end
 
     def render_pubid_stage
-      ((@stage && @stage) || "")
+      ((@stage && @stage.abbr != "IS" && @stage.abbr) || "")
     end
 
     def render_urn_stage
-      ((@stage && ":stage-#{sprintf('%05.2f', Pubid::Core::Renderer::Urn::STAGES[@stage.to_sym])}") || "")
+      ((@stage && ":stage-#{@stage.harmonized_code}") || "")
     end
 
     def <=>(other)
       (super == 0) && ((stage.nil? || stage == other.stage) && 0 || -1) || super
     end
+
+    def render_iteration
+      @iteration && ".#{@iteration}"
+    end
+
+    def render_pubid_number(with_date: true)
+      if @year && with_date
+        "#{@number}#{render_iteration}:#{@year}"
+      else
+        "#{@number}#{render_iteration}"
+      end
+    end
+
+    def render_urn_number
+      if @year
+        ":#{@year}:v#{@number}#{render_iteration}"
+      else
+        ":#{@number}#{render_iteration}:v1"
+      end
+    end
   end
 end

data/lib/pubid/iso/transformer.rb

@@ -9,16 +9,24 @@ module Pubid::Iso
     end
 
     rule(amendments: subtree(:amendments)) do |context|
-      if context[:amendments].key?(:stage)
-        context[:amendments][:stage] = convert_stage(context[:amendments][:stage])
-      end
+      context[:amendments] =
+        [Amendment.new(
+          number: context[:amendments][:number],
+          year: context[:amendments][:year],
+          stage: context[:amendments][:stage] && convert_stage(context[:amendments][:stage]),
+          iteration: context[:amendments][:iteration])]
+
       context
     end
-    #
+
     rule(corrigendums: subtree(:corrigendums)) do |context|
-      if context[:corrigendums].key?(:stage)
-        context[:corrigendums][:stage] = convert_stage(context[:corrigendums][:stage])
-      end
+      context[:corrigendums] =
+        [Corrigendum.new(
+          number: context[:corrigendums][:number],
+          year: context[:corrigendums][:year],
+          stage: context[:corrigendums][:stage] && convert_stage(context[:corrigendums][:stage]),
+          iteration: context[:corrigendums][:iteration])]
+
       context
     end
 
@@ -43,6 +51,8 @@ module Pubid::Iso
           "TS"
         when "ТО"
           "TR"
+        when "Directives Part", "Directives, Part", "Directives,"
+          "DIR"
         else
           type
         end
@@ -72,7 +82,8 @@ module Pubid::Iso
     #
     rule(publisher: simple(:publisher), supplement: subtree(:supplement)) do |context|
       context[:supplement] =
-        Supplement.new(number: context[:supplement][:year],
+        Supplement.new(number: context[:supplement][:number],
+                       year: context[:supplement][:year],
                        publisher: context[:supplement][:publisher],
                        edition: context[:supplement][:edition])
       context
@@ -80,31 +91,38 @@ module Pubid::Iso
 
     rule(supplement: subtree(:supplement)) do |context|
       context[:supplement] =
-        Supplement.new(number: context[:supplement][:year],
+        Supplement.new(number: context[:supplement][:number],
+                       year: context[:supplement][:year],
                        publisher: context[:supplement][:publisher],
                        edition: context[:supplement][:edition])
       context
     end
 
+    rule(joint_document: subtree(:joint_document)) do |context|
+      context[:joint_document] =
+        Identifier.new(**context[:joint_document])
+      context
+    end
 
     def self.convert_stage(code)
       russian_code = Renderer::Russian::STAGE.key(code.to_s)
-      return russian_code.to_s if russian_code
+      # return russian_code.to_s if russian_code
 
-      case code
-      when "NWIP"
-        "NP"
-      when "D"
-        "DIS"
-      when "FD"
-        "FDIS"
-      when "Fpr"
-        "PRF"
-      when "pD", "PD"
-        "CD"
-      else
-        code
-      end
+      code = case code
+             when "NWIP"
+               "NP"
+             when "D", "FPD"
+               "DIS"
+             when "FD", "F"
+               "FDIS"
+             when "Fpr"
+               "PRF"
+             when "pD", "PD"
+               "CD"
+             else
+               code
+             end
+      Stage.new(abbr: (russian_code || code))
     end
 
     def self.convert_language(code)

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.1.10".freeze
+    VERSION = "0.1.11".freeze
   end
 end

data/lib/pubid/iso.rb

@@ -10,12 +10,16 @@ end
 
 require "pubid-core"
 require_relative "iso/errors"
+require_relative "iso/stage"
+require_relative "iso/harmonized_stage_code"
 require_relative "iso/parser"
 require_relative "iso/transformer"
 require_relative "iso/supplement"
 require_relative "iso/amendment"
 require_relative "iso/corrigendum"
 require_relative "iso/identifier"
+require_relative "iso/renderer/base"
+require_relative "iso/renderer/urn"
 require_relative "iso/renderer/french"
 require_relative "iso/renderer/russian"
 require_relative "iso/renderer/tc"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-iso
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-08-05 00:00:00.000000000 Z
+date: 2022-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 1.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: 1.1.2
 description: Library to generate, parse and manipulate ISO PubID.
 email:
 - open.source@ribose.com
@@ -124,14 +124,18 @@ files:
 - lib/pubid/iso/amendment.rb
 - lib/pubid/iso/corrigendum.rb
 - lib/pubid/iso/errors.rb
+- lib/pubid/iso/harmonized_stage_code.rb
 - lib/pubid/iso/identifier.rb
 - lib/pubid/iso/parser.rb
+- lib/pubid/iso/renderer/base.rb
 - lib/pubid/iso/renderer/dir.rb
 - lib/pubid/iso/renderer/french.rb
 - lib/pubid/iso/renderer/russian.rb
 - lib/pubid/iso/renderer/tc.rb
 - lib/pubid/iso/renderer/urn-dir.rb
 - lib/pubid/iso/renderer/urn-tc.rb
+- lib/pubid/iso/renderer/urn.rb
+- lib/pubid/iso/stage.rb
 - lib/pubid/iso/supplement.rb
 - lib/pubid/iso/transformer.rb
 - lib/pubid/iso/version.rb