koujou 0.1.0

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/koujou.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{koujou}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Leung"]
+  s.date = %q{2009-07-19}
+  s.description = %q{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.}
+  s.email = ["me@michaelleung.us"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt"]
+  s.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", "lib/koujou/custom_validation.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/mleung/koujou}
+  s.post_install_message = %q{PostInstall.txt}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{koujou}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Koujou is a fixture replacement that requires no effort to use}
+  s.test_files = ["test/test_builder.rb", "test/test_data_generator.rb", "test/test_helper.rb", "test/test_kojo.rb", "test/test_sequence.rb"]
+  s.add_dependency('faker', '>= 0.3.1')
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 2.3.2"])
+    else
+      s.add_dependency(%q<hoe>, [">= 2.3.2"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 2.3.2"])
+  end
+end

data/lib/koujou.rb

@@ -0,0 +1,23 @@
+$:.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.1.0'
+end
+
+if ENV["RAILS_ENV"] == "test"
+  ActiveRecord::Base.class_eval do
+    include Koujou::ActiveRecordExtensions::ValidationReflection
+    Koujou::ActiveRecordExtensions::ValidationReflection.install(self)
+    include Koujou::ActiveRecordExtensions::Builder
+  end
+end

data/lib/koujou/builder.rb

@@ -0,0 +1,214 @@
+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)
+                
+                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)
+              
+              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
+            
+            retval = nil
+            # 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 do |o| 
+              retval = options[o.to_sym].entries.first if options.has_key?(o.to_sym)
+              break
+            end
+            if retval.nil?
+              # These other validations should just return the value set.
+              %w(is minimum maximum).each do |o| 
+                retval = options[o.to_sym] if options.has_key?(o.to_sym)  
+                break
+              end
+            end
+            retval
+          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
+            options[:in]
+          end
+          
+          def has_required_id_validation?(instance, association)
+            name = association.options.has_key?(:class_name) ? association.options[:class_name].downcase : association.name
+            !instance.class.required_validations.select{|v| v.name.to_s  == "#{name}_id" }.empty?
+          end
+          
+      end
+      
+    end
+  end
+end

data/lib/koujou/custom_validation.rb

@@ -0,0 +1,15 @@
+# TODO: We need to override any before_validation, or before_validation_on create callbacks as well, I think.
+module Koujou #:nodoc:
+  class CustomValidation # :nodoc:
+    
+    # This just goes in and redefines any custom validation methods. Since we can't
+    # really ascertain what the intent of those are when koujou runs, it seems 
+    # like stubbing them out is the most logical choice.
+    def self.stub_custom_validations!(instance)
+      instance.class.custom_validations.each do |v|
+        instance.class.module_eval { define_method(v.name.to_s) { true } }
+      end
+    end
+
+  end
+end

data/lib/koujou/data_generator.rb

@@ -0,0 +1,106 @@
+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
+      @required_length = nil
+      @inclusion_values = nil
+    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
+      retval = ''
+      # I don't really like all these elsif's but, apparently
+      # it's more efficient than the numerous explicit returns
+      # we used to have. SEE: http://gist.github.com/160718
+      if @validation.name.to_s.match(/email/)
+        retval = format_if_sequenced(Faker::Internet.email)     
+      elsif @validation.name.to_s == 'first_name'
+        retval = format_if_sequenced(Faker::Name.first_name)
+      elsif @validation.name.to_s == 'last_name'
+        retval = format_if_sequenced(Faker::Name.last_name)
+      elsif @validation.name.to_s.match(/login|user_name/)
+        retval = format_if_sequenced(Faker::Internet.user_name)
+      elsif @validation.name.to_s.match(/city/)
+        retval = format_if_sequenced(Faker::Address.city) 
+      elsif @validation.name.to_s.match(/state|province/)
+        retval = format_if_sequenced(Faker::Address.us_state)
+      elsif @validation.name.to_s.match(/zip|postal/)
+        retval =  format_if_sequenced(Faker::Address.zip_code)
+      elsif @validation.name.to_s == 'password' || @validation.name.to_s == 'password_confirmation'
+        retval = 'koujourama'
+      else
+        # 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.
+        retval = @required_length ? standard_text[0..@required_length - 1].to_s : standard_text
+      end
+      retval
+    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