pubid-iso 0.1.6 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3db426781c12fb80bbd99118bc9b601fe93473d0c9b395f88929ac8eb3b996d
-  data.tar.gz: 7e2c155d3397e1ac4888258c680357b204edb8252a3e03fa8d336292be85ccbb
+  metadata.gz: b09b867ebc673153defa32f6987a1f6337895789069e76388d8791cb9c8f2545
+  data.tar.gz: caa42c15191fca2b22905524f8ffa8765e137b4fb8fa96b693eec8626e3d46f2
 SHA512:
-  metadata.gz: 765bdaef471049f21f15ba5cf9f45bbb42edfe88baf53ee5f67d155fdba6f0b8ef8a1b8cf212a9f6d3d35ce289946c6c5281efd94e913d59274b9ea1a7143e8c
-  data.tar.gz: 628307f60259f11b97476d893861b73f1042104c940958ee695acc24069033e4689b0bfe490a641a6c7d557a5f8635ec6cf2140bed56d594910c8e2c46670d6f
+  metadata.gz: 251a4b42ce806cc3a55dc31923b07ea8c2202bacd563041d1fd4dd6bc8a4de0572fd8ff219b9f39bc58fba4e6edc713a33a86041b961d849567ac7cdbf7128bb
+  data.tar.gz: 45493ee2cc7deaade4a97ba422d87c9c76b0d9db9745ce1573a903be5669591897d9606a3cdd5dff03638d71aeb4c2ea94ed6ed59e92e6200741fceb28e35550

data/lib/pubid/iso/amendment.rb

@@ -0,0 +1,13 @@
+module Pubid::Iso
+  class Amendment < Supplement
+    def render_pubid
+      stage = render_pubid_stage
+      stage += " " unless stage.size == 0
+      "/#{stage}Amd #{render_pubid_number}"
+    end
+
+    def render_urn
+      "#{render_urn_stage}:amd#{render_urn_number}"
+    end
+  end
+end

data/lib/pubid/iso/corrigendum.rb

@@ -0,0 +1,13 @@
+module Pubid::Iso
+  class Corrigendum < Supplement
+    def render_pubid
+      stage = render_pubid_stage
+      stage += " " unless stage.size == 0
+      "/#{stage}Cor #{render_pubid_number}"
+    end
+
+    def render_urn
+      "#{render_urn_stage}:cor#{render_urn_number}"
+    end
+  end
+end

data/lib/pubid/iso/identifier.rb

@@ -1,201 +1,70 @@
 module Pubid::Iso
-  class Identifier
-    attr_accessor :number, :publisher, :copublisher, :stage, :substage, :part,
-                  :type, :year, :edition, :iteration, :supplements, :language,
-                  :amendment, :amendment_version, :amendment_number,
-                  :corrigendum, :corrigendum_version, :corrigendum_number,
+  class Identifier < Pubid::Core::Identifier
+    attr_accessor :stage, :substage,
+                  :iteration, :supplements,
                   :amendment_stage, :corrigendum_stage, :joint_document,
                   :tctype, :sctype, :wgtype, :tcnumber, :scnumber, :wgnumber,
-                  :urn_stage
-
-    LANGUAGES = {
-      "ru" => "R",
-      "fr" => "F",
-      "en" => "E",
-      "ar" => "A",
-    }.freeze
+                  :urn_stage, :dir, :dirtype, :supplement
 
     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(**get_params)
+      super
+      # if supplement
+      #   @supplement = Supplement.new(number: supplement[:year],
+      #                                publisher: supplement[:publisher],
+      #                                edition: supplement[:edition])
+      # end
     end
 
     def self.parse_from_title(title)
       title.split.reverse.inject(title) do |acc, part|
         return parse(acc)
-      rescue Pubid::Iso::Errors::ParseError
+      rescue Pubid::Core::Errors::ParseError
         # delete parts from the title until it's parseable
         acc.reverse.sub(part.reverse, "").reverse.strip
       end
     end
 
-    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)
+    class << self
+      def get_amendment_class
+        Pubid::Iso::Amendment
       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}"
+      def get_corrigendum_class
+        Pubid::Iso::Corrigendum
       end
-    end
-
-    def wgtype
-      return unless @wgtype
 
-      if @wgnumber
-        "/#{@wgtype} #{@wgnumber}"
-        else
-        "/#{@wgtype} #{@scnumber}"
+      def get_parser_class
+        Parser
       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
+      def get_transformer_class
+        Transformer
       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
+    def urn
+      (@tctype && Renderer::UrnTc || @dir && Renderer::UrnDir || Pubid::Core::Renderer::Urn).new(get_params).render
     end
 
