radiant 0.9.1 → 1.0.0.rc1

data/vendor/rails/activerecord/test/cases/transactions_test.rb

@@ -3,10 +3,12 @@ require 'models/topic'
 require 'models/reply'
 require 'models/developer'
 require 'models/book'
+require 'models/author'
+require 'models/post'
 
 class TransactionTest < ActiveRecord::TestCase
   self.use_transactional_fixtures = false
-  fixtures :topics, :developers
+  fixtures :topics, :developers, :authors, :posts
 
   def setup
     @first, @second = Topic.find(1, 2).sort_by { |t| t.id }
@@ -34,6 +36,25 @@ class TransactionTest < ActiveRecord::TestCase
     end
   end
 
+  def test_update_attributes_should_rollback_on_failure
+    author = Author.find(1)
+    posts_count = author.posts.size
+    assert posts_count > 0
+    status = author.update_attributes(:name => nil, :post_ids => [])
+    assert !status
+    assert_equal posts_count, author.posts(true).size
+  end
+
+  def test_update_attributes_should_rollback_on_failure!
+    author = Author.find(1)
+    posts_count = author.posts.size
+    assert posts_count > 0
+    assert_raise(ActiveRecord::RecordInvalid) do
+      author.update_attributes!(:name => nil, :post_ids => [])
+    end
+    assert_equal posts_count, author.posts(true).size
+  end
+
   def test_successful_with_return
     class << Topic.connection
       alias :real_commit_db_transaction :commit_db_transaction

data/vendor/rails/activerecord/test/cases/validations_i18n_test.rb

@@ -486,20 +486,20 @@ class ActiveRecordErrorI18nTests < ActiveSupport::TestCase
   end
 
   test ":default is only given to message if a symbol is supplied" do
-    store_translations(:errors => { :messages => { :"foo bar" => "You fooed: {{value}}." } })
+    store_translations(:errors => { :messages => { :"foo bar" => "You fooed: %{value}." } })
     @reply.errors.add(:title, :inexistent, :default => "foo bar")
     assert_equal "foo bar", @reply.errors[:title]
   end
 
   test "#generate_message passes the model attribute value for interpolation" do
-    store_translations(:errors => { :messages => { :foo => "You fooed: {{value}}." } })
+    store_translations(:errors => { :messages => { :foo => "You fooed: %{value}." } })
     @reply.title = "da title"
     assert_error_message 'You fooed: da title.', :title, :foo
   end
 
   test "#generate_message passes the human_name of the model for interpolation" do
     store_translations(
-      :errors => { :messages => { :foo => "You fooed: {{model}}." } },
+      :errors => { :messages => { :foo => "You fooed: %{model}." } },
       :models => { :topic => 'da topic' }
     )
     assert_error_message 'You fooed: da topic.', :title, :foo
@@ -507,7 +507,7 @@ class ActiveRecordErrorI18nTests < ActiveSupport::TestCase
 
   test "#generate_message passes the human_name of the attribute for interpolation" do
     store_translations(
-      :errors => { :messages => { :foo => "You fooed: {{attribute}}." } },
+      :errors => { :messages => { :foo => "You fooed: %{attribute}." } },
       :attributes => { :topic => { :title => 'da topic title' } }
     )
     assert_error_message 'You fooed: da topic title.', :title, :foo
@@ -607,17 +607,17 @@ class ActiveRecordErrorI18nTests < ActiveSupport::TestCase
   end
 
   test "#full_message with a format present" do
-    store_translations(:errors => { :messages => { :kaputt => 'is kaputt' }, :full_messages => { :format => '{{attribute}}: {{message}}' } })
+    store_translations(:errors => { :messages => { :kaputt => 'is kaputt' }, :full_messages => { :format => '%{attribute}: %{message}' } })
     assert_full_message 'Title: is kaputt', :title, :kaputt
   end
 
   test "#full_message with a type specific format present" do
-    store_translations(:errors => { :messages => { :kaputt => 'is kaputt' }, :full_messages => { :kaputt => '{{attribute}} {{message}}!' } })
+    store_translations(:errors => { :messages => { :kaputt => 'is kaputt' }, :full_messages => { :kaputt => '%{attribute} %{message}!' } })
     assert_full_message 'Title is kaputt!', :title, :kaputt
   end
 
   test "#full_message with class-level specified custom message" do
-    store_translations(:errors => { :messages => { :broken => 'is kaputt' }, :full_messages => { :broken => '{{attribute}} {{message}}?!' } })
+    store_translations(:errors => { :messages => { :broken => 'is kaputt' }, :full_messages => { :broken => '%{attribute} %{message}?!' } })
     assert_full_message 'Title is kaputt?!', :title, :kaputt, :message => :broken
   end
 
@@ -625,7 +625,7 @@ class ActiveRecordErrorI18nTests < ActiveSupport::TestCase
     store_translations(:my_errors => { :messages => { :kaputt => 'is kaputt' } })
     assert_full_message 'Title is kaputt', :title, :kaputt, :scope => [:activerecord, :my_errors]
 
-    store_translations(:my_errors => { :full_messages => { :kaputt => '{{attribute}} {{message}}!' } })
+    store_translations(:my_errors => { :full_messages => { :kaputt => '%{attribute} %{message}!' } })
     assert_full_message 'Title is kaputt!', :title, :kaputt, :scope => [:activerecord, :my_errors]
   end
 
@@ -763,7 +763,7 @@ class ActiveRecordDefaultErrorMessagesI18nTests < ActiveSupport::TestCase
   end
 
   test "custom message string interpolation" do
-    assert_equal 'custom message title', error_message(:invalid, :default => 'custom message {{value}}', :value => 'title')
+    assert_equal 'custom message title', error_message(:invalid, :default => 'custom message %{value}', :value => 'title')
   end
 end
 
@@ -897,14 +897,14 @@ class ActiveRecordValidationsI18nFullMessagesFullStackTests < ActiveSupport::Tes
 
   test "full_message format stored per custom error message key" do
     assert_full_message("Name is broken!") do
-      store_translations :errors => { :messages => { :broken => 'is broken' }, :full_messages => { :broken => '{{attribute}} {{message}}!' } }
+      store_translations :errors => { :messages => { :broken => 'is broken' }, :full_messages => { :broken => '%{attribute} %{message}!' } }
       I18nPerson.validates_presence_of :name, :message => :broken
     end
   end
 
   test "full_message format stored per error type" do
     assert_full_message("Name can't be blank!") do
-      store_translations :errors => { :full_messages => { :blank => '{{attribute}} {{message}}!' } }
+      store_translations :errors => { :full_messages => { :blank => '%{attribute} %{message}!' } }
       I18nPerson.validates_presence_of :name
     end
   end
@@ -912,7 +912,7 @@ class ActiveRecordValidationsI18nFullMessagesFullStackTests < ActiveSupport::Tes
 
   test "full_message format stored as default" do
     assert_full_message("Name: can't be blank") do
-      store_translations :errors => { :full_messages => { :format => '{{attribute}}: {{message}}' } }
+      store_translations :errors => { :full_messages => { :format => '%{attribute}: %{message}' } }
       I18nPerson.validates_presence_of :name
     end
   end

data/vendor/rails/activerecord/test/cases/validations_test.rb

@@ -434,6 +434,18 @@ class ValidationsTest < ActiveRecord::TestCase
     end
   end
 
+   def test_validate_uniqueness_with_reserved_word_as_scope
+    repair_validations(Reply) do
+      Topic.validates_uniqueness_of(:content, :scope => "group")
+
+      t1 = Topic.create "title" => "t1", "content" => "hello world2"
+      assert t1.valid?
+
+      t2 = Topic.create "title" => "t2", "content" => "hello world2"
+      assert !t2.valid?
+    end
+  end
+
   def test_validate_uniqueness_scoped_to_defining_class
     t = Topic.create("title" => "What, me worry?")
 
@@ -678,7 +690,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validate_format_with_formatted_message
-    Topic.validates_format_of(:title, :with => /^Valid Title$/, :message => "can't be {{value}}")
+    Topic.validates_format_of(:title, :with => /^Valid Title$/, :message => "can't be %{value}")
     t = Topic.create(:title => 'Invalid title')
     assert_equal "can't be Invalid title", t.errors.on(:title)
   end
@@ -741,7 +753,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_inclusion_of_with_formatted_message
-    Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ), :message => "option {{value}} is not in the list" )
+    Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ), :message => "option %{value} is not in the list" )
 
     assert Topic.create("title" => "a", "content" => "abc").valid?
 
@@ -768,7 +780,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_exclusion_of_with_formatted_message
-    Topic.validates_exclusion_of( :title, :in => %w( abe monkey ), :message => "option {{value}} is restricted" )
+    Topic.validates_exclusion_of( :title, :in => %w( abe monkey ), :message => "option %{value} is restricted" )
 
     assert Topic.create("title" => "something", "content" => "abc")
 
@@ -868,7 +880,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_optionally_validates_length_of_using_within_on_create
-    Topic.validates_length_of :title, :content, :within => 5..10, :on => :create, :too_long => "my string is too long: {{count}}"
+    Topic.validates_length_of :title, :content, :within => 5..10, :on => :create, :too_long => "my string is too long: %{count}"
 
     t = Topic.create("title" => "thisisnotvalid", "content" => "whatever")
     assert !t.save
@@ -889,7 +901,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_optionally_validates_length_of_using_within_on_update
-    Topic.validates_length_of :title, :content, :within => 5..10, :on => :update, :too_short => "my string is too short: {{count}}"
+    Topic.validates_length_of :title, :content, :within => 5..10, :on => :update, :too_short => "my string is too short: %{count}"
 
     t = Topic.create("title" => "vali", "content" => "whatever")
     assert !t.save
@@ -953,7 +965,7 @@ class ValidationsTest < ActiveRecord::TestCase
   def test_validates_length_with_globally_modified_error_message
     defaults = ActiveSupport::Deprecation.silence { ActiveRecord::Errors.default_error_messages }
     original_message = defaults[:too_short]
-    defaults[:too_short] = 'tu est trops petit hombre {{count}}'
+    defaults[:too_short] = 'tu est trops petit hombre %{count}'
 
     Topic.validates_length_of :title, :minimum => 10
     t = Topic.create(:title => 'too short')
@@ -1004,7 +1016,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_custom_errors_for_minimum_with_message
-    Topic.validates_length_of( :title, :minimum=>5, :message=>"boo {{count}}" )
+    Topic.validates_length_of( :title, :minimum=>5, :message=>"boo %{count}" )
     t = Topic.create("title" => "uhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1012,7 +1024,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_custom_errors_for_minimum_with_too_short
-    Topic.validates_length_of( :title, :minimum=>5, :too_short=>"hoo {{count}}" )
+    Topic.validates_length_of( :title, :minimum=>5, :too_short=>"hoo %{count}" )
     t = Topic.create("title" => "uhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1020,7 +1032,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_custom_errors_for_maximum_with_message
-    Topic.validates_length_of( :title, :maximum=>5, :message=>"boo {{count}}" )
+    Topic.validates_length_of( :title, :maximum=>5, :message=>"boo %{count}" )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1028,7 +1040,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_custom_errors_for_in
-    Topic.validates_length_of(:title, :in => 10..20, :message => "hoo {{count}}")
+    Topic.validates_length_of(:title, :in => 10..20, :message => "hoo %{count}")
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1041,7 +1053,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_custom_errors_for_maximum_with_too_long
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}" )
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}" )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1049,7 +1061,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_custom_errors_for_is_with_message
-    Topic.validates_length_of( :title, :is=>5, :message=>"boo {{count}}" )
+    Topic.validates_length_of( :title, :is=>5, :message=>"boo %{count}" )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1057,7 +1069,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_custom_errors_for_is_with_wrong_length
-    Topic.validates_length_of( :title, :is=>5, :wrong_length=>"hoo {{count}}" )
+    Topic.validates_length_of( :title, :is=>5, :wrong_length=>"hoo %{count}" )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1123,7 +1135,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_optionally_validates_length_of_using_within_on_create_utf8
     with_kcode('UTF8') do
-      Topic.validates_length_of :title, :within => 5..10, :on => :create, :too_long => "長すぎます: {{count}}"
+      Topic.validates_length_of :title, :within => 5..10, :on => :create, :too_long => "長すぎます: %{count}"
 
       t = Topic.create("title" => "一二三四五六七八九十A", "content" => "whatever")
       assert !t.save
@@ -1146,7 +1158,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_optionally_validates_length_of_using_within_on_update_utf8
     with_kcode('UTF8') do
-      Topic.validates_length_of :title, :within => 5..10, :on => :update, :too_short => "短すぎます: {{count}}"
+      Topic.validates_length_of :title, :within => 5..10, :on => :update, :too_short => "短すぎます: %{count}"
 
       t = Topic.create("title" => "一二三4", "content" => "whatever")
       assert !t.save
@@ -1181,7 +1193,7 @@ class ValidationsTest < ActiveRecord::TestCase
   end
 
   def test_validates_length_of_with_block
-    Topic.validates_length_of :content, :minimum => 5, :too_short=>"Your essay must be at least {{count}} words.",
+    Topic.validates_length_of :content, :minimum => 5, :too_short=>"Your essay must be at least %{count} words.",
                                         :tokenizer => lambda {|str| str.scan(/\w+/) }
     t = Topic.create!(:content => "this content should be long enough")
     assert t.valid?
@@ -1356,7 +1368,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_if_validation_using_method_true
     # When the method returns true
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => :condition_is_true )
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :if => :condition_is_true )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1365,7 +1377,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_unless_validation_using_method_true
     # When the method returns true
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => :condition_is_true )
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :unless => :condition_is_true )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
     assert !t.errors.on(:title)
@@ -1373,7 +1385,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_if_validation_using_method_false
     # When the method returns false
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => :condition_is_true_but_its_not )
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :if => :condition_is_true_but_its_not )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
     assert !t.errors.on(:title)
@@ -1381,7 +1393,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_unless_validation_using_method_false
     # When the method returns false
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => :condition_is_true_but_its_not )
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :unless => :condition_is_true_but_its_not )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1390,7 +1402,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_if_validation_using_string_true
     # When the evaluated string returns true
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => "a = 1; a == 1" )
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :if => "a = 1; a == 1" )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1399,7 +1411,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_unless_validation_using_string_true
     # When the evaluated string returns true
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => "a = 1; a == 1" )
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :unless => "a = 1; a == 1" )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
     assert !t.errors.on(:title)
@@ -1407,7 +1419,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_if_validation_using_string_false
     # When the evaluated string returns false
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => "false")
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :if => "false")
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
     assert !t.errors.on(:title)
@@ -1415,7 +1427,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_unless_validation_using_string_false
     # When the evaluated string returns false
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => "false")
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}", :unless => "false")
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
     assert t.errors.on(:title)
@@ -1424,7 +1436,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_if_validation_using_block_true
     # When the block returns true
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}",
       :if => Proc.new { |r| r.content.size > 4 } )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
@@ -1434,7 +1446,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_unless_validation_using_block_true
     # When the block returns true
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}",
       :unless => Proc.new { |r| r.content.size > 4 } )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
@@ -1443,7 +1455,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_if_validation_using_block_false
     # When the block returns false
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}",
       :if => Proc.new { |r| r.title != "uhohuhoh"} )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
@@ -1452,7 +1464,7 @@ class ValidationsTest < ActiveRecord::TestCase
 
   def test_unless_validation_using_block_false
     # When the block returns false
-    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo %{count}",
       :unless => Proc.new { |r| r.title != "uhohuhoh"} )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
     assert !t.valid?
@@ -1634,13 +1646,13 @@ class ValidatesNumericalityTest < ActiveRecord::TestCase
   end
 
   def test_validates_numericality_with_numeric_message
-    Topic.validates_numericality_of :approved, :less_than => 4, :message => "smaller than {{count}}"
+    Topic.validates_numericality_of :approved, :less_than => 4, :message => "smaller than %{count}"
     topic = Topic.new("title" => "numeric test", "approved" => 10)
 
     assert !topic.valid?
     assert_equal "smaller than 4", topic.errors.on(:approved)
 
-    Topic.validates_numericality_of :approved, :greater_than => 4, :message => "greater than {{count}}"
+    Topic.validates_numericality_of :approved, :greater_than => 4, :message => "greater than %{count}"
     topic = Topic.new("title" => "numeric test", "approved" => 1)
 
     assert !topic.valid?

data/vendor/rails/activerecord/test/fixtures/polymorphic_designs.yml

@@ -0,0 +1,19 @@
+awesome_tee_design:
+  id: 1
+  designable_id: 1
+  designable_type: Tee
+
+sucky_tee_design:
+  id: 2
+  designable_id: 2
+  designable_type: Tee
+
+awesome_hat_design:
+  id: 3
+  designable_id: 1
+  designable_type: Tie
+
+sucky_hat_design:
+  id: 4
+  designable_id: 2
+  designable_type: Tie

data/vendor/rails/activerecord/test/fixtures/polymorphic_prices.yml

@@ -0,0 +1,19 @@
+awesome_tee_price:
+  id: 1
+  sellable_id: 1
+  sellable_type: Tee
+
+sucky_tee_price:
+  id: 2
+  sellable_id: 2
+  sellable_type: Tee
+
+awesome_hat_price:
+  id: 3
+  sellable_id: 1
+  sellable_type: Tie
+
+sucky_hat_price:
+  id: 4
+  sellable_id: 2
+  sellable_type: Tie

data/vendor/rails/activerecord/test/fixtures/tees.yml

@@ -0,0 +1,4 @@
+awesome_tee:
+  id: 1
+sucky_tee:
+  id: 2