typed_uuid 2.1 → 3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0743664e3f9987059821b25c8c42f80b062bbeeb3ba563e795d4b9845920505
-  data.tar.gz: ec150decbaced84ca8cbd26b06af761551969ee9cc74145291c552215ab2a94b
+  metadata.gz: c9b97eecee8303b2863faf3982c4080d347c9dabc4b0fca45c2c5dc7c74b6172
+  data.tar.gz: 72d70bc0bc247987141c6ee4710a5ef34257693179b1d526dcc6fbf427e414f5
 SHA512:
-  metadata.gz: e3e66ca9962d22a9ccece4458708c132e776062dc5d10071b715816c4c5329a99c6bea6b172e0f33a55c274a761e0850c1cb4a957b31de2124f3942d60204aa3
-  data.tar.gz: 502b8f036034be6a080aa0722b26918810589fc741666d2ab4f0c125d987895bc2ba19ab886b79ff13b97e38b50698808dbc28eb80d2b1d822c1dda055f89ad3
+  metadata.gz: 204697bd0dc2c7dd64b62dc7b7955cb5d83242c5966bc447c84d79d343f3b0825cc8bd1bb450525a3acc3405a61a1740b06f127a9df6f5f5830f9a063a75f18a
+  data.tar.gz: cba9d2425930e678e4c44bfc163392fb749c249f5e2930b62998f22fae5ad10cdaa9e8df5df013b6155eac8c1c242056e4ff67b65dfb63140f82f545b24d38d4

data/README.md

