radiant 0.9.0.rc2 → 0.9.1

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

@@ -1,167 +0,0 @@
-require 'abstract_unit'
-
-class Deprecatee
-  def initialize
-    @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request)
-    @_request = 'there we go'
-  end
-  def request; @_request end
-  def old_request; @request end
-
-  def partially(foo = nil)
-    ActiveSupport::Deprecation.warn('calling with foo=nil is out', caller) if foo.nil?
-  end
-
-  def not() 2 end
-  def none() 1 end
-  def one(a) a end
-  def multi(a,b,c) [a,b,c] end
-  deprecate :none, :one, :multi
-
-  def a; end
-  def b; end
-  def c; end
-  def d; end
-  def e; end
-  deprecate :a, :b, :c => :e, :d => "you now need to do something extra for this one"
-
-  def f=(v); end
-  deprecate :f=
-
-  module B
-    C = 1
-  end
-  A = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('Deprecatee::A', 'Deprecatee::B::C')
-end
-
-
-class DeprecationTest < ActiveSupport::TestCase
-  def setup
-    # Track the last warning.
-    @old_behavior = ActiveSupport::Deprecation.behavior
-    @last_message = nil
-    ActiveSupport::Deprecation.behavior = Proc.new { |message| @last_message = message }
-
-    @dtc = Deprecatee.new
-  end
-
-  def teardown
-    ActiveSupport::Deprecation.behavior = @old_behavior
-  end
-
-  def test_inline_deprecation_warning
-    assert_deprecated(/foo=nil/) do
-      @dtc.partially
-    end
-  end
-
-  def test_undeprecated
-    assert_not_deprecated do
-      assert_equal 2, @dtc.not
-    end
-  end
-
-  def test_deprecate_class_method
-    assert_deprecated(/none is deprecated.*test_deprecate_class_method at/) do
-      assert_equal 1, @dtc.none
-    end
-
-    assert_deprecated(/one is deprecated/) do
-      assert_equal 1, @dtc.one(1)
-    end
-
-    assert_deprecated(/multi is deprecated/) do
-      assert_equal [1,2,3], @dtc.multi(1,2,3)
-    end
-  end
-
-  def test_nil_behavior_is_ignored
-    ActiveSupport::Deprecation.behavior = nil
-    assert_deprecated(/foo=nil/) { @dtc.partially }
-  end
-
-  def test_deprecated_instance_variable_proxy
-    assert_not_deprecated { @dtc.request.size }
-
-    assert_deprecated('@request.size') { assert_equal @dtc.request.size, @dtc.old_request.size }
-    assert_deprecated('@request.to_s') { assert_equal @dtc.request.to_s, @dtc.old_request.to_s }
-  end
-
-  def test_deprecated_instance_variable_proxy_shouldnt_warn_on_inspect
-    assert_not_deprecated { assert_equal @dtc.request.inspect, @dtc.old_request.inspect }
-  end
-
-  def test_deprecated_constant_proxy
-    assert_not_deprecated { Deprecatee::B::C }
-    assert_deprecated('Deprecatee::A') { assert_equal Deprecatee::B::C, Deprecatee::A }
-  end
-
-  def test_assert_deprecation_without_match
-    assert_deprecated do
-      @dtc.partially
-    end
-  end
-
-  def test_assert_deprecated_matches_any_warning
-    assert_deprecated 'abc' do
-      ActiveSupport::Deprecation.warn 'abc'
-      ActiveSupport::Deprecation.warn 'def'
-    end
-  rescue Test::Unit::AssertionFailedError
-    flunk 'assert_deprecated should match any warning in block, not just the last one'
-  end
-
-  def test_assert_not_deprecated_returns_result_of_block
-    assert_equal 123, assert_not_deprecated { 123 }
-  end
-
-  def test_assert_deprecated_returns_result_of_block
-    result = assert_deprecated('abc') do
-      ActiveSupport::Deprecation.warn 'abc'
-      123
-    end
-    assert_equal 123, result
-  end
-
-  def test_silence
-    ActiveSupport::Deprecation.silence do
-      assert_not_deprecated { @dtc.partially }
-    end
-
-    ActiveSupport::Deprecation.silenced = true
-    assert_not_deprecated { @dtc.partially }
-    ActiveSupport::Deprecation.silenced = false
-  end
-
-  def test_deprecation_without_explanation
-    assert_deprecated { @dtc.a }
-    assert_deprecated { @dtc.b }
-    assert_deprecated { @dtc.f = :foo }
-  end
-
-  def test_deprecation_with_alternate_method
-    assert_deprecated(/use e instead/) { @dtc.c }
-  end
-
-  def test_deprecation_with_explicit_message
-    assert_deprecated(/you now need to do something extra for this one/) { @dtc.d }
-  end
-
-  unless defined?(::MiniTest)
-    def test_assertion_failed_error_doesnt_spout_deprecation_warnings
-      error_class = Class.new(StandardError) do
-        def message
-          ActiveSupport::Deprecation.warn 'warning in error message'
-          super
-        end
-      end
-
-      raise error_class.new('hmm')
-
-    rescue => e
-      error = Test::Unit::Error.new('testing ur doodz', e)
-      assert_not_deprecated { error.message }
-      assert_nil @last_message
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require 'active_support'
-require 'test/unit'
-
-class FlashCacheOnPrivateMemoizationTest < Test::Unit::TestCase
-  extend ActiveSupport::Memoizable
-
-  def test_public
-    assert_method_unmemoizable :pub
-  end
-
-  def test_protected
-    assert_method_unmemoizable :prot
-  end
-
-  def test_private
-    assert_method_unmemoizable :priv
-  end
-
-  def pub; rand end
-  memoize :pub
-
-  protected
-
-  def prot; rand end
-  memoize :prot
-
-  private
-
-  def priv; rand end
-  memoize :priv
-
-  def assert_method_unmemoizable(meth, message=nil)
-    full_message = build_message(message, "<?> not unmemoizable.\n", meth)
-    assert_block(full_message) do
-      a = send meth
-      b = send meth
-      unmemoize_all
-      c = send meth
-      a == b && a != c
-    end
-  end
-
-end

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

@@ -1,7 +0,0 @@
-require 'abstract_unit'
-
-class GzipTest < Test::Unit::TestCase
-  def test_compress_should_decompress_to_the_same_value
-    assert_equal "Hello World", ActiveSupport::Gzip.decompress(ActiveSupport::Gzip.compress("Hello World"))
-  end
-end

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

@@ -1,98 +0,0 @@
-require 'abstract_unit'
-
-class I18nTest < Test::Unit::TestCase
-  def setup
-    @date = Date.parse("2008-7-2")
-    @time = Time.utc(2008, 7, 2, 16, 47, 1)
-  end
-  
-  def test_time_zone_localization_with_default_format
-    Time.zone.stubs(:now).returns Time.local(2000)
-    assert_equal Time.zone.now.strftime("%a, %d %b %Y %H:%M:%S %z"), I18n.localize(Time.zone.now)
-  end
-  
-  def test_date_localization_should_use_default_format
-    assert_equal @date.strftime("%Y-%m-%d"), I18n.localize(@date)
-  end
-  
-  def test_date_localization_with_default_format
-    assert_equal @date.strftime("%Y-%m-%d"), I18n.localize(@date, :format => :default)
-  end
-  
-  def test_date_localization_with_short_format
-    assert_equal @date.strftime("%b %d"), I18n.localize(@date, :format => :short)
-  end
-  
-  def test_date_localization_with_long_format
-    assert_equal @date.strftime("%B %d, %Y"), I18n.localize(@date, :format => :long)
-  end
-  
-  def test_time_localization_should_use_default_format    
-    assert_equal @time.strftime("%a, %d %b %Y %H:%M:%S %z"), I18n.localize(@time)
-  end
-  
-  def test_time_localization_with_default_format
-    assert_equal @time.strftime("%a, %d %b %Y %H:%M:%S %z"), I18n.localize(@time, :format => :default)
-  end
-  
-  def test_time_localization_with_short_format
-    assert_equal @time.strftime("%d %b %H:%M"), I18n.localize(@time, :format => :short)
-  end
-  
-  def test_time_localization_with_long_format
-    assert_equal @time.strftime("%B %d, %Y %H:%M"), I18n.localize(@time, :format => :long)
-  end
-    
-  def test_day_names
-    assert_equal Date::DAYNAMES, I18n.translate(:'date.day_names')
-  end
-  
-  def test_abbr_day_names
-    assert_equal Date::ABBR_DAYNAMES, I18n.translate(:'date.abbr_day_names')
-  end
-  
-  def test_month_names
-    assert_equal Date::MONTHNAMES, I18n.translate(:'date.month_names')
-  end
-  
-  def test_abbr_month_names
-    assert_equal Date::ABBR_MONTHNAMES, I18n.translate(:'date.abbr_month_names')
-  end
-  
-  def test_date_order
-    assert_equal [:year, :month, :day], I18n.translate(:'date.order')
-  end
-  
-  def test_time_am
-    assert_equal 'am', I18n.translate(:'time.am')
-  end
-  
-  def test_time_pm
-    assert_equal 'pm', I18n.translate(:'time.pm')
-  end
-
-  def test_words_connector
-    assert_equal ', ', I18n.translate(:'support.array.words_connector')
-  end
-
-  def test_two_words_connector
-    assert_equal ' and ', I18n.translate(:'support.array.two_words_connector')
-  end
-
-  def test_last_word_connector
-    assert_equal ', and ', I18n.translate(:'support.array.last_word_connector')
-  end
-
-  def test_to_sentence
-    default_two_words_connector = I18n.translate(:'support.array.two_words_connector')
-    default_last_word_connector = I18n.translate(:'support.array.last_word_connector')
-    assert_equal 'a, b, and c', %w[a b c].to_sentence
-    I18n.backend.store_translations 'en', :support => { :array => { :two_words_connector => ' & ' } }
-    assert_equal 'a & b', %w[a b].to_sentence
-    I18n.backend.store_translations 'en', :support => { :array => { :last_word_connector => ' and ' } }
-    assert_equal 'a, b and c', %w[a b c].to_sentence
-  ensure
-    I18n.backend.store_translations 'en', :support => { :array => { :two_words_connector => default_two_words_connector } }
-    I18n.backend.store_translations 'en', :support => { :array => { :last_word_connector => default_last_word_connector } }
-  end
-end

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

@@ -1,298 +0,0 @@
-require 'abstract_unit'
-require 'inflector_test_cases'
-
-module Ace
-  module Base
-    class Case
-    end
-  end
-end
-
-class InflectorTest < Test::Unit::TestCase
-  include InflectorTestCases
-
-  def test_pluralize_plurals
-    assert_equal "plurals", ActiveSupport::Inflector.pluralize("plurals")
-    assert_equal "Plurals", ActiveSupport::Inflector.pluralize("Plurals")
-  end
-
-  def test_pluralize_empty_string
-    assert_equal "", ActiveSupport::Inflector.pluralize("")
-  end
-
-  SingularToPlural.each do |singular, plural|
-    define_method "test_pluralize_#{singular}" do
-      assert_equal(plural, ActiveSupport::Inflector.pluralize(singular))
-      assert_equal(plural.capitalize, ActiveSupport::Inflector.pluralize(singular.capitalize))
-    end
-  end
-
-  SingularToPlural.each do |singular, plural|
-    define_method "test_singularize_#{plural}" do
-      assert_equal(singular, ActiveSupport::Inflector.singularize(plural))
-      assert_equal(singular.capitalize, ActiveSupport::Inflector.singularize(plural.capitalize))
-    end
-  end
-
-  def test_overwrite_previous_inflectors
-    assert_equal("series", ActiveSupport::Inflector.singularize("series"))
-    ActiveSupport::Inflector.inflections.singular "series", "serie"
-    assert_equal("serie", ActiveSupport::Inflector.singularize("series"))
-    ActiveSupport::Inflector.inflections.uncountable "series" # Return to normal
-  end
-
-  MixtureToTitleCase.each do |before, titleized|
-    define_method "test_titleize_#{before}" do
-      assert_equal(titleized, ActiveSupport::Inflector.titleize(before))
-    end
-  end
-
-  def test_camelize
-    CamelToUnderscore.each do |camel, underscore|
-      assert_equal(camel, ActiveSupport::Inflector.camelize(underscore))
-    end
-  end
-
-  def test_camelize_with_lower_downcases_the_first_letter
-    assert_equal('capital', ActiveSupport::Inflector.camelize('Capital', false))
-  end
-
-  def test_underscore
-    CamelToUnderscore.each do |camel, underscore|
-      assert_equal(underscore, ActiveSupport::Inflector.underscore(camel))
-    end
-    CamelToUnderscoreWithoutReverse.each do |camel, underscore|
-      assert_equal(underscore, ActiveSupport::Inflector.underscore(camel))
-    end
-  end
-
-  def test_camelize_with_module
-    CamelWithModuleToUnderscoreWithSlash.each do |camel, underscore|
-      assert_equal(camel, ActiveSupport::Inflector.camelize(underscore))
-    end
-  end
-
-  def test_underscore_with_slashes
-    CamelWithModuleToUnderscoreWithSlash.each do |camel, underscore|
-      assert_equal(underscore, ActiveSupport::Inflector.underscore(camel))
-    end
-  end
-
-  def test_demodulize
-    assert_equal "Account", ActiveSupport::Inflector.demodulize("MyApplication::Billing::Account")
-  end
-
-  def test_foreign_key
-    ClassNameToForeignKeyWithUnderscore.each do |klass, foreign_key|
-      assert_equal(foreign_key, ActiveSupport::Inflector.foreign_key(klass))
-    end
-
-    ClassNameToForeignKeyWithoutUnderscore.each do |klass, foreign_key|
-      assert_equal(foreign_key, ActiveSupport::Inflector.foreign_key(klass, false))
-    end
-  end
-
-  def test_tableize
-    ClassNameToTableName.each do |class_name, table_name|
-      assert_equal(table_name, ActiveSupport::Inflector.tableize(class_name))
-    end
-  end
-
-  def test_parameterize
-    StringToParameterized.each do |some_string, parameterized_string|
-      assert_equal(parameterized_string, ActiveSupport::Inflector.parameterize(some_string))
-    end
-  end
-
-  def test_parameterize_and_normalize
-    StringToParameterizedAndNormalized.each do |some_string, parameterized_string|
-      assert_equal(parameterized_string, ActiveSupport::Inflector.parameterize(some_string))
-    end
-  end
-
-  def test_parameterize_with_custom_separator
-    StringToParameterized.each do |some_string, parameterized_string|
-      assert_equal(parameterized_string.gsub('-', '_'), ActiveSupport::Inflector.parameterize(some_string, '_'))
-    end
-  end
-
-  def test_parameterize_with_multi_character_separator
-    StringToParameterized.each do |some_string, parameterized_string|
-      assert_equal(parameterized_string.gsub('-', '__sep__'), ActiveSupport::Inflector.parameterize(some_string, '__sep__'))
-    end
-  end
-
-  def test_classify
-    ClassNameToTableName.each do |class_name, table_name|
-      assert_equal(class_name, ActiveSupport::Inflector.classify(table_name))
-      assert_equal(class_name, ActiveSupport::Inflector.classify("table_prefix." + table_name))
-    end
-  end
-
-  def test_classify_with_symbol
-    assert_nothing_raised do
-      assert_equal 'FooBar', ActiveSupport::Inflector.classify(:foo_bars)
-    end
-  end
-
-  def test_classify_with_leading_schema_name
-    assert_equal 'FooBar', ActiveSupport::Inflector.classify('schema.foo_bar')
-  end
-
-  def test_humanize
-    UnderscoreToHuman.each do |underscore, human|
-      assert_equal(human, ActiveSupport::Inflector.humanize(underscore))
-    end
-  end
-
-  def test_humanize_by_rule
-    ActiveSupport::Inflector.inflections do |inflect|
-      inflect.human(/_cnt$/i, '\1_count')
-      inflect.human(/^prefx_/i, '\1')
-    end
-    assert_equal("Jargon count", ActiveSupport::Inflector.humanize("jargon_cnt"))
-    assert_equal("Request", ActiveSupport::Inflector.humanize("prefx_request"))
-  end
-
-  def test_humanize_by_string
-    ActiveSupport::Inflector.inflections do |inflect|
-      inflect.human("col_rpted_bugs", "Reported bugs")
-    end
-    assert_equal("Reported bugs", ActiveSupport::Inflector.humanize("col_rpted_bugs"))
-    assert_equal("Col rpted bugs", ActiveSupport::Inflector.humanize("COL_rpted_bugs"))
-  end
-
-  def test_constantize
-    assert_nothing_raised { assert_equal Ace::Base::Case, ActiveSupport::Inflector.constantize("Ace::Base::Case") }
-    assert_nothing_raised { assert_equal Ace::Base::Case, ActiveSupport::Inflector.constantize("::Ace::Base::Case") }
-    assert_nothing_raised { assert_equal InflectorTest, ActiveSupport::Inflector.constantize("InflectorTest") }
-    assert_nothing_raised { assert_equal InflectorTest, ActiveSupport::Inflector.constantize("::InflectorTest") }
-    assert_raise(NameError) { ActiveSupport::Inflector.constantize("UnknownClass") }
-    assert_raise(NameError) { ActiveSupport::Inflector.constantize("An invalid string") }
-    assert_raise(NameError) { ActiveSupport::Inflector.constantize("InvalidClass\n") }
-  end
-
-  def test_constantize_does_lexical_lookup
-    assert_raise(NameError) { ActiveSupport::Inflector.constantize("Ace::Base::InflectorTest") }
-  end
-
-  def test_ordinal
-    OrdinalNumbers.each do |number, ordinalized|
-      assert_equal(ordinalized, ActiveSupport::Inflector.ordinalize(number))
-    end
-  end
-
-  def test_dasherize
-    UnderscoresToDashes.each do |underscored, dasherized|
-      assert_equal(dasherized, ActiveSupport::Inflector.dasherize(underscored))
-    end
-  end
-
-  def test_underscore_as_reverse_of_dasherize
-    UnderscoresToDashes.each do |underscored, dasherized|
-      assert_equal(underscored, ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.dasherize(underscored)))
-    end
-  end
-
-  def test_underscore_to_lower_camel
-    UnderscoreToLowerCamel.each do |underscored, lower_camel|
-      assert_equal(lower_camel, ActiveSupport::Inflector.camelize(underscored, false))
-    end
-  end
-
-  %w{plurals singulars uncountables humans}.each do |inflection_type|
-    class_eval "
-      def test_clear_#{inflection_type}
-        cached_values = ActiveSupport::Inflector.inflections.#{inflection_type}
-        ActiveSupport::Inflector.inflections.clear :#{inflection_type}
-        assert ActiveSupport::Inflector.inflections.#{inflection_type}.empty?, \"#{inflection_type} inflections should be empty after clear :#{inflection_type}\"
-        ActiveSupport::Inflector.inflections.instance_variable_set :@#{inflection_type}, cached_values
-      end
-    "
-  end
-
-  def test_clear_all
-    cached_values = ActiveSupport::Inflector.inflections.plurals, ActiveSupport::Inflector.inflections.singulars, ActiveSupport::Inflector.inflections.uncountables, ActiveSupport::Inflector.inflections.humans
-    ActiveSupport::Inflector.inflections.clear :all
-    assert ActiveSupport::Inflector.inflections.plurals.empty?
-    assert ActiveSupport::Inflector.inflections.singulars.empty?
-    assert ActiveSupport::Inflector.inflections.uncountables.empty?
-    assert ActiveSupport::Inflector.inflections.humans.empty?
-    ActiveSupport::Inflector.inflections.instance_variable_set :@plurals, cached_values[0]
-    ActiveSupport::Inflector.inflections.instance_variable_set :@singulars, cached_values[1]
-    ActiveSupport::Inflector.inflections.instance_variable_set :@uncountables, cached_values[2]
-    ActiveSupport::Inflector.inflections.instance_variable_set :@humans, cached_values[3]
-  end
-
-  def test_clear_with_default
-    cached_values = ActiveSupport::Inflector.inflections.plurals, ActiveSupport::Inflector.inflections.singulars, ActiveSupport::Inflector.inflections.uncountables, ActiveSupport::Inflector.inflections.humans
-    ActiveSupport::Inflector.inflections.clear
-    assert ActiveSupport::Inflector.inflections.plurals.empty?
-    assert ActiveSupport::Inflector.inflections.singulars.empty?
-    assert ActiveSupport::Inflector.inflections.uncountables.empty?
-    assert ActiveSupport::Inflector.inflections.humans.empty?
-    ActiveSupport::Inflector.inflections.instance_variable_set :@plurals, cached_values[0]
-    ActiveSupport::Inflector.inflections.instance_variable_set :@singulars, cached_values[1]
-    ActiveSupport::Inflector.inflections.instance_variable_set :@uncountables, cached_values[2]
-    ActiveSupport::Inflector.inflections.instance_variable_set :@humans, cached_values[3]
-  end
-
-  Irregularities.each do |irregularity|
-    singular, plural = *irregularity
-    ActiveSupport::Inflector.inflections do |inflect|
-      define_method("test_irregularity_between_#{singular}_and_#{plural}") do
-        inflect.irregular(singular, plural)
-        assert_equal singular, ActiveSupport::Inflector.singularize(plural)
-        assert_equal plural, ActiveSupport::Inflector.pluralize(singular)
-      end
-    end
-  end
-
-  [ :all, [] ].each do |scope|
-    ActiveSupport::Inflector.inflections do |inflect|
-      define_method("test_clear_inflections_with_#{scope.kind_of?(Array) ? "no_arguments" : scope}") do
-        # save all the inflections
-        singulars, plurals, uncountables = inflect.singulars, inflect.plurals, inflect.uncountables
-
-        # clear all the inflections
-        inflect.clear(*scope)
-
-        assert_equal [], inflect.singulars
-        assert_equal [], inflect.plurals
-        assert_equal [], inflect.uncountables
-
-        # restore all the inflections
-        singulars.reverse.each { |singular| inflect.singular(*singular) }
-        plurals.reverse.each   { |plural|   inflect.plural(*plural) }
-        inflect.uncountable(uncountables)
-
-        assert_equal singulars, inflect.singulars
-        assert_equal plurals, inflect.plurals
-        assert_equal uncountables, inflect.uncountables
-      end
-    end
-  end
-
-  { :singulars => :singular, :plurals => :plural, :uncountables => :uncountable, :humans => :human }.each do |scope, method|
-    ActiveSupport::Inflector.inflections do |inflect|
-      define_method("test_clear_inflections_with_#{scope}") do
-        # save the inflections
-        values = inflect.send(scope)
-
-        # clear the inflections
-        inflect.clear(scope)
-
-        assert_equal [], inflect.send(scope)
-
-        # restore the inflections
-        if scope == :uncountables
-          inflect.send(method, values)
-        else
-          values.reverse.each { |value| inflect.send(method, *value) }
-        end
-
-        assert_equal values, inflect.send(scope)
-      end
-    end
-  end
-end