pubid-iso 0.2.1 → 0.3.0

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

@@ -1,60 +1,115 @@
 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",
+    }.freeze
+
+    # Prerender parameters
+    def prerender(with_edition: true, **args)
+      @params[:type_stage] = @params.slice(:stage, :type) if @params[:stage] || @params[:type]
+      super
+    end
+
+    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) : "")
+    end
+
     # Render identifier
     # @param with_edition [Boolean] include edition in output
     # @see Pubid::Core::Renderer::Base for another options
-    def render(with_edition: true, **args)
-      params = prerender_params(@params,
-                                { with_edition: with_edition }.merge(args))
-      # render empty string when the key is not exist
-      params.default = ""
+    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 }))
+      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
+      end
 
-      render_identifier(params)
     end
 
     def render_identifier(params)
-      if @params[:type] && @params[:stage]
-        if %w(DIS FDIS).include?(@params[:stage].abbr)
-          render_base(params, "#{render_short_stage(@params[:stage].abbr)}#{@params[:type]}")
-        else
-          if params[:copublisher] && !params[:copublisher].empty?
-            render_base(params, "%{type}%{stage}" % params)
-          else
-            render_base(params, "%{stage}%{type}" % params)
-          end
-        end
-      else
-        render_base(params, "%{type}%{stage}" % params)
-      end +
-        "%{part}%{iteration}%{year}%{amendments}%{corrigendums}%{edition}%{language}" % 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_short_stage(stage)
-      (params[:copublisher] ? " " : "/") +
-        case stage
-        when "DIS"
-          "D"
-        when "FDIS"
-          "FD"
-        end
+    def render_typed_stage(typed_stage, _opts, params)
+      (params[:copublisher] ? " " : "/") + typed_stage.to_s
     end
 
-    def render_type(type, opts, params)
-      if params[:copublisher] || (params[:stage] && params[:stage].abbr != "IS")
-        " #{type}"
-      else
-        "/#{type}"
+    # 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"
       end
     end
 
-    def render_stage(stage, opts, params)
-      return if (stage.abbr == "PRF" and !opts[:with_prf]) || stage.abbr == "IS"
+    def render_stage(stage, opts, _params)
+      return if stage.nil? || (stage.abbr == "PRF" and !opts[:with_prf]) || stage.abbr == "IS"
 
-      if params[:copublisher]
-        " #{stage.abbr}"
-      else
-        "/#{stage.abbr}"
-      end
+      stage.abbr
     end
 
     def render_edition(edition, opts, _params)

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

@@ -2,7 +2,7 @@ module Pubid::Iso::Renderer
   class Dir < Base
 
     def render_identifier(params)
-      res = ("%{publisher}%{copublisher} DIR%{dirtype}%{number}%{year}%{supplement}%{language}" % params)
+      res = ("%{publisher}%{copublisher} DIR%{dirtype}%{number}%{year}%{supplement}" % params)
 
       if params.key?(:joint_document)
         joint_params = prerender_params(params[:joint_document].get_params, {})

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

@@ -1,8 +1,13 @@
 module Pubid::Iso::Renderer
   class French < Base
+    def render_typed_stage(typed_stage, opts, params)
+      return nil if typed_stage.type == :guide
+
+      super
+    end
+
     def render_identifier(params)
-      if params[:type] == " Guide"
-        params[:type] = ""
+      if @params[:typed_stage]&.type == :guide
         "Guide #{super(params)}"
       else
         super

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

@@ -18,9 +18,16 @@ module Pubid::Iso::Renderer
              "ISP" => "ИСП",
     }.freeze
 
+    def render_typed_stage(typed_stage, opts, params)
+      return nil if typed_stage.type == :guide
+
+      return (params[:copublisher] ? " " : "/") + STAGE[typed_stage.to_s] if STAGE.key?(typed_stage.to_s)
+
+      super
+    end
+
     def render_identifier(params)
-      if params[:type] == " Guide"
-        params[:type] = ""
+      if @params[:typed_stage]&.type == :guide
         "Руководство #{super(params)}"
       else
         super
@@ -43,11 +50,7 @@ module Pubid::Iso::Renderer
     end
 
     def render_stage(stage, _opts, params)
-      if params[:copublisher]
-        " #{STAGE[stage.abbr]}"
-      else
-        "/#{STAGE[stage.abbr]}"
-      end
+      STAGE[stage.abbr] unless stage.nil?
     end
 
     def render_corrigendums(corrigendums, _opts, _params)

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

@@ -10,13 +10,42 @@ module Pubid::Iso::Renderer
                PRF: 50,
                IS: 60 }.freeze
 
+    def prerender(with_edition: true, **args)
+      @params[:type_stage] = @params.slice(:stage, :type) if @params[:stage] || @params[:type]
+      super
+    end
+
+    # Render identifier
+    # @param with_edition [Boolean] include edition in output
+    # @see Pubid::Core::Renderer::Base for another options
+    def render(with_edition: true, **args)
+      # copy type from typed stage
+      @params[:type] = @params[:typed_stage].type if @params[:typed_stage] && @params[:typed_stage].type
+      super(**args.merge({ with_edition: with_edition }))
+    end
+
     def render_identifier(params)
-      render_base(params) + "%{stage}"\
-      "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}%{language}" % params
+      render_base(params) + "%{typed_stage}"\
+      "%{corrigendum_stage}%{iteration}%{edition}%{amendments}%{corrigendums}" % params
+    end
+
+    def render_typed_stage(typed_stage, _opts, _params)
+      ":stage-#{typed_stage.stage.harmonized_code}" if typed_stage.stage
+    end
+    # def render_stage(stage, _opts, params)
+    #   ":stage-#{stage.harmonized_code}"
+    # end
+
+    def render_iteration(iteration, _opts, params)
+      ".v#{iteration}" if params[:typed_stage]&.stage
+    end
+
+    def render_type(type, _, _)
+      ":#{type.to_s.downcase}" unless type == :is
     end
 
-    def render_stage(stage, _opts, params)
-      ":stage-#{stage.harmonized_code}"
+    def render_year(year, _opts, _params)
+      ":#{year}"
     end
   end
 end

data/lib/pubid/iso/stage.rb

@@ -2,17 +2,22 @@ module Pubid::Iso
   class Stage
     attr_accessor :abbr, :harmonized_code
 
-    STAGES = { PWI: "00.00",
-               NP: "10.00",
+    STAGES = { PWI: %w[00.00 00.20 00.60 00.98 00.99],
+               NP: %w[10.00 10.20 10.60 10.98 10.92],
                AWI: %w[20.00 10.99],
                WD: %w[20.20 20.60 20.98 20.99],
-               CD: "30.00",
-               DIS: "40.00",
-               FDIS: "50.00",
-               PRF: "60.00",
-               IS: "60.60" }.freeze
+               CD: %w[30.00 30.20 30.60 30.92 30.98 30.99],
+               PRF: "60.00" }.freeze
 
 
+    STAGE_NAMES = {
+      WD: "Working Draft",
+      PWI: "Preliminary Work Item",
+      NP: "New Proposal",
+      CD: "Committee Draft",
+      PRF: "Proof of a new International Standard",
+    }.freeze
+
     # @param abbr [String, Symbol] abbreviation eg. :PWI, :WD
     # @param harmonized_code [String, Float, HarmonizedStageCode]
     def initialize(abbr: nil, harmonized_code: nil)
@@ -22,27 +27,38 @@ module Pubid::Iso
         @harmonized_code = if harmonized_code.is_a?(HarmonizedStageCode)
                              harmonized_code
                            else
-                             HarmonizedStageCode.new(*harmonized_code.to_s.split("."))
+                             HarmonizedStageCode.new(harmonized_code)
                            end
-        @abbr ||= lookup_abbr(@harmonized_code.to_s) || lookup_abbr("#{@harmonized_code.stage}.00")
+        @abbr ||= lookup_abbr(@harmonized_code.stages)
+        # unless @harmonized_code.fuzzy?
+        #   @abbr ||= lookup_abbr(@harmonized_code.to_s) || lookup_abbr("#{@harmonized_code.stage}.00")
+        # end
       end
 
       if abbr
         raise Errors::StageInvalidError, "#{abbr} is not valid stage" unless STAGES.key?(abbr.to_sym)
 
-        @harmonized_code ||= HarmonizedStageCode.new(*lookup_code(abbr).split("."))
+        @harmonized_code ||= HarmonizedStageCode.new(lookup_code(abbr))
       end
     end
 
     # Lookup for abbreviated code by numeric stage code
-    # @param lookup_code [String] stage code, e.g. "00.00", "20.20"
+    # @param lookup_code [String, Array] stage code or array of stage codes,
+    #   e.g. "00.00", "20.20", ["00.00", "00.20"]
     def lookup_abbr(lookup_code)
+      lookup_code = lookup_code.first if lookup_code.is_a?(Array) && lookup_code.count == 1
+
       STAGES.each do |abbr, codes|
         case codes
         when Array
-          codes.each do |code|
-            return abbr if code == lookup_code
+          if lookup_code.is_a?(Array)
+            return abbr if codes == lookup_code
+          else
+            return abbr if codes.include?(lookup_code)
           end
+          # codes.each do |code|
+          #   return abbr if code == lookup_code
+          # end
         when lookup_code
           return abbr
         end
@@ -52,8 +68,8 @@ module Pubid::Iso
     end
 
     def lookup_code(lookup_abbr)
-      code = STAGES[lookup_abbr.to_sym]
-      code.is_a?(Array) ? code.first : code
+      STAGES[lookup_abbr.to_sym]
+      # code.is_a?(Array) ? code.first : code
     end
 
     def self.parse(stage)
@@ -66,9 +82,22 @@ module Pubid::Iso
       end
     end
 
+    def self.has_stage?(stage)
+      if stage.is_a?(Stage)
+        STAGES.key?(stage.abbr.to_sym)
+      else
+        STAGES.key?(stage.to_sym) || /\A[\d.]+\z/.match?(stage)
+      end
+    end
+
     # Compares one stage with another
     def ==(other)
       other&.harmonized_code == harmonized_code
     end
+
+    # Return stage name, eg. "Draft International Standard" for "DIS"
+    def name
+      STAGE_NAMES[abbr.to_sym]
+    end
   end
 end

data/lib/pubid/iso/supplement.rb

@@ -1,34 +1,36 @@
 module Pubid::Iso
   class Supplement < Pubid::Core::Supplement
-    attr_accessor :stage, :publisher, :edition, :iteration
+    attr_accessor :typed_stage, :publisher, :edition, :iteration
 
     # @param stage [Stage, Symbol, String] stage, e.g. "PWI", "NP", "50.00", Stage.new(abbr: :WD)
-    # @param publisher [String] publisher, e.g. "ISO", "IEC"
+    # @param publisher [String] publisher, e.g. "ISO", "IEC" (only for DIR documents)
     # @param edition [Integer] edition, e.g. 1, 2, 3
     # @param iteration [Integer] iteration, e.g. 1, 2, 3
     # @see Pubid::Core::Supplement for other options
-    def initialize(stage: nil, publisher: nil, edition: nil, iteration: nil, **args)
+    def initialize(typed_stage: nil, publisher: nil, edition: nil, iteration: nil, **args)
       super(**args)
-      @stage = stage.is_a?(Stage) ? stage : Stage.parse(stage) if stage
+      @typed_stage = TypedStage.parse(typed_stage) if typed_stage
+      # for DIR identifiers only
       @publisher = publisher.to_s
       @edition = edition&.to_i
       @iteration = iteration&.to_i
 
-      if @iteration && @stage.nil?
+      if @iteration && @typed_stage.nil?
         raise Errors::PublishedIterationError.new("cannot assign iteration to published supplement")
       end
     end
 
     def render_pubid_stage
-      ((@stage && @stage.abbr != "IS" && @stage.abbr) || "")
+      # @typed_stage.stage.abbr != "IS" &&
+      ((@typed_stage && @typed_stage.to_s) || "")
     end
 
     def render_urn_stage
-      ((@stage && ":stage-#{@stage.harmonized_code}") || "")
+      ((@typed_stage&.stage && ":stage-#{@typed_stage.stage.harmonized_code}") || "")
     end
 
     def <=>(other)
-      (super == 0) && ((stage.nil? || stage == other.stage) && 0 || -1) || super
+      (super == 0) && ((typed_stage.nil? || typed_stage == other.typed_stage) && 0 || -1) || super
     end
 
     def render_iteration

data/lib/pubid/iso/transformer.rb

@@ -8,13 +8,47 @@ module Pubid::Iso
       { stage: convert_stage(context[:stage]) }
     end
 
+    rule(supplements: subtree(:supplements)) do |context|
+      context[:supplements] =
+        context[:supplements].map do |supplement|
+          supplement[:typed_stage] = case supplement[:typed_stage]
+                                     when "PDAM"
+                                       "CD Amd"
+                                     when "pDCOR"
+                                       "CD Cor"
+                                     when "FCOR"
+                                       "FDCor"
+                                     when "FPDAM"
+                                       "DAmd"
+                                     when "FDAM"
+                                       "FDAmd"
+                                     else
+                                       supplement[:typed_stage]
+                                     end
+    #       Supplement.new(
+    #         number: supplement[:number],
+    #         year: supplement[:year],
+    #         typed_stage:
+    #           case supplement[:typed_stage]
+    #           when "FCOR"
+    #             "FDCor"
+    #           else
+    #             supplement[:typed_stage]
+    #           end,
+    #         iteration: supplement[:iteration]
+    #       )
+          supplement
+        end
+      context
+    end
+
     rule(amendments: subtree(:amendments)) do |context|
       context[:amendments] =
         context[:amendments].map do |amendment|
           Amendment.new(
             number: amendment[:number],
             year: amendment[:year],
-            stage: amendment[:stage] && convert_stage(amendment[:stage]),
+            typed_stage: amendment[:stage] && convert_stage(amendment[:stage]),
             iteration: amendment[:iteration])
         end
       context
@@ -26,7 +60,7 @@ module Pubid::Iso
           Corrigendum.new(
             number: corrigendum[:number],
             year: corrigendum[:year],
-            stage: corrigendum[:stage] && convert_stage(corrigendum[:stage]),
+            typed_stage: corrigendum[:stage] && convert_stage(corrigendum[:stage]),
             iteration: corrigendum[:iteration])
         end
       context
@@ -44,21 +78,26 @@ module Pubid::Iso
 
     rule(type: simple(:type)) do
       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
-        when "GUIDE", "Руководства"
-          "Guide"
-        when "ТС"
-          "TS"
-        when "ТО"
-          "TR"
-        when "Directives Part", "Directives, Part", "Directives,"
-          "DIR"
-        else
-          type
-        end
-      }
+      { type: Type.new(russian_type&.downcase&.to_sym ||
+                        case type
+                        # XXX: can't put 2 alternative Russian translations to dictionary, temporary hack
+                        when "GUIDE", "Guide", "Руководства"
+                          :guide
+                        when "ТС", "TS"
+                          :ts
+                        when "ТО", "TR"
+                          :tr
+                        when "Directives Part", "Directives, Part", "Directives,"
+                          :dir
+                        when "PAS"
+                          :pas
+                        when "DPAS"
+                          :dpas
+                        when "DIR"
+                          :dir
+                        else
+                          type
+                        end) }
     end
 
     rule(copublisher: simple(:copublisher)) do
@@ -119,12 +158,17 @@ module Pubid::Iso
                "FDIS"
              when "Fpr"
                "PRF"
-             when "pD", "PD"
-               "CD"
+             # when "pD", "PD"
+             #   "CD"
+             when "PDTR"
+               "CD TR"
+             when "PDTS"
+               "CD TS"
              else
                code
              end
-      Stage.new(abbr: (russian_code || code))
+      russian_code || code
+      # Stage.new(abbr: (russian_code || code))
     end
 
     def self.convert_language(code)

data/lib/pubid/iso/type.rb

@@ -0,0 +1,77 @@
+module Pubid::Iso
+  class Type
+    attr_accessor :type
+
+    TYPE_NAMES = {
+      tr: {
+        long: "Technical Report",
+        short: "TR",
+      },
+      ts: {
+        long: "Technical Specification",
+        short: "TS",
+      },
+      is: {
+        long: "International Standard",
+        short: "IS",
+      },
+      pas: {
+        long: "Publicly Available Specification",
+        short: "PAS",
+      },
+      isp: {
+        long: "International Standardized Profiles",
+        short: "ISP",
+      },
+      guide: {
+        long: "Guide",
+        short: "Guide",
+      },
+      dir: {
+        long: "Directives",
+        short: "DIR",
+      },
+      dpas: {
+        long: "Publicly Available Specification Draft",
+        short: "DPAS",
+      },
+      cor: {
+        short: "Cor",
+      },
+      amd: {
+        short: "Amd",
+      },
+    }.freeze
+
+    # Create new type
+    # @param type [Symbol]
+    def initialize(type)
+      raise Errors::WrongTypeError, "#{type} type is not available" unless TYPE_NAMES.key?(type)
+
+      @type = type
+    end
+
+    def self.parse(type_string)
+      TYPE_NAMES.each do |type, values|
+        return new(type) if values[:short] == type_string
+      end
+      raise Errors::ParseTypeError, "Cannot parse '#{type_string}' type"
+    end
+
+    def to_s(format = :short)
+      TYPE_NAMES[type][format]
+    end
+
+    def ==(other)
+      return type == other if other.is_a?(Symbol)
+
+      type == other.type
+    end
+
+    def self.has_type?(type)
+      TYPE_NAMES.any? do |_, v|
+        v[:short] == type
+      end
+    end
+  end
+end