pubid-core 1.8.7 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65c153405bb8ae343ef26b9943f013864d2db8fd2abfd27e14d2db1f83de4d0a
-  data.tar.gz: 1ebdf5cef55a9c09111f18245a9d6767ee8107d7039398e8aaa9ceb8f5e0e9d5
+  metadata.gz: 135dbda350a5a305c463d0e56ed56303ad0a95dca7cbc6a74c38e66e37ae7780
+  data.tar.gz: cf8b5afc99d6d4876d1aefd8fd21d95732f6cd26fefb18a9b4f1c4c2552a25ad
 SHA512:
-  metadata.gz: ff849c54be9d3e4b49a54c48fd58413b66fe0f2aae40f7735c62820fe064e08fdb77b9e197b21a3471dd14570b4875223dce065ae3e5333b614beb520c171bae
-  data.tar.gz: d649815ce64e1654b64681d1a183c6309759403738fff8d270ca01effe4a87d4a9e0e7e82f8468bbc7fe15c9717d2e0024e6268a16571eaba71620f0398ead6b
+  metadata.gz: 3401aa6d8c5ad4ab9e82361d2ec67b84976ddb47e661afb3f54ca3538388740acba8960c948520c49b0be8e4fb6781c37cea0d016ccd2d56044d1e2bf843c328
+  data.tar.gz: f231d49c157d57b0d346ff9e246bd7cbe04b8ed770ac5b2c2b808f9c2ae8ff570f8d5b69649d94df35d5f239b5cdf15aa892775a85b0c0f9282a0090305ec33a

data/lib/pubid/core/configuration.rb

@@ -1,10 +1,18 @@
 module Pubid::Core
   class Configuration
-    attr_accessor :stages, :default_type, :type_class, :types, :type_names, :stage_class
+    attr_accessor :stages, :default_type, :type_class, :types, :type_names, :stage_class, :typed_stage_class
 
     def initialize
       @type_class = Pubid::Core::Type
       @stage_class = Pubid::Core::Stage
+      @typed_stage_class = Pubid::Core::TypedStage
+      @types = []
+    end
+
+    def typed_stages
+      types.inject({}) do |res, type|
+        res.merge(type::TYPED_STAGES)
+      end
     end
   end
 end

data/lib/pubid/core/errors.rb

@@ -7,6 +7,7 @@ module Pubid::Core
     class ParseTypeError < StandardError; end
     class TypeStageParseError < StandardError; end
     class WrongTypeError < StandardError; end
+    class TypedStageInvalidError < StandardError; end
 
   end
 end

data/lib/pubid/core/harmonized_stage_code.rb

@@ -2,20 +2,26 @@ module Pubid::Core
   class HarmonizedStageCode
     include Comparable
     # attr_accessor :stage, :substage
-    attr_accessor :config, :stages
+    attr_accessor :config, :stages, :harmonized_typed_stages
 
     # @param stage_or_code [String,Array<String>] stage number or whole harmonized code with substage
     #   or list or stages for fuzzy stages eg. "10", 10, "20.20", ["10.20", "20.20"]
     #   or stage name eg. "proposal", "approval"
+    #   or typed stages eg. :dtr, :fdis
     # @param substage [Integer, String] eg. "00", 0
     #   or substage name eg. "registration", "start_of_main_action"
     def initialize(stage_or_code, substage = "00", config:)
       @config = config
       @stages = if stage_or_code.is_a?(Array)
                   stage_or_code
-                elsif stage_or_code.is_a?(String) && config.stages["codes_description"].key?(stage_or_code)
+                elsif stage_or_code.is_a?(String) && (
+                  config.stages["codes_description"].key?(stage_or_code) ||
+                    harmonized_typed_stages.include?(stage_or_code))
                   [stage_or_code]
-                  # when stage is stage name
+                # when stage is typed stage
+                elsif stage_or_code.is_a?(Symbol) && config.typed_stages.key?(stage_or_code)
+                  config.typed_stages[stage_or_code][:harmonized_stages]
+                # when stage is stage name
                 elsif config.stages["stage_codes"]&.key?(stage_or_code.to_s)
                   ["#{config.stages["stage_codes"][stage_or_code.to_s]}.#{config.stages["substage_codes"][substage.to_s]}"]
                 else
@@ -25,10 +31,19 @@ module Pubid::Core
       validate_stages
     end
 
+    def harmonized_typed_stages
+      @harmonized_typed_stages ||= config.typed_stages.values.map { |v| v[:harmonized_stages] }.flatten
+    end
+
     def validate_stages
       @stages.each do |stage|
         # raise an error when stage is wrong
-        raise Errors::HarmonizedStageCodeInvalidError unless config.stages["codes_description"].key?(stage)
+        next if config.stages["codes_description"].key?(stage)
+
+        # check typed stages if no stages in config
+        next if harmonized_typed_stages.include?(stage)
+
+        raise Errors::HarmonizedStageCodeInvalidError
       end
     end
 

data/lib/pubid/core/identifier/base.rb

@@ -3,7 +3,7 @@ module Pubid::Core
     class Base
       attr_accessor :number, :publisher, :copublisher, :part,
                     :type, :year, :edition, :language, :amendments,
-                    :corrigendums, :stage, :typed_stage
+                    :corrigendums, :stage
 
       TYPED_STAGES = {}.freeze
 
@@ -54,15 +54,16 @@ module Pubid::Core
         @edition = edition.to_i if edition
         @language = language.to_s if language
 
-        @typed_stage, @stage = resolve_stage(stage) if stage
+        @stage = resolve_stage(stage) if stage
       end
 
       # @return [String] Rendered URN identifier
       def urn
-        Renderer::Urn.new(get_params).render
+        Renderer::Urn.new(to_h).render
       end
 
-      def get_params
+      # @return [Hash] Identifier's parameters
+      def to_h
         instance_variables.map do |var|
           # XXX: temporary hack to prepare typed_stage for rendering
           # probably need to convert typed_stage to class, now we store
@@ -76,17 +77,17 @@ module Pubid::Core
       end
 
       def ==(other)
-        get_params == other.get_params
+        to_h == other.to_h
       end
 
       # Render identifier using default renderer
       def to_s
-        self.class.get_renderer_class.new(get_params).render
+        self.class.get_renderer_class.new(to_h).render
       end
 
       def typed_stage_abbrev
-        if self.class::TYPED_STAGES.key?(typed_stage)
-          return self.class::TYPED_STAGES[typed_stage][:abbr]
+        if stage.is_a?(TypedStage)
+          return stage.to_s
         end
 
         stage ? "#{stage.abbr} #{self.class.type[:key].to_s.upcase}" : self.class.type[:key].to_s.upcase
@@ -94,8 +95,8 @@ module Pubid::Core
 
       # Return typed stage name, eg. "Final Draft Technical Report" for "FDTR"
       def typed_stage_name
-        if self.class::TYPED_STAGES.key?(typed_stage)
-          return self.class::TYPED_STAGES[typed_stage][:name]
+        if self.class::TYPED_STAGES.key?(stage&.typed_stage)
+          return self.class::TYPED_STAGES[stage.typed_stage][:name]
         end
 
         stage ? "#{stage.name} #{self.class.type[:title]}" : self.class.type[:title]
@@ -105,9 +106,14 @@ module Pubid::Core
       # @return [[nil, Stage], [Symbol, Stage]] typed stage and stage values
       def resolve_stage(stage)
         if stage.is_a?(Stage)
-          return [nil, stage] if stage.abbr
+          # return [nil, stage] if stage.abbr
+          # return stage if stage.abbr
 
-          return [self.class.resolve_typed_stage(stage.harmonized_code), stage]
+          # return [self.class.resolve_typed_stage(stage.harmonized_code), stage]
+          unless stage.abbr
+            stage.typed_stage = self.class.resolve_typed_stage(stage.harmonized_code)
+          end
+          return stage
           # @typed_stage = resolve_typed_stage(@stage.harmonized_code) unless @stage.abbr
         end
 
@@ -119,10 +125,10 @@ module Pubid::Core
         # resolve typed stage when harmonized code provided as stage
         # or stage abbreviation was not resolved
         if /\A[\d.]+\z/.match?(stage) || parsed_stage.empty_abbr?(with_prf: true)
-          return [self.class.resolve_typed_stage(parsed_stage.harmonized_code), parsed_stage]
+          parsed_stage.typed_stage = self.class.resolve_typed_stage(parsed_stage.harmonized_code)
         end
 
-        [nil, parsed_stage]
+        parsed_stage
 
         # from IEC
         # @typed_stage = self.class::TYPED_STAGES[@typed_stage][:abbr] if @typed_stage
@@ -238,10 +244,12 @@ module Pubid::Core
         # @return [[Symbol, Stage]] typed stage and stage with assigned harmonized codes
         def find_typed_stage(typed_stage)
           if typed_stage.is_a?(Symbol)
-            return [typed_stage,
-                    get_identifier.build_stage(
-                      harmonized_code: get_identifier.build_harmonized_stage_code(self::TYPED_STAGES[typed_stage][:harmonized_stages])),
-            ]
+            return get_identifier
+                .build_typed_stage(
+                  harmonized_code:
+                    get_identifier.build_harmonized_stage_code(self::TYPED_STAGES[typed_stage][:harmonized_stages]),
+                  abbr: typed_stage,
+                )
           end
 
           typed_stage = self::TYPED_STAGES.find do |_, v|
@@ -254,9 +262,9 @@ module Pubid::Core
             end
           end
 
-          [typed_stage.first,
-           get_identifier.build_stage(
-             harmonized_code: get_identifier.build_harmonized_stage_code(typed_stage[1][:harmonized_stages]))]
+          get_identifier.build_typed_stage(harmonized_code:
+                                       get_identifier.build_harmonized_stage_code(typed_stage[1][:harmonized_stages]),
+                                     abbr: typed_stage.first)
         end
 
         # Resolve typed stage using stage harmonized stage code

data/lib/pubid/core/identifier.rb

@@ -7,11 +7,6 @@ module Pubid::Core
     # @see Pubid::Identifier::Base.initialize for available options
     def create(**opts)
       resolve_identifier(opts)
-      # resolve_identifier(
-      #   opts[:type],
-      #   opts[:stage],
-      #   opts.reject { |k, _v| [:type, :stage].include?(k) },
-      # )
     end
 
     # @param typed_stage_or_stage [String] typed stage or stage
@@ -62,5 +57,9 @@ module Pubid::Core
     def build_harmonized_stage_code(stage_or_code, substage = "00")
       HarmonizedStageCode.new(stage_or_code, substage, config: @config)
     end
+
+    def build_typed_stage(**args)
+      @config.typed_stage_class.new(config: @config, **args)
+    end
   end
 end

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

@@ -44,9 +44,9 @@ module Pubid::Core::Renderer
     def render_supplement(supplement_params, **args)
       base = if supplement_params[:base].type == :amd
                # render inner amendment (cor -> amd -> base)
-               render_supplement(supplement_params[:base].get_params, **args)
+               render_supplement(supplement_params[:base].to_h, **args)
              else
-               self.class.new(supplement_params[:base].get_params).render_base_identifier(
+               self.class.new(supplement_params[:base].to_h).render_base_identifier(
                  # always render year for identifiers with supplement
                  **args.merge({ with_date: true }),
                )

data/lib/pubid/core/stage.rb

@@ -1,13 +1,14 @@
 module Pubid::Core
   class Stage
-    attr_accessor :config, :abbr, :harmonized_code
+    attr_accessor :config, :abbr, :harmonized_code, :typed_stage
 
     # @param abbr [String, Symbol] abbreviation eg. :PWI, :WD
     # @param harmonized_code [String, Float, HarmonizedStageCode]
     # @param config [Configuration]
-    def initialize(config:, abbr: nil, harmonized_code: nil)
+    def initialize(config:, abbr: nil, harmonized_code: nil, typed_stage: nil)
       @config = config
       @abbr = abbr&.to_s
+      @typed_stage = typed_stage
 
       if harmonized_code
         @harmonized_code = if harmonized_code.is_a?(HarmonizedStageCode)
@@ -75,6 +76,12 @@ module Pubid::Core
 
     # Compares one stage with another
     def ==(other)
+      return false unless other
+
+      unless other.is_a?(self.class)
+        return false
+        # other = self.class.parse(other, config: config)
+      end
       other&.harmonized_code == harmonized_code
     end
 

data/lib/pubid/core/typed_stage.rb

@@ -0,0 +1,42 @@
+module Pubid::Core
+  class TypedStage < Stage
+    attr_accessor :config, :abbr
+
+    # @param config [Configuration]
+    # @param abbr [Symbol] typed stage symbol, e.g. :dtr
+    # @param harmonized_code [String, Float, HarmonizedStageCode]
+    def initialize(config:, abbr: nil, harmonized_code: nil)
+      @config = config
+      @abbr = abbr
+
+      if harmonized_code
+        @harmonized_code = if harmonized_code.is_a?(HarmonizedStageCode)
+                             harmonized_code
+                           else
+                             HarmonizedStageCode.new(harmonized_code, config: config)
+                           end
+        # @abbr ||= lookup_abbr(@harmonized_code.stages)
+      end
+
+      if abbr
+        raise Errors::TypedStageInvalidError, "#{abbr} is not valid typed stage" unless config.typed_stages.key?(abbr)
+
+        @harmonized_code ||= HarmonizedStageCode.new(abbr, config: config)
+      end
+    end
+
+    # Compares one stage with another
+    # should return false if
+    def ==(other)
+      return false unless other
+
+      return abbr == other if other.is_a?(Symbol)
+
+      other&.harmonized_code == harmonized_code
+    end
+
+    def to_s(_opts = nil)
+      config.typed_stages[abbr][:abbr]
+    end
+  end
+end

data/lib/pubid/core/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Core
-    VERSION = "1.8.7".freeze
+    VERSION = "1.10.0".freeze
   end
 end

data/lib/pubid/core.rb

@@ -14,3 +14,4 @@ require_relative "core/identifier"
 require_relative "core/identifier/base"
 require_relative "core/harmonized_stage_code"
 require_relative "core/stage"
+require_relative "core/typed_stage"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-core
 version: !ruby/object:Gem::Version
-  version: 1.8.7
+  version: 1.10.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-25 00:00:00.000000000 Z
+date: 2023-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -79,6 +79,7 @@ files:
 - lib/pubid/core/supplement.rb
 - lib/pubid/core/transformer.rb
 - lib/pubid/core/type.rb
+- lib/pubid/core/typed_stage.rb
 - lib/pubid/core/version.rb
 homepage: https://github.com/metanorma/pubid-core
 licenses: