memfs 0.4.1 → 0.4.2

data/spec/memfs/file/stat_spec.rb

@@ -14,20 +14,20 @@ module MemFs
     let(:dir_stat) { File::Stat.new('/test-dir') }
     let(:dereferenced_dir_stat) { File::Stat.new('/test-dir', true) }
 
-    let(:entry) { fs.find!('/test-file') }
+    let(:entry) { _fs.find!('/test-file') }
 
     before :each do
-      fs.mkdir('/test-dir')
-      fs.touch('/test-file')
-      fs.symlink('/test-file', '/test-link')
-      fs.symlink('/test-dir', '/test-dir-link')
-      fs.symlink('/no-file', '/test-no-file-link')
+      _fs.mkdir('/test-dir')
+      _fs.touch('/test-file')
+      _fs.symlink('/test-file', '/test-link')
+      _fs.symlink('/test-dir', '/test-dir-link')
+      _fs.symlink('/no-file', '/test-no-file-link')
     end
 
     describe '.new' do
-      context "when optional dereference argument is set to true" do
-        context "when the last target of the link chain does not exist" do
-          it "raises an exception" do
+      context 'when optional dereference argument is set to true' do
+        context 'when the last target of the link chain does not exist' do
+          it 'raises an exception' do
             expect {
               File::Stat.new('/test-no-file-link', true)
             }.to raise_error(Errno::ENOENT)
@@ -37,24 +37,24 @@ module MemFs
     end
 
     describe '#atime' do
-      let(:time) { Time.now - 500000 }
+      let(:time) { Time.now - 500_000 }
 
-      it "returns the access time of the entry" do
-        entry = fs.find!('/test-file')
+      it 'returns the access time of the entry' do
+        entry = _fs.find!('/test-file')
         entry.atime = time
         expect(file_stat.atime).to eq(time)
       end
 
-      context "when the entry is a symlink" do
-        context "and the optional dereference argument is true" do
-          it "returns the access time of the last target of the link chain" do
+      context 'when the entry is a symlink' do
+        context 'and the optional dereference argument is true' do
+          it 'returns the access time of the last target of the link chain' do
             entry.atime = time
             expect(dereferenced_link_stat.atime).to eq(time)
           end
         end
 
-        context "and the optional dereference argument is false" do
-          it "returns the access time of the symlink itself" do
+        context 'and the optional dereference argument is false' do
+          it 'returns the access time of the symlink itself' do
             entry.atime = time
             expect(link_stat.atime).not_to eq(time)
           end
@@ -62,66 +62,66 @@ module MemFs
       end
     end
 
-    describe "#blksize" do
-      it "returns the block size of the file" do
+    describe '#blksize' do
+      it 'returns the block size of the file' do
         expect(file_stat.blksize).to be(4096)
       end
     end
 
-    describe "#blockdev?" do
-      context "when the file is a block device" do
-        it "returns true" do
-          fs.touch('/block-file')
-          file = fs.find('/block-file')
+    describe '#blockdev?' do
+      context 'when the file is a block device' do
+        it 'returns true' do
+          _fs.touch('/block-file')
+          file = _fs.find('/block-file')
           file.block_device = true
           block_stat = File::Stat.new('/block-file')
-          expect(block_stat.blockdev?).to be_true
+          expect(block_stat.blockdev?).to be true
         end
       end
 
-      context "when the file is not a block device" do
-        it "returns false" do
-          expect(file_stat.blockdev?).to be_false
+      context 'when the file is not a block device' do
+        it 'returns false' do
+          expect(file_stat.blockdev?).to be false
         end
       end
     end
 
-    describe "#chardev?" do
-      context "when the file is a character device" do
-        it "returns true" do
-          fs.touch('/character-file')
-          file = fs.find('/character-file')
+    describe '#chardev?' do
+      context 'when the file is a character device' do
+        it 'returns true' do
+          _fs.touch('/character-file')
+          file = _fs.find('/character-file')
           file.character_device = true
           character_stat = File::Stat.new('/character-file')
-          expect(character_stat.chardev?).to be_true
+          expect(character_stat.chardev?).to be true
         end
       end
 
-      context "when the file is not a character device" do
-        it "returns false" do
-          expect(file_stat.chardev?).to be_false
+      context 'when the file is not a character device' do
+        it 'returns false' do
+          expect(file_stat.chardev?).to be false
         end
       end
     end
 
     describe '#ctime' do
-      let(:time) { Time.now - 500000 }
+      let(:time) { Time.now - 500_000 }
 
-      it "returns the access time of the entry" do
+      it 'returns the access time of the entry' do
         entry.ctime = time
         expect(file_stat.ctime).to eq(time)
       end
 
-      context "when the entry is a symlink" do
-        context "and the optional dereference argument is true" do
-          it "returns the access time of the last target of the link chain" do
+      context 'when the entry is a symlink' do
+        context 'and the optional dereference argument is true' do
+          it 'returns the access time of the last target of the link chain' do
             entry.ctime = time
             expect(dereferenced_link_stat.ctime).to eq(time)
           end
         end
 
-        context "and the optional dereference argument is false" do
-          it "returns the access time of the symlink itself" do
+        context 'and the optional dereference argument is false' do
+          it 'returns the access time of the symlink itself' do
             entry.ctime = time
             expect(link_stat.ctime).not_to eq(time)
           end
@@ -129,64 +129,64 @@ module MemFs
       end
     end
 
-    describe "#dev" do
-      it "returns an integer representing the device on which stat resides" do
+    describe '#dev' do
+      it 'returns an integer representing the device on which stat resides' do
         expect(file_stat.dev).to be_a(Fixnum)
       end
     end
 
     describe '#directory?' do
       context 'when dereference is true' do
-        context "when the entry is a directory" do
-          it "returns true" do
-            expect(dereferenced_dir_stat.directory?).to be_true
+        context 'when the entry is a directory' do
+          it 'returns true' do
+            expect(dereferenced_dir_stat.directory?).to be true
           end
         end
 
-        context "when the entry is not a directory" do
-          it "returns false" do
-            expect(dereferenced_file_stat.directory?).to be_false
+        context 'when the entry is not a directory' do
+          it 'returns false' do
+            expect(dereferenced_file_stat.directory?).to be false
           end
         end
 
-        context "when the entry is a symlink" do
-          context "and the last target of the link chain is a directory" do
-            it "returns true" do
-              expect(dereferenced_dir_link_stat.directory?).to be_true
+        context 'when the entry is a symlink' do
+          context 'and the last target of the link chain is a directory' do
+            it 'returns true' do
+              expect(dereferenced_dir_link_stat.directory?).to be true
             end
           end
 
-          context "and the last target of the link chain is not a directory" do
-            it "returns false" do
-              expect(dereferenced_link_stat.directory?).to be_false
+          context 'and the last target of the link chain is not a directory' do
+            it 'returns false' do
+              expect(dereferenced_link_stat.directory?).to be false
             end
           end
         end
       end
 
       context 'when dereference is false' do
-        context "when the entry is a directory" do
-          it "returns true" do
-            expect(dir_stat.directory?).to be_true
+        context 'when the entry is a directory' do
+          it 'returns true' do
+            expect(dir_stat.directory?).to be true
           end
         end
 
-        context "when the entry is not a directory" do
-          it "returns false" do
-            expect(file_stat.directory?).to be_false
+        context 'when the entry is not a directory' do
+          it 'returns false' do
+            expect(file_stat.directory?).to be false
           end
         end
 
-        context "when the entry is a symlink" do
-          context "and the last target of the link chain is a directory" do
-            it "returns false" do
-              expect(dir_link_stat.directory?).to be_false
+        context 'when the entry is a symlink' do
+          context 'and the last target of the link chain is a directory' do
+            it 'returns false' do
+              expect(dir_link_stat.directory?).to be false
             end
           end
 
-          context "and the last target of the link chain is not a directory" do
-            it "returns false" do
-              expect(link_stat.directory?).to be_false
+          context 'and the last target of the link chain is not a directory' do
+            it 'returns false' do
+              expect(link_stat.directory?).to be false
             end
           end
         end
@@ -194,12 +194,12 @@ module MemFs
     end
 
     describe '#entry' do
-      it "returns the comcerned entry" do
+      it 'returns the comcerned entry' do
         expect(file_stat.entry).to be_a(Fake::File)
       end
     end
 
-    describe "#executable?" do
+    describe '#executable?' do
       let(:access) { 0 }
       let(:gid) { 0 }
       let(:uid) { 0 }
@@ -210,54 +210,54 @@ module MemFs
         entry.gid = gid
       end
 
