typed_uuid 3.2 → 4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b97eecee8303b2863faf3982c4080d347c9dabc4b0fca45c2c5dc7c74b6172
-  data.tar.gz: 72d70bc0bc247987141c6ee4710a5ef34257693179b1d526dcc6fbf427e414f5
+  metadata.gz: 9dd0a928d842b001570b023cace562666b6f391623fd27ca1c6b88cebd58ed3a
+  data.tar.gz: '09ea1aee57794d976b79c8bd221e1894519994603f8112bd4ffb55966b3082c6'
 SHA512:
-  metadata.gz: 204697bd0dc2c7dd64b62dc7b7955cb5d83242c5966bc447c84d79d343f3b0825cc8bd1bb450525a3acc3405a61a1740b06f127a9df6f5f5830f9a063a75f18a
-  data.tar.gz: cba9d2425930e678e4c44bfc163392fb749c249f5e2930b62998f22fae5ad10cdaa9e8df5df013b6155eac8c1c242056e4ff67b65dfb63140f82f545b24d38d4
+  metadata.gz: 5123b6d3291005d87ae8ed4fd1fefe9b55f10d83cde474367d9e136ff625a80a7bae221584a92c297f3a32e2b33e5a0c81bb3124b7acacb4bd82a28df94e4e82
+  data.tar.gz: 7e96e3a5376fdcd87ba3a0c89e0e1511707000d280aa17c52d618d6f7c150eb3ff33bf23102c6dfdbfe04b6b91dccf94f984d94d66e38b3830c89c23516ce805

data/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    name: TypedUUID Test
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.0
+
+      - uses: actions/checkout@v2
+
+      - run: |
+          sudo systemctl start postgresql.service
+          sudo -u postgres createuser runner --superuser
+          sudo -u postgres createdb uuid-types-test
+
+      - run: bundle
+
+      - run: bundle exec rake test

data/README.md

@@ -7,24 +7,44 @@ 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 3: A name-based UUID where the first 112 bits are based off the MD5
+             digest of the namespace and name. The following 16 bits are the
+             UUID type.
+
+- Version 4: A random UUID where the first 112 bits are random. The following
+             16 bits are the UUID type.
+
+- Version 5: A name-based UUID where the first 112 bits are based off the SHA1
+             digest of the namespace and name. The following 16 bits are the
+             UUID type.
 
 ## Install
 
@@ -40,8 +60,9 @@ below. This maps the __Model Classes__ to an integer between 0 and 65,535.
 
 ActiveRecord::Base.register_uuid_types({
   Listing: 	                0,
-  Building:                 512,
-  'Building::SkyScrpaer' => 65_535
+  Address:                  {enum: 5},
+  Building:                 {enum: 512, version: 1},
+  'Building::SkyScrpaer' => 8_191
 })
 
 # Or:
@@ -49,7 +70,7 @@ ActiveRecord::Base.register_uuid_types({
 ActiveRecord::Base.register_uuid_types({
   0         => :Listing,
   512       => :Building,
-  65_535    => 'Building::SkyScrpaer'
+  8_191     => 'Building::SkyScrpaer'
 })
 ```
 
@@ -61,18 +82,50 @@ a table.
 
 ```ruby
 class CreateProperties < ActiveRecord::Migration[5.2]
-  def change	
-	create_table :properties, id: :typed_uuid do |t|
+  def change
+    create_table :properties, id: :typed_uuid do |t|
       t.string "name", limit: 255
     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
+```
+
+When you need to lookup they class of a TypedUUID:
+
+```ruby
+ActiveRecord::Base.class_from_uuid(my_uuid) #=> MyClass
+```
+
 ## 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.
+`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

@@ -4,15 +4,27 @@ class AddTypedUuidFunction < ActiveRecord::Migration[6.0]
       enable_extension 'pgcrypto'
     
       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
     end

data/lib/typed_uuid/active_record.rb

@@ -10,9 +10,11 @@ module TypedUUID::ActiveRecord
   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|
-      hash[klass] = defined_uuid_types.key(klass.name)
+      if type = defined_uuid_types.find { |k, v| v[:class] == klass.name }
+        hash[klass] = type[1]
+      end
     })
-    class_attribute(:uuid_type_to_class_cache, instance_writer: false, default: {})
+    class_attribute(:uuid_enum_to_class_cache, instance_writer: false, default: {})
   end
   
   def _create_record
@@ -26,17 +28,25 @@ module TypedUUID::ActiveRecord
   end
   
   class_methods do
-    def register_uuid_type(class_name, int)
-      if int < 0 || int > 65_535
+    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
+        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?(int)
+      elsif defined_uuid_types.has_key?(enum)
         raise ArgumentError, UUID_TYPE_CONFLICT_MESSAGE % {
-          int: int,
+          int: enum,
           class_name: class_name,
-          other: defined_uuid_types[int]
+          other: defined_uuid_types[enum]
         }
       else
-        defined_uuid_types[int] = class_name.to_s
+        defined_uuid_types[enum] = { class: class_name.to_s, version: version, enum: enum }
       end
     end
   
@@ -54,37 +64,51 @@ module TypedUUID::ActiveRecord
       !!class_to_uuid_type_cache[self.base_class]
     end
     
-    def typed_uuid
-      TypedUUID.uuid(uuid_type_from_class(self))
+    def typed_uuid(**options)
+      TypedUUID.uuid(uuid_enum_from_class(self), uuid_version_from_class(self), **options)
     end
-  
-    def uuid_type_from_table_name(table)
-      uuid_type_from_class(class_from_table_name(table))
+    
+    def uuid_enum_from_table_name(table)
+      uuid_enum_from_class(class_from_table_name(table))
     end
 
-    def uuid_type_from_class(klass)
+    def uuid_version_from_table_name(table)
+      uuid_version_from_class(class_from_table_name(table))
+    end
+  
+    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
 
-      type
+      type[:version]
     end
-  
-    def class_from_uuid_type(type)
-      klass = if uuid_type_to_class_cache.has_key?(type)
-        uuid_type_to_class_cache[type]
+
+    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?
-        
-          uuid_type_to_class_cache[defined_uuid_types.key(klass.name)] = klass
+      
+          if key = defined_uuid_types.find { |enum, info| info[:class] == klass.name }
+            uuid_enum_to_class_cache[key[0]] = klass
+          end
         end
       
-        uuid_type_to_class_cache[type]
+        uuid_enum_to_class_cache[enum]
       end
     end
   
@@ -101,7 +125,7 @@ module TypedUUID::ActiveRecord
     end
   
     def class_from_uuid(uuid)
-      class_from_uuid_type(TypedUUID.enum(uuid))
+      class_from_uuid_enum(TypedUUID.enum(uuid))
     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

@@ -2,16 +2,17 @@ class TypedUUID::Railtie < Rails::Railtie
 
   initializer :typed_uuid do |app|
     ActiveRecord::Tasks::DatabaseTasks.migrations_paths << File.expand_path('../../../db/migrate', __FILE__)
-    
+
     ActiveSupport.on_load(:active_record) do
       ActiveRecord::Base.include TypedUUID::ActiveRecord
     end
-    
+
     require 'active_record/connection_adapters/postgresql/schema_definitions'
     ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include(TypedUUID::PsqlColumnMethods)
-    
+
+    require 'active_record/connection_adapters/abstract/schema_dumper'
     require 'active_record/connection_adapters/postgresql/schema_dumper'
     ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend(TypedUUID::PsqlSchemaDumper)
   end
 
-end
+end

data/lib/typed_uuid/version.rb

@@ -1,3 +1,3 @@
 module TypedUUID
-  VERSION = '3.2'
+  VERSION = '4.1'
 end

data/lib/typed_uuid.rb

@@ -1,17 +1,92 @@
+require 'digest/sha1'
+
 module TypedUUID
   autoload :ActiveRecord, 'typed_uuid/active_record'
   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
-  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)
+
+  class << self
+
+    def uuid(enum, version = 4, **options)
+      if enum < 0 || enum > 8_191
+        raise ArgumentError, "UUID type must be between 0 and 8,191"
+      end
+
+      case version
+      when 1
+        timestamp_uuid(enum, **options)
+      when 3
+        namebased_uuid(enum, digester: Digest::MD5, **options)
+      when 4
+        random_uuid(enum, **options)
+      when 5
+        namebased_uuid(enum, digester: Digest::SHA1, **options)
+      end
+    end
+
+    def 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 timestamp_uuid(enum, timestamp: nil, sequence: nil)
+      timestamp  ||= Time.now
+
+      uuid = [timestamp.to_i * 1_000_000 + timestamp.usec].pack('Q>')[1..-1]
+      uuid << if sequence.nil?
+        SecureRandom.random_bytes(8)
+      elsif sequence.is_a?(Integer)
+        sequence = [sequence].pack("Q>")
+        if sequence.bytesize == 8 && sequence[0..1] == "\x00\x00"
+          sequence[2..]
+        else
+          raise ArgumentError, 'Sequence is more than 6 bytes'
+        end
+      elsif sequence.is_a?(String)
+        raise ArgumentError, 'Sequence is more than 6 bytes' if sequence.bytesize > 6
+        sequence.b
+      else
+        raise ArgumentError, 'Unable to convert sequence to binary'
+      end
+      uuid << SecureRandom.random_bytes(4)
+
+      uuid = uuid.unpack("nnnnnnnn")
+      uuid[7] = (uuid[2] ^ uuid[6]) ^ ((enum << 3) | 1)
+      "%04x%04x-%04x-%04x-%04x-%04x%04x%04x" % uuid
+    end
+
+    def namebased_uuid(enum, digester:, name:, namespace: "")
+      uuid = digester.digest(name + namespace).unpack("nnnnnnnn")
+      uuid[7] = (uuid[2] ^ uuid[6]) ^ ((enum << 3) | 5)
+      "%04x%04x-%04x-%04x-%04x-%04x%04x%04x" % uuid
+    end
+
+    def enum(uuid)
+      uuid = uuid.gsub('-', '')
+      ((uuid[8..11].to_i(16) ^ uuid[24..27].to_i(16)) ^ uuid[28..31].to_i(16)) >> 3
+    end
+
+    def 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 timestamp(uuid)
+      uuid = uuid.gsub('-', '')
+      Time.at(*uuid[0..13].to_i(16).divmod(1_000_000), :usec)
+    end
+
+    def sequence_b(uuid)
+      uuid = uuid.gsub('-', '')
+      uuid[14..25].scan(/.{4}/).map{|i| i.to_i(16) }.pack('n*').b
+    end
+    
+    def sequence(uuid)
+      ("\x00\x00" + sequence_b(uuid)).unpack1('Q>')
+    end
+
   end
 end
 

data/test/test_helper.rb

@@ -32,7 +32,7 @@ def MiniTest.filter_backtrace(bt)
   bt
 end
 class ActiveSupport::TestCase
-  
+
   # File 'lib/active_support/testing/declarative.rb'
   def self.test(name, &block)
     test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
@@ -46,31 +46,32 @@ class ActiveSupport::TestCase
       end
     end
   end
-  
+
   def self.schema(&block)
     self.class_variable_set(:@@schema, block)
   end
-  
+
   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_type_to_class_cache.clear
+      ActiveRecord::Base.uuid_enum_to_class_cache.clear
       ActiveRecord::Base.class_to_uuid_type_cache.clear
-      
+
       configuration = {
         adapter:  "postgresql",
         database: "uuid-types-test",
         encoding: "utf8"
       }.stringify_keys
-  
-      db_tasks = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(configuration)
-      db_tasks.purge
-    
+
       ActiveRecord::Base.establish_connection(configuration)
+
+      db_tasks = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(ActiveRecord::Base.connection_db_config)
+      db_tasks.purge
+
       ActiveRecord::Migration.suppress_messages do
         AddTypedUuidFunction.migrate :up
-        
+
         if self.class.class_variable_defined?(:@@schema)
           ActiveRecord::Schema.define(&self.class.class_variable_get(:@@schema))
           ActiveRecord::Migration.execute("SELECT c.relname FROM pg_class c WHERE c.relkind = 'S'").each_row do |row|
@@ -134,7 +135,7 @@ class ActiveSupport::TestCase
       end
     end
   end
-  
+
   class SQLLogger
     class << self
       attr_accessor :ignored_sql, :log, :log_all
@@ -197,5 +198,5 @@ class ActiveSupport::TestCase
   alias :assert_not_predicate :refute_predicate
   alias :assert_not_respond_to :refute_respond_to
   alias :assert_not_same :refute_same
-  
-end
+
+end

data/test/typed_uuid_test.rb

@@ -1,46 +1,49 @@
 require 'test_helper'
 
-class FilterTest < ActiveSupport::TestCase
+class UUIDTest < ActiveSupport::TestCase
 
   schema do
     ActiveRecord::Base.register_uuid_types({
-      'FilterTest::Listing'  => 0,
-      'FilterTest::Building' => 592,
-      'FilterTest::SkyScraper' => 1_952
+      'UUIDTest::Listing'  => {enum: 0, version: 1},
+      'UUIDTest::Building' => 592,
+      'UUIDTest::SkyScraper' => {enum: 1_952}
     })
-    
+
     create_table :listings, id: :typed_uuid do |t|
       t.string   "name", limit: 255
     end
-    
+
     create_table :buildings, id: :typed_uuid do |t|
       t.string   "name", limit: 255
       t.string   "type", limit: 255
     end
   end
-  
+
   class Listing < ActiveRecord::Base
   end
-  
+
   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({
-      1 => 'FilterTest::Property'
+      1 => 'UUIDTest::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
@@ -52,48 +55,139 @@ 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({
+      'UUIDTest::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::SkyScraper, ::ActiveRecord::Base.class_from_uuid(SkyScraper.typed_uuid)
-    
+    assert_equal 512, TypedUUID.enum(TypedUUID.uuid(512, 1))
+    assert_equal 512, TypedUUID.enum(TypedUUID.uuid(512, 3, name: "test"))
+    assert_equal 512, TypedUUID.enum(TypedUUID.uuid(512, 5, name: "test"))
+    assert_equal UUIDTest::Listing,    ::ActiveRecord::Base.class_from_uuid(Listing.typed_uuid)
+    assert_equal UUIDTest::Building,   ::ActiveRecord::Base.class_from_uuid(Building.typed_uuid)
+    assert_equal UUIDTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid(SkyScraper.typed_uuid)
+
     assert_raises ArgumentError do
       ::ActiveRecord::Base.class_from_uuid(SingleFamilyHome.typed_uuid)
     end
   end
+
+  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' do
+  test 'typed_uuid v1 with a timestamp' do
+    time = Time.at(1606612254, 370979, :usec)
+    uuid = TypedUUID.uuid(592, 1, timestamp: time)
+
+    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 'typed_uuid v1 with sequence as a string' do
+    uuid = TypedUUID.uuid(592, 1, sequence: '123456')
+
+    assert_equal 1,               TypedUUID.version(uuid)
+    assert_equal 592,             TypedUUID.enum(uuid)
+    assert_equal 54091677185334,  TypedUUID.sequence(uuid)
+    assert_equal '123456',        TypedUUID.sequence_b(uuid)
+
+    assert_equal Listing, ::ActiveRecord::Base.class_from_uuid(Listing.typed_uuid)
+  end
+  
+  test 'typed_uuid v1 with sequence as a integer' do
+    uuid = TypedUUID.uuid(592, 1, sequence: 123456)
+
+    assert_equal 1,                         TypedUUID.version(uuid)
+    assert_equal 592,                       TypedUUID.enum(uuid)
+    assert_equal 123456,                    TypedUUID.sequence(uuid)
+    assert_equal "\x00\x00\x00\x01\xE2@".b, TypedUUID.sequence_b(uuid)
+
+    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_equal UUIDTest::Listing, ::ActiveRecord::Base.class_from_uuid(listing.id)
+    assert_equal UUIDTest::Building, ::ActiveRecord::Base.class_from_uuid(building.id)
+    assert_equal UUIDTest::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_type from class' do
-    assert_equal 0, ::ActiveRecord::Base.uuid_type_from_class(Listing)
-    assert_equal 0, ::ActiveRecord::Base.uuid_type_from_class(Listing)
-    assert_equal 592, ::ActiveRecord::Base.uuid_type_from_class(Building)
-    assert_equal 1_952, ::ActiveRecord::Base.uuid_type_from_class(SkyScraper)
+
+  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 '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)
-    assert_equal FilterTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid_type(1_952)
+
+  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
-  
-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_enum' do
+    assert_equal UUIDTest::Listing, ::ActiveRecord::Base.class_from_uuid_enum(0)
+    assert_equal UUIDTest::Building, ::ActiveRecord::Base.class_from_uuid_enum(592)
+    assert_equal UUIDTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid_enum(1_952)
+  end
+
+end

data/typed_uuid.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # Developoment 
+  # Developoment
   s.add_development_dependency 'rake'
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'minitest'
@@ -23,9 +23,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'mocha'
   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 'rails', '>= 6.1.0'
   s.add_development_dependency 'pg'
-  
+
   # Runtime
-  s.add_runtime_dependency 'activerecord', '>= 6.0.0'
-end
+  s.add_runtime_dependency 'activerecord', '>= 6.1.0'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed_uuid
 version: !ruby/object:Gem::Version
-  version: '3.2'
+  version: '4.1'
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-04 00:00:00.000000000 Z
+date: 2021-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -128,14 +128,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -156,14 +156,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 6.1.0
 description: Typed UUIDs 2 bytes are reserved in the UUID for the class enum
 email:
 - jonbracy@gmail.com
@@ -171,6 +171,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".tm_properties"
 - Gemfile
@@ -205,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Typed UUIDs for ActiveRecord