pubid-iso 0.3.1 → 0.4.1

data/lib/pubid/iso/amendment.rb

@@ -1,15 +0,0 @@
-module Pubid::Iso
-  class Amendment < Supplement
-    # @param stage_format_long [Boolean] long or short format for stage rendering
-    # @param with_date [Boolean] include date
-    def render_pubid(stage_format_long = true, with_date = true)
-      pubid_number = render_pubid_number(with_date: with_date)
-
-      "/#{@typed_stage.to_s(stage_format_long)} #{pubid_number}"
-    end
-
-    def render_urn
-      "#{render_urn_stage}:amd#{render_urn_number}"
-    end
-  end
-end

data/lib/pubid/iso/corrigendum.rb

@@ -1,31 +0,0 @@
-module Pubid::Iso
-  class Corrigendum < Supplement
-    def render_pubid(stage_format_long = true, with_date = true)
-      # stage = render_pubid_stage
-      pubid_number = render_pubid_number(with_date: with_date)
-      "/#{@typed_stage.to_s(stage_format_long)} #{pubid_number}"
-      # case stage.to_s
-      # when "DIS"
-      #   if stage_format_long
-      #     "/DCor #{pubid_number}"
-      #   else
-      #     "/DCOR #{pubid_number}"
-      #   end
-      # when "FDIS"
-      #   if stage_format_long
-      #     "/FDCor #{pubid_number}"
-      #   else
-      #     "/FDCOR #{pubid_number}"
-      #   end
-      # when ""
-      #   "/Cor #{pubid_number}"
-      # else
-      #   "/#{stage} Cor #{pubid_number}"
-      # end
-    end
-
-    def render_urn
-      "#{render_urn_stage}:cor#{render_urn_number}"
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-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[:typed_stage]&.type == :guide
-        "Guide #{super(params)}"
-      else
-        super
-      end
-    end
-
-    def render_copublisher(copublisher, opts, params)
-      "/#{copublisher.to_s.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

@@ -1,64 +0,0 @@
-module Pubid::Iso::Renderer
-  class Russian < Base
-    PUBLISHER = { "ISO" => "ИСО", "IEC" => "МЭК" }.freeze
-    STAGE = { "FDIS" => "ОПМС",
-              "DIS" => "ПМС",
-              "NP" => "НП",
-              "AWI" => "АВИ",
-              "CD" => "КПК",
-              "PD" => "ПД",
-              "FPD" => "ФПД",
-
-
-    }.freeze
-
-    TYPE = { "Guide" => "Руководство",
-             "TS" => "ТС",
-             "TR" => "ТО",
-             "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[:typed_stage]&.type == :guide
-        "Руководство #{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)
-      STAGE[stage.abbr] unless stage.nil?
-    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

@@ -1,30 +0,0 @@
-module Pubid::Iso::Renderer
-  class Tc < 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.to_s
-    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/supplement.rb

@@ -1,56 +0,0 @@
-module Pubid::Iso
-  class Supplement < Pubid::Core::Supplement
-    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" (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(typed_stage: nil, publisher: nil, edition: nil, iteration: nil, **args)
-      super(**args)
-      @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 && @typed_stage.nil?
-        raise Errors::PublishedIterationError.new("cannot assign iteration to published supplement")
-      end
-    end
-
-    def render_pubid_stage
-      # @typed_stage.stage.abbr != "IS" &&
-      ((@typed_stage && @typed_stage.to_s) || "")
-    end
-
-    def render_urn_stage
-      ((@typed_stage&.stage && ":stage-#{@typed_stage.stage.harmonized_code}") || "")
-    end
-
-    def <=>(other)
-      (super == 0) && ((typed_stage.nil? || typed_stage == other.typed_stage) && 0 || -1) || super
-    end
-
-    def render_iteration
-      @iteration && ".#{@iteration}"
-    end
-
-    def render_pubid_number(with_date: true)
-      if @year && with_date
-        "#{@number}#{render_iteration}:#{@year}"
-      else
-        "#{@number}#{render_iteration}"
-      end
-    end
-
-    def render_urn_number
-      if @year
-        ":#{@year}:v#{@number}#{render_iteration}"
-      else
-        ":#{@number}#{render_iteration}:v1"
-      end
-    end
-  end
-end

data/lib/pubid/iso/typed_stage.rb

@@ -1,204 +0,0 @@
-module Pubid::Iso
-  class TypedStage
-    attr_accessor :type, :stage, :typed_stage
-
-    TYPED_STAGES = {
-      dtr: {
-        abbr: "DTR",
-        type: :tr,
-        name: "Draft Technical Report",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
-      },
-      dis: {
-        abbr: "DIS",
-        type: :is,
-        name: "Draft International Standard",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93],
-      },
-      dts: {
-        abbr: "DTS",
-        type: :ts,
-        name: "Draft Technical Specification",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
-      },
-      fdts: {
-        abbr: "FDTS",
-        type: :ts,
-        name: "Final Draft Technical Specification",
-        harmonized_stages: %w[50.00 50.20 50.60 50.92],
-      },
-      fdtr: {
-        abbr: "FDTR",
-        type: :tr,
-        name: "Final Draft Technical Report",
-        harmonized_stages: %w[50.00 50.20 50.60 50.92],
-      },
-      fdis: {
-        abbr: "FDIS",
-        type: :is,
-        name: "Final Draft International Standard",
-        harmonized_stages: %w[50.00 50.20 50.60 50.92],
-      },
-      dpas: {
-        abbr: "DPAS",
-        type: :pas,
-        name: "Publicly Available Specification Draft",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
-      },
-      damd: {
-        abbr: { short: "DAM", long: "DAmd" },
-        type: :amd,
-        name: "Draft Amendment",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
-      },
-      dcor: {
-        abbr: { short: "DCOR", long: "DCor" },
-        type: :cor,
-        name: "Draft Corrigendum",
-        harmonized_stages: %w[40.00 40.20 40.60 40.92 40.93 50.00 50.20 50.60 50.92],
-      },
-      fdamd: {
-        abbr: { short: "FDAM", long: "FDAmd" },
-        type: :amd,
-        name: "Final Draft Amendment",
-        harmonized_stages: %w[50.00 50.20 50.60 50.92],
-      },
-      fdcor: {
-        abbr: { short: "FDCOR", long: "FDCor" },
-        type: :cor,
-        name: "Final Draft Corrigendum",
-        harmonized_stages: %w[50.00 50.20 50.60 50.92],
-      },
-    }.freeze
-
-    # @param type [Symbol,Type] eg. :tr, Type.new(:tr)
-    # @param stage [Symbol,Stage] eg. :CD, Stage.new(abbr: :CD)
-    def initialize(abbr: nil, type: nil, stage: nil)
-      @type = type.is_a?(Type) ? type : Type.new(type) if type
-      @stage = stage.is_a?(Stage) ? stage : Stage.new(abbr: stage) if stage
-
-      if abbr
-        raise Errors::TypeStageInvalidError, "#{abbr} is not valid typed stage" unless TYPED_STAGES.key?(abbr)
-        assign_abbreviation(abbr)
-      elsif !@stage.nil?
-        # lookup for typed stage
-        @typed_stage = lookup_typed_stage
-      end
-    end
-
-    def lookup_typed_stage
-      return nil unless @stage
-
-      TYPED_STAGES.each do |typed_stage, values|
-        if values[:harmonized_stages].include?(@stage.harmonized_code.to_s) && values[:type] == @type&.type
-          return typed_stage
-        end
-      end
-      nil
-    end
-
-    # Assigns type and stage according to provided typed stage abbreviation
-    # @param abbr [Symbol] eg. :dtr, :damd, :dis
-    def assign_abbreviation(abbr)
-      @typed_stage = if TYPED_STAGES.key?(abbr.downcase.to_sym)
-                       abbr.downcase.to_sym
-                     else
-                       TYPED_STAGES.select do |_, v|
-                         if v[:abbr].is_a?(Hash)
-                           v[:abbr].values.include?(abbr)
-                         else
-                           v[:abbr] == abbr
-                         end
-                       end.keys.first
-                     end
-
-      @type = Type.new(TYPED_STAGES[@typed_stage][:type])
-      @stage = Stage.new(harmonized_code: HarmonizedStageCode.new(TYPED_STAGES[@typed_stage][:harmonized_stages]))
-    end
-
-    # Render typed stage
-    # @param stage_format_long [Boolean] render stage in long or short format
-    def to_s(stage_format_long = true)
-      # return "" if @type == :amd || @type == :cor
-      if @typed_stage
-        if TYPED_STAGES[@typed_stage][:abbr].is_a?(Hash)
-          return TYPED_STAGES[@typed_stage][:abbr][stage_format_long ? :long : :short]
-        else
-          return TYPED_STAGES[@typed_stage][:abbr]
-        end
-      end
-
-      result = (@stage && @stage.abbr != "IS") ? "#{@stage.abbr}" : ""
-      result += " " if !result.empty? && @type && stage_format_long
-      result + if stage_format_long
-                 "#{@type&.to_s}"
-               else
-                 if @type == :amd
-                   "AM"
-                 elsif @type == :cor
-                   "COR"
-                 else
-                   "#{@type&.to_s}"
-                 end
-               end
-    end
-
-    # Check if typed stage listed in TYPED_STAGES constant
-    # @param typed_stage [String,Symbol] typed stage abbreviation, eg. "DTS", :dts, "DAmd", :damd
-    def self.has_typed_stage?(typed_stage)
-      return true if TYPED_STAGES.key?(typed_stage)
-
-      TYPED_STAGES.any? do |_, v|
-        if v[:abbr].is_a?(Hash)
-          v[:abbr].values.include?(typed_stage)
-        else
-          v[:abbr] == typed_stage
-        end
-      end
-    end
-
-    # Assigns stage or type or typed stage or stage and type depending on provided string
-    # @param stage_or_typed_stage [String, Stage] eg. "DTR", "CD", Stage.new(:CD), "TR", "CD Amd", :dtr
-    def parse_stage(stage_or_typed_stage)
-      if self.class.has_typed_stage?(stage_or_typed_stage)
-        return assign_abbreviation(stage_or_typed_stage)
-      end
-
-      if stage_or_typed_stage.is_a?(Stage)
-        @stage = stage_or_typed_stage
-      elsif stage_or_typed_stage.is_a?(String) && stage_or_typed_stage.split.count == 2 &&
-          Stage.has_stage?(stage_or_typed_stage.split.first)
-        # stage and type ("CD Amd")
-        @stage = Stage.parse(stage_or_typed_stage.split.first)
-        @type = Type.parse(stage_or_typed_stage.split.last)
-      elsif Type.has_type?(stage_or_typed_stage)
-        @type = Type.parse(stage_or_typed_stage)
-      elsif Stage.has_stage?(stage_or_typed_stage)
-        @stage = Stage.parse(stage_or_typed_stage.to_s)
-      else
-        raise Errors::TypeStageParseError, "cannot parse typed stage or stage"
-      end
-      @typed_stage = lookup_typed_stage
-    end
-
-    # Parse stage or typed stage
-    # @return [TypedStage] typed stage object with parsed stage and typed stage
-    def self.parse(stage_or_typed_stage)
-      return stage_or_typed_stage if stage_or_typed_stage.is_a?(TypedStage)
-
-      typed_stage = new
-      typed_stage.parse_stage(stage_or_typed_stage)
-      typed_stage
-    end
-
-    def name
-      TYPED_STAGES[@typed_stage][:name]
-    end
-
-    def ==(other)
-      return false if other.nil?
-
-      type == other.type && typed_stage == other.typed_stage && stage == other.stage
-    end
-  end
-end