@@ -33,24 +33,27 @@ 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,
+  Building:                 512,
+  'Building::SkyScrpaer' => 65_535
 })
 
 # Or:
 
 ActiveRecord::Base.register_uuid_types({
-  0 		=> :listings,
-  65_535 	=> :buildings
+  0         => :Listing,
+  512       => :Building,
+  65_535    => 'Building::SkyScrpaer'
 })
 ```
 
+
 ## Usage
 
 In your migrations simply replace `id: :uuid` with `id: :typed_uuid` when creating
@@ -64,4 +67,12 @@ class CreateProperties < ActiveRecord::Migration[5.2]
     end
   end
 end
-```
+```
+
+## STI Models
+When using STI Model Rails will generate the UUID to be inserted. This UUID will
+be calculated of the STI Model class and not the base class.
+
+In the migration you can still used `id: :typed_uuid`, this will use the base
+class to calculated the default type for the UUID. You could also set the
+`id` to `:uuid` and the `default` to `false` so when no ID is given it will error.

data/db/migrate/20191222234546_add_typed_uuid_function.rb

@@ -1,18 +1,20 @@
 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 $$
-        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;
-      $$ LANGUAGE plpgsql;
-    SQL
+      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;
+        $$ LANGUAGE plpgsql;
+      SQL
+    end
   end
-end
+end

data/lib/typed_uuid.rb

@@ -2,6 +2,17 @@ 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)
+  end
 end
 
 require 'typed_uuid/railtie' if defined? Rails

data/lib/typed_uuid/active_record.rb

@@ -1,67 +1,108 @@
+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|
+      hash[klass] = defined_uuid_types.key(klass.name)
+    })
+    class_attribute(:uuid_type_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, 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,
+          class_name: class_name,
+          other: defined_uuid_types[int]
+        }
       else
-        register_uuid_type(k, v)
+        defined_uuid_types[int] = class_name.to_s
+      end
+    end
+  
+    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
-  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 typed?
+      !!class_to_uuid_type_cache[self.base_class]
     end
     
-    type
-  end
+    def typed_uuid
+      TypedUUID.uuid(uuid_type_from_class(self))
+    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_type_from_table_name(table)
+      uuid_type_from_class(class_from_table_name(table))
+    end
+
+    def uuid_type_from_class(klass)
+      type = class_to_uuid_type_cache[klass]
 
-      ::ActiveRecord::Base.descendants.select do |klass|
+      if type.nil?
+        raise ArgumentError, "UUID Type for \"#{klass.name}\" not defined"
+      end
+
+      type
+    end
+  
+    def class_from_uuid_type(type)
+      klass = if uuid_type_to_class_cache.has_key?(type)
+        uuid_type_to_class_cache[type]
+      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
+        end
+      
+        uuid_type_to_class_cache[type]
+      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)
-    uuid = uuid.gsub('-', '')
-    class_from_uuid_type((uuid[8..11].to_i(16) ^ uuid[16..19].to_i(16)) ^ uuid[12..15].to_i(16))
+    def class_from_uuid(uuid)
+      class_from_uuid_type(TypedUUID.enum(uuid))
+    end
   end
   
 end

data/lib/typed_uuid/psql_column_methods.rb

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

data/lib/typed_uuid/railtie.rb

@@ -4,12 +4,13 @@ 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'    
+    require 'active_record/connection_adapters/postgresql/schema_definitions'
     ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include(TypedUUID::PsqlColumnMethods)
     
+    require 'active_record/connection_adapters/postgresql/schema_dumper'
     ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaDumper.prepend(TypedUUID::PsqlSchemaDumper)
   end
 

data/lib/typed_uuid/version.rb

@@ -1,3 +1,3 @@
 module TypedUUID
-  VERSION = '2.1'
+  VERSION = '3.2'
 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'
@@ -50,7 +52,12 @@ class ActiveSupport::TestCase
   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.class_to_uuid_type_cache.clear
+      
       configuration = {
         adapter:  "postgresql",
         database: "uuid-types-test",
@@ -75,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: 65_535
+      'FilterTest::Listing'  => 0,
+      'FilterTest::Building' => 592,
+      'FilterTest::SkyScraper' => 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,23 @@ class FilterTest < ActiveSupport::TestCase
   
   class Building < ActiveRecord::Base
   end
+  
+  class SkyScraper < Building
+  end
 
+  class SingleFamilyHome < Building
+  end
+  
+  class Property < ActiveRecord::Base
+  end
+  
   test 'adding primary key as a typed_uuid in a migration' do
     ActiveRecord::Base.register_uuid_types({
-      properties: 1
+      1 => 'FilterTest::Property'
     })
 
     exprexted_sql = <<-SQL
-      CREATE TABLE "properties" ("id" uuid DEFAULT typed_uuid('\\x1000') NOT NULL PRIMARY KEY, "name" character varying(255))
+      CREATE TABLE "properties" ("id" uuid DEFAULT typed_uuid('\\x0001') NOT NULL PRIMARY KEY, "name" character varying(255))
     SQL
 
     assert_sql exprexted_sql do
@@ -41,23 +52,48 @@ class FilterTest < ActiveSupport::TestCase
     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_raises ArgumentError do
+      ::ActiveRecord::Base.class_from_uuid(SingleFamilyHome.typed_uuid)
+    end
+  end
+  
   test 'class_from uuid' do
     listing = Listing.create
     building = Building.create
+    skyscraper = SkyScraper.create
     
     assert_equal FilterTest::Listing, ::ActiveRecord::Base.class_from_uuid(listing.id)
     assert_equal FilterTest::Building, ::ActiveRecord::Base.class_from_uuid(building.id)
+    assert_equal FilterTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid(skyscraper.id)
+
+    assert_raises ArgumentError do
+      SingleFamilyHome.create
+    end
   end
   
   test 'uuid_type from table_name' do
     assert_equal 0, ::ActiveRecord::Base.uuid_type_from_table_name(:listings)
     assert_equal 0, ::ActiveRecord::Base.uuid_type_from_table_name('listings')
-    assert_equal 65_535, ::ActiveRecord::Base.uuid_type_from_table_name(:buildings)
+    assert_equal 592, ::ActiveRecord::Base.uuid_type_from_table_name(:buildings)
+  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)
   end
   
   test 'class from uuid_type' do
     assert_equal FilterTest::Listing, ::ActiveRecord::Base.class_from_uuid_type(0)
-    assert_equal FilterTest::Building, ::ActiveRecord::Base.class_from_uuid_type(65_535)
+    assert_equal FilterTest::Building, ::ActiveRecord::Base.class_from_uuid_type(592)
+    assert_equal FilterTest::SkyScraper, ::ActiveRecord::Base.class_from_uuid_type(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.1'
+  version: '3.2'
 platform: ruby
 authors:
 - Jon Bracy
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-24 00:00:00.000000000 Z
+date: 2020-11-04 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
@@ -205,8 +205,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Typed UUIDs for ActiveRecord
 test_files: