pubid-iso 0.2.1 → 0.3.0

data/lib/pubid/iso/typed_stage.rb

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

data/lib/pubid/iso/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Iso
-    VERSION = "0.2.1".freeze
+    VERSION = "0.3.0".freeze
   end
 end

data/lib/pubid/iso.rb

@@ -11,6 +11,8 @@ end
 require "pubid-core"
 require_relative "iso/errors"
 require_relative "iso/stage"
+require_relative "iso/type"
+require_relative "iso/typed_stage"
 require_relative "iso/harmonized_stage_code"
 require_relative "iso/parser"
 require_relative "iso/transformer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-iso
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-29 00:00:00.000000000 Z
+date: 2022-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
 description: Library to generate, parse and manipulate ISO PubID.
 email:
 - open.source@ribose.com
@@ -138,6 +138,8 @@ files:
 - lib/pubid/iso/stage.rb
 - lib/pubid/iso/supplement.rb
 - lib/pubid/iso/transformer.rb
+- lib/pubid/iso/type.rb
+- lib/pubid/iso/typed_stage.rb
 - lib/pubid/iso/version.rb
 homepage: https://github.com/metanorma/pubid-iso
 licenses: