mleung-koujou 0.0.2

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2009-07-14
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,29 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+koujou.gemspec
+lib/koujou.rb
+lib/koujou/builder.rb
+lib/koujou/custom_validation.rb
+lib/koujou/data_generator.rb
+lib/koujou/sequence.rb
+lib/koujou/validation_reflection.rb
+script/console
+script/destroy
+script/generate
+test/lib/active_record_test_connector.rb
+test/lib/models/car.rb
+test/lib/models/comment.rb
+test/lib/models/message.rb
+test/lib/models/photo.rb
+test/lib/models/post.rb
+test/lib/models/profile.rb
+test/lib/models/user.rb
+test/test_builder.rb
+test/test_custom_validation.rb
+test/test_data_generator.rb
+test/test_helper.rb
+test/test_kojo.rb
+test/test_sequence.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on koujou, see http://koujou.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,43 @@
+= koujou
+
+* http://github.com/mleung/koujou
+
+== DESCRIPTION:
+
+Koujou is a fixture replacement that requires no effort to use. You don't have to define a single thing
+in your test_helper or whatever. Just call the koujou method on your active record model, and you're 
+off. 
+
+Check out: http://www.michaelleung.us/koujou for all the juicy details.
+
+Please note this is a very early release of koujou, so if you find any issues, just post
+them here: http://github.com/mleung/koujou/issues
+
+== INSTALL:
+
+gem install mleung-koujou --source http://gems.github.com
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Michael Leung
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/koujou'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'koujou' do
+  self.developer 'Michael Leung', 'me@michaelleung.us'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/lib/koujou.rb

@@ -0,0 +1,22 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'active_record'
+require 'faker'
+require 'koujou/sequence'
+require 'koujou/builder'
+require 'koujou/data_generator'
+require 'koujou/validation_reflection'
+require 'koujou/custom_validation'
+
+module Koujou
+  VERSION = '0.0.1'
+end
+
+ActiveRecord::Base.class_eval do
+  include Koujou::ActiveRecordExtensions::ValidationReflection
+  Koujou::ActiveRecordExtensions::ValidationReflection.install(self)
+  include Koujou::ActiveRecordExtensions::Builder
+end
+

data/lib/koujou/builder.rb

@@ -0,0 +1,209 @@
+module Koujou #:nodoc:
+  module ActiveRecordExtensions # :nodoc:
+    module Builder # :nodoc:
+
+      def self.included(base) # :nodoc:
+        base.extend ClassMethods
+      end
+
+      module ClassMethods #:nodoc:
+      
+        def koujou(create = true, attributes = nil)
+          generate_instance(create, attributes)
+        end
+      
+        def koujou_build(attributes = nil)
+          koujou(false, attributes)
+        end
+      
+        def koujou_create(attributes = nil)
+          koujou(true, attributes)
+        end
+
+        protected
+          def generate_instance(create, attributes)
+            # There were a metric ton of AR warnings about instance vars
+            # not being initialized when running our specs. This hides those.
+            silence_warnings do
+              instance = build_model_instance(self, attributes)
+              instance.save! if create 
+              instance
+            end
+          end
+        
+          def build_model_instance(klass, attributes = nil, recursed_from_model = nil)
+            # If we pass in a string here for klass instead of a constant
+            # we want to convert that. 
+            klass = Kernel.const_get(klass) unless klass.respond_to?(:new)
+            instance = klass.new
+            # Set the models attributes if the user passed them in.
+            # This will allow attributes to be set regardless if
+            # they're required or not.
+            instance.attributes = attributes unless attributes.nil?
+            
+            set_required_attributes!(instance, attributes)
+            set_unique_attributes!(instance, attributes)
+            set_confirmation_attributes!(instance, attributes)
+            set_length_validated_attributes!(instance, attributes)
+            set_inclusion_validated_attributes!(instance, attributes)
+            create_associations(instance, recursed_from_model)
+            CustomValidation.stub_custom_validations!(instance)
+
+            instance
+          end
+        
+          def set_required_attributes!(instance, attributes)
+            instance.class.required_validations.each do |v|
+              # We want to skip over setting any required fields if the field
+              # should also be unique. We handle that in the set_unique_attributes!
+              # method with a sequence. Also, if it's a confirmation field (e.g. password_confirmation)
+              # we can skip it, because that gets set below.
+              standard_required_attributes(instance, v) do
+                # We don't want to set anything if the user passed in data for this field
+                # or if this is a validates_presence_of :some_id. The ids will be set
+                # when we create the association.
+                next if overridden_attribute?(attributes, v.name)
+                # has_required_id_validation?(instance, v.name)
+                
+                generate_and_set_data(instance, v, false)
+              end
+            end
+          end
+
+          def set_unique_attributes!(instance, attributes)
+            instance.class.unique_validations.each do |v| 
+              next if overridden_attribute?(attributes, v.name)
+              generate_and_set_data(instance, v, true)
+            end
+          end
+          
+          # This generates set_length_validated_attributes! and set_inclusion_validated_attributes! methods.
+          # They used to look like this:
+          #
+          # def set_length_validated_attributes!(instance, attributes)
+          #   instance.class.length_validations.each do |v|
+          #     non_required_attributes(instance, v, attributes) { generate_and_set_data(instance, v, false) }
+          #   end
+          # end
+          #
+          # def set_inclusion_of_validated_attributes!(instance, attributes)
+          #   instance.class.inclusion_validations.each do |v|
+          #     non_required_attributes(instance, v, attributes) { generate_and_set_data(instance, v, false) }
+          #   end
+          # end
+          # I'm sure you see the similarities. 
+          %w(length inclusion).each do |validation|
+            define_method("set_#{validation}_validated_attributes!") do |instance, attributes|
+              instance.class.send("#{validation}_validations").each do |v|
+                # Non required attributes are anything that doesn't have validates_presence_of, 
+                # validates_uniqueness_of and also anything that hasn't been overriden. These
+                # values get set there. So there's no real point in setting them again here. 
+                non_required_attributes(instance, v, attributes) { generate_and_set_data(instance, v, false) }
+              end
+            end
+          end
+          
+
+          def set_confirmation_attributes!(instance, attributes)
+            instance.class.confirmation_validations.each do |v|
+              # This goes in and sets the models confirmation to whatever the corresponding
+              # fields value is. (e.g. password_confirmation= password)
+              instance.send("#{v.name}_confirmation=", instance.send("#{v.name}"))
+            end
+          end
+          
+          
+          def create_associations(instance, recursed_from_model = nil)
+            # We loop through all the has_one or belongs_to associations on the current instance 
+            # using introspection, and build up and assign some models to each, if the user has 
+            # required the id (e.g. requires_presence_of :user_id). So we're only going to build 
+            # the minimum requirements for each model. 
+            instance.class.reflect_on_all_associations.each do |a|
+              # We only want to create the association if the user has required the id field. 
+              # This will build the minimum valid requirements. 
+              next unless has_required_id_validation?(instance, a.name)
+              
+              if a.macro == :has_one || a.macro == :belongs_to
+                # If there's a two way association here (user has_one profile, profile belongs_to user)
+                # we only want to create one of those, or it'll recurse forever. That's what the 
+                # recursed_from_model does. 
+                unless recursed_from_model.to_s == instance.class.to_s.downcase
+                  instance.send("#{a.name.to_s}=", build_model_instance(get_assocation_class_name(a), nil, a.name))
+                end
+              end
+              
+            end
+          end
+          
+          def get_assocation_class_name(assocation)
+            # This condition is used if the class_name option
+            # is passed to has_many or has_one. We'll definitely
+            # want to use that key instead of the name of the association.
+            if assocation.options.has_key?(:class_name)
+              klass = assocation.options[:class_name]
+            else
+              klass = assocation.name.to_s.singularize.classify
+            end
+          end
+          
+          def generate_and_set_data(instance, validation, sequenced)
+            data_generator = DataGenerator.new(sequenced, validation)
+            data_generator.required_length = get_required_length(instance, validation)
+            if has_inclusion_validation?(instance, validation)
+              data_generator.inclusion_values = get_inclusion_values(instance, validation)
+            end
+            instance.send("#{validation.name}=", data_generator.generate_data_for_column_type)
+          end
+          
+          def standard_required_attributes(instance, validation)
+            yield unless has_unique_validation?(instance, validation) 
+          end
+          
+          def non_required_attributes(instance, validation, attributes)
+            yield unless has_unique_validation?(instance, validation) || has_required_validation?(instance, validation) ||
+                    overridden_attribute?(attributes, validation.name)
+          end
+          
+          def overridden_attribute?(attributes, key)
+            attributes && attributes.has_key?(key.to_sym)
+          end
+
+          # This creates has_unique_validation?, has_length_validation? etc. 
+          # We could probably make one method that takes a type, but I'd rather
+          # get separate methods for each. Cool?
+          %w(unique length required inclusion).each do |v|
+            define_method("has_#{v}_validation?") do |instance, validation|
+              !instance.class.send("#{v}_validations").select{|u| u.name == validation.name }.empty?
+            end
+          end
+                    
+          def get_required_length(instance, validation)
+            return unless has_length_validation?(instance, validation)
+            
+            options = instance.class.length_validations.select{|v| v.name == validation.name }.first.options
+            
+            # If the validation is validates_length_of :name, :within => 1..20 (or in, which is an alias),
+            # let's just return the minimum value of the range. 
+            %w(within in).each { |o| return options[o.to_sym].entries.first if options.has_key?(o.to_sym) }
+            # These other validations should just return the value set.
+            %w(is minimum maximum).each { |o| return options[o.to_sym] if options.has_key?(o.to_sym)  }
+            
+            nil
+          end
+          
+          def get_inclusion_values(instance, validation)
+            return unless has_inclusion_validation?(instance, validation) 
+            options = instance.class.inclusion_validations.select{|v| v.name == validation.name }.first.options
+            return unless options.has_key?(:in)
+            options[:in]
+          end
+          
+          def has_required_id_validation?(instance, name)
+            !instance.class.required_validations.select{|v| v.name.to_s  == "#{name}_id" }.empty?
+          end
+          
+      end
+      
+    end
+  end
+end

data/lib/koujou/data_generator.rb

@@ -0,0 +1,90 @@
+module Koujou #:nodoc:
+  class DataGenerator
+
+    attr_accessor :required_length, :inclusion_values
+    
+    def initialize(sequenced, validation)
+      @sequenced = sequenced
+      # Validation is actually a ActiveRecord::Reflection::MacroReflection
+      @validation = validation
+    end
+
+    def generate_data_for_column_type
+      # So if there was an inclusion passed in for validations_inclusion_of (which is just 
+      # an enumberable object), let's just return the first element to ensure the value
+      # set is the correct one. Mmmkay?
+      return get_first_value_for_inclusion unless @inclusion_values.nil?
+      # Sometimes models have a validates_presence_of set, but there's no corresponding 
+      # db column. The only example I can think of for this is a user model where the actual
+      # column is hashed_password but the model requires the presence of password. So we'll 
+      # assume string. This could bite me in the ass later, but we'll see.
+      if @validation.active_record.columns_hash.has_key?("#{@validation.name}")
+        db_type = @validation.active_record.columns_hash["#{@validation.name}"].type
+      else
+        db_type = 'string'
+      end
+      # Since the method names are all based on the db types, we'll just go ahead and
+      # dynamically call the appropriate one. 
+      send("generate_#{db_type}")
+    end
+    
+    def generate_string
+      return format_if_sequenced(Faker::Internet.email)     if @validation.name.to_s.match(/email/)
+      return format_if_sequenced(Faker::Name.first_name)    if @validation.name.to_s == 'first_name'
+      return format_if_sequenced(Faker::Name.last_name)     if @validation.name.to_s == 'last_name'
+      return format_if_sequenced(Faker::Internet.user_name) if @validation.name.to_s.match(/login|user_name/)
+      return format_if_sequenced(Faker::Address.city)       if @validation.name.to_s.match(/city/)
+      return format_if_sequenced(Faker::Address.us_state)   if @validation.name.to_s.match(/state|province/)
+      return format_if_sequenced(Faker::Address.zip_code)   if @validation.name.to_s.match(/zip|postal/)
+
+      # If we don't match any standard stuff, just return a regular bs lorem string comprised of 10 words.
+      # 10 is sort of a "magic number" I might make a constant for that.
+      standard_text = format_if_sequenced(Faker::Lorem.words(10).to_s)
+      # So if there's a length validation set, we need to return just that amount of data.
+      standard_text = standard_text[0..@required_length - 1].to_s  if @required_length
+      standard_text
+    end
+    
+    def generate_text
+      if @required_length
+        # So if there's a length validation set, we need to return just that amount of data.
+        Faker::Lorem.paragraph(2).to_s[0..@required_length - 1]
+      else
+        Faker::Lorem.paragraph.to_s
+      end
+    end
+    
+    def generate_integer
+      generate_number
+    end
+    
+    def generate_float
+      generate_number.to_f
+    end
+    
+    def generate_datetime
+      DateTime.now
+    end
+    
+    def generate_boolean
+      true
+    end
+          
+    protected 
+      def generate_number
+        # If this is supposed to be sequenced (aka unique), we'll get the next int from the 
+        # Sequence class, and randomize that.
+        random = rand(999)
+        @sequenced ? random + (Sequence.instance.next * rand(2)) : random
+      end
+
+      def format_if_sequenced(val)
+        @sequenced ? "#{Sequence.instance.next}#{val}" : val
+      end
+      
+      def get_first_value_for_inclusion
+        @inclusion_values.first
+      end
+      
+  end
+end

data/lib/koujou/sequence.rb

@@ -0,0 +1,11 @@
+module Koujou #:nodoc:
+  class Sequence # :nodoc:
+    include Singleton
+    def initialize
+      @current_value = 1
+    end
+    def next
+      @current_value += 1
+    end
+  end
+end

data/lib/koujou/validation_reflection.rb

@@ -0,0 +1,147 @@
+#--
+# Copyright (c) 2006-2008, Michael Schuerig, michael@schuerig.de
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+
+require 'active_record/reflection'
+require 'ostruct'
+
+# Based on code by Sebastian Kanthak
+# See http://dev.rubyonrails.org/ticket/861
+module Koujou # :nodoc:
+  module ActiveRecordExtensions # :nodoc:
+    module ValidationReflection # :nodoc:
+      
+      mattr_accessor :reflected_validations
+      Koujou::ActiveRecordExtensions::ValidationReflection.reflected_validations = %w(
+         validates_acceptance_of
+         validates_associated
+         validates_confirmation_of
+         validates_exclusion_of
+         validates_format_of
+         validates_inclusion_of
+         validates_length_of
+         validates_size_of
+         validates_numericality_of
+         validates_presence_of
+         validates_uniqueness_of
+         validate
+      )
+
+      mattr_accessor :in_ignored_subvalidation
+      Koujou::ActiveRecordExtensions::ValidationReflection.in_ignored_subvalidation = false
+      
+      def self.included(base)
+        return if base.kind_of?(Koujou::ActiveRecordExtensions::ValidationReflection::ClassMethods)
+        base.extend(ClassMethods)
+      end
+
+      def self.install(base)
+        reflected_validations.freeze
+        reflected_validations.each do |validation_type|
+          next if base.respond_to?("#{validation_type}_with_reflection")
+          ignore_subvalidations = false
+          if validation_type.kind_of?(Hash)
+            ignore_subvalidations = validation_type[:ignore_subvalidations]
+            validation_type = validation_type[:method]
+          end
+          base.class_eval <<-"end_eval"
+            class << self
+              def #{validation_type}_with_reflection(*attr_names)
+                ignoring_subvalidations(#{ignore_subvalidations}) do
+                  #{validation_type}_without_reflection(*attr_names)
+                  remember_validation_metadata(:#{validation_type}, *attr_names)
+                end
+              end
+
+              alias_method_chain :#{validation_type}, :reflection
+            end
+          end_eval
+        end
+      end
+
+      module ClassMethods
+
+        # Returns an array of MacroReflection objects for all validations in the class
+        def reflect_on_all_validations
+          read_inheritable_attribute(:validations) || []
+        end
+
+        # Returns an array of MacroReflection objects for all validations defined for the field +attr_name+.
+        def reflect_on_validations_for(attr_name)
+          attr_name = attr_name.to_sym
+          reflect_on_all_validations.select do |reflection|
+            reflection.name == attr_name
+          end
+        end
+        
+        # A few convenience methods added in by Mike. Why not loop and define_method these?
+        
+        def unique_validations
+          reflect_on_all_validations.select{|v| v.macro == :validates_uniqueness_of }
+        end
+
+        def required_validations
+          reflect_on_all_validations.select{|v| v.macro == :validates_presence_of }
+        end
+
+        def confirmation_validations
+          reflect_on_all_validations.select{|v| v.macro == :validates_confirmation_of }
+        end
+        
+        def length_validations
+          reflect_on_all_validations.select{|v| v.macro == :validates_length_of || v.macro == :validates_size_of }
+        end
+        
+        def inclusion_validations
+          reflect_on_all_validations.select{|v| v.macro == :validates_inclusion_of }
+        end
+
+        def custom_validations
+          # We don't want to get anything like: validate_associated_records_for_posts.
+          reflect_on_all_validations.select{|v| v.macro == :validate && !v.macro.to_s.match("_associated_") }
+        end
+        
+        private
+        
+        def remember_validation_metadata(validation_type, *attr_names)
+          configuration = attr_names.last.is_a?(Hash) ? attr_names.pop : {}
+          attr_names.each do |attr_name|
+            write_inheritable_array :validations,
+              [ ActiveRecord::Reflection::MacroReflection.new(validation_type, attr_name.to_sym, configuration, self) ]
+          end
+        end
+        
+        def ignoring_subvalidations(ignore)
+          save_ignore = Koujou::ActiveRecordExtensions::ValidationReflection.in_ignored_subvalidation
+          unless Koujou::ActiveRecordExtensions::ValidationReflection.in_ignored_subvalidation
+            Koujou::ActiveRecordExtensions::ValidationReflection.in_ignored_subvalidation = ignore
+            yield
+          end
+        ensure
+          Koujou::ActiveRecordExtensions::ValidationReflection.in_ignored_subvalidation = save_ignore
+        end
+      end
+
+    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/koujou.rb'}"
+puts "Loading koujou gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/lib/active_record_test_connector.rb

@@ -0,0 +1,78 @@
+# This let's us happily test AR. 
+require 'active_record'
+# Require all our models.
+Dir.glob(File.join(File.dirname(__FILE__), "..", "lib", "models", "*.rb")).each { |f| require f }
+
+
+class ActiveRecordTestConnector
+  cattr_accessor :connected
+  cattr_accessor :able_to_connect
+  
+  self.connected = false
+  self.able_to_connect = true
+  
+  class << self
+  
+    def setup
+      unless self.connected || !self.able_to_connect
+        setup_connection
+        load_schema
+        self.connected = true
+      end
+    rescue Exception => e  # errors from ActiveRecord setup
+      $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
+      self.able_to_connect = false
+    end
+  
+    def setup_connection
+      ActiveRecord::Base.establish_connection({
+        :adapter => 'sqlite3',
+        :dbfile => 'test.sqlite3'
+      })
+    end
+    
+    def load_schema
+      ActiveRecord::Schema.define do
+        create_table "users", :force => true do |t|
+          t.string "name", "email", "first_name", "last_name", "hashed_password"
+          t.integer "age"
+          t.float "salary"
+          t.datetime "hired_on"
+          t.boolean "terms_of_service"
+        end
+        create_table "posts", :force => true do |t|
+          t.string "name"
+          t.text "body"
+          t.integer "user_id"
+        end
+        create_table "comments", :force => true do |t|
+          t.text "bod"
+          t.integer "post_id"
+        end
+        create_table "profiles", :force => true do |t|
+          t.integer "user_id"
+          t.boolean "likes_cheese"
+        end
+        create_table "photos", :force => true do |t|
+          t.integer "profile_id"
+        end
+        create_table "messages", :force => true do |t|
+          t.string   "subject"
+          t.text     "body"
+          t.datetime "created_at"
+          t.datetime "updated_at"
+          t.integer  "sender_id"
+          t.integer  "receiver_id"
+          t.boolean  "read"
+        end
+        create_table "cars", :force => true do |t|
+          t.integer "user_id", "year"
+          t.string "make", "model"
+        end
+      end
+    end
+     
+  end
+end
+
+

data/test/lib/models/comment.rb

@@ -0,0 +1,7 @@
+class Comment < ActiveRecord::Base
+  validates_presence_of :bod
+  validates_length_of :bod, :maximum => 200
+  
+  belongs_to :post
+  
+end

data/test/lib/models/post.rb

@@ -0,0 +1,15 @@
+class Post < ActiveRecord::Base
+  validates_presence_of :name
+  validates_length_of :body, :is => 20
+  
+  belongs_to :user
+  has_many :comments
+  
+  validate :craziness
+  
+  protected
+    def craziness
+      raise 'No way Jose' if "Matz" != "Guido van Rossum"
+    end
+  
+end

data/test/lib/models/profile.rb

@@ -0,0 +1,9 @@
+class Profile < ActiveRecord::Base
+  belongs_to :user
+  has_many :photos, :order => 'created_at DESC'
+  
+  has_many :sent_messages, :class_name => 'Message', :order => 'created_at desc', :foreign_key => 'sender_id'
+  
+  validates_presence_of :user_id
+    
+end

data/test/lib/models/user.rb

@@ -0,0 +1,38 @@
+class User < ActiveRecord::Base
+  validates_presence_of :name, :age, :salary, :hired_on, :email, :first_name, :last_name
+  validates_uniqueness_of :name
+  validates_acceptance_of :terms_of_service
+
+  attr_accessor :password
+
+  
+  # This is basically the main validation from restful_auth's user model.
+  validates_presence_of     :password,                   :if => :password_required?
+  validates_presence_of     :password_confirmation,      :if => :password_required?
+  validates_length_of       :password, :within => 4..40, :if => :password_required?
+  validates_confirmation_of :password,                   :if => :password_required?
+  validates_length_of       :email,    :within => 3..100
+  
+  has_many :posts
+  has_one :profile
+  
+  attr_accessible :email, :password, :password_confirmation
+  
+  validate :custom_validation_method
+  validate :custom_private_method
+  
+  def password_required?
+    true
+  end
+  
+  def custom_validation_method
+    false
+  end
+  
+  private
+    def custom_private_method
+      false
+    end
+  
+  
+end

data/test/test_builder.rb

@@ -0,0 +1,143 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestBuilder < Test::Unit::TestCase
+
+  # Gives us DB access.
+  ActiveRecordTestConnector.setup
+
+  context 'ActiveRecord' do
+  
+    should 'have the koujou method' do
+      assert User.respond_to?(:koujou)
+    end
+    
+    should 'return an instance of User, with ActiveRecord::Base as an ancestor' do
+      u = User.koujou
+      assert_equal User, u.class
+      assert u.class.ancestors.include?(ActiveRecord::Base)
+    end
+  end
+  
+  context 'on sending the koujou message' do
+    
+    should 'persist the record to the db without any arguments' do
+      u = User.koujou
+      assert !u.new_record?
+    end
+    
+    should 'return a new record when passing in false' do
+      u = User.koujou(false)
+      assert u.new_record?
+    end
+    
+    should 'have unique values for multiple instances where validates_uniqueness_of is defined for a column' do
+      u1 = User.koujou
+      u2 = User.koujou
+      assert_not_equal u1.name, u2.name
+    end
+    
+    should 'have a password confirmation automatically set' do
+      u = User.koujou
+      assert_not_nil u.password_confirmation
+    end
+    
+    should 'allow me to override the model attributes' do
+      namae = 'One Factory to Rule them all'
+      p = Post.koujou(true, :name => namae)
+      assert_equal namae, p.name
+    end
+    
+    should 'allow me to override select attributes, yet still generate data for the rest' do
+      # We have a validates_length_of :bod, :is => 20 set.
+      bod = "T" * 20
+      p = Post.koujou_create(:body => bod)
+      assert_not_nil p.name
+      assert_equal bod, p.body
+    end
+        
+  end
+  
+  context 'on sending the koujou_create message' do
+  
+    should 'persist the record to the db' do
+      u = User.koujou_create
+      assert !u.new_record?
+    end
+    
+    should 'allow me to override the model attributes' do
+      comment = 'your post is epic fail'
+      c = Comment.koujou_create(:bod => comment)
+      assert_equal comment, c.bod
+    end
+    
+    should 'not be sequenced unless I say so' do
+      u = User.koujou
+      # The first digit should not be an integer.
+      assert_equal 0, u.first_name[0,1].to_i
+    end
+    
+  end
+  
+  context 'on sending the koujou_build message' do
+    
+    should 'return a new record' do
+      u = User.koujou_build
+      assert u.new_record?
+    end
+    
+    should 'allow me to override the model attributes' do
+      clever = 'Whatever\'s clever'
+      p = Post.koujou_build(:name => clever)
+      assert_equal clever, p.name
+    end
+    
+  end
+  
+  context 'associations' do
+    
+    should 'not automatically create any assoications unless there\'s a validation for the id' do
+      u = User.koujou
+      assert_equal 0, u.posts.size
+    end
+    
+    should 'automatically create a user for a profile when the profile has a required user_id validation' do
+      p = Profile.koujou
+      assert_not_nil p.user
+    end
+    
+    should 'find custom validations' do
+      User.reflect_on_all_validations.each do |v|
+        puts v.inspect if v.macro == :validate
+      end
+    end
+    
+  end
+  
+  context 'custom validations' do
+    
+    should 'totally override any custom validations, and thus not fail when we call koujou' do
+      p = Post.koujou
+      assert true
+    end
+    
+  end
+  
+  context 'inclusion_of_validation' do
+    
+    should 'create the correct value for an attribute marked with validates_inclusion_of' do
+      c = Car.koujou
+      assert_equal 'Nissan', c.make
+    end
+    
+    should 'create the correct values for inclusion when it\'s not also a required attribute' do
+      c = Car.koujou
+      assert_equal 1900, c.year
+    end
+    
+  end
+  
+  
+end
+
+
+

data/test/test_data_generator.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestDataGenerator < Test::Unit::TestCase
+
+  context 'on generate' do
+    
+    setup do
+      @validation = mock("ActiveRecord::Reflection::MacroReflection")
+      @validation.expects(:active_record).twice.returns(User)
+    end
+    
+    should 'generate a valid int' do
+      @validation.expects(:name).twice.returns('age')
+      int = Koujou::DataGenerator.new(false, @validation).generate_data_for_column_type
+      assert_kind_of Fixnum, int
+      assert int > 0
+    end
+
+    should 'generate a valid float' do
+      @validation.expects(:name).twice.returns('salary')
+      float = Koujou::DataGenerator.new(false, @validation).generate_data_for_column_type
+      assert_kind_of Float, float
+    end
+    
+    should 'generate a valid string' do
+      @validation.expects(:name).times(1..10).returns('name')
+      string = Koujou::DataGenerator.new(false, @validation).generate_data_for_column_type
+      assert_kind_of String, string
+      assert string.size > 0
+    end
+    
+    should 'generate a valid email' do
+      @validation.expects(:name).times(1..10).returns('email')
+      email = Koujou::DataGenerator.new(false, @validation).generate_data_for_column_type
+      assert_match(/\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, email)
+    end
+    
+    should 'generate a valid datetime' do
+      @validation.expects(:name).twice.returns('hired_on')
+      dt = Koujou::DataGenerator.new(false, @validation).generate_data_for_column_type
+      assert_kind_of DateTime, dt
+    end
+    
+    should 'always generate true for booleans' do
+      @validation.expects(:name).twice.returns('terms_of_service')
+      assert Koujou::DataGenerator.new(false, @validation).generate_data_for_column_type
+    end
+    
+  end
+  
+  context 'on generate with a required length' do
+    setup do
+      @validation = mock("ActiveRecord::Reflection::MacroReflection")
+      @validation.expects(:active_record).twice.returns(Post)
+    end
+    
+    should 'generate the correct size string with a length passed in' do
+      @validation.expects(:name).twice.returns('body')
+      data_generator = Koujou::DataGenerator.new(false, @validation)
+      data_generator.required_length = 20
+      body = data_generator.generate_data_for_column_type
+      assert_equal 20, body.size
+    end
+    
+  end
+  
+  context 'on generate with an inclusion' do
+    
+    setup do
+      @validation = mock("ActiveRecord::Reflection::MacroReflection")
+    end
+    
+    should 'generate the correct string with an inclusion_value passed in' do
+      data_generator = Koujou::DataGenerator.new(false, @validation)
+      data_generator.inclusion_values = %w(Nissan Subaru)
+      make = data_generator.generate_data_for_column_type
+      assert_equal 'Nissan', make
+    end
+    
+    should 'generate the correct int with an inclusion_value passed in' do
+      data_generator = Koujou::DataGenerator.new(false, @validation)
+      data_generator.inclusion_values = (1..3)
+      num = data_generator.generate_data_for_column_type
+      assert_equal 1, num
+    end
+    
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'stringio'
+require 'test/unit'
+require 'rubygems'
+gem 'thoughtbot-shoulda'
+require 'shoulda'
+gem 'mocha'
+require 'mocha'
+require File.dirname(__FILE__) + '/../lib/koujou'
+require File.join(File.dirname(__FILE__), 'lib', 'active_record_test_connector')
+
+

data/test/test_kojo.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestKoujou < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+    # assert User.respond_to?(:koujou)
+  end
+end

data/test/test_sequence.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestSequence < Test::Unit::TestCase
+  
+  context "sequence" do
+    
+    should "implement the singleton pattern" do
+      assert !Koujou::Sequence.respond_to?(:new)
+      assert Koujou::Sequence.include?(Singleton)
+    end
+    
+    should "generate successive numbers when calling next" do
+      first = Koujou::Sequence.instance.next
+      second = Koujou::Sequence.instance.next
+      assert_not_equal first, second
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: mleung-koujou
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Michael Leung
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-19 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: faker
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.2
+    version: 
+description: "Koujou is a fixture replacement that requires no effort to use. You don't have to define a single thing in your test_helper or whatever. Just call the koujou method on your active record model, and you're  off.   check out: http://www.michaelleung.us/koujou for all the juicy details."
+email: 
+- me@michaelleung.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/koujou.rb
+- lib/koujou/builder.rb
+- lib/koujou/data_generator.rb
+- lib/koujou/sequence.rb
+- lib/koujou/validation_reflection.rb
+- script/console
+- script/destroy
+- script/generate
+- test/lib/active_record_test_connector.rb
+- test/lib/models/comment.rb
+- test/lib/models/post.rb
+- test/lib/models/profile.rb
+- test/lib/models/user.rb
+- test/test_builder.rb
+- test/test_data_generator.rb
+- test/test_helper.rb
+- test/test_kojo.rb
+- test/test_sequence.rb
+has_rdoc: true
+homepage: http://github.com/mleung/koujou
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: koujou
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Koujou is a fixture replacement that requires no effort to use
+test_files: 
+- test/test_builder.rb
+- test/test_data_generator.rb
+- test/test_helper.rb
+- test/test_kojo.rb
+- test/test_sequence.rb