typed_uuid 2.3 → 4.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42ecd88d5a86ad89fe9a8c0cd8ec275bfded2d66ce7a7bd240f43184d0fe65ab
-  data.tar.gz: 2b32e8528b4d5dc750c54b8818ccb0fcbb99ea4d5276ece385d8af8f2f70c259
+  metadata.gz: 581721d0683d1e3bf4bfa2c4bc29d4a7f5079854c85d98d8672e2f9bec6934e9
+  data.tar.gz: cb660ea624b3be55d02084ca8175035ade7774604a7428cb4555fa00e95460e6
 SHA512:
-  metadata.gz: 2bacb4da4092347b9a483711e7e4530979bf2b135d03bc77f03599851463c21041dbef6b566c0ba6d151c1d2c516a4ca98caa150592888f2a3c85ec941dd060d
-  data.tar.gz: 7e4dd50dbd81e87934f04daf4bf94ed89f7bac9f024e23886bc3c401d626137de664aa8a8e087d02cb57f1193309159a5c6a97ac5b9258ab326c787669f427dc
+  metadata.gz: 25835d74e2cf54a76f4be490f95fa98e5b0cbde8ddec6bafdd990a17d9a900fa7033f15f63a4be23609ae1164d686132a0472bec2e168d93f19e6204af1ab315
+  data.tar.gz: 8dcd77488ddd9f45bba84db7faec4b3e1f37c4258df3dc6273bee7eef1b620799cd725d56338759dc1d488aece3c32102a7364232e03183fa123cef481aa0543

data/README.md

@@ -7,24 +7,36 @@ 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 15th & 16th bytes in the
+UUID are the enum XORed with the result of XORing bytes 5 & 6 with bytes 13 & 14.
 
-`xxxxxxxx-YYYY-TTTT-ZZZZ-xxxxxxxxxxxx`
+`xxxxxxxx-YYYY-xxxx-xxxx-xxxxZZZZTTTT`
 
 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 5 & 6 with 13 & 14 and XORing again with bytes 15 & 16 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 56 bits are an unsigned integer
+             representing the microseconds since epoch. Followed by 48 random
+             bits or a sequence counter. Then 8 random bits followed by 16 bits
+             which are the UUID type.
+
+- Version 4: A random UUID where the first 112 bits are random. The following
+             16 bits are the UUID type.
 
 ## Install
 
@@ -33,24 +45,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 +80,38 @@ class CreateProperties < ActiveRecord::Migration[5.2]
     end
   end
 end
