memfs 0.4.1 → 0.4.2

data/spec/memfs/fake/entry_spec.rb

@@ -62,7 +62,7 @@ module MemFs
         let(:value) { parent }
       end
 
-      describe ".new" do
+      describe '.new' do
         it "sets its default uid to the current user's uid" do
           expect(entry.uid).to eq(Process.euid)
         end
@@ -71,72 +71,72 @@ module MemFs
           expect(entry.gid).to eq(Process.egid)
         end
 
-        it "extract its name from the path passed as argument" do
+        it 'extract its name from the path passed as argument' do
           expect(entry.name).to eq('test')
         end
 
-        it "sets an empty string as name if none is given" do
+        it 'sets an empty string as name if none is given' do
           expect(Entry.new.name).to be_empty
         end
 
-        it "sets the access time" do
+        it 'sets the access time' do
           expect(Entry.new.atime).to be_a(Time)
         end
 
-        it "sets the modification time" do
+        it 'sets the modification time' do
           expect(entry.mtime).to be_a(Time)
         end
 
-        it "sets atime and mtime to the same value" do
+        it 'sets atime and mtime to the same value' do
           expect(entry.atime).to eq(entry.mtime)
         end
       end
 
-      describe "#delete" do
-        it "removes the entry from its parent" do
+      describe '#delete' do
+        it 'removes the entry from its parent' do
           entry.delete
           expect(parent.entries).not_to have_value(entry)
         end
       end
 
       describe '#dereferenced' do
-        it "returns the entry itself" do
+        it 'returns the entry itself' do
           expect(entry.dereferenced).to be(entry)
         end
       end
 
-      describe "#dereferenced_name" do
-        it "returns the entry name" do
+      describe '#dereferenced_name' do
+        it 'returns the entry name' do
           expect(entry.dereferenced_name).to eq('test')
         end
       end
 
-      describe "#dereferenced_path" do
-        it "returns the entry path" do
+      describe '#dereferenced_path' do
+        it 'returns the entry path' do
           expect(entry.dereferenced_path).to eq('/parent/test')
         end
       end
 
       describe '#find' do
-        it "raises an error" do
+        it 'raises an error' do
           expect { entry.find('test') }.to raise_error(Errno::ENOTDIR)
         end
       end
 
-      describe "#dev" do
-        it "returns an integer representing the device on which the entry resides" do
+      describe '#dev' do
+        it 'returns an integer representing the device on which the entry resides' do
           expect(entry.dev).to be_a(Fixnum)
         end
       end
 
-      describe "#ino" do
-        it "Returns the inode number for the entry" do
+      describe '#ino' do
+        it 'Returns the inode number for the entry' do
           expect(entry.ino).to be_a(Fixnum)
         end
       end
 
-      describe "#path" do
-        it "returns the complete path of the entry" do
+      describe '#path' do
+        it 'returns the complete path of the entry' do
           expect(entry.path).to eq('/parent/test')
         end
       end
@@ -147,7 +147,7 @@ module MemFs
         end
       end
 
-      describe "#touch" do
+      describe '#touch' do
         let(:time) { Time.now - 5000 }
 
         before :each do
@@ -155,18 +155,18 @@ module MemFs
           entry.mtime = time
         end
 
-        it "sets the access time to now" do
+        it 'sets the access time to now' do
           entry.touch
           expect(entry.atime).not_to eq(time)
         end
 
-        it "sets the modification time to now" do
+        it 'sets the modification time to now' do
           entry.touch
           expect(entry.mtime).not_to eq(time)
         end
       end
 
-      describe "#type" do
+      describe '#type' do
         it "returns 'unknown" do
           expect(entry.type).to eq('unknown')
         end

data/spec/memfs/fake/file/content_spec.rb

@@ -3,61 +3,60 @@ require 'spec_helper'
 
 module MemFs
   module Fake
-
     describe File::Content do
       subject { File::Content.new }
 
-      describe "#<<" do
-        it "writes the given string to the contained string" do
+      describe '#<<' do
+        it 'writes the given string to the contained string' do
           subject << 'test'
           expect(subject.to_s).to eq('test')
         end
       end
 
-      describe "#initialize" do
-        context "when no argument is given" do
-          it "initialize the contained string to an empty one" do
+      describe '#initialize' do
+        context 'when no argument is given' do
+          it 'initialize the contained string to an empty one' do
             expect(subject.to_s).to eq('')
           end
         end
 
-        context "when an argument is given" do
+        context 'when an argument is given' do
           subject { File::Content.new(base_value) }
 
-          context "when the argument is a string" do
+          context 'when the argument is a string' do
             let(:base_value) { 'test' }
 
-            it "initialize the contained string with the given one" do
+            it 'initialize the contained string with the given one' do
               expect(subject.to_s).to eq('test')
             end
 
-            it "duplicates the original string to prevent modifications on it" do
+            it 'duplicates the original string to prevent modifications on it' do
               expect(subject.to_s).not_to be(base_value)
             end
           end
 
-          context "when the argument is not a string" do
+          context 'when the argument is not a string' do
             let(:base_value) { 42 }
 
-            it "converts it to a string" do
+            it 'converts it to a string' do
               expect(subject.to_s).to eq('42')
             end
           end
         end
       end
 
-      describe "#puts" do
-        it "appends the given string to the contained string" do
+      describe '#puts' do
+        it 'appends the given string to the contained string' do
           subject.puts 'test'
           expect(subject.to_s).to eq("test\n")
         end
 
-        it "appends all given strings to the contained string" do
+        it 'appends all given strings to the contained string' do
           subject.puts 'this', 'is', 'a', 'test'
           expect(subject.to_s).to eq("this\nis\na\ntest\n")
         end
 
-        context "when a line break is present at the end of the given string" do
+        context 'when a line break is present at the end of the given string' do
           it "doesn't add any line break" do
             subject.puts "test\n"
             expect(subject.to_s).not_to eq("test\n\n")
@@ -65,14 +64,14 @@ module MemFs
         end
       end
 
-      describe "#to_s" do
-        context "when the content is empty" do
-          it "returns an empty string" do
+      describe '#to_s' do
+        context 'when the content is empty' do
+          it 'returns an empty string' do
             expect(subject.to_s).to eq('')
           end
         end
 
-        context "when the content is not empty" do
+        context 'when the content is not empty' do
           it "returns the content's string" do
             subject << 'test'
             expect(subject.to_s).to eq('test')
@@ -80,56 +79,56 @@ module MemFs
         end
       end
 
-      describe "#truncate" do
-        subject { File::Content.new('x'*50) }
+      describe '#truncate' do
+        subject { File::Content.new('x' * 50) }
 
-        it "truncates the content to length characters" do
+        it 'truncates the content to length characters' do
           subject.truncate(5)
           expect(subject.length).to eq(5)
         end
       end
 
-      describe "#write" do
-        it "writes the given string in content" do
+      describe '#write' do
+        it 'writes the given string in content' do
           subject.write 'test'
           expect(subject.to_s).to eq('test')
         end
 
-        it "returns the number of bytes written" do
+        it 'returns the number of bytes written' do
           expect(subject.write('test')).to eq(4)
         end
 
-        context "when the argument is not a string" do
-          it "converts it to a string" do
+        context 'when the argument is not a string' do
+          it 'converts it to a string' do
             subject.write 42
             expect(subject.to_s).to eq('42')
           end
         end
 
-        context "when the argument is a non-ascii string" do
-          it "returns the correct number of bytes written" do
+        context 'when the argument is a non-ascii string' do
+          it 'returns the correct number of bytes written' do
             expect(subject.write('é')).to eq(1)
           end
         end
       end
 
-      context "when initialized with a string argument" do
+      context 'when initialized with a string argument' do
         subject { File::Content.new('test') }
 
-        describe "#read" do
-          it "reads +length+ bytes from the contained string" do
+        describe '#read' do
+          it 'reads +length+ bytes from the contained string' do
             expect(subject.read(2)).to eq('te')
           end
 
-          context "when there is nothing else to read" do
-            it "returns nil" do
+          context 'when there is nothing else to read' do
+            it 'returns nil' do
               subject.read 4
               expect(subject.read(1)).to be_nil
             end
           end
 
-          context "when the optional +buffer+ argument is provided" do
-            it "inserts the output in the buffer" do
+          context 'when the optional +buffer+ argument is provided' do
+            it 'inserts the output in the buffer' do
               string = String.new
               subject.read(2, string)
               expect(string).to eq('te')
@@ -137,28 +136,27 @@ module MemFs
           end
         end
 
-        describe "#pos" do
-          context "when the string has not been read" do
-            it "returns 0" do
+        describe '#pos' do
+          context 'when the string has not been read' do
+            it 'returns 0' do
               expect(subject.pos).to eq(0)
             end
           end
 
-          context "when the string has been read" do
-            it "returns the current offset" do
+          context 'when the string has been read' do
+            it 'returns the current offset' do
               subject.read 2
               expect(subject.pos).to eq(2)
             end
           end
         end
 
-        describe "#close" do
-          it "responds to close" do
+        describe '#close' do
+          it 'responds to close' do
             expect(subject).to respond_to(:close)
           end
         end
       end
     end
-
   end
 end

data/spec/memfs/fake/file_spec.rb

@@ -3,51 +3,51 @@ require 'spec_helper'
 module MemFs
   module Fake
     describe File do
-      let(:file) { fs.find!('/test-file') }
+      let(:file) { _fs.find!('/test-file') }
 
       before do
-        fs.touch('/test-file')
+        _fs.touch('/test-file')
       end
 
-      it "stores the modification made on its content" do
+      it 'stores the modification made on its content' do
         file.content << 'test'
-        expect(fs.find!('/test-file').content.to_s).to eq('test')
+        expect(_fs.find!('/test-file').content.to_s).to eq('test')
       end
 
-      describe "#close" do
-        it "sets the file as closed?" do
+      describe '#close' do
+        it 'sets the file as closed?' do
           file.close
           expect(file).to be_closed
         end
       end
 
-      describe "#content" do
-        it "returns the file content" do
+      describe '#content' do
+        it 'returns the file content' do
           expect(file.content).not_to be_nil
         end
 
-        context "when the file is empty" do
-          it "returns an empty string container" do
+        context 'when the file is empty' do
+          it 'returns an empty string container' do
             expect(file.content.to_s).to be_empty
           end
         end
       end
 
-      describe "#type" do
-        context "when the file is a regular file" do
+      describe '#type' do
+        context 'when the file is a regular file' do
           it "returns 'file'" do
             expect(file.type).to eq('file')
           end
         end
 
-        context "when the file is a block device" do
+        context 'when the file is a block device' do
           it "returns 'blockSpecial'" do
             file.block_device = true
             expect(file.type).to eq('blockSpecial')
           end
         end
 
-        context "when the file is a character device" do
+        context 'when the file is a character device' do
           it "returns 'characterSpecial'" do
             file.character_device = true
             expect(file.type).to eq('characterSpecial')

data/spec/memfs/fake/symlink_spec.rb

@@ -5,7 +5,7 @@ module MemFs
     describe Symlink do
       describe '#content' do
         it "returns the target's content" do
-          MemFs::File.open('/test-file', 'w') { |f| f.puts "test" }
+          MemFs::File.open('/test-file', 'w') { |f| f.puts 'test' }
           s = Symlink.new('/test-link', '/test-file')
           expect(s.content).to be(s.dereferenced.content)
         end
@@ -13,53 +13,53 @@ module MemFs
 
       describe '#dereferenced' do
         it "returns the target if it's not a symlink" do
-          fs.touch '/test-file'
-          target = fs.find!('/test-file')
+          _fs.touch '/test-file'
+          target = _fs.find!('/test-file')
 
           s = Symlink.new('/test-link', '/test-file')
 
           expect(s.dereferenced).to eq(target)
         end
 
-        it "returns the last target of the chain" do
-          fs.touch '/test-file'
-          target = fs.find!('/test-file')
+        it 'returns the last target of the chain' do
+          _fs.touch '/test-file'
+          target = _fs.find!('/test-file')
 
-          fs.symlink '/test-file', '/test-link'
+          _fs.symlink '/test-file', '/test-link'
           s = Symlink.new('/test-link2', '/test-link')
 
           expect(s.dereferenced).to eq(target)
         end
       end
 
-      describe "#dereferenced_name" do
+      describe '#dereferenced_name' do
         context "when the symlink's target exists" do
-          it "returns its target name" do
-            fs.touch('/test-file')
+          it 'returns its target name' do
+            _fs.touch('/test-file')
             symlink = Symlink.new('/test-link', '/test-file')
             expect(symlink.dereferenced_name).to eq('test-file')
           end
         end
 
         context "when the symlink's target does not exist" do
-          it "returns its target name" do
+          it 'returns its target name' do
             symlink = Symlink.new('/test-link', '/no-file')
             expect(symlink.dereferenced_name).to eq('no-file')
           end
         end
       end
 
-      describe "#dereferenced_path" do
+      describe '#dereferenced_path' do
         context "when the symlink's target exists" do
-          it "returns its target path" do
-            fs.touch('/test-file')
+          it 'returns its target path' do
+            _fs.touch('/test-file')
             symlink = Symlink.new('/test-link', '/test-file')
             expect(symlink.dereferenced_path).to eq('/test-file')
           end
         end
 
         context "when the symlink's target does not exist" do
-          it "raises an exception" do
+          it 'raises an exception' do
             symlink = Symlink.new('/test-link', '/no-file')
             expect {
               symlink.dereferenced_path
@@ -69,17 +69,17 @@ module MemFs
       end
 
       describe '#find' do
-        let(:file) { fs.find!('/test-dir/test-file') }
+        let(:file) { _fs.find!('/test-dir/test-file') }
 
         before :each do
-          fs.mkdir '/test-dir'
-          fs.touch '/test-dir/test-file'
+          _fs.mkdir '/test-dir'
+          _fs.touch '/test-dir/test-file'
         end
 
         context "when the symlink's target exists" do
           subject { Symlink.new('/test-dir-link', '/test-dir') }
 
-          it "forwards the search to it" do
+          it 'forwards the search to it' do
             entry = subject.find('test-file')
             expect(entry).to eq(file)
           end
@@ -88,7 +88,7 @@ module MemFs
         context "when the symlink's target does not exist" do
           subject { Symlink.new('/test-no-link', '/no-dir') }
 
-          it "returns nil" do
+          it 'returns nil' do
             entry = subject.find('test-file')
             expect(entry).to be_nil
           end
@@ -96,13 +96,13 @@ module MemFs
       end
 
       describe '#target' do
-        it "returns the target of the symlink" do
+        it 'returns the target of the symlink' do
           s = Symlink.new('/test-link', '/test-file')
           expect(s.target).to eq('/test-file')
         end
       end
 
-      describe "#type" do
+      describe '#type' do
         it "returns 'link'" do
           s = Symlink.new('/test-link', '/test-file')
           expect(s.type).to eq('link')