-    def corrigendum
-      if @corrigendum_number
-        "Cor #{@corrigendum_version}:#{@corrigendum_number}"
+    def to_s(lang: nil, with_date: true, with_language_code: :iso)
+      # @pubid_language = lang
+      case lang
+      when :french
+        Renderer::French.new(get_params)
+      when :russian
+        Renderer::Russian.new(get_params)
       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]})"
+        if @tctype
+          Renderer::Tc.new(get_params)
+        elsif @dir
+          Renderer::Dir.new(get_params)
         else
-          "(#{@language})"
+          self.class.get_renderer_class.new(get_params)
         end
-      end
+      end.render(with_date: with_date, with_language_code: with_language_code) +
+        if @joint_document && !@dir
+          "|#{@joint_document}"
+        end.to_s
     end
-
   end
 end

data/lib/pubid/iso/parser.rb

@@ -1,33 +1,10 @@
-# from https://github.com/relaton/relaton-iso/issues/47#issuecomment-512251416
-# ISO {num}-{docpart}:{year} - docpart and year are optional. docpart is [\w-]+
-#   ISO/{stage} {num}-{docpart}:{year} or ISO/{subprefix} {stage} {num}:{year} - stages are WD, CD, DIS, FDIS, AWI
-# ISO/{subprefix} {stage} {num}-{docpart}:{year} - subpefixes are IEC, IEEE, IEC/IEEE, TR, R. Any other?
-# ISO {num}:{year}/{correction} {cornum}:{coryear} - corrections are Amd, DAmd, Cor. coryear is optional
-# ISO {num}:{year}/{corstage} {correction} {cornum}:{coryear} - corstages are CD, NP, AWI, PRF, WD, DIS. Any others?
-
 module Pubid::Iso
-  # ISO/IEC FDIS 7816-6
-  # ISO/IEC/IEEE 15289:2019
-  #
-  # Stage 10: NP (non-public)
-  # Stage 20: WD (non-public)
-  # Stage 30: CD
-  # Stage 40: DIS
-  # Stage 50: FDIS
-  # 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
-
+  class Parser < Pubid::Core::Parser
     rule(:stage) do
-      Russian::STAGE.values.reduce(
+      Renderer::Russian::STAGE.values.reduce(
         # other stages
-        str("NP") | str("WD") | str("CD") | str("DIS") | str("FDIS") | str("PRF") |
+        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|
@@ -35,18 +12,9 @@ module Pubid::Iso
       end
     end
 
-    # TYPES = {
-    #   "TS" => "technical-specification",
-    #   "TR" => "technical-report",
-    #   "PAS" => "publicly-available-specification",
-    #   "Guide" => "guide",
-    # }.freeze
-    # DATA|GUIDE|ISP|IWA|PAS|R|TR|TS|TTA
-    #       # type          = "data" / "guide" / "isp" / "iwa" /
-    #       #   "pas" / "r" / "tr" / "ts" / "tta"
     rule(:type) do
       (
-        Russian::TYPE.values.reduce(
+        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)
@@ -76,22 +44,13 @@ module Pubid::Iso
         str("CSC/SP") | str("CSC/FIN") | str("JAG")
     end
 
-    rule(:year) do
-      match('\d').repeat(4, 4).as(:year)
-    end
-
     rule(:part) do
       (str("-") | str("/")) >> space? >>
         (str("Amd") | str("Cor")).absent? >> (match['[\dA-Z]'] | str("-")).repeat(1).as(:part)
     end
 
-    rule(:originator) do
-      organization.as(:publisher) >>
-        (space? >> str("/") >> organization.as(:copublisher)).repeat
-    end
-
     rule(:organization) do
-      Russian::PUBLISHER.values.reduce(
+      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|
@@ -109,21 +68,23 @@ module Pubid::Iso
     end
 
     rule(:amendment) do
-      (str("/") >> stage.as(:amendment_stage)).maybe >>
+      ((str("/") >> stage.as(: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
+        (str("Amd") | str("AMD") | str("AM")) >>
+        str(".").maybe >>
+        space.maybe >>
+        digits.as(:version) >>
+        (str(":") >> digits.as(:number)).maybe).as(:amendments)
     end
 
     rule(:corrigendum) do
-      (str("/") >> stage.as(:corrigendum_stage)).maybe >>
+      ((str("/") >> stage.as(:stage)).maybe >>
       (str("/") | space).maybe >>
-        (str("Cor") | str("COR")).as(:corrigendum) >>
-        (space | str(".")) >>
-        digits.as(:corrigendum_version) >>
-        (str(":") >> digits.as(:corrigendum_number)).maybe
+        (str("Cor") | str("COR")) >>
+        str(".").maybe >>
+        space.maybe >>
+        digits.as(:version) >>
+        (str(":") >> digits.as(:number)).maybe).as(:corrigendums)
     end
 
     rule(:language) do
@@ -148,7 +109,20 @@ module Pubid::Iso
             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)
+        space >> str("N") >> space? >> digits.as(:number)
+    end
+
+    rule(:dir_supplement_edition) do
+      space >> (str("Edition") | str("Ed")) >> space >> digits.as(:edition)
+    end
+
+    rule(:dir_document_body) do
+      ((str("DIR") | str("Directives Part") | str("Directives, Part") | str("Directives,")).as(:dir) >> space).maybe >>
+        (str("JTC").as(:dirtype) >> space).maybe >>
+        (digits.as(:number) >> (str(":") >> year).maybe).maybe >>
+        (str(" -- Consolidated").maybe >> (space? >> (organization.as(:publisher) >> space).maybe >>
+          (str("SUP") | str("Supplement")) >> (str(":") >> year).maybe >>
+          dir_supplement_edition.maybe).as(:supplement)).maybe
     end
 
     rule(:std_document_body) do
@@ -176,7 +150,8 @@ module Pubid::Iso
         (guide_prefix.as(:type) >> space).maybe >>
         (stage.as(:stage) >> space).maybe >>
         originator >> (space | str("/")) >>
-        (tc_document_body | std_document_body)
+        (tc_document_body | std_document_body | (dir_document_body >>
+          (str(" + ") >> (originator >> space >> dir_document_body).as(:joint_document)).maybe))
     end
 
     rule(:root) { identifier }

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

@@ -0,0 +1,33 @@
+module Pubid::Iso::Renderer
+  class Dir < Pubid::Core::Renderer::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.default = ""
+        res += (" + %{publisher}%{copublisher}%{dirtype}%{number}%{year}%{supplement}" % joint_params)
+      end
+
+      res
+    end
+
+    def render_number(number, _opts, _params)
+      " #{number}"
+    end
+
+    def render_dirtype(dirtype, _opts, _params)
+      " #{dirtype}"
+    end
+
+    def render_supplement(supplement, _opts, _params)
+      if supplement.publisher && supplement.publisher != ""
+        " #{supplement.publisher} SUP"
+      else
+        " SUP"
+      end + (supplement.number && ":#{supplement.number}" || "") +
+        (supplement.edition && " Edition #{supplement.edition}" || "")
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Pubid::Iso::Renderer
+  class French < Pubid::Core::Renderer::Base
+    def render_identifier(params)
+      if params[:type] == " Guide"
+        params[:type] = ""
+        "Guide #{super(params)}"
+      else
+        super
+      end
+    end
+
+    def render_copublisher(copublisher, opts, params)
+      "/#{copublisher.sub("IEC", "CEI")}"
+    end
+
+    def render_corrigendums(corrigendums, _opts, _params)
+      super.gsub(" ", ".")
+    end
+
+    def render_amendments(amendments, _opts, _params)
+      super.gsub(" ", ".")
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Pubid::Iso::Renderer
+  class Russian < Pubid::Core::Renderer::Base
+    PUBLISHER = { "ISO" => "ИСО", "IEC" => "МЭК" }.freeze
+    STAGE = { "FDIS" => "ОПМС",
+              "DIS" => "ПМС",
+              "NP" => "НП",
+              "AWI" => "АВИ",
+              "CD" => "КПК",
+              "PD" => "ПД",
+              "FPD" => "ФПД",
+
+
+    }.freeze
+
+    TYPE = { "Guide" => "Руководство",
+             "TS" => "ТС",
+             "TR" => "ТО",
+             "ISP" => "ИСП",
+    }.freeze
+
+    def render_identifier(params)
+      if params[:type] == " Guide"
+        params[:type] = ""
+        "Руководство #{super(params)}"
+      else
+        super
+      end
+    end
+
+    def render_publisher(publisher, _opts, _params)
+      PUBLISHER[publisher]
+    end
+
+    def render_copublisher(copublisher, _opts, _params)
+      # (!@copublisher.is_a?(Array) && [@copublisher]) || @copublisher
+      if copublisher.is_a?(Array)
+        copublisher.map(&:to_s).sort.map do |copublisher|
+          "/#{PUBLISHER[copublisher].gsub('-', '/')}"
+        end.join
+      else
+        "/#{PUBLISHER[copublisher]}"
+      end
+    end
+
+    def render_stage(stage, _opts, params)
+      if params[:copublisher]
+        " #{STAGE[stage]}"
+      else
+        "/#{STAGE[stage]}"
+      end
+    end
+
+    def render_corrigendums(corrigendums, _opts, _params)
+      super.gsub(" ", ".")
+    end
+
+    def render_amendments(amendments, _opts, _params)
+      super.gsub(" ", ".")
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Pubid::Iso::Renderer
+  class Tc < Pubid::Core::Renderer::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
+    end
+
+    # TC 184/SC/WG 4 - no wg number
+    # TC 184/SC 4/WG 12 - separate sc and wg number
+    def render_sctype(sctype, _opts, params)
+      if params[:wgnumber] || !params[:wgtype]
+        "/#{sctype} #{params[:scnumber]}"
+      else
+        "/#{sctype}"
+      end
+    end
+
+    def render_wgtype(wgtype, _opts, params)
+      if params[:wgnumber]
+        "/#{wgtype} #{params[:wgnumber]}"
+      else
+        "/#{wgtype} #{params[:scnumber]}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Pubid::Iso::Renderer
+  class UrnDir < Pubid::Core::Renderer::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.default = ""
+        res += (":%{publisher}%{copublisher}%{dirtype}%{number}%{supplement}" % joint_params)
+      end
+
+      res
+    end
+
+    def render_number(number, _opts, _params)
+      ":#{number}"
+    end
+
+    def render_dirtype(dirtype, _opts, _params)
+      ":#{dirtype.downcase}"
+    end
+
+    def render_supplement(supplement, _opts, _params)
+      if supplement.publisher && supplement.publisher != ""
+        ":sup:#{supplement.publisher.downcase}"
+      else
+        ":sup"
+      end + (supplement.number && ":#{supplement.number}" || "") +
+        (supplement.edition && ":ed-#{supplement.edition}" || "")
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Pubid::Iso::Renderer
+  class UrnTc < Pubid::Core::Renderer::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
+    end
+
+    def render_sctype(sctype, _opts, params)
+      ":#{sctype.downcase}:#{params[:scnumber]}"
+    end
+
+    def render_wgtype(wgtype, _opts, params)
+      if params[:wgnumber]
+        ":#{wgtype.downcase}:#{params[:wgnumber]}"
+      else
+        ":#{wgtype.downcase}"
+      end
+    end
+  end
+end

data/lib/pubid/iso/supplement.rb

@@ -0,0 +1,24 @@
+module Pubid::Iso
+  class Supplement < Pubid::Core::Supplement
+    attr_accessor :stage, :publisher, :edition
+
+    def initialize(stage: nil, version: nil, publisher: nil, edition: nil, **args)
+      super(version: version, **args)
+      @stage = stage
+      @publisher = publisher.to_s
+      @edition = edition
+    end
+
+    def render_pubid_stage
+      ((@stage && @stage) || "")
+    end
+
+    def render_urn_stage
+      ((@stage && ":stage-#{sprintf('%05.2f', Pubid::Core::Renderer::Urn::STAGES[@stage.to_sym])}") || "")
+    end
+
+    def <=>(other)
+      (super == 0) && ((stage.nil? || stage == other.stage) && 0 || -1) || super
+    end
+  end
+end

data/lib/pubid/iso/transformer.rb

@@ -8,12 +8,18 @@ module Pubid::Iso
       { stage: convert_stage(context[:stage]) }
     end
 
-    rule(amendment_stage: simple(:amendment_stage)) do |context|
-      { amendment_stage: convert_stage(context[:amendment_stage]) }
+    rule(amendments: subtree(:amendments)) do |context|
+      if context[:amendments].key?(:stage)
+        context[:amendments][:stage] = convert_stage(context[:amendments][:stage])
+      end
+      context
     end
-
-    rule(corrigendum_stage: simple(:corrigendum_stage)) do |context|
-      { corrigendum_stage: convert_stage(context[:corrigendum_stage]) }
+    #
+    rule(corrigendums: subtree(:corrigendums)) do |context|
+      if context[:corrigendums].key?(:stage)
+        context[:corrigendums][:stage] = convert_stage(context[:corrigendums][:stage])
+      end
+      context
     end
 
     rule(language: simple(:language)) do |context|
@@ -27,7 +33,7 @@ module Pubid::Iso
     end
 
     rule(type: simple(:type)) do
-      russian_type = Russian::TYPE.key(type.to_s)
+      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
@@ -44,7 +50,7 @@ module Pubid::Iso
     end
 
     rule(copublisher: simple(:copublisher)) do
-      russian_copublisher = Russian::PUBLISHER.key(copublisher.to_s)
+      russian_copublisher = Renderer::Russian::PUBLISHER.key(copublisher.to_s)
       { copublisher: russian_copublisher&.to_s ||
         case copublisher
         when "CEI"
@@ -56,15 +62,38 @@ module Pubid::Iso
     end
 
     rule(publisher: simple(:publisher)) do
-      russian_publisher = Russian::PUBLISHER.key(publisher.to_s)
+      russian_publisher = Renderer::Russian::PUBLISHER.key(publisher.to_s)
       { publisher: russian_publisher&.to_s || publisher }
     end
 
+    # rule(year: simple(:year)) do
+    #   { year: year.to_i }
+    # end
+    #
+    rule(publisher: simple(:publisher), supplement: subtree(:supplement)) do |context|
+      context[:supplement] =
+        Supplement.new(number: context[:supplement][:year],
+                       publisher: context[:supplement][:publisher],
+                       edition: context[:supplement][:edition])
+      context
+    end
+
+    rule(supplement: subtree(:supplement)) do |context|
+      context[:supplement] =
+        Supplement.new(number: context[:supplement][:year],
+                       publisher: context[:supplement][:publisher],
+                       edition: context[:supplement][:edition])
+      context
+    end
+
+
     def self.convert_stage(code)
-      russian_code = Russian::STAGE.key(code.to_s)
+      russian_code = Renderer::Russian::STAGE.key(code.to_s)
       return russian_code.to_s if russian_code
 
       case code
+      when "NWIP"
+        "NP"
       when "D"
         "DIS"
       when "FD"

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.1.6".freeze
+    VERSION = "0.1.9".freeze
   end
 end

data/lib/pubid/iso.rb

@@ -8,10 +8,17 @@ module Pubid
   end
 end
 
+require "pubid-core"
 require_relative "iso/errors"
 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/identifier/french"
-require_relative "iso/identifier/russian"
-require_relative "iso/urn"
+require_relative "iso/renderer/french"
+require_relative "iso/renderer/russian"
+require_relative "iso/renderer/tc"
+require_relative "iso/renderer/urn-tc"
+require_relative "iso/renderer/dir"
+require_relative "iso/renderer/urn-dir"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-iso
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.9
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-01 00:00:00.000000000 Z
+date: 2022-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pubid-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: Library to generate, parse and manipulate ISO PubID.
 email:
 - open.source@ribose.com
@@ -107,13 +121,19 @@ files:
 - README.adoc
 - lib/pubid-iso.rb
 - lib/pubid/iso.rb
+- lib/pubid/iso/amendment.rb
+- lib/pubid/iso/corrigendum.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/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/supplement.rb
 - lib/pubid/iso/transformer.rb
-- lib/pubid/iso/urn.rb
 - lib/pubid/iso/version.rb
 homepage: https://github.com/metanorma/pubid-iso
 licenses:

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

@@ -1,32 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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/urn.rb

@@ -1,128 +0,0 @@
-module Pubid::Iso
-  class Urn < 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
-      # docidentifier = originator [":" type] ":" docnumber [":" partnumber]
-      # [[":" status] ":" edition]
-      # [":" docversion] [":" 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
-      ":-#{@part}" if @part
-    end
-
-    def render_stage(stage)
-      return ":stage-#{sprintf('%05.2f', stage)}#{iteration}" if stage.is_a?(Float)
-
-      ":stage-#{sprintf('%05.2f', STAGES[stage.to_sym])}#{iteration}"
-    end
-
-    def stage
-      return render_stage(@urn_stage) if @urn_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 @copublisher
-        @copublisher = [@copublisher] unless @copublisher.is_a?(Array)
-        @publisher.downcase + @copublisher.map(&:to_s).sort.map do |copublisher|
-          "-#{copublisher.downcase.gsub('/', '-')}"
-        end.join
-      else
-        @publisher.downcase
-      end
-    end
-
-    def edition
-      ":ed-#{@edition}" if @edition
-    end
-
-    def iteration
-      ".v#{@iteration}" if @iteration
-    end
-
-    def type
-      # type          = "data" / "guide" / "isp" / "iwa" /
-      #   "pas" / "r" / "tr" / "ts" / "tta"
-      if @type
-        ":#{@type.downcase}"
-      end
-    end
-
-    def supplement
-      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 @language
-        ":#{@language}"
-      end
-    end
-  end
-end