pubid-iso 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 821262e1b683c07f484d9102195fe832fd1eb00fb3a6b23f713893f081a527f3
-  data.tar.gz: 105da964ba57e1c703bf4d77f485a3fc981660b218b4bf019376f937758a4f6c
+  metadata.gz: 583ae9e428707932e9c3bc08eb9b726ea3e1f90dbf8c9fdba05e7b12e98302a2
+  data.tar.gz: 2fc723a9027e6bd49c6643b07618dcb68d38295846488c2f34513260f145ca57
 SHA512:
-  metadata.gz: 1e5fb2bdd1b05f02c788f4b546fa0f6b2054ef0ab01dd4b59961e8c92ccd063a95b655d04969062c2d3674ab7511058b22e7882e586c9ae00e666065592cc5d3
-  data.tar.gz: d5ded0494dbf495d81da9a98b25d72ed90303a343159bbe4d30315d857ae19e0824437f0ebbb0e47371c6f89565b39ca9d4f08bdc5b4bc8358656f7a56b54795
+  metadata.gz: f623fd9c0dadc20861cfed1c9a8ed788f5a5122d50835913689c69df5e67b1671141f7ad09af16e1bfccc186bc7c6144104f44c911561c910dea7d9c5b6d715e
+  data.tar.gz: e48de733a3ade64447d41ddd29b170eb13c1c60281b4f1d5cc27882f64a710706e9df87c001a827fd0ccc082843b882b7c78c69b5ff9a57649c1234a5f3af66f

data/lib/pubid/iso/amendment.rb

@@ -1,6 +1,5 @@
 module Pubid::Iso
   class Amendment < Supplement
-
     def render_pubid
       stage = render_pubid_stage
       stage += " " unless stage.size == 0

data/lib/pubid/iso/corrigendum.rb

@@ -1,6 +1,5 @@
 module Pubid::Iso
   class Corrigendum < Supplement
-
     def render_pubid
       stage = render_pubid_stage
       stage += " " unless stage.size == 0

data/lib/pubid/iso/identifier.rb

@@ -1,190 +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
+                  :urn_stage, :dir, :dirtype, :supplement
 
-    LANGUAGES = {
-      "ru" => "R",
-      "fr" => "F",
-      "en" => "E",
-      "ar" => "A",
-    }.freeze
-
-    def initialize(amendment: nil, amendment_number: nil, amendment_version: nil,
-                   amendment_stage: nil,
-                   corrigendum: nil, corrigendum_number: nil, corrigendum_version: nil,
-                   corrigendum_stage: nil, **opts)
-      if amendment_version
-        @amendment = Amendment.new(number: amendment_number,
-                                   version: amendment_version,
-                                   stage: amendment_stage)
-      end
-      if corrigendum_version
-        @corrigendum = Corrigendum.new(number: corrigendum_number,
-                                   version: corrigendum_version,
-                                   stage: corrigendum_stage)
-      end
-
-      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)
+    def initialize(**opts)
+      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)}"
+      def get_corrigendum_class
+        Pubid::Iso::Corrigendum
       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_parser_class
+        Parser
       end
-    end
 
-    def wgtype
-      return unless @wgtype
-
-      if @wgnumber
-        "/#{@wgtype} #{@wgnumber}"
-        else
-        "/#{@wgtype} #{@scnumber}"
+      def get_transformer_class
+        Transformer
       end
     end
 
-    def copublisher
-      return nil unless @copublisher
-
-      (!@copublisher.is_a?(Array) && [@copublisher]) || @copublisher
+    def urn
+      (@tctype && Renderer::UrnTc || @dir && Renderer::UrnDir || Pubid::Core::Renderer::Urn).new(get_params).render
     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
+    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
-        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 supplements
-      result = @amendment&.version && @amendment.render_pubid || ""
-
-      result + (@corrigendum&.version && @corrigendum.render_pubid || "")
-    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,31 +1,7 @@
-# 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("IS") | str("AWI") | str("PWI") |
@@ -35,18 +11,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 +43,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 +67,21 @@ 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) >>
+        (str("Amd") | str("AMD") | str("AM")) >>
         (space | str(".")) >>
-        digits.as(:amendment_version) >>
-        (str(":") >> digits.as(:amendment_number)).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) >>
+        (str("Cor") | str("COR")) >>
         (space | str(".")) >>
-        digits.as(:corrigendum_version) >>
-        (str(":") >> digits.as(:corrigendum_number)).maybe
+        digits.as(:version) >>
+        (str(":") >> digits.as(:number)).maybe).as(:corrigendums)
     end
 
     rule(:language) do
@@ -148,7 +106,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 +147,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

@@ -1,37 +1,24 @@
 module Pubid::Iso
-  class Supplement
-    attr_accessor :version, :number, :stage
+  class Supplement < Pubid::Core::Supplement
+    attr_accessor :stage, :publisher, :edition
 
-    def initialize(version:, number:, stage: nil)
-      @version, @number, @stage = version, number, stage
-    end
-
-    def ==(other)
-      other.version == version && (number.nil? || other.number == number) && (stage.nil? || other.stage == stage)
+    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_pubid_number
-        if @number
-          "#{@version}:#{@number}"
-        else
-          "#{@version}"
-        end
-    end
-
     def render_urn_stage
-      ((@stage && ":stage-#{sprintf('%05.2f', Urn::STAGES[@stage.to_sym])}") || "")
+      ((@stage && ":stage-#{sprintf('%05.2f', Pubid::Core::Renderer::Urn::STAGES[@stage.to_sym])}") || "")
     end
 
-    def render_urn_number
-        if @number
-          ":#{@number}:v#{@version}"
-        else
-          ":#{@version}:v1"
-        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,12 +62,33 @@ 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

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.1.7".freeze
+    VERSION = "0.1.8".freeze
   end
 end

data/lib/pubid/iso.rb

@@ -8,6 +8,7 @@ module Pubid
   end
 end
 
+require "pubid-core"
 require_relative "iso/errors"
 require_relative "iso/parser"
 require_relative "iso/transformer"
@@ -15,6 +16,9 @@ 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.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-02 00:00:00.000000000 Z
+date: 2022-07-20 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
@@ -111,12 +125,15 @@ files:
 - 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,24 +0,0 @@
-module Pubid::Iso
-  class French < Identifier
-    def initialize(**opts)
-      opts.each { |key, value| send("#{key}=", value) }
-    end
-
-    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 supplements
-      super.gsub(" ", ".")
-    end
-  end
-end

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

@@ -1,49 +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 initialize(**opts)
-      opts.each { |key, value| send("#{key}=", value) }
-    end
-
-    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
-
-    def supplements
-      super.gsub(" ", ".")
-    end
-  end
-end

data/lib/pubid/iso/urn.rb

@@ -1,114 +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
-
-      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 = @amendment&.render_urn || ""
-
-      result += @corrigendum&.render_urn || ""
-
-      result
-    end
-
-    def language
-      if @language
-        ":#{@language}"
-      end
-    end
-  end
-end