ptools 1.4.2 → 1.4.3

data/spec/binary_spec.rb

@@ -9,51 +9,51 @@ require 'rspec'
 require 'ptools'
 
 RSpec.describe File, :binary do
-  let(:dirname)  { File.dirname(__FILE__) }
-  let(:bin_file) { File::ALT_SEPARATOR ? File.join(ENV['windir'], 'notepad.exe') : '/bin/ls' }
+  let(:dirname)  { described_class.dirname(__FILE__) }
+  let(:bin_file) { File::ALT_SEPARATOR ? described_class.join(ENV['windir'], 'notepad.exe') : '/bin/ls' }
 
   before do
-    @txt_file = File.join(dirname, 'txt', 'english.txt')
-    @emp_file = File.join(dirname, 'txt', 'empty.txt')
-    @uni_file = File.join(dirname, 'txt', 'korean.txt')
-    @utf_file = File.join(dirname, 'txt', 'english.utf16')
-    @png_file = File.join(dirname, 'img', 'test.png')
-    @jpg_file = File.join(dirname, 'img', 'test.jpg')
-    @gif_file = File.join(dirname, 'img', 'test.gif')
+    @txt_file = described_class.join(dirname, 'txt', 'english.txt')
+    @emp_file = described_class.join(dirname, 'txt', 'empty.txt')
+    @uni_file = described_class.join(dirname, 'txt', 'korean.txt')
+    @utf_file = described_class.join(dirname, 'txt', 'english.utf16')
+    @png_file = described_class.join(dirname, 'img', 'test.png')
+    @jpg_file = described_class.join(dirname, 'img', 'test.jpg')
+    @gif_file = described_class.join(dirname, 'img', 'test.gif')
   end
 
-  example "File.binary? basic functionality" do
-    expect(File).to respond_to(:binary?)
-    expect{ File.binary?(@txt_file) }.not_to raise_error
+  example 'File.binary? basic functionality' do
+    expect(described_class).to respond_to(:binary?)
+    expect{ described_class.binary?(@txt_file) }.not_to raise_error
   end
 
-  example "File.binary? returns true for binary files" do
-    expect(File.binary?(bin_file)).to be true
+  example 'File.binary? returns true for binary files' do
+    expect(described_class.binary?(bin_file)).to be true
   end
 
-  example "File.binary? returns false for text files" do
-    expect(File.binary?(@emp_file)).to be false
-    expect(File.binary?(@txt_file)).to be false
-    expect(File.binary?(@uni_file)).to be false
-    expect(File.binary?(@utf_file)).to be false
+  example 'File.binary? returns false for text files' do
+    expect(described_class.binary?(@emp_file)).to be false
+    expect(described_class.binary?(@txt_file)).to be false
+    expect(described_class.binary?(@uni_file)).to be false
+    expect(described_class.binary?(@utf_file)).to be false
   end
 
-  example "File.binary? returns false for image files" do
-    expect(File.binary?(@png_file)).to be false
-    expect(File.binary?(@jpg_file)).to be false
-    expect(File.binary?(@gif_file)).to be false
+  example 'File.binary? returns false for image files' do
+    expect(described_class.binary?(@png_file)).to be false
+    expect(described_class.binary?(@jpg_file)).to be false
+    expect(described_class.binary?(@gif_file)).to be false
   end
 
-  example "File.binary? accepts an optional percentage argument" do
-    expect(File.binary?(@txt_file, 0.50)).to be false
-    expect(File.binary?(@txt_file, 0.05)).to be true
+  example 'File.binary? accepts an optional percentage argument' do
+    expect(described_class.binary?(@txt_file, 0.50)).to be false
+    expect(described_class.binary?(@txt_file, 0.05)).to be true
   end
 
-  example "File.binary? raises an error if the file cannot be found" do
-    expect{ File.binary?('bogus') }.to raise_error(SystemCallError)
+  example 'File.binary? raises an error if the file cannot be found' do
+    expect{ described_class.binary?('bogus') }.to raise_error(SystemCallError)
   end
 
-  example "File.binary? only accepts one argument" do
-    expect{ File.binary?(@txt_file, bin_file) }.to raise_error(ArgumentError)
+  example 'File.binary? only accepts one argument' do
+    expect{ described_class.binary?(@txt_file, bin_file) }.to raise_error(ArgumentError)
   end
 end

data/spec/constants_spec.rb

@@ -12,12 +12,12 @@ require 'ptools'
 RSpec.describe File, :constants do
   let(:windows) { File::ALT_SEPARATOR }
 
-  example "PTOOLS_VERSION constant is set to expected value" do
-    expect(File::PTOOLS_VERSION).to eq('1.4.2')
+  example 'PTOOLS_VERSION constant is set to expected value' do
+    expect(File::PTOOLS_VERSION).to eq('1.4.3')
     expect(File::PTOOLS_VERSION.frozen?).to be true
   end
 
-  example "IMAGE_EXT constant is set to array of values" do
+  example 'IMAGE_EXT constant is set to array of values' do
     expect(File::IMAGE_EXT).to match_array(%w[.bmp .gif .ico .jpeg .jpg .png])
   end
 end

data/spec/head_spec.rb

@@ -11,31 +11,31 @@ RSpec.describe File, :head do
   let(:test_file) { 'test_file_head.txt' }
 
   before do
-    File.open(test_file, 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
-    @expected_head1 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
-    @expected_head1.push("line6\n","line7\n","line8\n","line9\n","line10\n")
-    @expected_head2 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
+    described_class.open(test_file, 'w'){ |fh| 25.times{ |n| fh.puts "line#{n+1}" } }
+    @expected_head1 = %W[line1\n line2\n line3\n line4\n line5\n]
+    @expected_head1.push("line6\n", "line7\n", "line8\n", "line9\n", "line10\n")
+    @expected_head2 = %W[line1\n line2\n line3\n line4\n line5\n]
   end
 
-  example "head method basic functionality" do
-    expect(File).to respond_to(:head)
-    expect{ File.head(test_file) }.not_to raise_error
-    expect{ File.head(test_file, 5) }.not_to raise_error
-    expect{ File.head(test_file){} }.not_to raise_error
+  after do
+    described_class.delete(test_file) if described_class.exist?(test_file)
   end
 
-  example "head method returns the expected results" do
-    expect(File.head(test_file)).to be_kind_of(Array)
-    expect(File.head(test_file)).to eq(@expected_head1)
-    expect(File.head(test_file, 5)).to eq(@expected_head2)
+  example 'head method basic functionality' do
+    expect(described_class).to respond_to(:head)
+    expect{ described_class.head(test_file) }.not_to raise_error
+    expect{ described_class.head(test_file, 5) }.not_to raise_error
+    expect{ described_class.head(test_file){} }.not_to raise_error
   end
 
-  example "head method requires two arguments" do
-    expect{ File.head(test_file, 5, "foo") }.to raise_error(ArgumentError)
-    expect{ File.head("bogus") }.to raise_error(Errno::ENOENT)
+  example 'head method returns the expected results' do
+    expect(described_class.head(test_file)).to be_kind_of(Array)
+    expect(described_class.head(test_file)).to eq(@expected_head1)
+    expect(described_class.head(test_file, 5)).to eq(@expected_head2)
   end
 
-  after do
-    File.delete(test_file) if File.exists?(test_file)
+  example 'head method requires two arguments' do
+    expect{ described_class.head(test_file, 5, 'foo') }.to raise_error(ArgumentError)
+    expect{ described_class.head('bogus') }.to raise_error(Errno::ENOENT)
   end
 end

data/spec/image_spec.rb

@@ -1,51 +1,188 @@
 #####################################################################
 # image_spec.rb
 #
-# Specs for the File.image? method. You should run these specs via
-# the 'rake spec:image' task.
+# Specs for various image methods as well as the File.image? method
+# itself. You should run these specs via the 'rake spec:image' task.
 #####################################################################
 require 'rspec'
 require 'ptools'
 
 RSpec.describe File, :image do
   before do
-    Dir.chdir('spec') if File.exist?('spec')
-    @txt_file  = File.join(Dir.pwd, 'txt', 'english.txt')
-    @uni_file  = File.join(Dir.pwd, 'txt', 'korean.txt')
-    @jpg_file  = File.join(Dir.pwd, 'img', 'test.jpg')
-    @png_file  = File.join(Dir.pwd, 'img', 'test.png')
-    @gif_file  = File.join(Dir.pwd, 'img', 'test.gif')
-    @ico_file  = File.join(Dir.pwd, 'img', 'test.ico')
+    Dir.chdir('spec') if described_class.exist?('spec')
+    @txt_file  = described_class.join(Dir.pwd, 'txt', 'english.txt')
+    @uni_file  = described_class.join(Dir.pwd, 'txt', 'korean.txt')
+    @jpg_file  = described_class.join(Dir.pwd, 'img', 'test.jpg')
+    @png_file  = described_class.join(Dir.pwd, 'img', 'test.png')
+    @gif_file  = described_class.join(Dir.pwd, 'img', 'test.gif')
+    @tif_file  = described_class.join(Dir.pwd, 'img', 'test.tiff')
+    @ico_file  = described_class.join(Dir.pwd, 'img', 'test.ico')
+    @no_ext    = described_class.join(Dir.pwd, 'img', 'jpg_no_ext')
+    @bmp_file  = described_class.join(Dir.pwd, 'img', 'test.bmp')
   end
 
-  example "image? method basic functionality" do
-    expect(File).to respond_to(:image?)
-    expect{ File.image?(@txt_file) }.not_to raise_error
-    expect(File.image?(@txt_file)).to be(true).or be(false)
+  context 'bmp?' do
+    example 'bmp? method basic functionality' do
+      described_class.bmp?(@bmp_file)
+      expect(described_class).to respond_to(:bmp?)
+      expect{ described_class.bmp?(@bmp_file) }.not_to raise_error
+      expect(described_class.bmp?(@bmp_file)).to be(true).or be(false)
+    end
+
+    example 'bmp? method returns true for a bitmap file' do
+      expect(described_class.bmp?(@bmp_file)).to be(true)
+    end
+
+    example 'bmp? method returns false for an image that is not a bitmap' do
+      expect(described_class.bmp?(@gif_file)).to be(false)
+      expect(described_class.bmp?(@tif_file)).to be(false)
+    end
+
+    example 'bmp? method returns false for a text file' do
+      expect(described_class.bmp?(@txt_file)).to be(false)
+    end
   end
 
-  example "image? method returns false for a text file" do
-    expect(File.image?(@txt_file)).to be false
-    expect(File.image?(@uni_file)).to be false
+  context 'gif?' do
+    example 'gif? method basic functionality' do
+      expect(described_class).to respond_to(:gif?)
+      expect{ described_class.gif?(@gif_file) }.not_to raise_error
+      expect(described_class.gif?(@gif_file)).to be(true).or be(false)
+    end
+
+    example 'gif? method returns true for a gif file' do
+      expect(described_class.gif?(@gif_file)).to be(true)
+    end
+
+    example 'gif? method returns false for an image that is not a gif' do
+      expect(described_class.gif?(@jpg_file)).to be(false)
+    end
+
+    example 'gif? method returns false for a text file' do
+      expect(described_class.gif?(@txt_file)).to be(false)
+    end
   end
 
-  example "image? method returns true for a gif" do
-    expect(File.image?(@gif_file)).to be true
+  context 'ico?' do
+    example 'ico? method basic functionality' do
+      expect(described_class).to respond_to(:ico?)
+      expect{ described_class.ico?(@ico_file) }.not_to raise_error
+      expect(described_class.ico?(@ico_file)).to be(true).or be(false)
+    end
+
+    example 'ico? method returns true for an icon file' do
+      expect(described_class.ico?(@ico_file)).to be(true)
+    end
+
+    example 'ico? method returns false for an image that is not a icon file' do
+      expect(described_class.ico?(@gif_file)).to be(false)
+      expect(described_class.ico?(@png_file)).to be(false)
+    end
+
+    example 'ico? method returns false for a text file' do
+      expect(described_class.ico?(@txt_file)).to be(false)
+    end
   end
 
-  example "image? method returns true for a jpeg" do
-    expect(File.image?(@jpg_file)).to be true
+  context 'image?' do
+    example 'image? method basic functionality' do
+      expect(described_class).to respond_to(:image?)
+      expect{ described_class.image?(@txt_file) }.not_to raise_error
+      expect(described_class.image?(@txt_file)).to be(true).or be(false)
+    end
+
+    example 'image? method returns false for a text file' do
+      expect(described_class.image?(@txt_file)).to be false
+      expect(described_class.image?(@uni_file)).to be false
+    end
+
+    example 'image? method returns true for a gif' do
+      expect(described_class.image?(@gif_file)).to be true
+      expect(described_class.image?(@gif_file, check_file_extension: false)).to be true
+    end
+
+    example 'image? method returns true for a jpeg' do
+      expect(described_class.image?(@jpg_file)).to be true
+      expect(described_class.image?(@jpg_file, check_file_extension: false)).to be true
+    end
+
+    example 'image? method returns true for a png' do
+      expect(described_class.image?(@png_file)).to be true
+      expect(described_class.image?(@png_file, check_file_extension: false)).to be true
+    end
+
+    example 'image? method returns true for an ico' do
+      expect(described_class.image?(@ico_file)).to be true
+      expect(described_class.image?(@ico_file, check_file_extension: false)).to be true
+    end
+
+    example 'image? method raises an error if the file does not exist' do
+      expect{ described_class.image?('bogus') }.to raise_error(Exception) # Errno::ENOENT or ArgumentError
+    end
+
+    example "image? returns appropriate value if the extension isn't included" do
+      expect(described_class.image?(@no_ext, check_file_extension: true)).to be false
+      expect(described_class.image?(@no_ext, check_file_extension: false)).to be true
+    end
   end
 
-  example "image? method returns true for a png" do
-    expect(File.image?(@png_file)).to be true
+  context 'jpg?' do
+    example 'jpg? method basic functionality' do
+      expect(described_class).to respond_to(:jpg?)
+      expect{ described_class.jpg?(@jpg_file) }.not_to raise_error
+      expect(described_class.jpg?(@jpg_file)).to be(true).or be(false)
+    end
+
+    example 'jpg? method returns true for a jpeg file' do
+      expect(described_class.jpg?(@jpg_file)).to be(true)
+    end
+
+    example 'jpg? method returns false for an image that is not a jpeg' do
+      expect(described_class.jpg?(@gif_file)).to be(false)
+    end
+
+    example 'jpg? method returns false for a text file' do
+      expect(described_class.jpg?(@txt_file)).to be(false)
+    end
   end
 
-  example "image? method returns true for an ico" do
-    expect(File.image?(@ico_file)).to be true
+  context 'png?' do
+    example 'png? method basic functionality' do
+      expect(described_class).to respond_to(:png?)
+      expect{ described_class.png?(@png_file) }.not_to raise_error
+      expect(described_class.png?(@png_file)).to be(true).or be(false)
+    end
+
+    example 'png? method returns true for a png file' do
+      expect(described_class.png?(@png_file)).to be(true)
+    end
+
+    example 'png? method returns false for an image that is not a png' do
+      expect(described_class.png?(@gif_file)).to be(false)
+    end
+
+    example 'png? method returns false for a text file' do
+      expect(described_class.png?(@txt_file)).to be(false)
+    end
   end
 
-  example "image? method raises an error if the file does not exist" do
-    expect{ File.image?('bogus') }.to raise_error(Exception) # Errno::ENOENT or ArgumentError
+  context 'tiff?' do
+    example 'tiff? method basic functionality' do
+      expect(described_class).to respond_to(:tiff?)
+      expect{ described_class.tiff?(@tif_file) }.not_to raise_error
+      expect(described_class.tiff?(@tif_file)).to be(true).or be(false)
+    end
+
+    example 'tiff? method returns true for a tiff file' do
+      expect(described_class.tiff?(@tif_file)).to be(true)
+    end
+
+    example 'tiff? method returns false for an image that is not a tiff' do
+      expect(described_class.tiff?(@jpg_file)).to be(false)
+    end
+
+    example 'tiff? method returns false for a text file' do
+      expect(described_class.tiff?(@txt_file)).to be(false)
+    end
   end
 end

data/spec/nlconvert_spec.rb

@@ -10,95 +10,93 @@ require 'ptools'
 
 RSpec.describe File, :nlconvert do
   let(:windows)    { File::ALT_SEPARATOR }
-  let(:dirname)    { File.dirname(__FILE__) }
-  let(:test_file1) { File.join(dirname, 'test_nl_convert1.txt') }
-  let(:test_file2) { File.join(dirname, 'test_nl_convert2.txt') }
+  let(:dirname)    { described_class.dirname(__FILE__) }
+  let(:test_file1) { described_class.join(dirname, 'test_nl_convert1.txt') }
+  let(:test_file2) { described_class.join(dirname, 'test_nl_convert2.txt') }
 
   before do
-    File.open(test_file1, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
-    File.open(test_file2, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
-    @test_file1 = File.join(dirname, 'test_nl_convert1.txt')
-    @test_file2 = File.join(dirname, 'test_nl_convert2.txt')
-    @dos_file   = File.join(dirname, 'dos_test_file.txt')
-    @mac_file   = File.join(dirname, 'mac_test_file.txt')
+    described_class.open(test_file1, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+    described_class.open(test_file2, 'w'){ |fh| 10.times{ |n| fh.puts "line #{n}" } }
+    @test_file1 = described_class.join(dirname, 'test_nl_convert1.txt')
+    @test_file2 = described_class.join(dirname, 'test_nl_convert2.txt')
+    @dos_file   = described_class.join(dirname, 'dos_test_file.txt')
+    @mac_file   = described_class.join(dirname, 'mac_test_file.txt')
     @unix_file  = 'unix_test_file.txt'
   end
 
-  example "nl_for_platform basic functionality" do
-    expect(File).to respond_to(:nl_for_platform)
+  after do
+    [@dos_file, @mac_file, @unix_file].each{ |file| described_class.delete(file) if described_class.exist?(file) }
+    described_class.delete(test_file1) if described_class.exist?(test_file1)
+    described_class.delete(test_file2) if described_class.exist?(test_file2)
   end
 
-  example "nl_for_platform returns expected results" do
-    expect(File.nl_for_platform('dos') ).to eq( "\cM\cJ")
-    expect(File.nl_for_platform('unix') ).to eq( "\cJ")
-    expect(File.nl_for_platform('mac') ).to eq( "\cM")
+  example 'nl_for_platform basic functionality' do
+    expect(described_class).to respond_to(:nl_for_platform)
+  end
 
+  example 'nl_for_platform returns expected results' do
+    expect(described_class.nl_for_platform('dos')).to eq("\cM\cJ")
+    expect(described_class.nl_for_platform('unix')).to eq("\cJ")
+    expect(described_class.nl_for_platform('mac')).to eq("\cM")
   end
 
   example "nl_for_platform with 'local' platform does not raise an error" do
-    expect{ File.nl_for_platform('local') }.not_to raise_error
+    expect{ described_class.nl_for_platform('local') }.not_to raise_error
   end
 
-  example "nl_for_platform with unsupported platform raises an error" do
-    expect{ File.nl_for_platform('bogus') }.to raise_error(ArgumentError)
+  example 'nl_for_platform with unsupported platform raises an error' do
+    expect{ described_class.nl_for_platform('bogus') }.to raise_error(ArgumentError)
   end
 
-  example "nl_convert basic functionality" do
-    expect(File).to respond_to(:nl_convert)
+  example 'nl_convert basic functionality' do
+    expect(described_class).to respond_to(:nl_convert)
   end
 
-  example "nl_convert accepts one, two or three arguments" do
-    expect{ File.nl_convert(@test_file2) }.not_to raise_error
-    expect{ File.nl_convert(@test_file2, @test_file2) }.not_to raise_error
-    expect{ File.nl_convert(@test_file2, @test_file2, "unix") }.not_to raise_error
+  example 'nl_convert accepts one, two or three arguments' do
+    expect{ described_class.nl_convert(@test_file2) }.not_to raise_error
+    expect{ described_class.nl_convert(@test_file2, @test_file2) }.not_to raise_error
+    expect{ described_class.nl_convert(@test_file2, @test_file2, 'unix') }.not_to raise_error
   end
 
-  example "nl_convert with dos platform argument works as expected" do
-    expect{ File.nl_convert(@test_file1, @dos_file, "dos") }.not_to raise_error
-    expect{ File.nl_convert(@test_file1, @dos_file, "dos") }.not_to raise_error
-    expect(File.size(@dos_file)).to be > File.size(@test_file1)
-    expect(IO.readlines(@dos_file).first.split("")[-2..-1]).to eq(["\cM","\cJ"])
+  example 'nl_convert with dos platform argument works as expected' do
+    expect{ described_class.nl_convert(@test_file1, @dos_file, 'dos') }.not_to raise_error
+    expect{ described_class.nl_convert(@test_file1, @dos_file, 'dos') }.not_to raise_error
+    expect(described_class.size(@dos_file)).to be > described_class.size(@test_file1)
+    expect(described_class.readlines(@dos_file)).to all(end_with("\cM\cJ"))
   end
 
-  example "nl_convert with mac platform argument works as expected" do
-    expect{ File.nl_convert(@test_file1, @mac_file, 'mac') }.not_to raise_error
-    expect(IO.readlines(@mac_file).first.split("").last).to eq("\cM")
+  example 'nl_convert with mac platform argument works as expected' do
+    expect{ described_class.nl_convert(@test_file1, @mac_file, 'mac') }.not_to raise_error
+    expect(described_class.readlines(@mac_file)).to all(end_with("\cM"))
 
     skip if windows
-    expect(File.size(@mac_file)).to eq(File.size(@test_file1))
+    expect(described_class.size(@mac_file)).to eq(described_class.size(@test_file1))
   end
 
-  example "nl_convert with unix platform argument works as expected" do
-    expect{ File.nl_convert(@test_file1, @unix_file, "unix") }.not_to raise_error
-    expect(IO.readlines(@unix_file).first.split("").last).to eq("\n")
+  example 'nl_convert with unix platform argument works as expected' do
+    expect{ described_class.nl_convert(@test_file1, @unix_file, 'unix') }.not_to raise_error
+    expect(described_class.readlines(@unix_file)).to all(end_with("\n"))
 
     if windows
-      expect(File.size(@unix_file) >= File.size(@test_file1)).to be true
+      expect(described_class.size(@unix_file) >= described_class.size(@test_file1)).to be true
     else
-      expect(File.size(@unix_file) <= File.size(@test_file1)).to be true
+      expect(described_class.size(@unix_file) <= described_class.size(@test_file1)).to be true
     end
   end
 
-  example "nl_convert requires at least one argument" do
-    expect{ File.nl_convert }.to raise_error(ArgumentError)
+  example 'nl_convert requires at least one argument' do
+    expect{ described_class.nl_convert }.to raise_error(ArgumentError)
   end
 
-  example "nl_convert requires a valid platform string" do
-    expect{ File.nl_convert(@test_file1, "bogus.txt", "blah") }.to raise_error(ArgumentError)
+  example 'nl_convert requires a valid platform string' do
+    expect{ described_class.nl_convert(@test_file1, 'bogus.txt', 'blah') }.to raise_error(ArgumentError)
   end
 
-  example "nl_convert accepts a maximum of three arguments" do
-    expect{ File.nl_convert(@example_file1, @test_file2, 'dos', 1) }.to raise_error(ArgumentError)
-    expect{ File.nl_convert(@test_file1, @test_file2, 'dos', 1) }.to raise_error(ArgumentError)
+  example 'nl_convert accepts a maximum of three arguments' do
+    expect{ described_class.nl_convert(@test_file1, @test_file2, 'dos', 1) }.to raise_error(ArgumentError)
   end
 
-  example "nl_convert will fail on anything but plain files" do
-    expect{ File.nl_convert(IO::NULL, @test_file1) }.to raise_error(ArgumentError)
-  end
-
-  after do
-    [@dos_file, @mac_file, @unix_file].each{ |file| File.delete(file) if File.exist?(file) }
-    File.delete(test_file1) if File.exist?(test_file1)
-    File.delete(test_file2) if File.exist?(test_file2)
+  example 'nl_convert will fail on anything but plain files' do
+    expect{ described_class.nl_convert(IO::NULL, @test_file1) }.to raise_error(ArgumentError)
   end
 end

data/spec/sparse_spec.rb

@@ -1,43 +1,39 @@
 #####################################################################
-# test_is_sparse.rb
+# sparse_spec.rb
 #
 # Test case for the File.sparse? method. You should run this test
 # via the 'rake test:is_sparse' task.
 #####################################################################
-require 'rspec'
-require 'ptools'
+require 'spec_helper'
 
 RSpec.describe File, :sparse do
   let(:windows) { File::ALT_SEPARATOR }
-  let(:osx) { RbConfig::CONFIG['host_os'] =~ /darwin|osx/i }
-  let(:non_sparse_file) { File.expand_path(File.basename(__FILE__)) }
+  let(:non_sparse_file) { described_class.expand_path(described_class.basename(__FILE__)) }
   let(:sparse_file) { 'test_sparse_file' }
 
   before do
-    Dir.chdir("spec") if File.exist?("spec")
+    Dir.chdir('spec') if described_class.exist?('spec')
     system("dd of=#{sparse_file} bs=1k seek=5120 count=0 2>/dev/null") unless windows
   end
 
-  example "is_sparse basic functionality" do
-    skip "skipped on MS Windows or OSX" if windows || osx
-    expect(File).to respond_to(:sparse?)
-    expect{ File.sparse?(sparse_file) }.not_to raise_error
-    expect(File.sparse?(sparse_file)).to be(true).or be(false)
+  after do
+    Dir.chdir('spec') if described_class.exist?('spec')
+    described_class.delete(sparse_file) if described_class.exist?(sparse_file)
   end
 
-  example "is_sparse returns the expected results" do
-    skip "skipped on MS Windows or OSX" if windows || osx
-    expect(File.sparse?(sparse_file)).to be true
-    expect(File.sparse?(non_sparse_file)).to be false
+  example 'is_sparse basic functionality', :unix_only => true do
+    expect(described_class).to respond_to(:sparse?)
+    expect{ described_class.sparse?(sparse_file) }.not_to raise_error
+    expect(described_class.sparse?(sparse_file)).to be(true).or be(false)
   end
 
-  example "is_sparse only accepts one argument" do
-    skip if windows
-    expect{ File.sparse?(sparse_file, sparse_file) }.to raise_error(ArgumentError)
+  example 'is_sparse returns the expected results', :unix_only => true do
+    expect(described_class.sparse?(sparse_file)).to be true
+    expect(described_class.sparse?(non_sparse_file)).to be false
   end
 
-  after do
-    Dir.chdir("spec") if File.exist?("spec")
-    File.delete(sparse_file) if File.exist?(sparse_file)
+  example 'is_sparse only accepts one argument' do
+    skip if windows
+    expect{ described_class.sparse?(sparse_file, sparse_file) }.to raise_error(ArgumentError)
   end
 end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'ptools'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.filter_run_excluding(:windows_only) unless Gem.win_platform?
+  config.filter_run_excluding(:unix_only) if Gem.win_platform?
+end