Fixed use of guards in the specs.

See http://rubyspec.org/wiki/rubyspec/Guards for the correct use
of all the guards. In particular, note that the compliant_on/
not_compliant_on guarded specs will always run on MRI. The
deviates_on, extended_on, and not_supported_on never run on MRI.
These latter three guards will now raise an exception if passed
:ruby. Also, platforms like :windows are not proper for any of
these implementation compliance guards.

Use ruby_version_is or ruby_bug guards for version-specific specs
or specs that expose bugs in MRI.

core/argf/read_spec.rb

@@ -96,7 +96,7 @@
     end
   end
 
-  not_supported_on :windows do
+  platform_is_not :windows do
     it "reads the contents of a special device file" do
       argv ['/dev/zero'] do
         ARGF.read(100).should == "\000" * 100

core/array/append_spec.rb

@@ -28,17 +28,16 @@
     a << :foo
     a.should == [:foo]
   end
-
-  compliant_on :ruby, :jruby, :ir do
-    ruby_version_is '' ... '1.9' do
-      it "raises a TypeError on a frozen array" do
-        lambda { ArraySpecs.frozen_array << 5 }.should raise_error(TypeError)
-      end
+
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array << 5 }.should raise_error(TypeError)
     end
-    ruby_version_is '1.9' do
-      it "raises a RuntimeError on a frozen array" do
-        lambda { ArraySpecs.frozen_array << 5 }.should raise_error(RuntimeError)
-      end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array << 5 }.should raise_error(RuntimeError)
     end
   end
 end

core/array/clear_spec.rb

@@ -6,7 +6,7 @@
     a = [1, 2, 3, 4]
     a.clear.should equal(a)
     a.should == []
-  end  
+  end
 
   it "returns self" do
     a = [1]
@@ -39,20 +39,19 @@
     end
   end
 
-  compliant_on :ruby, :jruby, :ir do
-    ruby_version_is '' ... '1.9' do
-      it "raises a TypeError on a frozen array" do
-        a = [1]
-        a.freeze
-        lambda { a.clear }.should raise_error(TypeError)
-      end
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen array" do
+      a = [1]
+      a.freeze
+      lambda { a.clear }.should raise_error(TypeError)
     end
-    ruby_version_is '1.9' do
-      it "raises a RuntimeError on a frozen array" do
-        a = [1]
-        a.freeze
-        lambda { a.clear }.should raise_error(RuntimeError)
-      end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen array" do
+      a = [1]
+      a.freeze
+      lambda { a.clear }.should raise_error(RuntimeError)
     end
   end
 end

core/array/clone_spec.rb

@@ -5,17 +5,15 @@
 describe "Array#clone" do
   it_behaves_like :array_clone, :clone
 
-  not_compliant_on :rubinius do
-    it "copies frozen status from the original" do
-      a = [1, 2, 3, 4]
-      b = [1, 2, 3, 4]
-      a.freeze
-      aa = a.clone
-      bb = b.clone
+  it "copies frozen status from the original" do
+    a = [1, 2, 3, 4]
+    b = [1, 2, 3, 4]
+    a.freeze
+    aa = a.clone
+    bb = b.clone
 
-      aa.frozen?.should == true
-      bb.frozen?.should == false
-    end
+    aa.frozen?.should == true
+    bb.frozen?.should == false
   end
 
   it "copies singleton methods" do

core/array/compact_spec.rb

@@ -49,12 +49,12 @@
     a.compact!.should equal(a)
     a.should == ["a", "b", false, "c"]
   end
-  
+
   it "returns self if some nil elements are removed" do
     a = ['a', nil, 'b', false, 'c']
     a.compact!.object_id.should == a.object_id
   end
-  
+
   it "returns nil if there are no nil elements to remove" do
     [1, 2, false, 3].compact!.should == nil
   end
@@ -75,16 +75,15 @@
     end
   end
 
-  compliant_on :ruby, :jruby, :ir do
-    ruby_version_is '' ... '1.9' do
-      it "raises a TypeError on a frozen array" do
-        lambda { ArraySpecs.frozen_array.compact! }.should raise_error(TypeError)
-      end
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.compact! }.should raise_error(TypeError)
     end
-    ruby_version_is '1.9' do
-      it "raises a RuntimeError on a frozen array" do
-        lambda { ArraySpecs.frozen_array.compact! }.should raise_error(RuntimeError)
-      end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.compact! }.should raise_error(RuntimeError)
     end
   end
 end

core/array/concat_spec.rb

@@ -14,11 +14,11 @@
     ary.concat([])
     ary.should == [1, 2, 3, 9, 10, 11]
   end
-  
+
   it "does not loop endlessly when argument is self" do
     ary = ["x", "y"]
     ary.concat(ary).should == ["x", "y", "x", "y"]
-  end  
+  end
 
   it "tries to convert the passed argument to an Array using #to_ary" do
     obj = mock('to_ary')
@@ -31,24 +31,23 @@
     obj.should_not_receive(:to_ary)
     [].concat(obj).should == [5, 6, 7]
   end
-
-  compliant_on :ruby, :jruby, :ir do
-    ruby_version_is '' ... '1.9' do
-      it "raises a TypeError when Array is frozen and modification occurs" do
-        lambda { ArraySpecs.frozen_array.concat [1] }.should raise_error(TypeError)
-      end
-    end
-    ruby_version_is '1.9' do
-      it "raises a RuntimeError when Array is frozen and modification occurs" do
-        lambda { ArraySpecs.frozen_array.concat [1] }.should raise_error(RuntimeError)
-      end
+
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError when Array is frozen and modification occurs" do
+      lambda { ArraySpecs.frozen_array.concat [1] }.should raise_error(TypeError)
     end
+  end
 
-    it "does not raise a TypeError when Array is frozen but no modification occurs" do
-      ArraySpecs.frozen_array.concat([]).should == [1, 2, 3]
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError when Array is frozen and modification occurs" do
+      lambda { ArraySpecs.frozen_array.concat [1] }.should raise_error(RuntimeError)
     end
   end
 
+  it "does not raise a TypeError when Array is frozen but no modification occurs" do
+    ArraySpecs.frozen_array.concat([]).should == [1, 2, 3]
+  end
+
   it "keeps tainted status" do
     ary = [1, 2]
     ary.taint

core/array/delete_at_spec.rb

@@ -15,7 +15,7 @@
     a.delete_at(2).should == 3
     a.delete_at(-1).should == 4
   end
-  
+
   it "returns nil and makes no modification if the index is out of range" do
     a = [1, 2]
     a.delete_at(3).should == nil
@@ -35,16 +35,15 @@
     a.delete_at(-2).should == 1
   end
 
-  compliant_on :ruby, :jruby,:ir do
-    ruby_version_is '' ... '1.9' do
-      it "raises a TypeError on a frozen array" do
-        lambda { [1,2,3].freeze.delete_at(0) }.should raise_error(TypeError)
-      end
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen array" do
+      lambda { [1,2,3].freeze.delete_at(0) }.should raise_error(TypeError)
     end
-    ruby_version_is '1.9' do
-      it "raises a RuntimeError on a frozen array" do
-        lambda { [1,2,3].freeze.delete_at(0) }.should raise_error(RuntimeError)
-      end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { [1,2,3].freeze.delete_at(0) }.should raise_error(RuntimeError)
     end
   end
 

core/array/delete_if_spec.rb

@@ -21,6 +21,7 @@
       lambda { @a.delete_if }.should raise_error(LocalJumpError)
     end
   end
+
   ruby_version_is "1.8.7" ... "1.9" do
     it "returns an Enumerable::Enumerator if no block given, and the enumerator can modify the original array" do
       enum = @a.delete_if
@@ -30,6 +31,7 @@
       @a.should be_empty
     end
   end
+
   ruby_version_is '1.9' do
     it "returns an Enumerator if no block given, and the enumerator can modify the original array" do
       enum = @a.delete_if
@@ -40,16 +42,15 @@
     end
   end
 
-  compliant_on :ruby, :jruby, :ir do
-    ruby_version_is '' ... '1.9' do
-      it "raises a TypeError on a frozen array" do
-        lambda { ArraySpecs.frozen_array.delete_if {} }.should raise_error(TypeError)
-      end
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.delete_if {} }.should raise_error(TypeError)
     end
-    ruby_version_is '1.9' do
-      it "raises a RuntimeError on a frozen array" do
-        lambda { ArraySpecs.frozen_array.delete_if {} }.should raise_error(RuntimeError)
-      end
+  end
+
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen array" do
+      lambda { ArraySpecs.frozen_array.delete_if {} }.should raise_error(RuntimeError)
     end
   end
 

core/array/delete_spec.rb

@@ -19,7 +19,7 @@ def x.==(other) 3 == other end
     a.delete "foo"
     a.should == ["bar","quux"]
   end
-  
+
   it "returns object or nil if no elements match object" do
     [1, 2, 4, 5].delete(1).should == 1
     [1, 2, 4, 5].delete(3).should == nil
@@ -29,24 +29,23 @@ def x.==(other) 3 == other end
     [1].delete(1) {:not_found}.should == 1
     [].delete('a') {:not_found}.should == :not_found
   end
-
-  compliant_on :ruby, :jruby, :ir do
-    ruby_version_is '' ... '1.9' do
-      it "raises a TypeError on a frozen array if a modification would take place" do
-        lambda { [1, 2, 3].freeze.delete(1) }.should raise_error(TypeError)
-      end
-    end
-    ruby_version_is '1.9' do
-      it "raises a RuntimeError on a frozen array if a modification would take place" do
-        lambda { [1, 2, 3].freeze.delete(1) }.should raise_error(RuntimeError)
-      end
+
+  ruby_version_is '' ... '1.9' do
+    it "raises a TypeError on a frozen array if a modification would take place" do
+      lambda { [1, 2, 3].freeze.delete(1) }.should raise_error(TypeError)
     end
+  end
 
-    it "returns false on a frozen array if a modification does not take place" do
-      [1, 2, 3].freeze.delete(0).should == nil
+  ruby_version_is '1.9' do
+    it "raises a RuntimeError on a frozen array if a modification would take place" do
+      lambda { [1, 2, 3].freeze.delete(1) }.should raise_error(RuntimeError)
     end
   end
 
+  it "returns false on a frozen array if a modification does not take place" do
+    [1, 2, 3].freeze.delete(0).should == nil
+  end
+
   it "keeps tainted status" do
     a = [1, 2]
     a.taint