Guard ruby/spec with spec/mspec/tool/wrap_with_guard.rb

Merged: https://github.com/ruby/ruby/pull/4530

spec/ruby/library/matrix/eigenvalue_decomposition/eigenvalue_matrix_spec.rb

@@ -1,9 +1,12 @@
 require_relative '../../../spec_helper'
-require 'matrix'
 
-describe "Matrix::EigenvalueDecomposition#eigenvalue_matrix" do
-  it "returns a diagonal matrix with the eigenvalues on the diagonal" do
-    Matrix[[14, 16], [-6, -6]].eigensystem.eigenvalue_matrix.should == Matrix[[6, 0],[0, 2]]
-    Matrix[[1, 1], [-1, 1]].eigensystem.eigenvalue_matrix.should == Matrix[[Complex(1,1), 0],[0, Complex(1,-1)]]
+ruby_version_is ""..."3.1" do
+  require 'matrix'
+
+  describe "Matrix::EigenvalueDecomposition#eigenvalue_matrix" do
+    it "returns a diagonal matrix with the eigenvalues on the diagonal" do
+      Matrix[[14, 16], [-6, -6]].eigensystem.eigenvalue_matrix.should == Matrix[[6, 0],[0, 2]]
+      Matrix[[1, 1], [-1, 1]].eigensystem.eigenvalue_matrix.should == Matrix[[Complex(1,1), 0],[0, Complex(1,-1)]]
+    end
   end
 end

spec/ruby/library/matrix/eigenvalue_decomposition/eigenvalues_spec.rb

@@ -1,22 +1,25 @@
 require_relative '../../../spec_helper'
-require 'matrix'
 
-describe "Matrix::EigenvalueDecomposition#eigenvalues" do
-  it "returns an array of complex eigenvalues for a rotation matrix" do
-    Matrix[[ 1, 1],
-           [-1, 1]].eigensystem.eigenvalues.sort_by{|v| v.imag}.should ==
-    [ Complex(1, -1), Complex(1, 1)]
-  end
+ruby_version_is ""..."3.1" do
+  require 'matrix'
 
-  it "returns an array of real eigenvalues for a symmetric matrix" do
-    Matrix[[1, 2],
-           [2, 1]].eigensystem.eigenvalues.sort.map!{|x| x.round(10)}.should ==
-    [ -1, 3 ]
-  end
+  describe "Matrix::EigenvalueDecomposition#eigenvalues" do
+    it "returns an array of complex eigenvalues for a rotation matrix" do
+      Matrix[[ 1, 1],
+             [-1, 1]].eigensystem.eigenvalues.sort_by{|v| v.imag}.should ==
+      [ Complex(1, -1), Complex(1, 1)]
+    end
 
-  it "returns an array of real eigenvalues for a matrix" do
-    Matrix[[14, 16],
-           [-6, -6]].eigensystem.eigenvalues.sort.map!{|x| x.round(10)}.should ==
-    [ 2, 6 ]
+    it "returns an array of real eigenvalues for a symmetric matrix" do
+      Matrix[[1, 2],
+             [2, 1]].eigensystem.eigenvalues.sort.map!{|x| x.round(10)}.should ==
+      [ -1, 3 ]
+    end
+
+    it "returns an array of real eigenvalues for a matrix" do
+      Matrix[[14, 16],
+             [-6, -6]].eigensystem.eigenvalues.sort.map!{|x| x.round(10)}.should ==
+      [ 2, 6 ]
+    end
   end
 end

spec/ruby/library/matrix/eigenvalue_decomposition/eigenvector_matrix_spec.rb

@@ -1,20 +1,23 @@
 require_relative '../../../spec_helper'
-require 'matrix'
 
-describe "Matrix::EigenvalueDecomposition#eigenvector_matrix" do
-  it "returns a complex eigenvector matrix given a rotation matrix" do
-    # Fix me: should test for linearity, not for equality
-    Matrix[[ 1, 1],
-           [-1, 1]].eigensystem.eigenvector_matrix.should ==
-    Matrix[[1, 1],
-           [Complex(0, 1), Complex(0, -1)]]
-  end
+ruby_version_is ""..."3.1" do
+  require 'matrix'
 
-  it "returns an real eigenvector matrix for a symmetric matrix" do
-    # Fix me: should test for linearity, not for equality
-    Matrix[[1, 2],
-           [2, 1]].eigensystem.eigenvector_matrix.should ==
-    Matrix[[0.7071067811865475, 0.7071067811865475],
-           [-0.7071067811865475, 0.7071067811865475]]
+  describe "Matrix::EigenvalueDecomposition#eigenvector_matrix" do
+    it "returns a complex eigenvector matrix given a rotation matrix" do
+      # Fix me: should test for linearity, not for equality
+      Matrix[[ 1, 1],
+             [-1, 1]].eigensystem.eigenvector_matrix.should ==
+      Matrix[[1, 1],
+             [Complex(0, 1), Complex(0, -1)]]
+    end
+
+    it "returns an real eigenvector matrix for a symmetric matrix" do
+      # Fix me: should test for linearity, not for equality
+      Matrix[[1, 2],
+             [2, 1]].eigensystem.eigenvector_matrix.should ==
+      Matrix[[0.7071067811865475, 0.7071067811865475],
+             [-0.7071067811865475, 0.7071067811865475]]
+    end
   end
 end

spec/ruby/library/matrix/eigenvalue_decomposition/eigenvectors_spec.rb

@@ -1,22 +1,25 @@
 require_relative '../../../spec_helper'
-require 'matrix'
 
-describe "Matrix::EigenvalueDecomposition#eigenvectors" do
-  it "returns an array of complex eigenvectors for a rotation matrix" do
-    # Fix me: should test for linearity, not for equality
-    Matrix[[ 1, 1],
-           [-1, 1]].eigensystem.eigenvectors.should ==
-    [ Vector[1, Complex(0, 1)],
-      Vector[1, Complex(0, -1)]
-    ]
-  end
+ruby_version_is ""..."3.1" do
+  require 'matrix'
 
-  it "returns an array of real eigenvectors for a symmetric matrix" do
-    # Fix me: should test for linearity, not for equality
-    Matrix[[1, 2],
-           [2, 1]].eigensystem.eigenvectors.should ==
-    [ Vector[0.7071067811865475, -0.7071067811865475],
-      Vector[0.7071067811865475, 0.7071067811865475]
-    ]
+  describe "Matrix::EigenvalueDecomposition#eigenvectors" do
+    it "returns an array of complex eigenvectors for a rotation matrix" do
+      # Fix me: should test for linearity, not for equality
+      Matrix[[ 1, 1],
+             [-1, 1]].eigensystem.eigenvectors.should ==
+      [ Vector[1, Complex(0, 1)],
+        Vector[1, Complex(0, -1)]
+      ]
+    end
+
+    it "returns an array of real eigenvectors for a symmetric matrix" do
+      # Fix me: should test for linearity, not for equality
+      Matrix[[1, 2],
+             [2, 1]].eigensystem.eigenvectors.should ==
+      [ Vector[0.7071067811865475, -0.7071067811865475],
+        Vector[0.7071067811865475, 0.7071067811865475]
+      ]
+    end
   end
 end

spec/ruby/library/matrix/eigenvalue_decomposition/initialize_spec.rb

@@ -1,24 +1,27 @@
 require_relative '../../../spec_helper'
-require 'matrix'
 
-describe "Matrix::EigenvalueDecomposition#initialize" do
-  it "raises an error if argument is not a matrix" do
-    -> {
-      Matrix::EigenvalueDecomposition.new([[]])
-    }.should raise_error(TypeError)
-    -> {
-      Matrix::EigenvalueDecomposition.new(42)
-    }.should raise_error(TypeError)
-  end
+ruby_version_is ""..."3.1" do
+  require 'matrix'
 
-  it "raises an error if matrix is not square" do
-    -> {
-      Matrix::EigenvalueDecomposition.new(Matrix[[1, 2]])
-    }.should raise_error(Matrix::ErrDimensionMismatch)
-  end
+  describe "Matrix::EigenvalueDecomposition#initialize" do
+    it "raises an error if argument is not a matrix" do
+      -> {
+        Matrix::EigenvalueDecomposition.new([[]])
+      }.should raise_error(TypeError)
+      -> {
+        Matrix::EigenvalueDecomposition.new(42)
+      }.should raise_error(TypeError)
+    end
 
-  it "never hangs" do
-    m = Matrix[ [0,0,0,0,0], [0,0,0,0,1], [0,0,0,1,0], [1,1,0,0,1], [1,0,1,0,1] ]
-    Matrix::EigenvalueDecomposition.new(m).should_not == "infinite loop"
+    it "raises an error if matrix is not square" do
+      -> {
+        Matrix::EigenvalueDecomposition.new(Matrix[[1, 2]])
+      }.should raise_error(Matrix::ErrDimensionMismatch)
+    end
+
+    it "never hangs" do
+      m = Matrix[ [0,0,0,0,0], [0,0,0,0,1], [0,0,0,1,0], [1,1,0,0,1], [1,0,1,0,1] ]
+      Matrix::EigenvalueDecomposition.new(m).should_not == "infinite loop"
+    end
   end
 end

spec/ruby/library/matrix/eigenvalue_decomposition/to_a_spec.rb

@@ -1,18 +1,21 @@
 require_relative '../../../spec_helper'
-require 'matrix'
 
-describe "Matrix::EigenvalueDecomposition#to_a" do
-  before :each do
-    @a = Matrix[[14, 16], [-6, -6]]
-    @e = Matrix::EigenvalueDecomposition.new(@a)
-  end
+ruby_version_is ""..."3.1" do
+  require 'matrix'
 
-  it "returns an array of with [V, D, V.inv]" do
-    @e.to_a.should == [@e.v, @e.d, @e.v_inv]
-  end
+  describe "Matrix::EigenvalueDecomposition#to_a" do
+    before :each do
+      @a = Matrix[[14, 16], [-6, -6]]
+      @e = Matrix::EigenvalueDecomposition.new(@a)
+    end
 
-  it "returns a factorization" do
-    v, d, v_inv = @e.to_a
-    (v * d * v_inv).map{|e| e.round(10)}.should == @a
+    it "returns an array of with [V, D, V.inv]" do
+      @e.to_a.should == [@e.v, @e.d, @e.v_inv]
+    end
+
+    it "returns a factorization" do
+      v, d, v_inv = @e.to_a
+      (v * d * v_inv).map{|e| e.round(10)}.should == @a
+    end
   end
 end