vfs 0.4.8 → 0.5.0

data/Rakefile

@@ -1,11 +0,0 @@
-require 'rake_ext'
-
-project(
-  name: "vfs",
-  gem: true,
-  summary: "Virtual File System - simple and unified API over different storages (Local, S3, SFTP, ...)",
-  # version: '0.4.0',
-
-  author: "Alexey Petrushin",
-  homepage: "http://alexeypetrushin.github.com/vfs"
-)

data/readme.md

@@ -1,143 +0,0 @@
-**Documentation:** http://alexeypetrushin.github.com/vfs
-
-Virtual File System provides **clean, simple and unified API over different storages** (Local File System, AWS S3, SFTP, ...).
-
-- very simple and intuitive API.
-- same API for different storages.
-- work simultaneously with multiple storages.
-- small codebase, easy to learn and extend.
-- driver implementation is very simple, it is easy to create new drivers.
-
-Such unified API is possible because although the API of storages are different the core concept are almost the same.
-
-Install Vfs with Rubygems:
-
-    gem install vfs
-
-Once installed, You can proceed with the [basic example][basics], there's also [S3 version][s3_basics] and [SFTP version][ssh_basics] (also [S3 backup][s3_backup] and [SSH/SFTP deployment][ssh_deployment] examples availiable).
-
-You can report bugs and discuss features on the [issues page][issues].
-
-## Sample
-
-``` ruby
-# Preparing sandbox for our sample and cleaning it before starting
-# (ignore the `$sandbox` variable, it's needed to reuse this code in S3 and SSH samples).
-require 'vfs'
-sandbox = $sandbox || '/tmp/vfs_sandbox'.to_dir.destroy
-
-# Creating simple Hello World project.
-project = sandbox['hello_world']
-
-# Writing readme file (note that parent dirs where created automatically).
-project['readme.txt'].write 'My App'
-
-# We can assign files and dirs to variables, now the `readme` variable refers to our readme.txt file.
-readme = project['readme.txt']
-
-# Let's ensure that it's all ok with our readme file and check its attributes.
-p readme.name                               # => readme.txt
-p [readme.basename, readme.extension]       # => ['readme', 'txt']
-p readme.path                               # => /.../readme.txt
-p readme.exist?                             # => true
-p readme.file?                              # => true
-p readme.dir?                               # => false
-p readme.size                               # => 6
-p readme.created_at                         # => 2011-09-09 13:20:43 +0400
-p readme.updated_at                         # => 2011-09-09 13:20:43 +0400
-
-# Reading - You can read all at once or do it sequentially (input stream
-# will be automatically splitted into chunks of reasonable size).
-p readme.read                               # => "My shiny App"
-readme.read{|chunk| p chunk}                # => "My shiny App"
-
-# The same for writing - write all at once or do it sequentially
-# (if there's no file it will be created, if it exists it will be rewriten).
-readme.write "My App v2"
-readme.write{|stream| stream.write "My App v3"}
-p readme.read                               # => "My shiny App v3"
-
-# Appending content to existing file.
-readme.append "How to install ..."
-p readme.size                               # => 27
-
-# Copying and Moving. It also works exactly the same
-# way if You copy or move files and dirs to other storages.
-readme.copy_to project['docs/readme.txt']
-p project['docs/readme.txt'].exist?         # => true
-p readme.exist?                             # => true
-
-readme.move_to project['docs/readme.txt']
-p project['docs/readme.txt'].exist?         # => true
-p readme.exist?                             # => false
-
-# Let's add empty Rakefile to our project.
-project['Rakefile'].write
-
-# Operations with directories - checking our project exists and not empty.
-p project.exist?                            # => true
-p project.empty?                            # => false
-
-# Listing dir content. There are two versions of methods -
-# without block the result will be Array of Entries, with block
-# it will iterate over directory sequentially.
-p project.entries                           # => [/.../docs, /.../Rakefile]
-p project.files                             # => [/.../Rakefile]
-p project.dirs                              # => [/.../docs]
-project.entries do |entry|                  # => ["docs", false]
-  p [entry.name, entry.file?]               # => ["Rakefile", true]
-end
-p project.include?('Rakefile')              # => true
-
-# You can also use glob (if storage support it).
-if project.driver.local?
-  p project.entries('**/Rake*')             # => [/.../Rakefile]
-  p project['**/Rake*']                     # => [/.../Rakefile]
-end
-
-# The result of dir listing is just an array of Entries, so
-# You can use it to do interesting things. For example this code will
-# calculates the size of sources in our project.
-if project.driver.local?
-  project['**/*.rb'].collect(&:size).reduce(0, :+)
-end
-
-# Copying and moving - let's create another project by cloning our hello_world.
-project.copy_to sandbox['another_project']
-p sandbox['another_project'].entries        # => [/.../docs, .../Rakefile]
-
-# Cleaning sandbox.
-sandbox.destroy
-```
-
-## Integration with [Vos][vos] (Virtual Operating System)
-
-Vfs can be used toghether with the Virtual Operating System Tool, and while the Vfs covers all the I/O operations the Vos provides support for remote command execution.
-You can use this combination to fully control remote machines, for example - I'm using it to manage my production servers (setup, administration, deployment, migration, ...).
-
-For more details please go to [Vos][vos] project page.
-You can also take look at the actual configuration I'm using to control my servers [My Cluster][my_cluster] (in conjunction with small configuration tool [Cluster Management][cluster_management]).
-
-# Why?
-
-To easy my work: with local FS, remote FS, and some specific systems like Hadoop DFS.
-
-Because the API of standard File/Dir/FileUtils classes are just terrible. And there's the reason for it - the goal of thouse tools is to provide 1-to-1 clone of underlying OS API, instead of provididing handy tool.
-
-And if you want to use remote FS - things are getting even worse and more complicated (Net::SSH & Net::SFTP use a little
-different API than local FS, and you has to remember all thouse little quirks).
-
-## License
-
-Copyright (c) Alexey Petrushin http://petrush.in, released under the MIT license.
-
-[vos]: http://github.com/alexeypetrushin/vos
-[cluster_management]: http://github.com/alexeypetrushin/cluster_management
-[my_cluster]: http://github.com/alexeypetrushin/my_cluster
-
-[basics]:         http://alexeypetrushin.github.com/vfs/basics.html
-[s3_basics]:      http://alexeypetrushin.github.com/vfs/s3_basics.html
-[s3_backup]:      http://alexeypetrushin.github.com/vfs/s3_backup.html
-[ssh_basics]:     http://alexeypetrushin.github.com/vfs/ssh_basics.html
-[ssh_deployment]: http://alexeypetrushin.github.com/vfs/ssh_deployment.html
-[issues]:         https://github.com/alexeypetrushin/vfs/issues

data/spec/container_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe 'Container' do
-  with_test_dir
-
-  it "should threat paths as UniversalEntry except it ends with '/'" do
-    test_dir.should_receive(:entry).with('tmp/a/b')
-    test_dir['tmp/a/b']
-
-    test_dir.should_receive(:dir).with('tmp/a/b')
-    test_dir['tmp/a/b/']
-  end
-
-  it '/' do
-    test_dir[:some_path].should == test_dir / :some_path
-    test_dir[:some_path][:another_path].should == test_dir / :some_path / :another_path
-  end
-
-  it "UniversalEntry should be wrapped inside of proxy, Dir and File should not" do
-    -> {test_dir.dir.proxy?}.should raise_error(NoMethodError)
-    -> {test_dir.file.proxy?}.should raise_error(NoMethodError)
-    test_dir.entry.proxy?.should be_true
-  end
-
-  it "sometimes it also should inexplicitly guess that path is a Dir instead of UniversalEntry (but still wrap it inside of Proxy)" do
-
-    dir = test_dir['tmp/a/..']
-    dir.proxy?.should be_true
-    dir.should be_a(Vfs::Dir)
-  end
-end

data/spec/dir_spec.rb

@@ -1,253 +0,0 @@
-require 'spec_helper'
-
-describe 'Dir' do
-  with_test_dir
-
-  before do
-    @path = test_dir['a/b/c']
-  end
-
-  describe 'existence' do
-    it "should check only dirs" do
-      @path.should_not exist
-      @path.file.create
-      @path.should be_file
-      @path.dir.should_not exist
-      @path.dir.create
-      @path.should be_dir
-      @path.dir.should exist
-    end
-  end
-
-  it "should not respond to read and write methods" do
-    -> {@path.dir.read}.should raise_error(NoMethodError)
-    -> {@path.dir.write}.should raise_error(NoMethodError)
-  end
-
-  describe 'create' do
-    it 'should be chainable' do
-      @path.dir.create.should == @path
-    end
-
-    it 'should create parent dirs if not exists' do
-      @path.parent.should_not exist
-      @path.dir.create
-      @path.should be_dir
-    end
-
-    it 'should silently exit if dir already exist' do
-      @path.dir.create
-      @path.dir.create
-    end
-
-    it 'should override existing file' do
-      @path.file.create
-      @path.should be_file
-      @path.dir.create
-      @path.should be_dir
-    end
-
-    it 'should not override existing dir with content' do
-      dir = @path.dir
-      dir.create
-      file = dir.file :file
-      file.create
-      file.should exist
-
-      dir.create
-      file.should exist
-    end
-  end
-
-  describe 'destroying' do
-    it "should destroy a file" do
-      @path.file.create
-      @path.dir.destroy
-      @path.entry.should_not exist
-    end
-
-    it "shouldn't raise if dir not exist" do
-      @path.dir.destroy
-    end
-
-    it 'should destroy recursivelly' do
-      dir = @path.dir
-      dir.create
-      dir.file(:file).write 'something'
-      dir.dir(:dir).create.tap do |dir|
-        dir.file(:file2).write 'something2'
-      end
-
-      dir.destroy
-      dir.should_not exist
-    end
-
-    it 'should be chainable' do
-      @path.dir.destroy.should == @path
-    end
-  end
-
-  describe 'entries, files, dirs' do
-    before do
-      @path.dir('dir').create
-      @path.dir('dir/another_dir').create
-      @path.file('file').create
-    end
-
-    it 'entries' do
-      -> {@path['non_existing'].entries}.should raise_error(Vfs::Error, /not exist/)
-      @path['non_existing'].entries(bang: false).should == []
-      @path.entries.to_set.should be_eql([@path.entry('dir'), @path.entry('file')].to_set)
-      list = []
-      @path.entries{|e| list << e}
-      list.to_set.should be_eql([@path.entry('dir'), @path.entry('file')].to_set)
-    end
-
-    it 'entries with type' do
-      @path.entries(type: true).to_set.should be_eql([@path.dir('dir'), @path.file('file')].to_set)
-    end
-
-    it "glob search support" do
-      @path.dir('dir_a').create
-      @path.file('file_a').create
-      @path.dir('dir_b').create
-      @path.entries('*_a').collect(&:name).sort.should == %w(dir_a file_a)
-    end
-
-    it 'should raise error if trying :entries on file' do
-      @path.file('some_file').create
-      -> {@path.dir('some_file').entries}.should raise_error(/File/)
-    end
-
-    it 'files' do
-      @path.files.should be_eql([@path.file('file')])
-    end
-
-    it 'dirs' do
-      @path.dirs.should be_eql([@path.dir('dir')])
-    end
-
-    it 'has? & include?' do
-      @path.include?('dir').should be_true
-      @path.include?('dir/another_dir').should be_true
-      @path.include?('file').should be_true
-      @path.include?('non_existing').should be_false
-    end
-
-    it 'empty?' do
-      @path.empty?.should be_false
-      @path.dir('empty_dir').create.empty?.should be_true
-    end
-
-    it "should threat ['**/*.rb'] as glob" do
-      @path['**/*nother*'].first.name.should == 'another_dir'
-    end
-  end
-
-  describe 'copying' do
-    before do
-      @from = @path.dir
-      @from.create
-      @from.file('file').write 'something'
-      @from.dir('dir').create.tap do |dir|
-        dir.file('file2').write 'something2'
-      end
-    end
-
-    it 'should not copy to itself' do
-      -> {@from.copy_to @from}.should raise_error(Vfs::Error, /itself/)
-    end
-
-    shared_examples_for 'copy_to behavior' do
-      it 'should copy to file and overwrite it' do
-        @from.copy_to @to.file
-        @to['file'].read.should == 'something'
-      end
-
-      it 'should override files' do
-        @from.copy_to @to
-
-        @from['dir/file2'].write 'another'
-        @from.copy_to @to
-        @to['dir/file2'].read.should == 'another'
-      end
-
-      it 'should copy to UniversalEntry (and overwrite)' do
-        @from.copy_to @to.entry
-
-        @from.copy_to @to.entry
-        @to['file'].read.should == 'something'
-      end
-
-      it "shouldn't delete existing content of directory" do
-        @to.dir.create
-        @to.file('existing_file').write 'existing_content'
-        @to.dir('existing_dir').create
-        @to.file('dir/existing_file2').write 'existing_content2'
-
-        @from.copy_to @to
-        # copied files
-        @to['file'].read.should == 'something'
-        @to['dir/file2'].read.should == 'something2'
-        # shouldn't delete already existing files
-        @to.file('existing_file').read.should == 'existing_content'
-        @to.dir('existing_dir').should exist
-        @to.file('dir/existing_file2').read.should == 'existing_content2'
-      end
-
-      it 'should be chainable' do
-        @from.copy_to(@to).should == @to
-      end
-
-      it "should override without deleting other files" do
-        @from.copy_to(@to).should == @to
-        @to.file('other_file').write 'other'
-
-        @from.copy_to(@to).should == @to
-        @to.file('other_file').read.should == 'other'
-      end
-
-      it "should raise error if try to copy file as dir" do
-        dir = @from.dir 'file'
-        dir.file?.should be_true
-        -> {dir.copy_to @to}.should raise_error(Vfs::Error)
-      end
-    end
-
-    describe 'general copy' do
-      it_should_behave_like 'copy_to behavior'
-
-      before do
-        # prevenging usage of :efficient_dir_copy
-        # Vfs::Dir.dont_use_efficient_dir_copy = true
-
-        @to = test_dir['to']
-      end
-      # after do
-      #   Vfs::Dir.dont_use_efficient_dir_copy = false
-      # end
-    end
-
-    # describe 'effective copy' do
-    #   it_should_behave_like 'copy_to behavior'
-    #
-    #   before do
-    #     @to = test_dir['to']
-    #   end
-    # end
-  end
-
-  describe 'moving' do
-    it 'move_to' do
-      from, to = @path.file('from'), @path.file('to')
-      from.should_receive(:copy_to).with(to)
-      from.should_receive(:destroy).with()
-      from.move_to to
-    end
-
-    it 'should be chainable' do
-      from, to = @path.dir('from').create, @path.dir('to')
-      from.move_to(to).should == to
-    end
-  end
-end

data/spec/entry_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe 'Entry' do
-  with_test_dir
-
-  before do
-    @path = test_dir['a/b/c']
-  end
-
-  it "name" do
-    @path.name.should == 'c'
-  end
-
-  it "string integration" do
-    '/'.to_entry.path.should == '/'
-    'a'.to_entry.path.should == "./a"
-  end
-
-  it 'tmp' do
-    tmp = test_dir.tmp
-    tmp.should be_dir
-    tmp.destroy
-
-    tmp = nil
-    test_dir.tmp do |path|
-      tmp = path
-      tmp.should be_dir
-    end
-    tmp.should_not exist
-  end
-
-  it 'should respond to local?' do
-    test_dir.should respond_to(:local?)
-  end
-
-  it 'created_at, updated_at, size' do
-    file = test_dir.file('file').write 'data'
-    file.created_at.class.should == Time
-    file.updated_at.class.should == Time
-    file.size.should == 4
-  end
-end