ruby-ulid 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c7cf89034d0f74026278e2a4c113d57f8fc28b861b8bcf1d2210dbb76688e52
-  data.tar.gz: 340bfbea8fb1ff3ec0e49339e2a5a388a81552f8cd73a65ad9ff049448fc0c3f
+  metadata.gz: 637c2b95fc9d18a59e1bc6d23a3791bc80362b146c52ff962c407894c29c782e
+  data.tar.gz: 74a9e3ea4be5d9a541d4cb6dd012997406ef3cb68a08f7a1a42959f40f7ab4e5
 SHA512:
-  metadata.gz: 74d26cb5dc49a8d79a5c933817c1c8913954d675d996a91057f29859fd1fdf0a32c99d8121ef954e1d7d400110fa1737be17a9084bfc03655082de96c9614392
-  data.tar.gz: 96f19838c4c90ee313722857f88693e88f247e5380293291b362eadc834f6adb1613c01034a0cfe430f24576b4fea55f252b79f689b00c3e05b739118db8906e
+  metadata.gz: c39c42f8da0aac22356cb26fefb7d23855d118f68148be90c1e253577847b91135f8a04ef1fdca1af59075bd673e61cf2f492f046f30616f7c6b493e28332174
+  data.tar.gz: 623f7f9b4d46e46c2a47a143330b3d1c2cf83a033e83c8e68ab3af13e56f1ff5a082b3a15f57efcf4a3180fcc5786e18e94a0221fd03c44343322d641b69e31a

data/README.md

@@ -1,13 +1,13 @@
 # ruby-ulid
 
-[![Build Status](https://github.com/kachick/ruby-ulid/actions/workflows/test_behaviors.yml/badge.svg?branch=main)](https://github.com/kachick/ruby-ulid/actions/workflows/test_behaviors.yml/?branch=main)
+[![Build Status](https://github.com/kachick/ruby-ulid/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/kachick/ruby-ulid/actions/workflows/ci.yml?query=branch%3Amain)
 [![Gem Version](https://badge.fury.io/rb/ruby-ulid.svg)](http://badge.fury.io/rb/ruby-ulid)
 
 ## Overview
 
-[ulid/spec](https://github.com/ulid/spec) is useful.
-Especially possess all `uniqueness`, `randomness`, `extractable timestamps` and `sortable` features.  
-This gem aims to provide the generator, optional monotonicity, parser and other manipulation features around ULID with included [RBS](https://github.com/ruby/rbs).
+[ulid/spec](https://github.com/ulid/spec) has some useful features.\
+Especially possess all `uniqueness`, `randomness`, `extractable timestamps` and `sortability`.\
+This gem aims to provide the generator, optional monotonicity, parser and other manipulation ways around ULID with included [RBS](https://github.com/ruby/rbs).
 
 ---
 
@@ -49,7 +49,7 @@ Should be installed!
 Add this line in your Gemfile.
 
 ```ruby
-gem('ruby-ulid', '~> 0.6.1')
+gem('ruby-ulid', '~> 0.7.0')
 ```
 
 ### How to use
@@ -58,10 +58,10 @@ gem('ruby-ulid', '~> 0.6.1')
 require 'ulid'
 
 ULID::VERSION
-# => "0.6.1"
+# => "0.7.0"
 ```
 
-NOTE: This README includes info about development version. If you would see released version's one. [Look at the ref](https://github.com/kachick/ruby-ulid/tree/v0.6.1).
+NOTE: This README includes info about development version. If you would see released version's one. [Look at the ref](https://github.com/kachick/ruby-ulid/tree/v0.7.0).
 
 ### Generator and Parser
 
@@ -99,9 +99,9 @@ ULID.generate(moment: time) #=> ULID(2000-01-01 00:00:00.000 UTC: 00VHNCZB006WQT
 ULID.at(time) #=> ULID(2000-01-01 00:00:00.000 UTC: 00VHNCZB002W5BGWWKN76N22H6)
 ```
 
-Also `ULID.encode` and `ULID.decode_time` can be used to get primitive values for most usecases.  
+Also `ULID.encode` and `ULID.decode_time` can be used to get primitive values for most usecases.
 
-`ULID.encode` returns [normalized](#variants-of-format) String without ULID object creation.  
+`ULID.encode` returns [normalized](#variants-of-format) String without ULID object creation.\
 It can take same arguments as `ULID.generate`.
 
 ```ruby
@@ -116,13 +116,13 @@ ULID.decode_time('00VHNCZB00SYG7RCEXZC9DA4E1') #=> 2000-01-01 00:00:00 UTC
 ULID.decode_time('00VHNCZB00SYG7RCEXZC9DA4E1', in: '+09:00') #=> 2000-01-01 09:00:00 +0900
 ```
 
-This project does not prioritize the speed. However it actually works faster than others! :zap:
+This project does not prioritize on the speed. However it actually works faster than others! :zap:
 
-Snapshot on 0.6.1 is below
+Snapshot on 0.7.0 is below
 
-* Generator is 1.5x faster than - [ulid gem](https://github.com/rafaelsales/ulid)
-* Generator is 1.9x faster than - [ulid-ruby gem](https://github.com/abachman/ulid-ruby)
-* Parser is 2.7x faster than - [ulid-ruby gem](https://github.com/abachman/ulid-ruby)
+- Generator is 1.6x faster than - [ulid gem](https://github.com/rafaelsales/ulid)
+- Generator is 1.9x faster than - [ulid-ruby gem](https://github.com/abachman/ulid-ruby)
+- Parser is 2.6x faster than - [ulid-ruby gem](https://github.com/abachman/ulid-ruby)
 
 You can see further detail at [Benchmark](https://github.com/kachick/ruby-ulid/wiki/Benchmark).
 
@@ -151,7 +151,7 @@ ulids.sort == ulids #=> false
 
 ### How to keep `Sortable` even if in same timestamp
 
-If you want to prefer `sortable`, Use `MonotonicGenerator` instead. It is called as [Monotonicity](https://github.com/ulid/spec/tree/d0c7170df4517939e70129b4d6462cc162f2d5bf#monotonicity) on the spec.
+If you want to prefer `sortable`, Use `MonotonicGenerator` instead. It is called as [Monotonicity](https://github.com/ulid/spec/tree/d0c7170df4517939e70129b4d6462cc162f2d5bf#monotonicity) on the spec.\
 (Though it starts with new random value when changed the timestamp)
 
 ```ruby
@@ -195,7 +195,7 @@ ulids.grep(one_of_the_above)
 ulids.grep_v(one_of_the_above)
 ```
 
-When want to filter ULIDs with `Time`, we should consider to handle the precision.
+When want to filter ULIDs with `Time`, we should consider to handle the precision.\
 So this gem provides `ULID.range` to generate reasonable `Range[ULID]` from `Range[Time]`
 
 ```ruby
@@ -294,7 +294,7 @@ ULID.max(time) #=> ULID(2000-01-01 00:00:00.123 UTC: 00VHNCZB3VZZZZZZZZZZZZZZZZ)
 
 #### As element in Enumerable
 
-`ULID#next` and `ULID#succ` returns next(successor) ULID.
+`ULID#next` and `ULID#succ` returns next(successor) ULID.\
 Especially `ULID#succ` makes it possible `Range[ULID]#each`.
 
 NOTE: However basically `Range[ULID]#each` should not be used. Incrementing 128 bits IDs are not reasonable operation in most cases.
@@ -360,15 +360,15 @@ ULID.sample(5, period: ulid1.to_time..ulid2.to_time)
 
 I'm afraid so, we should consider [Current ULID spec](https://github.com/ulid/spec/tree/d0c7170df4517939e70129b4d6462cc162f2d5bf#universally-unique-lexicographically-sortable-identifier) has `orthographical variants of the format` possibilities.
 
->Case insensitive
+> Case insensitive
 
-I can understand it might be considered in actual use-case. So `ULID.parse` accepts upcase and downcase.
+I can understand it might be considered in actual use-case. So `ULID.parse` accepts upcase and downcase.\
 However it is a controversial point, discussing in [ulid/spec#3](https://github.com/ulid/spec/issues/3).
 
->Uses Crockford's base32 for better efficiency and readability (5 bits per character)
+> Uses Crockford's base32 for better efficiency and readability (5 bits per character)
 
-The original `Crockford's base32` maps `I`, `L` to `1`, `O` to `0`.
-And accepts freestyle inserting `Hyphens (-)`.
+The original `Crockford's base32` maps `I`, `L` to `1`, `O` to `0`.\
+And accepts freestyle inserting `Hyphens (-)`.\
 To consider this patterns or not is different in each implementations.
 
 I have suggested to clarify `subset of Crockford's base32` in [ulid/spec#57](https://github.com/ulid/spec/pull/57).
@@ -387,7 +387,7 @@ ULID.parse_variant_format('01G70Y0Y7G-ZLXWDIREXERGSDoD') #=> ULID(2022-07-03 02:
 
 #### UUIDv4 converter (experimental)
 
-`ULID.from_uuidv4` and `ULID#to_uuidv4` is the converter.
+`ULID.from_uuidv4` and `ULID#to_uuidv4` is the converter.\
 The imported timestamp is meaningless. So ULID's benefit will lost.
 
 ```ruby
@@ -426,11 +426,11 @@ See [wiki page for gem migration](https://github.com/kachick/ruby-ulid/wiki/Gem-
 
 Try at [examples/rbs_sandbox](https://github.com/kachick/ruby-ulid/tree/main/examples/rbs_sandbox).
 
-I have checked the behavior with [ruby/rbs@2.6.0](https://github.com/ruby/rbs) + [soutaro/steep@1.0.1](https://github.com/soutaro/steep) +  [soutaro/steep-vscode](https://github.com/soutaro/steep-vscode).
+I have checked the behavior with [ruby/rbs@2.6.0](https://github.com/ruby/rbs) + [soutaro/steep@1.0.1](https://github.com/soutaro/steep) + [soutaro/steep-vscode](https://github.com/soutaro/steep-vscode).
 
-* ![rbs overview](./assets/ulid-rbs-overview.png?raw=true.png)
-* ![rbs mix](./assets/ulid-rbs-mix.png?raw=true.png)
-* ![rbs ng-to_str](./assets/ulid-rbs-ng-to_str.png?raw=true.png)
+- ![rbs overview](./assets/ulid-rbs-overview.png?raw=true.png)
+- ![rbs mix](./assets/ulid-rbs-mix.png?raw=true.png)
+- ![rbs ng-to_str](./assets/ulid-rbs-ng-to_str.png?raw=true.png)
 
 ## References
 
@@ -440,5 +440,5 @@ I have checked the behavior with [ruby/rbs@2.6.0](https://github.com/ruby/rbs) +
 
 ## Note
 
-- [UUIDv6, UUIDv7, UUIDv8](https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-01.html) is another choice for sortable and randomness ID.  
+- [UUIDv6, UUIDv7, UUIDv8](https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-01.html) is another choice for sortable and randomness ID.\
   However they are stayed in draft state. ref: [ruby-ulid#37](https://github.com/kachick/ruby-ulid/issues/37)

data/lib/ulid/crockford_base32.rb

@@ -1,9 +1,10 @@
 # coding: us-ascii
 # frozen_string_literal: true
-# shareable_constant_value: literal
 
 # Copyright (C) 2021 Kenichi Kamiya
 
+require_relative('utils')
+
 class ULID
   # @see https://www.crockford.com/base32.html
   #
@@ -68,36 +69,36 @@ class ULID
     VARIANT_TR_PATTERN = variant_to_normarized.keys.join.freeze
     NORMALIZED_TR_PATTERN = variant_to_normarized.values.join.freeze
 
+    Utils.make_sharable_constantans(self)
+
     # @note Avoid to depend regex as possible. `tr(string, string)` is almost 2x Faster than `gsub(regex, hash)` in Ruby 3.1
 
-    # @api private
     # @param [String] string
     # @return [Integer]
     def self.decode(string)
-      n32encoded = string.upcase.tr(CROCKFORD_TR_PATTERN, BASE32_TR_PATTERN)
-      n32encoded.to_i(32)
+      base32encoded = string.upcase.tr(CROCKFORD_TR_PATTERN, BASE32_TR_PATTERN)
+      Integer(base32encoded, 32, exception: true)
     end
 
-    # @api private
     # @param [Integer] integer
     # @return [String]
     def self.encode(integer)
-      n32encoded = integer.to_s(32)
-      from_n32(n32encoded).rjust(ENCODED_LENGTH, '0')
+      base32encoded = integer.to_s(32)
+      from_base32(base32encoded).rjust(ENCODED_LENGTH, '0')
     end
 
-    # @api private
     # @param [String] string
     # @return [String]
     def self.normalize(string)
       string.delete('-').tr(VARIANT_TR_PATTERN, NORMALIZED_TR_PATTERN)
     end
 
-    # @api private
-    # @param [String] n32encoded
+    # @param [String] base32encoded
     # @return [String]
-    def self.from_n32(n32encoded)
-      n32encoded.upcase.tr(BASE32_TR_PATTERN, CROCKFORD_TR_PATTERN)
+    def self.from_base32(base32encoded)
+      base32encoded.upcase.tr(BASE32_TR_PATTERN, CROCKFORD_TR_PATTERN)
     end
   end
+
+  private_constant(:CrockfordBase32)
 end

data/lib/ulid/monotonic_generator.rb

@@ -4,6 +4,9 @@
 
 # Copyright (C) 2021 Kenichi Kamiya
 
+require_relative('errors')
+require_relative('utils')
+
 class ULID
   class MonotonicGenerator
     # @note When use https://github.com/ko1/ractor-tvar might realize Ractor based thread safe monotonic generator.
@@ -11,7 +14,8 @@ class ULID
     include(MonitorMixin)
 
     # @return [ULID, nil]
-    attr_reader(:prev)
+    attr_accessor(:prev)
+    private(:prev=)
 
     undef_method(:instance_variable_set)
 
@@ -31,7 +35,7 @@ class ULID
     # @raise [OverflowError] if the entropy part is larger than the ULID limit in same milliseconds
     # @raise [UnexpectedError] if the generated ULID is an invalid value in monotonicity spec.
     #   Basically will not happen. Just means this feature prefers error rather than invalid value.
-    def generate(moment: ULID.current_milliseconds)
+    def generate(moment: Utils.current_milliseconds)
       synchronize do
         prev_ulid = @prev
         unless prev_ulid
@@ -40,13 +44,13 @@ class ULID
           return ret
         end
 
-        milliseconds = ULID.milliseconds_from_moment(moment)
+        milliseconds = Utils.milliseconds_from_moment(moment)
 
         ulid = (
           if prev_ulid.milliseconds < milliseconds
             ULID.generate(moment: milliseconds)
           else
-            ULID.from_milliseconds_and_entropy(milliseconds: prev_ulid.milliseconds, entropy: prev_ulid.entropy.succ)
+            ULID.generate(moment: prev_ulid.milliseconds, entropy: prev_ulid.entropy.succ)
           end
         )
 
@@ -68,9 +72,12 @@ class ULID
       end
     end
 
+    # Just providing similar api as `ULID.generate` and `ULID.encode` relation. No performance benefit exists in monotonic generator's one.
+    #
+    # @see https://github.com/kachick/ruby-ulid/pull/220
     # @param [Time, Integer] moment
     # @return [String]
-    def encode(moment: ULID.current_milliseconds)
+    def encode(moment: Utils.current_milliseconds)
       generate(moment: moment).encode
     end
 

data/lib/ulid/utils.rb

@@ -0,0 +1,117 @@
+# coding: us-ascii
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+# Copyright (C) 2021 Kenichi Kamiya
+
+require('securerandom')
+
+class ULID
+  # @note I don't have confidence for the naming of `Utils`. However some standard libraries have same name.
+  #   https://github.com/ruby/webrick/blob/14612a7540fdd7373344461851c4bfff64985b3e/lib/webrick/utils.rb#L17
+  #   https://docs.ruby-lang.org/ja/latest/class/ERB=3a=3aUtil.html
+  #   https://github.com/ruby/rss/blob/af1c3c9c9630ec0a48abec48ed1ef348ba82aa13/lib/rss/utils.rb#L9
+  module Utils
+    # @return [Integer]
+    def self.current_milliseconds
+      milliseconds_from_time(Time.now)
+    end
+
+    # @param [Time] time
+    # @return [Integer]
+    def self.milliseconds_from_time(time)
+      (time.to_r * 1000).to_i
+    end
+
+    # @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]
+    def self.reasonable_entropy
+      SecureRandom.random_number(MAX_ENTROPY)
+    end
+
+    # @param [Integer] milliseconds
+    # @param [Integer] entropy
+    # @return [String]
+    # @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.encode_base32(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?
+
+      base32encoded_timestamp = milliseconds.to_s(32).rjust(TIMESTAMP_ENCODED_LENGTH, '0')
+      base32encoded_randomness = entropy.to_s(32).rjust(RANDOMNESS_ENCODED_LENGTH, '0')
+      "#{base32encoded_timestamp}#{base32encoded_randomness}"
+    end
+
+    # @param [BasicObject] object
+    # @return [String]
+    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
+    end
+
+    def self.make_sharable_value(value)
+      value.freeze
+      if defined?(Ractor)
+        case value
+        when ULID, Time
+          if ractor_can_make_shareable_time?
+            Ractor.make_shareable(value)
+          end
+        else
+          Ractor.make_shareable(value)
+        end
+      end
+    end
+
+    # @note Call before Module#private_constant
+    def self.make_sharable_constantans(mod)
+      mod.constants.each do |const_name|
+        value = mod.const_get(const_name)
+        make_sharable_value(value)
+      end
+    end
+
+    def self.ractor_can_make_shareable_time?
+      RUBY_VERSION >= '3.1'
+    end
+  end
+
+  private_constant(:Utils)
+end

data/lib/ulid/uuid.rb

@@ -1,9 +1,10 @@
 # coding: us-ascii
 # frozen_string_literal: true
-# shareable_constant_value: literal
 
 # Copyright (C) 2021 Kenichi Kamiya
 
+require_relative('errors')
+
 # Extracted features around UUID from some reasons
 # ref:
 #  * https://github.com/kachick/ruby-ulid/issues/105
@@ -11,6 +12,7 @@
 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
+  Utils.make_sharable_value(UUIDV4_PATTERN)
   private_constant(:UUIDV4_PATTERN)
 
   # @param [String, #to_str] uuid

data/lib/ulid/version.rb

@@ -3,5 +3,5 @@
 # shareable_constant_value: literal
 
 class ULID
-  VERSION = '0.6.1'
+  VERSION = '0.7.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,7 @@ require('securerandom')
 require_relative('ulid/version')
 require_relative('ulid/errors')
 require_relative('ulid/crockford_base32')
+require_relative('ulid/utils')
 require_relative('ulid/monotonic_generator')
 
 # @see https://github.com/ulid/spec
@@ -46,13 +46,36 @@ 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'
 
+  RANDOM_INTEGER_GENERATOR = -> {
+    SecureRandom.random_number(MAX_INTEGER)
+  }.freeze
+
+  Utils.make_sharable_constantans(self)
+
+  private_constant(
+    :PATTERN_WITH_CROCKFORD_BASE32_SUBSET,
+    :STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET,
+    :SCANNING_PATTERN,
+    :TIME_FORMAT_IN_INSPECT,
+    :RANDOM_INTEGER_GENERATOR
+  )
+
   private_class_method(:new)
 
   # @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)
+    base32_encoded = Utils.encode_base32(milliseconds: milliseconds, entropy: entropy)
+    new(
+      milliseconds: milliseconds,
+      entropy: entropy,
+      integer: base32_encoded.to_i(32),
+      encoded: CrockfordBase32.from_base32(base32_encoded).freeze
+    )
   end
 
   # Almost same as [.generate] except directly returning String without needless object creation
@@ -60,9 +83,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)
+    base32_encoded = Utils.encode_base32(milliseconds: Utils.milliseconds_from_moment(moment), entropy: entropy)
+    CrockfordBase32.from_base32(base32_encoded)
   end
 
   # Short hand of `ULID.generate(moment: time)`
@@ -71,7 +94,7 @@ 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
@@ -86,10 +109,6 @@ class ULID
     MAX_MILLISECONDS.equal?(moment) ? MAX : generate(moment: 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 +181,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)
+    base32encoded = integer.to_s(32).rjust(ENCODED_LENGTH, '0')
+    base32encoded_timestamp = base32encoded.slice(0, TIMESTAMP_ENCODED_LENGTH)
+    base32encoded_randomness = base32encoded.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH)
 
-    raise(UnexpectedError) unless n32encoded_timestamp && n32encoded_randomness
+    raise(UnexpectedError) unless base32encoded_timestamp && base32encoded_randomness
 
-    milliseconds = n32encoded_timestamp.to_i(32)
-    entropy = n32encoded_randomness.to_i(32)
+    milliseconds = base32encoded_timestamp.to_i(32)
+    entropy = base32encoded_randomness.to_i(32)
 
     new(
       milliseconds: milliseconds,
       entropy: entropy,
       integer: integer,
-      encoded: CrockfordBase32.from_n32(n32encoded).freeze
+      encoded: CrockfordBase32.from_base32(base32encoded).freeze
     )
   end
 
@@ -232,49 +251,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,6 +279,7 @@ 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')
@@ -375,74 +352,15 @@ 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
-  end
-
-  # @api private
-  # @param [Integer] milliseconds
-  # @param [Integer] entropy
-  # @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
-    )
-  end
-
   attr_reader(:milliseconds, :entropy)
 
-  # @api private
-  # @param [Integer] milliseconds
-  # @param [Integer] entropy
-  # @param [Integer] integer
-  # @param [String] encoded
-  # @return [void]
-  def initialize(milliseconds:, entropy:, integer:, encoded:)
-    # All arguments check should be done with each constructors, not here
-    @integer = integer
-    @encoded = encoded
-    @milliseconds = milliseconds
-    @entropy = entropy
-  end
-
   # @return [String]
   def encode
     @encoded
@@ -578,18 +496,21 @@ class ULID
     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.to_s
+    )
   end
 
   # @return [self]
@@ -611,17 +532,31 @@ class ULID
 
   private
 
+  # @param [Integer] milliseconds
+  # @param [Integer] entropy
+  # @param [Integer] integer
+  # @param [String] encoded
+  # @return [void]
+  def initialize(milliseconds:, entropy:, integer:, encoded:)
+    # All arguments check should be done with each constructors, not here
+    @integer = integer
+    @encoded = encoded
+    @milliseconds = milliseconds
+    @entropy = entropy
+  end
+
   # @return [void]
   def cache_all_instance_variables
     inspect
     timestamp
     randomness
   end
-end
 
-require_relative('ulid/ractor_unshareable_constants')
+  MIN = parse('00000000000000000000000000').freeze
+  MAX = parse('7ZZZZZZZZZZZZZZZZZZZZZZZZZ').freeze
 
-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)
+  Utils.make_sharable_value(MIN)
+  Utils.make_sharable_value(MAX)
+
+  private_constant(:MIN, :MAX)
 end

data/sig/ulid.rbs

@@ -19,8 +19,8 @@ class ULID < Object
   MAX: ULID
   include Comparable
 
-  # The `moment` is a `Time` or `Intger of the milliseconds`
-  type moment = Time | Integer
+  type milliseconds = Integer
+  type moment = Time | milliseconds
 
   class Error < StandardError
   end
@@ -34,27 +34,42 @@ class ULID < Object
   class UnexpectedError < Error
   end
 
-  module CrockfordBase32
-    class SetupError < UnexpectedError
-    end
+  # Private module
+  module Utils
+    def self.encode_base32: (milliseconds: milliseconds, entropy: Integer) -> String
+
+    def self.current_milliseconds: -> milliseconds
+
+    def self.milliseconds_from_moment: (moment moment) -> milliseconds
+
+    def self.reasonable_entropy: -> Integer
+
+    def self.milliseconds_from_time: (Time time) -> milliseconds
+
+    def self.safe_get_class_name: (untyped object) -> String
 
+    def self.make_sharable_value: (untyped object) -> void
+
+    def self.make_sharable_constantans: (Module) -> void
+
+    def self.ractor_can_make_shareable_time?: -> bool
+  end
+
+  # Private module
+  module CrockfordBase32
     ENCODING_STRING: String
     CROCKFORD_TR_PATTERN: String
     BASE32_TR_PATTERN: String
     VARIANT_TR_PATTERN: String
     NORMALIZED_TR_PATTERN: String
 
-    # A private API. Should not be used in your code.
     def self.encode: (Integer integer) -> String
 
-    # A private API. Should not be used in your code.
     def self.decode: (String string) -> Integer
 
-    # A private API. Should not be used in your code.
     def self.normalize: (String string) -> String
 
-    # A private API. Should not be used in your code.
-    def self.from_n32: (String n32encoded) -> String
+    def self.from_base32: (String base32encoded) -> String
   end
 
   class MonotonicGenerator
@@ -72,9 +87,6 @@ class ULID < Object
     # ```
     attr_reader prev: ULID | nil
 
-    # A private API. Should not be used in your code.
-    def initialize: -> void
-
     # See [How to keep `Sortable` even if in same timestamp](https://github.com/kachick/ruby-ulid#how-to-keep-sortable-even-if-in-same-timestamp)
     # The `Thread-safety` is implemented with [Monitor](https://bugs.ruby-lang.org/issues/16255)
     def generate: (?moment: moment) -> ULID
@@ -95,6 +107,12 @@ class ULID < Object
     def inspect: -> String
     alias to_s inspect
     def freeze: -> void
+
+    private
+
+    def initialize: -> void
+
+    def prev=: (ULID?) -> void
   end
 
   interface _ToULID
@@ -156,9 +174,6 @@ class ULID < Object
   #
   def self.encode: (?moment: moment, ?entropy: Integer) -> String
 
-  # A private API. Should not be used in your code.
-  def self.encode_n32: (milliseconds: Integer, entropy: Integer) -> String
-
   # Shorthand of `ULID.generate(moment: Time)`
   # See also [ULID.generate](https://kachick.github.io/ruby-ulid/ULID.html#generate-class_method)
   #
@@ -173,12 +188,6 @@ class ULID < Object
   # ```
   def self.at: (Time time) -> ULID
 
-  # A private API. Should not be used in your code.
-  def self.current_milliseconds: -> Integer
-
-  # A private API. Should not be used in your code.
-  def self.milliseconds_from_moment: (moment moment) -> Integer
-
   # `ULID` can be element of the `Range`. If you generated the IDs in monotonic generator, ID based filtering is easy and reliable
   #
   # ```ruby
@@ -440,7 +449,7 @@ class ULID < Object
   # ```
   def self.scan:  (_ToStr string) -> Enumerator[self, singleton(ULID)]
                 | (_ToStr string) { (ULID ulid) -> void } -> singleton(ULID)
-  def self.from_milliseconds_and_entropy: (milliseconds: Integer, entropy: Integer) -> ULID
+
   def self.try_convert: (_ToULID) -> ULID
                       | (untyped) -> nil
 
@@ -591,10 +600,8 @@ class ULID < Object
   def pred: -> ULID?
   def freeze: -> self
 
-  # A private API. Should not be used in your code.
   def marshal_dump: -> Integer
 
-  # A private API. Should not be used in your code.
   def marshal_load: (Integer integer) -> void
 
   # Returns `self`
@@ -609,18 +616,7 @@ class ULID < Object
 
   private
 
-  # A private API. Should not be used in your code.
-  def self.reasonable_entropy: -> Integer
-
-  # A private API. Should not be used in your code.
-  def self.milliseconds_from_time: (Time time) -> Integer
-
-  # A private API. Should not be used in your code.
-  def self.safe_get_class_name: (untyped object) -> String
-
-  # A private API. Should not be used in your code.
-  def initialize: (milliseconds: Integer, entropy: Integer, integer: Integer, encoded: String) -> void
+  def initialize: (milliseconds: milliseconds, entropy: Integer, integer: Integer, encoded: String) -> void
 
-  # A private API. Should not be used in your code.
   def cache_all_instance_variables: -> void
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-ulid
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Kenichi Kamiya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-18 00:00:00.000000000 Z
+date: 2022-08-05 00:00:00.000000000 Z
 dependencies: []
 description: "    generator, optional monotonicity, parser and tools for ULID (RBS
   included)\n"
@@ -25,7 +25,7 @@ files:
 - lib/ulid/crockford_base32.rb
 - lib/ulid/errors.rb
 - lib/ulid/monotonic_generator.rb
-- lib/ulid/ractor_unshareable_constants.rb
+- lib/ulid/utils.rb
 - lib/ulid/uuid.rb
 - lib/ulid/version.rb
 - sig/ulid.rbs

data/lib/ulid/ractor_unshareable_constants.rb

@@ -1,12 +0,0 @@
-# coding: us-ascii
-# frozen_string_literal: true
-
-class ULID
-  min = parse('00000000000000000000000000').freeze
-  max = parse('7ZZZZZZZZZZZZZZZZZZZZZZZZZ').freeze
-
-  ractor_can_make_shareable_time = RUBY_VERSION >= '3.1'
-
-  MIN = ractor_can_make_shareable_time ? Ractor.make_shareable(min) : min
-  MAX = ractor_can_make_shareable_time ? Ractor.make_shareable(max) : max
-end