radiant 0.9.0.rc2 → 0.9.1

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

@@ -1,252 +0,0 @@
-# encoding: utf-8
-
-module InflectorTestCases
-  SingularToPlural = {
-    "search"      => "searches",
-    "switch"      => "switches",
-    "fix"         => "fixes",
-    "box"         => "boxes",
-    "process"     => "processes",
-    "address"     => "addresses",
-    "case"        => "cases",
-    "stack"       => "stacks",
-    "wish"        => "wishes",
-    "fish"        => "fish",
-
-    "category"    => "categories",
-    "query"       => "queries",
-    "ability"     => "abilities",
-    "agency"      => "agencies",
-    "movie"       => "movies",
-
-    "archive"     => "archives",
-
-    "index"       => "indices",
-
-    "wife"        => "wives",
-    "safe"        => "saves",
-    "half"        => "halves",
-
-    "move"        => "moves",
-
-    "salesperson" => "salespeople",
-    "person"      => "people",
-
-    "spokesman"   => "spokesmen",
-    "man"         => "men",
-    "woman"       => "women",
-
-    "basis"       => "bases",
-    "diagnosis"   => "diagnoses",
-    "diagnosis_a" => "diagnosis_as",
-
-    "datum"       => "data",
-    "medium"      => "media",
-    "analysis"    => "analyses",
-
-    "node_child"  => "node_children",
-    "child"       => "children",
-
-    "experience"  => "experiences",
-    "day"         => "days",
-
-    "comment"     => "comments",
-    "foobar"      => "foobars",
-    "newsletter"  => "newsletters",
-
-    "old_news"    => "old_news",
-    "news"        => "news",
-
-    "series"      => "series",
-    "species"     => "species",
-
-    "quiz"        => "quizzes",
-
-    "perspective" => "perspectives",
-
-    "ox"          => "oxen",
-    "photo"       => "photos",
-    "buffalo"     => "buffaloes",
-    "tomato"      => "tomatoes",
-    "dwarf"       => "dwarves",
-    "elf"         => "elves",
-    "information" => "information",
-    "equipment"   => "equipment",
-    "bus"         => "buses",
-    "status"      => "statuses",
-    "status_code" => "status_codes",
-    "mouse"       => "mice",
-
-    "louse"       => "lice",
-    "house"       => "houses",
-    "octopus"     => "octopi",
-    "virus"       => "viri",
-    "alias"       => "aliases",
-    "portfolio"   => "portfolios",
-
-    "vertex"      => "vertices",
-    "matrix"      => "matrices",
-    "matrix_fu"   => "matrix_fus",
-
-    "axis"        => "axes",
-    "testis"      => "testes",
-    "crisis"      => "crises",
-
-    "rice"        => "rice",
-    "shoe"        => "shoes",
-
-    "horse"       => "horses",
-    "prize"       => "prizes",
-    "edge"        => "edges",
-
-    "cow"         => "kine",
-    "database"    => "databases"
-  }
-
-  CamelToUnderscore = {
-    "Product"               => "product",
-    "SpecialGuest"          => "special_guest",
-    "ApplicationController" => "application_controller",
-    "Area51Controller"      => "area51_controller"
-  }
-
-  UnderscoreToLowerCamel = {
-    "product"                => "product",
-    "special_guest"          => "specialGuest",
-    "application_controller" => "applicationController",
-    "area51_controller"      => "area51Controller"
-  }
-
-  CamelToUnderscoreWithoutReverse = {
-    "HTMLTidy"              => "html_tidy",
-    "HTMLTidyGenerator"     => "html_tidy_generator",
-    "FreeBSD"               => "free_bsd",
-    "HTML"                  => "html",
-  }
-
-  CamelWithModuleToUnderscoreWithSlash = {
-    "Admin::Product" => "admin/product",
-    "Users::Commission::Department" => "users/commission/department",
-    "UsersSection::CommissionDepartment" => "users_section/commission_department",
-  }
-
-  ClassNameToForeignKeyWithUnderscore = {
-    "Person" => "person_id",
-    "MyApplication::Billing::Account" => "account_id"
-  }
-
-  ClassNameToForeignKeyWithoutUnderscore = {
-    "Person" => "personid",
-    "MyApplication::Billing::Account" => "accountid"
-  }
-
-  ClassNameToTableName = {
-    "PrimarySpokesman" => "primary_spokesmen",
-    "NodeChild"        => "node_children"
-  }
-
-  StringToParameterized = {
-    "Donald E. Knuth"                     => "donald-e-knuth",
-    "Random text with *(bad)* characters" => "random-text-with-bad-characters",
-    "Allow_Under_Scores"                  => "allow_under_scores",
-    "Trailing bad characters!@#"          => "trailing-bad-characters",
-    "!@#Leading bad characters"           => "leading-bad-characters",
-    "Squeeze   separators"                => "squeeze-separators"
-  }
-
-  StringToParameterizeWithNoSeparator = {
-    "Donald E. Knuth"                     => "donaldeknuth",
-    "Random text with *(bad)* characters" => "randomtextwithbadcharacters",
-    "Trailing bad characters!@#"          => "trailingbadcharacters",
-    "!@#Leading bad characters"           => "leadingbadcharacters",
-    "Squeeze   separators"                => "squeezeseparators"
-  }
-
-  StringToParameterizeWithUnderscore = {
-    "Donald E. Knuth"                     => "donald_e_knuth",
-    "Random text with *(bad)* characters" => "random_text_with_bad_characters",
-    "Trailing bad characters!@#"          => "trailing_bad_characters",
-    "!@#Leading bad characters"           => "leading_bad_characters",
-    "Squeeze   separators"                => "squeeze_separators"
-  }
-
-  # Ruby 1.9 doesn't do Unicode normalization yet.
-  if RUBY_VERSION >= '1.9'
-    StringToParameterizedAndNormalized = {
-      "Malmö"                               => "malm",
-      "Garçons"                             => "gar-ons"
-    }
-  else
-    StringToParameterizedAndNormalized = {
-      "Malmö"                               => "malmo",
-      "Garçons"                             => "garcons"
-    }
-  end
-
-  UnderscoreToHuman = {
-    "employee_salary" => "Employee salary",
-    "employee_id"     => "Employee",
-    "underground"     => "Underground"
-  }
-
-  MixtureToTitleCase = {
-    'active_record'       => 'Active Record',
-    'ActiveRecord'        => 'Active Record',
-    'action web service'  => 'Action Web Service',
-    'Action Web Service'  => 'Action Web Service',
-    'Action web service'  => 'Action Web Service',
-    'actionwebservice'    => 'Actionwebservice',
-    'Actionwebservice'    => 'Actionwebservice',
-    "david's code"        => "David's Code",
-    "David's code"        => "David's Code",
-    "david's Code"        => "David's Code"
-  }
-
-  OrdinalNumbers = {
-    "0" => "0th",
-    "1" => "1st",
-    "2" => "2nd",
-    "3" => "3rd",
-    "4" => "4th",
-    "5" => "5th",
-    "6" => "6th",
-    "7" => "7th",
-    "8" => "8th",
-    "9" => "9th",
-    "10" => "10th",
-    "11" => "11th",
-    "12" => "12th",
-    "13" => "13th",
-    "14" => "14th",
-    "20" => "20th",
-    "21" => "21st",
-    "22" => "22nd",
-    "23" => "23rd",
-    "24" => "24th",
-    "100" => "100th",
-    "101" => "101st",
-    "102" => "102nd",
-    "103" => "103rd",
-    "104" => "104th",
-    "110" => "110th",
-    "111" => "111th",
-    "112" => "112th",
-    "113" => "113th",
-    "1000" => "1000th",
-    "1001" => "1001st"
-  }
-
-  UnderscoresToDashes = {
-    "street"                => "street",
-    "street_address"        => "street-address",
-    "person_street_address" => "person-street-address"
-  }
-
-  Irregularities = {
-    'person' => 'people',
-    'man'    => 'men',
-    'child'  => 'children',
-    'sex'    => 'sexes',
-    'move'   => 'moves',
-  }
-end

data/vendor/rails/activesupport/test/json/decoding_test.rb

@@ -1,73 +0,0 @@
-# encoding: UTF-8
-require 'abstract_unit'
-
-class TestJSONDecoding < ActiveSupport::TestCase
-  TESTS = {
-    %q({"returnTo":{"\/categories":"\/"}})        => {"returnTo" => {"/categories" => "/"}},
-    %q({"return\\"To\\":":{"\/categories":"\/"}}) => {"return\"To\":" => {"/categories" => "/"}},
-    %q({"returnTo":{"\/categories":1}})          => {"returnTo" => {"/categories" => 1}},
-    %({"returnTo":[1,"a"]})                    => {"returnTo" => [1, "a"]},
-    %({"returnTo":[1,"\\"a\\",", "b"]})        => {"returnTo" => [1, "\"a\",", "b"]},
-    %({"a": "'", "b": "5,000"})                  => {"a" => "'", "b" => "5,000"},
-    %({"a": "a's, b's and c's", "b": "5,000"})   => {"a" => "a's, b's and c's", "b" => "5,000"},
-    # multibyte
-    %({"matzue": "松江", "asakusa": "浅草"}) => {"matzue" => "松江", "asakusa" => "浅草"},
-    %({"a": "2007-01-01"})                       => {'a' => Date.new(2007, 1, 1)},
-    %({"a": "2007-01-01 01:12:34 Z"})            => {'a' => Time.utc(2007, 1, 1, 1, 12, 34)},
-    # no time zone
-    %({"a": "2007-01-01 01:12:34"})              => {'a' => "2007-01-01 01:12:34"},
-    # needs to be *exact*
-    %({"a": " 2007-01-01 01:12:34 Z "})          => {'a' => " 2007-01-01 01:12:34 Z "},
-    %({"a": "2007-01-01 : it's your birthday"})  => {'a' => "2007-01-01 : it's your birthday"},
-    %([])    => [],
-    %({})    => {},
-    %({"a":1})     => {"a" => 1},
-    %({"a": ""})    => {"a" => ""},
-    %({"a":"\\""}) => {"a" => "\""},
-    %({"a": null})  => {"a" => nil},
-    %({"a": true})  => {"a" => true},
-    %({"a": false}) => {"a" => false},
-    %q({"bad":"\\\\","trailing":""}) => {"bad" => "\\", "trailing" => ""},
-    %q({"a": "http:\/\/test.host\/posts\/1"}) => {"a" => "http://test.host/posts/1"},
-    %q({"a": "\u003cunicode\u0020escape\u003e"}) => {"a" => "<unicode escape>"},
-    %q({"a": "\\\\u0020skip double backslashes"}) => {"a" => "\\u0020skip double backslashes"},
-    %q({"a": "\u003cbr /\u003e"}) => {'a' => "<br />"},
-    %q({"b":["\u003ci\u003e","\u003cb\u003e","\u003cu\u003e"]}) => {'b' => ["<i>","<b>","<u>"]}
-  }
-
-  # load the default JSON backend
-  ActiveSupport::JSON.backend
-
-  backends = %w(Yaml)
-  backends << "JSONGem" if defined?(::JSON)
-
-  backends.each do |backend|
-    TESTS.each do |json, expected|
-      test "json decodes #{json} with the #{backend} backend" do
-        ActiveSupport.parse_json_times = true
-        silence_warnings do
-          ActiveSupport::JSON.with_backend backend do
-            assert_nothing_raised do
-              assert_equal expected, ActiveSupport::JSON.decode(json)
-            end
-          end
-        end
-      end
-    end
-  end
-
-  if backends.include?("JSONGem")
-    test "json decodes time json with time parsing disabled" do
-      ActiveSupport.parse_json_times = false
-      expected = {"a" => "2007-01-01 01:12:34 Z"}
-      ActiveSupport::JSON.with_backend "JSONGem" do
-        assert_equal expected, ActiveSupport::JSON.decode(%({"a": "2007-01-01 01:12:34 Z"}))
-      end
-    end
-  end
-
-  def test_failed_json_decoding
-    assert_raise(ActiveSupport::JSON.parse_error) { ActiveSupport::JSON.decode(%({: 1})) }
-  end
-end
-

data/vendor/rails/activesupport/test/json/encoding_test.rb

@@ -1,160 +0,0 @@
-# encoding: utf-8
-require 'abstract_unit'
-
-class TestJSONEncoding < Test::Unit::TestCase
-  class Foo
-    def initialize(a, b)
-      @a, @b = a, b
-    end
-  end
-
-  class Custom
-    def to_json(options)
-      '"custom"'
-    end
-  end
-
-  TrueTests     = [[ true,  %(true)  ]]
-  FalseTests    = [[ false, %(false) ]]
-  NilTests      = [[ nil,   %(null)  ]]
-  NumericTests  = [[ 1,     %(1)     ],
-                   [ 2.5,   %(2.5)   ]]
-
-  StringTests   = [[ 'this is the <string>',     %("this is the \\u003Cstring\\u003E")],
-                   [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
-                   [ 'http://test.host/posts/1', %("http://test.host/posts/1")]]
-
-  ArrayTests    = [[ ['a', 'b', 'c'],          %([\"a\",\"b\",\"c\"])          ],
-                   [ [1, 'a', :b, nil, false], %([1,\"a\",\"b\",null,false]) ]]
-
-  SymbolTests   = [[ :a,     %("a")    ],
-                   [ :this,  %("this") ],
-                   [ :"a b", %("a b")  ]]
-
-  ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
-  CustomTests   = [[ Custom.new, '"custom"' ]]
-
-  VariableTests = [[ ActiveSupport::JSON::Variable.new('foo'), 'foo'],
-                   [ ActiveSupport::JSON::Variable.new('alert("foo")'), 'alert("foo")']]
-  RegexpTests   = [[ /^a/, '/^a/' ], [/^\w{1,2}[a-z]+/ix, '/^\\w{1,2}[a-z]+/ix']]
-
-  DateTests     = [[ Date.new(2005,2,1), %("2005/02/01") ]]
-  TimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
-  DateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
-
-  StandardDateTests     = [[ Date.new(2005,2,1), %("2005-02-01") ]]
-  StandardTimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005-02-01T15:15:10Z") ]]
-  StandardDateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005-02-01T15:15:10+00:00") ]]
-  StandardStringTests   = [[ 'this is the <string>', %("this is the <string>")]]
-
-  constants.grep(/Tests$/).each do |class_tests|
-    define_method("test_#{class_tests[0..-6].underscore}") do
-      begin
-        ActiveSupport.escape_html_entities_in_json  = class_tests !~ /^Standard/
-        ActiveSupport.use_standard_json_time_format = class_tests =~ /^Standard/
-        self.class.const_get(class_tests).each do |pair|
-          assert_equal pair.last, ActiveSupport::JSON.encode(pair.first)
-        end
-      ensure
-        ActiveSupport.escape_html_entities_in_json  = false
-        ActiveSupport.use_standard_json_time_format = false
-      end
-    end
-  end
-
-  def test_hash_encoding
-    assert_equal %({\"a\":\"b\"}), ActiveSupport::JSON.encode(:a => :b)
-    assert_equal %({\"a\":1}),     ActiveSupport::JSON.encode('a' => 1)
-    assert_equal %({\"a\":[1,2]}), ActiveSupport::JSON.encode('a' => [1,2])
-    assert_equal %({"1":2}),       ActiveSupport::JSON.encode(1 => 2)
-
-    sorted_json = '{' + ActiveSupport::JSON.encode(:a => :b, :c => :d)[1..-2].split(',').sort.join(',') + '}'
-    assert_equal %({\"a\":\"b\",\"c\":\"d\"}), sorted_json
-  end
-
-  def test_utf8_string_encoded_properly_when_kcode_is_utf8
-    with_kcode 'UTF8' do
-      result = ActiveSupport::JSON.encode('€2.99')
-      assert_equal '"\\u20ac2.99"', result
-      assert_equal(Encoding::UTF_8, result.encoding) if result.respond_to?(:encoding)
-
-      result = ActiveSupport::JSON.encode('✎☺')
-      assert_equal '"\\u270e\\u263a"', result
-      assert_equal(Encoding::UTF_8, result.encoding) if result.respond_to?(:encoding)
-    end
-  end
-
-  def test_exception_raised_when_encoding_circular_reference
-    a = [1]
-    a << a
-    assert_raise(ActiveSupport::JSON::Encoding::CircularReferenceError) { ActiveSupport::JSON.encode(a) }
-  end
-
-  def test_hash_key_identifiers_are_always_quoted
-    values = {0 => 0, 1 => 1, :_ => :_, "$" => "$", "a" => "a", :A => :A, :A0 => :A0, "A0B" => "A0B"}
-    assert_equal %w( "$" "A" "A0" "A0B" "_" "a" "0" "1" ).sort, object_keys(ActiveSupport::JSON.encode(values))
-  end
-
-  def test_hash_should_allow_key_filtering_with_only
-    assert_equal %({"a":1}), ActiveSupport::JSON.encode({'a' => 1, :b => 2, :c => 3}, :only => 'a')
-  end
-
-  def test_hash_should_allow_key_filtering_with_except
-    assert_equal %({"b":2}), ActiveSupport::JSON.encode({'foo' => 'bar', :b => 2, :c => 3}, :except => ['foo', :c])
-  end
-  
-  def test_time_to_json_includes_local_offset
-    ActiveSupport.use_standard_json_time_format = true
-    with_env_tz 'US/Eastern' do
-      assert_equal %("2005-02-01T15:15:10-05:00"), ActiveSupport::JSON.encode(Time.local(2005,2,1,15,15,10))
-    end
-  ensure
-    ActiveSupport.use_standard_json_time_format = false
-  end
-
-  def test_nested_hash_with_float
-    assert_nothing_raised do
-      hash = {
-        "CHI" => {
-          :dislay_name => "chicago",
-          :latitude => 123.234
-        }
-      }
-      result = ActiveSupport::JSON.encode(hash)
-    end
-  end
-
-  protected
-
-    def object_keys(json_object)
-      json_object[1..-2].scan(/([^{}:,\s]+):/).flatten.sort
-    end
-    
-    def with_env_tz(new_tz = 'US/Eastern')
-      old_tz, ENV['TZ'] = ENV['TZ'], new_tz
-      yield
-    ensure
-      old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
-    end
-end
-
-class JsonOptionsTests < Test::Unit::TestCase
-  # The json extension passes internal state to to_json
-  def test_non_hash_options_should_be_tolerated
-    faux_internal_state_object = Object.new
-
-    value = Object.new
-    def value.to_json(options) options end
-
-    assert_kind_of Hash, ActiveSupport::JSON.encode(value, faux_internal_state_object)
-  end
-
-  def test_enumerable_should_passthrough_options_to_elements
-    json_options = { :include => :posts }
-    ActiveSupport::JSON.expects(:encode).with(1, json_options)
-    ActiveSupport::JSON.expects(:encode).with(2, json_options)
-    ActiveSupport::JSON.expects(:encode).with('foo', json_options)
-
-    [1, 2, 'foo'].to_json(json_options)
-  end
-end