ardb 0.21.0 → 0.22.0

data/Gemfile

@@ -3,9 +3,6 @@ source "https://rubygems.org"
 gemspec
 
 gem 'rake'
-gem 'pry', "~> 0.9.0"
-
-platform :rbx do
-  gem 'rubysl'
-end
+gem 'pry',  "~> 0.9.0"
+gem 'i18n', "< 0.7"
 

data/ardb.gemspec

@@ -18,12 +18,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert",       ["~> 2.10"])
-  gem.add_development_dependency("assert-mocha", ["~> 1.1"])
+  gem.add_development_dependency("assert", ["~> 2.14"])
 
   gem.add_dependency('activerecord',  ["~> 3.2"])
   gem.add_dependency('activesupport', ["~> 3.2"])
   gem.add_dependency('ns-options',    ["~> 1.1"])
-  gem.add_dependency('scmd',          ["~> 2.2"])
+  gem.add_dependency('scmd',          ["~> 2.3"])
 
 end

data/lib/ardb/record_spy.rb

@@ -1,3 +1,6 @@
+require 'arel'
+require 'ardb/relation_spy'
+
 module Ardb
 
   module RecordSpy
@@ -19,13 +22,16 @@ module Ardb
     module ClassMethods
 
       attr_accessor :table_name
-      attr_reader :associations, :callbacks, :validations
+
+      # Associations
+
+      def associations
+        @associations ||= []
+      end
 
       [ :belongs_to, :has_one, :has_many ].each do |method_name|
 
         define_method(method_name) do |assoc_name, *args|
-          @associations ||= []
-
           define_method(assoc_name) do
             instance_variable_get("@#{assoc_name}") || (method_name == :has_many ? [] : nil)
           end
@@ -33,57 +39,140 @@ module Ardb
             instance_variable_set("@#{assoc_name}", value)
           end
 
-          @associations << Association.new(method_name, assoc_name, *args)
+          self.associations << Association.new(method_name, assoc_name, *args)
         end
 
       end
 
