pubid-iso 0.3.0 → 0.4.0

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

@@ -2,130 +2,147 @@ module Pubid::Iso::Renderer
   class Base < Pubid::Core::Renderer::Base
     attr_accessor :prerendered_params
 
-    TYPE_VALUES = {
-      tr: "TR",
-      ts: "TS",
-      isp: "ISP",
-      guide: "Guide",
-      pas: "PAS",
-      dpas: "DPAS",
+    TRANSLATION = {
+      russian: {
+        publisher: { "ISO" => "ИСО", "IEC" => "МЭК" },
+        stage: { "FDIS" => "ОПМС",
+                 "DIS" => "ПМС",
+                 "NP" => "НП",
+                 "AWI" => "АВИ",
+                 "CD" => "КПК",
+                 "PD" => "ПД",
+                 "FPD" => "ФПД" },
+        type: { "TS" => "ТС",
+                "TR" => "ТО",
+                "ISP" => "ИСП" },
+      },
+      french: {
+        publisher: { "IEC" => "CEI" },
+      },
     }.freeze
 
-    # Prerender parameters
-    def prerender(with_edition: true, **args)
-      @params[:type_stage] = @params.slice(:stage, :type) if @params[:stage] || @params[:type]
-      super
-    end
+    TYPE = "".freeze
 
-    def render_supplement(supplement_params, **args)
-      if supplement_params[:base].type == :amd
-        # render inner amendment (cor -> amd -> base)
-        render_supplement(supplement_params[:base].get_params, **args)
-      else
-        self.class.new(supplement_params[:base].get_params).render_base_identifier(
-          # always render year for identifiers with supplement
-          **args.merge({ with_date: true }),
-          )
-      end +
-        case supplement_params[:typed_stage].type.type
-        when :amd
-          render_amendments(
-            [Pubid::Iso::Amendment.new(**supplement_params.slice(:number, :year, :typed_stage, :edition, :iteration))],
-            args,
-            nil,
-            )
-        when :cor
-          render_corrigendums(
-            [Pubid::Iso::Corrigendum.new(**supplement_params.slice(:number, :year, :typed_stage, :edition, :iteration))],
-            args,
-            nil,
-            )
-          # copy parameters from Identifier only supported by Corrigendum
-        end +
-        (supplement_params[:base].language ? render_language(supplement_params[:base].language, args, nil) : "")
+    def render_base_identifier(**args)
+      prerender(**args)
+
+      render_identifier(@prerendered_params, args)
     end
 
     # Render identifier
     # @param with_edition [Boolean] include edition in output
     # @see Pubid::Core::Renderer::Base for another options
     def render(with_edition: true, with_language_code: :iso, with_date: true, **args)
-      # super(**args.merge({ with_edition: with_edition }))
-      if %i(amd cor).include? @params[:typed_stage]&.type&.type
-        render_supplement(@params, **args.merge({ with_date: with_date,
-                                                  with_language_code: with_language_code,
-                                                  with_edition: with_edition }))
+      render_base_identifier(**args.merge({ with_date: with_date,
+                                            with_language_code: with_language_code,
+                                            with_edition: with_edition })) +
+        @prerendered_params[:language].to_s
+    end
+
+    def render_base(_base, _opts, _params)
+    end
+
+    def render_type_prefix(params)
+      result = params[:typed_stage].nil? || params[:typed_stage].empty? ? self.class::TYPE : ""
+
+      if params[:stage] && !params[:stage].empty? && !result.empty?
+        " #{result}"
       else
-        render_base_identifier(**args.merge({ with_date: with_date,
-                                              with_language_code: with_language_code,
-                                              with_edition: with_edition })) +
-          @prerendered_params[:language].to_s
+        result
       end
+    end
 
+    def render_identifier(params, opts)
+      "%{publisher}%{typed_stage}%{stage}#{render_type_prefix(params)} %{number}%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{addendum}%{edition}" % params
     end
 
-    def render_identifier(params)
-      # typed_stage = if params[:typed_stage] && params[:typed_stage] != ""
-      #                 ((params[:copublisher] && !params[:copublisher].empty?) ? " " : "/") + params[:typed_stage].to_s
-      #               else
-      #                 ""
-      #               end
-      render_base(params, params[:typed_stage]) +
-        ("%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}" % params)
-    end
-
-    def render_typed_stage(typed_stage, _opts, params)
-      (params[:copublisher] ? " " : "/") + typed_stage.to_s
-    end
-
-    # def render_type_stage(values, opts, params)
-    #
-    #   # prerender stage and type before
-    #   stage = render_stage(values[:stage], opts, params)
-    #   type = values[:type]&.to_s
-    #   return unless type || stage
-    #
-    #   if type && stage
-    #     # don't add prefix for pdf format
-    #     if %w(DIS FDIS).include?(stage)
-    #       "#{render_short_stage(stage)}#{type}"
-    #     else
-    #       "#{stage} #{type}"
-    #     end
-    #   else
-    #     # when only type or stage
-    #     "#{type}#{stage}"
-    #   end
-    # end
-
-    def render_short_stage(stage)
-      case stage
-      when "DIS"
-        "D"
-      when "FDIS"
-        "FD"
+    def render_copublisher_string(publisher, copublishers, opts)
+      case copublishers
+      when String
+        if opts[:language]
+          copublishers = TRANSLATION[opts[:language]][:publisher][copublishers] || copublishers
+        end
+        [publisher, copublishers].join("/")
+      when Array
+        ([publisher] + copublishers.map(&:to_s).sort).map do |pub|
+          if opts[:language]
+            (TRANSLATION[opts[:language]][:publisher][pub] || pub).gsub('-', '/')
+          else
+            pub
+          end
+        end.join("/")
+      else
+        raise StandardError.new("copublisher must be a string or an array")
       end
     end
 
-    def render_stage(stage, opts, _params)
-      return if stage.nil? || (stage.abbr == "PRF" and !opts[:with_prf]) || stage.abbr == "IS"
+    def omit_post_publisher_symbol?(typed_stage, stage, opts)
+      # return false unless typed_stage
 
-      stage.abbr
+      (stage.nil? || stage.empty_abbr?(with_prf: opts[:with_prf])) && typed_stage.nil?
     end
 
-    def render_edition(edition, opts, _params)
-      " ED#{edition}" if opts[:with_edition]
+    def render_publisher(publisher, opts, params)
+
+      if opts[:language]
+        publisher = TRANSLATION[opts[:language]][:publisher][publisher] || publisher
+      end
+      # No copublishers
+      unless params[:copublisher]
+
+        # No copublisher and IS
+        # ISO xxx
+        if omit_post_publisher_symbol?(params[:typed_stage], params[:stage], opts)
+          return publisher
+        end
+
+        # No copublisher and not IS
+        # ISO/TR xxx
+        return "#{publisher}/"
+      end
+
+      publisher_string = render_copublisher_string(publisher, params[:copublisher], opts)
+      publisher_string.sub!("/IEC", "/CEI") if opts[:language] == :french
+
+      # With copublisher and IS
+      # ISO/IEC xxx
+      if omit_post_publisher_symbol?(params[:typed_stage], params[:stage], opts)
+        return publisher_string
+      end
+
+      # With copublisher but not IS
+      # ISO/IEC TR xxx
+      publisher_string + " "
     end
 
-    def render_iteration(iteration, _opts, _params)
-      ".#{iteration}"
+    def render_typed_stage(typed_stage, opts, params)
+      return nil if typed_stage.to_s.empty?
+
+      if opts[:language]
+        return TRANSLATION[opts[:language]][:stage][typed_stage.to_s] || typed_stage.to_s
+      end
+
+      typed_stage.to_s
+    end
+
+    def render_stage(stage, opts, params)
+      return if params[:typed_stage]
+      return if stage.empty_abbr?(with_prf: opts[:with_prf])
+
+      if opts[:language]
+        return TRANSLATION[opts[:language]][:stage][stage.to_s(with_prf: opts[:with_prf])] ||
+          stage.to_s(with_prf: opts[:with_prf])
+      end
+
+      stage.to_s(with_prf: opts[:with_prf])
     end
 
-    def render_amendments(amendments, opts, _params)
-      amendments.sort.map { |amendment| amendment.render_pubid(opts[:stage_format_long], opts[:with_date]) }.join("+")
+    def render_edition(edition, opts, _params)
+      " ED#{edition}" if opts[:with_edition]
     end
 
-    def render_corrigendums(corrigendums, opts, _params)
-      corrigendums.sort.map { |corrigendum| corrigendum.render_pubid(opts[:stage_format_long], opts[:with_date]) }.join("+")
+    def render_iteration(iteration, _opts, _params)
+      ".#{iteration}"
     end
 
     def render_language(language, opts, _params)
@@ -137,5 +154,19 @@ module Pubid::Iso::Renderer
       return ":#{year}" if params[:amendments] || params[:corrigendums]
       opts[:with_date] && ":#{year}" || ""
     end
+
+    def render_part(part, opts, _params)
+      return "-#{part.reverse.join('-')}" if part.is_a?(Array)
+
+      "-#{part}"
+    end
+
+    def render_addendum(addendum, _opts, _params)
+      if addendum[:year]
+        "/Add #{addendum[:number]}:#{addendum[:year]}"
+      else
+        "/Add #{addendum[:number]}"
+      end
+    end
   end
 end

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

@@ -0,0 +1,7 @@
+require_relative "supplement"
+
+module Pubid::Iso::Renderer
+  class Corrigendum < Supplement
+    TYPE = "Cor".freeze
+  end
+end

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

@@ -1,13 +1,15 @@
+require_relative "base"
+
 module Pubid::Iso::Renderer
   class Dir < Base
 
-    def render_identifier(params)
-      res = ("%{publisher}%{copublisher} DIR%{dirtype}%{number}%{year}%{supplement}" % params)
+    def render_identifier(params, opts)
+      res = ("%{publisher} DIR%{dirtype}%{number}%{year}%{supplement}" % params)
 
       if params.key?(:joint_document)
         joint_params = prerender_params(params[:joint_document].get_params, {})
         joint_params.default = ""
-        res += (" + %{publisher}%{copublisher}%{dirtype}%{number}%{year}%{supplement}" % joint_params)
+        res += (" + %{publisher}%{dirtype}%{number}%{year}%{supplement}" % joint_params)
       end
 
       res

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

@@ -0,0 +1,19 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class Guide < Base
+    def render_identifier(params, opts)
+      if opts[:language] == :french
+        "Guide %{publisher}%{stage} %{number}%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}" % params
+      elsif opts[:language] == :russian
+        "Руководство %{publisher}%{stage} %{number}%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}" % params
+      else
+        if params[:typed_stage] && !params[:typed_stage].empty?
+          "%{publisher}%{typed_stage}%{stage} %{number}%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}" % params
+        else
+          "%{publisher}%{stage} Guide %{number}%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}" % params
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class InternationalStandard < Base
+    def omit_post_publisher_symbol?(typed_stage, stage)
+      # return false unless typed_stage
+
+      !stage.nil? && !typed_stage.nil?
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class InternationalStandardizedProfile < Base
+
+    TYPE = "ISP".freeze
+
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "TR"
+      false
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class InternationalWorkshopAgreement < Base
+
+    TYPE = "IWA".freeze
+
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "TR"
+      false
+    end
+
+    def render_identifier(params, opts)
+      "%{typed_stage}%{stage}#{render_type_prefix(params)} %{number}%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{addendum}%{edition}" % params
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class PubliclyAvailableSpecification < Base
+
+    TYPE = "PAS".freeze
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "TR"
+      false
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class Recommendation < Base
+
+    TYPE = "R".freeze
+
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "R"
+      false
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class Supplement < Base
+    TYPE = "Suppl".freeze
+
+    # Render identifier
+    # @param with_edition [Boolean] include edition in output
+    # @see Pubid::Core::Renderer::Base for another options
+    def render(with_edition: true, with_language_code: :iso, with_date: true, **args)
+      @params[:base].to_s(lang: args[:language], with_edition: with_edition) +
+        super(
+          with_edition: with_edition, with_language_code: with_language_code, with_date: with_date,
+          base_type: @params[:base].type[:key],
+          **args
+        ) +
+        if @params[:base].language
+          render_language(@params[:base].language,
+                          { with_language_code: with_language_code }, nil).to_s
+        else
+          ""
+        end
+    end
+
+    def render_identifier(params, opts)
+      type_prefix = params[:typed_stage].nil? || params[:typed_stage].empty? ? self.class::TYPE : ""
+
+      if params[:stage].is_a?(Pubid::Core::Stage) && !params[:stage].empty_abbr?
+        type_prefix = " #{type_prefix}"
+      end
+
+      if self.class == Supplement
+        if opts[:base_type] == :dir
+          "%{typed_stage}%{stage}%{publisher} SUP%{number}%{part}%{iteration}%{year}%{edition}" % params
+        else
+          # type_prefix = "/#{type_prefix}" unless type_prefix.empty?
+          "/%{typed_stage}%{stage}#{type_prefix}%{number}%{part}%{iteration}%{year}%{edition}" % params
+        end
+      else
+        "/%{typed_stage}%{stage}#{type_prefix}%{number}%{part}%{iteration}%{year}%{edition}" % params
+      end
+    end
+
+    def render_number(number, opts, _params)
+      space = opts[:language] == :french ? "." : " "
+
+      "#{space}#{number}"
+    end
+
+    def render_stage(stage, opts, params)
+      # do not render stage when already has typed stage
+      stage unless params[:typed_stage]
+    end
+
+    def render_publisher(publisher, opts, params)
+      " #{publisher}" unless publisher.empty?
+    end
+
+    def render_edition(edition, opts, _params)
+      " Edition #{edition}" if opts[:with_edition]
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class TechnicalCommittee < Base
+
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "TR"
+      false
+    end
+
+    def render_identifier(params, opts)
+      if params[:wgnumber] && !params[:wgnumber].empty?
+        "%{publisher}%{tctype}%{stage} %{tcnumber}%{sctype}%{scnumber}%{wgtype}%{wgnumber} %{number}" % params
+      else
+        "%{publisher}%{tctype}%{stage} %{tcnumber}%{sctype}%{wgtype}%{scnumber} %{number}" % params
+      end
+    end
+
+    def render_tctype(tctype, _params, _opts)
+      if tctype.is_a?(Array)
+        tctype.join("/")
+      else
+        tctype
+      end
+    end
+
+    def render_number(number, _params, _opts)
+      "N#{number}"
+    end
+
+    def render_sctype(sctype, _params, _opts)
+      "/#{sctype}"
+    end
+
+    def render_wgtype(wgtype, _params, _opts)
+      "/#{wgtype}"
+    end
+
+    def render_wgnumber(wgnumber, _params, _opts)
+      " #{wgnumber}"
+    end
+
+    def render_scnumber(scnumber, _params, _opts)
+      " #{scnumber}"
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class TechnicalReport < Base
+
+    TYPE = "TR".freeze
+
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "TR"
+      false
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class TechnicalSpecification < Base
+
+    TYPE = "TS".freeze
+
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "TR"
+      false
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_relative "base"
+
+module Pubid::Iso::Renderer
+  class TechnologyTrendsAssessments < Base
+
+    TYPE = "TTA".freeze
+
+    def omit_post_publisher_symbol?(_typed_stage, _stage, _opts)
+      # always need post publisher symbol, because we always have to add "TR"
+      false
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative "urn-supplement"
+
+module Pubid::Iso::Renderer
+  class UrnAmendment < UrnSupplement
+    TYPE = "amd".freeze
+
+    def render_identifier(params)
+      "%{base}%{stage}:amd%{year}%{number}%{edition}" \
+      "#{@params[:base].language ? (':' + @params[:base].language) : ''}" % params
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative "urn-supplement"
+
+module Pubid::Iso::Renderer
+  class UrnCorrigendum < UrnSupplement
+    TYPE = "cor".freeze
+
+    def render_identifier(params)
+      "%{base}%{stage}:cor%{year}%{number}%{edition}" \
+      "#{@params[:base].language ? (':' + @params[:base].language) : ''}" % params
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require_relative "urn"
+
 module Pubid::Iso::Renderer
   class UrnDir < Urn
 
@@ -5,9 +7,15 @@ module Pubid::Iso::Renderer
       res = ("urn:iso:doc:%{publisher}%{copublisher}:dir%{dirtype}%{number}%{year}%{supplement}" % params)
 
       if params.key?(:joint_document)
-        joint_params = prerender_params(params[:joint_document].get_params, {})
-        joint_params.default = ""
-        res += (":%{publisher}%{copublisher}%{dirtype}%{number}%{supplement}" % joint_params)
+        if params[:joint_document].is_a?(Pubid::Iso::Identifier::Supplement)
+          joint_params = params[:joint_document].get_params
+          res += ":#{joint_params[:base].publisher.downcase}:sup:%{year}" % joint_params
+        else
+          joint_params = prerender_params(params[:joint_document].get_params, {})
+          joint_params.default = ""
+          res += (":%{publisher}%{copublisher}%{dirtype}%{number}%{supplement}" % joint_params)
+        end
+
       end
 
       res

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

@@ -0,0 +1,31 @@
+require_relative "urn"
+
+module Pubid::Iso::Renderer
+  class UrnSupplement < Urn
+    TYPE = "sup".freeze
+
+    def render_identifier(params)
+      "%{base}%{stage}:#{self.class::TYPE}%{publisher}%{year}%{number}%{edition}" \
+      "#{@params[:base].language ? (':' + @params[:base].language) : ''}" % params
+    end
+
+    def render_base(base, _opts, _params)
+      return base.urn if base.base || base.is_a?(Pubid::Iso::Identifier::Directives)
+
+      # to avoid rendering language as part of base
+      Urn.new(base.get_params).render
+    end
+
+    def render_number(number, _opts, params)
+      if params[:year]
+        ":v#{number}"
+      else
+        ":#{number}:v1"
+      end
+    end
+
+    def render_publisher(publisher, _opts, _params)
+      ":#{publisher.downcase}" unless publisher.empty?
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require_relative "urn"
+
 module Pubid::Iso::Renderer
   class UrnTc < Urn