-      context "when the file is not executable by anyone" do
-        it "return false" do
-          expect(file_stat.executable?).to be_false
+      context 'when the file is not executable by anyone' do
+        it 'return false' do
+          expect(file_stat.executable?).to be false
         end
       end
 
-      context "when the file is user executable" do
+      context 'when the file is user executable' do
         let(:access) { MemFs::Fake::Entry::UEXEC }
 
-        context "and the current user owns the file" do
+        context 'and the current user owns the file' do
           let(:uid) { Process.euid }
 
-          it "returns true" do
-            expect(file_stat.executable?).to be_true
+          it 'returns true' do
+            expect(file_stat.executable?).to be true
           end
         end
       end
 
-      context "when the file is group executable" do
+      context 'when the file is group executable' do
         let(:access) { MemFs::Fake::Entry::GEXEC }
 
-        context "and the current user is part of the owner group" do
+        context 'and the current user is part of the owner group' do
           let(:gid) { Process.egid }
 
-          it "returns true" do
-            expect(file_stat.executable?).to be_true
+          it 'returns true' do
+            expect(file_stat.executable?).to be true
           end
         end
       end
 
-      context "when the file is executable by anyone" do
+      context 'when the file is executable by anyone' do
         let(:access) { MemFs::Fake::Entry::OEXEC }
 
-        context "and the user has no specific right on it" do
-          it "returns true" do
-            expect(file_stat.executable?).to be_true
+        context 'and the user has no specific right on it' do
+          it 'returns true' do
+            expect(file_stat.executable?).to be true
           end
         end
       end
 
-      context "when the file does not exist" do
-        it "returns false" do
-          expect(file_stat.executable?).to be_false
+      context 'when the file does not exist' do
+        it 'returns false' do
+          expect(file_stat.executable?).to be false
         end
       end
     end
 
-    describe "#executable_real?" do
+    describe '#executable_real?' do
       let(:access) { 0 }
       let(:gid) { 0 }
       let(:uid) { 0 }
@@ -268,145 +268,145 @@ module MemFs
         entry.gid = gid
       end
 
-      context "when the file is not executable by anyone" do
-        it "return false" do
-          expect(file_stat.executable_real?).to be_false
+      context 'when the file is not executable by anyone' do
+        it 'return false' do
+          expect(file_stat.executable_real?).to be false
         end
       end
 
-      context "when the file is user executable" do
+      context 'when the file is user executable' do
         let(:access) { MemFs::Fake::Entry::UEXEC }
 
-        context "and the current user owns the file" do
+        context 'and the current user owns the file' do
           let(:uid) { Process.uid }
 
-          it "returns true" do
-            expect(file_stat.executable_real?).to be_true
+          it 'returns true' do
+            expect(file_stat.executable_real?).to be true
           end
         end
       end
 
-      context "when the file is group executable" do
+      context 'when the file is group executable' do
         let(:access) { MemFs::Fake::Entry::GEXEC }
 
-        context "and the current user is part of the owner group" do
+        context 'and the current user is part of the owner group' do
           let(:gid) { Process.gid }
 
-          it "returns true" do
-            expect(file_stat.executable_real?).to be_true
+          it 'returns true' do
+            expect(file_stat.executable_real?).to be true
           end
         end
       end
 
-      context "when the file is executable by anyone" do
+      context 'when the file is executable by anyone' do
         let(:access) { MemFs::Fake::Entry::OEXEC }
 
-        context "and the user has no specific right on it" do
-          it "returns true" do
-            expect(file_stat.executable_real?).to be_true
+        context 'and the user has no specific right on it' do
+          it 'returns true' do
+            expect(file_stat.executable_real?).to be true
           end
         end
       end
 
-      context "when the file does not exist" do
-        it "returns false" do
-          expect(file_stat.executable_real?).to be_false
+      context 'when the file does not exist' do
+        it 'returns false' do
+          expect(file_stat.executable_real?).to be false
         end
       end
     end
 
-    describe "#file?" do
+    describe '#file?' do
       context 'when dereference is true' do
-        context "when the entry is a regular file" do
-          it "returns true" do
-            expect(dereferenced_file_stat.file?).to be_true
+        context 'when the entry is a regular file' do
+          it 'returns true' do
+            expect(dereferenced_file_stat.file?).to be true
           end
         end
 