-```
+```
+
+To add a typed UUID to an existing table:
+
+```ruby
+class UpdateProperties < ActiveRecord::Migration[6.1]
+  def change
+    klass_enum = ::ActiveRecord::Base.uuid_type_from_table_name(:properties)
+    
+    # Add the column
+    add_column :properties, :typed_uuid, :uuid, default: -> { "typed_uuid('\\x#{klass_enum.to_s(16).rjust(4, '0')}')" }
+    
+    # Update existing properties with a new typed UUID
+    execute "UPDATE properties SET id = typed_uuid('\\x#{klass_enum.to_s(16).rjust(4, '0')}');"
+    
+    # Add null constraint since we'll swap these out for the primary key
+    change_column_null :properties, :typed_uuid, false
+    
+    # TODO: Here you will want to update any reference to the old primary key
+    # with the new typed_uuid that will be the new primary key.
+    
+    # Replace the old primary key with the typed_uuid
+    execute "ALTER TABLE properties DROP CONSTRAINT properties_pkey;"
+    rename_column :properties, :typed_uuid, :id
+    execute "ALTER TABLE properties ADD PRIMARY KEY (id);"
+  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,32 @@
 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(
+                lpad(right(to_hex((extract(epoch from clock_timestamp())*1000000)::bigint), 12), 12, '0'),
+                encode(gen_random_bytes(10), 'hex')
+            ), 'hex');
+          ELSE
+            bytes := gen_random_bytes(16);
+          END IF;
+
+          type := decode( lpad(to_hex(((enum << 3) | version)), 4, '0'), 'hex');
+          bytes := set_byte(bytes, 14, (get_byte(bytes, 4) # get_byte(bytes, 12)) # get_byte(type, 0));
+          bytes := set_byte(bytes, 15, (get_byte(bytes, 5) # get_byte(bytes, 13)) # get_byte(type, 1));
+          
           RETURN encode( bytes, 'hex') :: uuid;
         END;
-      $$ LANGUAGE plpgsql;
-    SQL
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
   end
 end

data/lib/typed_uuid.rb

@@ -3,16 +3,50 @@ 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, **options)
+    if enum < 0 || enum > 8_191
+      raise ArgumentError, "UUID type must be between 0 and 8,191"
+    end
+    
+    if version == 1
+      timestamp_uuid(enum, **options)
+    elsif version == 4
+      random_uuid(enum, **options)
+    end
+  end
+  
+  def self.random_uuid(enum)
+    uuid = SecureRandom.random_bytes(16).unpack("nnnnnnnn")
+    
+    uuid[7] = (uuid[2] ^ uuid[6]) ^ ((enum << 3) | 4)
+    "%04x%04x-%04x-%04x-%04x-%04x%04x%04x" % uuid
+  end
+  
+  def self.timestamp_uuid(enum, timestamp: nil, sequence: nil)
+    timestamp  ||= Time.now
+    
+    uuid = [timestamp.to_i * 1_000_000 + timestamp.usec].pack('Q>')[1..-1]
+    uuid << (sequence&.pack('Q>') || SecureRandom.random_bytes(10))
+    
+    uuid = uuid.unpack("nnnnnnnn")
+    uuid[7] = (uuid[2] ^ uuid[6]) ^ ((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[8..11].to_i(16) ^ uuid[24..27].to_i(16)) ^ uuid[28..31].to_i(16)) >> 3
+  end
+  
+  def self.version(uuid)
+    uuid = uuid.gsub('-', '')
+    ((uuid[8..11].to_i(16) ^ uuid[24..27].to_i(16)) ^ uuid[28..31].to_i(16)) & 0b0000000000000111
+  end
+  
+  def self.timestamp(uuid)
+    uuid = uuid.gsub('-', '')
+    Time.at(*uuid[0..13].to_i(16).divmod(1_000_000), :usec)
   end
 end
 
-require 'typed_uuid/railtie' if defined? Rails
+require 'typed_uuid/railtie' if defined? Rails

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(**options)
+      TypedUUID.uuid(uuid_enum_from_class(self), uuid_version_from_class(self), **options)
+    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).rjust(4, '0')}')" }
+      options[:default] ||= -> { "typed_uuid(#{klass_type_enum}, #{klass_type_version})" }
       super(name, :uuid, **options)
     else
       super

data/lib/typed_uuid/psql_schema_dumper.rb

@@ -6,15 +6,27 @@ module TypedUUID::PsqlSchemaDumper
   ## These are functions that must be enabled in order to support typed_uuids
   ## in this database
   execute <<-SQL
-    CREATE OR REPLACE FUNCTION typed_uuid(t bytea) RETURNS uuid AS $$
-      DECLARE
-        bytes bytea := gen_random_bytes(16);
-        uuid 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));
-        RETURN encode( bytes, 'hex') :: uuid;
-      END;
+    CREATE OR REPLACE FUNCTION typed_uuid(enum int, version int default 4)
+    RETURNS uuid AS $$
+    DECLARE
+      bytes bytea;
+      type bytea;
+    BEGIN
+      IF version = 1 THEN
+        bytes := decode(concat(
+            lpad(right(to_hex((extract(epoch from clock_timestamp())*1000000)::bigint), 12), 12, '0'),
+            encode(gen_random_bytes(10), 'hex')
+        ), 'hex');
+      ELSE
+        bytes := gen_random_bytes(16);
+      END IF;
+
+      type := decode( lpad(to_hex(((enum << 3) | version)), 4, '0'), 'hex');
+      bytes := set_byte(bytes, 14, (get_byte(bytes, 4) # get_byte(bytes, 12)) # get_byte(type, 0));
+      bytes := set_byte(bytes, 15, (get_byte(bytes, 5) # get_byte(bytes, 13)) # get_byte(type, 1));
+    
+      RETURN encode( bytes, 'hex') :: uuid;
+    END;
     $$ LANGUAGE plpgsql;
   SQL
 

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.3'
+  VERSION = '4.0.rc2'
 end

data/test/test_helper.rb

@@ -28,7 +28,9 @@ module ActiveRecord::Tasks::DatabaseTasks
 end
 TypedUUID::Railtie.initializers.each(&:run)
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-
+def MiniTest.filter_backtrace(bt)
+  bt
+end
 class ActiveSupport::TestCase
   
   # File 'lib/active_support/testing/declarative.rb'
@@ -52,6 +54,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 +82,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: 592
+      '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('\\x0001') 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, 370979, :usec)
+    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 592, ::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(592)
+  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.3'
+  version: 4.0.rc2
 platform: ruby
 authors:
 - Jon Bracy
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-25 00:00:00.000000000 Z
+date: 2021-04-21 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.2.3
+signing_key:
 specification_version: 4
 summary: Typed UUIDs for ActiveRecord
 test_files: