koujou 0.1.0

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,143 @@
+#--
+# 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
+          base.class_eval <<-"end_eval"
+            class << self
+              def #{validation_type}_with_reflection(*attr_names, &block)
+                ignoring_subvalidations(#{ignore_subvalidations}) do
+                  #{validation_type}_without_reflection(*attr_names, &block)
+                  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.name.to_s.match("_associated_").nil? }
+        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,79 @@
+# 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.text "about"
+          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/car.rb

@@ -0,0 +1,7 @@
+class Car < ActiveRecord::Base
+  belongs_to :owner, :class_name => 'User'
+  validates_presence_of :make, :model, :user_id
+  
+  validates_inclusion_of :make, :in => %w(Nissan Subaru)
+  validates_inclusion_of :year, :in => 1900..2009
+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/message.rb

@@ -0,0 +1,5 @@
+class Message < ActiveRecord::Base
+  belongs_to :sender, :class_name => "Profile"
+  belongs_to :receiver, :class_name => "Profile"
+  validates_presence_of :body, :subject, :sender, :receiver
+end

data/test/lib/models/photo.rb

@@ -0,0 +1,3 @@
+class Photo < ActiveRecord::Base
+  belongs_to :profile
+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,150 @@
+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
+
+    should 'cause a model to be invalid if you override a field that has validates_presence_of with a nil value' do
+      u = User.koujou_build(:email => nil)
+      assert !u.valid?
+    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
+      assert_equal 2, User.custom_validations.size
+    end
+    
+    should 'car should have an owner association to user via class_name' do
+      c = Car.koujou
+      assert_not_nil c.owner
+    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
+
+
+