typed_uuid 3.2 → 4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9b97eecee8303b2863faf3982c4080d347c9dabc4b0fca45c2c5dc7c74b6172
-  data.tar.gz: 72d70bc0bc247987141c6ee4710a5ef34257693179b1d526dcc6fbf427e414f5
+  metadata.gz: 956d3f40e94a40968f9e66ae955a0eb4ca0a0d5e7c0a307e846a6bc329970108
+  data.tar.gz: 49844d2082da751bc4d36dede69bdd927bb93269a8caadcaee20916a66e56c4f
 SHA512:
-  metadata.gz: 204697bd0dc2c7dd64b62dc7b7955cb5d83242c5966bc447c84d79d343f3b0825cc8bd1bb450525a3acc3405a61a1740b06f127a9df6f5f5830f9a063a75f18a
-  data.tar.gz: cba9d2425930e678e4c44bfc163392fb749c249f5e2930b62998f22fae5ad10cdaa9e8df5df013b6155eac8c1c242056e4ff67b65dfb63140f82f545b24d38d4
+  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
 
@@ -40,8 +51,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 +61,7 @@ ActiveRecord::Base.register_uuid_types({
 ActiveRecord::Base.register_uuid_types({
   0         => :Listing,
   512       => :Building,
-  65_535    => 'Building::SkyScrpaer'
+  8_191    => 'Building::SkyScrpaer'
 })
 ```
 

data/db/migrate/20191222234546_add_typed_uuid_function.rb

@@ -4,15 +4,28 @@ 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(
+                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
     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

@@ -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
   
@@ -55,36 +65,50 @@ module TypedUUID::ActiveRecord
     end
     
     def typed_uuid
-      TypedUUID.uuid(uuid_type_from_class(self))
+      TypedUUID.uuid(uuid_enum_from_class(self), uuid_version_from_class(self))
     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/version.rb

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

data/test/test_helper.rb

@@ -28,9 +28,7 @@ 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'
@@ -55,7 +53,7 @@ class ActiveSupport::TestCase
     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 = {

data/test/typed_uuid_test.rb

@@ -4,9 +4,9 @@ class FilterTest < ActiveSupport::TestCase
 
   schema do
     ActiveRecord::Base.register_uuid_types({
-      'FilterTest::Listing'  => 0,
+      'FilterTest::Listing'  => {enum: 0, version: 1},
       'FilterTest::Building' => 592,
-      'FilterTest::SkyScraper' => 1_952
+      'FilterTest::SkyScraper' => {enum: 1_952}
     })
     
     create_table :listings, id: :typed_uuid do |t|
@@ -34,13 +34,16 @@ class FilterTest < ActiveSupport::TestCase
   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'
     })
 
     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,6 +55,24 @@ 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)
@@ -63,7 +84,23 @@ class FilterTest < ActiveSupport::TestCase
     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
@@ -77,23 +114,41 @@ class FilterTest < ActiveSupport::TestCase
     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 '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)
-    assert_equal FilterTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid_type(1_952)
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed_uuid
 version: !ruby/object:Gem::Version
-  version: '3.2'
+  version: 4.0.rc1
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-04 00:00:00.000000000 Z
+date: 2020-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -201,9 +201,9 @@ 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.1.4
 signing_key: