hickey 0.0.2

data/Rakefile

@@ -0,0 +1,129 @@
+# Rakefile for Hickey        -*- ruby -*-
+
+# Copyright 2007 by Li Xiao (iam@li-xiao.com)
+# All rights reserved.
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/lib')
+require 'hickey'
+
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'rubygems'
+  require 'rake/gempackagetask'
+rescue Exception
+  nil
+end
+
+# The default task is run if rake is given no explicit arguments.
+
+desc "Default Task"
+task :default => :test_all
+
+# Common Abbreviations ...
+
+task :test_all => [:test_units]
+task :test => :test_units
+
+Rake::TestTask.new(:test_units) do |t|
+  t.test_files = FileList['test/*test.rb']
+  t.warning = false
+  t.verbose = false
+end
+
+# Create a task to build the RDOC documentation tree.
+
+rd = Rake::RDocTask.new("rdoc") { |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.template = 'html'
+  rdoc.title    = "Hickey"
+  rdoc.options << '--line-numbers' << '--inline-source' <<
+    '--main' << 'README.rdoc' <<
+    '--title' <<  'Hickey' 
+  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
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+    package_task = Rake::GemPackageTask.new(spec) do |pkg|
+      #pkg.need_zip = true
+      #pkg.need_tar = true
+    end
+  end
+end
+
+# Misc tasks =========================================================
+
+def count_lines(filename)
+  lines = 0
+  codelines = 0
+  open(filename) { |f|
+    f.each do |line|
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+  }
+  [lines, codelines]
+end
+
+def show_line(msg, lines, loc)
+  printf "%6s %6s   %s\n", lines.to_s, loc.to_s, msg
+end
+
+desc "Count lines in the main MM file"
+task :lines do
+  total_lines = 0
+  total_code = 0
+  show_line("File Name", "LINES", "LOC")
+  FileList['lib/**/*.rb', 'lib/**/*.rake'].each do |fn|
+    lines, codelines = count_lines(fn)
+    show_line(fn, lines, codelines)
+    total_lines += lines
+    total_code  += codelines
+  end
+  show_line("TOTAL", total_lines, total_code)
+end

data/TODO

@@ -0,0 +1,53 @@
+= Hickey Project -- To Do List
+
+Send suggestions for this list to iam@li-xiao.com
+
+=== To Do
+  * auto create model associations by each_card_type:
+      property_definitions_card_types => [:each_card_type => {}]
+  * specify item type by key name inside array list example: property_definitions => [{:enum_prop_def => {:name => 'xx'}}]
+  * with scope
+    * scope with user defined foreign_key id inside of model
+  * Single table inheritance
+    * has one
+    * belongs_to
+    * has_and_belongs_to_many
+  * log of creating domain progress for problem detecting
+  * auto_generate_position_for_model_acts_as_list
+  * prepare multi-models domain
+    * :source, :source_type options in has_many :through
+  * enable validations
+  * composed_of
+  * prepare with model validation
+  * should be in transaction?
+  * fast prepare by sql? really need it?
+  * enable callbacks
+    * enable specific method of callbacks?
+=== Done
+  * prepare model data should not trigger any callback
+  * prepare model with attributes
+  * prepare multi-models domain
+    * prepare has_many relationship models
+    * prepare belongs_to relationship models
+    * prepare belongs_and_has_many relationship models
+    * specify class by :class_name
+      * has_one
+      * has_and_belongs_to_many
+      * has_many
+      * belongs_to
+    * :through in has_one
+    * polymorphic
+    * foreign_key
+  * Single table inheritance
+    * has many
+  * enable callbacks
+    * enable all callbacks
+    * enable specific callbacks
+  * actions: find or create
+    * find
+    * create as default
+    * find_or_create
+  * with scope
+    * simple scope with default model foreign_key id inside of model
+
+(moved DONE list to CHANGES file)

data/hickey.gemspec

@@ -0,0 +1,27 @@
+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 = ["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"]
+
+  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).
+
+  spec.require_path = 'lib'                         # Use these for libraries.
+
+  #### Documentation and testing.
+
+  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.
+
+  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

@@ -0,0 +1,24 @@
+
+begin
+  require 'active_record'
+rescue LoadError
+  require 'rubygems'
+  require 'active_record'
+end
+
+require 'hickey/acceptor'
+require 'hickey/domain_detector'
+
+module Hickey
+  VERSION = '0.0.2'
+
+  def dump(domain)
+    DomainDetector::Base.new.visit(domain)
+  end
+  
+  def setup(domain={})
+    DomainDetector::Base.configurations.merge! domain
+  end
+  
+  module_function :dump, :setup
+end

data/lib/hickey/acceptor.rb

@@ -0,0 +1,25 @@
+module Hickey
+  module Acceptor
+    module Hash
+      def accept_for_hickey(klass, visitor)
+        visitor.visit_hash(klass, self)
+      end
+    end
+    module Array
+      def accept_for_hickey(klass, visitor)
+        collect do |o|
+          o.accept_for_hickey(klass, visitor)
+        end
+      end
+    end
+    module ReturnSelf
+      def accept_for_hickey(klass, visitor)
+        self
+      end
+    end
+  end
+end
+
+Array.send(:include, Hickey::Acceptor::Array)
+Hash.send(:include, Hickey::Acceptor::Hash)
+ActiveRecord::Base.send(:include, Hickey::Acceptor::ReturnSelf)

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

@@ -0,0 +1,38 @@
+module Hickey
+  module DomainDetector
+    module Actions
+      def self.included(base)
+        base.send(:alias_method_chain, :visit_hash, :find_or_create_actions)
+      end
+      
+      def visit_hash_with_find_or_create_actions(attribute, record)
+        case record.keys.first
+        when :find
+          record = record[:find]
+          attribute = find_action(attribute, record)
+        when :create
+          record = record[:create]
+        when :find_or_create
+          record = record[:find_or_create]
+          if find_attribute = find_action(attribute, record)
+            attribute = find_attribute
+          end
+        end
+        visit_hash_without_find_or_create_actions(attribute, record)
+      end
+      
+      def find_action(attribute, record)
+        model_type = compute_type(attribute, record)
+        conditions = record.inject({}) do |c, entity|
+          key, value = entity
+          unless [Hash, Array].include?(value.class)
+            #added if to filter column name for fixing hickey on acitverecord 1.2.6
+            c[key] = value if model_type.column_names.include?(key.to_s)
+          end
+          c
+        end
+        compute_type(attribute, record).find(:first, :conditions => conditions)
+      end
+    end
+  end
+end

data/lib/hickey/domain_detector/associations.rb

@@ -0,0 +1,80 @@
+module Hickey
+  module DomainDetector
+    module BelongsToAssociation
+      def belongs_to(owner, reflection, attr_value)
+        association = attr_value.accept_for_hickey(reflection.klass, self)
+        owner.send("#{reflection.primary_key_name}=", association.id)
+        Proc.new{}
+      end
+    end
+    
+    module HasOneAssociation
+      def has_one(owner, reflection, attr_value)
+        return has_one_through(owner, reflection, attr_value) if reflection.through_reflection
+
+        Proc.new do
+          attr_value[reflection.primary_key_name] = owner.id
+          if reflection.options[:as]
+            attr_value["#{reflection.options[:as]}_type"] = owner.class.base_class.name.to_s
+          end
+          attr_value.accept_for_hickey(reflection.klass, self)
+        end
+      end
+    end
+    
+    module HasOneThroughAssociation
+      def has_one_through(owner, reflection, attr_value)
+        through_reflection = reflection.through_reflection
+        Proc.new do
+          target = attr_value.accept_for_hickey(reflection.klass, self)
+          association = ActiveRecord::Associations::HasOneThroughAssociation.new(owner, reflection).send(:construct_join_attributes, target)
+          association.accept_for_hickey(through_reflection.klass, self)
+        end
+      end
+    end
+    
+    module HasManyAssociation
+      def has_many(owner, reflection, attr_value)
+        return has_many_through(owner, reflection, attr_value) if reflection.through_reflection
+
+        Proc.new do
+          attr_value.each do |obj|
+            obj[reflection.primary_key_name] = owner.id
+            if reflection.options[:as]
+              obj["#{reflection.options[:as]}_type"] = owner.class.base_class.name.to_s
+            end
+          end
+          attr_value.accept_for_hickey(reflection.klass, self)
+        end
+      end
+    end
+    
+    module HasManyThroughAssociation
+      def has_many_through(owner, reflection, attr_value)
+        through_reflection = reflection.through_reflection
+        Proc.new do
+          owner_associations = owner.send(reflection.name)
+          target = attr_value.accept_for_hickey(reflection.klass, self)
+          target.each do |record|
+            association = owner_associations.send(:construct_join_attributes, record)
+            proxy = through_reflection.klass.send(:with_scope, :create => association) do
+              visit_hash(through_reflection.klass, {})
+            end
+            owner_associations.proxy_target << proxy
+          end
+        end
+      end
+    end
+    
+    module HasAndBelongsToManyAssociation
+      def has_and_belongs_to_many(owner, reflection, attr_value)
+        association = attr_value.accept_for_hickey(reflection.klass, self)
+        Proc.new do
+          association.each do |record|
+            owner.send(reflection.name).send(:insert_record, record)
+          end
+        end
+      end
+    end
+  end
+end

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