typed_uuid 4.0 → 4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb375ca568f121a2a996b9afd41123e18b820621e4417b2bce05024364eef414
-  data.tar.gz: 15d885d11a1dbcb19ca60733312ad0b21bcf77a0f9ce165ce8b25fa24f43cecf
+  metadata.gz: 4f970db2e5a0edffaa90e664113f7cc9ecde9a1c217301cb53f132994e74a18d
+  data.tar.gz: 8762a572a7b9ade2cecdb282a90b6fe030ad547305207c7c616674dd4772ace3
 SHA512:
-  metadata.gz: 38c295658ce41fac5b51c27fdb4df1922ef426e71c2bb234e7af0e0b87abdb11e8110c3e4604e84909f30aa4a3fd2782b740b443aae9ee926fc7ad567a31a8f6
-  data.tar.gz: 42139374aa96e9a43b5f0f7d749a410617fa14c1affd0fa334e1fe59661189fb58d911b26056aa9e5cc6092709db6ab62541c88f788be54cfe946f45bca5868c
+  metadata.gz: 662ddc5ed10e7a43eff50ff0aadf4ada9d43490f2c5370045aa2e4f41a64ef5d58cb8cc33cb8452104106de51a30abf6d950766a8bf8d019fa329e4716bbd689
+  data.tar.gz: 6ba7853a8853d37479d5eba8e11ca48d3b64e0c98ff7b1dd05ad9c1c635d2c3d34be06da4219ff76ca68d232d93ed88b4b01428b3e570342096d27961024307d

data/.github/workflows/ci.yml

@@ -1,28 +1,49 @@
 name: CI
 
-on:
+on: 
   push:
-    branches: [ master ]
   pull_request:
-    branches: [ master ]
+    types: [opened]
 
 jobs:
   test:
     name: TypedUUID Test
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        rails-version:
+          - 7.0.8
+          - 7.1.2
+        ruby-version:
+          - 3.0
+          - 3.1
+          - 3.2
+        postgres-version:
+          - 15
 
     steps:
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 3.0
+      - name: Install Postgresql
+        run: |
+          sudo apt-get -y --purge remove $(sudo apt list --installed | grep postgresql | awk '{print $1}')
+          sudo apt-get install curl ca-certificates gnupg
+          curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
+          sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
+          sudo apt-get update
+          sudo apt-get -y install postgresql-${{ matrix.postgres-version }}-postgis-3
+          sudo systemctl start postgresql@${{ matrix.postgres-version }}-main.service
+          sudo systemctl status postgresql@${{ matrix.postgres-version }}-main.service
+          sudo pg_lsclusters
+          sudo -u postgres createuser runner --superuser
+          sudo -u postgres psql -c "ALTER USER runner WITH PASSWORD 'runner';"
 
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
       - run: |
-          sudo systemctl start postgresql.service
-          sudo -u postgres createuser runner --superuser
-          sudo -u postgres createdb uuid-types-test
+          echo 'gem "rails", "${{ matrix.rails-version }}"' >> Gemfile
 
-      - run: bundle
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
 
       - run: bundle exec rake test

data/Gemfile

@@ -1,3 +1,3 @@
 source "https://rubygems.org"
 
-gemspec
+gemspec

data/README.md

@@ -31,9 +31,9 @@ Typed UUID will give us back the ENUM and Version of the Type using soley the UU
 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.
+             representing the microseconds since epoch. Followed by 56 random
+             bits or a sequence counter. 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
@@ -70,7 +70,7 @@ ActiveRecord::Base.register_uuid_types({
 ActiveRecord::Base.register_uuid_types({
   0         => :Listing,
   512       => :Building,
-  8_191    => 'Building::SkyScrpaer'
+  8_191     => 'Building::SkyScrpaer'
 })
 ```
 
@@ -83,7 +83,7 @@ a table.
 ```ruby
 class CreateProperties < ActiveRecord::Migration[5.2]
   def change
-	create_table :properties, id: :typed_uuid do |t|
+    create_table :properties, id: :typed_uuid do |t|
       t.string "name", limit: 255
     end
   end
@@ -116,6 +116,12 @@ class UpdateProperties < ActiveRecord::Migration[6.1]
   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.

data/db/migrate/20191222234546_add_typed_uuid_function.rb

@@ -12,8 +12,8 @@ class AddTypedUuidFunction < ActiveRecord::Migration[6.0]
         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')
+                lpad(right(to_hex((extract(epoch from clock_timestamp())*1000000)::bigint), 14), 14, '0'),
+                encode(gen_random_bytes(9), 'hex')
             ), 'hex');
           ELSE
             bytes := gen_random_bytes(16);

data/lib/typed_uuid/active_record.rb

@@ -117,10 +117,7 @@ module TypedUUID::ActiveRecord
       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?
-
-        klass.table_name == table
+        (klass.table_name || klass.send(:compute_table_name)) == table
       end
     end
   

data/lib/typed_uuid/psql_column_methods.rb

@@ -4,7 +4,6 @@ module TypedUUID::PsqlColumnMethods
     if type == :typed_uuid
       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(#{klass_type_enum}, #{klass_type_version})" }
       super(name, :uuid, **options)
     else

data/lib/typed_uuid/psql_schema_dumper.rb

@@ -14,8 +14,8 @@ module TypedUUID::PsqlSchemaDumper
     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')
+            lpad(right(to_hex((extract(epoch from clock_timestamp())*1000000)::bigint), 14), 14, '0'),
+            encode(gen_random_bytes(9), 'hex')
         ), 'hex');
       ELSE
         bytes := gen_random_bytes(16);

data/lib/typed_uuid/railtie.rb

@@ -1,7 +1,7 @@
 class TypedUUID::Railtie < Rails::Railtie
 
   initializer :typed_uuid do |app|
-    ActiveRecord::Tasks::DatabaseTasks.migrations_paths << File.expand_path('../../../db/migrate', __FILE__)
+    ActiveRecord::Tasks::DatabaseTasks.migrations_paths << TypedUUID::MIGRATIONS_PATH
 
     ActiveSupport.on_load(:active_record) do
       ActiveRecord::Base.include TypedUUID::ActiveRecord

data/lib/typed_uuid/version.rb

@@ -1,3 +1,3 @@
 module TypedUUID
-  VERSION = '4.0'
+  VERSION = '4.2'
 end

data/lib/typed_uuid.rb

@@ -1,6 +1,8 @@
 require 'digest/sha1'
 
 module TypedUUID
+  MIGRATIONS_PATH = File.expand_path('../../db/migrate', __FILE__)
+  
   autoload :ActiveRecord, 'typed_uuid/active_record'
   autoload :PsqlColumnMethods, 'typed_uuid/psql_column_methods'
   autoload :PsqlSchemaDumper, 'typed_uuid/psql_schema_dumper'
@@ -35,10 +37,25 @@ module TypedUUID
       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 << if sequence.nil?
+        SecureRandom.random_bytes(8)
+      elsif sequence.is_a?(Integer)
+        sequence = [sequence].pack("Q>")
+        if sequence.bytesize == 8 && sequence[0] == "\x00"
+          sequence[1..]
+        else
+          raise ArgumentError, 'Sequence must be less than 8 bytes'
+        end
+      elsif sequence.is_a?(String)
+        raise ArgumentError, 'Sequence must be less than 8 bytes' if sequence.bytesize > 7
+        sequence.b
+      else
+        raise ArgumentError, 'Unable to convert sequence to binary'
+      end
+      uuid << "\x00\x00"
 
       uuid = uuid.unpack("nnnnnnnn")
-      uuid[7] = (uuid[2] ^ uuid[6]) ^ ((enum << 3) | 1)
+      uuid[7] = ((uuid[2] ^ uuid[6]) ^ ((enum << 3) | 1))
       "%04x%04x-%04x-%04x-%04x-%04x%04x%04x" % uuid
     end
 
@@ -63,6 +80,15 @@ module TypedUUID
       Time.at(*uuid[0..13].to_i(16).divmod(1_000_000), :usec)
     end
 
+    def sequence_b(uuid)
+      uuid = uuid.gsub('-', '')
+      uuid[14..30].scan(/.{4}/).map{|i| i.to_i(16) }.pack('n*').b[0..-2]
+    end
+
+    def sequence(uuid)
+      ("\x00" + sequence_b(uuid)).unpack1('Q>')
+    end
+
   end
 end
 

data/test/database_function_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+class DatabaseFunctionTest < ActiveSupport::TestCase
+
+  schema do
+    ActiveRecord::Base.register_uuid_types({
+      'DatabaseFunctionTest::Ship'  => {enum: 13, version: 1}
+    })
+
+    create_table :ships, id: :typed_uuid do |t|
+      t.string   "name", limit: 255
+    end
+  end
+
+  class Ship < ActiveRecord::Base
+  end
+
+  class Sailor < ActiveRecord::Base
+  end
+
+  class Sea < ActiveRecord::Base
+  end
+
+  class ApplicationRecord < ActiveRecord::Base
+    primary_abstract_class
+  end
+
+  class Bird < ApplicationRecord
+    self.abstract_class = true
+  end
+  
+  class Emu < Bird
+  end
+
+  test 'adding primary key as a typed_uuid in a migration' do
+    ActiveRecord::Base.register_uuid_types({
+      1 => 'DatabaseFunctionTest::Sailor'
+    })
+
+    exprexted_sql = <<-SQL
+      CREATE TABLE "sailors" ("id" uuid DEFAULT typed_uuid(1, 4) NOT NULL PRIMARY KEY, "name" character varying(255))
+    SQL
+
+    assert_sql exprexted_sql do
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.create_table :sailors, id: :typed_uuid do |t|
+          t.string   "name",                    limit: 255
+        end
+      end
+    end
+  end
+
+  test 'adding primary key as a typed_uuid in a migration with a version' do
+    ActiveRecord::Base.register_uuid_types({
+      'DatabaseFunctionTest::Sea' => {version: 1, enum: 512}
+    })
+
+    exprexted_sql = <<-SQL
+      CREATE TABLE "seas" ("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 :seas, id: :typed_uuid do |t|
+          t.string   "name",                    limit: 255
+        end
+      end
+    end
+  end
+
+  test 'adding primary key as a typed_uuid in a migration to a STI table' do
+    ActiveRecord::Base.register_uuid_types({
+      30 => 'DatabaseFunctionTest::Bird',
+      31 => 'DatabaseFunctionTest::Emu'
+    })
+
+    exprexted_sql = <<-SQL
+      CREATE TABLE "birds" ("id" uuid DEFAULT typed_uuid(30, 4) NOT NULL PRIMARY KEY, "name" character varying(255))
+    SQL
+    
+    assert_sql exprexted_sql do
+      ActiveRecord::Migration.suppress_messages do
+        ActiveRecord::Migration.create_table :birds, id: :typed_uuid do |t|
+          t.string   "name",                    limit: 255
+        end
+      end
+    end
+  end
+
+  test 'typed_uuid(enum)' do
+    uuid = ActiveRecord::Base.connection.execute('SELECT typed_uuid(13) AS uuid')[0]['uuid']
+    
+    assert_equal 13,                           TypedUUID.enum(uuid)
+    assert_equal 4,                            TypedUUID.version(uuid)
+    assert_equal DatabaseFunctionTest::Ship,   ::ActiveRecord::Base.class_from_uuid(uuid)
+  end
+
+  test 'typed_uuid(enum, 4)' do
+    uuid = ActiveRecord::Base.connection.execute('SELECT typed_uuid(13, 4) AS uuid')[0]['uuid']
+    
+    assert_equal 13,                          TypedUUID.enum(uuid)
+    assert_equal 4,                           TypedUUID.version(uuid)
+    assert_equal DatabaseFunctionTest::Ship,  ::ActiveRecord::Base.class_from_uuid(uuid)
+  end
+
+  test 'typed_uuid(enum, 1)' do
+    time = Time.now
+    uuid = ActiveRecord::Base.connection.execute('SELECT typed_uuid(13, 1) AS uuid')[0]['uuid']
+    
+    assert_equal  13,                          TypedUUID.enum(uuid)
+    assert_equal  1,                           TypedUUID.version(uuid)
+    assert        (time.ceil(0) - TypedUUID.timestamp(uuid).ceil(0)).abs <= 1
+    assert_equal  DatabaseFunctionTest::Ship,  ::ActiveRecord::Base.class_from_uuid(uuid)
+  end
+
+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'
@@ -67,7 +65,8 @@ class ActiveSupport::TestCase
       ActiveRecord::Base.establish_connection(configuration)
 
       db_tasks = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(ActiveRecord::Base.connection_db_config)
-      db_tasks.purge
+      db_tasks.drop
+      db_tasks.create
 
       ActiveRecord::Migration.suppress_messages do
         AddTypedUuidFunction.migrate :up
@@ -103,18 +102,15 @@ class ActiveSupport::TestCase
     if patterns_to_match.all? { |s| s.is_a?(String) } && patterns_to_match.size > 1
       assert_equal(*patterns_to_match.take(2).map { |sql| sql.gsub(/( +|\n\s*|\s+)/, ' ').strip })
     else
-      begin
-        ret_value = nil
-        capture_sql { ret_value = yield }
-        ret_value
-      ensure
-        patterns_to_match.map! {|p| p.is_a?(String) ? p.gsub(/( +|\n\s*|\s+)/, ' ').strip : p }
-        failed_patterns = []
-        patterns_to_match.each do |pattern|
-          failed_patterns << pattern unless SQLLogger.log_all.any?{ |sql| pattern === sql.gsub(/( +|\n\s*|\s+)/, ' ').strip }
-        end
-        assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLLogger.log.size == 0 ? '' : "\nQueries:\n#{SQLLogger.log.join("\n")}"}"
+      ret_value = nil
+      capture_sql { ret_value = yield }
+      patterns_to_match.map! {|p| p.is_a?(String) ? p.gsub(/( +|\n\s*|\s+)/, ' ').strip : p }
+      failed_patterns = []
+      patterns_to_match.each do |pattern|
+        failed_patterns << pattern unless SQLLogger.log_all.any?{ |sql| pattern === sql.gsub(/( +|\n\s*|\s+)/, ' ').strip }
       end
+      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{SQLLogger.log.size == 0 ? '' : "\nQueries:\n#{SQLLogger.log.join("\n")}"}"
+      ret_value
     end
   end
 

data/test/typed_uuid_test.rb

@@ -103,6 +103,52 @@ class UUIDTest < ActiveSupport::TestCase
     assert_equal Listing, ::ActiveRecord::Base.class_from_uuid(Listing.typed_uuid)
   end
 
+  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: '1234567')
+
+    assert_equal 1,               TypedUUID.version(uuid)
+    assert_equal 592,             TypedUUID.enum(uuid)
+    assert_equal '1234567',           TypedUUID.sequence_b(uuid)
+    assert_equal 13847469359445559, TypedUUID.sequence(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\x00\x01\xE2@".b, TypedUUID.sequence_b(uuid)
+
+    assert_equal Listing, ::ActiveRecord::Base.class_from_uuid(Listing.typed_uuid)
+
+    [0, 1, 72057594037927935].each do |seq|
+      uuid = TypedUUID.uuid(592, 1, sequence: seq)
+      assert_equal seq,                    TypedUUID.sequence(uuid)
+    end
+
+    assert_raises ArgumentError do
+      TypedUUID.uuid(592, 1, sequence: 72057594037927936)
+    end
+  end
+
   test 'class_from uuid generated bye PostgresQL' do
     listing = Listing.create
     building = Building.create

data/typed_uuid.gemspec

@@ -22,10 +22,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'simplecov'
   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 'activesupport', '>= 7.0.0'
+  s.add_development_dependency 'rails', '>= 7.0.0'
   s.add_development_dependency 'pg'
 
   # Runtime
-  s.add_runtime_dependency 'activerecord', '>= 6.0.0'
+  s.add_runtime_dependency 'activerecord', '>= 7.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typed_uuid
 version: !ruby/object:Gem::Version
-  version: '4.0'
+  version: '4.2'
 platform: ruby
 authors:
 - Jon Bracy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-02 00:00:00.000000000 Z
+date: 2023-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -114,28 +114,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.0.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: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.0.0
 description: Typed UUIDs 2 bytes are reserved in the UUID for the class enum
 email:
 - jonbracy@gmail.com
@@ -185,6 +185,7 @@ files:
 - lib/typed_uuid/psql_schema_dumper.rb
 - lib/typed_uuid/railtie.rb
 - lib/typed_uuid/version.rb
+- test/database_function_test.rb
 - test/test_helper.rb
 - test/typed_uuid_test.rb
 - typed_uuid.gemspec
@@ -206,10 +207,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.4.13
 signing_key:
 specification_version: 4
 summary: Typed UUIDs for ActiveRecord
 test_files:
+- test/database_function_test.rb
 - test/test_helper.rb
 - test/typed_uuid_test.rb