typed_uuid 2.2 → 4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5bf0c87bdd7950cf4aa85e788d0e4d0ac49ac842947471b2788db6c5e7b347b
-  data.tar.gz: a396047b9153d11c56ba87412ac7dbd6a3e17e9ecf701eebf9fef8e4542e9971
+  metadata.gz: 956d3f40e94a40968f9e66ae955a0eb4ca0a0d5e7c0a307e846a6bc329970108
+  data.tar.gz: 49844d2082da751bc4d36dede69bdd927bb93269a8caadcaee20916a66e56c4f
 SHA512:
-  metadata.gz: 7e3fe8ade426da5a52beef42674a737ec22837b5c8d758155ee4f962ed81a054cf0a1e8d36c6122e2f4a6ea14db9c0bc88586351812eb8b859a4eeeb886af621
-  data.tar.gz: 94434e3ab2d1fbb58a41c8dceb4558cf8a554ce16efd3b94aa9a0d62bde91b267da06804a91079076b1a88407e5cec362250a92146c8ac148ffe56ac0f83ebd2
+  metadata.gz: 5e4792f1bf817f6d3edf9b958ce843ddbda5d9fbb1286629a4cd91acdc56581d239e167b1808d580d5139233c1a74cc0aae3f88adc5585542413196735f6c7ea
+  data.tar.gz: 143e55145e97eb7dd177d2d2785c03f8267cdad624a40cd52ce628c66194ae155c6d852b564eecdf991399e62c05ae1b48837698f362239aff6e2774a5b9ef1c

data/README.md

@@ -7,24 +7,35 @@ a hex representation of 4 bits.
 
 `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`
 
-Where:
-
 - M is 4 bits and is the Version
 - N is 3 bits and is the Variant of the Version followed a bit
 
-We modify this and use the following structure where the 7th & 8th bytes in the
-UUID are enum XORed with the result of XORing bytes 5 & 6 with bytes 9 & 10.
+We modify this and use the following structure where the 9th & 10th bytes in the
+UUID are the enum XORed with the result of XORing bytes 7 & 8 with bytes 11 & 12.
 
-`xxxxxxxx-YYYY-TTTT-ZZZZ-xxxxxxxxxxxx`
+`xxxxxxxx-xxxx-YYYY-TTTT-ZZZZxxxxxxxx`
 
 Where:
 
-- TTTT is the Type ENUM 0bNNNN_NNNN_NNNN_NNNN (0 - 65,535) XORed with (YYYY xor ZZZZ)
+- TTTT is the Type ENUM & Version 0bEEEE_EEEE_EEEE_EVVV; XORed with (YYYY xor ZZZZ)
+    - The Es are the bits of the 13 bit ENUM supporting 8,192 enums/types (0 - 8,191)
+    - The Vs are the bits in the 3 bit version supporting 8 versions (0 - 7)
 - YYYY bytes XORed with ZZZZ and the Type ENUM to produce the identifying bytes
 - ZZZZ bytes XORed with YYYY and the Type ENUM to produce the identifying bytes
 
-XORing bytes 5 & 6 with 9 & 10 and XORing again with bytes 5 & 6 of the Typed UUID
-will give us back the ENUM of the Type using soley the UUID.
+XORing bytes 7 & 8 with 11 & 12 and XORing again with bytes 9 & 10 of the
+Typed UUID will give us back the ENUM and Version of the Type using soley the UUID.
+
+## Versions
+
+As with regular UUID Typed UUIDs come in multiple version. The current versions are:
+
+- Version 1: A timebased UUID where the first 64 bits are an unsigned integer
+             representing the nanoseconds since epoch. The following 16 bits are
+             the UUID type folled by 48 random bits.
+
+- Version 4: A random UUID where the first 64 bits are random. The following
+             16 bits are the UUID type folled by another 48 random bits.
 
 ## Install
 
@@ -33,24 +44,28 @@ Add this to your Gemfile:
 `gem 'typed_uuid'`
 
 Once bundled you can add an initializer to Rails to register your types as shown
-below. This maps the __table_names__ of the models to an integer between 0 and 255.
+below. This maps the __Model Classes__ to an integer between 0 and 65,535.
 
 ```ruby
 # config/initializers/uuid_types.rb
 
 ActiveRecord::Base.register_uuid_types({
-  listings: 	0,
-  buildings: 	65_535
+  Listing: 	                0,
+  Address:                  {enum: 5},
+  Building:                 {enum: 512, version: 1},
+  'Building::SkyScrpaer' => 8_191
 })
 
 # Or:
 
 ActiveRecord::Base.register_uuid_types({
-  0 		=> :listings,
-  65_535 	=> :buildings
+  0         => :Listing,
+  512       => :Building,
+  8_191    => 'Building::SkyScrpaer'
 })
 ```
 
+
 ## Usage
 
 In your migrations simply replace `id: :uuid` with `id: :typed_uuid` when creating
@@ -64,4 +79,12 @@ class CreateProperties < ActiveRecord::Migration[5.2]
     end
   end
 end
-```
+```
+
+## STI Models
+When using STI Model Rails will generate the UUID to be inserted. This UUID will
+be calculated of the STI Model class and not the base class.
+
+In the migration you can still used `id: :typed_uuid`, this will use the base
+class to calculated the default type for the UUID. You could also set the
+`id` to `:uuid` and the `default` to `false` so when no ID is given it will error.

data/db/migrate/20191222234546_add_typed_uuid_function.rb

@@ -1,18 +1,33 @@
 class AddTypedUuidFunction < ActiveRecord::Migration[6.0]
   def up
-    enable_extension 'pgcrypto'
+    if connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+      enable_extension 'pgcrypto'
     
-    execute <<-SQL
-      CREATE OR REPLACE FUNCTION typed_uuid(t bytea) RETURNS uuid AS $$
+      execute <<-SQL
+        CREATE OR REPLACE FUNCTION typed_uuid(enum int, version int default 4)
+        RETURNS uuid AS $$
         DECLARE
-          bytes bytea := gen_random_bytes(16);
-          uuid bytea;
+          bytes bytea;
+          type bytea;
         BEGIN
