radiant 0.9.0.rc2 → 0.9.1

data/vendor/rails/activesupport/test/core_ext/integer_ext_test.rb

@@ -1,37 +0,0 @@
-require 'abstract_unit'
-
-class IntegerExtTest < Test::Unit::TestCase
-  def test_even
-    assert [ -2, 0, 2, 4 ].all? { |i| i.even? }
-    assert ![ -1, 1, 3 ].all? { |i| i.even? }
-
-    assert 22953686867719691230002707821868552601124472329079.odd?
-    assert !22953686867719691230002707821868552601124472329079.even?
-    assert 22953686867719691230002707821868552601124472329080.even?
-    assert !22953686867719691230002707821868552601124472329080.odd?
-  end
-
-  def test_odd
-    assert ![ -2, 0, 2, 4 ].all? { |i| i.odd? }
-    assert [ -1, 1, 3 ].all? { |i| i.odd? }
-    assert 1000000000000000000000000000000000000000000000000000000001.odd?
-  end
-
-  def test_multiple_of
-    [ -7, 0, 7, 14 ].each { |i| assert i.multiple_of?(7) }
-    [ -7, 7, 14 ].each { |i| assert ! i.multiple_of?(6) }
-    # test with a prime
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(2)
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(3)
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(5)
-    assert !22953686867719691230002707821868552601124472329079.multiple_of?(7)
-  end
-
-  def test_ordinalize
-    # These tests are mostly just to ensure that the ordinalize method exists.
-    # Its results are tested comprehensively in the inflector test cases.
-    assert_equal '1st', 1.ordinalize
-    assert_equal '8th', 8.ordinalize
-    1000000000000000000000000000000000000000000000000000000000000000000000.ordinalize
-  end
-end

data/vendor/rails/activesupport/test/core_ext/kernel_test.rb

@@ -1,43 +0,0 @@
-require 'abstract_unit'
-
-class KernelTest < Test::Unit::TestCase
-  def test_silence_warnings
-    silence_warnings { assert_nil $VERBOSE }
-    assert_equal 1234, silence_warnings { 1234 }
-  end
-
-  def test_silence_warnings_verbose_invariant
-    old_verbose = $VERBOSE
-    silence_warnings { raise }
-    flunk
-  rescue
-    assert_equal old_verbose, $VERBOSE
-  end
-
-
-  def test_enable_warnings
-    enable_warnings { assert_equal true, $VERBOSE }
-    assert_equal 1234, enable_warnings { 1234 }
-  end
-
-  def test_enable_warnings_verbose_invariant
-    old_verbose = $VERBOSE
-    enable_warnings { raise }
-    flunk
-  rescue
-    assert_equal old_verbose, $VERBOSE
-  end
-
-
-  def test_silence_stderr
-    old_stderr_position = STDERR.tell
-    silence_stderr { STDERR.puts 'hello world' }
-    assert_equal old_stderr_position, STDERR.tell
-  rescue Errno::ESPIPE
-    # Skip if we can't STDERR.tell
-  end
-
-  def test_silence_stderr_with_return_value
-    assert_equal 1, silence_stderr { 1 }
-  end
-end

data/vendor/rails/activesupport/test/core_ext/load_error_test.rb

@@ -1,16 +0,0 @@
-require 'abstract_unit'
-
-class TestMissingSourceFile < Test::Unit::TestCase
-  def test_with_require
-    assert_raise(MissingSourceFile) { require 'no_this_file_don\'t_exist' }
-  end
-  def test_with_load
-    assert_raise(MissingSourceFile) { load 'nor_does_this_one' }
-  end
-  def test_path
-    begin load 'nor/this/one.rb'
-    rescue MissingSourceFile => e
-      assert_equal 'nor/this/one.rb', e.path
-    end
-  end
-end

data/vendor/rails/activesupport/test/core_ext/module/attr_accessor_with_default_test.rb

@@ -1,30 +0,0 @@
-require 'abstract_unit'
-
-class AttrAccessorWithDefaultTest < Test::Unit::TestCase
-  def setup
-    @target = Class.new do
-      def helper
-        'helper'
-      end
-    end  
-    @instance = @target.new
-  end
-  
-  def test_default_arg
-    @target.attr_accessor_with_default :foo, :bar
-    assert_equal(:bar, @instance.foo)
-    @instance.foo = nil
-    assert_nil(@instance.foo)
-  end
-  
-  def test_default_proc
-    @target.attr_accessor_with_default(:foo) {helper.upcase}
-    assert_equal('HELPER', @instance.foo)
-    @instance.foo = nil
-    assert_nil(@instance.foo)
-  end
-  
-  def test_invalid_args
-    assert_raise(RuntimeError) {@target.attr_accessor_with_default :foo}
-  end
-end

data/vendor/rails/activesupport/test/core_ext/module/attr_internal_test.rb

@@ -1,52 +0,0 @@
-require 'abstract_unit'
-
-class AttrInternalTest < Test::Unit::TestCase
-  def setup
-    @target = Class.new
-    @instance = @target.new
-  end
-
-  def test_reader
-    assert_nothing_raised { @target.attr_internal_reader :foo }
-
-    assert !@instance.instance_variable_defined?('@_foo')
-    assert_raise(NoMethodError) { @instance.foo = 1 }
-
-    @instance.instance_variable_set('@_foo', 1)
-    assert_nothing_raised { assert_equal 1, @instance.foo }
-  end
-
-  def test_writer
-    assert_nothing_raised { @target.attr_internal_writer :foo }
-
-    assert !@instance.instance_variable_defined?('@_foo')
-    assert_nothing_raised { assert_equal 1, @instance.foo = 1 }
-
-    assert_equal 1, @instance.instance_variable_get('@_foo')
-    assert_raise(NoMethodError) { @instance.foo }
-  end
-
-  def test_accessor
-    assert_nothing_raised { @target.attr_internal :foo }
-
-    assert !@instance.instance_variable_defined?('@_foo')
-    assert_nothing_raised { assert_equal 1, @instance.foo = 1 }
-
-    assert_equal 1, @instance.instance_variable_get('@_foo')
-    assert_nothing_raised { assert_equal 1, @instance.foo }
-  end
-
-  def test_naming_format
-    assert_equal '@_%s', @target.attr_internal_naming_format
-    assert_nothing_raised { @target.attr_internal_naming_format = '@abc%sdef' }
-    @target.attr_internal :foo
-
-    assert !@instance.instance_variable_defined?('@_foo')
-    assert !@instance.instance_variable_defined?('@abcfoodef')
-    assert_nothing_raised { @instance.foo = 1 }
-    assert !@instance.instance_variable_defined?('@_foo')
-    assert @instance.instance_variable_defined?('@abcfoodef')
-  ensure
-    @target.attr_internal_naming_format = '@_%s'
-  end
-end

data/vendor/rails/activesupport/test/core_ext/module/attribute_accessor_test.rb

@@ -1,33 +0,0 @@
-require 'abstract_unit'
-
-class ModuleAttributeAccessorTest < Test::Unit::TestCase
-  def setup
-    m = @module = Module.new do
-      mattr_accessor :foo
-      mattr_accessor :bar, :instance_writer => false
-    end
-    @class = Class.new
-    @class.instance_eval { include m }
-    @object = @class.new
-  end
-
-  def test_should_use_mattr_default
-    assert_nil @module.foo
-    assert_nil @object.foo
-  end
-
-  def test_should_set_mattr_value
-    @module.foo = :test
-    assert_equal :test, @object.foo
-
-    @object.foo = :test2
-    assert_equal :test2, @module.foo
-  end
-
-  def test_should_not_create_instance_writer
-    assert @module.respond_to?(:foo)
-    assert @module.respond_to?(:foo=)
-    assert @object.respond_to?(:bar)
-    assert !@object.respond_to?(:bar=)
-  end
-end

data/vendor/rails/activesupport/test/core_ext/module/attribute_aliasing_test.rb

@@ -1,58 +0,0 @@
-require 'abstract_unit'
-
-module AttributeAliasing
-  class Content
-    attr_accessor :title, :Data
-
-    def initialize
-      @title, @Data = nil, nil
-    end
-
-    def title?
-      !title.nil?
-    end
-
-    def Data?
-      !self.Data.nil?
-    end
-  end
-
-  class Email < Content
-    alias_attribute :subject, :title
-    alias_attribute :body, :Data
-  end
-end
-
-class AttributeAliasingTest < Test::Unit::TestCase
-  def test_attribute_alias
-    e = AttributeAliasing::Email.new
-
-    assert !e.subject?
-
-    e.title = "Upgrade computer"
-    assert_equal "Upgrade computer", e.subject
-    assert e.subject?
-
-    e.subject = "We got a long way to go"
-    assert_equal "We got a long way to go", e.title
-    assert e.title?
-  end
-
-  def test_aliasing_to_uppercase_attributes
-    # Although it's very un-Ruby, some people's AR-mapped tables have
-    # upper-case attributes, and when people want to alias those names
-    # to more sensible ones, everything goes *foof*.
-    e = AttributeAliasing::Email.new
-    
-    assert !e.body?
-    assert !e.Data?
-    
-    e.body = "No, really, this is not a joke."
-    assert_equal "No, really, this is not a joke.", e.Data
-    assert e.Data?
-    
-    e.Data = "Uppercased methods are teh suck"
-    assert_equal "Uppercased methods are teh suck", e.body
-    assert e.body?
-  end
-end

data/vendor/rails/activesupport/test/core_ext/module/model_naming_test.rb

@@ -1,27 +0,0 @@
-require 'abstract_unit'
-
-class ModelNamingTest < Test::Unit::TestCase
-  def setup
-    @model_name = ActiveSupport::ModelName.new('Post::TrackBack')
-  end
-
-  def test_singular
-    assert_equal 'post_track_back', @model_name.singular
-  end
-
-  def test_plural
-    assert_equal 'post_track_backs', @model_name.plural
-  end
-
-  def test_element
-    assert_equal 'track_back', @model_name.element
-  end
-
-  def test_collection
-    assert_equal 'post/track_backs', @model_name.collection
-  end
-
-  def test_partial_path
-    assert_equal 'post/track_backs/track_back', @model_name.partial_path
-  end
-end

data/vendor/rails/activesupport/test/core_ext/module/synchronization_test.rb

@@ -1,85 +0,0 @@
-require 'abstract_unit'
-
-class SynchronizationTest < Test::Unit::TestCase
-  def setup
-    @target = Class.new
-    @target.cattr_accessor :mutex, :instance_writer => false
-    @target.mutex = Mutex.new
-    @instance = @target.new
-  end
-
-  def test_synchronize_aliases_method_chain_with_synchronize
-    @target.module_eval do
-      attr_accessor :value
-      synchronize :value, :with => :mutex
-    end
-    assert @instance.respond_to?(:value_with_synchronization)
-    assert @instance.respond_to?(:value_without_synchronization)
-  end
-
-  def test_synchronize_does_not_change_behavior
-    @target.module_eval do
-      attr_accessor :value
-      synchronize :value, :with => :mutex
-    end
-    expected = "some state"
-    @instance.value = expected
-    assert_equal expected, @instance.value
-  end
-
-  def test_synchronize_with_no_mutex_raises_an_argument_error
-    assert_raise(ArgumentError) do
-      @target.synchronize :to_s
-    end
-  end
-
-  def test_double_synchronize_raises_an_argument_error
-    @target.synchronize :to_s, :with => :mutex
-    assert_raise(ArgumentError) do
-      @target.synchronize :to_s, :with => :mutex
-    end
-  end
-
-  def dummy_sync
-    dummy = Object.new
-    def dummy.synchronize
-      @sync_count ||= 0
-      @sync_count += 1
-      yield
-    end
-    def dummy.sync_count; @sync_count; end
-    dummy
-  end
-
-  def test_mutex_is_entered_during_method_call
-    @target.mutex = dummy_sync
-    @target.synchronize :to_s, :with => :mutex
-    @instance.to_s
-    @instance.to_s
-    assert_equal 2, @target.mutex.sync_count
-  end
-
-  def test_can_synchronize_method_with_punctuation
-    @target.module_eval do
-      def dangerous?
-        @dangerous
-      end
-      def dangerous!
-        @dangerous = true
-      end
-    end
-    @target.synchronize :dangerous?, :dangerous!, :with => :mutex
-    @instance.dangerous!
-    assert @instance.dangerous?
-  end
-
-  def test_can_synchronize_singleton_methods
-    @target.mutex = dummy_sync
-    class << @target
-      synchronize :to_s, :with => :mutex
-    end
-    assert @target.respond_to?(:to_s_without_synchronization)
-    assert_nothing_raised { @target.to_s; @target.to_s }
-    assert_equal 2, @target.mutex.sync_count
-  end
-end

data/vendor/rails/activesupport/test/core_ext/module_test.rb

@@ -1,363 +0,0 @@
-require 'abstract_unit'
-
-module One
-  Constant1 = "Hello World"
-  Constant2 = "What's up?"
-end
-
-class Ab
-  include One
-  Constant1 = "Hello World" # Will have different object id than One::Constant1
-  Constant3 = "Goodbye World"
-end
-
-module Xy
-  class Bc
-    include One
-  end
-end
-
-module Yz
-  module Zy
-    class Cd
-      include One
-    end
-  end
-end
-
-class De
-end
-
-Somewhere = Struct.new(:street, :city)
-
-Someone   = Struct.new(:name, :place) do
-  delegate :street, :city, :to_f, :to => :place
-  delegate :state, :to => :@place
-  delegate :upcase, :to => "place.city"
-end
-
-Invoice   = Struct.new(:client) do
-  delegate :street, :city, :name, :to => :client, :prefix => true
-  delegate :street, :city, :name, :to => :client, :prefix => :customer
-end
-
-Project   = Struct.new(:description, :person) do
-  delegate :name, :to => :person, :allow_nil => true
-  delegate :to_f, :to => :description, :allow_nil => true
-end
-
-class Name
-  delegate :upcase, :to => :@full_name
-
-  def initialize(first, last)
-    @full_name = "#{first} #{last}"
-  end
-end
-
-$nowhere = <<-EOF
-class Name
-  delegate :nowhere
-end
-EOF
-
-$noplace = <<-EOF
-class Name
-  delegate :noplace, :tos => :hollywood
-end
-EOF
-
-class ModuleTest < Test::Unit::TestCase
-  def setup
-    @david = Someone.new("David", Somewhere.new("Paulina", "Chicago"))
-  end
-
-  def test_included_in_classes
-    assert One.included_in_classes.include?(Ab)
-    assert One.included_in_classes.include?(Xy::Bc)
-    assert One.included_in_classes.include?(Yz::Zy::Cd)
-    assert !One.included_in_classes.include?(De)
-  end
-
-  def test_delegation_to_methods
-    assert_equal "Paulina", @david.street
-    assert_equal "Chicago", @david.city
-  end
-
-  def test_delegation_down_hierarchy
-    assert_equal "CHICAGO", @david.upcase
-  end
-
-  def test_delegation_to_instance_variable
-    david = Name.new("David", "Hansson")
-    assert_equal "DAVID HANSSON", david.upcase
-  end
-
-  def test_missing_delegation_target
-    assert_raise(ArgumentError) { eval($nowhere) }
-    assert_raise(ArgumentError) { eval($noplace) }
-  end
-
-  def test_delegation_prefix
-    invoice = Invoice.new(@david)
-    assert_equal invoice.client_name, "David"
-    assert_equal invoice.client_street, "Paulina"
-    assert_equal invoice.client_city, "Chicago"
-  end
-
-  def test_delegation_custom_prefix
-    invoice = Invoice.new(@david)
-    assert_equal invoice.customer_name, "David"
-    assert_equal invoice.customer_street, "Paulina"
-    assert_equal invoice.customer_city, "Chicago"
-  end
-
-  def test_delegation_prefix_with_instance_variable
-    assert_raise ArgumentError do
-      Class.new do
-        def initialize(client)
-          @client = client
-        end
-        delegate :name, :address, :to => :@client, :prefix => true
-      end
-    end
-  end
-
-  def test_delegation_with_allow_nil
-    rails = Project.new("Rails", Someone.new("David"))
-    assert_equal rails.name, "David"
-  end
-
-  def test_delegation_with_allow_nil_and_nil_value
-    rails = Project.new("Rails")
-    assert_nil rails.name
-  end
-
-  def test_delegation_with_allow_nil_and_nil_value_and_prefix
-    Project.class_eval do
-      delegate :name, :to => :person, :allow_nil => true, :prefix => true
-    end
-    rails = Project.new("Rails")
-    assert_nil rails.person_name
-  end
-
-  def test_delegation_without_allow_nil_and_nil_value
-    david = Someone.new("David")
-    assert_raise(RuntimeError) { david.street }
-  end
-
-  def test_delegation_to_method_that_exists_on_nil
-    nil_person = Someone.new(nil)
-    assert_equal 0.0, nil_person.to_f
-  end
-
-  def test_delegation_to_method_that_exists_on_nil_when_allowing_nil
-    nil_project = Project.new(nil)
-    assert_equal 0.0, nil_project.to_f
-  end
-
-  def test_parent
-    assert_equal Yz::Zy, Yz::Zy::Cd.parent
-    assert_equal Yz, Yz::Zy.parent
-    assert_equal Object, Yz.parent
-  end
-
-  def test_parents
-    assert_equal [Yz::Zy, Yz, Object], Yz::Zy::Cd.parents
-    assert_equal [Yz, Object], Yz::Zy.parents
-  end
-
-  def test_local_constants
-    assert_equal %w(Constant1 Constant3), Ab.local_constants.sort.map(&:to_s)
-  end
-
-  def test_as_load_path
-    assert_equal 'yz/zy', Yz::Zy.as_load_path
-    assert_equal 'yz', Yz.as_load_path
-  end
-end
-
-module BarMethodAliaser
-  def self.included(foo_class)
-    foo_class.class_eval do
-      include BarMethods
-      alias_method_chain :bar, :baz
-    end
-  end
-end
-
-module BarMethods
-  def bar_with_baz
-    bar_without_baz << '_with_baz'
-  end
-
-  def quux_with_baz!
-    quux_without_baz! << '_with_baz'
-  end
-
-  def quux_with_baz?
-    false
-  end
-
-  def quux_with_baz=(v)
-    send(:quux_without_baz=, v) << '_with_baz'
-  end
-
-  def duck_with_orange
-    duck_without_orange << '_with_orange'
-  end
-end
-
-class MethodAliasingTest < Test::Unit::TestCase
-  def setup
-    Object.const_set :FooClassWithBarMethod, Class.new { def bar() 'bar' end }
-    @instance = FooClassWithBarMethod.new
-  end
-
-  def teardown
-    Object.instance_eval { remove_const :FooClassWithBarMethod }
-  end
-
-  def test_alias_method_chain
-    assert @instance.respond_to?(:bar)
-    feature_aliases = [:bar_with_baz, :bar_without_baz]
-
-    feature_aliases.each do |method|
-      assert !@instance.respond_to?(method)
-    end
-
-    assert_equal 'bar', @instance.bar
-
-    FooClassWithBarMethod.class_eval { include BarMethodAliaser }
-
-    feature_aliases.each do |method|
-      assert @instance.respond_to?(method)
-    end
-
-    assert_equal 'bar_with_baz', @instance.bar
-    assert_equal 'bar', @instance.bar_without_baz
-  end
-
-  def test_alias_method_chain_with_punctuation_method
-    FooClassWithBarMethod.class_eval do
-      def quux!; 'quux' end
-    end
-
-    assert !@instance.respond_to?(:quux_with_baz!)
-    FooClassWithBarMethod.class_eval do
-      include BarMethodAliaser
-      alias_method_chain :quux!, :baz
-    end
-    assert @instance.respond_to?(:quux_with_baz!)
-
-    assert_equal 'quux_with_baz', @instance.quux!
-    assert_equal 'quux', @instance.quux_without_baz!
-  end
-
-  def test_alias_method_chain_with_same_names_between_predicates_and_bang_methods
-    FooClassWithBarMethod.class_eval do
-      def quux!; 'quux!' end
-      def quux?; true end
-      def quux=(v); 'quux=' end
-    end
-
-    assert !@instance.respond_to?(:quux_with_baz!)
-    assert !@instance.respond_to?(:quux_with_baz?)
-    assert !@instance.respond_to?(:quux_with_baz=)
-
-    FooClassWithBarMethod.class_eval { include BarMethodAliaser }
-    assert @instance.respond_to?(:quux_with_baz!)
-    assert @instance.respond_to?(:quux_with_baz?)
-    assert @instance.respond_to?(:quux_with_baz=)
-
-
-    FooClassWithBarMethod.alias_method_chain :quux!, :baz
-    assert_equal 'quux!_with_baz', @instance.quux!
-    assert_equal 'quux!', @instance.quux_without_baz!
-
-    FooClassWithBarMethod.alias_method_chain :quux?, :baz
-    assert_equal false, @instance.quux?
-    assert_equal true,  @instance.quux_without_baz?
-
-    FooClassWithBarMethod.alias_method_chain :quux=, :baz
-    assert_equal 'quux=_with_baz', @instance.send(:quux=, 1234)
-    assert_equal 'quux=', @instance.send(:quux_without_baz=, 1234)
-  end
-
-  def test_alias_method_chain_with_feature_punctuation
-    FooClassWithBarMethod.class_eval do
-      def quux; 'quux' end
-      def quux?; 'quux?' end
-      include BarMethodAliaser
-      alias_method_chain :quux, :baz!
-    end
-
-    assert_nothing_raised do
-      assert_equal 'quux_with_baz', @instance.quux_with_baz!
-    end
-
-    assert_raise(NameError) do
-      FooClassWithBarMethod.alias_method_chain :quux?, :baz!
-    end
-  end
-
-  def test_alias_method_chain_yields_target_and_punctuation
-    args = nil
-
-    FooClassWithBarMethod.class_eval do
-      def quux?; end
-      include BarMethods
-
-      FooClassWithBarMethod.alias_method_chain :quux?, :baz do |target, punctuation|
-        args = [target, punctuation]
-      end
-    end
-
-    assert_not_nil args
-    assert_equal 'quux', args[0]
-    assert_equal '?', args[1]
-  end
-
-  def test_alias_method_chain_preserves_private_method_status
-    FooClassWithBarMethod.class_eval do
-      def duck; 'duck' end
-      include BarMethodAliaser
-      private :duck
-      alias_method_chain :duck, :orange
-    end
-
-    assert_raise NoMethodError do
-      @instance.duck
-    end
-
-    assert_equal 'duck_with_orange', @instance.instance_eval { duck }
-    assert FooClassWithBarMethod.private_method_defined?(:duck)
-  end
-
-  def test_alias_method_chain_preserves_protected_method_status
-    FooClassWithBarMethod.class_eval do
-      def duck; 'duck' end
-      include BarMethodAliaser
-      protected :duck
-      alias_method_chain :duck, :orange
-    end
-
-    assert_raise NoMethodError do
-      @instance.duck
-    end
-
-    assert_equal 'duck_with_orange', @instance.instance_eval { duck }
-    assert FooClassWithBarMethod.protected_method_defined?(:duck)
-  end
-
-  def test_alias_method_chain_preserves_public_method_status
-    FooClassWithBarMethod.class_eval do
-      def duck; 'duck' end
-      include BarMethodAliaser
-      public :duck
-      alias_method_chain :duck, :orange
-    end
-
-    assert_equal 'duck_with_orange', @instance.duck
-    assert FooClassWithBarMethod.public_method_defined?(:duck)
-  end
-end