usher 0.7.0 → 0.7.1

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

@@ -1,24 +0,0 @@
-require 'abstract_unit'
-
-class NameErrorTest < Test::Unit::TestCase
-  def test_name_error_should_set_missing_name
-    begin
-      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
-  end
-
-  def test_missing_method_should_ignore_missing_name
-    begin
-      some_method_that_does_not_exist
-      flunk "?!?!"
-    rescue NameError => exc
-      assert_equal nil, exc.missing_name
-      assert ! exc.missing_name?(:Foo)
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-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
-end

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

@@ -1,249 +0,0 @@
-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 < Test::Unit::TestCase
-  def test_suppress_re_raises
-    assert_raises(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.metaclass.instance_eval do
-      define_method(:foo) { "bar" }
-    end
-    assert_equal "bar", string.foo
-  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

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/pathname_test.rb

@@ -1,9 +0,0 @@
-require 'abstract_unit'
-
-class TestPathname < Test::Unit::TestCase
-  def test_clean_within
-    assert_equal "Hi", Pathname.clean_within("Hi")
-    assert_equal "Hi", Pathname.clean_within("Hi/a/b/../..")
-    assert_equal "Hello\nWorld", Pathname.clean_within("Hello/a/b/../..\na/b/../../World/c/..")
-  end
-end

data/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/proc_test.rb

@@ -1,11 +0,0 @@
-require 'abstract_unit'
-
-class ProcTests < Test::Unit::TestCase
-  def test_bind_returns_method_with_changed_self
-    block = Proc.new { self }
-    assert_equal self, block.call
-    bound_block = block.bind("hello")
-    assert_not_equal block, bound_block
-    assert_equal "hello", bound_block.call
-  end
-end