rfusefs 1.0.2 → 1.0.3

data/lib/fusefs/metadir.rb

@@ -1,7 +1,7 @@
 module FuseFS
 
     # A full in-memory filesystem defined with hashes. It is writable to the
-    # user that mounted it 
+    # user that mounted it
     # may create and edit files within it, as well as the programmer
     # === Usage
     #   root = Metadir.new()
@@ -14,10 +14,10 @@ module FuseFS
     # Because Metadir is fully recursive, you can mount your own or other defined
     # directory structures under it. For example, to mount a dictionary filesystem
     # (see samples/dictfs.rb), use:
-    #   
+    #
     #   root.mkdir("/dict",DictFS.new())
-    # 
-    class MetaDir 
+    #
+    class MetaDir
 
         DEFAULT_FS = FuseDir.new()
 
@@ -66,7 +66,7 @@ module FuseFS
         # Extended attributes
         def xattr(path)
             pathmethod(:xattr,path) do | path |
-               @xattr[path] 
+               @xattr[path]
             end
         end
 

data/lib/fusefs/pathmapper.rb

@@ -13,7 +13,7 @@ module FuseFS
     #
     class PathMapperFS < FuseDir
 
-        # Represents a mappted file or directory
+        # Represents a mapped file or directory
         class MNode
 
             # Merge extended attributes with the ones from the underlying file
@@ -112,10 +112,10 @@ module FuseFS
             end
 
             # Compatibility and convenience method
-            # @param [:pm_real_path,String,Symbol] key 
-            # @return [String] {#real_path} if key == :pm_real_path 
+            # @param [:pm_real_path,String,Symbol] key
+            # @return [String] {#real_path} if key == :pm_real_path
             # @return [MNode] the node representing the file named key
-            # @return [Object] shortcut for {#options}[key] 
+            # @return [Object] shortcut for {#options}[key]
             def[](key)
                 case key
                 when :pm_real_path
@@ -266,7 +266,7 @@ module FuseFS
         # @yieldparam [Hash] filesystem node
         # @yieldreturn [true,false] should this node be deleted
         def cleanup(&block)
-           recursive_cleanup(@root,&block) 
+           recursive_cleanup(@root,&block)
         end
 
 
@@ -379,7 +379,7 @@ module FuseFS
             file.sysseek(offset)
             file.syswrite(buf[0,sz])
         end
-        
+
         # @!visibility private
         def raw_sync(path,datasync,file=nil)
             file = @openfiles[path] unless file
@@ -393,7 +393,7 @@ module FuseFS
         # @!visibility private
         def raw_close(path,file=nil)
             file = @openfiles.delete(path) unless file
-           
+
             if file && !file.closed?
                 begin
                     flags = file.fcntl(Fcntl::F_GETFL) & Fcntl::O_ACCMODE

data/lib/fusefs/sqlitemapper.rb

@@ -15,7 +15,7 @@ module FuseFS
         # Maintains a count of the number of times through the scan loop
         attr_reader :scan_id
 
-        # 
+        #
         #
         # @param [String] db_path Path to Sqlite database
         # @param [String] sql query
@@ -55,7 +55,7 @@ module FuseFS
         end
 
         # FuseFS callback when filesystem is unmounted
-        # 
+        #
         # Stops the database watching threads
         # @api FuseFS
         def unmounted()
@@ -88,6 +88,11 @@ module FuseFS
             cleanup() { |file_node| file_node.options[:sqlite_scan_id] != @scan_id }
         end
 
+        # Rescan on HUP signal
+        def sighup
+          rescan()
+        end
+
         private
 
         def scan_loop()

data/lib/rfusefs.rb

@@ -45,28 +45,14 @@ module FuseFS
     #   end
     #
     def FuseFS.main(argv=ARGV,options=[],option_usage="",device=nil,exec=File.basename($0))
-        options = RFuse.parse_options(argv,*options)
-
-        if options[:mountpoint]
-            begin
-                fs = yield options
-            rescue StandardError => ex
-                puts ex.message
-                puts ex.backtrace.join("\n")
-            end
-
-            puts RFuse.usage(device,exec) if options[:help] || !fs
-            puts "Options:\n"  if options[:help]
-
-            FuseFS.start(fs,*argv) if fs || options[:help] 
-
-            puts option_usage if options[:help]
-        else
-            puts "rfusefs: failed, no mountpoint provided",RFuse.usage(device,exec)
+        RFuse.main(argv,options,option_usage,device,exec) do |options,argv|
+            root = yield options
+            FuseFS.set_root(root)
+            FuseFS.mount_under(*argv)
         end
     end
 
-    # Start the FuseFS root at mountpoint with opts. 
+    # Start the FuseFS root at mountpoint with opts.
     #
     # If not previously set, Signal traps for "TERM" and "INT" are added
     # to exit the filesystem
@@ -77,7 +63,6 @@ module FuseFS
     # @note RFuseFS extension
     # @return [void]
     def FuseFS.start(root,mountpoint,*opts)
-        set_default_traps("TERM","INT") { FuseFS.exit }
         FuseFS.set_root(root)
         begin
             FuseFS.mount_under(mountpoint,*opts)
@@ -88,7 +73,7 @@ module FuseFS
     end
 
     # Forks {FuseFS.start} so you can access your filesystem with ruby File
-    # operations (eg for testing). 
+    # operations (eg for testing).
     # @note This is an *RFuseFS* extension
     # @return [void]
     def FuseFS.mount(root,mountpoint,*opts)
@@ -126,43 +111,40 @@ module FuseFS
         end
     end
 
-    # Set the root virtual directory 
+    # Set the root virtual directory
     # @param root [Object] an object implementing a subset of {FuseFS::API}
     # @return [void]
     def FuseFS.set_root(root)
-        @fs=RFuseFS.new(root)
+        @fs=Fuse::Root.new(root)
     end
 
     # This will cause FuseFS to virtually mount itself under the given path. {set_root} must have
     # been called previously.
     # @param [String] mountpoint an existing directory where the filesystem will be virtually mounted
     # @param [Array<String>] args
+    # @return [Fuse] the mounted fuse filesystem
     #  These are as expected by the "mount" command. Note in particular that the first argument
     #  is expected to be the mount point. For more information, see http://fuse.sourceforge.net
     #  and the manual pages for "mount.fuse"
-    def FuseFS.mount_under(mountpoint, *args)    
-        @fuse = RFuse::FuseDelegator.new(@fs,mountpoint,*args)
+    def FuseFS.mount_under(mountpoint, *args)
+        @fuse = Fuse.new(@fs,mountpoint,*args)
     end
 
-    # This is the main loop waiting on then executing filesystem operations from the
-    # kernel. 
-    #    
+    # This is the main loop waiting on, then executing, filesystem operations from the
+    # kernel.
+    #
     # Note: Running in a separate thread is generally not useful. In particular
-    #       you cannot access your filesystem using ruby File operations.
+    #       you cannot use Ruby File operations to access your filesystem from
+    #       within the ruby process that calls run.
     # @note RFuseFS extension
     def FuseFS.run
-        @fs.mounted()
-        @fuse.loop if @fuse.mounted? 
-    ensure
-        @fs.unmounted()
+        @fuse.run()
     end
 
-    #  Exit the run loop and teardown FUSE   
-    #  Most useful from Signal.trap() or Kernel.at_exit()  
+    #  Exit the run loop and teardown FUSE
+    #  Most useful from Signal.trap() or Kernel.at_exit()
     def FuseFS.exit
-        if @fuse
-            @fuse.exit
-        end
+        @fuse.exit if @fuse
     end
 
     # @return [Fixnum] the calling process uid
@@ -188,15 +170,5 @@ module FuseFS
         #do nothing
     end
 
-    private
-    
-    def self.set_default_traps(*signals,&block)
-        signals.each do |sig|
-            old_proc = Signal.trap(sig,block)
-            unless "DEFAULT".eql?(old_proc)
-                Signal.trap(sig,old_proc)
-            end
-        end
-    end
 end
 

data/lib/rfusefs/version.rb

@@ -1,3 +1,3 @@
 module RFuseFS
-    VERSION="1.0.2"
+    VERSION="1.0.3"
 end

data/rfusefs.gemspec

@@ -20,9 +20,9 @@ Gem::Specification.new do |s|
   s.has_rdoc = 'yard'
   s_extra_rdoc_files = 'History.rdoc'
 
-  s.add_dependency("rfuse", ">= 1.0.5")
+  s.add_dependency("rfuse", "~> 1.1")
   s.add_development_dependency("rake")
-  s.add_development_dependency("rspec")
+  s.add_development_dependency("rspec","~> 3")
   s.add_development_dependency("yard")
   s.add_development_dependency("redcarpet")
   s.add_development_dependency("sqlite3")

data/samples/demo.rb

@@ -6,8 +6,8 @@ require 'fusefs/dirlink'
 include FuseFS
 
 root = MetaDir.new
-root.stats.total_space = 1024*1024
-root.stats.total_nodes = 1024
+root.stats.max_space = 1024*1024
+root.stats.max_nodes = 1024
 root.stats.strict = true
 
 class Counter

data/spec/metadir_spec.rb

@@ -4,361 +4,366 @@ require 'sys/filesystem'
 require 'ffi-xattr'
 
 describe FuseFS::MetaDir do
-  
-  context "in ruby" do
-    
+
+  context 'in ruby' do
+
     before(:each) do
       @metadir = FuseFS::MetaDir.new()
-      @metadir.mkdir("/test")
-      @metadir.mkdir("/test/hello")
-      @metadir.mkdir("/test/hello/emptydir")
-      @metadir.write_to("/test/hello/hello.txt","Hello World!\n")
+      @metadir.mkdir('/test')
+      @metadir.mkdir('/test/hello')
+      @metadir.mkdir('/test/hello/emptydir')
+      @metadir.write_to('/test/hello/hello.txt', "Hello World!\n")
     end
-    
-    context "general directory methods" do
-      it "should list directory contents" do
-        @metadir.contents("/").should =~ [ "test" ]
-        @metadir.contents("/test").should =~ [ "hello" ]
-        @metadir.contents("/test/hello").should =~ ["hello.txt", "emptydir" ]
-      end
-      
-      it "should indicate paths which are/are not directories" do
-        @metadir.directory?("/test").should be_true
-        @metadir.directory?("/test/hello").should be_true
-        @metadir.directory?("/test/hello/hello.txt").should be_false
-        @metadir.directory?("/nodir").should be_false
-        @metadir.directory?("/test/nodir").should be_false
-      end
-      
-      it "should indicate paths which are/are not files" do
-        @metadir.file?("/test").should be_false
-        @metadir.file?("/test/nodir").should be_false
-        @metadir.file?("/test/hello").should be_false
-        @metadir.file?("/test/hello/hello.txt").should be_true
-      end
-      
-      it "should indicate the size of a file" do
-        @metadir.size("/test/hello/hello.txt").should be "Hello World!\n".length
-      end
-
-      it "should report filesystem statistics" do
-          @metadir.statistics("/").should == [ 13, 5, nil, nil ]
+
+    context 'general directory methods' do
+      it 'should list directory contents' do
+        expect(@metadir.contents('/')).to match_array(['test'])
+        expect(@metadir.contents('/test')).to match_array(['hello'])
+        expect(@metadir.contents('/test/hello')).to match_array(['hello.txt', 'emptydir'])
+      end
+
+      it 'should indicate paths which are/are not directories' do
+        expect(@metadir.directory?('/test')).to be_truthy
+        expect(@metadir.directory?('/test/hello')).to be_truthy
+        expect(@metadir.directory?('/test/hello/hello.txt')).to be_falsey
+        expect(@metadir.directory?('/nodir')).to be_falsey
+        expect(@metadir.directory?('/test/nodir')).to be_falsey
+      end
+
+      it 'should indicate paths which are/are not files' do
+        expect(@metadir.file?('/test')).to be_falsey
+        expect(@metadir.file?('/test/nodir')).to be_falsey
+        expect(@metadir.file?('/test/hello')).to be_falsey
+        expect(@metadir.file?('/test/hello/hello.txt')).to be_truthy
+      end
+
+      it 'should indicate the size of a file' do
+        expect(@metadir.size('/test/hello/hello.txt')).to be "Hello World!\n".length
+      end
+
+      it 'should report filesystem statistics' do
+        expect(@metadir.statistics('/')).to eq([13, 5, nil, nil])
       end
     end
-    
-    context "with write access" do
-      
+
+    context 'with write access' do
+
       around(:each) do |example|
-        FuseFS::RFuseFS.context(fuse_context(),&example)
+        FuseFS::Fuse::Root.context(fuse_context(), &example)
       end
-      
+
       before(:each) do
-        FuseFS::reader_uid.should == Process.uid
-        FuseFS::reader_gid.should == Process.gid
-      end
-      
-      
-      it "should allow directory creation" do
-        @metadir.can_mkdir?("/test/otherdir").should be_true
-      end
-      
-      it "should allow file creation and update" do
-        @metadir.can_write?("/test/hello/newfile").should be_true
-        @metadir.can_write?("/test/hello/hello.txt").should be_true
-      end
-      
-      it "should read files" do
-        @metadir.read_file("/test/hello/hello.txt").should == "Hello World!\n"
-      end
-      
-      it "should update existing files" do
-        @metadir.write_to("/test/hello/hello.txt","new contents")
-        @metadir.read_file("/test/hello/hello.txt").should == "new contents"
-      end
-      
-      it "should not allow deletion of non empty directories" do
-        @metadir.can_rmdir?("/test/hello").should be_false
-      end
-      
-      it "should delete directories" do
-        @metadir.rmdir("/test/hello/emptydir")
-        @metadir.contents("/test/hello").should =~ ["hello.txt"]
-      end
-      
-      it "should allow and delete files" do
-        @metadir.can_delete?("/test/hello/hello.txt").should be_true
-        @metadir.delete("/test/hello/hello.txt")
-        @metadir.contents("/test/hello").should =~ ["emptydir"]
-      end
-      
-      it "should move directories at same level" do
-        before = @metadir.contents("/test/hello")
-        @metadir.rename("/test/hello","/test/moved").should be_true
-        @metadir.directory?("/test/moved").should be_true
-        @metadir.contents("/test/moved").should =~ before
-        @metadir.read_file("/test/moved/hello.txt").should == "Hello World!\n"
-      end
-
-      it "should move directories between different paths" do
-        @metadir.mkdir("/test/other")
-        @metadir.mkdir("/test/other/more")
-        before = @metadir.contents("/test/hello")
-        @metadir.rename("/test/hello","/test/other/more/hello").should be_true
-        @metadir.contents("/test/other/more/hello").should =~ before
-        @metadir.read_file("/test/other/more/hello/hello.txt").should == "Hello World!\n"
-      end
-
-      it "should maintain filesystem statistics" do
+        expect(FuseFS::reader_uid).to eq(Process.uid)
+        expect(FuseFS::reader_gid).to eq(Process.gid)
+      end
+
+
+      it 'should allow directory creation' do
+        expect(@metadir.can_mkdir?('/test/otherdir')).to be_truthy
+      end
+
+      it 'should allow file creation and update' do
+        expect(@metadir.can_write?('/test/hello/newfile')).to be_truthy
+        expect(@metadir.can_write?('/test/hello/hello.txt')).to be_truthy
+      end
+
+      it 'should read files' do
+        expect(@metadir.read_file('/test/hello/hello.txt')).to eq("Hello World!\n")
+      end
+
+      it 'should update existing files' do
+        @metadir.write_to('/test/hello/hello.txt', 'new contents')
+        expect(@metadir.read_file('/test/hello/hello.txt')).to eq('new contents')
+      end
+
+      it 'should not allow deletion of non empty directories' do
+        expect(@metadir.can_rmdir?('/test/hello')).to be_falsey
+      end
+
+      it 'should delete directories' do
+        @metadir.rmdir('/test/hello/emptydir')
+        expect(@metadir.contents('/test/hello')).to match_array(['hello.txt'])
+      end
+
+      it 'should allow and delete files' do
+        expect(@metadir.can_delete?('/test/hello/hello.txt')).to be_truthy
+        @metadir.delete('/test/hello/hello.txt')
+        expect(@metadir.contents('/test/hello')).to match_array(['emptydir'])
+      end
+
+      it 'should move directories at same level' do
+        before = @metadir.contents('/test/hello')
+        expect(@metadir.rename('/test/hello', '/test/moved')).to be_truthy
+        expect(@metadir.directory?('/test/moved')).to be_truthy
+        expect(@metadir.contents('/test/moved')).to match_array(before)
+        expect(@metadir.read_file('/test/moved/hello.txt')).to eq("Hello World!\n")
+      end
+
+      it 'should move directories between different paths' do
+        @metadir.mkdir('/test/other')
+        @metadir.mkdir('/test/other/more')
+        before = @metadir.contents('/test/hello')
+        expect(@metadir.rename('/test/hello', '/test/other/more/hello')).to be_truthy
+        expect(@metadir.contents('/test/other/more/hello')).to match_array(before)
+        expect(@metadir.read_file('/test/other/more/hello/hello.txt')).to eq("Hello World!\n")
+      end
+
+      it 'should maintain filesystem statistics' do
         # remove a directory
-        @metadir.rmdir("/test/hello/emptydir")
+        @metadir.rmdir('/test/hello/emptydir')
 
         # replace text for (the only)  existing file
-        @metadir.write_to("/test/hello/hello.txt","new text")
-        
-        @metadir.statistics("/").should == [ 8, 4, nil, nil ]
+        @metadir.write_to('/test/hello/hello.txt', 'new text')
+
+        expect(@metadir.statistics('/')).to eq([8, 4, nil, nil])
       end
     end
-    
-    context "with readonly access" do
+
+    context 'with readonly access' do
       around(:each) do |example|
         #Simulate a different userid..
-        FuseFS::RFuseFS.context(fuse_context(-1,-1),&example)
+        FuseFS::Fuse::Root.context(fuse_context(-1, -1), &example)
       end
-      
+
       before(:each) do
-        FuseFS::reader_uid.should_not == Process.uid
-        FuseFS::reader_gid.should_not == Process.gid
-      end
-      
-      it "should not allow directory creation" do
-        @metadir.can_mkdir?("/test/anydir").should be_false
-        @metadir.can_mkdir?("/test/hello/otherdir").should be_false
-      end
-      
-      it "should not allow file creation or write access" do
-        @metadir.can_write?("/test/hello/hello.txt").should be_false
-        @metadir.can_write?("/test/hello/newfile").should be_false
-      end
-      
-      it "should not allow file deletion" do
-        @metadir.can_delete?("/test/hello/hello.txt").should be_false
-      end
-      
-      it "should not allow directory deletion" do
-        @metadir.can_rmdir?("/test/emptydir").should be_false
-      end
-      
-      it "should not allow directory renames" do
-        @metadir.rename("/test/emptydir","/test/otherdir").should be_false
+        expect(FuseFS::reader_uid).not_to eq(Process.uid)
+        expect(FuseFS::reader_gid).not_to eq(Process.gid)
+      end
+
+      it 'should not allow directory creation' do
+        expect(@metadir.can_mkdir?('/test/anydir')).to be_falsey
+        expect(@metadir.can_mkdir?('/test/hello/otherdir')).to be_falsey
+      end
+
+      it 'should not allow file creation or write access' do
+        expect(@metadir.can_write?('/test/hello/hello.txt')).to be_falsey
+        expect(@metadir.can_write?('/test/hello/newfile')).to be_falsey
+      end
+
+      it 'should not allow file deletion' do
+        expect(@metadir.can_delete?('/test/hello/hello.txt')).to be_falsey
+      end
+
+      it 'should not allow directory deletion' do
+        expect(@metadir.can_rmdir?('/test/emptydir')).to be_falsey
+      end
+
+      it 'should not allow directory renames' do
+        expect(@metadir.rename('/test/emptydir', '/test/otherdir')).to be_falsey
         #TODO and make sure it doesn't rename
       end
 
-      it "should not allow file renames" do
-        @metadir.rename("test/hello/hello.txt","test/hello.txt2").should be_false
+      it 'should not allow file renames' do
+        expect(@metadir.rename('test/hello/hello.txt', 'test/hello.txt2')).to be_falsey
         #TODO and make sure it doesn't rename
       end
     end
-    
-    context "with subdirectory containing another FuseFS" do
+
+    context 'with subdirectory containing another FuseFS' do
       around(:each) do |example|
-        FuseFS::RFuseFS.context(fuse_context(),&example)
+        FuseFS::Fuse::Root.context(fuse_context(), &example)
       end
 
       before(:each) do
-        @fusefs = mock("mock_fusefs")
-        @metadir.mkdir("/test")
-        @metadir.mkdir("/test/fusefs",@fusefs)
+        @fusefs = double('mock_fusefs')
+        @metadir.mkdir('/test')
+        @metadir.mkdir('/test/fusefs', @fusefs)
       end
 
-      api_methods = [:directory?, :file?, :contents, :executable?, :size, :times, :read_file, :can_write?,  :can_delete?, :delete, :can_mkdir?, :can_rmdir?, :rmdir, :touch, :raw_open, :raw_truncate, :raw_read, :raw_write, :raw_close]
+      api_methods = [:directory?, :file?, :contents, :executable?, :size, :times, :read_file, :can_write?, :can_delete?, :delete, :can_mkdir?, :can_rmdir?, :rmdir, :touch, :raw_open, :raw_truncate, :raw_read, :raw_write, :raw_close]
       api_methods.each do |method|
-          it "should pass on #{method}" do
-             arity = FuseFS::FuseDir.instance_method(method).arity().abs - 1
-             args = Array.new(arity) { |i| i }
-             @fusefs.should_receive(method).with("/path/to/file",*args).and_return("anything")
-             @metadir.send(method,"/test/fusefs/path/to/file",*args)
-          end
+        it "should pass on #{method}" do
+          arity = FuseFS::FuseDir.instance_method(method).arity().abs - 1
+          args = Array.new(arity) { |i| i }
+          expect(@fusefs).to receive(method).with('/path/to/file', *args).and_return('anything')
+          @metadir.send(method, '/test/fusefs/path/to/file', *args)
+        end
       end
-     
-      it "should pass on :write_to" do
-         @fusefs.should_receive(:write_to).with("/path/to/file","new contents\n")
-         @metadir.write_to("/test/fusefs/path/to/file","new contents\n")
+
+      it 'should pass on :write_to' do
+        expect(@fusefs).to receive(:write_to).with('/path/to/file', "new contents\n")
+        @metadir.write_to('/test/fusefs/path/to/file', "new contents\n")
       end
 
-      it "should pass on :mkdir" do
-         @fusefs.should_receive(:mkdir).with("/path/to/file",nil).once().and_raise(ArgumentError)
-         @fusefs.should_receive(:mkdir).with("/path/to/file").once().and_return("true")
-         @metadir.mkdir("/test/fusefs/path/to/file")
+      it 'should pass on :mkdir' do
+        expect(@fusefs).to receive(:mkdir).with('/path/to/file', nil).once().and_raise(ArgumentError)
+        expect(@fusefs).to receive(:mkdir).with('/path/to/file').once().and_return('true')
+        @metadir.mkdir('/test/fusefs/path/to/file')
       end
 
-      it "should rename within same directory" do
-        @fusefs.should_receive(:rename).with("/oldfile","/newfile")
-        @metadir.rename("/test/fusefs/oldfile","/test/fusefs/newfile")
+      it 'should rename within same directory' do
+        expect(@fusefs).to receive(:rename).with('/oldfile', '/newfile')
+        @metadir.rename('/test/fusefs/oldfile', '/test/fusefs/newfile')
       end
 
-      it "should pass rename down common directories" do
-        @fusefs.should_receive(:rename).with("/path/to/file" ,"/new/path/to/file")
-        @metadir.rename("/test/fusefs/path/to/file","/test/fusefs/new/path/to/file")
+      it 'should pass rename down common directories' do
+        expect(@fusefs).to receive(:rename).with('/path/to/file', '/new/path/to/file')
+        @metadir.rename('/test/fusefs/path/to/file', '/test/fusefs/new/path/to/file')
       end
 
-      it "should rename across directories if from_path is a FuseFS object that accepts extended rename" do
-        @fusefs.should_receive(:rename).with("/path/to/file","/nonfusepath",
-                    an_instance_of(FuseFS::MetaDir)) do | myPath, extPath, extFS |
-                        extFS.write_to(extPath,"look Mum, no hands!")
-                    end
+      it 'should rename across directories if from_path is a FuseFS object that accepts extended rename' do
+        expect(@fusefs).to receive(:rename).with('/path/to/file', '/nonfusepath',
+                                                 an_instance_of(FuseFS::MetaDir)) do |myPath, extPath, extFS|
+          extFS.write_to(extPath, 'look Mum, no hands!')
+        end
 
-        @metadir.rename("/test/fusefs/path/to/file","/test/nonfusepath").should be_true
-        @metadir.read_file("/test/nonfusepath").should == "look Mum, no hands!"
+        expect(@metadir.rename('/test/fusefs/path/to/file', '/test/nonfusepath')).to be_truthy
+        expect(@metadir.read_file('/test/nonfusepath')).to eq('look Mum, no hands!')
       end
 
-      it "should quietly return false if from_path is a FuseFS object that does not accept extended rename" do
-        @fusefs.should_receive(:rename).
-            with("/path/to/file","/nonfusepath",an_instance_of(FuseFS::MetaDir)).
-                and_raise(ArgumentError)
-        @metadir.rename("/test/fusefs/path/to/file","/test/nonfusepath").should be_false
+      it 'should quietly return false if from_path is a FuseFS object that does not accept extended rename' do
+        expect(@fusefs).to receive(:rename).
+                               with('/path/to/file', '/nonfusepath', an_instance_of(FuseFS::MetaDir)).
+                               and_raise(ArgumentError)
+        expect(@metadir.rename('/test/fusefs/path/to/file', '/test/nonfusepath')).to be_falsey
 
       end
 
-      it "should not attempt rename file unless :can_write? the destination" do
-        @fusefs.should_receive(:can_write?).with("/newpath/to/file").and_return(false)
-        @metadir.write_to("/test/aFile","some contents")
-        @metadir.rename("/test/aFile","/test/fusefs/newpath/to/file").should be_false
+      it 'should not attempt rename file unless :can_write? the destination' do
+        expect(@fusefs).to receive(:can_write?).with('/newpath/to/file').and_return(false)
+        @metadir.write_to('/test/aFile', 'some contents')
+        expect(@metadir.rename('/test/aFile', '/test/fusefs/newpath/to/file')).to be_falsey
       end
 
-      it "should not attempt rename directory unless :can_mkdir? the destination" do
-        @fusefs.should_receive(:can_mkdir?).with("/newpath/to/dir").and_return(false)
-        @metadir.mkdir("/test/aDir","some contents")
-        @metadir.rename("/test/aDir","/test/fusefs/newpath/to/dir").should be_false
+      it 'should not attempt rename directory unless :can_mkdir? the destination' do
+        expect(@fusefs).to receive(:can_mkdir?).with('/newpath/to/dir').and_return(false)
+        @metadir.mkdir('/test/aDir', 'some contents')
+        expect(@metadir.rename('/test/aDir', '/test/fusefs/newpath/to/dir')).to be_falsey
       end
 
-      it "should pass on #statistics" do
-        @fusefs.should_receive(:statistics).with("/path/to/file")
+      it 'should pass on #statistics' do
+        expect(@fusefs).to receive(:statistics).with('/path/to/file')
 
-        @metadir.statistics("test/fusefs/path/to/file")
+        @metadir.statistics('test/fusefs/path/to/file')
       end
 
-      it "should pass on #statistics for root" do
-        @fusefs.should_receive(:statistics).with("/")
+      it 'should pass on #statistics for root' do
+        expect(@fusefs).to receive(:statistics).with('/')
 
-        @metadir.statistics("test/fusefs")
+        @metadir.statistics('test/fusefs')
       end
     end
-    
+
   end
-  context "in a mounted FUSE filesystem" do
-
-    let(:mountpoint) { Pathname.new(Dir.mktmpdir(["rfusefs","metadir"])) }
-    let(:metadir) { FuseFS::MetaDir.new() }
-    let(:testdir) { mountpoint + "test" }
-    let(:testfile) { testdir + "hello.txt" }
-
-	before(:all) do
-        metadir.mkdir("/test")
-        metadir.write_to("/test/hello.txt","Hello World!\n")
-        metadir.xattr("/test/hello.txt")["user.test"] = "an extended attribute"
-        metadir.xattr("/test")["user.test"] = "a dir attribute"
-		FuseFS.mount(metadir,mountpoint)
-		#Give FUSE some time to get started 
-		sleep(0.5)
-	end
-	
-	after(:all) do
-		FuseFS.unmount(mountpoint)
-        sleep(0.5)
-        FileUtils.rm_r(mountpoint)
-	end
-	
-    it "should list directory contents" do
-		testdir.entries().should =~ pathnames(".","..","hello.txt")
+  context 'in a mounted FUSE filesystem' do
+
+    before(:all) do
+      metadir = FuseFS::MetaDir.new()
+      mountpoint = Pathname.new(Dir.mktmpdir(['rfusefs', 'metadir']))
+
+      metadir.mkdir('/test')
+      metadir.write_to('/test/hello.txt', "Hello World!\n")
+      metadir.xattr('/test/hello.txt')['user.test'] = 'an extended attribute'
+      metadir.xattr('/test')['user.test'] = 'a dir attribute'
+      FuseFS.mount(metadir, mountpoint)
+      #Give FUSE some time to get started
+      sleep(0.5)
+      @metadir = metadir
+      @mountpoint = mountpoint
     end
 
-    it "should read files" do
-        testfile.file?.should be_true
-		testfile.read().should == "Hello World!\n"
+    after(:all) do
+      FuseFS.unmount(@mountpoint)
+      sleep(0.5)
+      FileUtils.rm_r(@mountpoint)
     end
 
-    it "should read and write extended attributes from files" do
-        x = Xattr.new(testfile.to_s)
-        x["user.test"].should == "an extended attribute"
+    let(:testdir) { mountpoint + 'test' }
+    let(:testfile) { testdir + 'hello.txt' }
+    let(:metadir) { @metadir}
+    let(:mountpoint) { @mountpoint }
+
+    it 'should list directory contents' do
+      expect(testdir.entries()).to match_array(pathnames('.', '..', 'hello.txt'))
+    end
 
-        x["user.new"] = "new"
-        
-        Xattr.new(testfile.to_s)["user.new"].should == "new"
+    it 'should read files' do
+      expect(testfile.file?).to be_truthy
+      expect(testfile.read()).to eq("Hello World!\n")
     end
 
-    it "should write extended attributes for directories" do
-        x = Xattr.new(testdir.to_s)
+    it 'should read and write extended attributes from files' do
+      x = Xattr.new(testfile.to_s)
+      expect(x['user.test']).to eq('an extended attribute')
 
-        x["user.test"].should == "a dir attribute"
-        x["user.new"] = "new dir"
-        
-        Xattr.new(testdir.to_s)["user.new"].should == "new dir"
+      x['user.new'] = 'new'
+
+      expect(Xattr.new(testfile.to_s)['user.new']).to eq('new')
     end
 
+    it 'should write extended attributes for directories' do
+      x = Xattr.new(testdir.to_s)
+
+      expect(x['user.test']).to eq('a dir attribute')
+      x['user.new'] = 'new dir'
 
-    it "should create directories" do
-        newdir = testdir + "newdir"
-        newdir.mkdir()
-        newdir.directory?.should be_true
-        testdir.entries().should =~ pathnames(".","..","hello.txt","newdir")
+      expect(Xattr.new(testdir.to_s)['user.new']).to eq('new dir')
     end
 
-    it "should create files" do
-        newfile = testdir + "newfile"
-        newfile.open("w") do |file|
-            file << "A new file\n"
-        end
-        newfile.read.should == "A new file\n"
+
+    it 'should create directories' do
+      newdir = testdir + 'newdir'
+      newdir.mkdir()
+      expect(newdir.directory?).to be_truthy
+      expect(testdir.entries()).to match_array(pathnames('.', '..', 'hello.txt', 'newdir'))
     end
 
-    it "should move directories" do
-        fromdir = testdir + "fromdir"
-        fromdir.mkdir()
-        subfile = fromdir + "afile"
-        subfile.open("w") do |file|
-           file << "testfile\n"
-        end
+    it 'should create files' do
+      newfile = testdir + 'newfile'
+      newfile.open('w') do |file|
+        file << "A new file\n"
+      end
+      expect(newfile.read).to eq("A new file\n")
+    end
+
+    it 'should move directories' do
+      fromdir = testdir + 'fromdir'
+      fromdir.mkdir()
+      subfile = fromdir + 'afile'
+      subfile.open('w') do |file|
+        file << "testfile\n"
+      end
+
+      movedir = (mountpoint + 'movedir')
+      expect(movedir.directory?).to be_falsey
+      fromdir.rename(movedir)
+      expect(movedir.directory?).to be_truthy
 
-        movedir = (mountpoint + "movedir")
-        movedir.directory?.should be_false
-        fromdir.rename(movedir)
-        movedir.directory?.should be_true
-        
-        subfile = movedir + "afile"
-        subfile.file?.should be_true
-        subfile.read.should == "testfile\n"
+      subfile = movedir + 'afile'
+      expect(subfile.file?).to be_truthy
+      expect(subfile.read).to eq("testfile\n")
     end
 
-    it "should move files" do
-        movefile = (mountpoint + "moved.txt")
-        movefile.file?.should be_false
-        testfile.should be_true
-        testfile.rename(movefile)
-        movefile.read.should == "Hello World!\n"
+    it 'should move files' do
+      movefile = (mountpoint + 'moved.txt')
+      expect(movefile.file?).to be_falsey
+      expect(testfile).to be_truthy
+      testfile.rename(movefile)
+      expect(movefile.read).to eq("Hello World!\n")
     end
 
 
-    it "should report filesystem statistics" do
-        bigfile = testdir + "bigfile"
-        bigfile.open("w") do |file|
-            file << ("x" * 2048)
-        end
-      
-        statfs = Sys::Filesystem.stat(mountpoint.to_s)
+    it 'should report filesystem statistics' do
+      bigfile = testdir + 'bigfile'
+      bigfile.open('w') do |file|
+        file << ('x' * 2048)
+      end
 
-        # These are fixed
-        statfs.block_size.should == 1024
-        statfs.fragment_size.should == 1024
+      statfs = Sys::Filesystem.stat(mountpoint.to_s)
 
-        # These are dependant on the tests above creating files/directories
-        statfs.files.should == 8
-        statfs.files_available == 8
+      # These are fixed
+      expect(statfs.block_size).to eq(1024)
+      expect(statfs.fragment_size).to eq(1024)
 
-        # assume test are less than 1 block, so dependant on bigfile above
-        statfs.blocks.should == 2
-        statfs.blocks_available.should == 0
-        statfs.blocks_free.should == 0
+      # These are dependant on the tests above creating files/directories
+      expect(statfs.files).to eq(8)
+      statfs.files_available == 8
+
+      # assume test are less than 1 block, so dependant on bigfile above
+      expect(statfs.blocks).to eq(2)
+      expect(statfs.blocks_available).to eq(0)
+      expect(statfs.blocks_free).to eq(0)
     end
   end
-  
+
 end