activeuuid 0.3.0 → 0.4.0

data/.rspec

@@ -1,3 +1,4 @@
 --colour
 --format documentation
 --backtrace
+--order random

data/.travis.yml

@@ -0,0 +1,27 @@
+before_script:
+  - mysql -e 'create database activeuuid_test;'
+  - psql -c 'create database activeuuid_test;' -U postgres
+
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - rbx-19mode
+
+gemfile:
+  - Gemfile
+  - gemfiles/Gemfile.rails-3-1
+  - gemfiles/Gemfile.rails-3-2
+  - gemfiles/Gemfile.rails-head
+
+env:
+  - DB=sqlite3
+  - DB=mysql
+  - DB=postgresql
+
+matrix:
+  allow_failures:
+    - gemfile: gemfiles/Gemfile.rails-head
+  exclude:
+    - rvm: 1.9.2
+      gemfile: gemfiles/Gemfile.rails-head

data/Gemfile

@@ -2,3 +2,5 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in activeuuid.gemspec
 gemspec
+
+gem "activerecord"

data/README.mkd

@@ -1,6 +1,8 @@
+[![Build Status](https://travis-ci.org/jashmenn/activeuuid.png)](http://travis-ci.org/jashmenn/activeuuid)
+
 # activeuuid
 
-Add `binary(16)` UUIDs to ActiveRecord. 
+Add `binary(16)` UUIDs to ActiveRecord.
 
 ## Example
 
@@ -48,20 +50,15 @@ require 'spec_helper'
 describe Email do
 
   context "when using uuid's as keys" do
-    before(:each) do
-      Email.delete_all
-      @guid = "1dd74dd0-d116-11e0-99c7-5ac5d975667e"
-      @e = Email.new(:subject => "hello", :body => "world") {|e| e.id = UUIDTools::UUID.parse(@guid) }
-      @e.save
-    end
+    let(:guid) { "1dd74dd0-d116-11e0-99c7-5ac5d975667e" }
+    let(:email) { Fabricate :email }
 
     it "the id guid should be equal to the uuid" do
-      @e.id.to_s.should eql(@guid)
+      email.id.to_s.should eql(guid)
     end
 
     it "should be able to find an email by the uuid" do
-      f = Email.find(UUIDTools::UUID.parse(@guid))
-      f.id.to_s.should eql(@guid)
+      Email.find(guid).id.to_s.should == guid
     end
 
   end
@@ -73,9 +70,9 @@ end
 From [2]:
 
 > [Here is a] UUID:  1e8ef774-581c-102c-bcfe-f1ab81872213
-> 
+>
 > A UUID like the one above is 36 characters long, including dashes.  If you store this VARCHAR(36), you're going to decrease compare performance dramatically.  This is your primary key, you don't want it to be slow.
-> 
+>
 > At its bit level, a UUID is 128 bits, which means it will fit into
 > 16 bytes, note this is not very human readable, but it will keep
 > storage low, and is only 4 times larger than a 32-bit int, or 2
@@ -98,10 +95,9 @@ application the keys are represented by a UUIDTools::UUID object.
 * more transparent support for natural and composite keys
 * support for MySQLs `INSERT ... ON DUPLICATE KEY UPDATE` syntax
 * support a primary column name other than `id`
-* work on other databases (Postgres, etc)
 * tests
 
-## Inspiration 
+## Inspiration
 James Golick's `friendly` is a great gem for NoSQL on MySQL. It's
 a great gateway drug to systems like Cassandra for teams that are
 already familiar with the ins-and-outs of MySQL.
@@ -114,35 +110,17 @@ Add this to your `Gemfile`
 
 Or get the code here: https://github.com/jashmenn/activeuuid
 
-## Notes
-
-### Fixtures
-
-You can use `activeuuid` in fixtures by using the `!!binary` directive in YAML.
-The trick is to base64 encode the raw bytes of the hexdigest.
-
-```yaml
-    devin_ifttt_new_tweet:         
-      id: !!binary "<%= Base64.encode64(UUIDTools::UUID.parse_hexdigest('2D79B402CBA811E1AA7C14DAE903E06A').raw) %>"
-      data:
-        user_id: 1
-        source_id: 1               
-        recipe_id: 1               
-        created_at: Mon, 09 Jul 2012 14:06:21 -0700 
-        body: Nice blog entry!
-```
 
 ## References
 * [1] http://bret.appspot.com/entry/how-friendfeed-uses-mysql
-* [2] http://kekoav.com/blog/36-computers/58-uuids-as-primary-keys-in-mysql.html 
+* [2] http://kekoav.com/blog/36-computers/58-uuids-as-primary-keys-in-mysql.html
 * [3] https://gist.github.com/937739
 * [4] http://www.codinghorror.com/blog/2007/03/primary-keys-ids-versus-guids.html
 * [5] http://krow.livejournal.com/497839.html
 * [6] https://github.com/jamesgolick/friendly
 
 ## Dependencies
-Rails ~> 3.1.0 - It uses the custom column serialization Aaron
-Patterson introduced in Rails 3.1.
+Rails ~> 3.1.0
 
 ## Author
 

data/Rakefile

@@ -4,3 +4,5 @@ require 'rspec/core'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/activeuuid.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = Activeuuid::VERSION
   s.authors     = ["Nate Murray"]
   s.email       = ["nate@natemurray.com"]
-  s.homepage    = "http://www.eigenjoy.com"
+  s.homepage    = "https://github.com/jashmenn/activeuuid"
   s.summary     = %q{Add binary UUIDs to ActiveRecord in MySQL}
   s.description = %q{Add binary (not string) UUIDs to ActiveRecord in MySQL}
 
@@ -27,5 +27,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "mysql2"
 
   s.add_runtime_dependency "uuidtools"
-  s.add_runtime_dependency "activerecord"
+  s.add_runtime_dependency "activerecord", '>= 3.1'
 end

data/gemfiles/Gemfile.rails-3-1

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec path: '../'
+
+gem 'activerecord', '~> 3.1.0'

data/gemfiles/Gemfile.rails-3-2

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec path: '../'
+
+gem 'activerecord', '~> 3.2.0'

data/gemfiles/Gemfile.rails-head

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec path: '../'
+
+gem 'activerecord', github: 'rails/rails'

data/lib/activeuuid/patches.rb

@@ -1,9 +1,12 @@
+require 'active_record'
+require 'active_support/concern'
+
+
 module ActiveUUID
   module Patches
     module Migrations
-      def uuid(*args)
-        options = args.extract_options!
-        column_names = args
+      def uuid(*column_names)
+        options = column_names.extract_options!
         column_names.each do |name|
           type = @base.adapter_name.downcase == 'postgresql' ? 'uuid' : 'binary(16)'
           column(name, "#{type}#{' PRIMARY KEY' if options.delete(:primary_key)}", options)
@@ -11,22 +14,65 @@ module ActiveUUID
       end
     end
 
+    module Column
+      extend ActiveSupport::Concern
+
+      included do
+        def type_cast_with_uuid(value)
+          return UUIDTools::UUID.serialize(value) if type == :uuid
+          type_cast_without_uuid(value)
+        end
+
+        def type_cast_code_with_uuid(var_name)
+          return "UUIDTools::UUID.serialize(#{var_name})" if type == :uuid
+          type_cast_code_without_uuid(var_name)
+        end
+
+        def simplified_type_with_uuid(field_type)
+          return :uuid if field_type == 'binary(16)'
+          simplified_type_without_uuid(field_type)
+        end
+
+        alias_method_chain :type_cast, :uuid
+        alias_method_chain :type_cast_code, :uuid
+        alias_method_chain :simplified_type, :uuid
+      end
+    end
+
+    module PostgreSQLColumn
+      extend ActiveSupport::Concern
+
+      included do
+        def simplified_type_with_pguuid(field_type)
+          return :uuid if field_type == 'uuid'
+          simplified_type_without_pguuid(field_type)
+        end
+
+        alias_method_chain :simplified_type, :pguuid
+      end
+    end
+
     module Quoting
       extend ActiveSupport::Concern
 
       included do
         def quote_with_visiting(value, column = nil)
-          value = ActiveUUID::UUIDSerializer.new.load(value) if column && column.sql_type == 'binary(16)'
+          value = UUIDTools::UUID.serialize(value) if column && column.type == :uuid
           quote_without_visiting(value, column)
         end
 
         def type_cast_with_visiting(value, column = nil)
-          value = ActiveUUID::UUIDSerializer.new.load(value) if column && column.sql_type == 'binary(16)'
+          value = UUIDTools::UUID.serialize(value) if column && column.type == :uuid
           type_cast_without_visiting(value, column)
         end
 
+        def native_database_types_with_uuid
+          @native_database_types ||= native_database_types_without_uuid.merge(uuid: { name: 'binary', limit: 16 })
+        end
+
         alias_method_chain :quote, :visiting
         alias_method_chain :type_cast, :visiting
+        alias_method_chain :native_database_types, :uuid
       end
     end
 
@@ -35,24 +81,35 @@ module ActiveUUID
 
       included do
         def quote_with_visiting(value, column = nil)
-          value = ActiveUUID::UUIDSerializer.new.load(value).to_s if column && column.sql_type == 'uuid'
+          value = UUIDTools::UUID.serialize(value) if column && column.type == :uuid
+          value = value.to_s if value.is_a? UUIDTools::UUID
           quote_without_visiting(value, column)
         end
 
         def type_cast_with_visiting(value, column = nil)
-          value = ActiveUUID::UUIDSerializer.new.load(value).to_s if column && column.sql_type == 'uuid'
+          value = UUIDTools::UUID.serialize(value) if column && column.type == :uuid
+          value = value.to_s if value.is_a? UUIDTools::UUID
           type_cast_without_visiting(value, column)
         end
 
+        def native_database_types_with_pguuid
+          @native_database_types ||= native_database_types_without_pguuid.merge(uuid: { name: 'uuid' })
+        end
+
         alias_method_chain :quote, :visiting
         alias_method_chain :type_cast, :visiting
+        alias_method_chain :native_database_types, :pguuid
       end
     end
 
     def self.apply!
       ActiveRecord::ConnectionAdapters::Table.send :include, Migrations if defined? ActiveRecord::ConnectionAdapters::Table
       ActiveRecord::ConnectionAdapters::TableDefinition.send :include, Migrations if defined? ActiveRecord::ConnectionAdapters::TableDefinition
-      ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter.send :include, Quoting if defined? ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
+
+      ActiveRecord::ConnectionAdapters::Column.send :include, Column
+      ActiveRecord::ConnectionAdapters::PostgreSQLColumn.send :include, PostgreSQLColumn if defined? ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+
+      ActiveRecord::ConnectionAdapters::Mysql2Adapter.send :include, Quoting if defined? ActiveRecord::ConnectionAdapters::Mysql2Adapter
       ActiveRecord::ConnectionAdapters::SQLite3Adapter.send :include, Quoting if defined? ActiveRecord::ConnectionAdapters::SQLite3Adapter
       ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :include, PostgreSQLQuoting if defined? ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
     end

data/lib/activeuuid/uuid.rb

@@ -1,10 +1,13 @@
 require 'uuidtools'
 
+# monkey-patch Friendly::UUID to serialize UUIDs
 module UUIDTools
   class UUID
-    # monkey-patch Friendly::UUID to serialize UUIDs to MySQL
     alias_method :id, :raw
 
+    # duck typing activerecord 3.1 dirty hack )
+    def gsub *; self; end
+
     def quoted_id
       s = raw.unpack("H*")[0]
       "x'#{s}'"
@@ -17,6 +20,30 @@ module UUIDTools
     def to_param
       hexdigest.upcase
     end
+
+    def self.serialize(value)
+      case value
+      when self
+        value
+      when String
+        parse_string value
+      else
+        nil
+      end
+    end
+
+  private
+
+    def self.parse_string(str)
+      return nil if str.length == 0
+      if str.length == 36
+        parse str
+      elsif str.length == 32
+        parse_hexdigest str
+      else
+        parse_raw str
+      end
+    end
   end
 end
 
@@ -49,89 +76,53 @@ module Arel
 end
 
 module ActiveUUID
-  class UUIDSerializer
-    def load(binary)
-      case binary
-      when UUIDTools::UUID
-        binary
-      when String
-        parse_string(binary)
-      else
-        nil
-      end
-    end
-
-    def dump(uuid)
-      case uuid
-      when UUIDTools::UUID
-        uuid.raw
-      when String
-        parse_string(uuid).try(:raw)
-      else
-        nil
-      end
-    end
-
-    private
-
-    def parse_string str
-      return nil if str.blank?
-      if str.length == 36
-        UUIDTools::UUID.parse str
-      elsif str.length == 32
-        UUIDTools::UUID.parse_hexdigest str
-      else
-        UUIDTools::UUID.parse_raw str
-      end
-    end
-  end
-
   module UUID
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :uuid_attributes, :instance_writer => true
-      uuids :id
+      class_attribute :_natural_key, instance_writer: false
+      class_attribute :_uuid_generator, instance_writer: false
+      self._uuid_generator = :random
+
+      singleton_class.alias_method_chain :instantiate, :uuid
       before_create :generate_uuids_if_needed
     end
 
     module ClassMethods
-      def natural_key_attributes
-        @_activeuuid_natural_key_attributes
-      end
-
       def natural_key(*attributes)
-        @_activeuuid_natural_key_attributes = attributes
+        self._natural_key = attributes
       end
 
-      def uuid_generator(generator_name=nil)
-        @_activeuuid_kind = generator_name if generator_name
-        @_activeuuid_kind || :random
+      def uuid_generator(generator_name)
+        self._uuid_generator = generator_name
       end
 
       def uuids(*attributes)
-        self.uuid_attributes = attributes.collect(&:intern).each do |attribute|
-          serialize attribute, ActiveUUID::UUIDSerializer.new
-          # serializing attributes on the fly
-          define_method "#{attribute}=" do |value|
-            write_attribute attribute, serialized_attributes[attribute.to_s].load(value)
-          end
+        ActiveSupport::Deprecation.warn <<-EOS
+          ActiveUUID detects uuid columns independently.
+          There is no more need to use uuid method.
+        EOS
+      end
+
+      def instantiate_with_uuid(record)
+        uuid_columns.each do |uuid_column|
+          record[uuid_column] = UUIDTools::UUID.serialize(record[uuid_column]).to_s if record[uuid_column]
         end
-         #class_eval <<-eos
-         #  # def #{@association_name}
-         #  #   @_#{@association_name} ||= self.class.associations[:#{@association_name}].new_proxy(self)
-         #  # end
-         #eos
+        instantiate_without_uuid(record)
+      end
+
+      def uuid_columns
+        @uuid_columns ||= columns.select { |c| c.type == :uuid }.map(&:name)
       end
     end
 
     def create_uuid
-      if nka = self.class.natural_key_attributes
+      if _natural_key
         # TODO if all the attributes return nil you might want to warn about this
-        chained = nka.collect{|a| self.send(a).to_s}.join("-")
+        chained = _natural_key.map { |attribute| self.send(attribute) }.join('-')
         UUIDTools::UUID.sha1_create(UUIDTools::UUID_OID_NAMESPACE, chained)
       else
-        case self.class.uuid_generator
+        case _uuid_generator
         when :random
           UUIDTools::UUID.random_create
         when :time
@@ -141,8 +132,9 @@ module ActiveUUID
     end
 
     def generate_uuids_if_needed
-      (uuid_attributes & [self.class.primary_key.intern]).each do |attr|
-        self.send("#{attr}=", create_uuid) unless self.send(attr)
+      primary_key = self.class.primary_key
+      if self.class.columns_hash[primary_key].type == :uuid
+        send("#{primary_key}=", create_uuid) unless send("#{primary_key}?")
       end
     end
 

data/lib/activeuuid/version.rb

@@ -1,3 +1,3 @@
 module Activeuuid
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/lib/activerecord_spec.rb

@@ -1,16 +1,78 @@
 require 'spec_helper'
 
+describe ActiveRecord::Base do
+  context '.connection' do
+    let!(:connection) { ActiveRecord::Base.connection }
+    let(:table_name) { :test_uuid_field_creation }
+
+    before do
+      connection.drop_table(table_name) if connection.table_exists?(table_name)
+      connection.create_table(table_name)
+    end
+
+    after do
+      connection.drop_table table_name
+    end
+
+    specify { connection.table_exists?(table_name).should be_true }
+
+    context '#add_column' do
+      let(:column_name) { :uuid_column }
+      let(:column) { connection.columns(table_name).detect { |c| c.name.to_sym == column_name } }
+
+      before { connection.add_column table_name, column_name, :uuid }
+
+      specify { connection.column_exists?(table_name, column_name).should be_true }
+      specify { column.should_not be_nil }
+
+      it 'should have proper sql type' do
+        spec_for_adapter do |adapters|
+          adapters.sqlite3 { column.sql_type.should == 'binary(16)' }
+          adapters.mysql2 { column.sql_type.should == 'binary(16)' }
+          adapters.postgresql { column.sql_type.should == 'uuid' }
+        end
+      end
+    end
+
+    context '#change_column' do
+      let(:column_name) { :string_col }
+      let(:column) { connection.columns(table_name).detect { |c| c.name.to_sym == column_name } }
+
+      before do
+        connection.add_column table_name, column_name, :string
+        spec_for_adapter do |adapters|
+          adapters.sqlite3 { connection.change_column table_name, column_name, :uuid }
+          adapters.mysql2 { connection.change_column table_name, column_name, :uuid }
+          # adapters.postgresql { connection.change_column table_name, column_name, :uuid }
+        end
+      end
+
+      it 'support changing type from string to uuid' do
+        spec_for_adapter do |adapters|
+          adapters.sqlite3 { column.sql_type.should == 'binary(16)' }
+          adapters.mysql2 { column.sql_type.should == 'binary(16)' }
+          adapters.postgresql { pending('postgresql can`t change column type to uuid') }
+        end
+      end
+    end
+
+  end
+end
+
 describe Article do
   let!(:article) { Fabricate :article }
   let(:id) { article.id }
   let(:model) { Article }
+  subject { model }
+
+  context 'model' do
+    its(:all) { should == [article] }
+    its(:first) { should == article }
+  end
 
   context 'existance' do
-    specify { article.id.should be_a Integer }
-    it "should create record" do
-      model.all.should == [article]
-      model.first.should == article
-    end
+    subject { article }
+    its(:id) { should be_a Integer }
   end
 
   context '.find' do
@@ -18,28 +80,40 @@ describe Article do
   end
 
   context '.where' do
-    specify { model.where(:id => id).first.should == article }
+    specify { model.where(id: id).first.should == article }
   end
 
-  context '.destroy' do
-    specify { article.delete.should be_true }
-    specify { article.destroy.should be_true }
+  context '#destroy' do
+    subject { article }
+    its(:delete) { should be_true }
+    its(:destroy) { should be_true }
   end
 end
 
 describe UuidArticle do
   let!(:article) { Fabricate :uuid_article }
-  let(:id) { article.id }
-  let(:model) { UuidArticle }
+  let!(:id) { article.id }
+  let(:model) { described_class }
+  subject { model }
 
-  specify { model.primary_key.should == 'id' }
+  context 'model' do
+    its(:primary_key) { should == 'id' }
+    its(:all) { should == [article] }
+    its(:first) { should == article }
+  end
 
   context 'existance' do
-    specify { article.id.should be_a UUIDTools::UUID }
-    it "should create record" do
-      model.all.should == [article]
-      model.first.should == article
-    end
+    subject { article }
+    its(:id) { should be_a UUIDTools::UUID }
+  end
+
+  context 'interpolation' do
+    specify { model.where("id = :id", id: article.id) }
+  end
+
+  context 'batch interpolation' do
+    before { model.update_all(["title = CASE WHEN id = :id THEN 'Passed' ELSE 'Nothing' END", id: article.id]) }
+    specify { article.reload.title.should == 'Passed' }
   end
 
   context '.find' do
@@ -50,14 +124,64 @@ describe UuidArticle do
   end
 
   context '.where' do
-    specify { model.where(:id => article).first.should == article }
-    specify { model.where(:id => id).first.should == article }
-    specify { model.where(:id => id.to_s).first.should == article }
-    specify { model.where(:id => id.raw).first.should == article }
+    specify { model.where(id: article).first.should == article }
+    specify { model.where(id: id).first.should == article }
+    specify { model.where(id: id.to_s).first.should == article }
+    specify { model.where(id: id.raw).first.should == article }
   end
 
-  context '.destroy' do
-    specify { article.delete.should be_true }
-    specify { article.destroy.should be_true }
+  context '#destroy' do
+    subject { article }
+    its(:delete) { should be_true }
+    its(:destroy) { should be_true }
+  end
+
+  context '#reload' do
+    subject { article }
+    its(:'reload.id') { should == id }
+    specify { subject.reload(:select => :another_uuid).id.should == id }
+  end
+
+  context 'columns' do
+    [:id, :another_uuid].each do |column|
+      context column do
+        subject { model.columns_hash[column.to_s] }
+        its(:type) { should == :uuid }
+      end
+    end
+  end
+
+  context 'typecasting' do
+    let(:uuid) { UUIDTools::UUID.random_create }
+    let(:string) { uuid.to_s }
+    context 'primary' do
+      before { article.id = string }
+      specify do
+        article.id.should == uuid
+        article.id_before_type_cast.should == string
+      end
+      specify do
+        article.id_before_type_cast.should == string
+        article.id.should == uuid
+      end
+    end
+
+    context 'non-primary' do
+      before { article.another_uuid = string }
+      specify do
+        article.another_uuid.should == uuid
+        article.another_uuid_before_type_cast.should == string
+      end
+      specify do
+        article.another_uuid_before_type_cast.should == string
+        article.another_uuid.should == uuid
+      end
+      specify do
+        article.save
+        article.reload
+        article.another_uuid_before_type_cast.should == string
+        article.another_uuid.should == uuid
+      end
+    end
   end
 end

data/spec/lib/uuid_mokeypatch_spec.rb

@@ -1,37 +1,29 @@
 require 'spec_helper'
 
 describe UUIDTools::UUID do
+  let(:input) { "e4618518-cb9f-11e1-aa7c-14dae903e06a" }
+  let(:hex) { "E4618518CB9F11E1AA7C14DAE903E06A" }
+  let(:uuid) { described_class.parse input }
 
-  before do
-    input = "e4618518-cb9f-11e1-aa7c-14dae903e06a"
-    @sql_out = "x'e4618518cb9f11e1aa7c14dae903e06a'"
-    @param_out = "E4618518CB9F11E1AA7C14DAE903E06A"
+  context 'instance methods' do
+    subject { uuid }
+    let(:sql_out) { "x'e4618518cb9f11e1aa7c14dae903e06a'" }
 
-    @uuid = UUIDTools::UUID.parse input
+    its(:quoted_id) {should == sql_out}
+    its(:as_json) {should == hex}
+    its(:to_param) {should == hex}
   end
 
-  it 'adds methods to the UUID class' do
-    [:quoted_id, :as_json, :to_param].each do |meth|
-      @uuid.should respond_to(meth)
-    end
+  describe '.serialize' do
+    subject { described_class }
+    let(:raw) { uuid.raw }
+
+    specify { subject.serialize(uuid).should == uuid }
+    specify { subject.serialize(input).should == uuid }
+    specify { subject.serialize(hex).should == uuid }
+    specify { subject.serialize(raw).should == uuid }
+    specify { subject.serialize(nil).should be_nil }
+    specify { subject.serialize('').should be_nil }
+    specify { subject.serialize(5).should be_nil }
   end
-
-  describe '#quoted_id' do
-    it 'returns the SQL binary representation for the uuid' do
-      @uuid.quoted_id.should eql(@sql_out)
-    end
-  end
-
-  describe '#as_json' do
-    it 'returns the uppercase hexdigest' do
-      @uuid.as_json.should eql(@param_out)
-    end
-  end
-
-  describe '#to_param' do
-    it 'also returns the uppercase hexdigest' do
-      @uuid.to_param.should eql(@param_out)
-    end
-  end
-
 end

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ ActiveRecord::Base.establish_connection(ENV["DB"] || "sqlite3")
 require 'activeuuid'
 
 ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + "/support/migrate")
+ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, STDOUT)
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 Dir["#{File.dirname(__FILE__)}/fabricators/**/*.rb"].each { |f| require f }
@@ -38,4 +39,10 @@ RSpec.configure do |config|
   config.after(:each) do
     DatabaseCleaner.clean
   end
+
+  def spec_for_adapter(&block)
+    switcher = ActiveUUID::SpecSupport::SpecForAdapter.new()
+    yield switcher
+    switcher.run(connection)
+  end
 end

data/spec/support/database.yml

@@ -3,13 +3,10 @@ sqlite3:
   database: ":memory:"
 postgresql:
   adapter: postgresql
-  username: postgres
-  password:
+  host: localhost
   database: activeuuid_test
-  min_messages: ERROR
 mysql:
   adapter: mysql2
-  host: localhost
   username: root
-  password:
-  database: activeuuid_test
+  database: activeuuid_test
+  encoding: utf8

data/spec/support/migrate/20120817081813_create_uuid_articles.rb

@@ -4,6 +4,7 @@ class CreateUuidArticles < ActiveRecord::Migration
       t.uuid :id, :primary_key => true
       t.string :title
       t.text :body
+      t.uuid :another_uuid
 
       t.timestamps
     end

data/spec/support/models/uuid_article.rb

@@ -1,4 +1,3 @@
 class UuidArticle < ActiveRecord::Base
   include ActiveUUID::UUID
-
 end

data/spec/support/spec_for_adapter.rb

@@ -0,0 +1,20 @@
+require 'activeuuid'
+
+module ActiveUUID::SpecSupport
+  class SpecForAdapter
+    def initialize
+      @specs = {}
+    end
+
+    [:sqlite3, :mysql2, :postgresql].each do |name|
+      send :define_method, name do |&block|
+        @specs[name] = block
+      end
+    end
+
+    def run(connection)
+      name = connection.adapter_name.downcase.to_sym
+      @specs[name].call() if(@specs.include? name)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeuuid
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-05 00:00:00.000000000 Z
+date: 2013-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -178,7 +178,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -186,7 +186,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.1'
 description: Add binary (not string) UUIDs to ActiveRecord in MySQL
 email:
 - nate@natemurray.com
@@ -197,10 +197,14 @@ files:
 - .gitignore
 - .rspec
 - .rvmrc
+- .travis.yml
 - Gemfile
 - README.mkd
 - Rakefile
 - activeuuid.gemspec
+- gemfiles/Gemfile.rails-3-1
+- gemfiles/Gemfile.rails-3-2
+- gemfiles/Gemfile.rails-head
 - lib/activeuuid.rb
 - lib/activeuuid/patches.rb
 - lib/activeuuid/railtie.rb
@@ -209,7 +213,6 @@ files:
 - spec/fabricators/article_fabricator.rb
 - spec/fabricators/uuid_article_fabricator.rb
 - spec/lib/activerecord_spec.rb
-- spec/lib/serializer_spec.rb
 - spec/lib/uuid_mokeypatch_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.yml
@@ -217,7 +220,8 @@ files:
 - spec/support/migrate/20120817081813_create_uuid_articles.rb
 - spec/support/models/article.rb
 - spec/support/models/uuid_article.rb
-homepage: http://www.eigenjoy.com
+- spec/support/spec_for_adapter.rb
+homepage: https://github.com/jashmenn/activeuuid
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -231,7 +235,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2357852166137688430
+      hash: 852897539311025223
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -240,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2357852166137688430
+      hash: 852897539311025223
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -251,7 +255,6 @@ test_files:
 - spec/fabricators/article_fabricator.rb
 - spec/fabricators/uuid_article_fabricator.rb
 - spec/lib/activerecord_spec.rb
