filepath 0.2 → 0.3.1

data/README.md

@@ -16,7 +16,7 @@ Features and examples
 
 The main purpose of FilePath is to able to write
 
-    require __FILE_.as_path / 'spec' / 'tasks'
+    require __FILE__.as_path / 'spec' / 'tasks'
 
 instad of cumbersome code like
 
@@ -48,7 +48,7 @@ The main features of FilePath are…
 
     converted_img = image.replace_extension("jpeg")
     converted_img.to_s     #=> "/home/gioele/Documents/images/cat.jpeg"
-    convert(image.to_s, converted_img.to_s)
+    convert(image, converted_img)
 
 ### Path traversal
 

data/Rakefile

@@ -13,7 +13,7 @@ Bones {
 	email    'gioele@svario.it'
 	url      'http://github.com/gioele/filepath'
 
-	version  '0.2'
+	version  '0.3.1'
 
 	ignore_file  '.gitignore'
 

data/lib/filepath.rb

@@ -12,7 +12,7 @@ class FilePath
 		elsif path.is_a? Array
 			@fragments = path
 		else
-			@fragments = split_path_string(path.to_s)
+			@fragments = split_path_string(path.to_str)
 		end
 	end
 
@@ -100,7 +100,7 @@ class FilePath
 			msg = "cannot compare: "
 			msg += "`#{self}` is #{self_abs} while "
 			msg += "`#{base}` is #{base_abs}"
-			raise msg # FIXME: argerror error class
+			raise ArgumentError, msg
 		end
 
 		self_frags = self.normalized_fragments
@@ -231,7 +231,7 @@ class FilePath
 		end
 	end
 
-	alias ext? extension?
+	alias :ext? :extension?
 
 
 	# @overload replace_extension(new_ext)
@@ -338,6 +338,7 @@ class FilePath
 	def normalized
 		return FilePath.join(self.normalized_fragments)
 	end
+
 	alias :normalised :normalized
 
 
@@ -379,7 +380,7 @@ class FilePath
 	# @return [String] this path converted to a String
 
 	def to_raw_string
-		return @fragments.join(SEPARATOR).sub(%r{^//}, SEPARATOR) # FIXME: windows, mac
+		@to_raw_string ||= join_fragments(@fragments)
 	end
 
 	alias :to_raw_str :to_raw_string
@@ -390,7 +391,12 @@ class FilePath
 	# @note this method operates on the normalized path
 
 	def to_s
-		return self.normalized_fragments.join(SEPARATOR).sub(%r{^//}, SEPARATOR)
+		to_str
+	end
+
+
+	def to_str
+		@to_str ||= join_fragments(self.normalized_fragments)
 	end
 
 
@@ -405,7 +411,21 @@ class FilePath
 	end
 
 	def ==(other)
-		return self.to_s == other.as_path.to_s
+		return self.normalized_fragments == other.as_path.normalized_fragments
+	end
+
+	def eql?(other)
+		if self.equal?(other)
+			return true
+		elsif self.class != other.class
+			return false
+		end
+
+		return self.fragments == other.fragments
+	end
+
+	def hash
+		return self.fragments.hash
 	end
 
 	# @private
@@ -425,7 +445,7 @@ class FilePath
 
 	# @private
 	def normalized_fragments
-		normalized_relative_frags(self.fragments)
+		@normalized_fragments ||= normalized_relative_frags(self.fragments)
 	end
 
 	# @private
@@ -453,19 +473,32 @@ class FilePath
 		return frags
 	end
 
+	# @private
+	def join_fragments(frags)
+		# FIXME: windows, mac
+		# FIXME: avoid string substitutions and regexen
+		return frags.join(SEPARATOR).sub(%r{^//}, SEPARATOR).sub(/\A\Z/, '.')
+	end
+
 	module PathResolution
 		def absolute_path(base_dir = Dir.pwd) # FIXME: rename to `#absolute`?
-			path = if !self.absolute?
-				self
-			else
-				base_dir.as_path / self
+			if self.absolute?
+				return self
 			end
 
+			return base_dir.as_path / self
+		end
+
+		def real_path(base_dir = Dir.pwd)
+			path = absolute_path(base_dir)
+
 			return path.resolve_link
 		end
 
+		alias :realpath :real_path
+
 		def resolve_link
-			return File.readlink(self.to_s).as_path
+			return File.readlink(self).as_path
 		end
 	end
 
@@ -474,7 +507,7 @@ class FilePath
 		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)
+				return FileTest.send(filetest_method, self)
 			end
 		end
 
@@ -502,27 +535,28 @@ class FilePath
 		alias :zero? :empty?
 
 		def hidden?
-			@fragments.last.start_with('.') # FIXME: windows, mac
+			@fragments.last.start_with?('.') # FIXME: windows, mac
 		end
 	end
 
 	module FileManipulationMethods
 		def open(*args, &block)
-			File.open(self.to_s, *args, &block)
+			File.open(self, *args, &block)
 		end
 
 		def touch
-			self.open do ; end
+			self.open('a') do ; end
+			File.utime(File.atime(self), Time.now, self)
 		end
 	end
 
 	module DirectoryMethods
 		def entries(pattern = '*')
 			if !self.directory?
-				raise Errno::ENOTDIR.new(self.to_s)
+				raise Errno::ENOTDIR.new(self)
 			end
 
-			raw_entries = Dir.glob((self / pattern).to_s)
+			raw_entries = Dir.glob((self / pattern))
 			entries = FilePathList.new(raw_entries)
 
 			return entries

data/lib/filepathlist.rb

@@ -4,9 +4,11 @@
 class FilePathList
 	include Enumerable
 
+	SEPARATOR = ':'.freeze
+
 	def initialize(raw_entries = nil)
 		raw_entries ||= []
-		@entries = raw_entries.map { |e| FilePath.new(e) }
+		@entries = raw_entries.map { |e| e.as_path }
 	end
 
 	def select_entries(type)
@@ -26,11 +28,6 @@ class FilePathList
 		return select_entries(:directory)
 	end
 
-	def exclude(pattern) # FIXME: block
-		raw_entries = @entries.delete_if { |e| e =~ pattern }
-		return FilePathList.new(raw_entries)
-	end
-
 	def /(extra_path)
 		return self.map { |path| path / extra_path }
 	end
@@ -39,7 +36,19 @@ class FilePathList
 		return FilePathList.new(@entries + extra_entries.to_a)
 	end
 
-	def <<(extra_path) # TODO: implement
+	def -(others) # FIXME: block
+		if others.is_a? Regexp # FIXME: support any object that responds to =~
+			remaining_entries = @entries.delete_if { |e| e =~ others }
+		else
+			remaining_entries = @entries - others.as_path_list.to_a
+		end
+
+		return FilePathList.new(remaining_entries)
+	end
+	alias :exclude :-
+
+	def <<(extra_path)
+		return FilePathList.new(@entries + [extra_path.as_path])
 	end
 
 	def *(other_list)
@@ -51,24 +60,87 @@ class FilePathList
 		return FilePathList.new(paths)
 	end
 
-	# FIXME: delegate :to => @entries
-	def [](index)
-		@entries[index]
+	def remove_common_fragments
+		all_frags = @entries.map(&:fragments)
+		max_length = all_frags.map(&:length).min
+
+		idx_different = nil
+
+		(0..max_length).each do |i|
+			fragment = all_frags.first[i]
+
+			different = all_frags.any? { |frags| frags[i] != fragment }
+			if different
+				idx_different = i
+				break
+			end
+		end
+
+		idx_different ||= max_length
+
+		remaining_frags = all_frags.map { |frags| frags[idx_different..-1] }
+
+		return FilePathList.new(remaining_frags)
 	end
 
-	def include?(*others)
-		@entries.include?(*others)
+	# @return [FilePathList] the path list itself
+
+	def as_path_list
+		self
 	end
 
-	def each(&block)
-		@entries.each(&block)
+	def to_a
+		@entries
 	end
 
-	def map(&block)
-		@entries.map(&block)
+	def to_s
+		@to_s ||= @entries.map(&:to_str).join(SEPARATOR)
 	end
 
 	def inspect
 		@entries.inspect
 	end
+
+	def ==(other)
+		@entries == other.as_path_list.to_a
+	end
+
+	module ArrayMethods
+		def self.define_array_method(name)
+			define_method(name) do |*args, &block|
+				return @entries.send(name, *args, &block)
+			end
+		end
+
+		define_array_method :[]
+
+		define_array_method :empty?
+
+		define_array_method :include?
+
+		define_array_method :each
+
+		define_array_method :map
+	end
+
+	include ArrayMethods
+end
+
+class Array
+	# Generates a path list from an array of paths.
+	#
+	# The elements of the array must respond to `#as_path`.
+	#
+	# `ary.as_path` is equivalent to `FilePathList.new(ary)`.
+	#
+	# @return [FilePathList] a new path list containing the elements of
+	#                        the array as FilePaths
+	#
+	# @see String#as_path
+	# @see Array#as_path
+	# @see FilePath#as_path
+
+	def as_path_list
+		FilePathList.new(self)
+	end
 end

data/spec/filepath_spec.rb

@@ -23,6 +23,7 @@ describe FilePath do
 			['foo', '.', 'foo'],
 			['foo', '..', '.'],
 			['foo/bar', 'baz', 'foo/bar/baz'],
+			['', 'foo/bar', './foo/bar'],
 		]
 		test_data.each do |base, extra, result|
 			it "concatenates `#{base}` and `#{extra}` (as String) into `#{result}`" do
@@ -49,6 +50,20 @@ describe FilePath do
 		end
 	end
 
+	describe "#join" do
+		test_data = [
+			['', ['bar'], './bar'],
+			['foo/quux', ['bar', 'baz'], 'foo/quux/bar/baz'],
+			['/', ['a', 'b', 'c'], '/a/b/c'],
+		]
+		test_data.each do |base, extra, result|
+			args = extra.map { |x| x.inspect }.join(',')
+			it "appends #{args} to '#{base}' to get <#{result}>" do
+				base.as_path.join(*extra).should == result
+			end
+		end
+	end
+
 	describe "filename" do
 		test_data = [
 			['/foo/bar', 'bar'],
@@ -107,7 +122,7 @@ 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
+				expect { p.relative_to(base) }.to raise_error(ArgumentError)
 			end
 		end
 	end
@@ -160,34 +175,38 @@ describe FilePath do
 	end
 
 	describe "#extension?" do
-		it "says that `foo.bar` has an extension" do
-			FilePath.new('foo.bar').extension?.should be_true
-		end
-
-		it "says that `foo.` has an extension" do
-			FilePath.new('foo.').extension?.should be_true
-		end
-
-		it "says that `foo` has no extension" do
-			FilePath.new('foo').extension?.should be_false
-		end
-
-		it "says that `foo.bar/baz` has no extension" do
-			FilePath.new('foo.bar/baz').extension?.should be_false
-		end
-
-		it "says that `.foo` has no extension" do
-			FilePath.new('.foo').extension?.should be_false
+		with_extension = [
+			'foo.bar',
+			'foo.',
+			'.foo.conf',
+		]
+		with_extension.each do |path|
+			it "says that <#{path}> has an extension" do
+				FilePath.new(path).extension?.should be_true
+			end
 		end
 
-		it "says that `.foo.conf` has no extension" do
-			FilePath.new('.foo.conf').extension?.should be_true
+		no_extension = [
+			'foo',
+			'foo.bar/baz',
+			'.foo',
+		]
+		no_extension.each do |path|
+			it "says that <#{path}> has no extension" do
+				FilePath.new(path).extension?.should be_false
+			end
 		end
-	end
 
-	describe "#extension?(String)" do
-		it "says that `foo.bar` extesions is `bar`" do
-			FilePath.new('foo.bar').extension?('bar').should be_true
+		extension_data = [
+			['foo.bar', 'bar'],
+			['/foo/bar.', ''],
+			['foo/bar.baz.conf', 'conf'],
+			['foo.bar.boom', /oo/],
+		]
+		extension_data.each do |path, ext|
+			it "says that <#{path}> extesions is #{ext.inspect}" do
+				FilePath.new(path).extension?(ext).should be_true
+			end
 		end
 
 		it "says that `foo.bar` extension is not `baz`" do
@@ -341,6 +360,10 @@ describe FilePath do
 		it "returns normalized paths" do
 			FilePath.new("/foo/bar/..").to_s.should eql('/foo')
 		end
+
+		it "returns '.' for empty paths" do
+			FilePath.new('').to_s.should eql('.')
+		end
 	end
 
 	describe "#as_path" do
@@ -369,10 +392,78 @@ describe FilePath do
 		end
 	end
 
+	describe "#eql?" do
+		it "is always true when an object is compared to itself" do
+			ph = 'foo/bar/baz'.as_path
+
+			ph.should eql(ph)
+		end
+
+		it "matches two different object representing the same path" do
+			p1 = '/foo/bar'.as_path
+			p2 = '/foo/bar'.as_path
+
+			p1.should eql(p2)
+		end
+
+		it "does not match different objects representing different paths" do
+			p1 = '/foo/bar'.as_path
+			p2 = '/foo/bar/baz'.as_path
+
+			p1.should_not eql(p2)
+		end
+
+		it "does not match objects that are not FilePaths" do
+			p1 = '/foo/bar/baz'.as_path
+			p2 = '/foo/bar/baz'
+
+			p1.should eq(p2)
+			p1.should_not eql(p2)
+		end
+	end
+
+	describe "#hash" do
+		it "has the same value for similar paths" do
+			p1 = '/foo/bar'.as_path
+			p2 = '/foo/bar'.as_path
+
+			p1.hash.should == p2.hash
+		end
+
+		it "has different values for different paths" do
+			p1 = '/foo/bar'.as_path
+			p2 = 'foo/quuz'.as_path
+
+			p1.hash.should_not == p2.hash
+		end
+
+		it "has different values for different paths with same normalized path" do
+			p1 = '/foo/bar/..'.as_path
+			p2 = '/foo'.as_path
+
+			p1.should eq(p2)
+			p1.hash.should_not eq(p2.hash)
+		end
+	end
+
 	describe FilePath::PathResolution do
 		describe "#absolute_path" do
-			it "resolves `d1/l11` to `/dev/null`" do
-				(@root / 'd1' / 'l11').absolute_path.should == '/dev/null'
+			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
+
+		describe "#real_path" do
+			it "resolves <d1/l11> to </dev/null>" do
+				(@root / 'd1' / 'l11').real_path.should == '/dev/null'
 			end
 		end
 	end
@@ -419,10 +510,71 @@ describe FilePath do
 				@root.should be_directory
 			end
 		end
+
+		describe "#hidden?" do
+			hidden_paths = [
+				'.foorc',
+				'foo/.bar',
+				'.foo.bar',
+			]
+			hidden_paths.each do |path|
+				it "says that <#{path}> is an hidden file" do
+					path.as_path.should be_hidden
+				end
+			end
+
+			non_hidden_paths = [
+				'foo.bar',
+				'foo/.bar/baz',
+			]
+			non_hidden_paths.each do |path|
+				it "says that <#{path}> not an hidden file" do
+					path.as_path.should_not be_hidden
+				end
+			end
+		end
+	end
+
+	describe FilePath::FileManipulationMethods do
+		describe "#touch" do
+			let(:ph) { @root / 'd1' / 'test-touch' }
+
+			before(:each) do
+				ph.should_not exist
+			end
+
+			after(:each) do
+				File.delete(ph) if File.exists?(ph)
+			end
+
+			it "creates an empty file" do
+				ph.touch
+				ph.should exist
+			end
+
+			it "updates the modification date of an existing file", :broken => true do
+				File.open(ph, "w+") { |file| file << "abc" }
+				File.utime(0, Time.now - 3200, ph)
+
+				before_stat = File.stat(ph)
+				before_time = Time.now
+
+				#sleep(5) # let Ruby flush its stat buffer to the disk
+				ph.touch
+
+				after_time = Time.now
+				after_stat = File.stat(ph)
+
+				before_stat.should_not eq(after_stat)
+
+				after_stat.size.should eq(before_stat.size)
+				after_stat.mtime.should be_between(before_time, after_time)
+			end
+		end
 	end
 
-	describe "methods that operate on directories" do
-		describe "#select_entries" do
+	describe FilePath::DirectoryMethods do
+		describe "#entries" do
 			it "raises when path is not a directory" do
 				expect { (@root / 'f1').entries(:files) }.to raise_error(Errno::ENOTDIR)
 			end
@@ -433,11 +585,11 @@ describe FilePath do
 				@root.files.should have(1).item
 			end
 
-			it "finds 2 files in directory `d1`" do
+			it "finds 2 files in directory <d1>" do
 				(@root / 'd1').files.should have(2).items
 			end
 
-			it "finds no files in directory `d1/d12`" do
+			it "finds no files in directory <d1/d12>" do
 				(@root / 'd1' / 'd12').files.should have(0).items
 			end
 		end
@@ -447,11 +599,11 @@ describe FilePath do
 				@root.directories.should have(4).items
 			end
 
-			it "finds 2 directories in directory `d2`" do
+			it "finds 2 directories in directory <d2>" do
 				(@root / 'd2').directories.should have(2).items
 			end
 
-			it "finds no directories in directory `d1/d13" do
+			it "finds no directories in directory <d1/d13>" do
 				(@root / 'd1' / 'd13').directories.should have(0).items
 			end
 		end
@@ -461,7 +613,7 @@ describe FilePath do
 				@root.links.should have(0).items
 			end
 
-			it "finds 1 link in directory `d1`" do
+			it "finds 1 link in directory <d1>" do
 				(@root / 'd1').links.should have(1).item
 			end
 		end

data/spec/filepathlist_spec.rb

@@ -4,6 +4,44 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe FilePathList do
+	describe "#initialize" do
+		it "creates an empty FilePathList" do
+			list = FilePathList.new()
+
+			list.should be_empty
+		end
+
+		it "creates a FilePathList from an Array of Strings" do
+			paths = %w{a/b c/d e/f}
+			list = FilePathList.new(paths)
+
+			list.should have(3).items
+			list.each { |path| path.should be_a(FilePath) }
+		end
+
+		it "creates a FilePathList from an Array of FilePaths" do
+			paths = %w{a/b c/d e/f}.map(&:as_path)
+			list = FilePathList.new(paths)
+
+			list.should have(3).items
+			list.each { |path| path.should be_a(FilePath) }
+		end
+
+		it "creates a FilePathList from an Array of Arrays" do
+			paths = [%w{a b}, %w{c d}, %w{e f}]
+			list = FilePathList.new(paths)
+
+			list.should have(3).items
+			list.each { |path| path.should be_a(FilePath) }
+		end
+	end
+
+	describe "#exclude" do
+		list = FilePathList.new(%w{a.foo b.bar c.foo d.foo b.bar})
+		refined = list.exclude(/bar$/)
+		refined.each { |path| path.extension.should == 'foo' }
+	end
+
 	describe "#/" do
 		it "adds the same string to all the paths" do
 			list = FilePathList.new(%w{foo faa}) / 'bar'
@@ -12,6 +50,45 @@ describe FilePathList do
 		end
 	end
 
+	describe "#+" do
+		it "concatenates two FilePathLists" do
+			list1 = FilePathList.new(%w{a b c})
+			list2 = FilePathList.new(%w{d e})
+
+			list = list1 + list2
+			list.should have(5).items
+			list[0].should eq('a')
+			list[1].should eq('b')
+			list[2].should eq('c')
+			list[3].should eq('d')
+			list[4].should eq('e')
+		end
+	end
+
+	describe "#-" do
+		it "removes a list (as array of strings) from another list" do
+			list1 = FilePathList.new(%w{a/b /a/c e/d})
+			list2 = list1 - %w{a/b e/d}
+
+			list2.should have(1).item
+			list2[0].should eq('/a/c')
+		end
+	end
+
+	describe "#<<" do
+		it "adds a new to path to a existing FilePathList" do
+			list1 = FilePathList.new(%w{a/b /c/d})
+			list2 = list1 << "e/f"
+
+			list1.should have(2).items
+			list2.should have(3).items
+
+			list2[0].should eq('a/b')
+			list2[1].should eq('/c/d')
+			list2[2].should eq('e/f')
+		end
+	end
+
 	describe "#*" do
 		describe "calculates the cartesian product between" do
 			it "two FilePathLists" do
@@ -56,10 +133,81 @@ describe FilePathList do
 		end
 	end
 
+	describe "#remove_common_fragments" do
+		it "works on lists of files from the same dir" do
+			paths = %w{a/b/x1 a/b/x2 a/b/x3}
+			list = FilePathList.new(paths).remove_common_fragments
+
+			list.should have(3).items
+			list.should include(*%w{x1 x2 x3})
+		end
+
+		it "works on lists of files from different dirs" do
+			list1 = FilePathList.new(%w{a/b/x1 a/b/c/x2 a/b/d/e/x3})
+			list2 = list1.remove_common_fragments
+
+			list2.should have(3).items
+			list2.should include(*%w{x1 c/x2 d/e/x3})
+		end
+
+		it "works on lists of files with no common fragments" do
+			paths = %w{a/b a/d g/f}
+			list1 = FilePathList.new(paths)
+			list2 = list1.remove_common_fragments
+
+			list1.should == list2
+		end
+
+		it "works on lists that contain duplicates only" do
+			paths = %w{a/b a/b a/b}
+			list1 = FilePathList.new(paths)
+			list2 = list1.remove_common_fragments
+
+			list2.should == FilePathList.new(['.', '.', '.'])
+		end
+	end
+
 	describe "#include?" do
-		it "says that `a/c` in included in [<a/b>, <a/c>, </a/d>]" do
+		it "says that 'a/c' is included in [<a/b>, <a/c>, </a/d>]" do
 			list = FilePathList.new(%w{a/b a/c /a/d})
 			list.should include("a/c")
 		end
 	end
+
+	describe "#to_s" do
+		it "returns files separated by a comma`" do
+			list = FilePathList.new(%w{a/b a/c /a/d})
+			list.to_s.should == "a/b:a/c:/a/d"
+		end
+	end
+
+	describe "#==" do
+		let(:list) { ['a/b', 'c/d', 'e/f'].as_path_list }
+
+		it "compares a FilePathList to another FilePathList" do
+			list2 = FilePathList.new << 'a/b' << 'c/d' << 'e/f'
+			list3 = list2 << 'g/h'
+
+			list.should eq(list2)
+			list.should_not eq(list3)
+		end
+
+		it "compares a FilePathList to an Array of Strings" do
+			list.should eq(%w{a/b c/d e/f})
+			list.should_not eq(%w{a/a b/b c/c})
+		end
+	end
+end
+
+
+describe Array do
+	describe "#as_path_list" do
+		it "generates a FilePathList from an Array" do
+			paths = %w{/a/b c/d /f/g}
+			list = paths.as_path_list
+
+			list.should be_a(FilePathList)
+			list.should include(*paths)
+		end
+	end
 end

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require 'filepath'
 require 'filepathlist'
 
 RSpec.configure do |config|
+	config.filter_run_excluding :broken => true
 end
 
 FIXTURES_DIR = File.join(%w{spec fixtures})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: filepath
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 0.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-15 00:00:00.000000000 Z
+date: 2012-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bones-rspec
-  requirement: &15445240 !ruby/object:Gem::Requirement
+  requirement: &21597840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 2.0.1
   type: :development
   prerelease: false
-  version_requirements: *15445240
+  version_requirements: *21597840
 - !ruby/object:Gem::Dependency
   name: bones
-  requirement: &15444620 !ruby/object:Gem::Requirement
+  requirement: &21595900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: 3.7.3
   type: :development
   prerelease: false
-  version_requirements: *15444620
+  version_requirements: *21595900
 description: ! 'filepath is a small library that helps dealing with files, directories
   and