hickey 0.0.2

data/lib/hickey/domain_detector/configurable.rb

@@ -0,0 +1,38 @@
+module Hickey
+  module DomainDetector
+    module Configurable
+      def self.included(base)
+        base.class_eval do
+          @@configurations = {}
+          cattr_accessor :configurations, :instance_writer => false
+          alias_method_chain :new_instance, :configuration
+        end
+      end
+      
+      private
+      def new_instance_with_configuration(class_or_instance, record)
+        instance = new_instance_without_configuration(class_or_instance, record)
+        instance.instance_eval do
+          def valid_without_callbacks?
+            true
+          end
+        end
+        unless configuration_of(instance)[:callbacks] == :all
+          callbacks = configuration_of(instance)[:callbacks] || []
+          instance.instance_eval <<-"end_eval"
+            alias :original_callback :callback
+            def callback(method)
+              [#{callbacks.collect(&:inspect).join(',')}].include?(method) ? original_callback(method) : true
+            end
+          end_eval
+        end
+        instance
+      end
+      
+      def configuration_of(instance)
+        klass = instance.class
+        @@configurations[klass.name.underscore.to_sym] || @@configurations[klass.base_class.name.underscore.to_sym] || {}
+      end
+    end
+  end
+end

data/lib/hickey/domain_detector/scopes.rb

@@ -0,0 +1,30 @@
+module Hickey
+  module DomainDetector
+    module Scopes
+      def self.included(base)
+        base.send(:alias_method_chain, :visit_hash, :scopes)
+        base.send(:alias_method_chain, :new_instance, :scopes)
+      end
+      
+      def visit_hash_with_scopes(attribute, record)
+        scopes.each do |foreign_key, owner|
+          record[foreign_key] = owner.id unless record[foreign_key]
+        end
+        returning visit_hash_without_scopes(attribute, record) do |instance|
+          scopes.delete instance.class.name.foreign_key
+        end
+      end
+      
+      def new_instance_with_scopes(class_or_instance, record)
+        returning new_instance_without_scopes(class_or_instance, record) do |instance|
+          scopes[instance.class.name.foreign_key] = instance
+        end
+      end
+      
+      private
+      def scopes
+        @scopes ||= {}
+      end
+    end
+  end
+end

data/test/belongs_to_association_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+class BelongsToAssociationTest < Test::Unit::TestCase
+  def test_create_associated_belongs_to_model
+    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.dump :topic => {:title => 'Bla bla...', :owner => {:login => 'xli'}}
+    
+    topic = Topic.find(:first)
+    assert_not_nil topic.owner
+    assert_equal 'xli', topic.owner.login
+  end
+end

data/test/database_config.rb

@@ -0,0 +1,20 @@
+require 'logger'
+
+RAILS_DEFAULT_LOGGER = Logger.new(File.expand_path(File.dirname(__FILE__)) + '/debug.log')
+RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+ActiveRecord::Base.logger = RAILS_DEFAULT_LOGGER
+
+ActiveRecord::Base.configurations = {
+  'test' => {
+    :database => ":memory:",
+    :adapter => 'sqlite3',
+    :timeout => 500
+  }
+}
+
+ActiveRecord::Base.establish_connection 'test'
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+  load File.join(File.dirname(__FILE__), 'schema.rb')
+end

data/test/enable_callbacks_test.rb

@@ -0,0 +1,144 @@
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+class EnableCallbacksTest < Test::Unit::TestCase
+  
+  def teardown
+    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.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.dump(:user => {:login => 'create_user_after_save'})
+      end
+      def create_user_before_save
+        Hickey.dump(:user => {:login => 'create_user_before_save'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+    
+    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.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.dump(:user => {:login => 'create_user_before_validation_on_create'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    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.setup(:simple => {:callbacks => :all})
+    Simple.class_eval do
+      before_validation :create_user_before_validation
+      def create_user_before_validation
+        Hickey.dump(:user => {:login => 'create_user_before_validation'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    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.setup(:simple => {:callbacks => :all})
+    Simple.class_eval do
+      after_validation :create_user_after_validation
+      def create_user_after_validation
+        Hickey.dump(:user => {:login => 'create_user_after_validation'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    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.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.dump(:user => {:login => 'create_user_before_validation_on_create'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    Hickey.dump(simple => {})
+    assert_equal [], User.find(:all).collect(&:login)
+  end
+  
+  def test_should_enable_configuration_of_invoking_all_callbacks_for_all_subclasses
+    Hickey.setup(:property_definition => {:callbacks => :all})
+    DatePropertyDefinition.class_eval do
+      after_validation :create_user_after_validation
+      def create_user_after_validation
+        Hickey.dump(:user => {:login => 'create_user_after_validation'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    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.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.dump(:user => {:login => 'create_user_before_create'})
+      end
+      def create_user_after_create
+        Hickey.dump(:user => {:login => 'create_user_after_create'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    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

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+class FindOrCreateActionsTest < Test::Unit::TestCase
+  def test_create_action
+    assert Hickey.dump(:simple => {:create => {}})
+  end
+  
+  def test_create_multi_models
+    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.dump(:project => {:identifier => 'hickey', :users => [{:create => {:login => 'xli', :admin => true}}]})
+    
+    assert_equal 'xli', project.users.first.login
+  end
+  
+  def test_find_action
+    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.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.dump(:project => {: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)
+    
+    assert_equal 2, User.count(:all)
+  end
+  
+  def test_find_model_with_finding_association
+    Hickey.dump(:project => {:identifier => 'hickey', :users => [{: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)
+    
+    assert_equal 1, User.count(:all)
+  end
+  
+  def test_find_or_create
+    Hickey.dump(:simple => {:find_or_create => {}})
+    assert_equal 1, Simple.count(:all)
+    Hickey.dump(:simple => {:find_or_create => {}})
+    assert_equal 1, Simple.count(:all)
+  end
+end

data/test/has_and_belongs_to_many_association_test.rb

@@ -0,0 +1,10 @@
+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.dump :user => {:login => 'xli', :countries => [{:name => 'China'}]}
+
+    assert_equal 1, user.countries.size
+    assert_equal 'China', user.countries.first.name
+  end
+end

data/test/has_many_association_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+class HasManyAssociationTest < Test::Unit::TestCase
+
+  def test_create_associated_empty_models
+    Hickey.dump(:project => {:identifier => 'hickey', :projects_members => []})
+    assert_equal [], project.projects_members
+  end
+  
+  def test_create_associated_many_existed_models
+    Hickey.dump :project => {:identifier => 'hickey', :projects_members => [{}, {}]}
+    
+    assert_equal 2, project.projects_members.size
+    assert_not_nil project.projects_members.first
+    assert_not_nil project.projects_members.last
+  end
+  
+  def test_option_class_name
+    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.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
+    
+    assert_equal 'xli', project.users.first.login
+  end
+
+  def test_option_foreign_key
+    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.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.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
+    speakers = [speakers.first.login, speakers.last.login]
+    assert_equal ['xli', 'oo'].sort, speakers.sort
+  end
+
+  def test_specifying_type_attribute_for_single_table_inheritance
+    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.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.dump :property_definition => {:type => 'NotPropertyDefinition'}
+    end
+  end
+  
+end

data/test/has_one_association_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+class HasOneAssociationTest < Test::Unit::TestCase
+  def test_user_has_one_address
+    Hickey.dump :user => {:address => {:location => 'BeiJing'}}
+    assert_equal 'BeiJing', user.address.location
+  end
+  
+  def test_with_option_foreign_key
+    Hickey.dump :author => {:address => {:location => 'BeiJing'}}
+    assert_equal 'BeiJing', author.address.location
+  end
+  
+  def test_with_option_as_and_class_name
+    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.dump :author => {:country => {:name => 'China'}}
+    assert_equal 'China', author.country.name
+  end
+  
+  def test_with_option_through_source
+    Hickey.dump :author => {:living_country => {:name => 'China'}}
+    assert_equal 'China', author.living_country.name
+  end
+
+  def test_with_option_through_source_type
+    Hickey.dump :disscution => {:speaker => {:login => 'xli'}}
+    assert_equal 'xli', disscution.speaker.login
+  end
+  
+  def test_through_and_as
+    # fail('do we need this?')
+  end
+
+  #active_record couldn't work on has_one :through belongs to
+  def xtest_with_option_through_belongs_to
+    user = User.create(:login => 'xli')
+    DisscutionBelongsToTopic.create!(:owner => user)
+    assert_equal 'xli', d.owner.login
+    
+    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.dump :disscution_belongs_to_topic => {:speaker => {:login => 'xli'}}
+    assert_equal 'xli', disscution_belongs_to_topic.speaker.login
+  end
+end