-- spec/lib/serializer_spec.rb
 - spec/lib/uuid_mokeypatch_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.yml
@@ -259,3 +262,4 @@ test_files:
 - spec/support/migrate/20120817081813_create_uuid_articles.rb
 - spec/support/models/article.rb
 - spec/support/models/uuid_article.rb
+- spec/support/spec_for_adapter.rb

data/spec/lib/serializer_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe ActiveUUID::UUIDSerializer do
-
-  before do
-    @input = "2d79b402-cba8-11e1-aa7c-14dae903e06a"
-    @hex = "2D79B402CBA811E1AA7C14DAE903E06A"
-    @uuid = UUIDTools::UUID.parse @input
-    @raw = @uuid.raw
-    @serializer = ActiveUUID::UUIDSerializer.new
-  end
-
-  describe '#load' do
-    it 'returns a UUID type verbatim' do
-       @serializer.load(@uuid).should eql(@uuid)
-    end
-
-    describe 'loads a given uuid' do
-      it 'handles uuid string' do
-        @serializer.load(@input).should eql(@uuid)
-      end
-
-      it 'handles uuid hexdigest string' do
-        @serializer.load(@hex).should eql(@uuid)
-      end
-
-      it 'handles raw uuid data' do
-        @serializer.load(@raw).should eql(@uuid)
-      end
-    end
-
-    it 'returns nil for nil' do
-      @serializer.load(nil).should be_nil
-    end
-
-    it 'returns nil for ""' do
-      @serializer.load('').should be_nil
-    end
-
-    it 'returns nil for other types' do
-      @serializer.load(5).should be_nil
-    end
-  end
-
-  describe '#dump' do
-    it 'returns the raw value of a passed uuid' do
-      @serializer.dump(@uuid).should eql(@raw)
-    end
-
-    describe 'loads a given uuid' do
-      it 'handles uuid string' do
-        @serializer.dump(@input).should eql(@raw)
-      end
-
-      it 'handles uuid hexdigest string' do
-        @serializer.dump(@hex).should eql(@raw)
-      end
-
-      it 'handles raw uuid data' do
-        @serializer.dump(@raw).should eql(@raw)
-      end
-    end
-
-    it 'returns nil for nil' do
-      @serializer.dump(nil).should be_nil
-    end
-
-    it 'returns nil for ""' do
-      @serializer.dump('').should be_nil
-    end
-
-    it 'returns nil for other types' do
-      @serializer.dump(5).should be_nil
-    end
-  end
-end