-        context "when the entry is not a regular file" do
-          it "returns false" do
-            expect(dereferenced_dir_stat.file?).to be_false
+        context 'when the entry is not a regular file' do
+          it 'returns false' do
+            expect(dereferenced_dir_stat.file?).to be false
           end
         end
 
-        context "when the entry is a symlink" do
-          context "and the last target of the link chain is a regular file" do
-            it "returns true" do
-              expect(dereferenced_link_stat.file?).to be_true
+        context 'when the entry is a symlink' do
+          context 'and the last target of the link chain is a regular file' do
+            it 'returns true' do
+              expect(dereferenced_link_stat.file?).to be true
             end
           end
 
-          context "and the last target of the link chain is not a regular file" do
-            it "returns false" do
-              expect(dereferenced_dir_link_stat.file?).to be_false
+          context 'and the last target of the link chain is not a regular file' do
+            it 'returns false' do
+              expect(dereferenced_dir_link_stat.file?).to be false
             end
           end
         end
       end
 
       context 'when dereference is false' do
-        context "when the entry is a regular file" do
-          it "returns true" do
-            expect(file_stat.file?).to be_true
+        context 'when the entry is a regular file' do
+          it 'returns true' do
+            expect(file_stat.file?).to be true
           end
         end
 
-        context "when the entry is not a regular file" do
-          it "returns false" do
-            expect(dir_stat.file?).to be_false
+        context 'when the entry is not a regular file' do
+          it 'returns false' do
+            expect(dir_stat.file?).to be false
           end
         end
 
-        context "when the entry is a symlink" do
-          context "and the last target of the link chain is a regular file" do
-            it "returns false" do
-              expect(link_stat.file?).to be_false
+        context 'when the entry is a symlink' do
+          context 'and the last target of the link chain is a regular file' do
+            it 'returns false' do
+              expect(link_stat.file?).to be false
             end
           end
 
-          context "and the last target of the link chain is not a regular file" do
-            it "returns false" do
-              expect(dir_link_stat.file?).to be_false
+          context 'and the last target of the link chain is not a regular file' do
+            it 'returns false' do
+              expect(dir_link_stat.file?).to be false
             end
           end
         end
       end
     end
 
-    describe "#ftype" do
-      context "when the entry is a regular file" do
+    describe '#ftype' do
+      context 'when the entry is a regular file' do
         it "returns 'file'" do
           expect(file_stat.ftype).to eq('file')
         end
       end
 
-      context "when the entry is a directory" do
+      context 'when the entry is a directory' do
         it "returns 'directory'" do
           expect(dir_stat.ftype).to eq('directory')
         end
       end
 
-      context "when the entry is a block device" do
+      context 'when the entry is a block device' do
         it "returns 'blockSpecial'" do
-          fs.touch('/block-file')
-          file = fs.find('/block-file')
+          _fs.touch('/block-file')
+          file = _fs.find('/block-file')
           file.block_device = true
           block_stat = File::Stat.new('/block-file')
           expect(block_stat.ftype).to eq('blockSpecial')
         end
       end
 
-      context "when the entry is a character device" do
+      context 'when the entry is a character device' do
         it "returns 'characterSpecial'" do
-          fs.touch('/character-file')
-          file = fs.find('/character-file')
+          _fs.touch('/character-file')
+          file = _fs.find('/character-file')
           file.character_device = true
           character_stat = File::Stat.new('/character-file')
           expect(character_stat.ftype).to eq('characterSpecial')
         end
       end
 
-      context "when the entry is a symlink" do
+      context 'when the entry is a symlink' do
         it "returns 'link'" do
           expect(link_stat.ftype).to eq('link')
         end
@@ -414,9 +414,9 @@ module MemFs
 
       # fifo and socket not handled for now
 
-      context "when the entry has no specific type" do
+      context 'when the entry has no specific type' do
         it "returns 'unknown'" do
-          root = fs.find('/')
+          root = _fs.find('/')
           root.add_entry Fake::Entry.new('test-entry')
           entry_stat = File::Stat.new('/test-entry')
           expect(entry_stat.ftype).to eq('unknown')
@@ -424,69 +424,69 @@ module MemFs
       end
     end
 
-    describe "#gid" do
-      it "returns the group id of the named entry" do
-        fs.chown(nil, 42, '/test-file')
+    describe '#gid' do
+      it 'returns the group id of the named entry' do
+        _fs.chown(nil, 42, '/test-file')
         expect(file_stat.gid).to be(42)
       end
     end
 
-    describe "#grpowned?" do
-      context "when the effective user group owns of the file" do
-        it "returns true" do
-          fs.chown(0, Process.egid, '/test-file')
-          expect(file_stat.grpowned?).to be_true
+    describe '#grpowned?' do
+      context 'when the effective user group owns of the file' do
+        it 'returns true' do
+          _fs.chown(0, Process.egid, '/test-file')
+          expect(file_stat.grpowned?).to be true
         end
       end
 
-      context "when the effective user group does not own of the file" do
-        it "returns false" do
-          fs.chown(0, 0, '/test-file')
-          expect(file_stat.grpowned?).to be_false
+      context 'when the effective user group does not own of the file' do
+        it 'returns false' do
+          _fs.chown(0, 0, '/test-file')
+          expect(file_stat.grpowned?).to be false
         end
       end
     end
 
-    describe "#ino" do
-      it "returns the inode number for stat." do
+    describe '#ino' do
+      it 'returns the inode number for stat.' do
         expect(file_stat.ino).to be_a(Fixnum)
       end
     end
 
     describe '#mode' do
-      it "returns an integer representing the permission bits of stat" do
-        fs.chmod(0777, '/test-file')
+      it 'returns an integer representing the permission bits of stat' do
+        _fs.chmod(0777, '/test-file')
         expect(file_stat.mode).to be(0100777)
       end
     end
 
-    describe "#owned?" do
-      context "when the effective user owns of the file" do
-        it "returns true" do
-          fs.chown(Process.euid, 0, '/test-file')
-          expect(file_stat.owned?).to be_true
+    describe '#owned?' do
+      context 'when the effective user owns of the file' do
+        it 'returns true' do
+          _fs.chown(Process.euid, 0, '/test-file')
+          expect(file_stat.owned?).to be true
         end
       end
 
-      context "when the effective user does not own of the file" do
-        it "returns false" do
-          fs.chown(0, 0, '/test-file')
-          expect(file_stat.owned?).to be_false
+      context 'when the effective user does not own of the file' do
+        it 'returns false' do
+          _fs.chown(0, 0, '/test-file')
+          expect(file_stat.owned?).to be false
         end
       end
     end
 
-    describe "#pipe?" do
+    describe '#pipe?' do
       # Pipes are not handled for now
 
-      context "when the file is not a pipe" do
-        it "returns false" do
-          expect(file_stat.pipe?).to be_false
+      context 'when the file is not a pipe' do
+        it 'returns false' do
+          expect(file_stat.pipe?).to be false
         end
       end
     end
 
-    describe "#readable?" do
+    describe '#readable?' do
       let(:access) { 0 }
       let(:gid) { 0 }
       let(:uid) { 0 }
@@ -497,48 +497,48 @@ module MemFs
         entry.gid = gid
       end
 
-      context "when the file is not readable by anyone" do
-        it "return false" do
-          expect(file_stat.readable?).to be_false
+      context 'when the file is not readable by anyone' do
+        it 'return false' do
+          expect(file_stat.readable?).to be false
         end
       end
 
-      context "when the file is user readable" do
+      context 'when the file is user readable' do
         let(:access) { MemFs::Fake::Entry::UREAD }
 
-        context "and the current user owns the file" do
+        context 'and the current user owns the file' do
           let(:uid) { Process.euid }
 
-          it "returns true" do
-            expect(file_stat.readable?).to be_true
+          it 'returns true' do
+            expect(file_stat.readable?).to be true
           end
         end
       end
 
-      context "when the file is group readable" do
+      context 'when the file is group readable' do
         let(:access) { MemFs::Fake::Entry::GREAD }
 
-        context "and the current user is part of the owner group" do
+        context 'and the current user is part of the owner group' do
           let(:gid) { Process.egid }
 
-          it "returns true" do
-            expect(file_stat.readable?).to be_true
+          it 'returns true' do
+            expect(file_stat.readable?).to be true
           end
         end
       end
 
-      context "when the file is readable by anyone" do
+      context 'when the file is readable by anyone' do
         let(:access) { MemFs::Fake::Entry::OREAD }
 
