antfarm 0.3.0

data/rails/vendor/rails/activesupport/lib/active_support/version.rb

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module VERSION #:nodoc:
+    MAJOR = 2
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/rails/vendor/rails/activesupport/lib/active_support/whiny_nil.rb

@@ -0,0 +1,58 @@
+# Extensions to +nil+ which allow for more helpful error messages for people who
+# are new to Rails.
+#
+# Ruby raises NoMethodError if you invoke a method on an object that does not
+# respond to it:
+#
+#   $ ruby -e nil.destroy
+#   -e:1: undefined method `destroy' for nil:NilClass (NoMethodError)
+#
+# With these extensions, if the method belongs to the public interface of the
+# classes in NilClass::WHINERS the error message suggests which could be the
+# actual intended class:
+#
+#   $ script/runner nil.destroy 
+#   ...
+#   You might have expected an instance of ActiveRecord::Base.
+#   ...
+#
+# NilClass#id exists in Ruby 1.8 (though it is deprecated). Since +id+ is a fundamental
+# method of Active Record models NilClass#id is redefined as well to raise a RuntimeError
+# and warn the user. She probably wanted a model database identifier and the 4
+# returned by the original method could result in obscure bugs.
+#
+# The flag <tt>config.whiny_nils</tt> determines whether this feature is enabled.
+# By default it is on in development and test modes, and it is off in production
+# mode.
+class NilClass
+  WHINERS = [::Array]
+  WHINERS << ::ActiveRecord::Base if defined? ::ActiveRecord
+
+  METHOD_CLASS_MAP = Hash.new
+
+  WHINERS.each do |klass|
+    methods = klass.public_instance_methods - public_instance_methods
+    class_name = klass.name
+    methods.each { |method| METHOD_CLASS_MAP[method.to_sym] = class_name }
+  end
+
+  # Raises a RuntimeError when you attempt to call +id+ on +nil+.
+  def id
+    raise RuntimeError, "Called id for nil, which would mistakenly be 4 -- if you really wanted the id of nil, use object_id", caller
+  end
+
+  private
+    def method_missing(method, *args, &block)
+      raise_nil_warning_for METHOD_CLASS_MAP[method], method, caller
+    end
+
+    # Raises a NoMethodError when you attempt to call a method on +nil+.
+    def raise_nil_warning_for(class_name = nil, selector = nil, with_caller = nil)
+      message = "You have a nil object when you didn't expect it!"
+      message << "\nYou might have expected an instance of #{class_name}." if class_name
+      message << "\nThe error occurred while evaluating nil.#{selector}" if selector
+
+      raise NoMethodError, message, with_caller || caller
+    end
+end
+

data/rails/vendor/rails/activesupport/lib/activesupport.rb

@@ -0,0 +1 @@
+require 'active_support'

data/rails/vendor/rails/activesupport/test/abstract_unit.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+$:.unshift File.dirname(__FILE__)
+require 'active_support'
+
+def uses_gem(gem_name, test_name, version = '> 0')
+  require 'rubygems'
+  gem gem_name.to_s, version
+  require gem_name.to_s
+  yield
+rescue LoadError
+  $stderr.puts "Skipping #{test_name} tests. `gem install #{gem_name}` and try again."
+end
+
+# Wrap tests that use Mocha and skip if unavailable.
+unless defined? uses_mocha
+  def uses_mocha(test_name, &block)
+    uses_gem('mocha', test_name, '>= 0.5.5', &block)
+  end
+end
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/a/b.rb

@@ -0,0 +1,2 @@
+class A::B
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/a/c/d.rb

@@ -0,0 +1,2 @@
+class A::C::D
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/a/c/e/f.rb

@@ -0,0 +1,2 @@
+class A::C::E::F
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/application.rb

@@ -0,0 +1 @@
+ApplicationController = 10

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/class_folder.rb

@@ -0,0 +1,3 @@
+class ClassFolder
+  ConstantInClassFolder = 'indeed'
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/class_folder/class_folder_subclass.rb

@@ -0,0 +1,3 @@
+class ClassFolder::ClassFolderSubclass < ClassFolder
+  ConstantInClassFolder
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/class_folder/inline_class.rb

@@ -0,0 +1,2 @@
+class ClassFolder::InlineClass
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/class_folder/nested_class.rb

@@ -0,0 +1,7 @@
+class ClassFolder
+  class NestedClass
+  end
+  
+  class SiblingClass
+  end
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/conflict.rb

@@ -0,0 +1 @@
+Conflict = 2

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/counting_loader.rb

@@ -0,0 +1,5 @@
+$counting_loaded_times ||= 0
+$counting_loaded_times += 1
+
+module CountingLoader
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/cross_site_dependency.rb

@@ -0,0 +1,2 @@
+class CrossSiteDependency
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/e.rb

@@ -0,0 +1,2 @@
+class E
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/module_folder/inline_class.rb

@@ -0,0 +1,2 @@
+class ModuleFolder::InlineClass
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/module_folder/nested_class.rb

@@ -0,0 +1,4 @@
+module ModuleFolder
+  class NestedClass
+  end
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/module_folder/nested_sibling.rb

@@ -0,0 +1,2 @@
+class ModuleFolder::NestedSibling
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/module_with_custom_const_missing/a/b.rb

@@ -0,0 +1 @@
+ModuleWithCustomConstMissing::A::B = "10"

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/multiple_constant_file.rb

@@ -0,0 +1,2 @@
+MultipleConstantFile = 10
+SiblingConstant = MultipleConstantFile * 2

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/raises_name_error.rb

@@ -0,0 +1,3 @@
+class RaisesNameError
+  FooBarBaz
+end

data/rails/vendor/rails/activesupport/test/autoloading_fixtures/raises_no_method_error.rb

@@ -0,0 +1,3 @@
+class RaisesNoMethodError
+  self.foobar_method_doesnt_exist
+end

data/rails/vendor/rails/activesupport/test/buffered_logger_test.rb

@@ -0,0 +1,118 @@
+require 'abstract_unit'
+require 'stringio'
+require 'fileutils'
+
+class BufferedLoggerTest < Test::Unit::TestCase
+  def setup
+    @message = "A debug message"
+    @integer_message = 12345
+    @output  = StringIO.new
+    @logger  = ActiveSupport::BufferedLogger.new(@output)
+  end
+
+  def test_should_log_debugging_message_when_debugging
+    @logger.level = Logger::DEBUG
+    @logger.add(Logger::DEBUG, @message)
+    assert @output.string.include?(@message)
+  end
+
+  def test_should_not_log_debug_messages_when_log_level_is_info
+    @logger.level = Logger::INFO
+    @logger.add(Logger::DEBUG, @message)
+    assert ! @output.string.include?(@message)
+  end
+
+  def test_should_add_message_passed_as_block_when_using_add
+    @logger.level = Logger::INFO
+    @logger.add(Logger::INFO) {@message}
+    assert @output.string.include?(@message)
+  end
+
+  def test_should_add_message_passed_as_block_when_using_shortcut
+    @logger.level = Logger::INFO
+    @logger.info {@message}
+    assert @output.string.include?(@message)
+  end
+
+  def test_should_convert_message_to_string
+    @logger.level = Logger::INFO
+    @logger.info @integer_message
+    assert @output.string.include?(@integer_message.to_s)
+  end
+
+  def test_should_convert_message_to_string_when_passed_in_block
+    @logger.level = Logger::INFO
+    @logger.info {@integer_message}
+    assert @output.string.include?(@integer_message.to_s)
+  end
+
+  def test_should_not_evaluate_block_if_message_wont_be_logged
+    @logger.level = Logger::INFO
+    evaluated = false
+    @logger.add(Logger::DEBUG) {evaluated = true}
+    assert evaluated == false
+  end
+
+  def test_should_not_mutate_message
+    message_copy = @message.dup
+    @logger.info @message
+    assert_equal message_copy, @message
+  end
+
+
+  [false, nil, 0].each do |disable|
+    define_method "test_disabling_auto_flush_with_#{disable.inspect}_should_buffer_until_explicit_flush" do
+      @logger.auto_flushing = disable
+
+      4.times do
+        @logger.info 'wait for it..'
+        assert @output.string.empty?, @output.string
+      end
+
+      @logger.flush
+      assert !@output.string.empty?, @logger.buffer.size
+    end
+
+    define_method "test_disabling_auto_flush_with_#{disable.inspect}_should_flush_at_max_buffer_size_as_failsafe" do
+      @logger.auto_flushing = disable
+      assert_equal ActiveSupport::BufferedLogger::MAX_BUFFER_SIZE, @logger.auto_flushing
+
+      (ActiveSupport::BufferedLogger::MAX_BUFFER_SIZE - 1).times do
+        @logger.info 'wait for it..'
+        assert @output.string.empty?, @output.string
+      end
+
+      @logger.info 'there it is.'
+      assert !@output.string.empty?, @logger.buffer.size
+    end
+  end
+  
+  def test_should_know_if_its_loglevel_is_below_a_given_level
+    ActiveSupport::BufferedLogger::Severity.constants.each do |level|
+      @logger.level = ActiveSupport::BufferedLogger::Severity.const_get(level) - 1
+      assert @logger.send("#{level.downcase}?"), "didn't know if it was #{level.downcase}? or below"
+    end
+  end
+
+  def test_should_auto_flush_every_n_messages
+    @logger.auto_flushing = 5
+
+    4.times do
+      @logger.info 'wait for it..'
+      assert @output.string.empty?, @output.string
+    end
+
+    @logger.info 'there it is.'
+    assert !@output.string.empty?, @output.string
+  end
+  
+  def test_should_create_the_log_directory_if_it_doesnt_exist
+    tmp_directory = File.join(File.dirname(__FILE__), "tmp")
+    log_file = File.join(tmp_directory, "development.log")
+    assert !File.exist?(tmp_directory)
+    @logger  = ActiveSupport::BufferedLogger.new(log_file)
+    assert File.exist?(tmp_directory)
+  ensure
+    FileUtils.rm_rf(tmp_directory)
+  end
+end

data/rails/vendor/rails/activesupport/test/caching_test.rb

@@ -0,0 +1,66 @@
+require 'abstract_unit'
+
+class CacheStoreSettingTest < Test::Unit::TestCase
+  def test_file_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store :file_store, "/path/to/cache/directory"
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+  
+  def test_drb_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store :drb_store, "druby://localhost:9192"
+    assert_kind_of(ActiveSupport::Cache::DRbStore, store)
+    assert_equal "druby://localhost:9192", store.address
+  end
+
+  def test_mem_cache_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost"
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    assert_equal %w(localhost), store.addresses
+  end
+  
+  def test_mem_cache_fragment_cache_store_with_multiple_servers
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", '192.168.1.1'
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    assert_equal %w(localhost 192.168.1.1), store.addresses
+  end
+  
+  def test_mem_cache_fragment_cache_store_with_options
+    store = ActiveSupport::Cache.lookup_store :mem_cache_store, "localhost", '192.168.1.1', :namespace => 'foo'
+    assert_kind_of(ActiveSupport::Cache::MemCacheStore, store)
+    assert_equal %w(localhost 192.168.1.1), store.addresses
+    assert_equal 'foo', store.instance_variable_get('@data').instance_variable_get('@namespace')
+  end
+
+  def test_object_assigned_fragment_cache_store
+    store = ActiveSupport::Cache.lookup_store ActiveSupport::Cache::FileStore.new("/path/to/cache/directory")
+    assert_kind_of(ActiveSupport::Cache::FileStore, store)
+    assert_equal "/path/to/cache/directory", store.cache_path
+  end
+end
+
+uses_mocha 'high-level cache store tests' do
+  class CacheStoreTest < Test::Unit::TestCase
+    def setup
+      @cache = ActiveSupport::Cache.lookup_store(:memory_store)
+    end
+
+    def test_fetch_without_cache_miss
+      @cache.stubs(:read).with('foo', {}).returns('bar')
+      @cache.expects(:write).never
+      assert_equal 'bar', @cache.fetch('foo') { 'baz' }
+    end
+
+    def test_fetch_with_cache_miss
+      @cache.stubs(:read).with('foo', {}).returns(nil)
+      @cache.expects(:write).with('foo', 'baz', {})
+      assert_equal 'baz', @cache.fetch('foo') { 'baz' }
+    end
+
+    def test_fetch_with_forced_cache_miss
+      @cache.expects(:read).never
+      @cache.expects(:write).with('foo', 'bar', :force => true)
+      @cache.fetch('foo', :force => true) { 'bar' }
+    end
+  end
+end

data/rails/vendor/rails/activesupport/test/callbacks_test.rb

@@ -0,0 +1,148 @@
+require 'abstract_unit'
+
+class Record
+  include ActiveSupport::Callbacks
+
+  define_callbacks :before_save, :after_save
+
+  class << self
+    def callback_symbol(callback_method)
+      returning("#{callback_method}_method") do |method_name|
+        define_method(method_name) do
+          history << [callback_method, :symbol]
+        end
+      end
+    end
+
+    def callback_string(callback_method)
+      "history << [#{callback_method.to_sym.inspect}, :string]"
+    end
+
+    def callback_proc(callback_method)
+      Proc.new { |model| model.history << [callback_method, :proc] }
+    end
+
+    def callback_object(callback_method)
+      klass = Class.new
+      klass.send(:define_method, callback_method) do |model|
+        model.history << [callback_method, :object]
+      end
+      klass.new
+    end
+  end
+
+  def history
+    @history ||= []
+  end
+end
+
+class Person < Record
+  [:before_save, :after_save].each do |callback_method|
+    callback_method_sym = callback_method.to_sym
+    send(callback_method, callback_symbol(callback_method_sym))
+    send(callback_method, callback_string(callback_method_sym))
+    send(callback_method, callback_proc(callback_method_sym))
+    send(callback_method, callback_object(callback_method_sym))
+    send(callback_method) { |model| model.history << [callback_method_sym, :block] }
+  end
+
+  def save
+    run_callbacks(:before_save)
+    run_callbacks(:after_save)
+  end
+end
+
+class ConditionalPerson < Record
+  before_save Proc.new { |r| r.history << [:before_save, :proc] }, :if => Proc.new { |r| true }
+  before_save Proc.new { |r| r.history << "b00m" }, :if => Proc.new { |r| false }
+  before_save Proc.new { |r| r.history << [:before_save, :proc] }, :unless => Proc.new { |r| false }
+  before_save Proc.new { |r| r.history << "b00m" }, :unless => Proc.new { |r| true }
+
+  def save
+    run_callbacks(:before_save)
+    run_callbacks(:after_save)
+  end
+end
+
+class CallbacksTest < Test::Unit::TestCase
+  def test_save_person
+    person = Person.new
+    assert_equal [], person.history
+    person.save
+    assert_equal [
+      [:before_save, :symbol],
+      [:before_save, :string],
+      [:before_save, :proc],
+      [:before_save, :object],
+      [:before_save, :block],
+      [:after_save, :symbol],
+      [:after_save, :string],
+      [:after_save, :proc],
+      [:after_save, :object],
+      [:after_save, :block]
+    ], person.history
+  end
+end
+
+class ConditionalCallbackTest < Test::Unit::TestCase
+  def test_save_conditional_person
+    person = ConditionalPerson.new
+    person.save
+    assert_equal [
+      [:before_save, :proc],
+      [:before_save, :proc]
+    ], person.history
+  end
+end
+
+class CallbackTest < Test::Unit::TestCase
+  include ActiveSupport::Callbacks
+
+  def test_eql
+    callback = Callback.new(:before, :save, :identifier => :lifesaver)
+    assert callback.eql?(Callback.new(:before, :save, :identifier => :lifesaver))
+    assert callback.eql?(Callback.new(:before, :save))
+    assert callback.eql?(:lifesaver)
+    assert callback.eql?(:save)
+    assert !callback.eql?(Callback.new(:before, :destroy))
+    assert !callback.eql?(:destroy)
+  end
+
+  def test_dup
+    a = Callback.new(:before, :save)
+    assert_equal({}, a.options)
+    b = a.dup
+    b.options[:unless] = :pigs_fly
+    assert_equal({:unless => :pigs_fly}, b.options)
+    assert_equal({}, a.options)
+  end
+end
+
+class CallbackChainTest < Test::Unit::TestCase
+  include ActiveSupport::Callbacks
+
+  def setup
+    @chain = CallbackChain.build(:make, :bacon, :lettuce, :tomato)
+  end
+
+  def test_build
+    assert_equal 3, @chain.size
+    assert_equal [:bacon, :lettuce, :tomato], @chain.map(&:method)
+  end
+
+  def test_find
+    assert_equal :bacon, @chain.find(:bacon).method
+  end
+
+  def test_union
+    assert_equal [:bacon, :lettuce, :tomato], (@chain | Callback.new(:make, :bacon)).map(&:method)
+    assert_equal [:bacon, :lettuce, :tomato, :turkey], (@chain | CallbackChain.build(:make, :bacon, :lettuce, :tomato, :turkey)).map(&:method)
+    assert_equal [:bacon, :lettuce, :tomato, :turkey, :mayo], (@chain | Callback.new(:make, :mayo)).map(&:method)
+  end
+
+  def test_delete
+    assert_equal [:bacon, :lettuce, :tomato], @chain.map(&:method)
+    @chain.delete(:bacon)
+    assert_equal [:lettuce, :tomato], @chain.map(&:method)
+  end
+end