pubid-core 1.9.0 → 1.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8fa90c212d201a964cf2744e9c8bcba06af62d10dfe195caa6af284189b82cd
-  data.tar.gz: 9d526bcae7afe9781b462aabd17fe3bbaafb1349e3b40c5f5fc6364468dce76d
+  metadata.gz: ebe928af0a08e530bc616c88526fa076841d66f32fdb075640f67b7a72847b83
+  data.tar.gz: 438ade1f287d204a01aea76ea44e2bbc6cac186fd73bf5332bc1974dcec45df6
 SHA512:
-  metadata.gz: bd9862d64043e894cd11ab5a92f5e792377dc28d1986918799e809c06070504e16f1be6fcecac05da3f366e52e2266476ff4733664ba3427a03f87b5a4ba8c4d
-  data.tar.gz: b0962ace109243f800c6c17ceacde35cc50f345c952dd75b9af42045d03dbf961a72cb4d42b3585f4c1a98ecc7a035795614c45c7e83ca48bd18160c11f573d6
+  metadata.gz: b4d60fc2b2dc1f146a31f3b03275522d598b18adc8e86c9b229fd9cea4375c851fea88b02e96ff74e2c55d6e215e849ec7f026f53fa34d18a77a47d7e2312a81
+  data.tar.gz: 8d7e1fffb7cf18ff56524be8187fb4895a2e1043ccc1941c9a6500f834bf566461758cca8aac34be8c64bc637610602d65129e4b658e76a973ac91ea4a7a5541

data/README.adoc

@@ -1,2 +1,31 @@
 = Publication identifiers parsing library
 
+== Usage
+
+=== Exclude attributes when compare
+
+[source,ruby]
+----
+require "pubid-core"
+
+pubid_first = Identifier.parse("ISO 1:1999")
+pubid_second = Identifier.parse("ISO 1")
+
+pubid_first == pubid_second
+=> false
+
+pubid_first.exclude(:year) == pubid_second
+=> true
+----
+
+=== Using #to_h to convert identifier to hash
+
+
+[source,ruby]
+----
+require "pubid-core"
+
+pubid = Identifier.parse("ISO 1:1999")
+pubid.to_h
+=> { publisher: "ISO", number: 1, year: 1999 }
+----

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,7 +54,7 @@ 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
@@ -65,14 +65,15 @@ module Pubid::Core
       # @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
-          # typed_stage as key to typed stage (Symbol)
-          if var.to_s == "@typed_stage" && @typed_stage
-            [:typed_stage, self.class::TYPED_STAGES[@typed_stage][:abbr]]
-          else
-            [var.to_s.gsub("@", "").to_sym, instance_variable_get(var)]
-          end
+          value = instance_variable_get(var)
+
+          [var.to_s.gsub("@", "").to_sym,
+           if value.is_a?(Array)
+             value.map { |v| v.respond_to?(:to_h) ? v.to_h : v }
+           else
+             value.respond_to?(:to_h) ? value.to_h : value
+           end
+          ]
         end.to_h
       end
 
@@ -85,9 +86,13 @@ module Pubid::Core
         self.class.get_renderer_class.new(to_h).render
       end
 
+      def exclude(*attrs)
+        self.class.new(**to_h.reject { |k| attrs.include?(k) })
+      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
@@ -95,8 +100,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]
@@ -106,9 +111,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
 
@@ -120,10 +130,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
@@ -239,10 +249,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|
@@ -255,9 +267,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/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
 
@@ -94,5 +101,9 @@ module Pubid::Core
     def to_s(opts = {})
       empty_abbr?(**opts) ? "" : abbr
     end
+
+    def to_h
+      abbr
+    end
   end
 end

data/lib/pubid/core/supplement.rb

@@ -33,5 +33,10 @@ module Pubid::Core
           ":#{@number}:v1"
         end
     end
+
+    def to_h
+      { number: number,
+        year: year }
+    end
   end
 end

data/lib/pubid/core/typed_stage.rb

@@ -0,0 +1,40 @@
+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:, 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
+
+      raise Errors::TypedStageInvalidError, "#{abbr} is not valid typed stage" unless config.typed_stages.key?(abbr)
+
+      @harmonized_code ||= HarmonizedStageCode.new(abbr, config: config)
+    end
+
+    # Compares one stage with another
+    # should return false if
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      # 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.9.0".freeze
+    VERSION = "1.10.2".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.9.0
+  version: 1.10.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-09 00:00:00.000000000 Z
+date: 2023-11-04 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: