ruby-ulid 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b50cb3fee0b304a62ebd460e7d08b932d3c58c1f7810a1dc24b5166df10ceaf
-  data.tar.gz: b84a2ad766640fa7c87e4bbb5b0fdd637bf831407f235989cdd043ea5b1189aa
+  metadata.gz: 5c7cf89034d0f74026278e2a4c113d57f8fc28b861b8bcf1d2210dbb76688e52
+  data.tar.gz: 340bfbea8fb1ff3ec0e49339e2a5a388a81552f8cd73a65ad9ff049448fc0c3f
 SHA512:
-  metadata.gz: e44eadac5ad4c83f1c8da74fbfa502a3b3b7293dda8eb44855bb477070687afd815d46237a9cc15266223f7cd0981b69670165767b366156d23728cdb76c878e
-  data.tar.gz: 349b2e8c2b16d5c9ae58270fdb5e87a3c364eef4b3ae2972680cb5de119ba737ed035db36bb7283fc96ff7c7a54663be5de8c0725e0de1975d8f66de34dd052c
+  metadata.gz: 74d26cb5dc49a8d79a5c933817c1c8913954d675d996a91057f29859fd1fdf0a32c99d8121ef954e1d7d400110fa1737be17a9084bfc03655082de96c9614392
+  data.tar.gz: 96f19838c4c90ee313722857f88693e88f247e5380293291b362eadc834f6adb1613c01034a0cfe430f24576b4fea55f252b79f689b00c3e05b739118db8906e

data/README.md

@@ -7,8 +7,7 @@
 
 [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 [RBS](https://github.com/ruby/rbs) signatures.
+This gem aims to provide the generator, optional monotonicity, parser and other manipulation features around ULID with included [RBS](https://github.com/ruby/rbs).
 
 ---
 
@@ -50,7 +49,7 @@ Should be installed!
 Add this line in your Gemfile.
 
 ```ruby
-gem('ruby-ulid', '~> 0.4.0')
+gem('ruby-ulid', '~> 0.6.1')
 ```
 
 ### How to use
@@ -58,34 +57,32 @@ gem('ruby-ulid', '~> 0.4.0')
 ```ruby
 require 'ulid'
 
-defined? ULID
-# => "constant"
+ULID::VERSION
+# => "0.6.1"
 ```
 
-### Basic Generator
+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).
 
-The generated `ULID` is an object not just a string.
+### Generator and Parser
+
+`ULID.generate` returns `ULID` instance. It is not just a string.
 
 ```ruby
 ulid = ULID.generate #=> ULID(2021-04-27 17:27:22.826 UTC: 01F4A5Y1YAQCYAYCTC7GRMJ9AA)
 ```
 
-### Parser
-
-You can get the objects from exists encoded ULIDs.
+`ULID.parse` returns `ULID` instance from exists encoded ULIDs.
 
 ```ruby
-ulid = ULID.parse('01ARZ3NDEKTSV4RRFFQ69G5FAV') #=> ULID(2016-07-30 23:54:10.259 UTC: 01ARZ3NDEKTSV4RRFFQ69G5FAV)
+ulid = ULID.parse('01F4A5Y1YAQCYAYCTC7GRMJ9AA') #=> ULID(2021-04-27 17:27:22.826 UTC: 01F4A5Y1YAQCYAYCTC7GRMJ9AA)
 ```
 
-### ULID object
-
-You can extract timestamps and binary formats.
+It is helpful to inspect.
 
 ```ruby
-ulid = ULID.parse('01F4A5Y1YAQCYAYCTC7GRMJ9AA') #=> ULID(2021-04-27 17:27:22.826 UTC: 01F4A5Y1YAQCYAYCTC7GRMJ9AA)
 ulid.to_time #=> 2021-04-27 17:27:22.826 UTC
 ulid.milliseconds #=> 1619544442826
+ulid.encode #=> "01F4A5Y1YAQCYAYCTC7GRMJ9AA"
 ulid.to_s #=> "01F4A5Y1YAQCYAYCTC7GRMJ9AA"
 ulid.timestamp #=> "01F4A5Y1YA"
 ulid.randomness #=> "QCYAYCTC7GRMJ9AA"
@@ -93,6 +90,42 @@ ulid.to_i #=> 1957909092946624190749577070267409738
 ulid.octets #=> [1, 121, 20, 95, 7, 202, 187, 60, 175, 51, 76, 60, 49, 73, 37, 74]
 ```
 
+`ULID.generate` can take fixed `Time` instance. `ULID.at` is the shorthand.
+
+```ruby
+time = Time.at(946684800).utc #=> 2000-01-01 00:00:00 UTC
+ULID.generate(moment: time) #=> ULID(2000-01-01 00:00:00.000 UTC: 00VHNCZB00N018DCPJA4H9379P)
+ULID.generate(moment: time) #=> ULID(2000-01-01 00:00:00.000 UTC: 00VHNCZB006WQT3JTMN0T14EBP)
+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.  
+
+`ULID.encode` returns [normalized](#variants-of-format) String without ULID object creation.  
+It can take same arguments as `ULID.generate`.
+
+```ruby
+ULID.encode #=> "01G86M42Q6SJ9XQM2ZRM6JRDSF"
+ULID.encode(moment: Time.at(946684800).utc) #=> "00VHNCZB00SYG7RCEXZC9DA4E1"
+```
+
+`ULID.decode_time` returns Time. It can take `in` keyarg as same as `Time.at`.
+
+```ruby
+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:
+
+Snapshot on 0.6.1 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)
+
+You can see further detail at [Benchmark](https://github.com/kachick/ruby-ulid/wiki/Benchmark).
+
 ### Sortable with the timestamp
 
 ULIDs are sortable when they are generated in different timestamp with milliseconds precision.
@@ -106,21 +139,7 @@ ulids.uniq(&:to_time).size #=> 1000
 ulids.sort == ulids #=> true
 ```
 
-`ULID.generate` can take fixed `Time` instance. The shorthand is `ULID.at`.
-
-```ruby
-time = Time.at(946684800).utc #=> 2000-01-01 00:00:00 UTC
-ULID.generate(moment: time) #=> ULID(2000-01-01 00:00:00.000 UTC: 00VHNCZB00N018DCPJA4H9379P)
-ULID.generate(moment: time) #=> ULID(2000-01-01 00:00:00.000 UTC: 00VHNCZB006WQT3JTMN0T14EBP)
-ULID.at(time) #=> ULID(2000-01-01 00:00:00.000 UTC: 00VHNCZB002W5BGWWKN76N22H6)
-
-ulids = 1000.times.map do |n|
-  ULID.at(time + n)
-end
-ulids.sort == ulids #=> true
-```
-
-The basic generator prefers `randomness`, it does not guarantee `sortable` for same milliseconds ULIDs.
+Basic generator prefers `randomness`, it does not guarantee `sortable` for same milliseconds ULIDs.
 
 ```ruby
 ulids = 10000.times.map do
@@ -162,7 +181,7 @@ sample_ulids_by_the_time.take(5) #=>
 ulids.sort == ulids #=> true
 ```
 
-Same generator does not generate duplicated ULIDs even in multi threads environment. It is implemented with [Monitor](https://bugs.ruby-lang.org/issues/16255).
+Same instance of `ULID::MonotonicGenerator` does not generate duplicated ULIDs even in multi threads environment. It is implemented with [Monitor](https://bugs.ruby-lang.org/issues/16255).
 
 ### Filtering IDs with `Time`
 
@@ -202,7 +221,7 @@ time = Time.at(946684800, Rational('123456.789')).utc #=> 2000-01-01 00:00:00.12
 ULID.floor(time) #=> 2000-01-01 00:00:00.123 UTC
 ```
 
-### Some methods to help manipulations
+### Tools
 
 #### Scanner for string (e.g. `JSON`)
 
@@ -278,7 +297,7 @@ ULID.max(time) #=> ULID(2000-01-01 00:00:00.123 UTC: 00VHNCZB3VZZZZZZZZZZZZZZZZ)
 `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. Iincrementing 128 bits IDs are not reasonable operation in most cases.
+NOTE: However basically `Range[ULID]#each` should not be used. Incrementing 128 bits IDs are not reasonable operation in most cases.
 
 ```ruby
 ULID.parse('01BX5ZZKBKZZZZZZZZZZZZZZZY').next.to_s #=> "01BX5ZZKBKZZZZZZZZZZZZZZZZ"
@@ -341,31 +360,32 @@ 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
+
+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)
 
 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.
 
-Current parser/validator/matcher aims to cover `subset of Crockford's base32`.
-I have suggested it would be clarified in [ulid/spec#57](https://github.com/ulid/spec/pull/57).
+I have suggested to clarify `subset of Crockford's base32` in [ulid/spec#57](https://github.com/ulid/spec/pull/57).
 
->Case insensitive
+This gem provides some methods to handle the nasty possibilities.
 
-I can understand it might be considered in actual use-case.
-But it is a controversial point, discussing in [ulid/spec#3](https://github.com/ulid/spec/issues/3).
-
-Be that as it may, this gem provides API for handling the nasty possibilities.
-
-`ULID.normalize` and `ULID.normalized?`
+`ULID.normalize`, `ULID.normalized?`, `ULID.valid_as_variant_format?` and `ULID.parse_variant_format`
 
 ```ruby
-ULID.normalize('-olarz3-noekisv4rrff-q6ig5fav--') #=> "01ARZ3N0EK1SV4RRFFQ61G5FAV"
-ULID.normalized?('-olarz3-noekisv4rrff-q6ig5fav--') #=> false
-ULID.normalized?('01ARZ3N0EK1SV4RRFFQ61G5FAV') #=> true
+ULID.normalize('01g70y0y7g-z1xwdarexergsddd') #=> "01G70Y0Y7GZ1XWDAREXERGSDDD"
+ULID.normalized?('01g70y0y7g-z1xwdarexergsddd') #=> false
+ULID.normalized?('01G70Y0Y7GZ1XWDAREXERGSDDD') #=> true
+ULID.valid_as_variant_format?('01g70y0y7g-z1xwdarexergsddd') #=> true
+ULID.parse_variant_format('01G70Y0Y7G-ZLXWDIREXERGSDoD') #=> ULID(2022-07-03 02:25:22.672 UTC: 01G70Y0Y7GZ1XWD1REXERGSD0D)
 ```
 
-#### UUIDv4 converter for migration use-cases
+#### UUIDv4 converter (experimental)
 
 `ULID.from_uuidv4` and `ULID#to_uuidv4` is the converter.
 The imported timestamp is meaningless. So ULID's benefit will lost.
@@ -398,68 +418,19 @@ ULID.min == reversed_min #=> false
 ULID.max == reversed_max #=> false
 ```
 
-## How to migrate from other gems
-
-As far as I know, major prior arts are below
-
-### [ulid gem](https://rubygems.org/gems/ulid) - [rafaelsales/ulid](https://github.com/rafaelsales/ulid)
-
-It is just providing basic `String` generator only.
-So you can replace the code as below
-
-```diff
--ULID.generate
-+ULID.generate.to_s
-```
-
-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)
-1. [Released in 1.3.0](https://github.com/rafaelsales/ulid/compare/1.2.0...v1.3.0)
-
-### [ulid-ruby gem](https://rubygems.org/gems/ulid-ruby) - [abachman/ulid-ruby](https://github.com/abachman/ulid-ruby)
-
-It is providing basic generator(except monotonic generator) and parser.
-Major methods can be replaced as below.
-
-```diff
--ULID.generate
-+ULID.generate.to_s
--ULID.at(time)
-+ULID.at(time).to_s
--ULID.time(string)
-+ULID.parse(string).to_time
--ULID.min_ulid_at(time)
-+ULID.min(time).to_s
--ULID.max_ulid_at(time)
-+ULID.max(time).to_s
-```
-
-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
-
-See [Benchmark](https://github.com/kachick/ruby-ulid/wiki/Benchmark).
+## Migration from other gems
 
-The results are not something to be proud of.
+See [wiki page for gem migration](https://github.com/kachick/ruby-ulid/wiki/Gem-migration).
 
-## How to use rbs
+## RBS
 
-See structure at [examples/rbs_sandbox](https://github.com/kachick/ruby-ulid/tree/main/examples/rbs_sandbox)
+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).
 
 * ![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
 

data/lib/ulid/crockford_base32.rb

@@ -15,63 +15,66 @@ class ULID
   #   * https://github.com/kachick/ruby-ulid/issues/57
   #   * https://github.com/kachick/ruby-ulid/issues/78
   module CrockfordBase32
-    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
-
-    n32_char_by_number = {}
-    n32_chars.each_with_index do |char, index|
-      n32_char_by_number[index] = char
-    end
-    n32_char_by_number.freeze
-
-    crockford_base32_mappings = {
-      'J' => 18,
-      'K' => 19,
-      'M' => 20,
-      'N' => 21,
-      'P' => 22,
-      'Q' => 23,
-      'R' => 24,
-      'S' => 25,
-      'T' => 26,
-      'V' => 27,
-      'W' => 28,
-      'X' => 29,
-      'Y' => 30,
-      'Z' => 31
+    same_definitions = {
+      '0' => '0',
+      '1' => '1',
+      '2' => '2',
+      '3' => '3',
+      '4' => '4',
+      '5' => '5',
+      '6' => '6',
+      '7' => '7',
+      '8' => '8',
+      '9' => '9',
+      'A' => 'A',
+      'B' => 'B',
+      'C' => 'C',
+      'D' => 'D',
+      'E' => 'E',
+      'F' => 'F',
+      'G' => 'G',
+      'H' => 'H'
     }.freeze
 
-    N32_CHAR_BY_CROCKFORD_BASE32_CHAR = CROCKFORD_BASE32_ENCODING_STRING.chars.map(&:freeze).each_with_object({}) do |encoding_char, map|
-      if n = crockford_base32_mappings[encoding_char]
-        char_32 = n32_char_by_number.fetch(n)
-        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
-
-    CROCKFORD_BASE32_CHAR_PATTERN = /[#{N32_CHAR_BY_CROCKFORD_BASE32_CHAR.keys.join}]/.freeze
-
-    CROCKFORD_BASE32_CHAR_BY_N32_CHAR = N32_CHAR_BY_CROCKFORD_BASE32_CHAR.invert.freeze
-    N32_CHAR_PATTERN = /[#{CROCKFORD_BASE32_CHAR_BY_N32_CHAR.keys.join}]/.freeze
+    # Excluded I, L, O, U, - from Base32
+    base32_to_crockford = {
+      'I' => 'J',
+      'J' => 'K',
+      'K' => 'M',
+      'L' => 'N',
+      'M' => 'P',
+      'N' => 'Q',
+      'O' => 'R',
+      'P' => 'S',
+      'Q' => 'T',
+      'R' => 'V',
+      'S' => 'W',
+      'T' => 'X',
+      'U' => 'Y',
+      'V' => 'Z'
+    }.freeze
+    BASE32_TR_PATTERN = base32_to_crockford.keys.join.freeze
+    CROCKFORD_TR_PATTERN = base32_to_crockford.values.join.freeze
+    ENCODING_STRING = "#{same_definitions.values.join}#{CROCKFORD_TR_PATTERN}".freeze
 
-    STANDARD_BY_VARIANT = {
+    variant_to_normarized = {
       'L' => '1',
       'l' => '1',
       'I' => '1',
       'i' => '1',
       'O' => '0',
-      'o' => '0',
-      '-' => ''
+      'o' => '0'
     }.freeze
-    VARIANT_PATTERN = /[#{STANDARD_BY_VARIANT.keys.join}]/.freeze
+    VARIANT_TR_PATTERN = variant_to_normarized.keys.join.freeze
+    NORMALIZED_TR_PATTERN = variant_to_normarized.values.join.freeze
+
+    # @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.gsub(CROCKFORD_BASE32_CHAR_PATTERN, N32_CHAR_BY_CROCKFORD_BASE32_CHAR)
+      n32encoded = string.upcase.tr(CROCKFORD_TR_PATTERN, BASE32_TR_PATTERN)
       n32encoded.to_i(32)
     end
 
@@ -80,14 +83,21 @@ class ULID
     # @return [String]
     def self.encode(integer)
       n32encoded = integer.to_s(32)
-      n32encoded.upcase.gsub(N32_CHAR_PATTERN, CROCKFORD_BASE32_CHAR_BY_N32_CHAR).rjust(ENCODED_LENGTH, '0')
+      from_n32(n32encoded).rjust(ENCODED_LENGTH, '0')
     end
 
     # @api private
     # @param [String] string
     # @return [String]
     def self.normalize(string)
-      string.gsub(VARIANT_PATTERN, STANDARD_BY_VARIANT)
+      string.delete('-').tr(VARIANT_TR_PATTERN, NORMALIZED_TR_PATTERN)
+    end
+
+    # @api private
+    # @param [String] n32encoded
+    # @return [String]
+    def self.from_n32(n32encoded)
+      n32encoded.upcase.tr(BASE32_TR_PATTERN, CROCKFORD_TR_PATTERN)
     end
   end
 end

data/lib/ulid/errors.rb

@@ -0,0 +1,10 @@
+# coding: us-ascii
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+class ULID
+  class Error < StandardError; end
+  class OverflowError < Error; end
+  class ParserError < Error; end
+  class UnexpectedError < Error; end
+end

data/lib/ulid/monotonic_generator.rb

@@ -10,7 +10,6 @@ class ULID
     #       However it is a C extention, I'm pending to use it for now.
     include(MonitorMixin)
 
-    # @dynamic prev
     # @return [ULID, nil]
     attr_reader(:prev)
 
@@ -25,7 +24,6 @@ class ULID
     def inspect
       "ULID::MonotonicGenerator(prev: #{@prev.inspect})"
     end
-    # @dynamic to_s
     alias_method(:to_s, :inspect)
 
     # @param [Time, Integer] moment
@@ -70,6 +68,12 @@ class ULID
       end
     end
 
+    # @param [Time, Integer] moment
+    # @return [String]
+    def encode(moment: ULID.current_milliseconds)
+      generate(moment: moment).encode
+    end
+
     undef_method(:freeze)
 
     # @raise [TypeError] always raises exception and does not freeze self

data/lib/ulid/version.rb

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

data/lib/ulid.rb

@@ -6,6 +6,11 @@
 
 require('securerandom')
 
+require_relative('ulid/version')
+require_relative('ulid/errors')
+require_relative('ulid/crockford_base32')
+require_relative('ulid/monotonic_generator')
+
 # @see https://github.com/ulid/spec
 # @!attribute [r] milliseconds
 #   @return [Integer]
@@ -14,16 +19,6 @@ require('securerandom')
 class ULID
   include(Comparable)
 
-  class Error < StandardError; end
-  class OverflowError < Error; end
-  class ParserError < Error; end
-  class UnexpectedError < Error; end
-
-  # Excluded I, L, O, U, -.
-  # This is the encoding patterns.
-  # The decoding issue is written in ULID::CrockfordBase32
-  CROCKFORD_BASE32_ENCODING_STRING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'
-
   TIMESTAMP_ENCODED_LENGTH = 10
   RANDOMNESS_ENCODED_LENGTH = 16
   ENCODED_LENGTH = 26
@@ -38,12 +33,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][#{CROCKFORD_BASE32_ENCODING_STRING}]{#{TIMESTAMP_ENCODED_LENGTH - 1}})(?<randomness>[#{CROCKFORD_BASE32_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.freeze
 
   STRICT_PATTERN_WITH_CROCKFORD_BASE32_SUBSET = /\A#{PATTERN_WITH_CROCKFORD_BASE32_SUBSET.source}\z/i.freeze
 
   # Optimized for `ULID.scan`, might be changed the definition with gathered `ULID.scan` spec changed.
-  SCANNING_PATTERN = /\b[0-7][#{CROCKFORD_BASE32_ENCODING_STRING}]{#{TIMESTAMP_ENCODED_LENGTH - 1}}[#{CROCKFORD_BASE32_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.freeze
 
   # 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.
@@ -60,6 +55,16 @@ class ULID
     from_milliseconds_and_entropy(milliseconds: milliseconds_from_moment(moment), entropy: entropy)
   end
 
+  # Almost same as [.generate] except directly returning String without needless object creation
+  #
+  # @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)
+  end
+
   # Short hand of `ULID.generate(moment: time)`
   # @param [Time] time
   # @return [ULID]
@@ -166,7 +171,12 @@ class ULID
     milliseconds = n32encoded_timestamp.to_i(32)
     entropy = n32encoded_randomness.to_i(32)
 
-    new(milliseconds: milliseconds, entropy: entropy, integer: integer)
+    new(
+      milliseconds: milliseconds,
+      entropy: entropy,
+      integer: integer,
+      encoded: CrockfordBase32.from_n32(n32encoded).freeze
+    )
   end
 
   # @param [Range<Time>, Range<nil>, Range[ULID]] period
@@ -254,6 +264,17 @@ class ULID
     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
@@ -268,6 +289,36 @@ class ULID
     from_integer(CrockfordBase32.decode(string))
   end
 
+  # @param [String, #to_str] string
+  # @return [ULID]
+  # @raise [ParserError] if the given format is not correct for ULID specs
+  def self.parse_variant_format(string)
+    string = String.try_convert(string)
+    raise(ArgumentError, 'ULID.parse_variant_format takes only strings') unless string
+
+    normalized_in_crockford = CrockfordBase32.normalize(string)
+    parse(normalized_in_crockford)
+  end
+
+  # Almost same as `ULID.parse(string).to_time` except directly returning Time instance without needless object creation
+  #
+  # @param [String, #to_str] string
+  # @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.
+    string = String.try_convert(string)
+    raise(ArgumentError, 'ULID.decode_time 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}`")
+    end
+
+    timestamp = string.slice(0, TIMESTAMP_ENCODED_LENGTH).freeze || raise(UnexpectedError)
+
+    Time.at(0, CrockfordBase32.decode(timestamp), :millisecond, in: in_for_time_at)
+  end
+
   # @param [String, #to_str] string
   # @return [String]
   # @raise [ParserError] if the given format is not correct for ULID specs, even if ignored `orthographical variants of the format`
@@ -275,23 +326,40 @@ class ULID
     string = String.try_convert(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
-    parse(normalized_in_crockford).to_s
+    parse_variant_format(string).to_s
+  end
+
+  # @param [String, #to_str] string
+  # @return [Boolean]
+  def self.normalized?(string)
+    normalized = normalize(string)
+  rescue Exception
+    false
+  else
+    normalized == string
   end
 
+  # @param [String, #to_str] string
   # @return [Boolean]
-  def self.normalized?(object)
-    normalized = normalize(object)
+  def self.valid_as_variant_format?(string)
+    parse_variant_format(string)
   rescue Exception
     false
   else
-    normalized == object
+    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?(object)
-    string = String.try_convert(object)
+  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
 
@@ -350,37 +418,36 @@ 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?
-
-    n32encoded_timestamp = milliseconds.to_s(32).rjust(TIMESTAMP_ENCODED_LENGTH, '0')
-    n32encoded_randomness = entropy.to_s(32).rjust(RANDOMNESS_ENCODED_LENGTH, '0')
-    integer = (n32encoded_timestamp + n32encoded_randomness).to_i(32)
-
-    new(milliseconds: milliseconds, entropy: entropy, integer: integer)
+    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
 
-  # @dynamic milliseconds, entropy
   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:)
+  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 to_s
-    @string ||= CrockfordBase32.encode(@integer).freeze
+  def encode
+    @encoded
   end
+  alias_method(:to_s, :encode)
 
   # @return [Integer]
   def to_i
@@ -392,21 +459,20 @@ class ULID
     [ULID, @integer].hash
   end
 
-  # @return [Integer, nil]
+  # @return [-1, 0, 1, nil]
   def <=>(other)
     (ULID === other) ? (@integer <=> other.to_i) : nil
   end
 
   # @return [String]
   def inspect
-    @inspect ||= "ULID(#{to_time.strftime(TIME_FORMAT_IN_INSPECT)}: #{to_s})".freeze
+    @inspect ||= "ULID(#{to_time.strftime(TIME_FORMAT_IN_INSPECT)}: #{@encoded})".freeze
   end
 
   # @return [Boolean]
   def eql?(other)
     equal?(other) || (ULID === other && @integer == other.to_i)
   end
-  # @dynamic ==
   alias_method(:==, :eql?)
 
   # Return `true` for same value of ULID, variant formats of strings, same Time in ULID precision(msec).
@@ -421,11 +487,9 @@ class ULID
       @integer == other.to_i
     when String
       begin
-        normalized = ULID.normalize(other)
+        to_i == ULID.parse_variant_format(other).to_i
       rescue Exception
         false
-      else
-        to_s == normalized
       end
     when Time
       to_time == ULID.floor(other)
@@ -460,12 +524,12 @@ class ULID
 
   # @return [String]
   def timestamp
-    @timestamp ||= (to_s.slice(0, TIMESTAMP_ENCODED_LENGTH).freeze || raise(UnexpectedError))
+    @timestamp ||= (@encoded.slice(0, TIMESTAMP_ENCODED_LENGTH).freeze || raise(UnexpectedError))
   end
 
   # @return [String]
   def randomness
-    @randomness ||= (to_s.slice(TIMESTAMP_ENCODED_LENGTH, RANDOMNESS_ENCODED_LENGTH).freeze || raise(UnexpectedError))
+    @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.
@@ -491,7 +555,6 @@ class ULID
       ULID.from_integer(succ_int)
     end
   end
-  # @dynamic next
   alias_method(:next, :succ)
 
   # @return [ULID, nil] when called on ULID as `00000000000000000000000000`, returns `nil` instead of ULID
@@ -526,7 +589,7 @@ class ULID
   # @return [void]
   def marshal_load(integer)
     unmarshaled = ULID.from_integer(integer)
-    initialize(integer: unmarshaled.to_i, milliseconds: unmarshaled.milliseconds, entropy: unmarshaled.entropy)
+    initialize(integer: unmarshaled.to_i, milliseconds: unmarshaled.milliseconds, entropy: unmarshaled.entropy, encoded: unmarshaled.to_s)
   end
 
   # @return [self]
@@ -556,12 +619,9 @@ class ULID
   end
 end
 
-require_relative('ulid/version')
-require_relative('ulid/crockford_base32')
-require_relative('ulid/monotonic_generator')
 require_relative('ulid/ractor_unshareable_constants')
 
 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, :CROCKFORD_BASE32_ENCODING_STRING)
+  private_constant(:TIME_FORMAT_IN_INSPECT, :MIN, :MAX, :RANDOM_INTEGER_GENERATOR)
 end

data/sig/ulid.rbs

@@ -1,6 +1,5 @@
 class ULID < Object
   VERSION: String
-  CROCKFORD_BASE32_ENCODING_STRING: String
   TIMESTAMP_ENCODED_LENGTH: 10
   RANDOMNESS_ENCODED_LENGTH: 16
   ENCODED_LENGTH: 26
@@ -39,12 +38,11 @@ class ULID < Object
     class SetupError < UnexpectedError
     end
 
-    N32_CHAR_BY_CROCKFORD_BASE32_CHAR: Hash[String, String]
-    CROCKFORD_BASE32_CHAR_PATTERN: Regexp
-    CROCKFORD_BASE32_CHAR_BY_N32_CHAR: Hash[String, String]
-    N32_CHAR_PATTERN: Regexp
-    STANDARD_BY_VARIANT: Hash[String, String]
-    VARIANT_PATTERN: Regexp
+    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
@@ -54,6 +52,9 @@ class ULID < Object
 
     # 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
   end
 
   class MonotonicGenerator
@@ -78,6 +79,9 @@ class ULID < Object
     # The `Thread-safety` is implemented with [Monitor](https://bugs.ruby-lang.org/issues/16255)
     def generate: (?moment: moment) -> ULID
 
+    # Just providing similar api as `ULID.generate` and `ULID.encode` relation. No performance benefit exists in monotonic generator's one.
+    def encode: (?moment: moment) -> String
+
     # Returned value is `basically not` Thread-safety
     # If you want to keep Thread-safety, keep to call {#generate} only in same {#synchronize} block
     #
@@ -102,8 +106,8 @@ class ULID < Object
   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?
   @integer: Integer
+  @encoded: String
   @timestamp: String?
   @randomness: String?
   @inspect: String?
@@ -145,6 +149,16 @@ class ULID < Object
   #
   def self.generate: (?moment: moment, ?entropy: Integer) -> ULID
 
+  # Retuns encoded and normalzied String.
+  # It has same arguments signatures as `.generate`. So can be used for just ID creation usecases without needless object creation.
+  #
+  # NOTE: Difference of ULID#encode, returned String is NOT frozen.
+  #
+  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)
   #
@@ -205,7 +219,7 @@ class ULID < Object
   # ```
   def self.floor: (Time time) -> Time
 
-  # Get ULID instance from encoded String.
+  # Return ULID instance from encoded String.
   #
   # ```ruby
   # ulid = ULID.parse('01ARZ3NDEKTSV4RRFFQ69G5FAV')
@@ -213,6 +227,32 @@ class ULID < Object
   # ```
   def self.parse: (_ToStr string) -> ULID
 
+  # Return Time instance from encoded String.
+  # See also `ULID.encode` for similar purpose.
+  #
+  # NOTE: Difference of ULID#to_time, returned Time is NOT frozen.
+  #
+  # ```ruby
+  # time = ULID.decode_time('01ARZ3NDEKTSV4RRFFQ69G5FAV')
+  # #=> 2016-07-30 23:54:10.259 UTC
+  # ```
+  def self.decode_time: (_ToStr string, ?in: String | Integer | nil) -> Time
+
+  # Get ULID instance from unnormalized String that encoded in Crockford's base32.
+  #
+  # http://www.crockford.com/base32.html
+  #
+  # * Ignore Hyphens (-)
+  # * Mapping 0 O o => 0, 1 I i L l => 1
+  #
+  # ```ruby
+  # ulid = ULID.parse_variant_format('01G70Y0Y7G-ZLXWDIREXERGSDoD')
+  # #=> ULID(2022-07-03 02:25:22.672 UTC: 01G70Y0Y7GZ1XWD1REXERGSD0D)
+  # ```
+  #
+  # See also [ulid/spec#57](https://github.com/ulid/spec/pull/57) and [ulid/spec#3](https://github.com/ulid/spec/issues/3)
+  def self.parse_variant_format: (_ToStr string) -> ULID
+
   # ```ruby
   # # Currently experimental feature, so needed to load the extension.
   # require 'ulid/uuid'
@@ -309,14 +349,13 @@ class ULID < Object
   # ```
   def self.sample: (?period: period) -> ULID
                  | (Integer number, ?period: period?) -> Array[ULID]
-  def self.valid?: (untyped) -> bool
 
   # Returns normalized string
   #
   # ```ruby
+  # ULID.normalize('01G70Y0Y7G-Z1XWDAREXERGSDDD') #=> "01G70Y0Y7GZ1XWDAREXERGSDDD"
   # ULID.normalize('-olarz3-noekisv4rrff-q6ig5fav--') #=> "01ARZ3N0EK1SV4RRFFQ61G5FAV"
-  # ULID.normalized?('-olarz3-noekisv4rrff-q6ig5fav--') #=> false
-  # ULID.normalized?('01ARZ3N0EK1SV4RRFFQ61G5FAV') #=> true
+  # ULID.normalize('01G70Y0Y7G_Z1XWDAREXERGSDDD') #=> ULID::ParserError
   # ```
   #
   # See also [ulid/spec#57](https://github.com/ulid/spec/pull/57) and [ulid/spec#3](https://github.com/ulid/spec/issues/3)
@@ -325,13 +364,40 @@ class ULID < Object
   # Returns `true` if it is normalized string
   #
   # ```ruby
-  # ULID.normalize('-olarz3-noekisv4rrff-q6ig5fav--') #=> "01ARZ3N0EK1SV4RRFFQ61G5FAV"
-  # ULID.normalized?('-olarz3-noekisv4rrff-q6ig5fav--') #=> false
-  # ULID.normalized?('01ARZ3N0EK1SV4RRFFQ61G5FAV') #=> true
+  # ULID.normalized?('01G70Y0Y7GZ1XWDAREXERGSDDD') #=> true
+  # ULID.normalized?('01G70Y0Y7G-Z1XWDAREXERGSDDD') #=> false
+  # ULID.normalized?(ULID.generate.to_s.downcase) #=> false
+  # ULID.normalized?('01G70Y0Y7G_Z1XWDAREXERGSDDD') #=> false (Not raising ULID::ParserError)
+  # ```
+  #
+  # See also [ulid/spec#57](https://github.com/ulid/spec/pull/57) and [ulid/spec#3](https://github.com/ulid/spec/issues/3)
+  def self.normalized?: (_ToStr string) -> bool
+                      | (untyped) -> false
+
+  # Returns `true` if it is valid in ULID format variants
+  #
+  # ```ruby
+  # ULID.valid_as_variant_format?(ULID.generate.to_s.downcase) #=> true
+  # ULID.valid_as_variant_format?('01G70Y0Y7G-Z1XWDAREXERGSDDD') #=> true
+  # ULID.valid_as_variant_format?('01G70Y0Y7G_Z1XWDAREXERGSDDD') #=> false
   # ```
   #
   # See also [ulid/spec#57](https://github.com/ulid/spec/pull/57) and [ulid/spec#3](https://github.com/ulid/spec/issues/3)
-  def self.normalized?: (untyped) -> bool
+  def self.valid_as_variant_format?: (_ToStr string) -> bool
+                             | (untyped) -> false
+
+  # DEPRECATED Use valid_as_variant_format? 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.
+  #
+  # ```ruby
+  # ULID.valid?(ULID.generate.to_s.downcase) #=> true
+  # ```
+  #
+  # See also [ulid/spec#57](https://github.com/ulid/spec/pull/57) and [ulid/spec#3](https://github.com/ulid/spec/issues/3)
+  def self.valid?: (_ToStr string) -> bool
+                 | (untyped) -> false
 
   # Returns parsed ULIDs from given String for rough operations.
   #
@@ -389,9 +455,12 @@ class ULID < Object
   # ```ruby
   # ulid = ULID.generate
   # #=> ULID(2021-04-27 17:27:22.826 UTC: 01F4A5Y1YAQCYAYCTC7GRMJ9AA)
-  # ulid.to_s #=> "01F4A5Y1YAQCYAYCTC7GRMJ9AA"
+  # ulid.encode #=> "01F4A5Y1YAQCYAYCTC7GRMJ9AA"
+  # ulid.encode.frozen? #=> true
+  # ulid.encode.equal?(ulid.to_s) #=> true
   # ```
-  def to_s: -> String
+  def encode: -> String
+  alias to_s encode
 
   # ```ruby
   # ulid = ULID.generate
@@ -411,7 +480,12 @@ class ULID < Object
   # #=> true
   # ```
   #
-  # To be precise, this sorting unaffected with `case sensitive or not` and might handle [ulid/spec#57](https://github.com/ulid/spec/pull/57) in future. So preferable than `lexicographically sortable` in actual case.
+  # To be precise, this sorting unaffected with `case sensitive or not` and might handle [ulid/spec#57](https://github.com/ulid/spec/pull/57) in future.
+  # So preferable than `lexicographically sortable` in actual case.
+  #
+  # This returns -1 | 0 | 1 for ULIDs. However defined as returning Integer. It is caused on ruby/rbs current definition.
+  #   https://github.com/ruby/ruby/blob/cd34f56d450f2310cceaf4c5f34d23eddfda58e8/numeric.c#L4646-L4660
+  #   https://github.com/ruby/rbs/blob/14abbbae8885a09a2ed82de2ef31d67a9c0a108d/core/integer.rbs#L461-L462
   #
   def <=>: (ULID other) -> Integer
          | (untyped other) -> nil
@@ -535,9 +609,6 @@ class ULID < Object
 
   private
 
-  # A private API. Should not be used in your code.
-  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
 
@@ -548,7 +619,7 @@ class ULID < Object
   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) -> void
+  def initialize: (milliseconds: Integer, entropy: Integer, integer: Integer, encoded: String) -> void
 
   # A private API. Should not be used in your code.
   def cache_all_instance_variables: -> void

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: ruby-ulid
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Kenichi Kamiya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-02 00:00:00.000000000 Z
+date: 2022-07-18 00:00:00.000000000 Z
 dependencies: []
-description: "    generator, monotonic generator, parser and manipulations for ULID
-  (RBS included)\n"
+description: "    generator, optional monotonicity, parser and tools for ULID (RBS
+  included)\n"
 email:
 - kachick1+ruby@gmail.com
 executables: []
@@ -23,6 +23,7 @@ files:
 - lib/ruby-ulid.rb
 - lib/ulid.rb
 - lib/ulid/crockford_base32.rb
+- lib/ulid/errors.rb
 - lib/ulid/monotonic_generator.rb
 - lib/ulid/ractor_unshareable_constants.rb
 - lib/ulid/uuid.rb