xli-hickey 0.0.1

data/lib/hickey/domain_detector/base.rb

@@ -0,0 +1,55 @@
+module Hickey
+  module DomainDetector
+    class Base
+      def visit(domain)
+        r = {}
+        domain.each do |key, value|
+          r[key] = value.accept_for_hickey(key, self)
+        end
+        r.size == 1 ? r.values.first : r
+      end
+      
+      def visit_hash(attribute, record)
+        owner = new_instance(attribute, record)
+        after_created = []
+
+        record.each do |key, value|
+          if reflection = owner.class.reflections[key]
+            after_created << send(reflection.macro, owner, reflection, value)
+          else
+            owner.send :write_attribute, key, value
+          end
+        end
+        
+        #bypass new alias method chain of save! method
+        owner.save_with_validation!
+
+        after_created.each(&:call)
+        owner
+      end
+      
+      private
+      def new_instance(class_or_instance, record)
+        return class_or_instance unless ['Class', 'String', 'Symbol'].include?(class_or_instance.class.name)
+        compute_type(class_or_instance, record).new
+      end
+      
+      def compute_type(class_name, record)
+        klass = class_name.is_a?(Class) ? class_name : class_name.to_s.classify.constantize
+        if (subclass_name = record[klass.inheritance_column.to_sym]).blank?
+          klass
+        else
+          begin
+            subclass_name.to_s.classify.constantize
+          rescue NameError
+            raise ActiveRecord::SubclassNotFound,
+              "The single-table inheritance mechanism failed to locate the subclass: '#{subclass_name}'. " +
+              "This error is raised because the column '#{klass.inheritance_column}' is reserved for storing the class in case of inheritance. " +
+              "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+              "or overwrite #{klass.name}.inheritance_column to use another column for that information."
+          end
+        end
+      end
+    end
+  end
+end

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/lib/hickey/domain_detector.rb

@@ -0,0 +1,17 @@
+require 'hickey/domain_detector/base'
+require 'hickey/domain_detector/associations'
+require 'hickey/domain_detector/configurable'
+require 'hickey/domain_detector/actions'
+require 'hickey/domain_detector/scopes'
+
+Hickey::DomainDetector::Base.class_eval do
+  include Hickey::DomainDetector::BelongsToAssociation
+  include Hickey::DomainDetector::HasOneAssociation
+  include Hickey::DomainDetector::HasOneThroughAssociation
+  include Hickey::DomainDetector::HasManyAssociation
+  include Hickey::DomainDetector::HasManyThroughAssociation
+  include Hickey::DomainDetector::HasAndBelongsToManyAssociation
+  include Hickey::DomainDetector::Configurable
+  include Hickey::DomainDetector::Scopes
+  include Hickey::DomainDetector::Actions
+end

data/lib/hickey.rb

@@ -0,0 +1,22 @@
+
+begin
+  require 'active_record'
+rescue LoadError
+  require 'rubygems'
+  require 'active_record'
+end
+
+require 'hickey/acceptor'
+require 'hickey/domain_detector'
+
+module Hickey
+  def kiss(domain)
+    DomainDetector::Base.new.visit(domain)
+  end
+  
+  def lipstick(domain={})
+    DomainDetector::Base.configurations.merge! domain
+  end
+  
+  module_function :kiss, :lipstick
+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.kiss :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'}}
+    
+    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,135 @@
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+class EnableCallbacksTest < Test::Unit::TestCase
+  
+  def teardown
+    Hickey.lipstick.clear
+    Simple.public_instance_methods(false).each do |method|
+      next if method == 'id'
+      Simple.class_eval "def #{method};end"
+    end
+  end
+  
+  def test_invoke_before_save_and_after_save_after_configured_all_callbacks
+    Hickey.lipstick(: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'})
+      end
+      def create_user_before_save
+        Hickey.kiss(:user => {:login => 'create_user_before_save'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+    
+    Hickey.kiss(: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})
+    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'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    Hickey.kiss(: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})
+    Simple.class_eval do
+      before_validation :create_user_before_validation
+      def create_user_before_validation
+        Hickey.kiss(:user => {:login => 'create_user_before_validation'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    Hickey.kiss(: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})
+    Simple.class_eval do
+      after_validation :create_user_after_validation
+      def create_user_after_validation
+        Hickey.kiss(:user => {:login => 'create_user_after_validation'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    Hickey.kiss(: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.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'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    Hickey.kiss(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})
+    DatePropertyDefinition.class_eval do
+      after_validation :create_user_after_validation
+      def create_user_after_validation
+        Hickey.kiss(:user => {:login => 'create_user_after_validation'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    Hickey.kiss(: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]})
+    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'})
+      end
+      def create_user_after_create
+        Hickey.kiss(:user => {:login => 'create_user_after_create'})
+      end
+      def validate
+        raise 'should bypass'
+      end
+    end
+
+    Hickey.kiss(: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.kiss(:simple => {:create => {}})
+  end
+  
+  def test_create_multi_models
+    result = Hickey.kiss(: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}}]})
+    
+    assert_equal 'xli', project.users.first.login
+  end
+  
+  def test_find_action
+    simple1 = Hickey.kiss(:simple => {})
+    simple2 = Hickey.kiss(: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'}})
+    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}]})
+
+    project = Hickey.kiss(: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.kiss(:project => {:identifier => 'hickey', :users => [{:login => 'xli', :admin => true}]})
+
+    project = Hickey.kiss(: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.kiss(:simple => {:find_or_create => {}})
+    assert_equal 1, Simple.count(:all)
+    Hickey.kiss(: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.kiss :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.kiss(: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 => [{}, {}]}
+    
+    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.kiss :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'}]}
+    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.kiss :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'}]}
+    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'}}]}
+    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.kiss :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'}]}
+    
+    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'}
+    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.kiss :user => {:address => {:location => 'BeiJing'}}
+    assert_equal 'BeiJing', user.address.location
+  end
+  
+  def test_with_option_foreign_key
+    Hickey.kiss :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'}}
+    assert_equal 'Hello world', author.working_topic.title
+  end
+  
+  def test_with_option_through_has_one
+    Hickey.kiss :author => {:country => {:name => 'China'}}
+    assert_equal 'China', author.country.name
+  end
+  
+  def test_with_option_through_source
+    Hickey.kiss :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'}}
+    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.kiss :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'}}
+    assert_equal 'xli', disscution_belongs_to_topic.speaker.login
+  end
+end

data/test/model_association_test.rb

@@ -0,0 +1,21 @@
+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'}]}
+    
+    db_project = Project.find(:first)
+    assert_equal project, db_project
+    assert_equal project.projects_members.size, db_project.projects_members.size
+    assert_equal project.projects_members.first.user, db_project.projects_members.first.user
+  end
+
+  def test_create_associated_both_has_many_association_and_belongs_to_association_models
+    Hickey.kiss :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
+  end
+  
+end

data/test/models/address.rb

@@ -0,0 +1,5 @@
+class Address < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :country
+  should_bypass_all_callbacks_and_validations
+end

data/test/models/author.rb

@@ -0,0 +1,10 @@
+class Author < ActiveRecord::Base
+  set_table_name "users"
+  
+  has_one :address, :foreign_key => 'user_id'
+  has_one :working_topic, :as => :writer, :class_name => 'Topic'
+  has_one :country, :through => :address
+  has_one :living_country, :through => :address, :source => :country
+
+  should_bypass_all_callbacks_and_validations
+end

data/test/models/country.rb

@@ -0,0 +1,4 @@
+class Country < ActiveRecord::Base
+  has_and_belongs_to_many :users
+  should_bypass_all_callbacks_and_validations
+end

data/test/models/project.rb

@@ -0,0 +1,9 @@
+class Project < ActiveRecord::Base
+  has_many :projects_members
+  has_many :users, :through => :projects_members
+  has_many :admins, :through => :projects_members, :source => :user, :conditions => ["projects_members.admin = ?", true]
+  has_many :all_property_definitions, :class_name => 'PropertyDefinition'
+  has_many :tags
+  has_many :cards
+  should_bypass_all_callbacks_and_validations
+end

data/test/models/projects_member.rb

@@ -0,0 +1,5 @@
+class ProjectsMember < ActiveRecord::Base
+  belongs_to :project
+  belongs_to :user
+  should_bypass_all_callbacks_and_validations
+end

data/test/models/property_definition.rb

@@ -0,0 +1,21 @@
+class PropertyDefinition < ActiveRecord::Base
+  belongs_to :project
+end
+
+class EnumPropertyDefinition < PropertyDefinition
+  has_many :enum_values, :foreign_key => 'property_definition_id'
+  should_bypass_all_callbacks_and_validations
+end
+
+class UserPropertyDefinition < PropertyDefinition
+  should_bypass_all_callbacks_and_validations
+end
+
+class EnumValue < ActiveRecord::Base
+  belongs_to :property_definition, :class_name => "EnumeratedPropertyDefinition", :foreign_key => "property_definition_id"
+  should_bypass_all_callbacks_and_validations
+end
+
+class DatePropertyDefinition < PropertyDefinition
+end
+

data/test/models/simple.rb

@@ -0,0 +1,26 @@
+class Simple < ActiveRecord::Base
+end
+
+class Prisoner < ActiveRecord::Base
+  set_table_name "users"
+  
+  def login=(login)
+    raise 'unsupported operation'
+  end
+end
+
+class SimpleObserver < ActiveRecord::Observer
+
+  observe Simple
+  def after_save(simple)
+    raise 'should be bypass'
+  end
+
+  def after_create(simple)
+    raise 'should be bypass'
+  end
+
+  def after_update(simple)
+    raise 'should be bypass'
+  end
+end

data/test/models/tag.rb

@@ -0,0 +1,17 @@
+class Tag < ActiveRecord::Base
+  has_many :taggings, :class_name => '::Tagging'
+  belongs_to :project
+  
+  should_bypass_all_callbacks_and_validations
+end
+
+class Tagging < ActiveRecord::Base
+  belongs_to :tag
+  belongs_to :taggable, :polymorphic => true
+  should_bypass_all_callbacks_and_validations
+end
+
+class Card < ActiveRecord::Base
+  has_many :taggings, :as => :taggable
+  belongs_to :project
+end