-          bytes := set_byte(bytes, 6, (get_byte(bytes, 4) # get_byte(bytes, 8)) # get_byte(t, 0));
-          bytes := set_byte(bytes, 7, (get_byte(bytes, 5) # get_byte(bytes, 9)) # get_byte(t, 1));
+          IF version = 1 THEN
+            bytes := decode(concat(
+                to_hex((extract(epoch from clock_timestamp())*1000000000)::bigint),
+                encode(gen_random_bytes(8), 'hex')
+            ), 'hex');
+          ELSE
+            bytes := gen_random_bytes(16);
+            version := 4;
+          END IF;
+
+          type := decode( lpad(to_hex(((enum << 3) | version)), 4, '0'), 'hex');
+          bytes := set_byte(bytes, 8, (get_byte(bytes, 6) # get_byte(bytes, 10)) # get_byte(type, 0));
+          bytes := set_byte(bytes, 9, (get_byte(bytes, 7) # get_byte(bytes, 11)) # get_byte(type, 1));
+          
           RETURN encode( bytes, 'hex') :: uuid;
         END;
-      $$ LANGUAGE plpgsql;
-    SQL
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
   end
-end
+end

data/lib/typed_uuid.rb

@@ -3,15 +3,48 @@ module TypedUUID
   autoload :PsqlColumnMethods, 'typed_uuid/psql_column_methods'
   autoload :PsqlSchemaDumper, 'typed_uuid/psql_schema_dumper'
   
-  def self.uuid(enum)
-    uuid = SecureRandom.random_bytes(16).unpack("NnnnnN")
-    uuid[2] = (uuid[1] ^ uuid[3]) ^ enum
-    "%08x-%04x-%04x-%04x-%04x%08x" % uuid
+  def self.uuid(enum, version = 4)
+    if enum < 0 || enum > 8_191
+      raise ArgumentError, "UUID type must be between 0 and 8,191"
+    end
+    
+    if version == 1
+      timestamp_uuid(enum)
+    elsif version == 4
+      random_uuid(enum)
+    end
+  end
+  
+  def self.random_uuid(enum)
+    uuid = SecureRandom.random_bytes(16).unpack("nnnnnnnn")
+    
+    uuid[4] = (uuid[3] ^ uuid[5]) ^ ((enum << 3) | 4)
+    "%04x%04x-%04x-%04x-%04x-%04x%04x%04x" % uuid
+  end
+
+  def self.timestamp_uuid(enum)
+    time = Time.now
+    uuid = [time.to_i * 1_000_000_000 + time.nsec].pack('Q>')
+    uuid << SecureRandom.random_bytes(8)
+
+    uuid = uuid.unpack("nnnnnnnn")
+    uuid[4] = (uuid[3] ^ uuid[5]) ^ ((enum << 3) | 1)
+    "%04x%04x-%04x-%04x-%04x-%04x%04x%04x" % uuid
   end
   
   def self.enum(uuid)
     uuid = uuid.gsub('-', '')
-    (uuid[8..11].to_i(16) ^ uuid[16..19].to_i(16)) ^ uuid[12..15].to_i(16)
+    ((uuid[12..15].to_i(16) ^ uuid[20..23].to_i(16)) ^ uuid[16..19].to_i(16)) >> 3
+  end
+  
+  def self.version(uuid)
+    uuid = uuid.gsub('-', '')
+    ((uuid[12..15].to_i(16) ^ uuid[20..23].to_i(16)) ^ uuid[16..19].to_i(16)) & 0b0000000000000111
+  end
+  
+  def self.timestamp(uuid)
+    uuid = uuid.gsub('-', '')
+    Time.at(*uuid[0..15].to_i(16).divmod(1_000_000_000), :nsec)
   end
 end
 

data/lib/typed_uuid/active_record.rb

@@ -1,79 +1,132 @@
+require 'active_support/concern'
+
 module TypedUUID::ActiveRecord
+  extend ActiveSupport::Concern
   
   UUID_TYPE_CONFLICT_MESSAGE = \
-    "You tried to define an UUID type %{int} for \"%{table}\", but " \
+    "You tried to define an UUID type %{int} for \"%{class_name}\", but " \
     " %{int} is already defined as the type for %{other}"
-  
-  def self.extended(base) # :nodoc:
-    base.class_attribute(:defined_uuid_types, instance_writer: false, default: {})
-    base.class_attribute(:uuid_type_cache, instance_writer: false, default: {})
+
+  included do
+    class_attribute(:defined_uuid_types, instance_writer: false, default: {})
+    class_attribute(:class_to_uuid_type_cache, instance_writer: false, default: Hash.new { |hash, klass|
+      if type = defined_uuid_types.find { |k, v| v[:class] == klass.name }
+        hash[klass] = type[1]
+      end
+    })
+    class_attribute(:uuid_enum_to_class_cache, instance_writer: false, default: {})
   end
   
-  def register_uuid_type(table, int)
-    if int < 0 || int > 65_535
-      raise ArgumentError, "UUID type must be between 0 and 65,535"
-    elsif defined_uuid_types.has_key?(int)
-      raise ArgumentError, UUID_TYPE_CONFLICT_MESSAGE % {
-        int: int,
-        table: table,
-        other: defined_uuid_types[int]
-      }
-    else
-      defined_uuid_types[int] = table.to_s
+  def _create_record
+    klass = self.class
+    if !klass.descends_from_active_record? && klass.typed?
+      pk = klass.primary_key
+      write_attribute(pk, klass.typed_uuid) if pk && read_attribute(pk).nil?
     end
+    
+    super
   end
   
-  def register_uuid_types(mapping)
-    mapping.each do |k, v|
-      if k.is_a?(Integer)
-        register_uuid_type(v, k)
+  class_methods do
+    def register_uuid_type(class_name, enum_or_options)
+      if enum_or_options.is_a?(Hash)
+        enum = enum_or_options[:enum]
+        version = enum_or_options[:version] || 4
       else
-        register_uuid_type(k, v)
+        enum = enum_or_options
+        version = 4
+      end
+      
+      if enum < 0 || enum > 8_191
+        raise ArgumentError, "UUID type must be between 0 and 65,535"
+      elsif defined_uuid_types.has_key?(enum)
+        raise ArgumentError, UUID_TYPE_CONFLICT_MESSAGE % {
+          int: enum,
+          class_name: class_name,
+          other: defined_uuid_types[enum]
+        }
+      else
+        defined_uuid_types[enum] = { class: class_name.to_s, version: version, enum: enum }
       end
     end
-  end
-
-  def typed_uuid
-    TypedUUID.uuid(uuid_type_from_class(self))
-  end
   
-  def uuid_type_from_table_name(table)
-    type = defined_uuid_types.key(table.to_s)
-    if type.nil?
-      raise ArgumentError, "UUID Type for \"#{table}\" not defined"
+    def register_uuid_types(mapping)
+      mapping.each do |k, v|
+        if k.is_a?(Integer)
+          register_uuid_type(v, k)
+        else
+          register_uuid_type(k, v)
+        end
+      end
     end
-    
-    type
-  end
 
-  def uuid_type_from_class(klass)
-    type = defined_uuid_types.key(klass.table_name)
-    if type.nil?
-      raise ArgumentError, "UUID Type for \"#{table}\" not defined"
+    def typed?
+      !!class_to_uuid_type_cache[self.base_class]
     end
     
-    type
-  end
+    def typed_uuid
+      TypedUUID.uuid(uuid_enum_from_class(self), uuid_version_from_class(self))
+    end
+    
+    def uuid_enum_from_table_name(table)
+      uuid_enum_from_class(class_from_table_name(table))
+    end
+
+    def uuid_version_from_table_name(table)
+      uuid_version_from_class(class_from_table_name(table))
+    end
   
-  def class_from_uuid_type(type)
-    if klass = uuid_type_cache[type]
-      return klass 
-    else
-      Rails.application.eager_load! if !Rails.application.config.eager_load
+    def uuid_enum_from_class(klass)
+      type = class_to_uuid_type_cache[klass]
+      if type.nil?
+        raise ArgumentError, "UUID Type for \"#{klass.name}\" not defined"
+      end
+
+      type[:enum]
+    end
+
+    def uuid_version_from_class(klass)
+      type = class_to_uuid_type_cache[klass]
+      if type.nil?
+        raise ArgumentError, "UUID Type for \"#{klass.name}\" not defined"
+      end
 
-      ::ActiveRecord::Base.descendants.select do |klass|
+      type[:version]
+    end
+
+    def class_from_uuid_enum(enum)
+      if uuid_enum_to_class_cache.has_key?(enum)
+        uuid_enum_to_class_cache[enum]
+      else
+        Rails.application.eager_load! if !Rails.application.config.eager_load
+
+        ::ActiveRecord::Base.descendants.each do |klass|
+          next if klass.table_name.nil?
+      
+          if key = defined_uuid_types.find { |enum, info| info[:class] == klass.name }
+            uuid_enum_to_class_cache[key[0]] = klass
+          end
+        end
+      
+        uuid_enum_to_class_cache[enum]
+      end
+    end
+  
+    def class_from_table_name(table)
+      table = table.to_s
+      Rails.application.eager_load! if !Rails.application.config.eager_load
+    
+      ::ActiveRecord::Base.descendants.find do |klass|
         next unless ( klass.superclass == ::ActiveRecord::Base || klass.superclass.abstract_class? )
         next if klass.table_name.nil?
-        
-        uuid_type_cache[defined_uuid_types.key(klass.table_name)] = klass
+
+        klass.table_name == table
       end
-      
-      uuid_type_cache[type]
     end
-  end
   
-  def class_from_uuid(uuid)
-    class_from_uuid_type(TypedUUID.enum(uuid))
+    def class_from_uuid(uuid)
+      class_from_uuid_enum(TypedUUID.enum(uuid))
+    end
   end
   
 end

data/lib/typed_uuid/psql_column_methods.rb

@@ -2,9 +2,10 @@ module TypedUUID::PsqlColumnMethods
 
   def primary_key(name, type = :primary_key, **options)
     if type == :typed_uuid
-      klass_enum = ::ActiveRecord::Base.uuid_type_from_table_name(self.name)
+      klass_type_enum = ::ActiveRecord::Base.uuid_enum_from_table_name(self.name)
+      klass_type_version = ::ActiveRecord::Base.uuid_version_from_table_name(self.name)
       options[:id] = :uuid
-      options[:default] ||= -> { "typed_uuid('\\x#{klass_enum.to_s(16).ljust(4, '0')}')" }
+      options[:default] ||= -> { "typed_uuid(#{klass_type_enum}, #{klass_type_version})" }
       super(name, :uuid, **options)
     else
       super

data/lib/typed_uuid/railtie.rb

@@ -4,7 +4,7 @@ class TypedUUID::Railtie < Rails::Railtie
     ActiveRecord::Tasks::DatabaseTasks.migrations_paths << File.expand_path('../../../db/migrate', __FILE__)
     
     ActiveSupport.on_load(:active_record) do
-      ActiveRecord::Base.extend TypedUUID::ActiveRecord
+      ActiveRecord::Base.include TypedUUID::ActiveRecord
     end
     
     require 'active_record/connection_adapters/postgresql/schema_definitions'

data/lib/typed_uuid/version.rb

@@ -1,3 +1,3 @@
 module TypedUUID
-  VERSION = '2.2'
+  VERSION = '4.0.rc1'
 end

data/test/test_helper.rb

@@ -52,6 +52,10 @@ class ActiveSupport::TestCase
   set_callback(:setup, :before) do
     Rails.stubs(:application).returns(stub(config: stub(eager_load: true)))
     if !self.class.class_variable_defined?(:@@suite_setup_run)
+      ActiveRecord::Base.defined_uuid_types.clear
+      ActiveRecord::Base.uuid_enum_to_class_cache.clear
+      ActiveRecord::Base.class_to_uuid_type_cache.clear
+      
       configuration = {
         adapter:  "postgresql",
         database: "uuid-types-test",
@@ -76,14 +80,14 @@ class ActiveSupport::TestCase
     self.class.class_variable_set(:@@suite_setup_run, true)
   end
 
-  # def debug
-  #   ActiveRecord::Base.logger = Logger.new(STDOUT)
-  #   $debugging = true
-  #   yield
-  # ensure
-  #   ActiveRecord::Base.logger = nil
-  #   $debugging = false
-  # end
+  def debug
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    $debugging = true
+    yield
+  ensure
+    ActiveRecord::Base.logger = nil
+    $debugging = false
+  end
 
   def capture_sql
     # ActiveRecord::Base.connection.materialize_transactions

data/test/typed_uuid_test.rb

@@ -4,8 +4,9 @@ class FilterTest < ActiveSupport::TestCase
 
   schema do
     ActiveRecord::Base.register_uuid_types({
-      listings: 0,
-      buildings: 65_535
+      'FilterTest::Listing'  => {enum: 0, version: 1},
+      'FilterTest::Building' => 592,
+      'FilterTest::SkyScraper' => {enum: 1_952}
     })
     
     create_table :listings, id: :typed_uuid do |t|
@@ -14,6 +15,7 @@ class FilterTest < ActiveSupport::TestCase
     
     create_table :buildings, id: :typed_uuid do |t|
       t.string   "name", limit: 255
+      t.string   "type", limit: 255
     end
   end
   
@@ -22,14 +24,26 @@ class FilterTest < ActiveSupport::TestCase
   
   class Building < ActiveRecord::Base
   end
+  
+  class SkyScraper < Building
+  end
 
+  class SingleFamilyHome < Building
+  end
+  
+  class Property < ActiveRecord::Base
+  end
+  
+  class Lot < ActiveRecord::Base
+  end
+  
   test 'adding primary key as a typed_uuid in a migration' do
     ActiveRecord::Base.register_uuid_types({
-      properties: 1
+      1 => 'FilterTest::Property'
     })
 
     exprexted_sql = <<-SQL
-      CREATE TABLE "properties" ("id" uuid DEFAULT typed_uuid('\\x1000') NOT NULL PRIMARY KEY, "name" character varying(255))
+      CREATE TABLE "properties" ("id" uuid DEFAULT typed_uuid(1, 4) NOT NULL PRIMARY KEY, "name" character varying(255))
     SQL
 
     assert_sql exprexted_sql do
@@ -41,29 +55,100 @@ class FilterTest < ActiveSupport::TestCase
     end
   end
 
+  test 'adding primary key as a typed_uuid in a migration with a version' do
+    ActiveRecord::Base.register_uuid_types({
+      'FilterTest::Lot' => {version: 1, enum: 512}
+    })
+
+    exprexted_sql = <<-SQL
+      CREATE TABLE "lots" ("id" uuid DEFAULT typed_uuid(512, 1) NOT NULL PRIMARY KEY, "name" character varying(255))
+    SQL
+
+    assert_sql exprexted_sql do
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.create_table :lots, id: :typed_uuid do |t|
+          t.string   "name",                    limit: 255
+        end
+      end
+    end
+  end
+
   test 'typed_uuid' do
     assert_equal 512, TypedUUID.enum(TypedUUID.uuid(512))
-    assert_equal FilterTest::Listing, ::ActiveRecord::Base.class_from_uuid(Listing.typed_uuid)
-    assert_equal FilterTest::Building, ::ActiveRecord::Base.class_from_uuid(Building.typed_uuid)
+    assert_equal FilterTest::Listing,    ::ActiveRecord::Base.class_from_uuid(Listing.typed_uuid)
+    assert_equal FilterTest::Building,   ::ActiveRecord::Base.class_from_uuid(Building.typed_uuid)
+    assert_equal FilterTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid(SkyScraper.typed_uuid)
+    
+    assert_raises ArgumentError do
+      ::ActiveRecord::Base.class_from_uuid(SingleFamilyHome.typed_uuid)
+    end
   end
   
-  test 'class_from uuid' do
+  test 'typed_uuid v1' do
+    time = Time.at(1606612254, 370979123, :nsec)
+    Time.stubs(:now).returns(time)
+
+    uuid = TypedUUID.uuid(592, 1)
+    
+    assert_equal 1, TypedUUID.version(uuid)
+    assert_equal 592, TypedUUID.enum(uuid)
+    
+    assert_equal time, TypedUUID.timestamp(uuid)
+    assert_equal time.to_i, TypedUUID.timestamp(uuid).to_i
+    assert_equal time.nsec, TypedUUID.timestamp(uuid).nsec
+    
+    assert_equal Listing, ::ActiveRecord::Base.class_from_uuid(Listing.typed_uuid)
+  end
+  
+  test 'class_from uuid generated bye PostgresQL' do
     listing = Listing.create
     building = Building.create
+    skyscraper = SkyScraper.create
     
     assert_equal FilterTest::Listing, ::ActiveRecord::Base.class_from_uuid(listing.id)
     assert_equal FilterTest::Building, ::ActiveRecord::Base.class_from_uuid(building.id)
+    assert_equal FilterTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid(skyscraper.id)
+
+    assert_raises ArgumentError do
+      SingleFamilyHome.create
+    end
   end
   
-  test 'uuid_type from table_name' do
-    assert_equal 0, ::ActiveRecord::Base.uuid_type_from_table_name(:listings)
-    assert_equal 0, ::ActiveRecord::Base.uuid_type_from_table_name('listings')
-    assert_equal 65_535, ::ActiveRecord::Base.uuid_type_from_table_name(:buildings)
+  test 'class_from v1 uuid generated bye PostgresQL' do
+    listing = Listing.create
+    
+    assert_equal Listing, ::ActiveRecord::Base.class_from_uuid(listing.id)
+  end
+  
+  test 'uuid_enum from table_name' do
+    assert_equal 0, ::ActiveRecord::Base.uuid_enum_from_table_name(:listings)
+    assert_equal 0, ::ActiveRecord::Base.uuid_enum_from_table_name('listings')
+    
+    assert_equal 592, ::ActiveRecord::Base.uuid_enum_from_table_name(:buildings)
+  end
+  
+  test 'uuid_version from table_name' do
+    assert_equal 1, ::ActiveRecord::Base.uuid_version_from_table_name(:listings)
+    assert_equal 1, ::ActiveRecord::Base.uuid_version_from_table_name('listings')
+    assert_equal 4, ::ActiveRecord::Base.uuid_version_from_table_name(:buildings)
+  end
+
+  test 'uuid_enum from class' do
+    assert_equal 0, ::ActiveRecord::Base.uuid_enum_from_class(Listing)
+    assert_equal 592, ::ActiveRecord::Base.uuid_enum_from_class(Building)
+    assert_equal 1_952, ::ActiveRecord::Base.uuid_enum_from_class(SkyScraper)
+  end
+
+  test 'uuid_version from class' do
+    assert_equal 1, ::ActiveRecord::Base.uuid_version_from_class(Listing)
+    assert_equal 4, ::ActiveRecord::Base.uuid_version_from_class(Building)
+    assert_equal 4, ::ActiveRecord::Base.uuid_version_from_class(SkyScraper)
   end
   
-  test 'class from uuid_type' do
-    assert_equal FilterTest::Listing, ::ActiveRecord::Base.class_from_uuid_type(0)
-    assert_equal FilterTest::Building, ::ActiveRecord::Base.class_from_uuid_type(65_535)
+  test 'class from uuid_enum' do
+    assert_equal FilterTest::Listing, ::ActiveRecord::Base.class_from_uuid_enum(0)
+    assert_equal FilterTest::Building, ::ActiveRecord::Base.class_from_uuid_enum(592)
+    assert_equal FilterTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid_enum(1_952)
   end
   
 end

data/typed_uuid.gemspec

@@ -24,8 +24,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'byebug'
   s.add_development_dependency 'activesupport', '>= 6.0.0'
   s.add_development_dependency 'rails', '>= 6.0.0'
+  s.add_development_dependency 'pg'
   
   # Runtime
-  s.add_runtime_dependency 'pg'
   s.add_runtime_dependency 'activerecord', '>= 6.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed_uuid
 version: !ruby/object:Gem::Version
-  version: '2.2'
+  version: 4.0.rc1
 platform: ruby
 authors:
 - Jon Bracy
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-25 00:00:00.000000000 Z
+date: 2020-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -143,7 +143,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -190,7 +190,7 @@ files:
 homepage: https://github.com/malomalo/typed_uuid
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -201,12 +201,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Typed UUIDs for ActiveRecord
 test_files: