rfusefs 1.0.2.RC0 → 1.0.2.RC1

data/spec/pathmapper_spec.rb

@@ -3,40 +3,47 @@ require "spec_helper"
 require "fusefs/pathmapper"
 require 'tmpdir'
 require 'pathname'
+require 'sys/filesystem'
+require 'ffi-xattr/extensions'
 
 class PMFixture
     attr_reader :tmpdir
 
     def initialize()
-        @tmpdir = Pathname.new(Dir.mktmpdir("rfusefs_pathmapper"))
-        pathmap(@tmpdir + "hello.txt","/textfiles/hello")
-        pathmap(@tmpdir + "mysong.mp3","/artist/album/mysong.mp3")
-        pathmap(@tmpdir + "apicture.jpeg","/pictures/201103/apicture.jpg")
+        #Note - these names define the filesystem stats so if you change them those tests will break
     end
 
-    def pathmap(real_file,mapped_path)
-        File.open(real_file.to_s,"w") do |f|
-            f << mapped_path
+    def tmpdir
+        @tmpdir ||= Pathname.new(Dir.mktmpdir("rfusefs_pathmapper"))
+    end
+
+    def real_path(file)
+        tmpdir + file
+    end
+
+    def pathmap(file,mapped_path, content = mapped_path, options = {})
+        real_file = tmpdir + file
+        real_file.open("w") do |f|
+            f << content
         end
+        fs.map_file(real_file,mapped_path,options)
     end
 
     def fs
-        @fs ||= FuseFS::PathMapperFS.create(@tmpdir) do |file|
-            File.file?(file) ? IO.read(file.to_s) : nil
-        end
+        @fs ||= FuseFS::PathMapperFS.new()
     end
 
     def mount()
         return @mountpoint if @mountpoint
         @mountpoint = Pathname.new(Dir.mktmpdir("rfusefs_pathmapper_mnt"))
         FuseFS.mount(fs,@mountpoint)
-        sleep(0.5) 
+        sleep(0.5)
         @mountpoint
     end
 
     def cleanup
         if @mountpoint
-            FuseFS.unmount(@mountpoint) 
+            FuseFS.unmount(@mountpoint)
             sleep(0.5)
             FileUtils.rmdir(@mountpoint)
         end
@@ -46,134 +53,333 @@ end
 
 
 describe FuseFS::PathMapperFS do
-    before(:each) do 
-        @fixture = PMFixture.new
-        @tmpdir = @fixture.tmpdir
-        @pathmapFS = @fixture.fs
+
+    let(:fixture) { PMFixture.new() }
+    let(:pathmap_fs) { fixture.fs }
+    let(:tmpdir) { fixture.tmpdir }
+    let(:mountpoint) { fixture.mount }
+
+    before(:each) do
+        fixture.pathmap("hello.txt","/textfiles/hello")
+        fixture.pathmap("mysong.mp3","/artist/album/mysong.mp3")
+        fixture.pathmap("apicture.jpeg","/pictures/201103/apicture.jpg")
     end
 
     after(:each) do
-        @fixture.cleanup
+        fixture.cleanup
     end
 
     context "fusefs api" do
 
         it "maps files and directories" do
-            @pathmapFS.directory?("/").should be_true
-            @pathmapFS.directory?("/textfiles").should be_true
-            @pathmapFS.directory?("/pictures/201103").should be_true
-            @pathmapFS.file?("/textfiles/hello").should be_true
-            @pathmapFS.directory?("/textfiles/hello").should be_false
-            @pathmapFS.file?("/artist/album/mysong.mp3").should be_true
-            @pathmapFS.directory?("/artist/album/mysong.mp3").should be_false
-            @pathmapFS.file?("/some/unknown/path").should be_false
-            @pathmapFS.directory?("/some/unknown/path").should be_false
+            pathmap_fs.directory?("/").should be_true
+            pathmap_fs.directory?("/textfiles").should be_true
+            pathmap_fs.directory?("/pictures/201103").should be_true
+            pathmap_fs.file?("/textfiles/hello").should be_true
+            pathmap_fs.directory?("/textfiles/hello").should be_false
+            pathmap_fs.file?("/artist/album/mysong.mp3").should be_true
+            pathmap_fs.directory?("/artist/album/mysong.mp3").should be_false
+            pathmap_fs.file?("/some/unknown/path").should be_false
+            pathmap_fs.directory?("/some/unknown/path").should be_false
         end
 
         it "lists the mapped contents of directories" do
-            @pathmapFS.contents("/").should =~ [ "textfiles","artist","pictures" ]
-            @pathmapFS.contents("/artist").should =~ [ "album" ]
-            @pathmapFS.contents("/textfiles").should =~ [ "hello" ]
+            pathmap_fs.contents("/").should =~ [ "textfiles","artist","pictures" ]
+            pathmap_fs.contents("/artist").should =~ [ "album" ]
+            pathmap_fs.contents("/textfiles").should =~ [ "hello" ]
         end
 
         it "reports the size of a file" do
-            @pathmapFS.size("/textfiles/hello").should == 16
+            pathmap_fs.size("/textfiles/hello").should == 16
         end
 
         it "reads the contents of a file" do
-            @pathmapFS.read_file("/textfiles/hello").should == "/textfiles/hello"
+            pathmap_fs.read_file("/textfiles/hello").should == "/textfiles/hello"
         end
 
         it "does not allow writes" do
-            @pathmapFS.can_write?("/textfiles/hello").should be_false
+            pathmap_fs.can_write?("/textfiles/hello").should be_false
         end
 
         it "reports the atime,mtime and ctime of the mapped file" do
-            atime,mtime,ctime = @pathmapFS.times("/pictures/201103/apicture.jpg")
-            picture = @tmpdir + "apicture.jpeg"
+            atime,mtime,ctime = pathmap_fs.times("/pictures/201103/apicture.jpg")
+            picture = tmpdir + "apicture.jpeg"
             atime.should == picture.atime()
             mtime.should == picture.mtime()
             ctime.should == picture.ctime()
         end
 
-        it "reports filesystem statistics"
+        context "with extended attributes" do
+            let (:hello_realpath) {fixture.real_path("hello.txt")}
+            let (:hello_xattr) { Xattr.new(hello_realpath) }
+            let (:pm_file_xattr) { pathmap_fs.xattr("/textfiles/hello") }
+            let (:pm_dir_xattr) { pathmap_fs.xattr("/textfiles") }
+
+            before(:each) do
+                # attribute set on real file
+                hello_xattr["user.file_attr"] = "fileValue"
+
+                # additional attribute on file
+                pathmap_fs.node("/textfiles/hello")[:xattr] =
+                    { "user.add_attr" => "addValue" }
+
+                # additional attribute on directory
+                pathmap_fs.node("/textfiles")[:xattr] =
+                    { "user.dir_attr" => "dirValue" }
+
+            end
+
+            it "should list extended attributes" do
+                pm_file_xattr.keys.should include("user.file_attr")
+                pm_file_xattr.keys.should include("user.add_attr")
+                pm_file_xattr.keys.size.should == 2
+            end
+
+            it "should read extended attributes from underlying file" do
+                pm_file_xattr["user.file_attr"].should == "fileValue"
+            end
+
+            it "should read additional attributes" do
+                # make sure additional attributes are not on the real file
+                hello_xattr.list.should_not include("user.add_attr")
+
+                pm_file_xattr["user.add_attr"].should == "addValue"
+            end
+
+            it "should write extended attributes to the underlying file" do
+                pm_file_xattr["user.file_attr"] = "written"
+                hello_xattr["user.file_attr"].should == "written"
+            end
+
+            it "should remove extended attributes from the underlying file" do
+                pm_file_xattr.delete("user.file_attr")
+                hello_xattr.list.should_not include("user.file_attr")
+            end
+
+            it "raise EACCES when writing to additional attributes" do
+                lambda {pm_file_xattr["user.add_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+            end
+
+            it "raise EACCES when removing additional attributes" do
+                lambda {pm_file_xattr.delete("user.add_attr")}.should raise_error(Errno::EACCES)
+            end
+
+            it "should list additional attributes from virtual directories" do
+                pm_dir_xattr.keys.should include("user.dir_attr")
+                pm_dir_xattr.keys.size.should == 1
+            end
+
+            it "should read additional attributes from virtual directories" do
+                pm_dir_xattr["user.dir_attr"].should == "dirValue"
+
+            end
+
+            it "should raise EACCES when writing additional attributes on virtual directories" do
+                lambda {pm_dir_xattr["user.dir_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+            end
+
+            it "should raise EACCES when deleting additional attributes on virtual directories" do
+                lambda {pm_dir_xattr.delete("user.dir_attr")}.should raise_error(Errno::EACCES)
+            end
+
+            it "should accept xattr as option to #map_file" do
+                fixture.pathmap("mapped_xattr.txt","/textfiles/mapped_xattr","content",
+                                 :xattr => { "user.xattr" => "map_file" })
+                pathmap_fs.xattr("/textfiles/mapped_xattr")["user.xattr"].should == "map_file"
+            end
+        end
+
+        context "filesystem statistics" do
+
+            it "reports accumulated stats about mapped files" do
+                used_space, used_nodes, max_space, max_nodes = pathmap_fs.statistics("/pictures/201103/apicture.jpg")
+                used_space.should == 69
+                used_nodes.should == 9
+                max_space.should be_nil
+                max_nodes.should be_nil
+            end
+        end
 
         context "writing to a pathmapped FS" do
             before(:each) do
-                @pathmapFS.allow_write=true
-                @pathmapFS.write_to("textfiles/hello","updated content")
+                pathmap_fs.allow_write=true
+                pathmap_fs.write_to("textfiles/hello","updated content")
             end
 
             it "updates the contents of the real file" do
-                hello_path = @tmpdir + "hello.txt"
+                hello_path = tmpdir + "hello.txt"
                 hello_path.read.should == "updated content"
             end
 
             it "updates the contents of the mapped file" do
-                @pathmapFS.read_file("textfiles/hello").should == "updated content"
+                pathmap_fs.read_file("textfiles/hello").should == "updated content"
             end
 
             it "changes the reported file size" do
-                @pathmapFS.size("textfiles/hello").should == 15
+                pathmap_fs.size("textfiles/hello").should == 15
             end
 
-            it "changes the filesystem statistics"
+            it "changes the filesystem statistics" do
+                used_space, used_nodes, max_space, max_nodes = pathmap_fs.statistics("/pictures/201103/apicture.jpg")
+                used_space.should == 68
+            end
         end
 
     end
 
     context "a real Fuse mounted filesystem" do
         before(:each) do
-            @pathmapFS.allow_write=true
-            @mountpoint = @fixture.mount
+            pathmap_fs.allow_write=true
         end
 
         it "maps files and directories" do
-            (@mountpoint + "textfiles").directory?.should be_true
-            (@mountpoint + "textfiles/hello").file?.should be_true
+            (mountpoint + "textfiles").directory?.should be_true
+            (mountpoint + "textfiles/hello").file?.should be_true
         end
 
         it "lists the mapped contents of directories" do
-            (@mountpoint + "textfiles").entries.should =~ pathnames(".","..","hello")
+            (mountpoint + "textfiles").entries.should =~ pathnames(".","..","hello")
         end
 
         it "represents the stat information of the underlying files" do
-            hellopath=(@mountpoint + "textfiles/hello")
-            realpath=(@tmpdir + "hello.txt")
+            hellopath=(mountpoint + "textfiles/hello")
+            realpath=(tmpdir + "hello.txt")
             mappedstat = hellopath.stat
             realstat = realpath.stat
             mappedstat.size.should == realstat.size
-            mappedstat.atime.should == realstat.atime 
+            mappedstat.atime.should == realstat.atime
             mappedstat.mtime.should == realstat.mtime
             mappedstat.ctime.should == realstat.ctime
         end
 
         it "reads the files" do
-            hellopath= @mountpoint + "textfiles/hello"
+            hellopath= mountpoint + "textfiles/hello"
             hellopath.read.should == "/textfiles/hello"
         end
 
         it "writes the files" do
-            hellopath= @mountpoint + "textfiles/hello"
-            real_path = @tmpdir + "hello.txt"
+            hellopath= mountpoint + "textfiles/hello"
+            real_path = tmpdir + "hello.txt"
             hellopath.open("w") do |f|
                 f.print "updated content"
-            end 
+            end
             hellopath.read.should == "updated content"
             real_path.read.should == "updated content"
         end
+
+        context "extended attributes" do
+            let (:hello_realpath) {fixture.real_path("hello.txt")}
+            let (:hello_xattr) { hello_realpath.xattr }
+            let (:file_xattr) { (mountpoint + "textfiles/hello").xattr }
+            let (:dir_xattr) { (mountpoint + "textfiles").xattr }
+
+            before(:each) do
+                # attribute set on real file
+                hello_xattr["user.file_attr"] = "fileValue"
+
+                # additional attribute on file
+                pathmap_fs.node("/textfiles/hello")[:xattr] =
+                    { "user.add_attr" => "addValue" }
+
+                # additional attribute on directory
+                pathmap_fs.node("/textfiles")[:xattr] =
+                    { "user.dir_attr" => "dirValue" }
+
+            end
+
+            it "should list extended attributes" do
+                file_xattr.list.should include("user.file_attr")
+                file_xattr.list.should include("user.add_attr")
+                file_xattr.list.size.should == 2
+            end
+
+            it "should read extended attributes from underlying file" do
+                file_xattr["user.file_attr"].should == "fileValue"
+            end
+
+            it "should read additional attributes" do
+                file_xattr["user.add_attr"].should == "addValue"
+            end
+
+            it "should write extended attributes to the underlying file" do
+                file_xattr["user.file_attr"] = "written"
+                hello_xattr["user.file_attr"].should == "written"
+            end
+
+            it "should remove extended attributes from the underlying file" do
+                file_xattr.remove("user.file_attr")
+                hello_xattr.list.should_not include("user.file_attr")
+            end
+
+            it "raise EACCES when writing to additional attributes" do
+                lambda {file_xattr["user.add_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+            end
+
+            it "raise EACCES when removing additional attributes" do
+                lambda {file_xattr.remove("user.add_attr")}.should raise_error(Errno::EACCES)
+            end
+
+            it "should list additional attributes from virtual directories" do
+                dir_xattr.list.should include("user.dir_attr")
+                dir_xattr.list.size.should == 1
+            end
+
+            it "should read additional attributes from virtual directories" do
+                dir_xattr["user.dir_attr"].should == "dirValue"
+            end
+
+            it "should raise EACCES when writing additional attributes on virtual directories" do
+                lambda {dir_xattr["user.dir_attr"] = "newValue"}.should raise_error(Errno::EACCES)
+            end
+
+            it "should raise EACCES when deleting additional attributes on virtual directories" do
+                lambda {dir_xattr.remove("user.dir_attr")}.should raise_error(Errno::EACCES)
+            end
+
+        end
+
+        context "filesystem statistics" do
+            before(:each) do
+                fixture.pathmap("bigfile.txt","/textfiles/bigfile","x" * 2048)
+            end
+
+            it "reports stats for files" do
+                statfs = Sys::Filesystem.stat(mountpoint.to_path)
+                # These are fixed
+                statfs.block_size.should == 1024
+                statfs.fragment_size.should == 1024
+
+                # These are dependant on the tests above creating files/directories
+                statfs.files.should == 10
+                statfs.files_available == 10
+
+                # 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
+            end
+
+            it "reports stats for files after writing" do
+
+                (mountpoint + "textfiles/bigfile").open("w") { |f| f.print("y" * 4096) }
+                statfs = Sys::Filesystem.stat(mountpoint.to_path)
+                statfs.files.should == 10
+                statfs.blocks.should == 4
+
+            end
+
+        end
     end
 
     context "a real Fuse mount with raw file access" do
 
         before(:each) do
-            @pathmapFS.use_raw_file_access = true
-            @pathmapFS.allow_write = true
-            @mountpoint = @fixture.mount
+            pathmap_fs.use_raw_file_access = true
+            pathmap_fs.allow_write = true
         end
 
         it "reads files" do
-            hello_path = (@mountpoint + "textfiles/hello")
+            hello_path = (mountpoint + "textfiles/hello")
             hello_path.open do |f|
                 f.seek(2)
                 f.read(3).should == "ext"
@@ -186,17 +392,26 @@ describe FuseFS::PathMapperFS do
         end
 
         it "writes files" do
-            hello_path = (@mountpoint + "textfiles/hello")
-            real_path = @tmpdir + "hello.txt"
+            hello_path = (mountpoint + "textfiles/hello")
+            real_path = tmpdir + "hello.txt"
             hello_path.open("r+") do |f|
                 f.sysseek(2)
                 f.syswrite("zzz")
                 f.sysseek(0)
                 f.sysread(6).should == "/tzzzf"
-            end 
+            end
 
-            real_path.read.should == "/tzzzfiles/hello"   
+            real_path.read.should == "/tzzzfiles/hello"
         end
 
+        it "reports filesystem statistics after raw write" do
+            hello_path = (mountpoint + "textfiles/hello")
+            hello_path.open("w") do |f|
+                f.syswrite("z" * 2048)
+            end
+
+            statfs = Sys::Filesystem.stat(mountpoint.to_path)
+            statfs.blocks.should == 2
+        end
     end
 end

data/spec/rfusefs_spec.rb

@@ -197,10 +197,23 @@ describe FuseFS do
     		filetype(stat.mode).should == RFuse::Stat::S_IFREG
     		stat.size.should == 0
     	end
-    	
+        
+        it "should create zero length files" do
+     		ffi = Struct::FuseFileInfo.new()
+    		ffi.flags = Fcntl::O_WRONLY
+    		@mock_fuse.stub!(:file?).with(TEST_FILE).and_return(false)
+    		@mock_fuse.stub!(:directory?).with(TEST_FILE).and_return(false)
+    		@mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
+            @mock_fuse.should_receive(:write_to).once.with(TEST_FILE,"")
+    		@fuse.mknod(nil,TEST_FILE,RFuse::Stat::S_IFREG | 0644,0,0)
+    		@fuse.open(nil,TEST_FILE,ffi)
+    		@fuse.flush(nil,TEST_FILE,ffi)
+    		@fuse.release(nil,TEST_FILE,ffi)
+        end
+
     	it ":mkdir should not raise error if can_mkdir?" do
     		@mock_fuse.should_receive(:can_mkdir?).with(TEST_FILE).and_return(true)
-    		@fuse.mkdir(nil,TEST_FILE,004555)	
+    		@fuse.mkdir(nil,TEST_FILE,004555)
     	end
       
     end
@@ -254,9 +267,11 @@ describe FuseFS do
     		@fuse.release(nil,TEST_FILE,ffi)
    		
     	end
-        
+
     	it "should do sensible things for files opened RDWR"
-    	
+    
+        it "should pass on buffered data when requested (fsync)"
+
     end
     
     context "raw reading" do
@@ -278,19 +293,21 @@ describe FuseFS do
     end
     
     context "raw writing" do
-		it "should call raw_truncate,raw_write,raw_close if raw_open returns true" do
+		it "should call other raw_* methods if raw_open returns true" do
 			ffi = Struct::FuseFileInfo.new()
-			ffi.flags = Fcntl::O_WRONLY 
+			ffi.flags = Fcntl::O_WRONLY
 			raw = Object.new()
 			@mock_fuse.stub!(:can_write?).with(TEST_FILE).and_return(true)
 			@mock_fuse.should_receive(:raw_open).with(TEST_FILE,"w",true).and_return(raw)
 			@mock_fuse.should_receive(:raw_truncate).with(TEST_FILE,0,raw)
 			@mock_fuse.should_receive(:raw_write).with(TEST_FILE,0,5,"12345",raw).once().and_return(5)
 			@mock_fuse.should_receive(:raw_write).with(TEST_FILE,5,5,"67890",raw).once().and_return(5)
+            @mock_fuse.should_receive(:raw_sync).with(TEST_FILE, false, raw)
 			@mock_fuse.should_receive(:raw_close).with(TEST_FILE,raw)
 			@fuse.open(nil,TEST_FILE,ffi)
 			@fuse.ftruncate(nil,TEST_FILE,0,ffi)
     		@fuse.write(nil,TEST_FILE,"12345",0,ffi).should == 5
+            @fuse.fsync(nil,TEST_FILE,0,ffi)
 			@fuse.write(nil,TEST_FILE,"67890",5,ffi).should == 5
 			@fuse.flush(nil,TEST_FILE,ffi)
 			@fuse.release(nil,TEST_FILE,ffi)
@@ -393,24 +410,63 @@ describe FuseFS do
     end
     context "extended attributes" do
 
-        let(:xattr) { {} }
+        let(:xattr) { mock(:xattr) }
         before(:each) { @mock_fuse.stub!(:xattr).with(TEST_FILE).and_return(xattr) }
 
-        it "should get, set and list attributes" do
-           xattr["user.one"] = "xattr one"
-           
-           @fuse.getxattr(nil,TEST_FILE,"user.one").should == "xattr one"
-           @fuse.setxattr(nil,TEST_FILE,"user.two","xattr two")
-           xattr["user.two"].should == "xattr two"
-           @fuse.listxattr(nil,TEST_FILE).should =~ [ "user.one", "user.two" ]
-           @fuse.removexattr(nil,TEST_FILE,"user.two")
-           xattr.keys.should =~ [ "user.one" ]
+        it "should list attributes via #keys on result of #xattr" do
+            xattr.should_receive(:keys).and_return(["one","two"])
+            @fuse.listxattr(nil,TEST_FILE).should == [ "one","two" ]
         end
 
-        it "should raise ENODATA is no attribute is available" do
+        it "should get attributes via #xattr.[]" do
+            xattr.should_receive(:[]).with("user.one").and_return("one")
+
+            @fuse.getxattr(nil,TEST_FILE,"user.one").should == "one"
+        end
+
+        it "should set attributes via #xattr.[]=" do
+            xattr.should_receive(:[]=).with("user.two","two")
+
+            @fuse.setxattr(nil,TEST_FILE,"user.two","two",0)
+        end
+
+        it "should remove attributes via #xattr.delete" do
+            xattr.should_receive(:delete).with("user.three")
+
+            @fuse.removexattr(nil,TEST_FILE,"user.three")
+        end
+
+        it "should raise ENODATA when #xattr.[] returns nil" do
+
+            xattr.should_receive(:[]).with("user.xxxx").and_return(nil)
             lambda{@fuse.getxattr(nil,TEST_FILE,"user.xxxx") }.should raise_error(Errno::ENODATA)
         end
     end
+
+    context "#statfs" do
+        # used space, used files, total_space, total_files
+        let(:stats) { [ 1000 * 1024, 5, 1200 * 1024, 12 ] }
+        it "should convert simple array into StatVfs" do
+    
+            @mock_fuse.should_receive(:statistics).with(TEST_FILE).and_return(stats)
+
+            result = @fuse.statfs(nil,TEST_FILE)
+            result.should be_kind_of(RFuse::StatVfs)
+            result.f_bsize.should == 1024
+            result.f_blocks.should == 1200
+            result.f_bavail.should == 200
+            result.f_files.should == 12
+            result.f_ffree.should == 7
+        end
+
+        it "passes on raw statistics" do
+            statvfs = Object.new()
+            @mock_fuse.should_receive(:statistics).with(TEST_FILE).and_return(statvfs)
+
+            @fuse.statfs(nil,TEST_FILE).should equal(statvfs)
+        end
+
+    end
   end
   
   describe "a FuseFS filesystem with gid/uid specific behaviour" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rfusefs
 version: !ruby/object:Gem::Version
-  version: 1.0.2.RC0
+  version: 1.0.2.RC1
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-02 00:00:00.000000000 Z
+date: 2014-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rfuse
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: 1.0.5RC0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: 1.0.5RC0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +107,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sys-filesystem
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi-xattr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 description: A more Ruby like way to write FUSE filesystems - inspired by (compatible
   with) FuseFS, implemented over RFuse
 email: