xli-hickey 0.0.1 → 0.0.2

data/{README → README.rdoc}

@@ -31,7 +31,7 @@ Suppose we have a User model that has attributes login and admin
   % end
 
 We can create a user model by the following code:
-  % Hickey.kiss(:user => {:login => 'xli', :admin => true})
+  % Hickey.dump(:user => {:login => 'xli', :admin => true})
 
 It's not the simplest way to create user model, but just let you know how it works.
 
@@ -59,7 +59,7 @@ Suppose we have the following models:
   % end
 
 We can create a domain in the test by the following code:
-  % Hickey.kiss :project => {
+  % Hickey.dump :project => {
   %   :identifier => 'hickey', :cards => [
   %     {
   %       :name => 'first card', 
@@ -73,7 +73,7 @@ We can create a domain in the test by the following code:
   % }
 
 Another example for we want to create tag cards with one same tag named 'first_tag':
-  % Hickey.kiss :project => {
+  % Hickey.dump :project => {
   %   :identifier => 'hickey', :cards => [
   %     {
   %       :name => 'first card', 
@@ -90,15 +90,6 @@ Another example for we want to create tag cards with one same tag named 'first_t
 
 Hickey is available under an Apache License Version 2.0.
 
-== Support
-
-Feel free to submit commits or feature requests.  If you send a patch,
-remember to update the corresponding unit tests.  If fact, I prefer
-new feature to be submitted in the form of new unit tests.
-
-For other information, feel free to ask on the ruby-talk mailing list or contact
-mailto:iam@li-xiao.com.
-
 = Other stuff
 
 Author::  Li Xiao <iam@li-xiao.com>

data/Rakefile

@@ -37,20 +37,52 @@ end
 
 rd = Rake::RDocTask.new("rdoc") { |rdoc|
   rdoc.rdoc_dir = 'html'
-#  rdoc.template = 'kilmer'
-#  rdoc.template = 'css2'
-  rdoc.template = 'doc/jamis.rb'
+  rdoc.template = 'html'
   rdoc.title    = "Hickey"
   rdoc.options << '--line-numbers' << '--inline-source' <<
-    '--main' << 'README' <<
+    '--main' << 'README.rdoc' <<
     '--title' <<  'Hickey' 
-  rdoc.rdoc_files.include('README', 'LICENSE.txt', 'TODO', 'CHANGES')
+  rdoc.rdoc_files.include('README.rdoc', 'LICENSE.txt', 'TODO', 'CHANGES')
   rdoc.rdoc_files.include('lib/**/*.rb', 'doc/**/*.rdoc')
 }
 
 if ! defined?(Gem)
   puts "Package Target requires RubyGEMs"
 else
+  gem_content = <<-GEM
+Gem::Specification.new do |spec|
+  spec.name = 'hickey'
+  spec.version = "0.0.2"
+  spec.summary = "Hickey provides a simple way of preparing test data inside test for Rails project."
+
+  #### Dependencies and requirements.
+  spec.files = #{(Dir.glob("lib/**/*.rb") + ["CHANGES", "hickey.gemspec", "lib", "LICENSE.TXT", "Rakefile", "README.rdoc", "TODO"]).inspect}
+
+  spec.test_files = #{Dir.glob("test/**/*.rb").inspect}
+
+  #### Load-time details: library and application (you will need one or both).
+
+  spec.require_path = 'lib'                         # Use these for libraries.
+
+  #### Documentation and testing.
+
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = #{rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a.inspect}
+  spec.rdoc_options = #{rd.options.inspect}
+
+  #### Author and project details.
+
+  spec.author = "Li Xiao"
+  spec.email = "iam@li-xiao.com"
+  spec.homepage = "http://github.com/xli/hickey/tree/master"
+  spec.rubyforge_project = "hickey"
+end
+GEM
+  File.open(File.dirname(__FILE__) + '/hickey.gemspec', 'w') do |f|
+    f.write(gem_content)
+  end
+
+  #build gem package same steps with github
   File.open(File.dirname(__FILE__) + '/hickey.gemspec') do |f|
     data = f.read
     spec = nil

data/hickey.gemspec

@@ -1,26 +1,27 @@
-Gem::Specification.new do |s|
-  
-  #### Basic information.
+Gem::Specification.new do |spec|
+  spec.name = 'hickey'
+  spec.version = "0.0.2"
+  spec.summary = "Hickey provides a simple way of preparing test data inside test for Rails project."
 
-  s.name = 'hickey'
-  s.version = '0.0.1'
-  s.summary = "Hickey provides a simple way of preparing test data inside test for Rails project."
+  #### Dependencies and requirements.
+  spec.files = ["lib/hickey/acceptor.rb", "lib/hickey/domain_detector/actions.rb", "lib/hickey/domain_detector/associations.rb", "lib/hickey/domain_detector/base.rb", "lib/hickey/domain_detector/configurable.rb", "lib/hickey/domain_detector/scopes.rb", "lib/hickey/domain_detector.rb", "lib/hickey.rb", "CHANGES", "hickey.gemspec", "lib", "LICENSE.TXT", "Rakefile", "README.rdoc", "TODO"]
 
-  s.add_dependency('activerecord', '>= 2.1.0')
-  #### Which files are to be included in this gem?  Everything!  (Except SVN directories.)
-  # p Dir.glob("lib/**/*.rb") + Dir.glob("test/**/*.rb")
-  s.files = ["lib/hickey/acceptor.rb", "lib/hickey/domain_detector/actions.rb", "lib/hickey/domain_detector/associations.rb", "lib/hickey/domain_detector/base.rb", "lib/hickey/domain_detector/configurable.rb", "lib/hickey/domain_detector/scopes.rb", "lib/hickey/domain_detector.rb", "lib/hickey.rb", "test/belongs_to_association_test.rb", "test/database_config.rb", "test/enable_callbacks_test.rb", "test/find_or_create_actions_test.rb", "test/has_and_belongs_to_many_association_test.rb", "test/has_many_association_test.rb", "test/has_one_association_test.rb", "test/model_association_test.rb", "test/models/address.rb", "test/models/author.rb", "test/models/country.rb", "test/models/project.rb", "test/models/projects_member.rb", "test/models/property_definition.rb", "test/models/simple.rb", "test/models/tag.rb", "test/models/topic.rb", "test/models/user.rb", "test/models/writer.rb", "test/schema.rb", "test/single_model_test.rb", "test/test_helper.rb", "test/with_scope_test.rb"] + ["CHANGES", "hickey.gemspec", "LICENSE.TXT", "Rakefile", "README", "TODO"]
+  spec.test_files = ["test/belongs_to_association_test.rb", "test/database_config.rb", "test/enable_callbacks_test.rb", "test/find_or_create_actions_test.rb", "test/has_and_belongs_to_many_association_test.rb", "test/has_many_association_test.rb", "test/has_one_association_test.rb", "test/model_association_test.rb", "test/models/address.rb", "test/models/author.rb", "test/models/country.rb", "test/models/project.rb", "test/models/projects_member.rb", "test/models/property_definition.rb", "test/models/simple.rb", "test/models/tag.rb", "test/models/topic.rb", "test/models/user.rb", "test/models/writer.rb", "test/schema.rb", "test/single_model_test.rb", "test/test_helper.rb", "test/with_scope_test.rb"]
 
   #### Load-time details: library and application (you will need one or both).
 
-  s.require_path = 'lib'                         # Use these for libraries.
+  spec.require_path = 'lib'                         # Use these for libraries.
 
   #### Documentation and testing.
 
-  s.has_rdoc = false
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = ["README.rdoc", "LICENSE.txt", "TODO", "CHANGES"]
+  spec.rdoc_options = ["--line-numbers", "--inline-source", "--main", "README.rdoc", "--title", "Hickey"]
 
   #### Author and project details.
-  s.author = "Li Xiao"
-  s.email = "iam@li-xiao.com"
-  s.homepage = "https://github.com/xli/hickey/tree"
+
+  spec.author = "Li Xiao"
+  spec.email = "iam@li-xiao.com"
+  spec.homepage = "http://github.com/xli/hickey/tree/master"
+  spec.rubyforge_project = "hickey"
 end

data/lib/hickey.rb

@@ -10,13 +10,13 @@ require 'hickey/acceptor'
 require 'hickey/domain_detector'
 
 module Hickey
-  def kiss(domain)
+  def dump(domain)
     DomainDetector::Base.new.visit(domain)
   end
   
-  def lipstick(domain={})
+  def setup(domain={})
     DomainDetector::Base.configurations.merge! domain
   end
   
-  module_function :kiss, :lipstick
+  module_function :dump, :setup
 end

data/test/belongs_to_association_test.rb

@@ -2,13 +2,13 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 
 class BelongsToAssociationTest < Test::Unit::TestCase
   def test_create_associated_belongs_to_model
-    Hickey.kiss :projects_member => {:user => {:login => 'xli'}}
+    Hickey.dump :projects_member => {:user => {:login => 'xli'}}
     assert_not_nil projects_member.user
     assert_equal 'xli', projects_member.user.login
   end
   
   def test_create_associated_belongs_to_model_with_class_name
-    Hickey.kiss :topic => {:title => 'Bla bla...', :owner => {:login => 'xli'}}
+    Hickey.dump :topic => {:title => 'Bla bla...', :owner => {:login => 'xli'}}
     
     topic = Topic.find(:first)
     assert_not_nil topic.owner

data/test/enable_callbacks_test.rb

@@ -3,133 +3,142 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 class EnableCallbacksTest < Test::Unit::TestCase
   
   def teardown
-    Hickey.lipstick.clear
+    Hickey.setup.clear
     Simple.public_instance_methods(false).each do |method|
       next if method == 'id'
       Simple.class_eval "def #{method};end"
     end
   end
-  
+
+  def test_configuration_setup_should_not_effect_other_instances
+    Hickey.setup(:simple => {:callbacks => [:after_save]})
+    simple = Hickey.dump(:simple => {})
+    assert simple.respond_to?(:original_callback, true)
+
+    simple = Simple.find(:all).first
+    assert !simple.respond_to?(:original_callback, true)
+  end
+
   def test_invoke_before_save_and_after_save_after_configured_all_callbacks
-    Hickey.lipstick(:simple => {:callbacks => :all})
+    Hickey.setup(:simple => {:callbacks => :all})
     Simple.class_eval do
       before_save :create_user_before_save
       after_save :create_user_after_save
       def create_user_after_save
-        Hickey.kiss(:user => {:login => 'create_user_after_save'})
+        Hickey.dump(:user => {:login => 'create_user_after_save'})
       end
       def create_user_before_save
-        Hickey.kiss(:user => {:login => 'create_user_before_save'})
+        Hickey.dump(:user => {:login => 'create_user_before_save'})
       end
       def validate
         raise 'should bypass'
       end
     end
     
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
 
     assert_equal ['create_user_before_save', 'create_user_after_save'].sort, User.find(:all).collect(&:login).sort
   end
 
   def test_invoke_before_validation_on_create_after_configured_all_callbacks
-    Hickey.lipstick(:simple => {:callbacks => :all})
+    Hickey.setup(:simple => {:callbacks => :all})
     Simple.class_eval do
       before_validation_on_create :create_user_before_validation_on_create
       def create_user_before_validation_on_create
-        Hickey.kiss(:user => {:login => 'create_user_before_validation_on_create'})
+        Hickey.dump(:user => {:login => 'create_user_before_validation_on_create'})
       end
       def validate
         raise 'should bypass'
       end
     end
 
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
     assert_equal ['create_user_before_validation_on_create'], User.find(:all).collect(&:login)
   end
   
   def test_invoke_before_validation_after_configured_all_callbacks
-    Hickey.lipstick(:simple => {:callbacks => :all})
+    Hickey.setup(:simple => {:callbacks => :all})
     Simple.class_eval do
       before_validation :create_user_before_validation
       def create_user_before_validation
-        Hickey.kiss(:user => {:login => 'create_user_before_validation'})
+        Hickey.dump(:user => {:login => 'create_user_before_validation'})
       end
       def validate
         raise 'should bypass'
       end
     end
 
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
     assert_equal ['create_user_before_validation'], User.find(:all).collect(&:login)
   end
   
   def test_invoke_before_validation_after_configured_all_callbacks
-    Hickey.lipstick(:simple => {:callbacks => :all})
+    Hickey.setup(:simple => {:callbacks => :all})
     Simple.class_eval do
       after_validation :create_user_after_validation
       def create_user_after_validation
-        Hickey.kiss(:user => {:login => 'create_user_after_validation'})
+        Hickey.dump(:user => {:login => 'create_user_after_validation'})
       end
       def validate
         raise 'should bypass'
       end
     end
 
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
     assert_equal ['create_user_after_validation'], User.find(:all).collect(&:login)
   end
   
   def test_should_not_callback_before_validation_on_create_if_pass_in_existed_model
-    simple = Hickey.kiss(:simple => {})
-    Hickey.lipstick(:simple => {:callbacks => :all})
+    simple = Hickey.dump(:simple => {})
+    Hickey.setup(:simple => {:callbacks => :all})
     Simple.class_eval do
       before_validation_on_create :create_user_before_validation_on_create
       def create_user_before_validation_on_create
-        Hickey.kiss(:user => {:login => 'create_user_before_validation_on_create'})
+        Hickey.dump(:user => {:login => 'create_user_before_validation_on_create'})
       end
       def validate
         raise 'should bypass'
       end
     end
 
-    Hickey.kiss(simple => {})
+    Hickey.dump(simple => {})
     assert_equal [], User.find(:all).collect(&:login)
   end
   
   def test_should_enable_configuration_of_invoking_all_callbacks_for_all_subclasses
-    Hickey.lipstick(:property_definition => {:callbacks => :all})
+    Hickey.setup(:property_definition => {:callbacks => :all})
     DatePropertyDefinition.class_eval do
       after_validation :create_user_after_validation
       def create_user_after_validation
-        Hickey.kiss(:user => {:login => 'create_user_after_validation'})
+        Hickey.dump(:user => {:login => 'create_user_after_validation'})
       end
       def validate
         raise 'should bypass'
       end
     end
 
-    Hickey.kiss(:property_definition => {:type => 'DatePropertyDefinition'})
+    Hickey.dump(:property_definition => {:type => 'DatePropertyDefinition'})
     
     assert_equal ['create_user_after_validation'], User.find(:all).collect(&:login)
   end
 
   def test_invoke_callback_specified_after_configured
-    Hickey.lipstick(:simple => {:callbacks => [:after_create, :before_create]})
+    Hickey.setup(:simple => {:callbacks => [:after_create, :before_create]})
     Simple.class_eval do
       before_create :create_user_before_create
       after_create :create_user_after_create
       def create_user_before_create
-        Hickey.kiss(:user => {:login => 'create_user_before_create'})
+        Hickey.dump(:user => {:login => 'create_user_before_create'})
       end
       def create_user_after_create
-        Hickey.kiss(:user => {:login => 'create_user_after_create'})
+        Hickey.dump(:user => {:login => 'create_user_after_create'})
       end
       def validate
         raise 'should bypass'
       end
     end
 
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
     assert_equal ['create_user_after_create', 'create_user_before_create'].sort, User.find(:all).collect(&:login).sort
   end
 end

data/test/find_or_create_actions_test.rb

@@ -2,39 +2,39 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 
 class FindOrCreateActionsTest < Test::Unit::TestCase
   def test_create_action
-    assert Hickey.kiss(:simple => {:create => {}})
+    assert Hickey.dump(:simple => {:create => {}})
   end
   
   def test_create_multi_models
-    result = Hickey.kiss(:simple => {:create => {}}, :user => {:create => {:login => 'xli'}})
+    result = Hickey.dump(:simple => {:create => {}}, :user => {:create => {:login => 'xli'}})
     assert_equal({:simple => Simple.find(:first), :user => User.find(:first)}, result)
   end
   
   def test_create_association_model
-    Hickey.kiss(:project => {:identifier => 'hickey', :users => [{:create => {:login => 'xli', :admin => true}}]})
+    Hickey.dump(:project => {:identifier => 'hickey', :users => [{:create => {:login => 'xli', :admin => true}}]})
     
     assert_equal 'xli', project.users.first.login
   end
   
   def test_find_action
-    simple1 = Hickey.kiss(:simple => {})
-    simple2 = Hickey.kiss(:simple => {:find => {}})
+    simple1 = Hickey.dump(:simple => {})
+    simple2 = Hickey.dump(:simple => {:find => {}})
     assert_equal simple1, simple2
     assert_equal 1, Simple.count(:all)
   end
   
   def test_find_by_attributes
-    Hickey.kiss(:user => {:login => 'mm'})
-    user1 = Hickey.kiss(:user => {:login => 'xli'})
-    user2 = Hickey.kiss(:user => {:find => {:login => 'xli'}})
+    Hickey.dump(:user => {:login => 'mm'})
+    user1 = Hickey.dump(:user => {:login => 'xli'})
+    user2 = Hickey.dump(:user => {:find => {:login => 'xli'}})
     assert_equal user1, user2
     assert_equal 2, User.count(:all)
   end
   
   def test_should_find_model_without_association
-    Hickey.kiss(:project => {:identifier => 'hickey', :users => [{:login => 'xli', :admin => true}]})
+    Hickey.dump(:project => {:identifier => 'hickey', :users => [{:login => 'xli', :admin => true}]})
 
-    project = Hickey.kiss(:project => {:find => {:identifier => 'hickey', :users => [{:login => 'xli', :admin => true}]}})
+    project = Hickey.dump(:project => {:find => {:identifier => 'hickey', :users => [{:login => 'xli', :admin => true}]}})
     assert_equal 'hickey', project.identifier
     assert_equal 'xli', project.users.first.login
     assert_equal 1, Project.count(:all)
@@ -43,9 +43,9 @@ class FindOrCreateActionsTest < Test::Unit::TestCase
   end
   
   def test_find_model_with_finding_association
-    Hickey.kiss(:project => {:identifier => 'hickey', :users => [{:login => 'xli', :admin => true}]})
+    Hickey.dump(:project => {:identifier => 'hickey', :users => [{:login => 'xli', :admin => true}]})
 
-    project = Hickey.kiss(:project => {:find => {:identifier => 'hickey', :users => [{:find => {:login => 'xli', :admin => true}}]}})
+    project = Hickey.dump(:project => {:find => {:identifier => 'hickey', :users => [{:find => {:login => 'xli', :admin => true}}]}})
     assert_equal 'hickey', project.identifier
     assert_equal 'xli', project.users.first.login
     assert_equal 1, Project.count(:all)
@@ -54,9 +54,9 @@ class FindOrCreateActionsTest < Test::Unit::TestCase
   end
   
   def test_find_or_create
-    Hickey.kiss(:simple => {:find_or_create => {}})
+    Hickey.dump(:simple => {:find_or_create => {}})
     assert_equal 1, Simple.count(:all)
-    Hickey.kiss(:simple => {:find_or_create => {}})
+    Hickey.dump(:simple => {:find_or_create => {}})
     assert_equal 1, Simple.count(:all)
   end
 end

data/test/has_and_belongs_to_many_association_test.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 
 class HasAndBelongsToManyAssociationTest < Test::Unit::TestCase
   def test_create_associated_has_and_belongs_to_many_models
-    Hickey.kiss :user => {:login => 'xli', :countries => [{:name => 'China'}]}
+    Hickey.dump :user => {:login => 'xli', :countries => [{:name => 'China'}]}
 
     assert_equal 1, user.countries.size
     assert_equal 'China', user.countries.first.name

data/test/has_many_association_test.rb

@@ -3,12 +3,12 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 class HasManyAssociationTest < Test::Unit::TestCase
 
   def test_create_associated_empty_models
-    Hickey.kiss(:project => {:identifier => 'hickey', :projects_members => []})
+    Hickey.dump(:project => {:identifier => 'hickey', :projects_members => []})
     assert_equal [], project.projects_members
   end
   
   def test_create_associated_many_existed_models
-    Hickey.kiss :project => {:identifier => 'hickey', :projects_members => [{}, {}]}
+    Hickey.dump :project => {:identifier => 'hickey', :projects_members => [{}, {}]}
     
     assert_equal 2, project.projects_members.size
     assert_not_nil project.projects_members.first
@@ -16,13 +16,13 @@ class HasManyAssociationTest < Test::Unit::TestCase
   end
   
   def test_option_class_name
-    Hickey.kiss :user => {:login => 'xli', :my_topics => [{:title => 'Bla bla...'}]}
+    Hickey.dump :user => {:login => 'xli', :my_topics => [{:title => 'Bla bla...'}]}
     assert_equal 1, user.my_topics.size
     assert_equal 'Bla bla...', user.my_topics.first.title
   end
 
   def test_option_through_models
-    Hickey.kiss :project => {:identifier => 'hickey', :users => [{:login => 'xli'}]}
+    Hickey.dump :project => {:identifier => 'hickey', :users => [{:login => 'xli'}]}
     assert_equal 1, project.projects_members.size
     assert_not_nil project.projects_members.first.user
     assert_equal 'xli', project.projects_members.first.user.login
@@ -31,18 +31,18 @@ class HasManyAssociationTest < Test::Unit::TestCase
   end
 
   def test_option_foreign_key
-    Hickey.kiss :writer => {:login => 'xli', :addresses => [{:location => 'BeiJing'}, {:location => 'ShangHai'}]}
+    Hickey.dump :writer => {:login => 'xli', :addresses => [{:location => 'BeiJing'}, {:location => 'ShangHai'}]}
     assert_equal 2, writer.addresses.size
     assert_equal ['BeiJing', 'ShangHai'].sort, writer.addresses.collect(&:location).sort
   end
 
   def test_option_as
-    Hickey.kiss :writer => {:topics => [{:title => 'Hello world'}, {:title => 'Hello world again'}]}
+    Hickey.dump :writer => {:topics => [{:title => 'Hello world'}, {:title => 'Hello world again'}]}
     assert_equal ['Hello world', 'Hello world again'].sort, writer.topics.collect(&:title).sort
   end
   
   def test_option_through_and_as
-    Hickey.kiss :writer => {:login => 'writer', :disscutions => [{:speaker => {:login => 'xli'}}, {:speaker => {:login => 'oo'}}]}
+    Hickey.dump :writer => {:login => 'writer', :disscutions => [{:speaker => {:login => 'xli'}}, {:speaker => {:login => 'oo'}}]}
     speakers = writer.disscutions.collect(&:speaker)
     assert_equal ['writer', 'xli', 'oo'].sort, User.find(:all).collect(&:login).sort
     assert_equal 2, speakers.size
@@ -51,20 +51,20 @@ class HasManyAssociationTest < Test::Unit::TestCase
   end
 
   def test_specifying_type_attribute_for_single_table_inheritance
-    Hickey.kiss :project => {:all_property_definitions => [{:name => 'status', :type => 'EnumPropertyDefinition'}, {:name => 'owner', :type => 'UserPropertyDefinition'}]}
+    Hickey.dump :project => {:all_property_definitions => [{:name => 'status', :type => 'EnumPropertyDefinition'}, {:name => 'owner', :type => 'UserPropertyDefinition'}]}
     
     assert_equal ['status', 'owner'].sort, project.all_property_definitions.collect(&:name).sort
   end
   
   def test_subclass_relationship_of_single_table_inheritance
-    Hickey.kiss :property_definition => {:type => 'EnumPropertyDefinition', :enum_values => [{:value => 'new'}, {:value => 'open'}]}
+    Hickey.dump :property_definition => {:type => 'EnumPropertyDefinition', :enum_values => [{:value => 'new'}, {:value => 'open'}]}
     
     assert_equal ['new', 'open'].sort, property_definition.enum_values.collect(&:value).sort
   end
   
   def test_should_raise_active_record_subclass_not_found_error_when_cant_find_subclass
     assert_raise ActiveRecord::SubclassNotFound do
-      Hickey.kiss :property_definition => {:type => 'NotPropertyDefinition'}
+      Hickey.dump :property_definition => {:type => 'NotPropertyDefinition'}
     end
   end
   

data/test/has_one_association_test.rb

@@ -2,32 +2,32 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 
 class HasOneAssociationTest < Test::Unit::TestCase
   def test_user_has_one_address
-    Hickey.kiss :user => {:address => {:location => 'BeiJing'}}
+    Hickey.dump :user => {:address => {:location => 'BeiJing'}}
     assert_equal 'BeiJing', user.address.location
   end
   
   def test_with_option_foreign_key
-    Hickey.kiss :author => {:address => {:location => 'BeiJing'}}
+    Hickey.dump :author => {:address => {:location => 'BeiJing'}}
     assert_equal 'BeiJing', author.address.location
   end
   
   def test_with_option_as_and_class_name
-    Hickey.kiss :author => {:working_topic => {:title => 'Hello world'}}
+    Hickey.dump :author => {:working_topic => {:title => 'Hello world'}}
     assert_equal 'Hello world', author.working_topic.title
   end
   
   def test_with_option_through_has_one
-    Hickey.kiss :author => {:country => {:name => 'China'}}
+    Hickey.dump :author => {:country => {:name => 'China'}}
     assert_equal 'China', author.country.name
   end
   
   def test_with_option_through_source
-    Hickey.kiss :author => {:living_country => {:name => 'China'}}
+    Hickey.dump :author => {:living_country => {:name => 'China'}}
     assert_equal 'China', author.living_country.name
   end
 
   def test_with_option_through_source_type
-    Hickey.kiss :disscution => {:speaker => {:login => 'xli'}}
+    Hickey.dump :disscution => {:speaker => {:login => 'xli'}}
     assert_equal 'xli', disscution.speaker.login
   end
   
@@ -41,13 +41,13 @@ class HasOneAssociationTest < Test::Unit::TestCase
     DisscutionBelongsToTopic.create!(:owner => user)
     assert_equal 'xli', d.owner.login
     
-    Hickey.kiss :disscution_belongs_to_topic => {:owner => {:login => 'xli'}}
+    Hickey.dump :disscution_belongs_to_topic => {:owner => {:login => 'xli'}}
     assert_equal 'xli', disscution_belongs_to_topic.owner.login
   end
 
   #active_record couldn't work on has_one :through belongs to
   def xtest_with_option_through_source_type
-    Hickey.kiss :disscution_belongs_to_topic => {:speaker => {:login => 'xli'}}
+    Hickey.dump :disscution_belongs_to_topic => {:speaker => {:login => 'xli'}}
     assert_equal 'xli', disscution_belongs_to_topic.speaker.login
   end
 end

data/test/model_association_test.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 class ModelAssociationTest < Test::Unit::TestCase
   
   def test_should_return_same_with_models_loaded_from_db_after_created_models
-    project = Hickey.kiss :project => {:identifier => 'hickey', :projects_members => [:user => {:login => 'xli'}]}
+    project = Hickey.dump :project => {:identifier => 'hickey', :projects_members => [:user => {:login => 'xli'}]}
     
     db_project = Project.find(:first)
     assert_equal project, db_project
@@ -12,7 +12,7 @@ class ModelAssociationTest < Test::Unit::TestCase
   end
 
   def test_create_associated_both_has_many_association_and_belongs_to_association_models
-    Hickey.kiss :project => {:identifier => 'hickey', :projects_members => [:user => {:login => 'xli'}]}
+    Hickey.dump :project => {:identifier => 'hickey', :projects_members => [:user => {:login => 'xli'}]}
     assert_equal 1, project.projects_members.size
     assert_not_nil project.projects_members.first.user
     assert_equal 'xli', project.projects_members.first.user.login

data/test/models/tag.rb

@@ -1,8 +1,10 @@
 class Tag < ActiveRecord::Base
   has_many :taggings, :class_name => '::Tagging'
   belongs_to :project
-  
-  should_bypass_all_callbacks_and_validations
+  before_save :validate_scopt_object
+  def validate_scopt_object
+    raise 'Project is nil' if project.nil?
+  end
 end
 
 class Tagging < ActiveRecord::Base
@@ -14,4 +16,9 @@ end
 class Card < ActiveRecord::Base
   has_many :taggings, :as => :taggable
   belongs_to :project
+
+  before_save :validate_scopt_object
+  def validate_scopt_object
+    raise 'Project is nil' if project.nil?
+  end
 end

data/test/single_model_test.rb

@@ -2,22 +2,22 @@ require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 
 class SingleModelTest < Test::Unit::TestCase
   def test_create_simple_model
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
     assert_equal 1, Simple.find(:all).size
   end
 
   def test_should_return_created_domain
-    result = Hickey.kiss(:simple => {})
+    result = Hickey.dump(:simple => {})
     assert_equal Simple.find(:first), result
   end
 
   def test_should_return_created_domain
-    result = Hickey.kiss(:simple => [{}])
+    result = Hickey.dump(:simple => [{}])
     assert_equal Simple.find(:all), result
   end
 
-  def test_should_return_created_domain_as_hash_when_kiss_multi_models
-    result = Hickey.kiss(:simple => {}, :user => {:login => 'xli'})
+  def test_should_return_created_domain_as_hash_when_dump_multi_models
+    result = Hickey.dump(:simple => {}, :user => {:login => 'xli'})
     assert_equal({:simple => Simple.find(:first), :user => User.find(:first)}, result)
   end
 
@@ -28,7 +28,7 @@ class SingleModelTest < Test::Unit::TestCase
       end
     end
   
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
   ensure
     Simple.class_eval do
       def validate
@@ -37,7 +37,7 @@ class SingleModelTest < Test::Unit::TestCase
   end
 
   def test_create_simple_model_list
-    Hickey.kiss(:simple => [{}, {}])
+    Hickey.dump(:simple => [{}, {}])
     assert_equal 2, Simple.find(:all).size
   end
 
@@ -49,7 +49,7 @@ class SingleModelTest < Test::Unit::TestCase
       end
     end
 
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
   ensure
     Simple.class_eval do
       def should_be_bypass
@@ -59,59 +59,72 @@ class SingleModelTest < Test::Unit::TestCase
 
   def test_should_bypass_notifications
     SimpleObserver.instance
-    Hickey.kiss(:simple => {})
+    Hickey.dump(:simple => {})
     assert_equal 1, Simple.count(:all)
   end
 
   def test_create_model_with_attributes
-    Hickey.kiss(:user => {:login => 'xli', :admin => true})
+    Hickey.dump(:user => {:login => 'xli', :admin => true})
     user = User.find_by_login_and_admin('xli', true)
     assert_not_nil user
   end
   
+  def test_create_model_with_nil_attribute
+    Hickey.dump(:user => {:login => 'xli', :admin => nil})
+    user = User.find_by_login_and_admin('xli')
+    assert_not_nil user
+    assert_nil user.admin
+  end
+  
+  def test_create_model_with_string_keys
+    Hickey.dump('user' => {'login' => 'xli'})
+    user = User.find_by_login_and_admin('xli')
+    assert_not_nil user
+  end
+  
   def test_should_auto_set_created_at_and_updated_at_attributes
-    Hickey.kiss(:project => {:identifier => 'hickey'})
+    Hickey.dump(:project => {:identifier => 'hickey'})
     assert_not_nil Project.find(:first).created_at
     assert_not_nil Project.find(:first).updated_at
   end
 
   def test_should_auto_set_created_on_and_updated_on_attributes
-    Hickey.kiss(:project => {:identifier => 'hickey'})
+    Hickey.dump(:project => {:identifier => 'hickey'})
     assert_not_nil Project.find(:first).created_on
     assert_not_nil Project.find(:first).updated_on
   end
 
   def test_should_ignore_created_timestamp_attributes_when_they_have_value
     t = Time.parse("1/1/2000")
-    Hickey.kiss(:project => {:identifier => 'hickey', :created_on => t, :created_at => t})
+    Hickey.dump(:project => {:identifier => 'hickey', :created_on => t, :created_at => t})
 
     assert_equal t, project.created_on
     assert_equal t, project.created_at
   end
   
   def test_should_update_object_specified
-    project = Hickey.kiss(:project => {:identifier => 'hickey'})
-    Hickey.kiss project => {:identifier => 'new project identifier'}
+    project = Hickey.dump(:project => {:identifier => 'hickey'})
+    Hickey.dump project => {:identifier => 'new project identifier'}
     project.reload
     
     assert_equal 'new project identifier', project.identifier
   end
 
   def test_create_object_associating_with_exist_object
-    user = Hickey.kiss(:user => {:login => 'xli', :admin => true})
-    Hickey.kiss(:project => {:identifier => 'hickey', :users => [user]})
+    user = Hickey.dump(:user => {:login => 'xli', :admin => true})
+    Hickey.dump(:project => {:identifier => 'hickey', :users => [user]})
     
     assert_equal 'xli', project.users.first.login
   end
 
   def test_should_raise_error_when_create_model_failed_by_sql_error
     assert_raise ActiveRecord::StatementInvalid do
-      Hickey.kiss(:property_definition => {}) #type should not be nil
+      Hickey.dump(:property_definition => {}) #type should not be nil
     end
   end
   
   def test_should_work_after_redefined_accessor_method_for_column
-    Hickey.kiss(:prisoner => {:login => 'xli'})
+    Hickey.dump(:prisoner => {:login => 'xli'})
     assert_equal 'xli', prisoner.login
   end
 end

data/test/test_helper.rb

@@ -32,7 +32,6 @@ module Hickey
     end
 
     def should_be_bypass
-      return if $testing_active_record
       raise 'should be bypass'
     end
   end
@@ -63,13 +62,6 @@ class Test::Unit::TestCase
     end
   end
   
-  def with_testing_active_record
-    $testing_active_record = true
-    yield
-  ensure
-    $testing_active_record = false
-  end
-  
   def models
     return @models if defined?(@models)
     @models = []

data/test/with_scope_test.rb

@@ -1,8 +1,18 @@
 require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
 
 class WithScopeTest < Test::Unit::TestCase
+  def test_should_be_able_get_associated_scope_object_in_before_save
+    Hickey.setup(:card => {:callbacks => :all})
+    Hickey.setup(:tag => {:callbacks => :all})
+    Hickey.dump :project => {
+      :identifier => 'hickey', :cards => [{:name => 'first card', :taggings => [{:tag => {:name => 'first_tag'}}]}]
+    }
+  ensure
+    Hickey.setup.clear
+  end
+  
   def test_should_auto_associate_models_even_they_are_not_related_directly
-    Hickey.kiss :project => {
+    Hickey.dump :project => {
       :identifier => 'hickey', :cards => [
         {
           :name => 'first card', 
@@ -15,7 +25,7 @@ class WithScopeTest < Test::Unit::TestCase
   end
   
   def test_should_work_with_find_or_create_actions
-    Hickey.kiss :project => {
+    Hickey.dump :project => {
       :identifier => 'hickey', :cards => [
         {
           :name => 'first card', 
@@ -32,12 +42,12 @@ class WithScopeTest < Test::Unit::TestCase
   end
   
   def test_should_not_effect_object_out_of_model_scope
-    Hickey.kiss :writer => {:login => 'writer', :disscutions => [{:speaker => {:login => 'xli'}}, {:speaker => {:login => 'oo'}}]}
+    Hickey.dump :writer => {:login => 'writer', :disscutions => [{:speaker => {:login => 'xli'}}, {:speaker => {:login => 'oo'}}]}
     assert_equal 2, writer.disscutions.collect(&:id).uniq.size
   end
 
   def test_should_ignore_keys_that_dont_belong_to_model_in_the_scopes
-    project = Hickey.kiss :project => {
+    project = Hickey.dump :project => {
       :identifier => 'hickey', :cards => [
         {
           :name => 'first card',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: xli-hickey
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Li Xiao
@@ -9,26 +9,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -07:00
+date: 2008-10-27 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activerecord
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.1.0
-    version: 
+dependencies: []
+
 description: 
 email: iam@li-xiao.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
+- TODO
+- CHANGES
 files: 
 - lib/hickey/acceptor.rb
 - lib/hickey/domain_detector/actions.rb
@@ -38,40 +33,24 @@ files:
 - lib/hickey/domain_detector/scopes.rb
 - lib/hickey/domain_detector.rb
 - lib/hickey.rb
-- test/belongs_to_association_test.rb
-- test/database_config.rb
-- test/enable_callbacks_test.rb
-- test/find_or_create_actions_test.rb
-- test/has_and_belongs_to_many_association_test.rb
-- test/has_many_association_test.rb
-- test/has_one_association_test.rb
-- test/model_association_test.rb
-- test/models/address.rb
-- test/models/author.rb
-- test/models/country.rb
-- test/models/project.rb
-- test/models/projects_member.rb
-- test/models/property_definition.rb
-- test/models/simple.rb
-- test/models/tag.rb
-- test/models/topic.rb
-- test/models/user.rb
-- test/models/writer.rb
-- test/schema.rb
-- test/single_model_test.rb
-- test/test_helper.rb
-- test/with_scope_test.rb
 - CHANGES
 - hickey.gemspec
+- lib
 - LICENSE.TXT
 - Rakefile
-- README
+- README.rdoc
 - TODO
-has_rdoc: false
-homepage: https://github.com/xli/hickey/tree
+- LICENSE.txt
+has_rdoc: true
+homepage: http://github.com/xli/hickey/tree/master
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.rdoc
+- --title
+- Hickey
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -88,10 +67,32 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: hickey
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Hickey provides a simple way of preparing test data inside test for Rails project.
-test_files: []
-
+test_files: 
+- test/belongs_to_association_test.rb
+- test/database_config.rb
+- test/enable_callbacks_test.rb
+- test/find_or_create_actions_test.rb
+- test/has_and_belongs_to_many_association_test.rb
+- test/has_many_association_test.rb
+- test/has_one_association_test.rb
+- test/model_association_test.rb
+- test/models/address.rb
+- test/models/author.rb
+- test/models/country.rb
+- test/models/project.rb
+- test/models/projects_member.rb
+- test/models/property_definition.rb
+- test/models/simple.rb
+- test/models/tag.rb
+- test/models/topic.rb
+- test/models/user.rb
+- test/models/writer.rb
+- test/schema.rb
+- test/single_model_test.rb
+- test/test_helper.rb
+- test/with_scope_test.rb