radiant 0.9.1 → 1.0.0.rc1

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

@@ -0,0 +1,20 @@
+require 'abstract_unit'
+
+class NameErrorTest < Test::Unit::TestCase
+  def test_name_error_should_set_missing_name
+    SomeNameThatNobodyWillUse____Really ? 1 : 0
+    flunk "?!?!"
+  rescue NameError => exc
+    assert_equal "NameErrorTest::SomeNameThatNobodyWillUse____Really", exc.missing_name
+    assert exc.missing_name?(:SomeNameThatNobodyWillUse____Really)
+    assert exc.missing_name?("NameErrorTest::SomeNameThatNobodyWillUse____Really")
+  end
+
+  def test_missing_method_should_ignore_missing_name
+    some_method_that_does_not_exist
+    flunk "?!?!"
+  rescue NameError => exc
+    assert !exc.missing_name?(:Foo)
+    assert_nil exc.missing_name
+  end
+end

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

@@ -0,0 +1,168 @@
+require 'abstract_unit'
+
+class NumericExtTimeAndDateTimeTest < Test::Unit::TestCase
+  def setup
+    @now = Time.local(2005,2,10,15,30,45)
+    @dtnow = DateTime.civil(2005,2,10,15,30,45)
+    @seconds = {
+      1.minute   => 60,
+      10.minutes => 600,
+      1.hour + 15.minutes => 4500,
+      2.days + 4.hours + 30.minutes => 189000,
+      5.years + 1.month + 1.fortnight => 161589600
+    }
+  end
+
+  def test_units
+    @seconds.each do |actual, expected|
+      assert_equal expected, actual
+    end
+  end
+
+  def test_intervals
+    @seconds.values.each do |seconds|
+      assert_equal seconds.since(@now), @now + seconds
+      assert_equal seconds.until(@now), @now - seconds
+    end
+  end
+
+  # Test intervals based from Time.now
+  def test_now
+    @seconds.values.each do |seconds|
+      now = Time.now
+      assert seconds.ago >= now - seconds
+      now = Time.now
+      assert seconds.from_now >= now + seconds
+    end
+  end
+
+  def test_irregular_durations
+    assert_equal @now.advance(:days => 3000), 3000.days.since(@now)
+    assert_equal @now.advance(:months => 1), 1.month.since(@now)
+    assert_equal @now.advance(:months => -1), 1.month.until(@now)
+    assert_equal @now.advance(:years => 20), 20.years.since(@now)
+    assert_equal @dtnow.advance(:days => 3000), 3000.days.since(@dtnow)
+    assert_equal @dtnow.advance(:months => 1), 1.month.since(@dtnow)
+    assert_equal @dtnow.advance(:months => -1), 1.month.until(@dtnow)
+    assert_equal @dtnow.advance(:years => 20), 20.years.since(@dtnow)
+  end
+
+  def test_duration_addition
+    assert_equal @now.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@now)
+    assert_equal @now.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@now)
+    assert_equal @now.advance(:years => 2), (4.years - 2.years).since(@now)
+    assert_equal @dtnow.advance(:days => 1).advance(:months => 1), (1.day + 1.month).since(@dtnow)
+    assert_equal @dtnow.advance(:days => 7), (1.week + 5.seconds - 5.seconds).since(@dtnow)
+    assert_equal @dtnow.advance(:years => 2), (4.years - 2.years).since(@dtnow)
+  end
+
+  def test_time_plus_duration
+    assert_equal @now + 8, @now + 8.seconds
+    assert_equal @now + 22.9, @now + 22.9.seconds
+    assert_equal @now.advance(:days => 15), @now + 15.days
+    assert_equal @now.advance(:months => 1), @now + 1.month
+    assert_equal @dtnow.since(8), @dtnow + 8.seconds
+    assert_equal @dtnow.since(22.9), @dtnow + 22.9.seconds
+    assert_equal @dtnow.advance(:days => 15), @dtnow + 15.days
+    assert_equal @dtnow.advance(:months => 1), @dtnow + 1.month
+  end
+
+  def test_chaining_duration_operations
+    assert_equal @now.advance(:days => 2).advance(:months => -3), @now + 2.days - 3.months
+    assert_equal @now.advance(:days => 1).advance(:months => 2), @now + 1.day + 2.months
+    assert_equal @dtnow.advance(:days => 2).advance(:months => -3), @dtnow + 2.days - 3.months
+    assert_equal @dtnow.advance(:days => 1).advance(:months => 2), @dtnow + 1.day + 2.months
+  end
+
+  def test_duration_after_convertion_is_no_longer_accurate
+    assert_equal 30.days.to_i.since(@now), 1.month.to_i.since(@now)
+    assert_equal 365.25.days.to_f.since(@now), 1.year.to_f.since(@now)
+    assert_equal 30.days.to_i.since(@dtnow), 1.month.to_i.since(@dtnow)
+    assert_equal 365.25.days.to_f.since(@dtnow), 1.year.to_f.since(@dtnow)
+  end
+
+  def test_add_one_year_to_leap_day
+    assert_equal Time.utc(2005,2,28,15,15,10), Time.utc(2004,2,29,15,15,10) + 1.year
+    assert_equal DateTime.civil(2005,2,28,15,15,10), DateTime.civil(2004,2,29,15,15,10) + 1.year
+  end
+end
+
+class NumericExtDateTest < Test::Unit::TestCase
+  def setup
+    @today = Date.today
+  end
+
+  def test_date_plus_duration
+    assert_equal @today + 1, @today + 1.day
+    assert_equal @today >> 1, @today + 1.month
+    assert_equal @today.to_time.since(1), @today + 1.second
+    assert_equal @today.to_time.since(60), @today + 1.minute
+    assert_equal @today.to_time.since(60*60), @today + 1.hour
+  end
+
+  def test_chaining_duration_operations
+    assert_equal @today.advance(:days => 2).advance(:months => -3), @today + 2.days - 3.months
+    assert_equal @today.advance(:days => 1).advance(:months => 2), @today + 1.day + 2.months
+  end
+
+  def test_add_one_year_to_leap_day
+    assert_equal Date.new(2005,2,28), Date.new(2004,2,29) + 1.year
+  end
+end
+
+class NumericExtSizeTest < Test::Unit::TestCase
+  def test_unit_in_terms_of_another
+    relationships = {
+        1024.bytes     =>   1.kilobyte,
+        1024.kilobytes =>   1.megabyte,
+      3584.0.kilobytes => 3.5.megabytes,
+      3584.0.megabytes => 3.5.gigabytes,
+      1.kilobyte ** 4  =>   1.terabyte,
+      1024.kilobytes + 2.megabytes =>   3.megabytes,
+                   2.gigabytes / 4 => 512.megabytes,
+      256.megabytes * 20 + 5.gigabytes => 10.gigabytes,
+      1.kilobyte ** 5 => 1.petabyte,
+      1.kilobyte ** 6 => 1.exabyte
+    }
+
+    relationships.each do |left, right|
+      assert_equal right, left
+    end
+  end
+
+  def test_units_as_bytes_independently
+    assert_equal 3145728, 3.megabytes
+    assert_equal 3145728, 3.megabyte
+    assert_equal 3072, 3.kilobytes
+    assert_equal 3072, 3.kilobyte
+    assert_equal 3221225472, 3.gigabytes
+    assert_equal 3221225472, 3.gigabyte
+    assert_equal 3298534883328, 3.terabytes
+    assert_equal 3298534883328, 3.terabyte
+    assert_equal 3377699720527872, 3.petabytes
+    assert_equal 3377699720527872, 3.petabyte
+    assert_equal 3458764513820540928, 3.exabytes
+    assert_equal 3458764513820540928, 3.exabyte
+  end
+end
+
+class NumericExtConversionsTest < Test::Unit::TestCase
+
+  def test_to_utc_offset_s_with_colon
+    assert_equal "-06:00", -21_600.to_utc_offset_s
+    assert_equal "+00:00", 0.to_utc_offset_s
+    assert_equal "+05:00", 18_000.to_utc_offset_s
+  end
+
+  def test_to_utc_offset_s_without_colon
+    assert_equal "-0600", -21_600.to_utc_offset_s(false)
+    assert_equal "+0000", 0.to_utc_offset_s(false)
+    assert_equal "+0500", 18_000.to_utc_offset_s(false)
+  end
+
+  def test_to_utc_offset_s_with_negative_offset
+    assert_equal "-01:00", -3_600.to_utc_offset_s
+    assert_equal "-00:59", -3_599.to_utc_offset_s
+    assert_equal "-05:30", -19_800.to_utc_offset_s
+  end
+end

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

@@ -0,0 +1,294 @@
+require 'abstract_unit'
+
+class ClassA; end
+class ClassB < ClassA; end
+class ClassC < ClassB; end
+class ClassD < ClassA; end
+
+class ClassI; end
+class ClassJ < ClassI; end
+
+class ClassK
+end
+module Nested
+  class << self
+    def on_const_missing(&callback)
+      @on_const_missing = callback
+    end
+    private
+      def const_missing(mod_id)
+        @on_const_missing[mod_id] if @on_const_missing
+        super
+      end
+  end
+  class ClassL < ClassK
+  end
+end
+
+module Bar
+  def bar; end
+end
+
+module Baz
+  def baz; end
+end
+
+class Foo
+  include Bar
+end
+
+class ClassExtTest < Test::Unit::TestCase
+  def test_methods
+    assert defined?(ClassB)
+    assert defined?(ClassC)
+    assert defined?(ClassD)
+
+    ClassA.remove_subclasses
+
+    assert !defined?(ClassB)
+    assert !defined?(ClassC)
+    assert !defined?(ClassD)
+  end
+
+  def test_subclasses_of
+    cj = ClassJ
+    assert_equal [ClassJ], Object.subclasses_of(ClassI)
+    ClassI.remove_subclasses
+    assert_equal [], Object.subclasses_of(ClassI)
+  ensure
+    Object.const_set :ClassJ, cj
+  end
+
+  def test_subclasses_of_should_find_nested_classes
+    assert Object.subclasses_of(ClassK).include?(Nested::ClassL)
+  end
+
+  def test_subclasses_of_should_not_return_removed_classes
+    # First create the removed class
+    old_class = Nested.class_eval { remove_const :ClassL }
+    new_class = Class.new(ClassK)
+    Nested.const_set :ClassL, new_class
+    assert_equal "Nested::ClassL", new_class.name # Sanity check
+
+    subclasses = Object.subclasses_of(ClassK)
+    assert subclasses.include?(new_class)
+    assert ! subclasses.include?(old_class)
+  ensure
+    Nested.const_set :ClassL, old_class unless defined?(Nested::ClassL)
+  end
+
+  def test_subclasses_of_should_not_trigger_const_missing
+    const_missing = false
+    Nested.on_const_missing { const_missing = true }
+
+    subclasses = Object.subclasses_of ClassK
+    assert !const_missing
+    assert_equal [ Nested::ClassL ], subclasses
+
+    removed = Nested.class_eval { remove_const :ClassL }  # keep it in memory
+    subclasses = Object.subclasses_of ClassK
+    assert !const_missing
+    assert subclasses.empty?
+  ensure
+    Nested.const_set :ClassL, removed unless defined?(Nested::ClassL)
+  end
+
+  def test_subclasses_of_with_multiple_roots
+    classes = Object.subclasses_of(ClassI, ClassK)
+    assert_equal %w(ClassJ Nested::ClassL), classes.collect(&:to_s).sort
+  end
+
+  def test_subclasses_of_doesnt_find_anonymous_classes
+    assert_equal [], Object.subclasses_of(Foo)
+    bar = Class.new(Foo)
+    assert_nothing_raised do
+      assert_equal [bar], Object.subclasses_of(Foo)
+    end
+  end
+end
+
+class ObjectTests < ActiveSupport::TestCase
+  def test_suppress_re_raises
+    assert_raise(LoadError) { suppress(ArgumentError) {raise LoadError} }
+  end
+  def test_suppress_supresses
+    suppress(ArgumentError) { raise ArgumentError }
+    suppress(LoadError) { raise LoadError }
+    suppress(LoadError, ArgumentError) { raise LoadError }
+    suppress(LoadError, ArgumentError) { raise ArgumentError }
+  end
+
+  def test_extended_by
+    foo = Foo.new
+    assert foo.extended_by.include?(Bar)
+    foo.extend(Baz)
+    assert(([Bar, Baz] - foo.extended_by).empty?, "Expected Bar, Baz in #{foo.extended_by.inspect}")
+  end
+
+  def test_extend_with_included_modules_from
+    foo, object = Foo.new, Object.new
+    assert !object.respond_to?(:bar)
+    assert !object.respond_to?(:baz)
+
+    object.extend_with_included_modules_from(foo)
+    assert object.respond_to?(:bar)
+    assert !object.respond_to?(:baz)
+
+    foo.extend(Baz)
+    object.extend_with_included_modules_from(foo)
+    assert object.respond_to?(:bar)
+    assert object.respond_to?(:baz)
+  end
+
+  class DuckTime
+    def acts_like_time?
+      true
+    end
+  end
+
+  def test_duck_typing
+    object = Object.new
+    time   = Time.now
+    date   = Date.today
+    dt     = DateTime.new
+    duck   = DuckTime.new
+
+    assert !object.acts_like?(:time)
+    assert !object.acts_like?(:date)
+
+    assert time.acts_like?(:time)
+    assert !time.acts_like?(:date)
+
+    assert !date.acts_like?(:time)
+    assert date.acts_like?(:date)
+
+    assert dt.acts_like?(:time)
+    assert dt.acts_like?(:date)
+
+    assert duck.acts_like?(:time)
+    assert !duck.acts_like?(:date)
+  end
+
+  def test_metaclass
+    string = "Hello"
+    string.singleton_class.instance_eval do
+      define_method(:foo) { "bar" }
+    end
+    assert_equal "bar", string.foo
+  end
+
+  def test_singleton_class
+    o = Object.new
+    assert_equal class << o; self end, o.singleton_class
+  end
+
+  def test_metaclass_deprecated
+    o = Object.new
+    assert_deprecated(/use singleton_class instead/) do
+      assert_equal o.singleton_class, o.metaclass
+    end
+   end
+end
+
+class ObjectInstanceVariableTest < Test::Unit::TestCase
+  def setup
+    @source, @dest = Object.new, Object.new
+    @source.instance_variable_set(:@bar, 'bar')
+    @source.instance_variable_set(:@baz, 'baz')
+  end
+
+  def test_instance_variable_names
+    assert_equal %w(@bar @baz), @source.instance_variable_names.sort
+  end
+
+  def test_instance_variable_defined
+    assert @source.instance_variable_defined?('@bar')
+    assert @source.instance_variable_defined?(:@bar)
+    assert !@source.instance_variable_defined?(:@foo)
+    assert !@source.instance_variable_defined?('@foo')
+  end
+
+  def test_copy_instance_variables_from_without_explicit_excludes
+    assert_equal [], @dest.instance_variables
+    @dest.copy_instance_variables_from(@source)
+
+    assert_equal %w(@bar @baz), @dest.instance_variables.sort.map(&:to_s)
+    %w(@bar @baz).each do |name|
+      assert_equal @source.instance_variable_get(name).object_id,
+                   @dest.instance_variable_get(name).object_id
+    end
+  end
+
+  def test_copy_instance_variables_from_with_explicit_excludes
+    @dest.copy_instance_variables_from(@source, ['@baz'])
+    assert !@dest.instance_variable_defined?('@baz')
+    assert_equal 'bar', @dest.instance_variable_get('@bar')
+  end
+
+  def test_copy_instance_variables_automatically_excludes_protected_instance_variables
+    @source.instance_variable_set(:@quux, 'quux')
+    class << @source
+      def protected_instance_variables
+        ['@bar', :@quux]
+      end
+    end
+
+    @dest.copy_instance_variables_from(@source)
+    assert !@dest.instance_variable_defined?('@bar')
+    assert !@dest.instance_variable_defined?('@quux')
+    assert_equal 'baz', @dest.instance_variable_get('@baz')
+  end
+
+  def test_instance_values
+    object = Object.new
+    object.instance_variable_set :@a, 1
+    object.instance_variable_set :@b, 2
+    assert_equal({'a' => 1, 'b' => 2}, object.instance_values)
+  end
+
+  def test_instance_exec_passes_arguments_to_block
+    assert_equal %w(hello goodbye), 'hello'.instance_exec('goodbye') { |v| [self, v] }
+  end
+
+  def test_instance_exec_with_frozen_obj
+    assert_equal %w(olleh goodbye), 'hello'.freeze.instance_exec('goodbye') { |v| [reverse, v] }
+  end
+
+  def test_instance_exec_nested
+    assert_equal %w(goodbye olleh bar), 'hello'.instance_exec('goodbye') { |arg|
+      [arg] + instance_exec('bar') { |v| [reverse, v] } }
+  end
+end
+
+class ObjectTryTest < Test::Unit::TestCase
+  def setup
+    @string = "Hello"
+  end
+
+  def test_nonexisting_method
+    method = :undefined_method
+    assert !@string.respond_to?(method)
+    assert_raise(NoMethodError) { @string.try(method) }
+  end
+
+  def test_valid_method
+    assert_equal 5, @string.try(:size)
+  end
+
+  def test_argument_forwarding
+    assert_equal 'Hey', @string.try(:sub, 'llo', 'y')
+  end
+
+  def test_block_forwarding
+    assert_equal 'Hey', @string.try(:sub, 'llo') { |match| 'y' }
+  end
+
+  def test_nil_to_type
+    assert_nil nil.try(:to_s)
+    assert_nil nil.try(:to_i)
+  end
+
+  def test_false_try
+    assert_equal 'false', false.try(:to_s)
+  end
+end