filepath 0.4 → 0.5

data/lib/filepath/filepathlist.rb

@@ -43,24 +43,6 @@ class FilePathList
 		return FilePathList.new(remaining_entries)
 	end
 
-	def exclude(pattern = nil, &block)
-		if block_given?
-			select { |e| !block.call(e) }
-		else
-			select { |e| !(e =~ pattern) }
-		end
-	end
-
-	def select(pattern = nil, &block)
-		if !block_given?
-			block = proc { |e| e =~ pattern }
-		end
-
-		remaining_entries = @entries.select { |e| block.call(e) }
-
-		return FilePathList.new(remaining_entries)
-	end
-
 	def <<(extra_path)
 		return FilePathList.new(@entries + [extra_path.as_path])
 	end
@@ -137,10 +119,40 @@ class FilePathList
 
 		define_array_method :each
 
-		define_array_method :map
+		define_array_method :all?
+
+		define_array_method :any?
+
+		define_array_method :none?
 
 		define_array_method :size
 	end
 
+	module EntriesMethods
+		def map(&block)
+			mapped_entries = @entries.map(&block)
+			return FilePathList.new(mapped_entries)
+		end
+
+		def select(pattern = nil, &block)
+			if !block_given?
+				block = proc { |e| e =~ pattern }
+			end
+
+			remaining_entries = @entries.select { |e| block.call(e) }
+
+			return FilePathList.new(remaining_entries)
+		end
+
+		def exclude(pattern = nil, &block)
+			if block_given?
+				select { |e| !block.call(e) }
+			else
+				select { |e| !(e =~ pattern) }
+			end
+		end
+	end
+
 	include ArrayMethods
+	include EntriesMethods
 end

data/spec/filepath_spec.rb

@@ -27,15 +27,15 @@ describe FilePath do
 		]
 		test_data.each do |base, extra, result|
 			it "concatenates `#{base}` and `#{extra}` (as String) into `#{result}`" do
-				p = FilePath.new(base) / extra
-				p.should == result
+				ph = FilePath.new(base) / extra
+				ph.should == result
 			end
 		end
 
 		test_data.each do |base, extra, result|
 			it "concatenates `#{base}` and `#{extra}` (as FilePath) into `#{result}`" do
-				p = FilePath.new(base) / FilePath.new(extra)
-				p.should == result
+				ph = FilePath.new(base) / FilePath.new(extra)
+				ph.should == result
 			end
 		end
 	end
@@ -69,13 +69,14 @@ describe FilePath do
 			['/foo/bar', 'bar'],
 			['foo', 'foo'],
 			['/', ''],
+			['a/b/../../', ''],
 			['/foo/bar/.', 'bar'],
 			['a/b/../c', 'c'],
 		]
 		test_data.each do |path, result|
 			it "says that `#{result}` is the filename of `#{path}`" do
-				p = FilePath.new(path)
-				p.filename.should == result
+				ph = FilePath.new(path)
+				ph.filename.should == result
 			end
 		end
 	end
@@ -90,8 +91,8 @@ describe FilePath do
 		]
 		test_data.each do |path, result|
 			it "says that `#{result}` is the parent dir of `#{path}`" do
-				p = FilePath.new(path)
-				p.parent_dir.should == result
+				ph = FilePath.new(path)
+				ph.parent_dir.should == result
 			end
 		end
 	end
@@ -108,8 +109,8 @@ describe FilePath do
 		]
 		test_data.each do |path, base, result|
 			it "says that `#{path}` relative to `#{base}` is `#{result}`" do
-				p = FilePath.new(path)
-				p.relative_to(base).should == result
+				ph = FilePath.new(path)
+				ph.relative_to(base).should == result
 			end
 		end
 
@@ -121,8 +122,8 @@ describe FilePath do
 		]
 		test_data2.each do |path, base|
 			it "raise an exception because `#{path}` and `#{base}` have different prefixes" do
-				p = FilePath.new(path)
-				expect { p.relative_to(base) }.to raise_error(ArgumentError)
+				ph = FilePath.new(path)
+				expect { ph.relative_to(base) }.to raise_error(ArgumentError)
 			end
 		end
 	end
@@ -137,13 +138,13 @@ describe FilePath do
 		]
 		test_data.each do |path, base, result|
 			it "says that `#{path}` relative to the file `#{base}` is `#{result}`" do
-				p = FilePath.new(path)
-				p.relative_to_file(base).should == result
+				ph = FilePath.new(path)
+				ph.relative_to_file(base).should == result
 			end
 		end
 	end
 
-	describe "#replace_filename" do
+	describe "#with_filename" do
 		test_data = [
 			['foo/bar', 'quux', 'foo/quux'],
 			['foo/baz/..', 'quux', 'quux'],
@@ -151,8 +152,8 @@ describe FilePath do
 		]
 		test_data.each do |base, new, result|
 			it "changes `#{base}` + `#{new}` into `#{result}`" do
-				p = FilePath.new(base)
-				p.replace_filename(new).should == result
+				ph = FilePath.new(base)
+				ph.with_filename(new).should == result
 			end
 		end
 	end
@@ -214,7 +215,7 @@ describe FilePath do
 		end
 	end
 
-	describe "#replace_extension(String)" do
+	describe "#with_extension(String)" do
 		test_data = [
 			['foo.bar', 'foo.baz'],
 			['foo.', 'foo.baz'],
@@ -224,13 +225,13 @@ describe FilePath do
 		]
 		test_data.each do |path, result|
 			it "replaces `#{path}` with `baz` into `#{result}`" do
-				new = FilePath.new(path).replace_extension('baz')
+				new = FilePath.new(path).with_extension('baz')
 				new.basename.to_s.should == result
 			end
 		end
 	end
 
-	describe "#remove_extension" do
+	describe "#without_extension" do
 		test_data = [
 			['foo.bar', 'foo'],
 			['foo.', 'foo'],
@@ -240,7 +241,7 @@ describe FilePath do
 		]
 		test_data.each do |path, result|
 			it "turns `#{path}` into `#{result}`" do
-				new = FilePath.new(path).remove_extension
+				new = FilePath.new(path).without_extension
 				new.basename.to_s.should == result
 			end
 		end
@@ -304,6 +305,7 @@ describe FilePath do
 			['/', '/'],
 			['/..', '/'],
 			['/../../../a', '/a'],
+			['a/b/../..', '.'],
 		]
 		test_data.each do |path, result|
 			it "turns `#{path}` into `#{result}`" do
@@ -312,11 +314,43 @@ describe FilePath do
 		end
 	end
 
+	describe "#each_segment" do
+		it "goes through all the segments of an absolute path" do
+			steps = []
+			FilePath.new("/a/b/c").each_segment do |seg|
+				steps << seg
+			end
+
+			steps.should have(4).items
+			steps[0].should eq("/")
+			steps[1].should eq("a")
+			steps[2].should eq("b")
+			steps[3].should eq("c")
+		end
+
+		it "goes through all the segments of a relative path" do
+			steps = []
+			FilePath.new("a/b/c").each_segment do |seg|
+				steps << seg
+			end
+
+			steps.should have(3).items
+			steps[0].should eq("a")
+			steps[1].should eq("b")
+			steps[2].should eq("c")
+		end
+
+		it "returns the path itself" do
+			path = FilePath.new("/a/b/c/")
+			path.each_segment { }.should be(path)
+		end
+	end
+
 	describe "#ascend" do
 		it "goes through all the segments of an absolute path" do
 			steps = []
-			FilePath.new("/a/b/c").ascend do |p|
-				steps << p
+			FilePath.new("/a/b/c").ascend do |seg|
+				steps << seg
 			end
 
 			steps.should have(4).items
@@ -328,8 +362,8 @@ describe FilePath do
 
 		it "goes through all the segments of a relative path" do
 			steps = []
-			FilePath.new("a/b/c").ascend do |p|
-				steps << p
+			FilePath.new("a/b/c").ascend do |seg|
+				steps << seg
 			end
 
 			steps.should have(3).items
@@ -347,8 +381,8 @@ describe FilePath do
 	describe "#descend" do
 		it "goes through all the segments of an absolute path" do
 			steps = []
-			FilePath.new("/a/b/c").descend do |p|
-				steps << p
+			FilePath.new("/a/b/c").descend do |seg|
+				steps << seg
 			end
 
 			steps.should have(4).items
@@ -360,8 +394,8 @@ describe FilePath do
 
 		it "goes through all the segments of a relative path" do
 			steps = []
-			FilePath.new("a/b/c").descend do |p|
-				steps << p
+			FilePath.new("a/b/c").descend do |seg|
+				steps << seg
 			end
 
 			steps.should have(3).items
@@ -414,8 +448,8 @@ describe FilePath do
 		]
 		test_data.each do |ver1, ver2|
 			it "says that `#{ver1}` is equivalent to `#{ver2}`" do
-				p = FilePath.new(ver1)
-				p.should == ver2
+				ph = FilePath.new(ver1)
+				ph.should == ver2
 			end
 		end
 	end
@@ -450,6 +484,23 @@ describe FilePath do
 		end
 	end
 
+	describe "#<=>" do
+		test_data = [
+			['a/', 'b'],
+			['/a', 'a'],
+			['../b', 'a'],
+		]
+		test_data.each do |path1, path2|
+			it "says that `#{path1}` precedes `#{path2}`" do
+				p1 = path1.as_path
+				p2 = path2.as_path
+
+				order = p1 <=> p2
+				order.should == -1
+			end
+		end
+	end
+
 	describe "#hash" do
 		it "has the same value for similar paths" do
 			p1 = '/foo/bar'.as_path
@@ -474,29 +525,63 @@ describe FilePath do
 		end
 	end
 
-	describe FilePath::PathResolution do
-		describe "#absolute_path" do
-			test_data = [
-				['d1/l11', File.expand_path('d1/l11', FIXTURES_DIR), FIXTURES_DIR],
-				['/foo/bar', '/foo/bar', '.'],
-			]
-			test_data.each do |path, abs_path, cwd|
-				it "resolves <#{path}> to <#{abs_path}> (in #{cwd})" do
-					Dir.chdir(cwd) do # FIXME
-						FilePath.new(path).absolute_path.should == abs_path
-					end
-				end
+	describe FilePath::MetadataInfo do
+		describe "#stat" do
+			it "returns a stat for the file" do
+				(@root / 'd1').stat.should be_directory
+				(@root / 'f1').stat.size.should be_zero
+			end
+
+			it "follows links" do
+				(@root / 'd1' / 'l11').stat.should == '/dev/null'.as_path.stat
+			end
+
+			it "raises Errno::ENOENT for non-existing files" do
+				expect { (@root / 'foobar').stat }.to raise_error(Errno::ENOENT)
 			end
 		end
 
-		describe "#real_path" do
-			it "resolves <d1/l11> to </dev/null>" do
-				(@root / 'd1' / 'l11').real_path.should == '/dev/null'
+		describe "#lstat" do
+			it "does not follow links" do
+				link_lstat = (@root / 'd1' / 'l11').lstat
+
+				link_lstat.should_not eq('/dev/null'.as_path.stat)
+				link_lstat.should be_symlink
+			end
+		end
+	end
+
+	describe FilePath::MetadataChanges do
+		describe "#chtime" do
+			it "change mtime" do
+				ph = @root / 'f1'
+				orig_mtime = ph.mtime
+
+				ph.chtime(Time.now, 0)
+				ph.mtime.to_i.should eq(0)
+
+				ph.chtime(Time.now, orig_mtime)
+				ph.mtime.should eq(orig_mtime)
+			end
+		end
+
+		describe "#chmod" do
+			it "changes file permissions" do
+				ph = @root / 'f1'
+				orig_mode = ph.stat.mode
+
+				ph.should be_readable
+
+				ph.chmod(000)
+				ph.should_not be_readable
+
+				ph.chmod(orig_mode)
+				ph.should be_readable
 			end
 		end
 	end
 
-	describe FilePath::FileInfo do
+	describe FilePath::MetadataTests do
 		describe "#file?" do
 			it "says that `f1` is a file" do
 				(@root / 'f1').should be_file
@@ -506,7 +591,7 @@ describe FilePath do
 				(@root / 'd1' / 'l11').should_not be_file
 			end
 
-			it "says that the root directory is not a file" do
+			it "says that the fixture root directory is not a file" do
 				@root.should_not be_file
 			end
 		end
@@ -520,7 +605,7 @@ describe FilePath do
 				(@root / 'd1' / 'l11').should be_link
 			end
 
-			it "says that the root directory is not a link" do
+			it "says that the fixture root directory is not a link" do
 				@root.should_not be_link
 			end
 		end
@@ -534,11 +619,39 @@ describe FilePath do
 				(@root / 'd1' / 'l11').should_not be_directory
 			end
 
-			it "says that the root directory is file" do
+			it "says that the fixture root directory is a directory" do
 				@root.should be_directory
 			end
 		end
 
+		describe "#pipe?" do
+			it "says that `p1` is a pipe" do
+				(@root / 'p1').should be_pipe
+			end
+
+			it "says that `f1` is not a pipe" do
+				(@root / 'f1').should_not be_pipe
+			end
+
+			it "says that the fixture root directory is not a pipe" do
+				@root.should_not be_pipe
+			end
+		end
+
+		describe "#socket?" do
+			it "says that `s1` is a socket" do
+				(@root / 's1').should be_socket
+			end
+
+			it "says that `f1` is not a socket" do
+				(@root / 'f1').should_not be_socket
+			end
+
+			it "says that the fixture root directory is not a socket" do
+				@root.should_not be_socket
+			end
+		end
+
 		describe "#hidden?" do
 			hidden_paths = [
 				'.foorc',
@@ -563,18 +676,40 @@ describe FilePath do
 		end
 	end
 
-	describe FilePath::FileManipulationMethods do
-		describe "#touch" do
-			let(:ph) { @root / 'd1' / 'test-touch' }
-
-			before(:each) do
-				ph.should_not exist
+	describe FilePath::FilesystemInfo do
+		describe "#absolute_path" do
+			test_data = [
+				['d1/l11', File.expand_path('d1/l11', FIXTURES_DIR), FIXTURES_DIR],
+				['/foo/bar', '/foo/bar', '.'],
+			]
+			test_data.each do |path, abs_path, cwd|
+				it "resolves <#{path}> to <#{abs_path}> (in #{cwd})" do
+					Dir.chdir(cwd) do # FIXME
+						FilePath.new(path).absolute_path.should == abs_path
+					end
+				end
 			end
+		end
 
-			after(:each) do
-				File.delete(ph) if File.exists?(ph)
+		describe "#real_path" do
+			it "resolves <d1/l11> to </dev/null>" do
+				(@root / 'd1' / 'l11').real_path.should == '/dev/null'
 			end
+		end
+	end
+
+	describe FilePath::FilesystemChanges do
+		let(:ph) { @root / 'd1' / 'test-file' }
+
+		before(:each) do
+			ph.should_not exist
+		end
+
+		after(:each) do
+			File.delete(ph) if File.exists?(ph)
+		end
 
+		describe "#touch" do
 			it "creates an empty file" do
 				ph.touch
 				ph.should exist
@@ -601,7 +736,225 @@ describe FilePath do
 		end
 	end
 
-	describe FilePath::DirectoryMethods do
+	describe FilePath::FilesystemTests do
+		describe "mountpoint?" do
+			it "says that </proc> is a mount point" do
+				"/proc".as_path.should be_mountpoint
+			end
+
+			it "says that this RSpec file is not a mount point" do
+				__FILE__.as_path.should_not be_mountpoint
+			end
+
+			it "says that an non-existing file is not a mount point" do
+				"/foo/bar".as_path.should_not be_mountpoint
+			end
+
+			it "says that </> is a mount point" do
+				"/".as_path.should be_mountpoint
+			end
+		end
+	end
+
+	describe FilePath::ContentInfo do
+		let(:ph) { @root / 'd1' / 'test-file' }
+
+		before(:each) do
+			ph.should_not exist
+		end
+
+		after(:each) do
+			File.delete(ph) if File.exists?(ph)
+		end
+
+		describe "#read" do
+			let(:content) { "a"*20 + "b"*10 + "c"*5 }
+
+			before(:each) do
+				ph.open('w') { |f| f << content }
+			end
+
+			it "reads the complete content of a file" do
+				c = ph.read
+				c.should == content
+			end
+
+			it "reads the content in chunks of arbitrary sizes" do
+				sum = ""
+				len = 8
+
+				num_chunks = (content.length.to_f / len).ceil
+				num_chunks.times do |i|
+					c = ph.read(len, len*i)
+					sum += c
+					c.should == content[len*i, len]
+				end
+
+				sum.should == content
+			end
+		end
+
+		describe "#readlines" do
+			let(:line) { "abcd12" }
+			let(:lines) { Array.new(3) { line } }
+
+			it "reads all the lines in the file" do
+				ph.open('w') { |file| file << lines.join("\n") }
+				readlines = ph.readlines
+
+				readlines.should have(3).lines
+				readlines.all? { |l| l.chomp.should == line }
+			end
+
+			it "read lines separated by arbitrary separators" do
+				sep = ','
+
+				ph.open('w') { |file| file << lines.join(sep) }
+				readlines = ph.readlines(sep)
+
+				readlines.should have(3).lines
+				readlines[0..-2].all? { |l| l.should == line + sep}
+				readlines.last.should == line
+			end
+		end
+
+		describe "#size" do
+			before(:each) do
+				ph.touch
+			end
+
+			it "says that an empty file contains 0 bytes" do
+				ph.size.should be_zero
+			end
+
+			it "reports the size of a non-empty file" do
+				ph.size.should be_zero
+
+				ph.open("a") { |f| f << "abc" }
+				ph.size.should eq(3)
+
+				ph.open("a") { |f| f << "defg" }
+				ph.size.should eq(3+4)
+			end
+		end
+	end
+
+	describe FilePath::ContentChanges do
+		let(:ph) { @root / 'd1' / 'test-file' }
+		let(:content) { "a"*20 + "b"*10 + "c"*5 }
+
+		before(:each) do
+			ph.should_not exist
+		end
+
+		after(:each) do
+			File.delete(ph) if File.exists?(ph)
+		end
+
+		describe "#open" do
+			before(:each) do
+				ph.touch
+			end
+
+			it "opens files" do
+				file = ph.open
+				file.should be_a(File)
+			end
+
+			it "opens files in read-only mode" do
+				ph.open do |file|
+					expect { file << "abc" }.to raise_error(IOError)
+				end
+			end
+
+			it "opens files in read-write mode" do
+				ph.open('w') do |file|
+					file << "abc"
+				end
+
+				ph.size.should == 3
+			end
+		end
+
+		describe "#write" do
+			it "writes data passed as argument" do
+				ph.write(content)
+
+				ph.read.should == content
+			end
+
+			it "overwrites an existing file" do
+				ph.write(content * 2)
+				ph.size.should eq(content.length * 2)
+
+				ph.write(content)
+				ph.size.should eq(content.length)
+
+				ph.read.should == content
+			end
+		end
+
+		describe "#append" do
+			it "appends data to an existing file" do
+				ph.write(content)
+				ph.append(content)
+
+				ph.size.should eq(content.length * 2)
+				ph.read.should == content * 2
+			end
+		end
+
+		describe "#truncate" do
+			before(:each) do
+				ph.open('w') { |f| f << content }
+			end
+
+			it "truncates a file to 0 bytes" do
+				ph.size.should_not be_zero
+				ph.truncate
+				ph.size.should be_zero
+			end
+
+			it "truncates a file to an arbitrary size" do
+				ph.size.should_not be_zero
+				ph.truncate(2)
+				ph.size.should == 2
+			end
+		end
+	end
+
+	describe FilePath::ContentTests do
+		let(:ph) { @root / 'd1' / 'test-file' }
+
+		before(:each) do
+			ph.should_not exist
+		end
+
+		after(:each) do
+			File.delete(ph) if File.exists?(ph)
+		end
+
+		describe "#empty?" do
+			before(:each) do
+				ph.touch
+			end
+
+			it "says that an empty file is empty" do
+				ph.should be_empty
+			end
+
+			it "says that a non-empyt file is not empty" do
+				ph.open('w') { |f| f << "abc" }
+				ph.should_not be_empty
+			end
+
+			it "says that </dev/null> is empty" do
+				'/dev/null'.as_path.should be_empty
+			end
+		end
+	end
+
+	describe FilePath::SearchMethods do
 		describe "#entries" do
 			it "raises when path is not a directory" do
 				expect { (@root / 'f1').entries(:files) }.to raise_error(Errno::ENOTDIR)
@@ -612,14 +965,14 @@ describe FilePath do
 			it "finds all paths matching a glob string" do
 				list = @root.find('*1')
 
-				list.should have(6).items
+				list.should have(8).items
 				list.each { |path| path.should =~ /1/ }
 			end
 
 			it "finds all paths matching a Regex" do
 				list = @root.find(/2/)
 
-				list.should have(5).items
+				list.should have(6).items
 				list.each { |path| path.should =~ /2/ }
 			end
 
@@ -677,6 +1030,8 @@ describe FilePath do
 			end
 		end
 	end
+
+	describe FilePath::EnvironmentInfo
 end
 
 describe String do