ruby-ulid 0.6.1 → 0.8.0

data/lib/ulid/uuid.rb

@@ -4,40 +4,72 @@
 
 # Copyright (C) 2021 Kenichi Kamiya
 
-# Extracted features around UUID from some reasons
-# ref:
-#  * https://github.com/kachick/ruby-ulid/issues/105
-#  * https://github.com/kachick/ruby-ulid/issues/76
+require_relative('errors')
+require_relative('utils')
+
 class ULID
-  # Imported from https://stackoverflow.com/a/38191104/1212807, thank you!
-  UUIDV4_PATTERN = /\A[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}\z/i.freeze
-  private_constant(:UUIDV4_PATTERN)
-
-  # @param [String, #to_str] uuid
-  # @return [ULID]
-  # @raise [ParserError] if the given format is not correct for UUIDv4 specs
-  def self.from_uuidv4(uuid)
-    uuid = String.try_convert(uuid)
-    raise(ArgumentError, 'ULID.from_uuidv4 takes only strings') unless uuid
-
-    prefix_trimmed = uuid.delete_prefix('urn:uuid:')
-    unless UUIDV4_PATTERN.match?(prefix_trimmed)
-      raise(ParserError, "given `#{uuid}` does not match to `#{UUIDV4_PATTERN.inspect}`")
+  module UUID
+    BASE_PATTERN = /\A[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\z/i
+    # Imported from https://stackoverflow.com/a/38191104/1212807, thank you!
+    V4_PATTERN = /\A[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}\z/i
+
+    def self.parse_any_to_int(uuidish)
+      encoded = String.try_convert(uuidish)
+      raise(ArgumentError, 'should pass a string for UUID parser') unless encoded
+
+      prefix_trimmed = encoded.delete_prefix('urn:uuid:')
+      unless BASE_PATTERN.match?(prefix_trimmed)
+        raise(ParserError, "given `#{encoded}` does not match to `#{BASE_PATTERN.inspect}`")
+      end
+
+      normalized = prefix_trimmed.gsub(/[^0-9A-Fa-f]/, '')
+      Integer(normalized, 16, exception: true)
     end
 
-    normalized = prefix_trimmed.gsub(/[^0-9A-Fa-f]/, '')
-    from_integer(normalized.to_i(16))
-  end
+    def self.parse_v4_to_int(uuid)
+      encoded = String.try_convert(uuid)
+      raise(ArgumentError, 'should pass a string for UUID parser') unless encoded
+
+      prefix_trimmed = encoded.delete_prefix('urn:uuid:')
+      unless V4_PATTERN.match?(prefix_trimmed)
+        raise(ParserError, "given `#{encoded}` does not match to `#{V4_PATTERN.inspect}`")
+      end
 
-  # @return [String]
-  def to_uuidv4
-    # This code referenced https://github.com/ruby/ruby/blob/121fa24a3451b45c41ac0a661b64e9fc8600e589/lib/securerandom.rb#L221-L241
-    array = octets.pack('C*').unpack('NnnnnN')
-    ref2, ref3 = array[2], array[3]
-    raise unless Integer === ref2 && Integer === ref3
+      parse_any_to_int(encoded)
+    end
+
+    # @see https://www.rfc-editor.org/rfc/rfc4122#section-4.1.2
+    # @todo Replace to Data class after dropped Ruby 3.1
+    # @note Using `Fields = Struct.new` syntax made https://github.com/kachick/ruby-ulid/issues/233 again. So use class syntax instead
+    class Fields < Struct.new(:time_low, :time_mid, :time_hi_and_version, :clock_seq_hi_and_res, :clk_seq_low, :node, keyword_init: true)
+      def self.raw_from_octets(octets)
+        case octets.pack('C*').unpack('NnnnnN')
+        in [Integer => time_low, Integer => time_mid, Integer => time_hi_and_version, Integer => clock_seq_hi_and_res, Integer => clk_seq_low, Integer => node]
+          new(time_low:, time_mid:, time_hi_and_version:, clock_seq_hi_and_res:, clk_seq_low:, node:).freeze
+        end
+      end
+
+      def self.forced_v4_from_octets(octets)
+        case octets.pack('C*').unpack('NnnnnN')
+        in [Integer => time_low, Integer => time_mid, Integer => time_hi_and_version, Integer => clock_seq_hi_and_res, Integer => clk_seq_low, Integer => node]
+          new(
+            time_low:,
+            time_mid:,
+            time_hi_and_version: (time_hi_and_version & 0x0fff) | 0x4000,
+            clock_seq_hi_and_res: (clock_seq_hi_and_res & 0x3fff) | 0x8000,
+            clk_seq_low:,
+            node:
+          ).freeze
+        end
+      end
 
-    array[2] = (ref2 & 0x0fff) | 0x4000
-    array[3] = (ref3 & 0x3fff) | 0x8000
-    ('%08x-%04x-%04x-%04x-%04x%08x' % array).freeze
+      def to_s
+        '%08x-%04x-%04x-%04x-%04x%08x' % values
+      end
+    end
   end
+
+  Ractor.make_shareable(UUID)
+
+  private_constant(:UUID)
 end

data/lib/ulid/version.rb

@@ -3,5 +3,5 @@
 # shareable_constant_value: literal
 
 class ULID
-  VERSION = '0.6.1'
+  VERSION = '0.8.0'
 end

data/lib/ulid.rb

@@ -1,6 +1,5 @@
 # coding: us-ascii
 # frozen_string_literal: true
-# shareable_constant_value: experimental_everything
 
 # Copyright (C) 2021 Kenichi Kamiya
 
@@ -9,6 +8,8 @@ require('securerandom')
 require_relative('ulid/version')
 require_relative('ulid/errors')
 require_relative('ulid/crockford_base32')
+require_relative('ulid/utils')
+require_relative('ulid/uuid')
 require_relative('ulid/monotonic_generator')
 
 # @see https://github.com/ulid/spec
@@ -23,8 +24,6 @@ class ULID
   RANDOMNESS_ENCODED_LENGTH = 16
   ENCODED_LENGTH = 26
 
-  TIMESTAMP_OCTETS_LENGTH = 6
-  RANDOMNESS_OCTETS_LENGTH = 10
   OCTETS_LENGTH = 16
 
   MAX_MILLISECONDS = 281474976710655
@@ -33,12 +32,12 @@ class ULID
 
   # @see https://github.com/ulid/spec/pull/57
   # Currently not used as a constant, but kept as a reference for now.
-  PATTERN_WITH_CROCKFORD_BASE32_SUBSET = /(?<timestamp>[0-7][#{CrockfordBase32::ENCODING_STRING}]{#{TIMESTAMP_ENCODED_LENGTH - 1}})(?<randomness>[#{CrockfordBase32::ENCODING_STRING}]{#{RANDOMNESS_ENCODED_LENGTH}})/i.freeze
+  PATTERN_WITH_CROCKFORD_BASE32_SUBSET = /(?<timestamp>[0-7][#{CrockfordBase32::ENCODING_STRING}]{#{TIMESTAMP_ENCODED_LENGTH - 1}})(?<randomness>[#{CrockfordBase32::ENCODING_STRING}]{#{RANDOMNESS_ENCODED_LENGTH}})/i
 
-  STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET = /\A#{PATTERN_WITH_CROCKFORD_BASE32_SUBSET.source}\z/i.freeze
+  STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET = /\A#{PATTERN_WITH_CROCKFORD_BASE32_SUBSET.source}\z/i
 
   # Optimized for `ULID.scan`, might be changed the definition with gathered `ULID.scan` spec changed.
-  SCANNING_PATTERN = /\b[0-7][#{CrockfordBase32::ENCODING_STRING}]{#{TIMESTAMP_ENCODED_LENGTH - 1}}[#{CrockfordBase32::ENCODING_STRING}]{#{RANDOMNESS_ENCODED_LENGTH}}\b/i.freeze
+  SCANNING_PATTERN = /\b[0-7][#{CrockfordBase32::ENCODING_STRING}]{#{TIMESTAMP_ENCODED_LENGTH - 1}}[#{CrockfordBase32::ENCODING_STRING}]{#{RANDOMNESS_ENCODED_LENGTH}}\b/i
 
   # Similar as Time#inspect since Ruby 2.7, however it is NOT same.
   # Time#inspect trancates needless digits. Keeping full milliseconds with "%3N" will fit for ULID.
@@ -46,13 +45,38 @@ class ULID
   # @see https://github.com/ruby/ruby/blob/744d17ff6c33b09334508e8110007ea2a82252f5/time.c#L4026-L4078
   TIME_FORMAT_IN_INSPECT = '%Y-%m-%d %H:%M:%S.%3N %Z'
 
-  private_class_method(:new)
+  RANDOM_INTEGER_GENERATOR = -> {
+    SecureRandom.random_number(MAX_INTEGER)
+  }.freeze
+
+  Utils.make_sharable_constants(self)
+
+  private_constant(
+    :PATTERN_WITH_CROCKFORD_BASE32_SUBSET,
+    :STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET,
+    :SCANNING_PATTERN,
+    :TIME_FORMAT_IN_INSPECT,
+    :RANDOM_INTEGER_GENERATOR,
+    :OCTETS_LENGTH,
+    :UUID
+  )
+
+  private_class_method(:new, :allocate)
 
   # @param [Integer, Time] moment
   # @param [Integer] entropy
   # @return [ULID]
-  def self.generate(moment: current_milliseconds, entropy: reasonable_entropy)
-    from_milliseconds_and_entropy(milliseconds: milliseconds_from_moment(moment), entropy: entropy)
+  # @raise [OverflowError] if the given value is larger than the ULID limit
+  # @raise [ArgumentError] if the given milliseconds and/or entropy is negative number
+  def self.generate(moment: Utils.current_milliseconds, entropy: Utils.reasonable_entropy)
+    milliseconds = Utils.milliseconds_from_moment(moment)
+    base32hex = Utils.encode_base32hex(milliseconds:, entropy:)
+    new(
+      milliseconds:,
+      entropy:,
+      integer: Integer(base32hex, 32, exception: true),
+      encoded: CrockfordBase32.from_base32hex(base32hex).freeze
+    )
   end
 
   # Almost same as [.generate] except directly returning String without needless object creation
@@ -60,9 +84,9 @@ class ULID
   # @param [Integer, Time] moment
   # @param [Integer] entropy
   # @return [String]
-  def self.encode(moment: current_milliseconds, entropy: reasonable_entropy)
-    n32_encoded = encode_n32(milliseconds: milliseconds_from_moment(moment), entropy: entropy)
-    CrockfordBase32.from_n32(n32_encoded)
+  def self.encode(moment: Utils.current_milliseconds, entropy: Utils.reasonable_entropy)
+    base32hex = Utils.encode_base32hex(milliseconds: Utils.milliseconds_from_moment(moment), entropy:)
+    CrockfordBase32.from_base32hex(base32hex)
   end
 
   # Short hand of `ULID.generate(moment: time)`
@@ -71,25 +95,21 @@ class ULID
   def self.at(time)
     raise(ArgumentError, 'ULID.at takes only `Time` instance') unless Time === time
 
-    from_milliseconds_and_entropy(milliseconds: milliseconds_from_time(time), entropy: reasonable_entropy)
+    generate(moment: time)
   end
 
   # @param [Time, Integer] moment
   # @return [ULID]
   def self.min(moment=0)
-    0.equal?(moment) ? MIN : generate(moment: moment, entropy: 0)
+    0.equal?(moment) ? MIN : generate(moment:, entropy: 0)
   end
 
   # @param [Time, Integer] moment
   # @return [ULID]
   def self.max(moment=MAX_MILLISECONDS)
-    MAX_MILLISECONDS.equal?(moment) ? MAX : generate(moment: moment, entropy: MAX_ENTROPY)
+    MAX_MILLISECONDS.equal?(moment) ? MAX : generate(moment:, entropy: MAX_ENTROPY)
   end
 
-  RANDOM_INTEGER_GENERATOR = -> {
-    SecureRandom.random_number(MAX_INTEGER)
-  }.freeze
-
   # @param [Range<Time>, Range<nil>, Range[ULID], nil] period
   # @overload sample(number, period: nil)
   #   @param [Integer] number
@@ -162,20 +182,20 @@ class ULID
     raise(OverflowError, "integer overflow: given #{integer}, max: #{MAX_INTEGER}") unless integer <= MAX_INTEGER
     raise(ArgumentError, "integer should not be negative: given: #{integer}") if integer.negative?
 
-    n32encoded = integer.to_s(32).rjust(ENCODED_LENGTH, '0')
-    n32encoded_timestamp = n32encoded.slice(0, TIMESTAMP_ENCODED_LENGTH)
-    n32encoded_randomness = n32encoded.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH)
+    base32hex = integer.to_s(32).rjust(ENCODED_LENGTH, '0')
+    base32hex_timestamp = base32hex.slice(0, TIMESTAMP_ENCODED_LENGTH)
+    base32hex_randomness = base32hex.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH)
 
-    raise(UnexpectedError) unless n32encoded_timestamp && n32encoded_randomness
+    raise(UnexpectedError) unless base32hex_timestamp && base32hex_randomness
 
-    milliseconds = n32encoded_timestamp.to_i(32)
-    entropy = n32encoded_randomness.to_i(32)
+    milliseconds = Integer(base32hex_timestamp, 32, exception: true)
+    entropy = Integer(base32hex_randomness, 32, exception: true)
 
     new(
-      milliseconds: milliseconds,
-      entropy: entropy,
-      integer: integer,
-      encoded: CrockfordBase32.from_n32(n32encoded).freeze
+      milliseconds:,
+      entropy:,
+      integer:,
+      encoded: CrockfordBase32.from_base32hex(base32hex).freeze
     )
   end
 
@@ -186,12 +206,10 @@ class ULID
     raise(ArgumentError, 'ULID.range takes only `Range[Time]`, `Range[nil]` or `Range[ULID]`') unless Range === period
 
     begin_element, end_element, exclude_end = period.begin, period.end, period.exclude_end?
-    new_begin, new_end = false, false
 
     begin_ulid = (
       case begin_element
       when Time
-        new_begin = true
         min(begin_element)
       when nil
         MIN
@@ -205,7 +223,6 @@ class ULID
     end_ulid = (
       case end_element
       when Time
-        new_end = true
         exclude_end ? min(end_element) : max(end_element)
       when nil
         exclude_end = false
@@ -218,9 +235,6 @@ class ULID
       end
     )
 
-    begin_ulid.freeze if new_begin
-    end_ulid.freeze if new_end
-
     Range.new(begin_ulid, end_ulid, exclude_end)
   end
 
@@ -232,49 +246,6 @@ class ULID
     time.floor(3)
   end
 
-  # @api private
-  # @return [Integer]
-  def self.current_milliseconds
-    milliseconds_from_time(Time.now)
-  end
-
-  # @api private
-  # @param [Time] time
-  # @return [Integer]
-  private_class_method def self.milliseconds_from_time(time)
-    (time.to_r * 1000).to_i
-  end
-
-  # @api private
-  # @param [Time, Integer] moment
-  # @return [Integer]
-  def self.milliseconds_from_moment(moment)
-    case moment
-    when Integer
-      moment
-    when Time
-      milliseconds_from_time(moment)
-    else
-      raise(ArgumentError, '`moment` should be a `Time` or `Integer as milliseconds`')
-    end
-  end
-
-  # @return [Integer]
-  private_class_method def self.reasonable_entropy
-    SecureRandom.random_number(MAX_ENTROPY)
-  end
-
-  private_class_method def self.encode_n32(milliseconds:, entropy:)
-    raise(ArgumentError, 'milliseconds and entropy should be an `Integer`') unless Integer === milliseconds && Integer === entropy
-    raise(OverflowError, "timestamp overflow: given #{milliseconds}, max: #{MAX_MILLISECONDS}") unless milliseconds <= MAX_MILLISECONDS
-    raise(OverflowError, "entropy overflow: given #{entropy}, max: #{MAX_ENTROPY}") unless entropy <= MAX_ENTROPY
-    raise(ArgumentError, 'milliseconds and entropy should not be negative') if milliseconds.negative? || entropy.negative?
-
-    n32encoded_timestamp = milliseconds.to_s(32).rjust(TIMESTAMP_ENCODED_LENGTH, '0')
-    n32encoded_randomness = entropy.to_s(32).rjust(RANDOMNESS_ENCODED_LENGTH, '0')
-    "#{n32encoded_timestamp}#{n32encoded_randomness}"
-  end
-
   # @param [String, #to_str] string
   # @return [ULID]
   # @raise [ParserError] if the given format is not correct for ULID specs
@@ -303,10 +274,11 @@ class ULID
   # Almost same as `ULID.parse(string).to_time` except directly returning Time instance without needless object creation
   #
   # @param [String, #to_str] string
+  # @param [String, Integer, nil] in
   # @return [Time]
   # @raise [ParserError] if the given format is not correct for ULID specs
   def self.decode_time(string, in: 'UTC')
-    in_for_time_at = binding.local_variable_get(:in) # Needed because `in` is a reserved word.
+    in_for_time_at = { in: }.fetch(:in)
     string = String.try_convert(string)
     raise(ArgumentError, 'ULID.decode_time takes only strings') unless string
 
@@ -327,7 +299,7 @@ class ULID
     raise(ArgumentError, 'ULID.normalize takes only strings') unless string
 
     # Ensure the ULID correctness, because CrockfordBase32 does not always mean to satisfy ULID format
-    parse_variant_format(string).to_s
+    parse_variant_format(string).encode
   end
 
   # @param [String, #to_str] string
@@ -350,19 +322,6 @@ class ULID
     true
   end
 
-  # @deprecated Use [.valid_as_variant_format?] or [.normalized?] instead
-  #
-  # Returns `true` if it is normalized string.
-  # Basically the difference of normalized? is to accept downcase or not. This returns true for downcased ULIDs.
-  #
-  # @return [Boolean]
-  def self.valid?(string)
-    warn_kwargs = (RUBY_VERSION >= '3.0') ? { category: :deprecated } : {}
-    Warning.warn('ULID.valid? is deprecated. Use ULID.valid_as_variant_format? or ULID.normalized? instead.', **warn_kwargs)
-    string = String.try_convert(string)
-    string ? STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET.match?(string) : false
-  end
-
   # @param [ULID, #to_ulid] object
   # @return [ULID, nil]
   # @raise [TypeError] if `object.to_ulid` did not return ULID instance
@@ -375,61 +334,30 @@ class ULID
       if ULID === converted
         converted
       else
-        object_class_name = safe_get_class_name(object)
-        converted_class_name = safe_get_class_name(converted)
+        object_class_name = Utils.safe_get_class_name(object)
+        converted_class_name = Utils.safe_get_class_name(converted)
         raise(TypeError, "can't convert #{object_class_name} to ULID (#{object_class_name}#to_ulid gives #{converted_class_name})")
       end
     end
   end
 
-  # @param [BasicObject] object
-  # @return [String]
-  private_class_method def self.safe_get_class_name(object)
-    fallback = 'UnknownObject'
-
-    # This class getter implementation used https://github.com/rspec/rspec-support/blob/4ad8392d0787a66f9c351d9cf6c7618e18b3d0f2/lib/rspec/support.rb#L83-L89 as a reference, thank you!
-    # ref: https://twitter.com/_kachick/status/1400064896759304196
-    klass = (
-      begin
-        object.class
-      rescue NoMethodError
-        # steep can't correctly handle singleton class assign. See https://github.com/soutaro/steep/pull/586 for further detail
-        # So this annotation is hack for the type infer.
-        # @type var object: BasicObject
-        # @type var singleton_class: untyped
-        singleton_class = class << object; self; end
-        (Class === singleton_class) ? singleton_class.ancestors.detect { |ancestor| !ancestor.equal?(singleton_class) } : fallback
-      end
-    )
-
-    begin
-      name = String.try_convert(klass.name)
-    rescue Exception
-      fallback
-    else
-      name || fallback
-    end
+  # @param [String, #to_str] uuidish
+  # @return [ULID]
+  # @raise [ParserError] if the given format is not correct for UUID`ish` format
+  def self.from_uuidish(uuidish)
+    from_integer(UUID.parse_any_to_int(uuidish))
   end
 
-  # @api private
-  # @param [Integer] milliseconds
-  # @param [Integer] entropy
+  # @param [String, #to_str] uuid
   # @return [ULID]
-  # @raise [OverflowError] if the given value is larger than the ULID limit
-  # @raise [ArgumentError] if the given milliseconds and/or entropy is negative number
-  def self.from_milliseconds_and_entropy(milliseconds:, entropy:)
-    n32_encoded = encode_n32(milliseconds: milliseconds, entropy: entropy)
-    new(
-      milliseconds: milliseconds,
-      entropy: entropy,
-      integer: n32_encoded.to_i(32),
-      encoded: CrockfordBase32.from_n32(n32_encoded).upcase.freeze
-    )
+  # @raise [ParserError] if the given format is not correct for UUIDv4 specs
+  def self.from_uuidv4(uuid)
+    from_integer(UUID.parse_v4_to_int(uuid))
   end
 
-  attr_reader(:milliseconds, :entropy)
+  attr_reader(:milliseconds, :entropy, :encoded)
+  protected(:encoded)
 
-  # @api private
   # @param [Integer] milliseconds
   # @param [Integer] entropy
   # @param [Integer] integer
@@ -441,6 +369,7 @@ class ULID
     @encoded = encoded
     @milliseconds = milliseconds
     @entropy = entropy
+    freeze
   end
 
   # @return [String]
@@ -466,7 +395,7 @@ class ULID
 
   # @return [String]
   def inspect
-    @inspect ||= "ULID(#{to_time.strftime(TIME_FORMAT_IN_INSPECT)}: #{@encoded})".freeze
+    "ULID(#{to_time.strftime(TIME_FORMAT_IN_INSPECT)}: #{@encoded})"
   end
 
   # @return [Boolean]
@@ -499,47 +428,25 @@ class ULID
   end
 
   # @return [Time]
-  def to_time
-    @time ||= Time.at(0, @milliseconds, :millisecond, in: 'UTC').freeze
+  # @param [String, Integer, nil] in
+  def to_time(in: 'UTC')
+    Time.at(0, @milliseconds, :millisecond, in: { in: }.fetch(:in))
   end
 
   # @return [Array(Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer)]
   def octets
     digits = @integer.digits(256)
-    (OCTETS_LENGTH - digits.size).times do
-      digits.push(0)
-    end
-    digits.reverse!
-  end
-
-  # @return [Array(Integer, Integer, Integer, Integer, Integer, Integer)]
-  def timestamp_octets
-    octets.slice(0, TIMESTAMP_OCTETS_LENGTH) || raise(UnexpectedError)
-  end
-
-  # @return [Array(Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer)]
-  def randomness_octets
-    octets.slice(TIMESTAMP_OCTETS_LENGTH, RANDOMNESS_OCTETS_LENGTH) || raise(UnexpectedError)
+    digits.fill(0, digits.size, OCTETS_LENGTH - digits.size).reverse
   end
 
   # @return [String]
   def timestamp
-    @timestamp ||= (@encoded.slice(0, TIMESTAMP_ENCODED_LENGTH).freeze || raise(UnexpectedError))
+    @encoded.slice(0, TIMESTAMP_ENCODED_LENGTH) || raise(UnexpectedError)
   end
 
   # @return [String]
   def randomness
-    @randomness ||= (@encoded.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH).freeze || raise(UnexpectedError))
-  end
-
-  # @note Providing for rough operations. The keys and values is not fixed.
-  # @return [Hash{Symbol => Regexp, String}]
-  def patterns
-    named_captures = /(?<timestamp>#{timestamp})(?<randomness>#{randomness})/i.freeze
-    {
-      named_captures: named_captures,
-      strict_named_captures: /\A#{named_captures.source}\z/i.freeze
-    }
+    @encoded.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH) || raise(UnexpectedError)
   end
 
   # @return [ULID, nil] when called on ULID as `7ZZZZZZZZZZZZZZZZZZZZZZZZZ`, returns `nil` instead of ULID
@@ -571,25 +478,21 @@ class ULID
     end
   end
 
-  # @return [self]
-  def freeze
-    # Need to cache before freezing, because frozen objects can't assign instance variables
-    cache_all_instance_variables
-    super
-  end
-
-  # @api private
   # @return [Integer]
   def marshal_dump
     @integer
   end
 
-  # @api private
   # @param [Integer] integer
   # @return [void]
   def marshal_load(integer)
     unmarshaled = ULID.from_integer(integer)
-    initialize(integer: unmarshaled.to_i, milliseconds: unmarshaled.milliseconds, entropy: unmarshaled.entropy, encoded: unmarshaled.to_s)
+    initialize(
+      integer: unmarshaled.to_i,
+      milliseconds: unmarshaled.milliseconds,
+      entropy: unmarshaled.entropy,
+      encoded: unmarshaled.encoded
+    )
   end
 
   # @return [self]
@@ -597,31 +500,49 @@ class ULID
     self
   end
 
-  # @return [self]
-  def dup
-    self
+  # Generate a UUID-like string that does not set the version and variants field.
+  # It means wrong in UUIDv4 spec, but reversible
+  #
+  # @return [String]
+  def to_uuidish
+    UUID::Fields.raw_from_octets(octets).to_s.freeze
   end
 
-  # @return [self]
-  def clone(freeze: true)
-    self
+  # Generate a UUIDv4-like string that sets the version and variants field.
+  # It may conform to the UUID specification, but it is irreversible with the source ULID and may conflict with some other ULIDs.
+  # You can specify `force` keyword argument to turn off the irreversible check
+  #
+  # @raise [IrreversibleUUIDError] if the converted UUID cannot be reversible with the replacing above 2 fields
+  # @see https://github.com/kachick/ruby-ulid/issues/76
+  # @param [bool] force
+  # @return [String]
+  def to_uuidv4(force: false)
+    v4 = UUID::Fields.forced_v4_from_octets(octets)
+    unless force
+      uuidish = UUID::Fields.raw_from_octets(octets)
+      raise(IrreversibleUUIDError) unless uuidish == v4
+    end
+
+    v4.to_s.freeze
   end
 
-  undef_method(:instance_variable_set)
+  # @return [ULID]
+  def dup
+    super.freeze
+  end
 
-  private
+  # @return [ULID]
+  def clone(freeze: true)
+    raise(ArgumentError, 'unfreezing ULID is an unexpected operation') unless freeze == true
 
-  # @return [void]
-  def cache_all_instance_variables
-    inspect
-    timestamp
-    randomness
+    super
   end
-end
 
-require_relative('ulid/ractor_unshareable_constants')
+  MIN = parse('00000000000000000000000000')
+  MAX = parse('7ZZZZZZZZZZZZZZZZZZZZZZZZZ')
 
-class ULID
-  # Do not write as `ULID.private_constant` for avoiding YARD warnings `[warn]: in YARD::Handlers::Ruby::PrivateConstantHandler: Undocumentable private constants:`
-  private_constant(:TIME_FORMAT_IN_INSPECT, :MIN, :MAX, :RANDOM_INTEGER_GENERATOR)
+  Ractor.make_shareable(MIN)
+  Ractor.make_shareable(MAX)
+
+  private_constant(:MIN, :MAX)
 end