pubid-core 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d11f67c2e955fc7a68dffe340770552b3148b1767bd3095600c35ec9696e239c
-  data.tar.gz: f1db402f0c58b0340ea34da7b129021be3985aed9e6573d462645240717062b3
+  metadata.gz: b85bcef46a9327cb4c9ae474a84dea3b3986990082459b2f2bb37aa1c7578861
+  data.tar.gz: b7caa4de8dd3ac5c9e9b0d9bed0f3690207f48b5ec6366d4515a2ab138ab5b92
 SHA512:
-  metadata.gz: 330a2e07981ef86fa2c26ac46636d91c8737fb6a0a11e84e2b91fc15f9c7b2eee98f3d6f0792534f924cbb343d80df634febfabc4325c87f5eede56481d10d2c
-  data.tar.gz: e6b481d0431d82220983541c2f7162d087bc38894d9b8c8d7c6758b02adc87009a4b195ee639626af6a436ad833f6c4441b38d8c41553ff882b1c0405540f029
+  metadata.gz: 70ab4b5c6c3393811c898e3d66dbb9c1f1f80b34a5f9337697748ef06a6ee5f3331828b731b776fedeb44379c7766dda901cca146e15ba62731b17258e7d7cb5
+  data.tar.gz: 518912efd803e1ee6cef6d189fd618f4f52300109d057b35f9061437a199488b74c09cf2cafbb9622fe9a49c4e8fd7a0cea96e4e2861f53b6014e06277444c80

data/lib/pubid/core/configuration.rb

@@ -0,0 +1,6 @@
+module Pubid::Core
+  class Configuration
+    attr_accessor :stages, :default_type, :type_class, :types, :type_names
+
+  end
+end

data/lib/pubid/core/errors.rb

@@ -4,5 +4,9 @@ module Pubid::Core
     class HarmonizedStageCodeInvalidError < StandardError; end
     class StageInvalidError < StandardError; end
     class HarmonizedStageRenderingError < StandardError; end
+    class ParseTypeError < StandardError; end
+    class TypeStageParseError < StandardError; end
+    class WrongTypeError < StandardError; end
+
   end
 end

data/lib/pubid/core/harmonized_stage_code.rb

@@ -2,28 +2,22 @@ module Pubid::Core
   class HarmonizedStageCode
     include Comparable
     # attr_accessor :stage, :substage
-    attr_accessor :stages
-
-    DESCRIPTIONS = STAGES_CONFIG["codes_description"]
-    DRAFT_STAGES = STAGES_CONFIG["draft_codes"]
-    CANCELED_STAGES = STAGES_CONFIG["canceled_codes"]
-    PUBLISHED_STAGES = STAGES_CONFIG["published_codes"]
-    STAGES_NAMES = STAGES_CONFIG["stage_codes"]
-    SUBSTAGES_NAMES = STAGES_CONFIG["substage_codes"]
+    attr_accessor :config, :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"
     # @param substage [Integer, String] eg. "00", 0
     #   or substage name eg. "registration", "start_of_main_action"
-    def initialize(stage_or_code, substage = "00")
+    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) && DESCRIPTIONS.key?(stage_or_code)
+                elsif stage_or_code.is_a?(String) && config.stages["codes_description"].key?(stage_or_code)
                   [stage_or_code]
                   # when stage is stage name
-                elsif STAGES_NAMES.key?(stage_or_code.to_s)
-                  ["#{STAGES_NAMES[stage_or_code.to_s]}.#{SUBSTAGES_NAMES[substage.to_s]}"]
+                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
                   # stage is number
                   ["#{stage_or_code}.#{substage}"]
@@ -34,15 +28,15 @@ module Pubid::Core
     def validate_stages
       @stages.each do |stage|
         # raise an error when stage is wrong
-        raise Errors::HarmonizedStageCodeInvalidError unless DESCRIPTIONS.key?(stage)
+        raise Errors::HarmonizedStageCodeInvalidError unless config.stages["codes_description"].key?(stage)
       end
     end
 
     def to_s
       if fuzzy?
-        return "draft" if @stages.all? { |s| DRAFT_STAGES.include?(s) || CANCELED_STAGES.include?(s) }
+        return "draft" if @stages.all? { |s| config.stages["draft_codes"].include?(s) || config.stages["canceled_codes"].include?(s) }
 
-        return "published" if @stages.all? { |s| PUBLISHED_STAGES.include?(s) }
+        return "published" if @stages.all? { |s| config.stages["published_codes"].include?(s) }
 
         raise Errors::HarmonizedStageRenderingError, "cannot render fuzzy stages"
       else
@@ -73,7 +67,7 @@ module Pubid::Core
     end
 
     def description
-      DESCRIPTIONS[to_s]
+      config.stages["codes_description"][to_s]
     end
   end
 end

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

@@ -0,0 +1,157 @@
+module Pubid::Core
+  module Identifier
+    class Base
+      attr_accessor :number, :publisher, :copublisher, :part,
+                    :type, :year, :edition, :language, :amendments,
+                    :corrigendums, :stage
+
+      # Creates new identifier from options provided:
+      # @param publisher [String] document's publisher, eg. "ISO"
+      # @param copublisher [String,Array<String>] document's copublisher, eg. "IEC"
+      # @param number [Integer] document's number, eg. "1234"
+      # @param part [String] document's part and subparts, eg. "1", "1-1A", "2-3D"
+      # @param type [String] document's type, eg. "TR", "TS"
+      # @param year [Integer] document's year, eg. "2020"
+      # @param edition [Integer] document's edition, eg. "1"
+      # @param language [String] document's translation language
+      #   (available languages: "ru", "fr", "en", "ar")
+      # @param amendments [Array<Amendment>,Array<Hash>] document's amendments
+      # @param corrigendums [Array<Corrigendum>,Array<Hash>] document's corrigendums
+      # @see Amendment
+      # @see Corrigendum
+      def initialize(publisher:, number:, copublisher: nil, part: nil, type: nil,
+                     year: nil, edition: nil, language: nil, amendments: nil,
+                     corrigendums: nil, stage: nil)
+
+        if amendments
+          @amendments = amendments.map do |amendment|
+            if amendment.is_a?(Hash)
+              self.class.get_transformer_class.new.apply(:amendments => [amendment])[:amendments].first
+            else
+              amendment
+            end
+          end
+        end
+
+        if corrigendums
+          @corrigendums = corrigendums.map do |corrigendum|
+            if corrigendum.is_a?(Hash)
+              self.class.get_transformer_class.new.apply(:corrigendums => [corrigendum])[:corrigendums].first
+            else
+              corrigendum
+            end
+          end
+        end
+
+        @publisher = publisher.to_s
+        @number = number
+        @copublisher = copublisher if copublisher
+        @part = part.to_s if part
+        @type = type.to_s if type
+        @year = year.to_i if year
+        @edition = edition.to_i if edition
+        @language = language.to_s if language
+        @stage = stage if stage
+      end
+
+      # @return [String] Rendered URN identifier
+      def urn
+        Renderer::Urn.new(get_params).render
+      end
+
+      def get_params
+        instance_variables.map { |var| [var.to_s.gsub("@", "").to_sym, instance_variable_get(var)] }.to_h
+      end
+
+      # Render identifier using default renderer
+      def to_s
+        self.class.get_renderer_class.new(get_params).render
+      end
+
+      class << self
+        # Parses given identifier
+        # @param code_or_params [String, Hash] code or hash from parser
+        #   eg. "ISO 1234", { }
+        # @return [Pubid::Core::Identifier] identifier
+        def parse(code_or_params)
+          params = code_or_params.is_a?(String) ?
+                     get_parser_class.new.parse(update_old_code(code_or_params)) : code_or_params
+          transform(params.is_a?(Array) ? array_to_hash(params) : params)
+        rescue Parslet::ParseFailed => failure
+          raise Errors::ParseError, "#{failure.message}\ncause: #{failure.parse_failure_cause.ascii_tree}"
+        end
+
+        # Converts array of hashes into single hash
+        # array like [{ publisher: "ISO" }, { number: 1 }] to hash { publisher: "ISO", number: 1 }
+        # @param params [Array<Hash>] input array of hashes, eg. [{ a: 1 }, { b: 2 }]
+        def array_to_hash(params)
+          params.inject({}) do |r, i|
+            result = r
+            i.each do |k, v|
+              result = result.merge(k => r.key?(k) ? [v, r[k]].flatten : v)
+            end
+            result
+          end
+        end
+
+        # Transform parameters hash or array or hashes to identifier
+        def transform(params)
+          # run transform through each element,
+          # like running transformer.apply(number: 1) and transformer.apply(year: 1999)
+          # instead of running transformer on whole hash, like running transformer.apply({ number: 1, year: 1999 })
+          # where rule for number or year only will be not applied
+          # transformation only applied to rules matching the whole hash
+
+          identifier_params = params.map do |k, v|
+                                get_transformer_class.new.apply(k => v).to_a.first
+                              end.to_h
+
+          new(**identifier_params)
+        end
+
+        # @param type [Symbol, String] eg. :tr, :ts, "TS"
+        # @return [Boolean] true if provided type matches with identifier's class type
+        def has_type?(type)
+          return type == self.type[:key] if type.is_a?(Symbol)
+
+          self.type.key?(:values) ? self.type[:values].include?(type) : type.to_s.downcase.to_sym == self.type[:key]
+        end
+
+        def get_amendment_class
+          Amendment
+        end
+
+        def get_corrigendum_class
+          Corrigendum
+        end
+
+        def get_renderer_class
+          Renderer::Base
+        end
+
+        def get_transformer_class
+          Transformer
+        end
+
+        # @return [Hash, nil] replacement patterns
+        def get_update_codes
+          nil
+        end
+
+        def update_old_code(code)
+          return code unless get_update_codes
+
+          get_update_codes.each do |from, to|
+            code = code.gsub(from.match?(/^\/.*\/$/) ? Regexp.new(from[1..-2]) : /^#{Regexp.escape(from)}$/, to)
+          end
+          code
+        end
+
+        # Returns true when identifier's type match with provided parameters
+        def type_match?(parameters)
+          has_type?(parameters[:type])
+        end
+      end
+    end
+  end
+end

data/lib/pubid/core/identifier.rb

@@ -1,153 +1,66 @@
 module Pubid::Core
-  class Identifier
-    attr_accessor :number, :publisher, :copublisher, :part,
-                  :type, :year, :edition, :language, :amendments,
-                  :corrigendums
+  module Identifier
+    attr_accessor :config
+    @config = nil
+
+    # Resolve identifier's class and create new identifier
+    # @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
 
-    # Creates new identifier from options provided:
-    # @param publisher [String] document's publisher, eg. "ISO"
-    # @param copublisher [String,Array<String>] document's copublisher, eg. "IEC"
-    # @param number [Integer] document's number, eg. "1234"
-    # @param part [String] document's part and subparts, eg. "1", "1-1A", "2-3D"
-    # @param type [String] document's type, eg. "TR", "TS"
-    # @param year [Integer] document's year, eg. "2020"
-    # @param edition [Integer] document's edition, eg. "1"
-    # @param language [String] document's translation language
-    #   (available languages: "ru", "fr", "en", "ar")
-    # @param amendments [Array<Amendment>,Array<Hash>] document's amendments
-    # @param corrigendums [Array<Corrigendum>,Array<Hash>] document's corrigendums
-    # @see Amendment
-    # @see Corrigendum
-    def initialize(publisher:, number:, copublisher: nil, part: nil, type: nil,
-                   year: nil, edition: nil, language: nil, amendments: nil,
-                   corrigendums: nil)
+    # @param typed_stage_or_stage [String] typed stage or stage
+    # @return identifier's class
+    def resolve_identifier(parameters = {})
+      return @config.default_type.new(**parameters) if parameters[:type].nil? && parameters[:stage].nil?
 
-      if amendments
-        @amendments = amendments.map do |amendment|
-          if amendment.is_a?(Hash)
-            self.class.get_transformer_class.new.apply(:amendments => [amendment])[:amendments].first
-          else
-            amendment
-          end
-        end
+      @config.types.each do |identifier_type|
+        return identifier_type.new(**parameters) if identifier_type.type_match?(parameters)
       end
 
-      if corrigendums
-        @corrigendums = corrigendums.map do |corrigendum|
-          if corrigendum.is_a?(Hash)
-            self.class.get_transformer_class.new.apply(:corrigendums => [corrigendum])[:corrigendums].first
-          else
-            corrigendum
-          end
-        end
+      # When stage is not typed stage and type is not defined
+      if parameters[:type].nil? && (parameters[:stage].is_a?(Stage) || has_stage?(parameters[:stage]))
+        return @config.default_type.new(stage: parameters[:stage], **parameters)
       end
 
-      @publisher = publisher.to_s
-      @number = number
-      @copublisher = copublisher if copublisher
-      @part = part.to_s if part
-      @type = type.to_s if type
-      @year = year.to_i if year
-      @edition = edition.to_i if edition
-      @language = language.to_s if language
-    end
+      raise Errors::TypeStageParseError, "cannot parse typed stage or stage '#{parameters[:stage]}'" if parameters[:type].nil?
 
-    # @return [String] Rendered URN identifier
-    def urn
-      Renderer::Urn.new(get_params).render
+      raise Errors::ParseTypeError, "cannot parse type #{parameters[:type]}"
     end
 
-    def get_params
-      instance_variables.map { |var| [var.to_s.gsub("@", "").to_sym, instance_variable_get(var)] }.to_h
+    # @see Pubid::Identifier::Base.parse
+    def parse(*args)
+      Base.parse(*args)
     end
 
-    # Render identifier using default renderer
-    def to_s
-      self.class.get_renderer_class.new(get_params).render
+    # Parse identifier from title
+    def set_config(config)
+      @config = config
     end
 
-    class << self
-      # Parses given identifier
-      # @param code_or_params [String, Hash] code or hash from parser
-      #   eg. "ISO 1234", { }
-      # @return [Pubid::Core::Identifier] identifier
-      def parse(code_or_params)
-        params = code_or_params.is_a?(String) ?
-                   get_parser_class.new.parse(update_old_code(code_or_params)) : code_or_params
-        transform(params.is_a?(Array) ? array_to_hash(params) : params)
-      rescue Parslet::ParseFailed => failure
-        raise Errors::ParseError, "#{failure.message}\ncause: #{failure.parse_failure_cause.ascii_tree}"
-      end
-
-      # Converts array of hashes into single hash
-      # array like [{ publisher: "ISO" }, { number: 1 }] to hash { publisher: "ISO", number: 1 }
-      # @param params [Array<Hash>] input array of hashes, eg. [{ a: 1 }, { b: 2 }]
-      def array_to_hash(params)
-        params.inject({}) do |r, i|
-          result = r
-          i.each do |k, v|
-            result = result.merge(k => r.key?(k) ? [v, r[k]].flatten : v)
-          end
-          result
-        end
-      end
-
-      # Transform parameters hash or array or hashes to identifier
-      def transform(params)
-        # run transform through each element,
-        # like running transformer.apply(number: 1) and transformer.apply(year: 1999)
-        # instead of running transformer on whole hash, like running transformer.apply({ number: 1, year: 1999 })
-        # where rule for number or year only will be not applied
-        # transformation only applied to rules matching the whole hash
-
-        identifier_params = params.map do |k, v|
-                              get_transformer_class.new.apply(k => v).to_a.first
-                            end.to_h
-
-        new(**identifier_params)
-      end
-
-      def descendants
-        ObjectSpace.each_object(Class).select { |klass| klass < self }
-      end
-
-      # @param type [Symbol, String] eg. :tr, :ts, "TS"
-      # @return [Boolean] true if provided type matches with identifier's class type
-      def has_type?(type)
-        return type == self.type[:key] if type.is_a?(Symbol)
-
-        self.type.key?(:values) ? self.type[:values].include?(type) : type.to_s.downcase.to_sym == self.type[:key]
-      end
-
-      def get_amendment_class
-        Amendment
-      end
-
-      def get_corrigendum_class
-        Corrigendum
-      end
-
-      def get_renderer_class
-        Renderer::Base
-      end
+    def build_stage(**args)
+      Stage.new(config: @config, **args)
+    end
 
-      def get_transformer_class
-        Transformer
-      end
+    def parse_stage(stage)
+      Stage.parse(stage, config: @config)
+    end
 
-      # @return [Hash, nil] replacement patterns
-      def get_update_codes
-        nil
-      end
+    def has_stage?(stage)
+      Stage.has_stage?(stage, config: @config)
+    end
 
-      def update_old_code(code)
-        return code unless get_update_codes
+    def build_type(type, **args)
+      @config.type_class.new(type, config: @config, **args)
+    end
 
-        get_update_codes.each do |from, to|
-          code = code.gsub(from.match?(/^\/.*\/$/) ? Regexp.new(from[1..-2]) : /^#{Regexp.escape(from)}$/, to)
-        end
-        code
-      end
+    def build_harmonized_stage_code(stage_or_code, substage = "00")
+      HarmonizedStageCode.new(stage_or_code, substage, config: @config)
     end
   end
 end

data/lib/pubid/core/stage.rb

@@ -1,27 +1,27 @@
 module Pubid::Core
   class Stage
-    attr_accessor :abbr, :harmonized_code
-
-    STAGES = STAGES_CONFIG["abbreviations"]
+    attr_accessor :config, :abbr, :harmonized_code
 
     # @param abbr [String, Symbol] abbreviation eg. :PWI, :WD
     # @param harmonized_code [String, Float, HarmonizedStageCode]
-    def initialize(abbr: nil, harmonized_code: nil)
+    # @param config [Configuration]
+    def initialize(config:, abbr: nil, harmonized_code: nil)
+      @config = config
       @abbr = abbr&.to_s
 
       if harmonized_code
         @harmonized_code = if harmonized_code.is_a?(HarmonizedStageCode)
                              harmonized_code
                            else
-                             HarmonizedStageCode.new(harmonized_code)
+                             HarmonizedStageCode.new(harmonized_code, config: config)
                            end
         @abbr ||= lookup_abbr(@harmonized_code.stages)
       end
 
       if abbr
-        raise Errors::StageInvalidError, "#{abbr} is not valid stage" unless STAGES.key?(abbr.to_s)
+        raise Errors::StageInvalidError, "#{abbr} is not valid stage" unless config.stages["abbreviations"].key?(abbr.to_s)
 
-        @harmonized_code ||= HarmonizedStageCode.new(lookup_code(abbr))
+        @harmonized_code ||= HarmonizedStageCode.new(lookup_code(abbr), config: config)
       end
     end
 
@@ -31,7 +31,7 @@ module Pubid::Core
     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|
+      config.stages["abbreviations"].each do |abbr, codes|
         case codes
         when Array
           if lookup_code.is_a?(Array)
@@ -51,25 +51,25 @@ module Pubid::Core
     end
 
     def lookup_code(lookup_abbr)
-      STAGES[lookup_abbr.to_s]
+      config.stages["abbreviations"][lookup_abbr.to_s]
     end
 
-    def self.parse(stage)
+    def self.parse(stage, config:)
       if /\A[\d.]+\z/.match?(stage)
-        Stage.new(harmonized_code: stage)
+        Stage.new(harmonized_code: stage, config: config)
       else
         raise Errors::StageInvalidError unless stage.is_a?(Symbol) || stage.is_a?(String) || stage.is_a?(Parslet::Slice)
 
-        Stage.new(abbr: stage.to_s)
+        Stage.new(abbr: stage.to_s, config: config)
       end
     end
 
     # @return [Boolean] true if stage exists
-    def self.has_stage?(stage)
+    def self.has_stage?(stage, config:)
       if stage.is_a?(Stage)
-        STAGES.key?(stage.abbr.to_sym)
+        config.stages["abbreviations"].key?(stage.abbr.to_sym)
       else
-        STAGES.key?(stage.to_s) || /\A[\d.]+\z/.match?(stage)
+        config.stages["abbreviations"].key?(stage.to_s) || /\A[\d.]+\z/.match?(stage)
       end
     end
 
@@ -80,7 +80,7 @@ module Pubid::Core
 
     # Return stage name, eg. "Draft International Standard" for "DIS"
     def name
-      STAGES_CONFIG["names"][abbr.to_s]
+      config.stages["names"][abbr.to_s]
     end
 
     # @param with_prf [Boolean]

data/lib/pubid/core/type.rb

@@ -1,25 +1,30 @@
 module Pubid::Core
   class Type
-    attr_accessor :type
+    attr_accessor :type, :config
+
     # Create new type
     # @param type [Symbol]
-    def initialize(type = DEFAULT_TYPE)
+    def initialize(type = nil, config:)
+      @config = config
+      if type.nil?
+        type = @config.default_type.type[:key]
+      end
       type = type.to_s.downcase.to_sym unless type.is_a?(Symbol)
 
-      raise Errors::WrongTypeError, "#{type} type is not available" unless TYPE_NAMES.key?(type)
+      raise Errors::WrongTypeError, "#{type} type is not available" unless @config.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
+    def self.parse(type_string, config:)
+      config.type_names.each do |type, values|
+        return new(type, config: config) if values[:short] == type_string
       end
       raise Errors::ParseTypeError, "Cannot parse '#{type_string}' type"
     end
 
     def to_s(format = :short)
-      TYPE_NAMES[type][format]
+      @config.type_names[type][format]
     end
 
     def ==(other)
@@ -30,8 +35,8 @@ module Pubid::Core
       type == other.type
     end
 
-    def self.has_type?(type)
-      TYPE_NAMES.any? do |_, v|
+    def self.has_type?(type, config:)
+      config.type_names.any? do |_, v|
         v[:short] == type
       end
     end

data/lib/pubid/core/version.rb

@@ -1,5 +1,5 @@
 module Pubid
   module Core
-    VERSION = "1.5.2".freeze
+    VERSION = "1.6.0".freeze
   end
 end

data/lib/pubid/core.rb

@@ -1,5 +1,6 @@
 require "parslet"
 
+require_relative "core/configuration"
 require_relative "core/errors"
 require_relative "core/parser"
 require_relative "core/type"
@@ -10,5 +11,6 @@ require_relative "core/transformer"
 require_relative "core/renderer/base"
 require_relative "core/renderer/urn"
 require_relative "core/identifier"
+require_relative "core/identifier/base"
 require_relative "core/harmonized_stage_code"
 require_relative "core/stage"

data/lib/pubid-core.rb

@@ -1,3 +1,13 @@
 # frozen_string_literal: true
 
+module Pubid::Core
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end
+
 require_relative "pubid/core"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid-core
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-07 00:00:00.000000000 Z
+date: 2023-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,10 +66,12 @@ files:
 - lib/pubid-core.rb
 - lib/pubid/core.rb
 - lib/pubid/core/amendment.rb
+- lib/pubid/core/configuration.rb
 - lib/pubid/core/corrigendum.rb
 - lib/pubid/core/errors.rb
 - lib/pubid/core/harmonized_stage_code.rb
 - lib/pubid/core/identifier.rb
+- lib/pubid/core/identifier/base.rb
 - lib/pubid/core/parser.rb
 - lib/pubid/core/renderer/base.rb
 - lib/pubid/core/renderer/urn.rb