pubid-iso 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1f95297e422efe82291fd2570ba264ca9daf1b6304dc3050ae7aebcff532739
-  data.tar.gz: '08f400bc76e43847ae0ae0b7d0c516de05a6a9bdc1dce60abd9b69ca9745b05e'
+  metadata.gz: e9a5dae3e19189666e2259f498813de7aa502ee7d68e1ec4567d493be74e3acb
+  data.tar.gz: f7834ffc05c7eaeec131aaef54804512d2e6d9e5494da8fe286e9730493dd7be
 SHA512:
-  metadata.gz: 6d2f14cbb013fc0e9097178bc9cf7c3b5255f21699c0e904cbd8bb4aec159464f451c679e5d2f4a24aee9c3c3397d8b882f3fbb89c096104c17da51bfe6cf4f7
-  data.tar.gz: 3d263a1fad953c7e508b2d1936fda41fd4d827f09eb81fecc6b3379acb23502d6852cdaa99860717714934af262eb01a13039b00871af2ef8f11cf97b738e3df
+  metadata.gz: 5a3319d163496c073813d052ecc873fb6f2f90e2351f1c8ac891c2c093c56a59d8405bc942f44b3f57e013f1f7149a7b3a35fc7b73ca3c58a0116ebce5e85b63
+  data.tar.gz: 3c72a547b1abaa06142caa496e8ce6d3769499954bfeaf3f9b01a470017bd3f38a1682be9e793f7eaab019ce202367feeda9d771f13ad14cf11b9cd901dafd42

data/README.adoc

@@ -1,2 +1,179 @@
 = ISO publication identifiers ("ISO PubID")
 
+== Purpose
+
+This gem implements a mechanism to parse and utilize ISO publication
+identifiers.
+
+== Use cases to support
+
+. generate the corresponding URN format (according to RFC 5141)
+. generate updated PubID
+. generate language specific PubID
+. generate dated vs undated PubIDs
+
+
+== Elements of the PubID
+
+=== Document identifier
+
+==== General
+
+The ISO document identifier is assembled out of these metadata elements:
+
+publisher:: publisher of the document
+document stage:: stage of development of document, according to the Harmonized Stage Codes
+document number:: numeric identifier of document
+update number:: serial number of update (for amendments and technical corrigenda)
+document type:: type of ISO deliverable
+copyright year:: year of publication of document
+language:: language of document
+
+==== Publisher
+
+This is the abbreviation of the publishing organization, typically `ISO`.
+
+If the document is published under co-publishing agreements, it can contain the
+abbreviations of other publishing SDOs, delimited by `/` after `ISO`.
+
+An International Workshop Agreement document has publisher abbreviation of
+`IWA`.
+
+[example]
+====
+`ISO`, `ISO/IEC`, `ISO/IEC/IEEE`, `ISO/IEEE`, `ISO/SAE`, `IWA`
+====
+
+
+==== Document type and stage
+
+ISO document stages in document identifiers are mapped as follows.
+
+International Standard::
+
+`00.00` to `00.99`::: "`PWI`"
+`10.00` to `10.98`::: "`NP`"
+`10.99` to `20.00`::: "`AWI`"
+`20.20` to `20.99`::: "`WD`"
+`30.00` to `30.99`::: "`CD`"
+`40.00` to `40.99`::: "`DIS`"
+`50.00` to `50.99`::: "`FDIS`"
+`60.00`::: "`PRF`"
+`60.60`::: empty designation
+
+Technical Specification, Technical Report::
+
+`00.00` to `00.99`::: "`PWI {TR,TS}`"
+`10.00` to `10.98`::: "`NP {TR,TS}`"
+`10.98` to `20.00`::: "`AWI {TR,TS}`"
+`20.20` to `20.99`::: "`WD {TR,TS}`"
+`30.00` to `30.99`::: "`CD {TR,TS}`"
+`40.00` to `40.99`::: TS/TRs do not have DIS stage because they are not
+international standards.
+`50.00` to `50.99`::: TS/TRs do not have FDIS stage because they are not
+international standards.
+`60.00`::: "`PRF {TR,TS}`"
+`60.60`::: "`{TR,TS}`"
+
+//The stage abbreviations DIS and FDIS change to DTS and FDTS
+
+Amendment::
+
+`00.00` to `00.99`::: "`{base-document-id}/PWI Amd {num}`"
+`10.00` to `10.98`::: "`{base-document-id}/NP Amd {num}`"
+`10.99` to `20.00`::: "`{base-document-id}/AWI Amd {num}`"
+`20.20` to `20.99`::: "`{base-document-id}/WD Amd {num}`"
+`30.00` to `30.99`::: "`{base-document-id}/CD Amd {num}`"
+`40.00` to `40.99`::: "`{base-document-id}/DAmd {num}`"
+`50.00` to `50.99`::: "`{base-document-id}/FDAmd {num}`"
+`60.00`::: "`{base-document-id}/PRF Amd {num}`"
+`60.60`::: "`{base-document-id}/Amd {num}`"
+
+Technical Corrigendum::
+
+`00.00` to `00.99`::: "`{base-document-id}/PWI Cor {num}`"
+`10.00` to `10.98`::: "`{base-document-id}/NP Cor {num}`"
+`10.99` to `20.00`::: "`{base-document-id}/AWI Cor {num}`"
+`20.20` to `20.99`::: "`{base-document-id}/WD Cor {num}`"
+`30.00` to `30.99`::: "`{base-document-id}/CD Cor {num}`"
+`40.00` to `40.99`::: "`{base-document-id}/DIS Cor {num}`"
+`50.00` to `50.99`::: "`{base-document-id}/FDCor {num}`"
+`60.00`::: "`{base-document-id}/PRF Cor {num}`"
+`60.60`::: "`{base-document-id}/Cor {num}`"
+
+
+When the Publisher element contains a "`slash`" ("`/`"), the separation in front
+of the document stage will be converted into an empty space.
+
+[example]
+====
+`ISO/NP 33333` but `ISO/IEC NP 33333`.
+`ISO/NP TR 33333` but `ISO/IEC NP TR 33333`.
+====
+
+According to ISO Directives Part 1 (11ed), SE.2:
+
+[quote]
+____
+Working drafts (WD), committee drafts (CD), draft International Standards (DIS),
+final draft International Standards (FDIS) and International Standards`",
+"`Successive DIS on the same subject will carry the same number but will be
+distinguished by a numerical suffix (.2, .3, etc.).
+____
+
+The stage iteration number is assigned accordingly for all stages, which is
+patterned as:
+
+* `{document stage}` (no suffix if iteration is 1); or
+* `{document stage}.{iteration number}`
+  (suffix including iteration number after 1).
+
+Once the document is published (stage 60 substage 60), no status abbreviation is
+given.
+
+
+==== Full PubID patterns
+
+The patterns are as follows:
+
+*International Standard*::
+`{publisher} (/{document type and stage})? ({document number}) (- {part number})? (: {copyright year}) ({ISO 639 language code})?` +
++
+====
+`ISO/IEEE/FDIS 33333-2`, `ISO/IEEE 33333-2:2030(E)`
+====
+
+*Technical Report*, *Technical Specification*::
+`{publisher} (/{document type and stage}) ({document number}) (- {part number})? (: {copyright year}) ({ISO 639 language code})?` +
++
+====
+`ISO/IEC/FDIS TS 33333-2`, `ISO/TR 33333-2:2030(E)`, `ISO/IEC TR 33333-2:2030(E)`
+====
+
+*Amendments*, *Technical Corrigendum*::
+`{source document ID}/{document type and stage} {update number} (: {copyright year}) ({ISO 639 language code})?` +
++
+====
+`ISO 33333-2:2030/DIS Cor 2:2031`, `ISO 33333-2:2030/Cor 2:2032`, `ISO/IEC 33333-2:2030/Cor 2:2032`
+====
+
+
+// === Title
+
+// `:title-intro-{en,fr}:`:: The introductory component of the English or French
+// title of the document.
+
+// `:title-main-{en,fr}:`:: The main component of the English or French title of
+// the document (mandatory).
+
+// `:title-part-{en,fr}:`:: The English or French title of the document part.
+
+// `:title-amendment-{en,fr}:`:: (only when `doctype` is set to `amendment` or `technical-corrigendum`)
+// The English or French title of the amendment [added in https://github.com/metanorma/isodoc/releases/tag/v1.3.25]
+
+// `:amendment-number:`:: (only when `doctype` is set to `amendment`)
+// The number of the amendment [added in https://github.com/metanorma/isodoc/releases/tag/v1.3.25]
+
+// `:corrigendum-number:`:: (only when `doctype` is set to `technical-corrigendum`)
+// The number of the technical corrigendum [added in https://github.com/metanorma/isodoc/releases/tag/v1.3.25]
+

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

@@ -0,0 +1,32 @@
+module Pubid::Iso
+  class French < Identifier
+    def identifier(with_date, with_language_code)
+      if @type == "Guide"
+        "Guide #{originator}#{stage} #{number}#{part}#{iteration}"\
+          "#{with_date && rendered_year || ''}#{edition}#{supplements}#{language(with_language_code)}"
+      else
+        super
+      end
+    end
+
+    def copublisher
+      super.map { |copublisher| copublisher.sub("IEC", "CEI") }
+    end
+
+    def amendment
+      if @amendment_number
+        "Amd.#{@amendment_version}:#{@amendment_number}"
+      else
+        "Amd.#{@amendment_version}"
+      end
+    end
+
+    def corrigendum
+      if @corrigendum_number
+        "Cor.#{@corrigendum_version}:#{@corrigendum_number}"
+      else
+        "Cor.#{@corrigendum_version}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Pubid::Iso
+  class Russian < Identifier
+    PUBLISHER = { "ISO" => "ИСО", "IEC" => "МЭК" }.freeze
+    STAGE = { "FDIS" => "ОПМС",
+              "DIS" => "ПМС",
+              "NP" => "НП",
+              "AWI" => "АВИ",
+              "CD" => "КПК",
+              "PD" => "ПД",
+              "FPD" => "ФПД",
+
+
+    }.freeze
+    TYPE = { "Guide" => "Руководство",
+             "TS" => "ТС",
+             "TR" => "ТО",
+             "ISP" => "ИСП",
+    }.freeze
+
+    def identifier(with_date, with_language_code)
+      if @type == "Guide"
+        "Руководство #{originator}#{stage} #{number}#{part}#{iteration}"\
+          "#{with_date && rendered_year || ''}#{edition}#{supplements}#{language(with_language_code)}"
+      else
+        super
+      end
+    end
+
+    def publisher
+      PUBLISHER[@publisher]
+    end
+
+    def copublisher
+      super&.map { |copublisher| PUBLISHER[copublisher] }
+    end
+
+    def stage
+      "#{(@copublisher && ' ') || '/'}#{STAGE[@stage]}" if @stage
+    end
+  end
+end

data/lib/pubid/iso/identifier.rb

@@ -1,46 +1,191 @@
 module Pubid::Iso
   class Identifier
-    STAGES = { NP: 10,
-               WD: 20,
-               CD: 30,
-               DIS: 40,
-               FDIS: 50,
-               PRF: 50,
-               IS: 60,
-               Fpr: 50 }.freeze
-
     attr_accessor :number, :publisher, :copublisher, :stage, :substage, :part,
-                  :type, :year, :edition, :iteration, :supplements, :language
-
-    def initialize(stage: nil, supplements: nil, **opts)
-      if stage
-        @stage = STAGES[stage.to_sym]
-        @substage = 0
-      end
-
-      # XXX: temporary hack for ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1 parsing
-      supplements&.each do |supplement|
-        if supplement[:stage]
-          @stage = STAGES[Transformer.new.apply(stage: supplement[:stage].to_s)[:stage].to_sym]
-          @substage = 0
-        end
-      end
+                  :type, :year, :edition, :iteration, :supplements, :language,
+                  :amendment, :amendment_version, :amendment_number,
+                  :corrigendum, :corrigendum_version, :corrigendum_number,
+                  :amendment_stage, :corrigendum_stage, :joint_document,
+                  :tctype, :sctype, :wgtype, :tcnumber, :scnumber, :wgnumber
 
-      @supplements = supplements
+    LANGUAGES = {
+      "ru" => "R",
+      "fr" => "F",
+      "en" => "E",
+      "ar" => "A",
+    }.freeze
 
+    def initialize(**opts)
       opts.each { |key, value| send("#{key}=", value.is_a?(Array) && value || value.to_s) }
     end
 
+    def get_params
+      instance_variables.map { |var| [var.to_s.gsub("@", "").to_sym, instance_variable_get(var)] }.to_h
+    end
+
     def urn
-      URN.new(self)
+      Urn.new(**get_params)
     end
 
-    def self.parse(code)
-      new(**Parser.new.parse(code).map do |k, v|
-        Transformer.new.apply(k => v).to_a.first
-      end.to_h)
+    def self.parse(code_or_params)
+      params = code_or_params.is_a?(String) ? Parser.new.parse(code_or_params) : code_or_params
+      # Parslet returns an array when match any copublisher
+      # otherwise it's hash
+      if params.is_a?(Array)
+        new(
+          **(
+            params.inject({}) do |r, i|
+              result = r
+              i.map {|k, v| Transformer.new.apply(k => v).to_a.first }.each do |k, v|
+                result = result.merge(k => r.key?(k) ? [v, r[k]] : v)
+              end
+              result
+            end
+          )
+        )
+      else
+        new(**params.map do |k, v|
+          Transformer.new.apply(k => v).to_a.first
+        end.to_h)
+      end
+      # merge values repeating keys into array (for copublishers)
+
+
+      # params.to_h)
     rescue Parslet::ParseFailed => failure
       raise Pubid::Iso::Errors::ParseError, "#{failure.message}\ncause: #{failure.parse_failure_cause.ascii_tree}"
     end
+
+    def to_s(lang: nil, with_date: true, with_language_code: :iso)
+      # @pubid_language = lang
+      case lang
+      when :french
+        French.new(**get_params)
+      when :russian
+        Russian.new(**get_params)
+      else
+        self
+      end.identifier(with_date, with_language_code) + (@joint_document && "|#{@joint_document}").to_s
+    end
+
+    def identifier(with_date, with_language_code)
+      if @tctype
+        "#{originator} #{tctype} #{tcnumber}#{sctype}#{wgtype} N#{number}"
+      else
+        "#{originator}#{type}#{stage} #{number}#{part}#{iteration}"\
+        "#{with_date && rendered_year || ''}#{edition}#{supplements}#{language(with_language_code)}"
+      end
+    end
+
+    def tctype
+      return @tctype.join("/") if @tctype.is_a?(Array)
+
+      @tctype
+    end
+
+    # TC 184/SC/WG 4 - no wg number
+    # TC 184/SC 4/WG 12 - separate sc and wg number
+    def sctype
+      return unless @sctype
+
+      if @wgnumber || !@wgtype
+        "/#{@sctype} #{@scnumber}"
+      else
+        "/#{@sctype}"
+      end
+    end
+
+    def wgtype
+      return unless @wgtype
+
+      if @wgnumber
+        "/#{@wgtype} #{@wgnumber}"
+        else
+        "/#{@wgtype} #{@scnumber}"
+      end
+    end
+
+    def copublisher
+      return nil unless @copublisher
+
+      (!@copublisher.is_a?(Array) && [@copublisher]) || @copublisher
+    end
+
+    def originator
+      if copublisher
+        # @copublisher = [@copublisher] unless @copublisher.is_a?(Array)
+        # @copublisher.map! { |copublisher| copublisher.sub("IEC", "CEI") } if @french
+        publisher + copublisher.map(&:to_s).sort.map do |copublisher|
+          "/#{copublisher.gsub('-', '/')}"
+        end.join
+      else
+        publisher
+      end
+    end
+
+    def stage
+      "#{(@copublisher && ' ') || '/'}#{@stage}" if @stage
+    end
+
+    def part
+      "-#{@part}" if @part
+    end
+
+    def rendered_year
+      @year && ":#{@year}"
+    end
+
+    def type
+      "#{(@copublisher && ' ') || '/'}#{@type}" if @type
+    end
+
+    def edition
+      " ED#{@edition}" if @edition
+    end
+
+    def iteration
+      ".#{@iteration}" if @iteration
+    end
+
+    def amendment
+      if @amendment_number
+        "Amd #{@amendment_version}:#{@amendment_number}"
+      else
+        "Amd #{@amendment_version}"
+      end
+    end
+
+    def corrigendum
+      if @corrigendum_number
+        "Cor #{@corrigendum_version}:#{@corrigendum_number}"
+      else
+        "Cor #{@corrigendum_version}"
+      end
+    end
+
+    def supplements
+      result = ""
+      if @amendment_version
+        result += (@amendment_stage && "/#{@amendment_stage} ") || "/"
+        result += amendment
+      end
+
+      if @corrigendum_version
+        result += (@corrigendum_stage && "/#{@corrigendum_stage} ") || "/"
+        result += corrigendum
+      end
+
+      result
+    end
+
+    def language(with_language_code = :iso)
+      if @language
+        if with_language_code == :single
+          "(#{LANGUAGES[@language]})"
+        else
+          "(#{@language})"
+        end
+      end
+    end
+
   end
 end

data/lib/pubid/iso/parser.rb

@@ -17,13 +17,22 @@ module Pubid::Iso
   # Stage 50.60: PRF ("proof") (non-public)
   # Stage 60: IS
   class Parser < Parslet::Parser
+    rule(:space) { str(" ") }
+    rule(:space?) { space.maybe }
+
     rule(:digits) do
       match('\d').repeat(1)
     end
 
     rule(:stage) do
-      (str("NP") | str("WD") | str("CD") | str("DIS") | str("FDIS") | str("PRF") |
-        str("IS") | str("AWI") | str("FD") | str("D")).as(:stage)
+      Russian::STAGE.values.reduce(
+        # other stages
+        str("NP") | 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
     end
 
     # TYPES = {
@@ -36,32 +45,62 @@ module Pubid::Iso
     #       # type          = "data" / "guide" / "isp" / "iwa" /
     #       #   "pas" / "r" / "tr" / "ts" / "tta"
     rule(:type) do
-      (str("DATA") | str("ISP") | str("IWA") | str("R") | str("TTA") |
-        str("TS") | str("TR") | str("PAS") | str("Guide")).as(:type)
+      (
+        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)
+    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")
+    end
+
+    rule(:sctype) do
+      str("SC")
+    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")
     end
 
     rule(:year) do
-      match('\d').repeat(4, 4)
+      match('\d').repeat(4, 4).as(:year)
     end
 
     rule(:part) do
-      (str("-") | str("/")) >> str(" ").maybe >>
-        (match['[\dA-Z]'] | str("-")).repeat(1).as(:part)
+      (str("-") | str("/")) >> space? >>
+        (str("Amd") | str("Cor")).absent? >> (match['[\dA-Z]'] | str("-")).repeat(1).as(:part)
     end
 
     rule(:originator) do
       organization.as(:publisher) >>
-        (str(" ").maybe >> str("/") >> organization.as(:copublisher)).maybe
+        (space? >> str("/") >> organization.as(:copublisher)).repeat
     end
 
     rule(:organization) do
-      str("IEC/IEEE") | str("IEC") | str("IEEE") | str("CIW") | str("SAE") |
+      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("IWA") | str("HL7") | str("CEI")) do |acc, publisher|
+        acc | str(publisher)
+      end
     end
 
     rule(:edition) do
-      str(" ") >> ((str("ED") | str("Ed ") | str("Ed.")) >>
+      space >> ((str("ED") | str("Ed ") | str("Ed.")) >>
         digits.as(:edition) | str("Ed").as(:edition))
     end
 
@@ -69,33 +108,75 @@ module Pubid::Iso
       str(".") >> digits.as(:iteration)
     end
 
-    rule(:supplement) do
-      (str("/") | str(" ")).maybe >>
-        (str("Amd") | str("AMD") | str("Cor") | str("COR")).as(:supplement) >>
-        str(" ") >>
-        digits.as(:supplement_version) >>
-        (str(":") >> digits.as(:supplement_number)).maybe
+    rule(:amendment) do
+      (str("/") >> stage.as(:amendment_stage)).maybe >>
+      (str("/") | space).maybe >>
+        (str("Amd") | str("AMD") | str("AM")).as(:amendment) >>
+        (space | str(".")) >>
+        digits.as(:amendment_version) >>
+        (str(":") >> digits.as(:amendment_number)).maybe
+    end
+
+    rule(:corrigendum) do
+      (str("/") >> stage.as(:corrigendum_stage)).maybe >>
+      (str("/") | space).maybe >>
+        (str("Cor") | str("COR")).as(:corrigendum) >>
+        (space | str(".")) >>
+        digits.as(:corrigendum_version) >>
+        (str(":") >> digits.as(:corrigendum_number)).maybe
     end
 
     rule(:language) do
-      str("(") >> match["a-z"].repeat(1).as(:language) >> str(")")
+      str("(") >> (
+        ( # parse ru,en,fr
+          (match["a-z"].repeat(1) >> str(",").maybe) |
+          # parse R/E/F
+          ((str("E") | str("F") | str("A") | str("R")) >> str("/").maybe)
+        ).repeat.as(:language)
+      ) >> str(")")
+    end
+
+    rule(:guide_prefix) do
+      str("Guide") | str("GUIDE") | str("Руководство") | str("Руководства")
+    end
+
+    # Parse technical committee documents
+    rule(:tc_document_body) do
+      (tctype.as(:tctype) >> str("/").maybe).repeat >> space >> digits.as(:tcnumber) >>
+        (str("/") >> (
+          ((sctype.as(:sctype) >> space >> digits.as(:scnumber) >> str("/")).maybe >>
+            wgtype.as(:wgtype) >> space >> digits.as(:wgnumber)) |
+            (sctype.as(:sctype) >> (space | str("/") >> wgtype.as(:wgtype) >> space) >> digits.as(:scnumber))
+        )).maybe >>
+        str(" N") >> space? >> digits.as(:number)
+    end
+
+    rule(:std_document_body) do
+      (type | stage.as(:stage)).maybe >>
+        # for ISO/IEC WD TS 25025
+        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 >>
+        part.maybe >> iteration.maybe >>
+        (space? >> str(":") >> year).maybe >>
+        # stage before amendment
+        (
+          # stage before corrigendum
+          ((amendment >> corrigendum.maybe) | corrigendum).maybe) >>
+        edition.maybe >>
+        language.maybe
     end
 
     rule(:identifier) do
       str("Fpr").as(:stage).maybe >>
         # Withdrawn e.g: WD/ISO 10360-5:2000
         str("WD/").maybe >>
-        originator >> ((str(" ") | str("/")) >>
-        # for ISO/FDIS
-        (type | stage)).maybe >>
-        # for ISO/IEC WD TS 25025
-        str(" ").maybe >> ((stage | type) >> str(" ")).maybe >>
-        digits.as(:number) >> part.maybe >> iteration.maybe >>
-        (str(" ").maybe >> str(":") >> year).maybe >>
-        ((str("/") >> stage).maybe >>
-        supplement).repeat.as(:supplements) >>
-        edition.maybe >>
-        language.maybe
+        # for French and Russian PubIDs starting with Guide type
+        (guide_prefix.as(:type) >> space).maybe >>
+        (stage.as(:stage) >> space).maybe >>
+        originator >> (space | str("/")) >>
+        (tc_document_body | std_document_body)
     end
 
     rule(:root) { identifier }

data/lib/pubid/iso/transformer.rb

@@ -4,16 +4,93 @@ module Pubid::Iso
       { edition: "1" }
     end
 
-    rule(stage: simple(:stage)) do
-      { stage: case stage
-               when "D"
-                 "DIS"
-               when "FD"
-                 "FDIS"
-               else
-                 stage
-               end
+    rule(stage: simple(:stage)) do |context|
+      { stage: convert_stage(context[:stage]) }
+    end
+
+    rule(amendment_stage: simple(:amendment_stage)) do |context|
+      { amendment_stage: convert_stage(context[:amendment_stage]) }
+    end
+
+    rule(corrigendum_stage: simple(:corrigendum_stage)) do |context|
+      { corrigendum_stage: convert_stage(context[:corrigendum_stage]) }
+    end
+
+    rule(language: simple(:language)) do |context|
+      if context[:language].to_s.include?("/")
+        { language: context[:language]
+          .to_s.split("/")
+          .map { |code| convert_language(code) }.join(",") }
+      else
+        { language: convert_language(context[:language]) }
+      end
+    end
+
+    rule(type: simple(:type)) do
+      russian_type = 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"
+        else
+          type
+        end
+      }
+    end
+
+    rule(copublisher: simple(:copublisher)) do
+      russian_copublisher = Russian::PUBLISHER.key(copublisher.to_s)
+      { copublisher: russian_copublisher&.to_s ||
+        case copublisher
+        when "CEI"
+          "IEC"
+        else
+          copublisher
+        end
       }
     end
+
+    rule(publisher: simple(:publisher)) do
+      russian_publisher = Russian::PUBLISHER.key(publisher.to_s)
+      { publisher: russian_publisher&.to_s || publisher }
+    end
+
+    def self.convert_stage(code)
+      russian_code = Russian::STAGE.key(code.to_s)
+      return russian_code.to_s if russian_code
+
+      case code
+      when "D"
+        "DIS"
+      when "FD"
+        "FDIS"
+      when "Fpr"
+        "PRF"
+      when "pD", "PD"
+        "CD"
+      else
+        code
+      end
+    end
+
+    def self.convert_language(code)
+      case code
+      when "R"
+        "ru"
+      when "F"
+        "fr"
+      when "E"
+        "en"
+      when "A"
+        "ar"
+      else
+        code
+      end
+    end
   end
 end

data/lib/pubid/iso/urn.rb

@@ -1,9 +1,18 @@
 module Pubid::Iso
-  class URN
-    attr_accessor :identifier
+  class Urn < Identifier
 
-    def initialize(identifier)
-      @identifier = identifier
+    STAGES = { PWI: 0,
+               NP: 10,
+               AWI: 20,
+               WD: 20.20,
+               CD: 30,
+               DIS: 40,
+               FDIS: 50,
+               PRF: 50,
+               IS: 60 }.freeze
+
+    def initialize(**opts)
+      opts.each { |key, value| send("#{key}=", value) }
     end
 
     def to_s
@@ -11,58 +20,104 @@ module Pubid::Iso
       # [[":" status] ":" edition]
       # [":" docversion] [":" language]
 
-      "urn:iso:std:#{originator}#{type}:#{identifier.number}#{part}#{stage}#{edition}#{supplement}#{language}"
+      if tctype
+        "urn:iso:doc:#{originator}:#{tctype.downcase}:#{tcnumber}#{sctype}#{wgtype}:#{number}"
+      else
+        "urn:iso:std:#{originator}#{type}:#{number}#{part}#{stage}#{edition}#{supplement}#{language}"
+      end
+    end
+
+    def tctype
+      return @tctype.join(":") if @tctype.is_a?(Array)
+
+      @tctype
+    end
+
+    def sctype
+      return unless @sctype
+
+      ":#{@sctype.downcase}:#{@scnumber}"
+    end
+
+    def wgtype
+      return unless @wgtype
+
+      if @wgnumber
+        ":#{@wgtype.downcase}:#{@wgnumber}"
+      else
+        ":#{@wgtype.downcase}"
+      end
     end
 
     def part
-      ":-#{identifier.part}" if identifier.part
+      ":-#{@part}" if @part
+    end
+
+    def render_stage(stage)
+      ":stage-#{sprintf('%05.2f', STAGES[stage.to_sym])}#{iteration}"
     end
 
     def stage
-      ":stage-#{identifier.stage}.#{sprintf('%02d', identifier.substage)}#{iteration}" if identifier.stage
+      return render_stage(@stage) if @stage
+
+      return render_stage(@amendment_stage) if @amendment_stage
+
+      render_stage(@corrigendum_stage) if @corrigendum_stage
     end
 
     def originator
       # originator    = "iso" / "iso-iec" / "iso-cie" / "iso-astm" /
       #   "iso-ieee" / "iec"
 
-      if identifier.copublisher
-        "#{identifier.publisher.downcase}-#{identifier.copublisher.downcase.gsub('/', '-')}"
+      if @copublisher
+        @copublisher = [@copublisher] unless @copublisher.is_a?(Array)
+        @publisher.downcase + @copublisher.map(&:to_s).sort.map do |copublisher|
+          "-#{copublisher.downcase.gsub('/', '-')}"
+        end.join
       else
-        identifier.publisher.downcase
+        @publisher.downcase
       end
     end
 
     def edition
-      ":ed-#{identifier.edition}" if identifier.edition
+      ":ed-#{@edition}" if @edition
     end
 
     def iteration
-      ".v#{identifier.iteration}" if identifier.iteration
+      ".v#{@iteration}" if @iteration
     end
 
     def type
       # type          = "data" / "guide" / "isp" / "iwa" /
       #   "pas" / "r" / "tr" / "ts" / "tta"
-
-      if identifier.type
-        ":#{identifier.type.downcase}"
+      if @type
+        ":#{@type.downcase}"
       end
     end
 
     def supplement
-      identifier.supplements&.map do |supplement|
-        if supplement[:supplement_number]
-          ":#{supplement[:supplement].to_s.downcase}:#{supplement[:supplement_number]}:v#{supplement[:supplement_version]}"
-        else
-          ":#{supplement[:supplement].to_s.downcase}:v#{supplement[:supplement_version]}"
-        end
-      end&.join
+      result = ""
+      if @amendment
+        result +=  if @amendment_number
+                     ":amd:#{@amendment_number}:v#{@amendment_version}"
+                   else
+                     ":amd:#{@amendment_version}:v1"
+                   end
+      end
+      if @corrigendum
+        result += if @corrigendum_number
+                    ":cor:#{@corrigendum_number}:v#{@corrigendum_version}"
+                  else
+                    ":cor:#{@corrigendum_version}:v1"
+                  end
+      end
+
+      result
     end
 
     def language
-      if identifier.language
-        ":#{identifier.language}"
+      if @language
+        ":#{@language}"
       end
     end
   end

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.1.1".freeze
+    VERSION = "0.1.4".freeze
   end
 end

data/lib/pubid/iso.rb

@@ -11,5 +11,7 @@ end
 require_relative "iso/errors"
 require_relative "iso/parser"
 require_relative "iso/transformer"
-require_relative "iso/urn"
 require_relative "iso/identifier"
+require_relative "iso/identifier/french"
+require_relative "iso/identifier/russian"
+require_relative "iso/urn"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-iso
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
 platform: ruby
 authors:
 - Ribose Inc.
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-03-06 00:00:00.000000000 Z
+date: 2022-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -109,6 +109,8 @@ files:
 - lib/pubid/iso.rb
 - lib/pubid/iso/errors.rb
 - lib/pubid/iso/identifier.rb
+- lib/pubid/iso/identifier/french.rb
+- lib/pubid/iso/identifier/russian.rb
 - lib/pubid/iso/parser.rb
 - lib/pubid/iso/transformer.rb
 - lib/pubid/iso/urn.rb
@@ -117,7 +119,7 @@ homepage: https://github.com/metanorma/pubid-iso
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -132,8 +134,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: Library to generate, parse and manipulate ISO PubID.
 test_files: []