gold-record 0.1.0 → 0.2.0

data/HISTORY.rdoc

@@ -1,4 +1,16 @@
-=== Version 0.1.0 (git)
+=== Version 0.2.0 (2009-12-06)
+
+This version replaces ID generation and parsing code from UUIDTools with smaller/faster implementation using pack and SecureRandom directly.
+
+NOTE: #to_param now generates hex UUIDs *without* dashes. This is a slight change in behavior from 0.1.0. Hex-encoded UUIDs with dashes are still supported by #find.
+
+* #find supports binary, Base64, hex and dash-delimited hex UUID strings as input.
+* Support for varied UUID encodings is implemented in GoldRecord::UUID.coerce.
+* ID parsing is about 36x faster on my machine (see extras/benchmark-uuidtools-vs-pack).
+* Initial support for URL-safe Base64 encoding.
+* #to_param is no longer patched using alias_method_chain. This prevents interfering with models using a specific #to_param implementation.
+
+=== Version 0.1.0 (2009-10-01)
 
 This is the first preview release of GoldRecord, an extension for ActiveRecord that implements unobtrusive support for binary UUIDs.
 

data/Rakefile

@@ -18,9 +18,6 @@ GEM_NAME      = File.join(File.dirname(__FILE__), "#{PKG_NAME}-#{PKG_VERSION}.ge
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
 
-RUBY_FORGE_PROJECT = "gold-record"
-RUBY_FORGE_USER    = "ydnar"
-
 MYSQL_DB_USER = 'root'
 
 PKG_FILES = FileList[
@@ -62,7 +59,7 @@ task :rebuild_mysql_databases => 'mysql:rebuild_databases'
 
 Rake::RDocTask.new { |rdoc|
   rdoc.rdoc_dir = 'doc'
-  rdoc.title    = "GoldRecord -- Object-relation mapping put on rails"
+  rdoc.title    = "GoldRecord — Unobtrusive binary UUID support for ActiveRecord"
   rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
   rdoc.options << '--charset' << 'utf-8'
   rdoc.template = ENV['template'] ? "#{ENV['template']}.rb" : '../doc/template/horo'
@@ -78,7 +75,7 @@ dist_dirs = [ "lib", "test" ]
 spec = Gem::Specification.new do |s|
   s.name = PKG_NAME
   s.version = PKG_VERSION
-  s.summary = "Binary UUID support for ActiveRecord"
+  s.summary = "Unobtrusive binary UUID support for ActiveRecord"
   s.description = "Unobtrusive binary UUID support for ActiveRecord. Supports migrations, reflections, assocations and SchemaDumper."
   s.author = "Randy Reddig"
   s.email = "randy@shaderlab.com"
@@ -118,6 +115,9 @@ spec = Gem::Specification.new do |s|
   end
 end
 
+"Default gem task"
+task :gem => "gem:build"
+
 namespace :gem do
   desc "Print gemspec"
   task :spec do

data/lib/gold_record.rb

@@ -21,6 +21,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'gold_record/uuid'
 require 'gold_record/base'
 require 'gold_record/fixtures'
 require 'gold_record/connection_adapters/mysql_adapter'

data/lib/gold_record/base.rb

@@ -1,3 +1,4 @@
+require 'active_record'
 require 'uuidtools'
 
 module GoldRecord
@@ -5,21 +6,13 @@ module GoldRecord
     def gold_record?
       true
     end
-    
-    def coerce_id(id)
-      if id.is_a?(String) && id.size == 16
-        id
-      else
-        UUIDTools::UUID.parse(id).raw rescue nil
-      end
-    end
 
     def find_one_with_uuid(id, options)
-      find_one_without_uuid(coerce_id(id), options)
+      find_one_without_uuid(GoldRecord::UUID.coerce(id), options)
     end
 
     def find_some_with_uuid(ids, options)
-      ids = ids.map { |id| coerce_id(id) }
+      ids = ids.map { |id| GoldRecord::UUID.coerce(id) }
       ids = ids.uniq # must do this after coercion
       find_some_without_uuid(ids, options)
     end
@@ -29,14 +22,13 @@ module GoldRecord
     def to_uuid
       UUIDTools::UUID.parse_raw(id) rescue nil
     end
-
-    def to_param_with_uuid
-      uuid = to_uuid
-      uuid ? uuid.to_param : nil
+    
+    def to_param
+      (id = self.id) ? GoldRecord::UUID.encode_hex(id) : nil
     end
 
     def generate_id!
-      self[self.class.primary_key] ||= UUIDTools::UUID.random_create.raw
+      self[self.class.primary_key] ||= GoldRecord::UUID.random_generate
     end
   end
 
@@ -48,7 +40,6 @@ module GoldRecord
         alias_method_chain :find_some, :uuid
       end
       include InstanceMethods
-      alias_method_chain :to_param, :uuid
       before_create :generate_id!
     end
   end

data/lib/gold_record/uuid.rb

@@ -0,0 +1,40 @@
+require 'securerandom'
+
+module GoldRecord
+  module UUID
+    def self.random_generate
+      SecureRandom.random_bytes(16)
+    end
+  
+    def self.coerce(value)
+      return nil unless value.kind_of?(String)
+      if value.size == 22
+        value = urlsafe_decode64(value)
+      elsif value.size == 32 || value.size == 36
+        value = decode_hex(value)
+      end
+      value = nil unless value.size == 16
+      value
+    end
+  
+    def self.encode_hex(bin)
+      bin.unpack("H*").first
+    end
+  
+    def self.decode_hex(str)
+      [str.delete("-")].pack("H*")
+    end
+
+    # Slightly modified backport from Ruby 1.9
+    # http://www.ruby-doc.org/ruby-1.9/classes/Base64.html
+    # Strips padding char (=) and newlines from end of encoded string.
+  
+    def self.urlsafe_encode64(bin)
+      [bin].pack("m").tr("+/=", "-_ ").strip.delete("\n")
+    end
+
+    def self.urlsafe_decode64(str)
+      "#{str.tr("-_", "+/")}===".unpack("m").first
+    end
+  end
+end

data/lib/gold_record/version.rb

@@ -1,7 +1,7 @@
 module GoldRecord
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/test/cases/coerce_test.rb

@@ -0,0 +1,43 @@
+require 'cases/helper'
+
+class CoerceTest < ActiveRecord::TestCase
+  def test_coerce_with_nil
+    assert_equal nil, GoldRecord::UUID.coerce(nil)
+  end
+
+  def test_coerce_with_false
+    assert_equal nil, GoldRecord::UUID.coerce(false)
+  end
+
+  def test_coerce_with_integer
+    assert_equal nil, GoldRecord::UUID.coerce(12345)
+  end
+
+  def test_coerce_with_empty_string
+    assert_equal nil, GoldRecord::UUID.coerce("")
+  end
+
+  def test_coerce_with_bogus_string
+    assert_equal nil, GoldRecord::UUID.coerce("BOGUS")
+  end
+
+  def test_coerce_with_22_character_bogus_string
+    assert_equal nil, GoldRecord::UUID.coerce("~" * 22)
+  end
+
+  def test_coerce_with_36_character_bogus_string
+    assert_equal nil, GoldRecord::UUID.coerce("~" * 36)
+  end
+
+  def test_coerce_with_binary_uuid
+    assert_equal NULL_UUID_RAW, GoldRecord::UUID.coerce(NULL_UUID_RAW)
+  end
+
+  def test_coerce_with_hex_uuid
+    assert_equal NULL_UUID_RAW, GoldRecord::UUID.coerce(NULL_UUID_HEX)
+  end
+
+  def test_coerce_with_base64_uuid
+    assert_equal NULL_UUID_RAW, GoldRecord::UUID.coerce(NULL_UUID_BASE64)
+  end
+end

data/test/cases/find_test.rb

@@ -7,11 +7,21 @@ class FindTest < ActiveRecord::TestCase
   def test_find_with_one_binary_uuid
     artist = Artist.find identify(:michael_jackson)
     assert artist.instance_of?(Artist)
+    assert_equal "Michael Jackson", artist.name
   end
 
   def test_find_with_one_hex_uuid
     artist = Artist.find identify_hex(:michael_jackson)
     assert artist.instance_of?(Artist)
+    assert_equal "Michael Jackson", artist.name
+  end
+
+  def test_find_with_one_base64_uuid
+    assert_equal GoldRecord::UUID.coerce(identify(:michael_jackson)),
+      GoldRecord::UUID.coerce(identify_base64(:michael_jackson))
+    artist = Artist.find identify_base64(:michael_jackson)
+    assert artist.instance_of?(Artist)
+    assert_equal "Michael Jackson", artist.name
   end
 
   def test_find_with_multiple_binary_uuids
@@ -38,11 +48,23 @@ class FindTest < ActiveRecord::TestCase
     end
   end
 
+  def test_find_with_multiple_base64_uuids
+    artists = Artist.find([
+      identify_base64(:method_man),
+      identify_base64(:beatles),
+      identify_base64(:warren_g),
+    ])
+    assert_equal 3, artists.size
+    artists.each do |artist|
+      assert artist.instance_of?(Artist)
+    end
+  end
+
   def test_find_with_multiple_mixed_uuids
     artists = Artist.find([
-      identify_hex(:beatles),
-      identify(:michael_jackson),
-      identify_hex(:warren_g),
+      identify(:beatles),
+      identify_hex(:michael_jackson),
+      identify_base64(:warren_g),
     ])
     assert_equal 3, artists.size
     artists.each do |artist|
@@ -58,6 +80,9 @@ class FindTest < ActiveRecord::TestCase
       identify_hex(:beatles),
       identify_hex(:method_man),
       identify_hex(:warren_g),
+      identify_base64(:beatles),
+      identify_base64(:method_man),
+      identify_base64(:warren_g),
     ])
     assert_equal 3, artists.size
     artists.each do |artist|

data/test/cases/helper.rb

@@ -21,8 +21,9 @@ Fixtures.send :include, GoldRecord::Fixtures
 
 # UUID composed of all null bytes
 NULL_UUID_RAW = ("\000" * 16).freeze
-NULL_UUID = UUIDTools::UUID.parse_raw(NULL_UUID_RAW)
-NULL_UUID_HEX = NULL_UUID.to_s
+NULL_UUID = UUIDTools::UUID.parse_raw(NULL_UUID_RAW).freeze
+NULL_UUID_HEX = "00000000-0000-0000-0000-000000000000".freeze
+NULL_UUID_BASE64 = ("A" * 22).freeze
 
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
@@ -79,7 +80,19 @@ class ActiveSupport::TestCase
     Fixtures.identify(label)
   end
   
+  def identify_uuid(label)
+    UUIDTools::UUID.parse_raw(identify(label))
+  end
+  
   def identify_hex(label)
-    UUIDTools::UUID.parse_raw(identify(label)).to_s
+    identify_uuid(label).to_s
+  end
+  
+  def identify_base64(label)
+    raw = [identify_hex(label).gsub(/-/, '')].pack("H*")
+    # puts "Label: #{label}"
+    # puts "UUID:  #{identify_uuid(label)}"
+    # puts "Raw:   #{raw.unpack("H*").first}"
+    GoldRecord::UUID.urlsafe_encode64(raw)
   end
 end

data/test/cases/hex_test.rb

@@ -0,0 +1,65 @@
+require 'cases/helper'
+
+class HexTest < ActiveRecord::TestCase
+  def test_encode_with_nil
+    assert_raise NoMethodError do
+      GoldRecord::UUID.encode_hex(nil)
+    end
+  end
+
+  def test_encode_with_false
+    assert_raise NoMethodError do
+      GoldRecord::UUID.encode_hex(false)
+    end
+  end
+
+  def test_encode_with_number
+    assert_raise NoMethodError do
+      GoldRecord::UUID.encode_hex(12345)
+    end
+  end
+
+  def test_encode_with_null_string
+    assert_equal "0" * 32, GoldRecord::UUID.encode_hex("\000" * 16)
+  end
+
+  def test_decode_with_nil
+    assert_raise NoMethodError do
+      GoldRecord::UUID.decode_hex(nil)
+    end
+  end
+
+  def test_decode_with_false
+    assert_raise NoMethodError do
+      GoldRecord::UUID.decode_hex(false)
+    end
+  end
+
+  def test_decode_with_number
+    assert_raise NoMethodError do
+      GoldRecord::UUID.decode_hex(12345)
+    end
+  end
+
+  def test_decode_with_null_string
+    assert_equal "\000" * 16, GoldRecord::UUID.decode_hex("0" * 32)
+  end
+
+  def test_decode_with_short_strings
+    assert_equal "\000", GoldRecord::UUID.decode_hex("0")
+    assert_equal "\000", GoldRecord::UUID.decode_hex("00")
+    assert_equal "\000\000", GoldRecord::UUID.decode_hex("000")
+    assert_equal "\000\000", GoldRecord::UUID.decode_hex("0000")
+    assert_equal "\000\000\000", GoldRecord::UUID.decode_hex("00000")
+    assert_equal "\000\000\000", GoldRecord::UUID.decode_hex("000000")
+  end
+  
+  def test_symmetry
+    [
+      "a" * 32,
+      "b" * 32,
+    ].each do |value|
+      assert_equal value, GoldRecord::UUID.encode_hex(GoldRecord::UUID.decode_hex(value))
+    end
+  end
+end

data/test/cases/random_generate_test.rb

@@ -0,0 +1,16 @@
+require 'cases/helper'
+
+class RandomGenerateTest < ActiveRecord::TestCase
+  def test_size_of_generated_string
+    assert_equal 16, GoldRecord::UUID.random_generate.size
+  end
+  
+  def test_randomness # This is kind of weak.
+    cache = {}
+    10000.times do
+      value = GoldRecord::UUID.random_generate
+      assert !cache.has_key?(value)
+      cache[value] = true
+    end
+  end
+end

data/test/cases/to_param_test.rb

@@ -15,6 +15,6 @@ class ToParamTest < ActiveRecord::TestCase
     artist = Artist.first
     param = artist.to_param
     assert param.instance_of?(String)
-    assert param.match(/\A[0-9a-f\-]{36}\z/)
+    assert param.match(/\A[0-9a-f]{32}\z/)
   end
 end

data/test/cases/urlsafe_base64_test.rb

@@ -0,0 +1,91 @@
+require 'cases/helper'
+
+class UrlSafeBase64Test < ActiveRecord::TestCase
+  def test_encode_with_nil
+    assert_raise TypeError do
+      GoldRecord::UUID.urlsafe_encode64(nil)
+    end
+  end
+
+  def test_encode_with_false
+    assert_raise TypeError do
+      GoldRecord::UUID.urlsafe_encode64(false)
+    end
+  end
+
+  def test_encode_with_number
+    assert_raise TypeError do
+      GoldRecord::UUID.urlsafe_encode64(12345)
+    end
+  end
+
+  def test_encode_with_null_string
+    assert_equal "A" * 22, GoldRecord::UUID.urlsafe_encode64("\000" * 16)
+  end
+
+  def test_encode_omits_padding_characters
+    assert_no_match /[=]/, GoldRecord::UUID.urlsafe_encode64("\001" * 16)
+  end
+
+  def test_encode_omits_newlines
+    assert_no_match /[\r\n]/, GoldRecord::UUID.urlsafe_encode64("\002" * 16)
+  end
+  
+  def test_translation_of_plus_characters
+    encoded = GoldRecord::UUID.urlsafe_encode64("\x7e" * 16)
+    assert_no_match /[+]/, encoded
+    assert_equal "fn5-fn5-fn5-fn5-fn5-fg", encoded
+  end
+  
+  def test_translation_of_slash_characters
+    encoded = GoldRecord::UUID.urlsafe_encode64("\x7f" * 16)
+    assert_no_match /\//, encoded
+    assert_equal "f39_f39_f39_f39_f39_fw", encoded
+  end
+
+  def test_decode_with_nil
+    assert_raise NoMethodError do
+      GoldRecord::UUID.urlsafe_decode64(nil)
+    end
+  end
+
+  def test_decode_with_false
+    assert_raise NoMethodError do
+      GoldRecord::UUID.urlsafe_decode64(false)
+    end
+  end
+
+  def test_decode_with_number
+    assert_raise NoMethodError do
+      GoldRecord::UUID.urlsafe_decode64(12345)
+    end
+  end
+
+  def test_decode_with_null_string
+    assert_equal "\000" * 16, GoldRecord::UUID.urlsafe_decode64("A" * 22)
+  end
+
+  def test_decode_with_short_strings
+    assert_equal "", GoldRecord::UUID.urlsafe_decode64("A")
+    assert_equal "\000", GoldRecord::UUID.urlsafe_decode64("AA")
+    assert_equal "\000\000", GoldRecord::UUID.urlsafe_decode64("AAA")
+    assert_equal "\000\000\000", GoldRecord::UUID.urlsafe_decode64("AAAA")
+    assert_equal "\000\000\000", GoldRecord::UUID.urlsafe_decode64("AAAAA")
+    assert_equal "\000\000\000\000", GoldRecord::UUID.urlsafe_decode64("AAAAAA")
+  end
+  
+  def test_symmetry
+    [
+      "A" * 22,
+      "BBBBBBBBBBBBBBBBBBBBBA",
+      "CCCCCCCCCCCCCCCCCCCCCA",
+      "aaaaaaaaaaaaaaaaaaaaaQ",
+      "bbbbbbbbbbbbbbbbbbbbbQ",
+      "cccccccccccccccccccccQ",
+      "---------------------w",
+      "_____________________w",
+    ].each do |value|
+      assert_equal value, GoldRecord::UUID.urlsafe_encode64(GoldRecord::UUID.urlsafe_decode64(value))
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gold-record
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Randy Reddig
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-01 00:00:00 +00:00
+date: 2009-12-06 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,6 +61,7 @@ files:
 - lib/gold_record/base.rb
 - lib/gold_record/connection_adapters/mysql_adapter.rb
 - lib/gold_record/fixtures.rb
+- lib/gold_record/uuid.rb
 - lib/gold_record/version.rb
 - lib/gold_record.rb
 - test/cases/aaa_create_tables_test.rb
@@ -72,12 +73,15 @@ files:
 - test/cases/associations/habtm_uuid_to_uuid_association_test.rb
 - test/cases/associations/has_many_integer_assocation_test.rb
 - test/cases/associations/has_many_uuid_association_test.rb
-- test/cases/coerce_id_test.rb
+- test/cases/coerce_test.rb
 - test/cases/find_test.rb
 - test/cases/generate_id_test.rb
 - test/cases/helper.rb
+- test/cases/hex_test.rb
+- test/cases/random_generate_test.rb
 - test/cases/to_param_test.rb
 - test/cases/to_uuid_test.rb
+- test/cases/urlsafe_base64_test.rb
 - test/cases/zzz_migration_test.rb
 - test/config.rb
 - test/connection.rb
@@ -122,6 +126,6 @@ rubyforge_project: gold-record
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Binary UUID support for ActiveRecord
+summary: Unobtrusive binary UUID support for ActiveRecord
 test_files: []
 

data/test/cases/coerce_id_test.rb

@@ -1,20 +0,0 @@
-require 'cases/helper'
-require 'models/artist'
-
-class CoerceIdTest < ActiveRecord::TestCase
-  def test_coerce_id_with_nil
-    assert_nil Artist.coerce_id(nil)
-  end
-
-  def test_coerce_id_with_bogus_data
-    assert_nil Artist.coerce_id("BOGUS")
-  end
-
-  def test_coerce_id_with_binary_uuid
-    assert_equal NULL_UUID_RAW, Artist.coerce_id(NULL_UUID_RAW)
-  end
-
-  def test_coerce_id_with_hex_uuid
-    assert_equal NULL_UUID_RAW, Artist.coerce_id(NULL_UUID.to_s)
-  end
-end