ruby-ulid 0.1.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e67f6449c010a7c85ff8050a081b21e824ed876d7695a4fa22beb25f2a62534
-  data.tar.gz: f0b0607131f8b04dd57c587746cd992a9a01070cacb53857fca6efb7dd11fe45
+  metadata.gz: 358b03a503f8a12c87f3f7daaf3b0acf6e55dc44f1aba7a38b9f9a38985c2c68
+  data.tar.gz: 15d25d443f4826b07fc9a74b092e35b9cd60dc34cc3615f03fee619d4fc39445
 SHA512:
-  metadata.gz: 5c1e3540e8e4f75c92fbc8347d2898fe8f8f233830a878c67462f8f9c9f065c969a9df8dd93e11bd27baa7a5cb7c1cb1eaf2fdf1e7dba5f5833e6295cd9d083f
-  data.tar.gz: cd70d28d9cba7270ddf61dcf46bba1c4a04328d828ba7ed32a39c68c01f460b36f9f85da74fdb1d1b742309fdffb29d118cc8bc238c1744b61dbdc3a32255475
+  metadata.gz: 5b18d13597bd2f3dcd85a15a26d9086fb9a80b91775292c9da82d93144b6abd37585996f1bf64dfc4ac12b6d6d49683012dfea8e04624005358459667864114c
+  data.tar.gz: d987aa9b60717577fae96eef68fca76b2395f11a580df4863a69dd0931d955e4cf68608c101959db18f5e3a26031fbe284ff90a0d107fa84bbebb63949bba66b

data/README.md

@@ -1,17 +1,18 @@
 # 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)
+[![Gem Version](https://badge.fury.io/rb/ruby-ulid.svg)](http://badge.fury.io/rb/ruby-ulid)
+
 ## Overview
 
-The `ULID` spec is defined on [ulid/spec](https://github.com/ulid/spec). It has useful specs for applications (e.g. `Database key`), especially possess all `uniqueness`, `randomness`, `extractable timestamps` and `sortable` features.
-This gem aims to provide the generator, monotonic generator, parser and handy manipulation features around the ULID.
-Also providing [ruby/rbs](https://github.com/ruby/rbs) signature files.
+[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, monotonic generator, parser and handy manipulation features around ULID.  
+Also providing [ruby/rbs](https://github.com/ruby/rbs) signatures.
 
 ---
 
-![ULIDlogo](https://raw.githubusercontent.com/kachick/ruby-ulid/main/logo.png)
-
-![Build Status](https://github.com/kachick/ruby-ulid/actions/workflows/test_behaviors.yml/badge.svg?branch=main)
-[![Gem Version](https://badge.fury.io/rb/ruby-ulid.png)](http://badge.fury.io/rb/ruby-ulid)
+![ULIDlogo](./assets/logo.png)
 
 ## Universally Unique Lexicographically Sortable Identifier
 
@@ -37,7 +38,7 @@ Instead, herein is proposed ULID:
 
 ### Install
 
-Require Ruby 2.6 or later
+Require Ruby 2.7 or later
 
 This command will install the latest version into your environment
 
@@ -46,10 +47,10 @@ $ gem install ruby-ulid
 Should be installed!
 ```
 
-Add this line to your application/library's `Gemfile` is needed in basic use-case
+Add this line to your Gemfile`.
 
 ```ruby
-gem 'ruby-ulid', '>= 0.1.6', '< 0.2.0'
+gem('ruby-ulid', '~> 0.2.2')
 ```
 
 ### Generator and Parser
@@ -170,8 +171,7 @@ exclude_end = ULID.range(time1...time2) #=> The end of `Range[ULID]` will be the
 
 # Below patterns are acceptable
 pinpointing = ULID.range(time1..time1) #=> This will match only for all IDs in `time1`
-# until_the_end = ULID.range(..time1) #=> This will match only for all IDs upto `time1` (The `nil` starting `Range` can be used since Ruby 2.7)
-until_the_end = ULID.range(ULID.min.to_time..time1) #=> This is same as above for Ruby 2.6
+until_the_end = ULID.range(..time1) #=> This will match only for all IDs upto `time1`
 until_the_ulid_limit = ULID.range(time1..) # This will match only for all IDs from `time1` to max value of the ULID limit
 
 # So you can use the generated range objects as below
@@ -401,7 +401,7 @@ So you can replace the code as below
 +ULID.generate.to_s
 ```
 
-NOTE: It had crucial issue for handling precision, in version before `1.3.0`, when you extract timestamps from old generated ULIDs, it might be not accurate value.
+NOTE: In version before `1.3.0`, timestamps might not be correct value.
 
 1. [Sort order does not respect millisecond ordering](https://github.com/rafaelsales/ulid/issues/22)
 1. [Fixed in this PR](https://github.com/rafaelsales/ulid/pull/23)
@@ -425,11 +425,12 @@ Major methods can be replaced as below.
 +ULID.max(time).to_s
 ```
 
-NOTE: It is still having precision issue similar as `ulid gem` in the both generator and parser. I sent PRs.
+NOTE: In version before `1.0.2`, timestamps might not be correct value.
 
 1. [Parsed time object has more than milliseconds](https://github.com/abachman/ulid-ruby/issues/3)
 1. [Fix to handle timestamp precision in parser](https://github.com/abachman/ulid-ruby/pull/5)
 1. [Fix to handle timestamp precision in generator](https://github.com/abachman/ulid-ruby/pull/4)
+1. [Released in 1.0.2](https://github.com/abachman/ulid-ruby/compare/v1.0.0...v1.0.2)
 
 ### Compare performance with them
 
@@ -437,6 +438,18 @@ See [Benchmark](https://github.com/kachick/ruby-ulid/wiki/Benchmark).
 
 The results are not something to be proud of.
 
+## How to use rbs
+
+See structure 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).
+
+* ![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 ok-at-time](./assets/ulid-rbs-ok-at-time.png?raw=true.png)
+* ![rbs ng-at-int](./assets/ulid-rbs-ng-at-int.png?raw=true.png)
+
 ## References
 
 - [Repository](https://github.com/kachick/ruby-ulid)
@@ -445,4 +458,5 @@ The results are not something to be proud of.
 
 ## Note
 
-- Another choices for sortable and randomness IDs, [UUIDv6, UUIDv7, UUIDv8 might be the one. (But they are still in draft state)](https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-01.html), I will track them in [ruby-ulid#37](https://github.com/kachick/ruby-ulid/issues/37)
+- [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/ruby-ulid.rb

@@ -3,4 +3,4 @@
 
 # Copyright (C) 2021 Kenichi Kamiya
 
-require_relative 'ulid'
+require_relative('ulid')

data/lib/ulid/crockford_base32.rb

@@ -14,10 +14,10 @@ class ULID
   #   * https://github.com/kachick/ruby-ulid/issues/57
   #   * https://github.com/kachick/ruby-ulid/issues/78
   module CrockfordBase32
-    class SetupError < ScriptError; end
+    class SetupError < UnexpectedError; end
 
     n32_chars = [*'0'..'9', *'A'..'V'].map(&:freeze).freeze
-    raise SetupError, 'obvious bug exists in the mapping algorithm' unless n32_chars.size == 32
+    raise(SetupError, 'obvious bug exists in the mapping algorithm') unless n32_chars.size == 32
 
     n32_char_by_number = {}
     n32_chars.each_with_index do |char, index|
@@ -48,7 +48,7 @@ class ULID
         map[encoding_char] = char_32
       end
     end.freeze
-    raise SetupError, 'obvious bug exists in the mapping algorithm' unless N32_CHAR_BY_CROCKFORD_BASE32_CHAR.keys == crockford_base32_mappings.keys
+    raise(SetupError, 'obvious bug exists in the mapping algorithm') unless N32_CHAR_BY_CROCKFORD_BASE32_CHAR.keys == crockford_base32_mappings.keys
 
     CROCKFORD_BASE32_CHAR_PATTERN = /[#{N32_CHAR_BY_CROCKFORD_BASE32_CHAR.keys.join}]/.freeze
 

data/lib/ulid/monotonic_generator.rb

@@ -5,15 +5,16 @@
 
 class ULID
   class MonotonicGenerator
-    include MonitorMixin
+    include(MonitorMixin)
 
+    # @dynamic prev
     # @return [ULID, nil]
-    attr_reader :prev
+    attr_reader(:prev)
 
-    undef_method :instance_variable_set
+    undef_method(:instance_variable_set)
 
     def initialize
-      super()
+      super
       @prev = nil
     end
 
@@ -21,7 +22,8 @@ class ULID
     def inspect
       "ULID::MonotonicGenerator(prev: #{@prev.inspect})"
     end
-    alias_method :to_s, :inspect
+    # @dynamic to_s
+    alias_method(:to_s, :inspect)
 
     # @param [Time, Integer] moment
     # @return [ULID]
@@ -30,23 +32,25 @@ class ULID
     #   Basically will not happen. Just means this feature prefers error rather than invalid value.
     def generate(moment: ULID.current_milliseconds)
       synchronize do
-        unless @prev
-          @prev = ULID.generate(moment: moment)
-          return @prev
+        prev_ulid = @prev
+        unless prev_ulid
+          ret = ULID.generate(moment: moment)
+          @prev = ret
+          return ret
         end
 
         milliseconds = ULID.milliseconds_from_moment(moment)
 
         ulid = (
-          if @prev.milliseconds < milliseconds
+          if prev_ulid.milliseconds < milliseconds
             ULID.generate(moment: milliseconds)
           else
-            ULID.from_milliseconds_and_entropy(milliseconds: @prev.milliseconds, entropy: @prev.entropy.succ)
+            ULID.from_milliseconds_and_entropy(milliseconds: prev_ulid.milliseconds, entropy: prev_ulid.entropy.succ)
           end
         )
 
-        unless ulid > @prev
-          base_message = "monotonicity broken from unexpected reasons # generated: #{ulid.inspect}, prev: #{@prev.inspect}"
+        unless ulid > prev_ulid
+          base_message = "monotonicity broken from unexpected reasons # generated: #{ulid.inspect}, prev: #{prev_ulid.inspect}"
           additional_information = (
             if Thread.list == [Thread.main]
               '# NOTE: looks single thread only exist'
@@ -55,7 +59,7 @@ class ULID
             end
           )
 
-          raise UnexpectedError, base_message + additional_information
+          raise(UnexpectedError, base_message + additional_information)
         end
 
         @prev = ulid
@@ -63,12 +67,12 @@ class ULID
       end
     end
 
-    undef_method :freeze
+    undef_method(:freeze)
 
     # @raise [TypeError] always raises exception and does not freeze self
     # @return [void]
     def freeze
-      raise TypeError, "cannot freeze #{self.class}"
+      raise(TypeError, "cannot freeze #{self.class}")
     end
   end
 end

data/lib/ulid/uuid.rb

@@ -10,18 +10,18 @@
 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
+  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
+    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}`"
+      raise(ParserError, "given `#{uuid}` does not match to `#{UUIDV4_PATTERN.inspect}`")
     end
 
     normalized = prefix_trimmed.gsub(/[^0-9A-Fa-f]/, '')
@@ -32,8 +32,11 @@ class ULID
   def to_uuidv4
     # This code referenced https://github.com/ruby/ruby/blob/121fa24a3451b45c41ac0a661b64e9fc8600e589/lib/securerandom.rb#L221-L241
     array = octets.pack('C*').unpack('NnnnnN')
-    array[2] = (array[2] & 0x0fff) | 0x4000
-    array[3] = (array[3] & 0x3fff) | 0x8000
+    ref2, ref3 = array[2], array[3]
+    raise unless Integer === ref2 && Integer === ref3
+
+    array[2] = (ref2 & 0x0fff) | 0x4000
+    array[3] = (ref3 & 0x3fff) | 0x8000
     ('%08x-%04x-%04x-%04x-%04x%08x' % array).freeze
   end
 end

data/lib/ulid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 class ULID
-  VERSION = '0.1.6'
+  VERSION = '0.3.0'
 end

data/lib/ulid.rb

@@ -3,7 +3,7 @@
 
 # Copyright (C) 2021 Kenichi Kamiya
 
-require 'securerandom'
+require('securerandom')
 
 # @see https://github.com/ulid/spec
 # @!attribute [r] milliseconds
@@ -11,7 +11,7 @@ require 'securerandom'
 # @!attribute [r] entropy
 #   @return [Integer]
 class ULID
-  include Comparable
+  include(Comparable)
 
   class Error < StandardError; end
   class OverflowError < Error; end
@@ -25,10 +25,12 @@ class ULID
 
   TIMESTAMP_ENCODED_LENGTH = 10
   RANDOMNESS_ENCODED_LENGTH = 16
-  ENCODED_LENGTH = TIMESTAMP_ENCODED_LENGTH + RANDOMNESS_ENCODED_LENGTH
+  ENCODED_LENGTH = 26
+
   TIMESTAMP_OCTETS_LENGTH = 6
   RANDOMNESS_OCTETS_LENGTH = 10
-  OCTETS_LENGTH = TIMESTAMP_OCTETS_LENGTH + RANDOMNESS_OCTETS_LENGTH
+  OCTETS_LENGTH = 16
+
   MAX_MILLISECONDS = 281474976710655
   MAX_ENTROPY = 1208925819614629174706175
   MAX_INTEGER = 340282366920938463463374607431768211455
@@ -43,11 +45,13 @@ class ULID
   # This can't contain `\b` for considering UTF-8 (e.g. Japanese), so intentional `false negative` definition.
   SCANNING_PATTERN = /[0-7][#{CROCKFORD_BASE32_ENCODING_STRING}]{#{TIMESTAMP_ENCODED_LENGTH - 1}}[#{CROCKFORD_BASE32_ENCODING_STRING}]{#{RANDOMNESS_ENCODED_LENGTH}}/i.freeze
 
-  # Same as Time#inspect since Ruby 2.7, just to keep backward compatibility
+  # 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.
   # @see https://bugs.ruby-lang.org/issues/15958
+  # @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
+  private_class_method(:new)
 
   # @param [Integer, Time] moment
   # @param [Integer] entropy
@@ -60,7 +64,7 @@ class ULID
   # @param [Time] time
   # @return [ULID]
   def self.at(time)
-    raise ArgumentError, 'ULID.at takes only `Time` instance' unless Time === time
+    raise(ArgumentError, 'ULID.at takes only `Time` instance') unless Time === time
 
     from_milliseconds_and_entropy(milliseconds: milliseconds_from_time(time), entropy: reasonable_entropy)
   end
@@ -92,14 +96,14 @@ class ULID
   #   * Do not ensure the uniqueness
   #   * Do not take random generator for the arguments
   #   * Raising error instead of truncating elements for the given number
-  def self.sample(*args, period: nil)
+  def self.sample(number=nil, period: nil)
     int_generator = (
       if period
         ulid_range = range(period)
         min, max, exclude_end = ulid_range.begin.to_i, ulid_range.end.to_i, ulid_range.exclude_end?
 
         possibilities = (max - min) + (exclude_end ? 0 : 1)
-        raise ArgumentError, "given range `#{ulid_range.inspect}` does not have possibilities" unless possibilities.positive?
+        raise(ArgumentError, "given range `#{ulid_range.inspect}` does not have possibilities") unless possibilities.positive?
 
         -> {
           SecureRandom.random_number(possibilities) + min
@@ -109,24 +113,21 @@ class ULID
       end
     )
 
-    case args.size
-    when 0
+    case number
+    when nil
       from_integer(int_generator.call)
-    when 1
-      number = args.first
-      raise ArgumentError, 'accepts no argument or integer only' unless Integer === number
-
+    when Integer
       if number > MAX_INTEGER || number.negative?
-        raise ArgumentError, "given number `#{number}` is larger than ULID limit `#{MAX_INTEGER}` or negative"
+        raise(ArgumentError, "given number `#{number}` is larger than ULID limit `#{MAX_INTEGER}` or negative")
       end
 
-      if period && (number > possibilities)
-        raise ArgumentError, "given number `#{number}` is larger than given possibilities `#{possibilities}`"
+      if period && possibilities && (number > possibilities)
+        raise(ArgumentError, "given number `#{number}` is larger than given possibilities `#{possibilities}`")
       end
 
       Array.new(number) { from_integer(int_generator.call) }
     else
-      raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0..1)"
+      raise(ArgumentError, 'accepts no argument or integer only')
     end
   end
 
@@ -136,11 +137,13 @@ class ULID
   # @yieldreturn [self]
   def self.scan(string)
     string = String.try_convert(string)
-    raise ArgumentError, 'ULID.scan takes only strings' unless string
-    return to_enum(__callee__, string) unless block_given?
+    raise(ArgumentError, 'ULID.scan takes only strings') unless string
+    return to_enum(:scan, string) unless block_given?
 
     string.scan(SCANNING_PATTERN) do |matched|
-      yield parse(matched)
+      if String === matched
+        yield(parse(matched))
+      end
     end
     self
   end
@@ -150,14 +153,16 @@ class ULID
   # @raise [OverflowError] if the given integer is larger than the ULID limit
   # @raise [ArgumentError] if the given integer is negative number
   def self.from_integer(integer)
-    raise ArgumentError, 'ULID.from_integer takes only `Integer`' unless Integer === integer
-    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?
+    raise(ArgumentError, 'ULID.from_integer takes only `Integer`') unless Integer === integer
+    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)
 
+    raise(UnexpectedError) unless n32encoded_timestamp && n32encoded_randomness
+
     milliseconds = n32encoded_timestamp.to_i(32)
     entropy = n32encoded_randomness.to_i(32)
 
@@ -168,37 +173,43 @@ class ULID
   # @return [Range<ULID>]
   # @raise [ArgumentError] if the given period is not a `Range[Time]`, `Range[nil]` or `Range[ULID]`
   def self.range(period)
-    raise ArgumentError, 'ULID.range takes only `Range[Time]`, `Range[nil]` or `Range[ULID]`' unless Range === period
+    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?
-    return period if self === begin_element && self === end_element
-
-    case begin_element
-    when Time
-      begin_ulid = min(begin_element)
-    when nil
-      begin_ulid = MIN
-    when self
-      begin_ulid = begin_element
-    else
-      raise ArgumentError, "ULID.range takes only `Range[Time]`, `Range[nil]` or `Range[ULID]`, given: #{period.inspect}"
-    end
+    new_begin, new_end = false, false
+
+    begin_ulid = (
+      case begin_element
+      when Time
+        new_begin = true
+        min(begin_element)
+      when nil
+        MIN
+      when self
+        begin_element
+      else
+        raise(ArgumentError, "ULID.range takes only `Range[Time]`, `Range[nil]` or `Range[ULID]`, given: #{period.inspect}")
+      end
+    )
 
-    case end_element
-    when Time
-      end_ulid = exclude_end ? min(end_element) : max(end_element)
-    when nil
-      # The end should be max and include end, because nil end means to cover endless ULIDs until the limit
-      end_ulid = MAX
-      exclude_end = false
-    when self
-      end_ulid = end_element
-    else
-      raise ArgumentError, "ULID.range takes only `Range[Time]`, `Range[nil]` or `Range[ULID]`, given: #{period.inspect}"
-    end
+    end_ulid = (
+      case end_element
+      when Time
+        new_end = true
+        exclude_end ? min(end_element) : max(end_element)
+      when nil
+        exclude_end = false
+        # The end should be max and include end, because nil end means to cover endless ULIDs until the limit
+        MAX
+      when self
+        end_element
+      else
+        raise(ArgumentError, "ULID.range takes only `Range[Time]`, `Range[nil]` or `Range[ULID]`, given: #{period.inspect}")
+      end
+    )
 
-    begin_ulid.freeze
-    end_ulid.freeze
+    begin_ulid.freeze if new_begin
+    end_ulid.freeze if new_end
 
     Range.new(begin_ulid, end_ulid, exclude_end)
   end
@@ -206,13 +217,9 @@ class ULID
   # @param [Time] time
   # @return [Time]
   def self.floor(time)
-    raise ArgumentError, 'ULID.floor takes only `Time` instance' unless Time === time
+    raise(ArgumentError, 'ULID.floor takes only `Time` instance') unless Time === time
 
-    if RUBY_VERSION >= '2.7'
-      time.floor(3)
-    else
-      Time.at(0, milliseconds_from_time(time), :millisecond)
-    end
+    time.floor(3)
   end
 
   # @api private
@@ -224,9 +231,9 @@ class ULID
   # @api private
   # @param [Time] time
   # @return [Integer]
-  private_class_method def self.milliseconds_from_time(time)
+  private_class_method(def self.milliseconds_from_time(time)
     (time.to_r * 1000).to_i
-  end
+  end)
 
   # @api private
   # @param [Time, Integer] moment
@@ -238,24 +245,24 @@ class ULID
     when Time
       milliseconds_from_time(moment)
     else
-      raise ArgumentError, '`moment` should be a `Time` or `Integer as milliseconds`'
+      raise(ArgumentError, '`moment` should be a `Time` or `Integer as milliseconds`')
     end
   end
 
   # @return [Integer]
-  private_class_method def self.reasonable_entropy
+  private_class_method(def self.reasonable_entropy
     SecureRandom.random_number(MAX_ENTROPY)
-  end
+  end)
 
   # @param [String, #to_str] string
   # @return [ULID]
   # @raise [ParserError] if the given format is not correct for ULID specs
   def self.parse(string)
     string = String.try_convert(string)
-    raise ArgumentError, 'ULID.parse takes only strings' unless string
+    raise(ArgumentError, 'ULID.parse takes only strings') unless string
 
     unless STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET.match?(string)
-      raise ParserError, "given `#{string}` does not match to `#{STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET.inspect}`"
+      raise(ParserError, "given `#{string}` does not match to `#{STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET.inspect}`")
     end
 
     from_integer(CrockfordBase32.decode(string))
@@ -266,7 +273,7 @@ class ULID
   # @raise [ParserError] if the given format is not correct for ULID specs, even if ignored `orthographical variants of the format`
   def self.normalize(string)
     string = String.try_convert(string)
-    raise ArgumentError, 'ULID.normalize takes only strings' unless string
+    raise(ArgumentError, 'ULID.normalize takes only strings') unless string
 
     normalized_in_crockford = CrockfordBase32.normalize(string)
     # Ensure the ULID correctness, because CrockfordBase32 does not always mean to satisfy ULID format
@@ -302,14 +309,14 @@ class ULID
       else
         object_class_name = safe_get_class_name(object)
         converted_class_name = safe_get_class_name(converted)
-        raise TypeError, "can't convert #{object_class_name} to ULID (#{object_class_name}#to_ulid gives #{converted_class_name})"
+        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)
+  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!
@@ -318,8 +325,12 @@ class ULID
       begin
         object.class
       rescue NoMethodError
+        # steep can't correctly handle singeton 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
-        singleton_class.ancestors.detect { |ancestor| !ancestor.equal?(singleton_class) }
+        (Class === singleton_class) ? singleton_class.ancestors.detect { |ancestor| !ancestor.equal?(singleton_class) } : fallback
       end
     )
 
@@ -330,7 +341,7 @@ class ULID
     else
       name || fallback
     end
-  end
+  end)
 
   # @api private
   # @param [Integer] milliseconds
@@ -339,10 +350,10 @@ class 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:)
-    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?
+    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')
@@ -351,7 +362,8 @@ class ULID
     new(milliseconds: milliseconds, entropy: entropy, integer: integer)
   end
 
-  attr_reader :milliseconds, :entropy
+  # @dynamic milliseconds, entropy
+  attr_reader(:milliseconds, :entropy)
 
   # @api private
   # @param [Integer] milliseconds
@@ -374,7 +386,11 @@ class ULID
   def to_i
     @integer
   end
-  alias_method :hash, :to_i
+
+  # @return [Integer]
+  def hash
+    [ULID, @integer].hash
+  end
 
   # @return [Integer, nil]
   def <=>(other)
@@ -390,7 +406,8 @@ class ULID
   def eql?(other)
     equal?(other) || (ULID === other && @integer == other.to_i)
   end
-  alias_method :==, :eql?
+  # @dynamic ==
+  alias_method(:==, :eql?)
 
   # @return [Boolean]
   def ===(other)
@@ -406,13 +423,7 @@ class ULID
 
   # @return [Time]
   def to_time
-    @time ||= begin
-      if RUBY_VERSION >= '2.7'
-        Time.at(0, @milliseconds, :millisecond, in: 'UTC').freeze
-      else
-        Time.at(0, @milliseconds, :millisecond).utc.freeze
-      end
-    end
+    @time ||= Time.at(0, @milliseconds, :millisecond, in: 'UTC').freeze
   end
 
   # @return [Array(Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer)]
@@ -426,22 +437,22 @@ class ULID
 
   # @return [Array(Integer, Integer, Integer, Integer, Integer, Integer)]
   def timestamp_octets
-    octets.slice(0, TIMESTAMP_OCTETS_LENGTH)
+    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)
+    octets.slice(TIMESTAMP_OCTETS_LENGTH, RANDOMNESS_OCTETS_LENGTH) || raise(UnexpectedError)
   end
 
   # @return [String]
   def timestamp
-    @timestamp ||= to_s.slice(0, TIMESTAMP_ENCODED_LENGTH).freeze
+    @timestamp ||= (to_s.slice(0, TIMESTAMP_ENCODED_LENGTH).freeze || raise(UnexpectedError))
   end
 
   # @return [String]
   def randomness
-    @randomness ||= to_s.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH).freeze
+    @randomness ||= (to_s.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH).freeze || raise(UnexpectedError))
   end
 
   # @note Providing for rough operations. The keys and values is not fixed.
@@ -467,7 +478,8 @@ class ULID
       ULID.from_integer(succ_int)
     end
   end
-  alias_method :next, :succ
+  # @dynamic next
+  alias_method(:next, :succ)
 
   # @return [ULID, nil] when called on ULID as `00000000000000000000000000`, returns `nil` instead of ULID
   def pred
@@ -519,7 +531,7 @@ class ULID
     self
   end
 
-  undef_method :instance_variable_set
+  undef_method(:instance_variable_set)
 
   private
 
@@ -531,13 +543,13 @@ class ULID
   end
 end
 
-require_relative 'ulid/version'
-require_relative 'ulid/crockford_base32'
-require_relative 'ulid/monotonic_generator'
+require_relative('ulid/version')
+require_relative('ulid/crockford_base32')
+require_relative('ulid/monotonic_generator')
 
 class ULID
   MIN = parse('00000000000000000000000000').freeze
   MAX = parse('7ZZZZZZZZZZZZZZZZZZZZZZZZZ').freeze
 
-  private_constant :TIME_FORMAT_IN_INSPECT, :MIN, :MAX, :RANDOM_INTEGER_GENERATOR
+  private_constant(:TIME_FORMAT_IN_INSPECT, :MIN, :MAX, :RANDOM_INTEGER_GENERATOR, :CROCKFORD_BASE32_ENCODING_STRING)
 end

data/sig/ulid.rbs

@@ -36,7 +36,7 @@ class ULID < Object
   end
 
   module CrockfordBase32
-    class SetupError < ScriptError
+    class SetupError < UnexpectedError
     end
 
     N32_CHAR_BY_CROCKFORD_BASE32_CHAR: Hash[String, String]
@@ -97,9 +97,9 @@ class ULID < Object
     def to_ulid: () -> ULID
   end
 
-  type octets = [Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer]
-  type timestamp_octets = [Integer, Integer, Integer, Integer, Integer, Integer]
-  type randomness_octets = [Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer]
+  type full_octets = [Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer] | Array[Integer]
+  type timestamp_octets = [Integer, Integer, Integer, Integer, Integer, Integer] | Array[Integer]
+  type randomness_octets = [Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer] | Array[Integer]
   type period = Range[Time] | Range[nil] | Range[ULID]
 
   @string: String?
@@ -185,8 +185,7 @@ class ULID < Object
   #
   # # Below patterns are acceptable
   # pinpointing = ULID.range(time1..time1) #=> This will match only for all IDs in `time1`
-  # until_the_end = ULID.range(..time1) #=> This will match only for all IDs upto `time1` (The `nil` starting `Range` can be used since Ruby 2.7)
-  # until_the_end = ULID.range(ULID.min.to_time..time1) #=> This is same as above for Ruby 2.6
+  # until_the_end = ULID.range(..time1) #=> This will match only for all IDs upto `time1`
   # until_the_ulid_limit = ULID.range(time1..) # This will match only for all IDs from `time1` to max value of the ULID limit
   #
   # # So you can use the generated range objects as below
@@ -319,7 +318,7 @@ class ULID < Object
   # #  ULID(2021-04-28 15:05:06.808 UTC: 01F4CG68ZRST94T056KRZ5K9S4)]
   # ```
   def self.sample: (?period: period) -> ULID
-                 | (Integer number, ?period: period) -> Array[ULID]
+                 | (Integer number, ?period: period?) -> Array[ULID]
   def self.valid?: (untyped) -> bool
 
   # Returns normalized string
@@ -410,7 +409,9 @@ class ULID < Object
   # ulid.to_i #=> 1957909092946624190749577070267409738
   # ```
   def to_i: -> Integer
-  alias hash to_i
+
+  # Returns integer for making as a hash key use-case
+  def hash: -> Integer
 
   # Basically same as String based sort.
   #
@@ -463,7 +464,7 @@ class ULID < Object
   # Intentionally avoiding to use `Record type` ref: https://github.com/ruby/rbs/blob/4fb4c33b2325d1a73d79ff7aaeb49f21cec1e0e5/docs/syntax.md#record-type
   # Because the returning values are not fixed.
   def patterns: -> Hash[Symbol, Regexp | String]
-  def octets: -> octets
+  def octets: -> full_octets
   def timestamp_octets: -> timestamp_octets
   def randomness_octets: -> randomness_octets
 
@@ -526,7 +527,7 @@ class ULID < Object
   private
 
   # A private API. Should not be used in your code.
-  def self.new: (milliseconds: Integer, entropy: Integer, integer: Integer) -> self
+  def self.new: (milliseconds: Integer, entropy: Integer, integer: Integer) -> ULID
 
   # A private API. Should not be used in your code.
   def self.reasonable_entropy: -> Integer

metadata

@@ -1,19 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: ruby-ulid
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Kenichi Kamiya
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-05 00:00:00.000000000 Z
+date: 2022-06-22 00:00:00.000000000 Z
 dependencies: []
-description: |2
-      The ULID(Universally Unique Lexicographically Sortable Identifier) has useful specs for applications (e.g. `Database key`), especially possess all `uniqueness`, `randomness`, `extractable timestamps` and `sortable` features.
-      This gem aims to provide the generator, monotonic generator, parser and handy manipulation features around the ULID.
-      Also providing `ruby/rbs` signature files.
+description: "    generator, monotonic generator, parser and manipulations for ULID
+  (ruby/rbs signatures included)\n"
 email:
 - kachick1+ruby@gmail.com
 executables: []
@@ -37,7 +35,8 @@ metadata:
   homepage_uri: https://github.com/kachick/ruby-ulid
   source_code_uri: https://github.com/kachick/ruby-ulid
   bug_tracker_uri: https://github.com/kachick/ruby-ulid/issues
-post_install_message:
+  rubygems_mfa_required: 'true'
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -45,15 +44,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key:
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: ULID manipulation library
 test_files: []