filepath 0.1 → 0.2

data/.yardopts

@@ -1,3 +1,3 @@
--m none
+-m markdown
 -
 UNLICENSE

data/README.md

@@ -1,13 +1,15 @@
 FilePath
 ========
 
-`FilePath` is a class that helps dealing with files, directories and paths in
-general; a modern replacement for the standard Pathname.
+filepath is a small library that helps dealing with files, directories and
+paths in general; a modern replacement for the standard Pathname.
+
+filepath is built around two main classes: `FilePath`, that represents paths,
+and `FilePathList`, lists of paths. The instances of these classes are
+immutable objects with dozens of convience methods for common operations such
+as calculating relative paths, concatenating paths, finding all the files in
+a directory or modifing all the extensions of a list of file names at once.
 
-`FilePath` instances are immutable objects with dozens of convience methods
-for common operations such as calculating relative paths, concatenating paths
-or finding all the files in a directory. There is also a companion class
-`FilePathList` to perform operations on multiple files at once.
 
 Features and examples
 ---------------------

data/Rakefile

@@ -13,9 +13,11 @@ Bones {
 	email    'gioele@svario.it'
 	url      'http://github.com/gioele/filepath'
 
-	version  '0.1'
+	version  '0.2'
 
 	ignore_file  '.gitignore'
+
+	depend_on 'bones-rspec', :development => true
 }
 
 require File.join(File.dirname(__FILE__), 'spec/tasks')

data/lib/filepath.rb

@@ -27,7 +27,7 @@ class FilePath
 			raw_paths = raw_paths.first
 		end
 
-		paths = raw_paths.map { |p| FilePath.new(p) }
+		paths = raw_paths.map { |p| p.as_path }
 
 		frags = []
 		paths.each { |path| frags += path.fragments }
@@ -40,12 +40,12 @@ class FilePath
 	#
 	# @example Append a string
 	#
-	#    FilePath.new("a/b") / "c" #=> <a/b/c>
+	#    "a/b".as_path / "c" #=> <a/b/c>
 	#
 	# @example Append another FilePath
 	#
-	#    home = FilePath.new(ENV["HOME"] || "/root")
-	#    conf_dir = FilePath.new('.config')
+	#    home = (ENV["HOME"] || "/root").as_path
+	#    conf_dir = '.config'.as_path
 	#
 	#    home / conf_dir #=> </home/user/.config>
 	#
@@ -82,15 +82,17 @@ class FilePath
 	end
 
 
-	# Calculates the relative path from another path.
+	# Calculates the relative path from a given directory.
 	#
-	# @param [FilePath, String] base the path to use as a base for the
+	# @param [FilePath, String] base the directory to use as base for the
 	#                                relative path
 	#
 	# @return [FilePath] the relative path
+	#
+	# @note this method operates on the normalized paths
 
 	def relative_to(base)
-		base = FilePath.new(base) unless base.is_a? FilePath
+		base = base.as_path
 
 		if self.absolute? != base.absolute?
 			self_abs = self.absolute? ? "absolute" : "relative"
@@ -101,21 +103,37 @@ class FilePath
 			raise msg # FIXME: argerror error class
 		end
 
-		self_frags = self.fragments
-		base_frags = base.fragments.dup
+		self_frags = self.normalized_fragments
+		base_frags = base.normalized_fragments
+
+		base_frags_tmp = base_frags.dup
 		num_same = self_frags.find_index do |frag|
-			base_frags.delete_at(0) != frag
+			base_frags_tmp.delete_at(0) != frag
 		end
 
 		# find_index returns nil if `self` is a subset of `base`
-		num_same ||= self.fragments.length
+		num_same ||= self_frags.length
 
-		num_parent_dirs = base.fragments.length - num_same
-		left_in_self = self.fragments[num_same..-1]
+		num_parent_dirs = base_frags.length - num_same
+		left_in_self = self_frags[num_same..-1]
 
 		frags = [".."] * num_parent_dirs + left_in_self
+		normalized_frags = normalized_relative_frags(frags)
 
-		return FilePath.join(frags)
+		return FilePath.join(normalized_frags)
+	end
+
+	# Calculates the relative path from a given file.
+	#
+	# @param [FilePath, String] base the file to use as base for the
+	#                                relative path
+	#
+	# @return [FilePath] the relative path
+	#
+	# @see #relative_to
+
+	def relative_to_file(base_file)
+		return relative_to(base_file.as_path.parent_dir)
 	end
 
 
@@ -128,11 +146,11 @@ class FilePath
 
 	def filename
 		if self.root?
-			return FilePath.new('')
+			return ''.as_path
 		end
 
 		filename = self.normalized_fragments.last
-		return FilePath.new(filename)
+		return filename.as_path
 	end
 
 	alias :basename :filename
@@ -157,7 +175,7 @@ class FilePath
 
 	def replace_filename(new_path)
 		dir = self.parent_dir
-		return dir / FilePath.new(new_path)
+		return dir / new_path
 	end
 
 	alias :replace_basename :replace_filename
@@ -232,21 +250,24 @@ class FilePath
 	def replace_extension(new_ext) # FIXME: accept block
 		if !self.extension?
 			if new_ext.nil?
-				path = self.to_s
+				new_filename = filename
 			else
-				path = self.to_s + '.' + new_ext
+				new_filename = filename.to_s + '.' + new_ext
 			end
 		else
 			if new_ext.nil?
 				pattern = /\.[^.]*?\Z/
-				path = self.to_s.sub(pattern, '')
+				new_filename = filename.to_s.sub(pattern, '')
 			else
-				pattern = '.' + extension
-				path = self.to_s.sub(pattern, '.' + new_ext)
+				pattern = Regexp.new('.' + extension + '\\Z')
+				new_filename = filename.to_s.sub(pattern, '.' + new_ext)
 			end
 		end
 
-		return FilePath.new(path)
+		frags = @fragments[0..-2]
+		frags << new_filename
+
+		return FilePath.join(frags)
 	end
 
 	alias :replace_ext :replace_extension
@@ -264,6 +285,16 @@ class FilePath
 	alias :remove_ext :remove_extension
 
 
+	# Matches a pattern against this path.
+	#
+	# @param [Regexp, Object] pattern the pattern to match against
+	#                                 this path
+	#
+	# @return [Fixnum, nil] the position of the pattern in the path, or
+	#                       nil if there is no match
+	#
+	# @note this method operates on the normalized path
+
 	def =~(pattern)
 		return self.to_s =~ pattern
 	end
@@ -319,11 +350,7 @@ class FilePath
 	# @yield [path] TODO
 
 	def ascend(max_depth = nil, &block)
-		max_depth ||= @fragments.length
-		(1..max_depth).reverse_each do |limit|
-			frags = @fragments.take(limit)
-			yield FilePath.join(frags)
-		end
+		iterate(max_depth, :reverse_each, &block)
 	end
 
 	# Iterates over all the directory that lead to the current path.
@@ -334,8 +361,13 @@ class FilePath
 	# @yield [path] TODO
 
 	def descend(max_depth = nil, &block)
+		iterate(max_depth, :each, &block)
+	end
+
+	# @private
+	def iterate(max_depth, method, &block)
 		max_depth ||= @fragments.length
-		(1..max_depth).each do |limit|
+		(1..max_depth).send(method) do |limit|
 			frags = @fragments.take(limit)
 			yield FilePath.join(frags)
 		end
@@ -355,19 +387,25 @@ class FilePath
 
 	# @return [String] this path converted to a String
 	#
-	# @note this method operates on the normalized the path
+	# @note this method operates on the normalized path
 
 	def to_s
 		return self.normalized_fragments.join(SEPARATOR).sub(%r{^//}, SEPARATOR)
 	end
 
 
+	# @return [FilePath] the path itself.
+	def as_path
+		self
+	end
+
+
 	def inspect
 		return '<' +  self.to_raw_string + '>'
 	end
 
 	def ==(other)
-		return self.to_s == FilePath.new(other).to_s
+		return self.to_s == other.as_path.to_s
 	end
 
 	# @private
@@ -403,7 +441,7 @@ class FilePath
 				# remove '..' fragments following a root delimiter
 				frags.delete_at(i)
 				i -= 1
-			elsif frags[i] == '..' && frags[i-1] != '..'
+			elsif frags[i] == '..' && frags[i-1] != '..' && i >= 1
 				# remove every fragment followed by a ".." marker
 				frags.delete_at(i)
 				frags.delete_at(i-1)
@@ -420,63 +458,52 @@ class FilePath
 			path = if !self.absolute?
 				self
 			else
-				FilePath.new(base_dir) / self
+				base_dir.as_path / self
 			end
 
 			return path.resolve_link
 		end
 
 		def resolve_link
-			return FilePath.new(File.readlink(self.to_s))
+			return File.readlink(self.to_s).as_path
 		end
 	end
 
 	module FileInfo
-		def file?
-			FileTest.file?(self.to_s)
+		# @private
+		def self.define_filetest_method(filepath_method, filetest_method = nil)
+			filetest_method ||= filepath_method
+			define_method(filepath_method) do
+				return FileTest.send(filetest_method, self.to_s)
+			end
 		end
 
-		def link?
-			FileTest.symlink?(self.to_s)
-		end
-		alias symlink? link?
+		define_filetest_method :file?
 
-		def directory?
-			FileTest.directory?(self.to_s)
-		end
+		define_filetest_method :link?, :symlink?
+		alias :symlink? :link?
 
-		def exists?
-			FileTest.exists?(self.to_s)
-		end
-		alias exist? exists?
+		define_filetest_method :directory?
 
-		def readable?
-			FileTest.readable?(self.to_s)
-		end
+		define_filetest_method :exists?
+		alias :exist? :exists?
 
-		def writable?
-			FileTest.writable?(self.to_s)
-		end
+		define_filetest_method :readable?
 
-		def executable?
-			FileTest.executable?(self.to_s)
-		end
+		define_filetest_method :writeable?
 
-		def setgid?
-			FileTest.setgid?(self.to_s)
-		end
+		define_filetest_method :executable?
 
-		def setuid?
-			FileTest.setuid?(self.to_s)
-		end
+		define_filetest_method :setgid?
+
+		define_filetest_method :setuid?
+
+		define_filetest_method :empty?, :zero?
+		alias :zero? :empty?
 
 		def hidden?
 			@fragments.last.start_with('.') # FIXME: windows, mac
 		end
-
-		def empty?
-			FileTest.zero?(self.to_s)
-		end
 	end
 
 	module FileManipulationMethods
@@ -489,7 +516,7 @@ class FilePath
 		end
 	end
 
-	module DirectoyMethods
+	module DirectoryMethods
 		def entries(pattern = '*')
 			if !self.directory?
 				raise Errno::ENOTDIR.new(self.to_s)
@@ -518,7 +545,7 @@ class FilePath
 	include PathResolution
 	include FileInfo
 	include FileManipulationMethods
-	include DirectoyMethods
+	include DirectoryMethods
 end
 
 class String

data/spec/filepath_spec.rb

@@ -81,12 +81,15 @@ describe FilePath do
 		end
 	end
 
-	describe "#relative_to(FilePath)" do
+	describe "#relative_to" do
 		test_data = [
 			['/a/b/c', '/a/b', 'c'],
 			['/a/b/c', '/a/d', '../b/c'],
 			['/a/b/c', '/a/b/c/d', '..'],
 			['/a/b/c', '/a/b/c', '.'],
+			['a/d', 'a/b/c', '../../d'],
+			['a/e/f', 'a/b/c/d', '../../../e/f'],
+			['a/c', 'a/b/..', 'c'],
 		]
 		test_data.each do |path, base, result|
 			it "says that `#{path}` relative to `#{base}` is `#{result}`" do
@@ -109,6 +112,22 @@ describe FilePath do
 		end
 	end
 
+	describe "#relative_to_file" do
+				test_data = [
+			['/a/b/c', '/a/d', 'b/c'],
+			['/a/b/c', '/a/b/c/d', '.'],
+			['/a/b/c', '/a/b/c', 'c'],
+			['a/d', 'a/b/c', '../d'],
+			['a/e/f', 'a/b/c/d', '../../e/f'],
+		]
+		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
+			end
+		end
+	end
+
 	describe "#replace_filename" do
 		test_data = [
 			['foo/bar', 'quux', 'foo/quux'],
@@ -220,6 +239,10 @@ describe FilePath do
 		it "matches `/foo/bar` with /o\\/ba" do
 			FilePath.new('/foo/bar').should =~ /o\/b/
 		end
+
+		it "matches `/foo/bar/../quux` with /foo\\/quux/" do
+			FilePath.new('/foo/bar/../quux').should =~ /foo\/quux/
+		end
 	end
 
 	describe "#absolute?" do
@@ -232,6 +255,26 @@ describe FilePath do
 		end
 	end
 
+	describe "#normalized" do
+		test_data = [
+			['a', 'a'],
+			['a/b/c', 'a/b/c'],
+			['a/../c', 'c'],
+			['a/b/..', 'a'],
+			['../a', '../a'],
+			['../../a', '../../a'],
+			['../a/..', '..'],
+			['/', '/'],
+			['/..', '/'],
+			['/../../../a', '/a'],
+		]
+		test_data.each do |path, result|
+			it "turns `#{path}` into `#{result}`" do
+				FilePath.new(path).normalized.to_raw_string.should == result
+			end
+		end
+	end
+
 	describe "#ascend" do
 		it "goes through all the fragments of an absolute path" do
 			steps = []
@@ -300,6 +343,12 @@ describe FilePath do
 		end
 	end
 
+	describe "#as_path" do
+		it "returns the path itself" do
+			@root.as_path.should be(@root)
+		end
+	end
+
 	describe "#==(String)" do
 		test_data = [
 			['./', '.'],

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: filepath
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-14 00:00:00.000000000 Z
+date: 2012-01-15 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bones-rspec
+  requirement: &15445240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: *15445240
 - !ruby/object:Gem::Dependency
   name: bones
-  requirement: &14096440 !ruby/object:Gem::Requirement
+  requirement: &15444620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,11 +32,11 @@ dependencies:
         version: 3.7.3
   type: :development
   prerelease: false
-  version_requirements: *14096440
-description: ! '`FilePath` is a class that helps dealing with files, directories and
-  paths in
+  version_requirements: *15444620
+description: ! 'filepath is a small library that helps dealing with files, directories
+  and
 
-  general; a modern replacement for the standard Pathname.'
+  paths in general; a modern replacement for the standard Pathname.'
 email: gioele@svario.it
 executables: []
 extensions: []
@@ -67,6 +78,6 @@ rubyforge_project: filepath
 rubygems_version: 1.8.12
 signing_key: 
 specification_version: 3
-summary: ! '`FilePath` is a class that helps dealing with files, directories and paths
-  in general; a modern replacement for the standard Pathname.'
+summary: filepath is a small library that helps dealing with files, directories and
+  paths in general; a modern replacement for the standard Pathname.
 test_files: []