-      [ :validates_acceptance_of, :validates_confirmation_of,
-        :validates_exclusion_of,  :validates_format_of, :validates_inclusion_of,
-        :validates_length_of, :validates_numericality_of,
-        :validates_presence_of, :validates_size_of, :validates_uniqueness_of
+      # Validations
+
+      def validations
+        @validations ||= []
+      end
+
+      [ :validates_acceptance_of,
+        :validates_confirmation_of,
+        :validates_exclusion_of,
+        :validates_format_of,
+        :validates_inclusion_of,
+        :validates_length_of,
+        :validates_numericality_of,
+        :validates_presence_of,
+        :validates_size_of,
+        :validates_uniqueness_of
       ].each do |method_name|
         type = method_name.to_s.match(/\Avalidates_(.+)_of\Z/)[1]
 
         define_method(method_name) do |*args|
-          @validations ||= []
-          @validations << Validation.new(type, *args)
+          self.validations << Validation.new(type, *args)
         end
 
       end
 
       def validates_associated(*args)
-        @validations ||= []
-        @validations << Validation.new(:associated, *args)
+        self.validations << Validation.new(:associated, *args)
       end
 
       def validates_with(*args)
-        @validations ||= []
-        @validations << Validation.new(:with, *args)
+        self.validations << Validation.new(:with, *args)
       end
 
       def validates_each(*args, &block)
-        @validations ||= []
-        @validations << Validation.new(:each, *args, &block)
+        self.validations << Validation.new(:each, *args, &block)
       end
 
       def validate(method_name = nil, &block)
-        @validations ||= []
-        @validations << Validation.new(:custom, method_name, &block)
+        self.validations << Validation.new(:custom, method_name, &block)
+      end
+
+      def callbacks
+        @callbacks ||= []
       end
 
-      [ :before_validation, :after_validation,
-        :before_create,  :around_create,  :after_create,
-        :before_update,  :around_update,  :after_update,
-        :before_save,    :around_save,    :after_save,
-        :before_destroy, :around_destroy, :after_destroy,
-        :after_commit, :after_rollback,
-        :after_initialize, :after_find
+      # Callbacks
+
+      [ :before_validation,
+        :after_validation,
+        :before_create,
+        :around_create,
+        :after_create,
+        :before_update,
+        :around_update,
+        :after_update,
+        :before_save,
+        :around_save,
+        :after_save,
+        :before_destroy,
+        :around_destroy,
+        :after_destroy,
+        :after_commit,
+        :after_rollback,
+        :after_initialize,
+        :after_find
       ].each do |method_name|
 
         define_method(method_name) do |*args, &block|
-          @callbacks ||= []
-          @callbacks << Callback.new(method_name, *args, &block)
+          self.callbacks << Callback.new(method_name, *args, &block)
+        end
+
+      end
+
+      def custom_callback_types
+        @custom_callback_types ||= []
+      end
+
+      def define_model_callbacks(*args)
+        options   = args.last.kind_of?(Hash) ? args.pop : {}
+        types     = options[:only] || [:before, :around, :after]
+        metaclass = class << self; self; end
+
+        args.each do |name|
+          self.custom_callback_types << CallbackType.new(name, options)
+          types.each do |type|
+            method_name = "#{type}_#{name}"
+            metaclass.send(:define_method, method_name) do |*args, &block|
+              self.callbacks << Callback.new(method_name, *args, &block)
+            end
+          end
+        end
+      end
+
+      CallbackType = Struct.new(:name, :options)
+
+      # Scopes
+
+      attr_writer :relation_spy
+      def relation_spy
+        @relation_spy ||= RelationSpy.new
+      end
+
+      def arel_table
+        @arel_table ||= Arel::Table.new(self.table_name)
+      end
+
+      def scoped
+        self.relation_spy
+      end
+
+      [ :select,
+        :from,
+        :includes,
+        :joins,
+        :where,
+        :group,
+        :having,
+        :order,
+        :reverse_order,
+        :readonly,
+        :limit,
+        :offset,
+        :merge,
+        :except,
+        :only
+      ].each do |method_name|
+
+        define_method(method_name) do |*args|
+          self.relation_spy.send(method_name, *args)
         end
 
       end
@@ -98,6 +187,15 @@ module Ardb
         self.send("#{col}=", value)
       end
 
+      def manually_run_callbacks
+        @manually_run_callbacks ||= []
+      end
+
+      def run_callbacks(name, &block)
+        self.manually_run_callbacks << name
+        block.call if block
+      end
+
     end
 
     class Association

data/lib/ardb/relation_spy.rb

@@ -25,14 +25,24 @@ module Ardb
       @applied.map(&:to_sql).join(", ")
     end
 
+    def reset!
+      @applied.clear
+      @results.clear
+      @offset_value = nil
+      @limit_value  = nil
+    end
+
     # ActiveRecord::QueryMethods
 
     [ :select,
       :from,
-      :includes, :joins,
+      :includes,
+      :joins,
       :where,
-      :group, :having,
-      :order, :reverse_order,
+      :group,
+      :having,
+      :order,
+      :reverse_order,
       :readonly
     ].each do |type|
 

data/lib/ardb/version.rb

@@ -1,3 +1,3 @@
 module Ardb
-  VERSION = "0.21.0"
+  VERSION = "0.22.0"
 end

data/test/helper.rb

@@ -6,7 +6,7 @@ $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
 require 'pry'
-require 'assert-mocha' if defined?(Assert)
+require 'test/support/factory'
 
 ENV['ARDB_DB_FILE'] = 'tmp/testdb/config/db'
 require 'ardb'

data/test/support/factory.rb

@@ -0,0 +1,6 @@
+require 'assert/factory'
+
+module Factory
+  extend Assert::Factory
+
+end

data/test/unit/adapter/postgresql_tests.rb

@@ -54,13 +54,7 @@ class Ardb::Adapter::Postgresql
     setup do
       cmd_str = "psql -f \"#{@adapter.sql_schema_path}\" #{@adapter.database}"
       @cmd_spy = CmdSpy.new
-      Scmd.stubs(:new).tap do |s|
-        s.with(cmd_str, @env)
-        s.returns(@cmd_spy)
-      end
-    end
-    teardown do
-      Scmd.unstub(:new)
+      Assert.stub(Scmd, :new).with(cmd_str, @env){ @cmd_spy }
     end
 
     should "run a command for loading a SQL schema using `load_sql_schema`" do
@@ -75,13 +69,7 @@ class Ardb::Adapter::Postgresql
       cmd_str = "pg_dump -i -s -x -O -f " \
                 "\"#{@adapter.sql_schema_path}\" #{@adapter.database}"
       @cmd_spy = CmdSpy.new
-      Scmd.stubs(:new).tap do |s|
-        s.with(cmd_str, @env)
-        s.returns(@cmd_spy)
-      end
-    end
-    teardown do
-      Scmd.unstub(:new)
+      Assert.stub(Scmd, :new).with(cmd_str, @env){ @cmd_spy }
     end
 
     should "run a command for dumping a SQL schema using `dump_sql_schema`" do

data/test/unit/record_spy_tests.rb

@@ -6,13 +6,17 @@ module Ardb::RecordSpy
   class UnitTests < Assert::Context
     desc "Ardb::RecordSpy"
     setup do
-      @instance = MyRecord.new
+      @record_spy_class = Class.new do
+        include Ardb::RecordSpy
+        attr_accessor :name
+      end
     end
-    subject{ MyRecord }
+    subject{ @record_spy_class }
 
     should have_accessors :table_name
-    should have_readers :associations, :callbacks, :validations
+    should have_imeths :associations
     should have_imeths :belongs_to, :has_many, :has_one
+    should have_imeths :validations
     should have_imeths :validates_acceptance_of, :validates_confirmation_of
     should have_imeths :validates_exclusion_of,  :validates_format_of
     should have_imeths :validates_inclusion_of, :validates_length_of
@@ -20,6 +24,7 @@ module Ardb::RecordSpy
     should have_imeths :validates_size_of, :validates_uniqueness_of
     should have_imeths :validates_associated, :validates_with, :validates_each
     should have_imeths :validate
+    should have_imeths :callbacks
     should have_imeths :before_validation, :after_validation
     should have_imeths :before_create,  :around_create,  :after_create
     should have_imeths :before_update,  :around_update,  :after_update
@@ -27,16 +32,22 @@ module Ardb::RecordSpy
     should have_imeths :before_destroy, :around_destroy, :after_destroy
     should have_imeths :after_commit, :after_rollback
     should have_imeths :after_initialize, :after_find
-
-    should "included the record spy instance methods" do
-      assert_includes Ardb::RecordSpy::InstanceMethods, subject.included_modules
-    end
+    should have_imeths :custom_callback_types, :define_model_callbacks
+    should have_writers :relation_spy
+    should have_imeths :relation_spy, :arel_table, :scoped
+    should have_imeths :select, :from, :includes, :joins, :where
+    should have_imeths :group, :having, :order, :reverse_order, :readonly
+    should have_imeths :limit, :offset, :merge, :except, :only
 
     should "allow reading and writing the record's table name" do
       subject.table_name = 'my_records'
       assert_equal 'my_records', subject.table_name
     end
 
+    should "default its associations" do
+      assert_equal [], subject.associations
+    end
+
     should "add an association config with #belongs_to" do
       subject.belongs_to :area, :foreign_key => :area_id
       association = subject.associations.last
@@ -61,6 +72,10 @@ module Ardb::RecordSpy
       assert_equal 'Linking', association.options[:class_name]
     end
 
+    should "default its validations" do
+      assert_equal [], subject.validations
+    end
+
     should "add a validation config for '*_of' validations" do
       subject.validates_presence_of :name, :email, :on => :create
       validation = subject.validations.last
@@ -108,10 +123,14 @@ module Ardb::RecordSpy
       subject.validate(&block)
       validation = subject.validations.last
       assert_equal :custom, validation.type
-      assert_equal block,    validation.block
+      assert_equal block,   validation.block
     end
 
-    should "add a callback config with with a method name" do
+    should "default its callbacks" do
+      assert_equal [], subject.validations
+    end
+
+    should "add a callback config with a method name" do
       subject.after_initialize :a_callback_method
       callback = subject.callbacks.last
       assert_equal :after_initialize, callback.type
@@ -125,8 +144,141 @@ module Ardb::RecordSpy
       callback = subject.callbacks.last
       assert_equal :before_validation, callback.type
       assert_equal :create, callback.options[:on]
-      @instance.instance_eval(&callback.block)
-      assert_equal 'test', @instance.name
+      record_spy = subject.new
+      record_spy.instance_eval(&callback.block)
+      assert_equal 'test', record_spy.name
+    end
+
+    should "default its custom callback types" do
+      assert_equal [], subject.custom_callback_types
+    end
+
+    should "add a custom callback type using `define_model_callbacks`" do
+      name    = Factory.string
+      options = { Factory.string => Factory.string }
+      subject.define_model_callbacks(name, options)
+
+      callback_type = subject.custom_callback_types.last
+      assert_equal name,    callback_type.name
+      assert_equal options, callback_type.options
+    end
+
+    should "define callback methods using `define_model_callbacks`" do
+      name = Factory.string
+      subject.define_model_callbacks(name)
+
+      assert_respond_to "before_#{name}", subject
+      assert_respond_to "around_#{name}", subject
+      assert_respond_to "after_#{name}",  subject
+
+      callback_name = ["before_#{name}", "around_#{name}", "after_#{name}"].choice
+      method_name = Factory.string
+      subject.send(callback_name, method_name)
+      callback = subject.callbacks.last
+      assert_equal callback_name.to_sym, callback.type
+      assert_equal [method_name],        callback.args
+
+      name = Factory.string
+      subject.define_model_callbacks(name, :only => [:before])
+
+      assert_respond_to "before_#{name}", subject
+      assert_not_respond_to "around_#{name}", subject
+      assert_not_respond_to "after_#{name}",  subject
+    end
+
+    should "know its relation spy" do
+      assert_instance_of Ardb::RelationSpy, subject.relation_spy
+      spy = subject.relation_spy
+      assert_same spy, subject.relation_spy
+    end
+
+    should "know its arel table" do
+      subject.table_name = Factory.string
+      assert_instance_of Arel::Table, subject.arel_table
+      assert_equal subject.table_name, subject.arel_table.name
+    end
+
+    should "return its relation spy using `scoped`" do
+      assert_same subject.relation_spy, subject.scoped
+    end
+
+    should "demeter its scope methods to its relation spy" do
+      relation_spy = subject.relation_spy
+
+      select_args = [Factory.string]
+      subject.select(*select_args)
+      assert_equal :select,     relation_spy.applied.last.type
+      assert_equal select_args, relation_spy.applied.last.args
+
+      from_args = [Factory.string]
+      subject.from(*from_args)
+      assert_equal :from,     relation_spy.applied.last.type
+      assert_equal from_args, relation_spy.applied.last.args
+
+      includes_args = [Factory.string]
+      subject.includes(*includes_args)
+      assert_equal :includes,     relation_spy.applied.last.type
+      assert_equal includes_args, relation_spy.applied.last.args
+
+      joins_args = [Factory.string]
+      subject.joins(*joins_args)
+      assert_equal :joins,     relation_spy.applied.last.type
+      assert_equal joins_args, relation_spy.applied.last.args
+
+      where_args = [Factory.string]
+      subject.where(*where_args)
+      assert_equal :where,     relation_spy.applied.last.type
+      assert_equal where_args, relation_spy.applied.last.args
+
+      group_args = [Factory.string]
+      subject.group(*group_args)
+      assert_equal :group,     relation_spy.applied.last.type
+      assert_equal group_args, relation_spy.applied.last.args
+
+      having_args = [Factory.string]
+      subject.having(*having_args)
+      assert_equal :having,     relation_spy.applied.last.type
+      assert_equal having_args, relation_spy.applied.last.args
+
+      order_args = [Factory.string]
+      subject.order(*order_args)
+      assert_equal :order,     relation_spy.applied.last.type
+      assert_equal order_args, relation_spy.applied.last.args
+
+      subject.reverse_order
+      assert_equal :reverse_order, relation_spy.applied.last.type
+
+      readonly_args = [Factory.boolean]
+      subject.readonly(*readonly_args)
+      assert_equal :readonly,     relation_spy.applied.last.type
+      assert_equal readonly_args, relation_spy.applied.last.args
+
+      limit_args = [Factory.integer]
+      subject.limit(*limit_args)
+      assert_equal :limit,     relation_spy.applied.last.type
+      assert_equal limit_args, relation_spy.applied.last.args
+
+      offset_args = [Factory.integer]
+      subject.offset(*offset_args)
+      assert_equal :offset,     relation_spy.applied.last.type
+      assert_equal offset_args, relation_spy.applied.last.args
+
+      merge_args = [Factory.string]
+      subject.merge(*merge_args)
+      assert_equal :merge,     relation_spy.applied.last.type
+      assert_equal merge_args, relation_spy.applied.last.args
+
+      except_args = [Factory.string]
+      except_called_with = nil
+      Assert.stub(relation_spy, :except){ |*args| except_called_with = args }
+      subject.except(*except_args)
+      assert_equal except_args, except_called_with
+
+      only_args = [Factory.string]
+      only_called_with = nil
+      Assert.stub(relation_spy, :only){ |*args| only_called_with = args }
+      subject.only(*only_args)
+      assert_equal only_args, only_called_with
     end
 
   end
@@ -151,10 +303,14 @@ module Ardb::RecordSpy
   end
 
   class InstanceTests < UnitTests
+    setup do
+      @instance = MyRecord.new
+    end
     subject{ @instance }
 
     should have_accessors :id
     should have_imeths :update_column
+    should have_imeths :manually_run_callbacks, :run_callbacks
 
     should "allow spying the update_column method by just writing the value" do
       assert_not_equal 'updated', subject.name
@@ -177,6 +333,23 @@ module Ardb::RecordSpy
       assert_equal [1,2,3], subject.hm_things
     end
 
+    should "default its manually run callbacks" do
+      assert_equal [], subject.manually_run_callbacks
+    end
+
+    should "spy any callbacks that are manually run" do
+      assert_empty subject.manually_run_callbacks
+      name = Factory.string
+      subject.run_callbacks(name)
+      assert_includes name, subject.manually_run_callbacks
+
+      name = Factory.string
+      block_called = false
+      subject.run_callbacks(name){ block_called = true }
+      assert_includes name, subject.manually_run_callbacks
+      assert_true block_called
+    end
+
   end
 
   class MyRecord

data/test/unit/relation_spy_tests.rb

@@ -13,7 +13,7 @@ class Ardb::RelationSpy
     should have_readers :applied
     should have_accessors :results
     should have_accessors :limit_value, :offset_value
-    should have_imeths :to_sql
+    should have_imeths :to_sql, :reset!
     should have_imeths :select
     should have_imeths :from
     should have_imeths :includes, :joins
@@ -27,10 +27,10 @@ class Ardb::RelationSpy
     should have_imeths :count
 
     should "default it's attributes" do
-      assert_equal [],  subject.applied
-      assert_equal [],  subject.results
-      assert_equal nil, subject.limit_value
-      assert_equal nil, subject.offset_value
+      assert_equal [], subject.applied
+      assert_equal [], subject.results
+      assert_nil subject.limit_value
+      assert_nil subject.offset_value
     end
 
     should "dup its applied and results arrays when copied" do
@@ -57,6 +57,18 @@ class Ardb::RelationSpy
       assert_equal expected, subject.to_sql
     end
 
+    should "be able to be reset" do
+      Factory.integer(3).times.each{ subject.applied << Factory.string }
+      Factory.integer(3).times.each{ subject.results << Factory.string }
+      subject.limit_value  = Factory.integer
+      subject.offset_value = Factory.integer
+      subject.reset!
+      assert_equal [], subject.applied
+      assert_equal [], subject.results
+      assert_nil subject.limit_value
+      assert_nil subject.offset_value
+    end
+
   end
 
   class SelectTests < UnitTests
@@ -66,7 +78,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a select applied expression with the passed args" do
+    should "add a select applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :select, @applied.type
       assert_equal [ :column_a, :column_b ], @applied.args
@@ -81,7 +93,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a from applied expression with the passed args" do
+    should "add a from applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :from, @applied.type
       assert_equal [ "some SQL" ], @applied.args
@@ -96,7 +108,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added an includes applied expression with the passed args" do
+    should "add an includes applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :includes, @applied.type
       assert_equal [ :table_a, :table_b ], @applied.args
@@ -111,7 +123,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a joins applied expression with the passed args" do
+    should "add a joins applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :joins, @applied.type
       assert_equal [ :table_a, :table_b ], @applied.args
@@ -126,7 +138,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a where applied expression with the passed args" do
+    should "add a where applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :where, @applied.type
       assert_equal [ { :column_a => 'some value' } ], @applied.args
@@ -141,7 +153,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added an order applied expression with the passed args" do
+    should "add an order applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :order, @applied.type
       assert_equal [ :column_a, :column_b ], @applied.args
@@ -156,7 +168,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a reverse order applied expression with the passed args" do
+    should "add a reverse order applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :reverse_order, @applied.type
     end
@@ -170,7 +182,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a group applied expression with the passed args" do
+    should "add a group applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :group, @applied.type
       assert_equal [ :column_a, :column_b ], @applied.args
@@ -185,7 +197,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a having applied expression with the passed args" do
+    should "add a having applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :having, @applied.type
       assert_equal [ 'COUNT(column_a) > 0' ], @applied.args
@@ -200,7 +212,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a readonly applied expression with the passed args" do
+    should "add a readonly applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :readonly, @applied.type
       assert_equal [ true ], @applied.args
@@ -215,7 +227,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a limit applied expression with the passed args" do
+    should "add a limit applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :limit, @applied.type
       assert_equal [ 100 ], @applied.args
@@ -234,7 +246,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a offset applied expression with the passed args" do
+    should "add an offset applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :offset, @applied.type
       assert_equal [ 100 ], @applied.args
@@ -269,7 +281,7 @@ class Ardb::RelationSpy
       @applied = subject.applied.first
     end
 
-    should "have added a merge applied expression with the passed args" do
+    should "add a merge applied expression with the passed args" do
       assert_instance_of AppliedExpression, @applied
       assert_equal :merge, @applied.type
       assert_equal [ @fake_relation ], @applied.args

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ardb
 version: !ruby/object:Gem::Version 
-  hash: 75
+  hash: 71
   prerelease: 
   segments: 
   - 0
-  - 21
+  - 22
   - 0
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-06-13 00:00:00 Z
+date: 2015-07-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   requirement: &id001 !ruby/object:Gem::Requirement 
@@ -24,32 +24,17 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 31
         segments: 
         - 2
-        - 10
-        version: "2.10"
-  version_requirements: *id001
+        - 14
+        version: "2.14"
   type: :development
   name: assert
+  version_requirements: *id001
   prerelease: false
 - !ruby/object:Gem::Dependency 
   requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 13
-        segments: 
-        - 1
-        - 1
-        version: "1.1"
-  version_requirements: *id002
-  type: :development
-  name: assert-mocha
-  prerelease: false
-- !ruby/object:Gem::Dependency 
-  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -59,12 +44,12 @@ dependencies:
         - 3
         - 2
         version: "3.2"
-  version_requirements: *id003
   type: :runtime
   name: activerecord
+  version_requirements: *id002
   prerelease: false
 - !ruby/object:Gem::Dependency 
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -74,12 +59,12 @@ dependencies:
         - 3
         - 2
         version: "3.2"
-  version_requirements: *id004
   type: :runtime
   name: activesupport
+  version_requirements: *id003
   prerelease: false
 - !ruby/object:Gem::Dependency 
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -89,24 +74,24 @@ dependencies:
         - 1
         - 1
         version: "1.1"
-  version_requirements: *id005
   type: :runtime
   name: ns-options
+  version_requirements: *id004
   prerelease: false
 - !ruby/object:Gem::Dependency 
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 5
         segments: 
         - 2
-        - 2
-        version: "2.2"
-  version_requirements: *id006
+        - 3
+        version: "2.3"
   type: :runtime
   name: scmd
+  version_requirements: *id005
   prerelease: false
 description: Activerecord database tools.
 email: 
@@ -147,6 +132,7 @@ files:
 - lib/ardb/version.rb
 - log/.gitkeep
 - test/helper.rb
+- test/support/factory.rb
 - test/unit/adapter/base_tests.rb
 - test/unit/adapter/mysql_tests.rb
 - test/unit/adapter/postgresql_tests.rb
@@ -206,12 +192,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.29
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Activerecord database tools.
 test_files: 
 - test/helper.rb
+- test/support/factory.rb
 - test/unit/adapter/base_tests.rb
 - test/unit/adapter/mysql_tests.rb
 - test/unit/adapter/postgresql_tests.rb