usher 0.6.8 → 0.7.0

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

@@ -0,0 +1,37 @@
+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
+    # It's results are tested comprehensively in the inflector test cases.
+    assert_equal '1st', 1.ordinalize
+    assert_equal '8th', 8.ordinalize
+    1000000000000000000000000000000000000000000000000000000000000000000000.ordinalize
+  end
+end

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

@@ -0,0 +1,43 @@
+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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/load_error_test.rb

@@ -0,0 +1,16 @@
+require 'abstract_unit'
+
+class TestMissingSourceFile < Test::Unit::TestCase
+  def test_with_require
+    assert_raises(MissingSourceFile) { require 'no_this_file_don\'t_exist' }
+  end
+  def test_with_load
+    assert_raises(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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/module/attr_accessor_with_default_test.rb

@@ -0,0 +1,30 @@
+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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/module/attr_internal_test.rb

@@ -0,0 +1,52 @@
+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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/module/attribute_accessor_test.rb

@@ -0,0 +1,33 @@
+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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/module/attribute_aliasing_test.rb

@@ -0,0 +1,58 @@
+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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/module/model_naming_test.rb

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

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

@@ -0,0 +1,85 @@
+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_raises(ArgumentError) do
+      @target.synchronize :to_s
+    end
+  end
+
+  def test_double_synchronize_raises_an_argument_error
+    @target.synchronize :to_s, :with => :mutex
+    assert_raises(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/spec/rails2_2/vendor/rails/vendor/rails/activesupport/test/core_ext/module_test.rb

@@ -0,0 +1,325 @@
+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 => :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
+
+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_raises(ArgumentError) { eval($nowhere) }
+    assert_raises(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_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_raises 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_raises 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