-        context "and the user has no specific right on it" do
-          it "returns true" do
-            expect(file_stat.readable?).to be_true
+        context 'and the user has no specific right on it' do
+          it 'returns true' do
+            expect(file_stat.readable?).to be true
           end
         end
       end
     end
 
-    describe "#readable_real?" do
+    describe '#readable_real?' do
       let(:access) { 0 }
       let(:gid) { 0 }
       let(:uid) { 0 }
@@ -549,174 +549,174 @@ module MemFs
         entry.gid = gid
       end
 
-      context "when the file is not readable by anyone" do
-        it "return false" do
-          expect(file_stat.readable_real?).to be_false
+      context 'when the file is not readable by anyone' do
+        it 'return false' do
+          expect(file_stat.readable_real?).to be false
         end
       end
 
-      context "when the file is user readable" do
+      context 'when the file is user readable' do
         let(:access) { MemFs::Fake::Entry::UREAD }
 
-        context "and the current user owns the file" do
+        context 'and the current user owns the file' do
           let(:uid) { Process.euid }
 
-          it "returns true" do
-            expect(file_stat.readable_real?).to be_true
+          it 'returns true' do
+            expect(file_stat.readable_real?).to be true
           end
         end
       end
 
-      context "when the file is group readable" do
+      context 'when the file is group readable' do
         let(:access) { MemFs::Fake::Entry::GREAD }
 
-        context "and the current user is part of the owner group" do
+        context 'and the current user is part of the owner group' do
           let(:gid) { Process.egid }
 
-          it "returns true" do
-            expect(file_stat.readable_real?).to be_true
+          it 'returns true' do
+            expect(file_stat.readable_real?).to be true
           end
         end
       end
 
-      context "when the file is readable by anyone" do
+      context 'when the file is readable by anyone' do
         let(:access) { MemFs::Fake::Entry::OREAD }
 
-        context "and the user has no specific right on it" do
-          it "returns true" do
-            expect(file_stat.readable_real?).to be_true
+        context 'and the user has no specific right on it' do
+          it 'returns true' do
+            expect(file_stat.readable_real?).to be true
           end
         end
       end
 
-      context "when the file does not exist" do
-        it "returns false" do
-          expect(file_stat.readable_real?).to be_false
+      context 'when the file does not exist' do
+        it 'returns false' do
+          expect(file_stat.readable_real?).to be false
         end
       end
     end
 
-    describe "#setgid?" do
-      context "when the file has the setgid bit set" do
-        it "returns true" do
-          fs.chmod(02000, '/test-file')
-          expect(file_stat.setgid?).to be_true
+    describe '#setgid?' do
+      context 'when the file has the setgid bit set' do
+        it 'returns true' do
+          _fs.chmod(02000, '/test-file')
+          expect(file_stat.setgid?).to be true
         end
       end
 
-      context "when the file does not have the setgid bit set" do
-        it "returns false" do
-          expect(file_stat.setgid?).to be_false
+      context 'when the file does not have the setgid bit set' do
+        it 'returns false' do
+          expect(file_stat.setgid?).to be false
         end
       end
     end
 
-    describe "#setuid?" do
-      context "when the file has the setuid bit set" do
-        it "returns true" do
-          fs.chmod(04000, '/test-file')
-          expect(file_stat.setuid?).to be_true
+    describe '#setuid?' do
+      context 'when the file has the setuid bit set' do
+        it 'returns true' do
+          _fs.chmod(04000, '/test-file')
+          expect(file_stat.setuid?).to be true
         end
       end
 
-      context "when the file does not have the setuid bit set" do
-        it "returns false" do
-          expect(file_stat.setuid?).to be_false
+      context 'when the file does not have the setuid bit set' do
+        it 'returns false' do
+          expect(file_stat.setuid?).to be false
         end
       end
     end
 
-    describe "#socket?" do
+    describe '#socket?' do
       # Sockets are not handled for now
 
-      context "when the file is not a socket" do
-        it "returns false" do
-          expect(file_stat.socket?).to be_false
+      context 'when the file is not a socket' do
+        it 'returns false' do
+          expect(file_stat.socket?).to be false
         end
       end
     end
 
-    describe "#sticky?" do
-      it "returns true if the named file has the sticky bit set" do
-        fs.chmod(01777, '/test-file')
-        expect(file_stat.sticky?).to be_true
+    describe '#sticky?' do
+      it 'returns true if the named file has the sticky bit set' do
+        _fs.chmod(01777, '/test-file')
+        expect(file_stat.sticky?).to be true
       end
 
       it "returns false if the named file hasn't' the sticky bit set" do
-        expect(file_stat.sticky?).to be_false
+        expect(file_stat.sticky?).to be false
       end
     end
 
     describe '#symlink?' do
       context 'when dereference is true' do
-        context "when the entry is a symlink" do
-          it "returns false" do
-            expect(dereferenced_link_stat.symlink?).to be_false
+        context 'when the entry is a symlink' do
+          it 'returns false' do
+            expect(dereferenced_link_stat.symlink?).to be false
           end
         end
 
-        context "when the entry is not a symlink" do
-          it "returns false" do
-            expect(dereferenced_file_stat.symlink?).to be_false
+        context 'when the entry is not a symlink' do
+          it 'returns false' do
+            expect(dereferenced_file_stat.symlink?).to be false
           end
         end
       end
 
       context 'when dereference is false' do
-        context "when the entry is a symlink" do
-          it "returns true" do
-            expect(link_stat.symlink?).to be_true
+        context 'when the entry is a symlink' do
+          it 'returns true' do
+            expect(link_stat.symlink?).to be true
           end
         end
 
-        context "when the entry is not a symlink" do
-          it "returns false" do
-            expect(file_stat.symlink?).to be_false
+        context 'when the entry is not a symlink' do
+          it 'returns false' do
+            expect(file_stat.symlink?).to be false
           end
         end
       end
     end
 
-    describe "#uid" do
-      it "returns the user id of the named entry" do
-        fs.chown(42, nil, '/test-file')
+    describe '#uid' do
+      it 'returns the user id of the named entry' do
+        _fs.chown(42, nil, '/test-file')
         expect(file_stat.uid).to be(42)
       end
     end
 
-    describe "#world_reable?" do
-      context "when +file_name+ is readable by others" do
-        it "returns an integer representing the file permission bits of +file_name+" do
-          fs.chmod(MemFs::Fake::Entry::OREAD, '/test-file')
+    describe '#world_reable?' do
+      context 'when +file_name+ is readable by others' do
+        it 'returns an integer representing the file permission bits of +file_name+' do
+          _fs.chmod(MemFs::Fake::Entry::OREAD, '/test-file')
           expect(file_stat.world_readable?).to eq(MemFs::Fake::Entry::OREAD)
         end
       end
 
-      context "when +file_name+ is not readable by others" do
-        it "returns nil" do
-          fs.chmod(MemFs::Fake::Entry::UREAD, '/test-file')
+      context 'when +file_name+ is not readable by others' do
+        it 'returns nil' do
+          _fs.chmod(MemFs::Fake::Entry::UREAD, '/test-file')
           expect(file_stat.world_readable?).to be_nil
         end
       end
     end
 
-    describe "#world_writable?" do
-      context "when +file_name+ is writable by others" do
-        it "returns an integer representing the file permission bits of +file_name+" do
-          fs.chmod(MemFs::Fake::Entry::OWRITE, '/test-file')
+    describe '#world_writable?' do
+      context 'when +file_name+ is writable by others' do
+        it 'returns an integer representing the file permission bits of +file_name+' do
+          _fs.chmod(MemFs::Fake::Entry::OWRITE, '/test-file')
           expect(file_stat.world_writable?).to eq(MemFs::Fake::Entry::OWRITE)
         end
       end
 
-      context "when +file_name+ is not writable by others" do
-        it "returns nil" do
-          fs.chmod(MemFs::Fake::Entry::UWRITE, '/test-file')
+      context 'when +file_name+ is not writable by others' do
+        it 'returns nil' do
+          _fs.chmod(MemFs::Fake::Entry::UWRITE, '/test-file')
           expect(file_stat.world_writable?).to be_nil
         end
       end
     end
 
-    describe "#writable?" do
+    describe '#writable?' do
       let(:access) { 0 }
       let(:gid) { 0 }
       let(:uid) { 0 }
@@ -727,54 +727,54 @@ module MemFs
         entry.gid = gid
       end
 
-      context "when the file is not executable by anyone" do
-        it "return false" do
-          expect(file_stat.writable?).to be_false
+      context 'when the file is not executable by anyone' do
+        it 'return false' do
+          expect(file_stat.writable?).to be false
         end
       end
 
-      context "when the file is user executable" do
+      context 'when the file is user executable' do
         let(:access) { MemFs::Fake::Entry::UWRITE }
 
-        context "and the current user owns the file" do
+        context 'and the current user owns the file' do
           let(:uid) { Process.euid }
 
-          it "returns true" do
-            expect(file_stat.writable?).to be_true
+          it 'returns true' do
+            expect(file_stat.writable?).to be true
           end
         end
       end
 
-      context "when the file is group executable" do
+      context 'when the file is group executable' do
         let(:access) { MemFs::Fake::Entry::GWRITE }
 
-        context "and the current user is part of the owner group" do
+        context 'and the current user is part of the owner group' do
           let(:gid) { Process.egid }
 
-          it "returns true" do
-            expect(file_stat.writable?).to be_true
+          it 'returns true' do
+            expect(file_stat.writable?).to be true
           end
         end
       end
 
-      context "when the file is executable by anyone" do
+      context 'when the file is executable by anyone' do
         let(:access) { MemFs::Fake::Entry::OWRITE }
 
-        context "and the user has no specific right on it" do
-          it "returns true" do
-            expect(file_stat.writable?).to be_true
+        context 'and the user has no specific right on it' do
+          it 'returns true' do
+            expect(file_stat.writable?).to be true
           end
         end
       end
 
-      context "when the file does not exist" do
-        it "returns false" do
-          expect(file_stat.writable?).to be_false
+      context 'when the file does not exist' do
+        it 'returns false' do
+          expect(file_stat.writable?).to be false
         end
       end
     end
 
-    describe "#writable_real?" do
+    describe '#writable_real?' do
       let(:access) { 0 }
       let(:gid) { 0 }
       let(:uid) { 0 }
@@ -785,67 +785,67 @@ module MemFs
         entry.gid = gid
       end
 
-      context "when the file is not executable by anyone" do
-        it "return false" do
-          expect(file_stat.writable_real?).to be_false
+      context 'when the file is not executable by anyone' do
+        it 'return false' do
+          expect(file_stat.writable_real?).to be false
         end
       end
 
-      context "when the file is user executable" do
+      context 'when the file is user executable' do
         let(:access) { MemFs::Fake::Entry::UWRITE }
 
-        context "and the current user owns the file" do
+        context 'and the current user owns the file' do
           let(:uid) { Process.euid }
 
-          it "returns true" do
-            expect(file_stat.writable_real?).to be_true
+          it 'returns true' do
+            expect(file_stat.writable_real?).to be true
           end
         end
       end
 
-      context "when the file is group executable" do
+      context 'when the file is group executable' do
         let(:access) { MemFs::Fake::Entry::GWRITE }
 
-        context "and the current user is part of the owner group" do
+        context 'and the current user is part of the owner group' do
           let(:gid) { Process.egid }
 
-          it "returns true" do
-            expect(file_stat.writable_real?).to be_true
+          it 'returns true' do
+            expect(file_stat.writable_real?).to be true
           end
         end
       end
 
-      context "when the file is executable by anyone" do
+      context 'when the file is executable by anyone' do
         let(:access) { MemFs::Fake::Entry::OWRITE }
 
-        context "and the user has no specific right on it" do
-          it "returns true" do
-            expect(file_stat.writable_real?).to be_true
+        context 'and the user has no specific right on it' do
+          it 'returns true' do
+            expect(file_stat.writable_real?).to be true
           end
         end
       end
 
-      context "when the file does not exist" do
-        it "returns false" do
-          expect(file_stat.writable_real?).to be_false
+      context 'when the file does not exist' do
+        it 'returns false' do
+          expect(file_stat.writable_real?).to be false
         end
       end
     end
 
-    describe "#zero?" do
-      context "when the file has a zero size" do
-        it "returns true" do
-          expect(file_stat.zero?).to be_true
+    describe '#zero?' do
+      context 'when the file has a zero size' do
+        it 'returns true' do
+          expect(file_stat.zero?).to be true
         end
       end
 
-      context "when the file does not have a zero size" do
+      context 'when the file does not have a zero size' do
         before :each do
-          fs.find!('/test-file').content << 'test'
+          _fs.find!('/test-file').content << 'test'
         end
 
-        it "returns false" do
-          expect(file_stat.zero?).to be_false
+        it 'returns false' do
+          expect(file_stat.zero?).to be false
         end
       end
     end