io 0.0.1

data/spec/file_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe 'File' do
+  with_test_dir
+
+  before do
+    @path = test_dir['a/b/c']
+  end
+
+  describe 'existence' do
+    it "should check only files" do
+      @path.should_not exist
+      @path.dir.create
+      @path.should be_dir
+      @path.file.should_not exist
+      @path.file.create
+      @path.should be_file
+      @path.file.should exist
+    end
+  end
+
+  describe 'read' do
+    it 'should raise error if not exist' do
+      -> {@path.read}.should raise_error(Vfs::Error, /not exist/)
+      -> {@path.read{|buff|}}.should raise_error(Vfs::Error, /not exist/)
+    end
+
+    it 'should not raise error in silent mode' do
+      @path.read(bang: false).should == ''
+      data = ""; @path.read(bang: false){|buff| data << buff}; data.should == ''
+    end
+
+    it "reading" do
+      @path.write('something')
+
+      @path.read.should == 'something'
+      @path.read(bang: false).should == 'something'
+      data = ""; @path.read{|buff| data << buff}; data.should == 'something'
+    end
+
+    # it 'content' do
+    #   @path.write('something')
+    #   @path.content.should == 'something'
+    # end
+  end
+
+  describe 'creation' do
+    it 'create' do
+      file = @path.file
+
+      file.should_receive(:write).with('', {})
+      file.create
+    end
+
+    it 'should be chainable' do
+      @path.file.create.should == @path
+    end
+  end
+
+  describe 'write' do
+    it 'should create parent dirs if not exists' do
+      @path.parent.should_not exist
+      @path.write 'something'
+      @path.read.should == 'something'
+    end
+
+    it 'should override existing file' do
+      @path.write 'something'
+      @path.should be_file
+      @path.write 'other'
+      @path.read.should == 'other'
+    end
+
+    it 'should override existing dir' do
+      @path.dir.create
+      @path.should be_dir
+      @path.write 'another'
+      @path.read.should == 'another'
+    end
+
+    it 'writing' do
+      @path.write 'something'
+      @path.read.should == 'something'
+
+      @path.write do |writer|
+        writer.write 'another'
+      end
+      @path.read.should == 'another'
+    end
+
+    it 'append' do
+      file = @path.file
+      file.should_receive(:write).with('something', append: true)
+      file.append 'something'
+    end
+
+    it 'should correctly display errors (from error)' do
+      -> {test_dir['test'].write{|writer| raise 'some error'}}.should raise_error(/some error/)
+    end
+  end
+
+  it 'update' do
+    @path.write 'something'
+    @path.update do |data|
+      data.should == 'something'
+      'another'
+    end
+    @path.read.should == 'another'
+  end
+
+  describe 'copying' do
+    before do
+      @from = @path.file
+      @from.write('something')
+    end
+
+    it 'should not copy to itself' do
+      -> {@from.copy_to @from}.should raise_error(Vfs::Error, /itself/)
+    end
+
+    def check_copy_for to
+      target = @from.copy_to to
+      target.read.should == 'something'
+      target.should == to
+
+      # overriding
+      @from.write 'another'
+      target = @from.copy_to to
+      target.read.should == 'another'
+      target.should == to
+    end
+
+    it 'should copy to file (and overwrite)' do
+      check_copy_for test_dir.file('to')
+    end
+
+    it 'should copy to dir (and overwrite)' do
+      check_copy_for test_dir.dir("to")
+    end
+
+    it 'should copy to UniversalEntry (and overwrite)' do
+      check_copy_for test_dir.entry('to')
+    end
+
+    it 'should be chainable' do
+      to = test_dir['to']
+      @from.copy_to(to).should == to
+    end
+
+    it "should autocreate parent's path if not exist (from error)" do
+      to = test_dir['parent_path/to']
+      @from.copy_to(to)
+      to.read.should == 'something'
+    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.file('from').create, @path.file('to')
+      from.move_to(to).should == to
+    end
+  end
+
+  describe 'destroying' do
+    it "should not raise error if it's trying to destroy a dir" do
+      @path.dir.create
+      @path.file.destroy
+      @path.entry.should_not exist
+    end
+
+    it "shouldn't raise if file not exist" do
+      @path.file.destroy
+    end
+
+    it 'should be chainable' do
+      @path.file.destroy.should == @path
+    end
+  end
+
+  describe "extra stuff" do
+    it 'render' do
+      template = test_dir / 'letter.erb'
+      template.write "Hello dear <%= name %>"
+      template.render(name: 'Mary').should == "Hello dear Mary"
+    end
+
+    begin
+      require 'haml'
+
+      it 'render using other template engines' do
+        template = test_dir / 'letter.haml'
+        template.write "Hello dear \#{name}"
+        template.render(name: 'Mary').should =~ /Hello dear Mary/
+      end
+    rescue LoadError
+      warn "no :haml template engine, skipping rendering with haml specs"
+    end
+
+    it 'size' do
+      @path.file.write('data').size.should == 4
+    end
+  end
+end

data/spec/misc_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Miscellaneous' do
+  with_test_dir
+
+  it "File should respond to :to_file, :to_entry" do
+    path = "#{test_dir.path}/file"
+    File.open(path, 'w'){|f| f.write 'something'}
+
+    file = nil
+    begin
+      file = File.open path
+      file.to_file.path.should == file.path
+      file.to_entry.path.should == file.path
+    ensure
+      file.close
+    end
+  end
+end

data/spec/path_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe "Path" do
+  before(:all){Path = Vfs::Path}
+  after(:all){remove_constants :Path}
+
+  it 'validations' do
+    %w(
+      /
+      /a
+      /a/b/c
+      /a/../c
+      /a/...
+      ~/a
+      ./a
+      /~a
+      /a~b
+      /a.b~
+    ).each{|path| Path.should be_valid(path)}
+
+    special = ['']
+    (%w(
+      /a/~/c
+      /a/./c
+      /a/
+      ~/
+      ./
+    ) + special).each{|path| Path.should_not be_valid(path)}
+  end
+
+  # it 'tmp' do
+  #   (Path.new('.') + '..').should == './..'
+  # end
+
+  it 'normalize' do
+    special = ['/a/../..', nil]
+    (%w(
+      /a        /a
+      ~/a       ~/a
+      ./a       ./a
+      /a/../c   /c
+      /         /
+      ~         ~
+      /a~/b    /a~/b
+      .         .
+    ) + special).each_slice(2) do |path, normalized_path|
+      Path.normalize(path).should == normalized_path
+    end
+  end
+
+  it "+" do
+    special = [
+      '/a', '../..', nil,
+      '/',  '..',    nil,
+      '.',  '..',    './..',
+    ]
+    (%w(
+      /         /a        /a
+      /         ~/a       ~/a
+      /         ./a       ./a
+      /a        b/c       /a/b/c
+      /a/b/c    ../d      /a/b/d
+    ) + special).each_slice(3) do |base, path, sum|
+      (Path.new(base) + path).should == sum
+    end
+  end
+
+  it 'parent' do
+    special = [
+      '/', nil,
+      '~', nil,
+      '.', './..'
+    ]
+    (%w(
+      /a/b/c    /a/b
+    ) + special).each_slice(2) do |path, parent|
+      Path.new(path).parent.should == parent
+    end
+  end
+
+  it "should raise error if current dir outside of root" do
+    -> {Path.new('/a/../..')}.should raise_error(/outside.*root/)
+  end
+
+  it "should guess if current dir is a dir" do
+    [
+      '/a',      false,
+      '/',       true,
+      '~',       true,
+      '.',       true,
+      '/a/..',   true,
+      '/a/../b', false,
+    ].each_slice 2 do |path, result|
+      Path.new(path).probably_dir?.should == result
+    end
+
+    path = Path.new('/a/b/c')
+    [
+      path,           false,
+      (path + '..'),  true,
+      path.parent,    true,
+
+      (path + '/'),   true,
+      (path + '/a'),  false,
+    ].each_slice 2 do |path, result|
+      path.probably_dir?.should == result
+    end
+  end
+
+  it 'name' do
+    %w(
+      /a        a
+      /a/b/c    c
+      /         /
+      ~         ~
+      .         .
+    ).each_slice 2 do |path, name|
+      Path.new(path).name.should == name
+    end
+  end
+
+  it 'to_s' do
+    Path.new.to_s.class.should == String
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'rspec_ext'
+require 'ruby_ext'
+
+require 'tilt'
+require 'vfs'
+
+rspec do
+  def self.with_test_dir
+    before do
+      @test_dir = "/tmp/test_dir".to_dir
+
+      FileUtils.rm_r test_dir.path if File.exist? test_dir.path
+      FileUtils.mkdir_p test_dir.path
+    end
+
+    after do
+      FileUtils.rm_r test_dir.path if File.exist? test_dir.path
+      @test_dir = nil
+    end
+  end
+
+  def test_dir
+    @test_dir
+  end
+end
+
+# require 'fakefs/spec_helpers'
+#
+# include FakeFS::SpecHelpers
+# use_fakefs self
+#
+#
+# #
+# # FakeFS fixes
+# #
+# FakeFS::File::Stat.class_eval do
+#   # there's also file? method defined on File::Stat
+#   def file?; !directory? end
+# end
+#
+# FakeFS::File.class_eval do
+#   class << self
+#     # File.delete should raise error if it's directory
+#     alias_method :delete_without_bang, :delete
+#     def delete path
+#       raise Errno::EPERM, "Operation not permitted - #{path}" if directory?(path)
+#       delete_without_bang path
+#     end
+#   end
+# end

data/spec/storages/local_spec.rb

@@ -0,0 +1,24 @@
+require 'vfs/drivers/local'
+require 'vfs/drivers/specification'
+
+describe Vfs::Drivers::Local do
+  with_tmp_spec_dir
+
+  before do
+    @driver = Vfs::Drivers::Local.new spec_dir
+    @driver.open
+  end
+
+  after do
+    @driver.close
+  end
+
+  it_should_behave_like 'vfs driver basic'
+  it_should_behave_like 'vfs driver attributes basic'
+  it_should_behave_like 'vfs driver files'
+  it_should_behave_like 'vfs driver full attributes for files'
+  it_should_behave_like 'vfs driver dirs'
+  it_should_behave_like 'vfs driver full attributes for dirs'
+  it_should_behave_like 'vfs driver query'
+  it_should_behave_like 'vfs driver tmp dir'
+end

data/spec/universal_entry_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe 'UniversalEntry' do
+  with_test_dir
+
+  before do
+    @path = test_dir['a/b/c']
+  end
+
+  describe 'existence' do
+    it "should check both files and dirs" do
+      @path.should_not exist
+      @path.dir.create
+      @path.should be_dir
+      @path.should exist
+
+      @path.file.create
+      @path.should be_file
+      @path.should exist
+    end
+  end
+
+  describe 'destroying' do
+    it "should destroy both files and dirs" do
+      @path.dir.create
+      @path.should be_dir
+      @path.destroy
+      @path.should_not exist
+
+      @path.file.create
+      @path.should be_file
+      @path.destroy
+      @path.should_not exist
+
+      @path.file.create
+      @path.destroy
+      @path.file.should_not exist
+    end
+
+    it "shouldn't raise if file not exist" do
+      @path.destroy
+    end
+  end
+
+  describe 'copy_to' 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
+
+      @to = test_dir['to']
+    end
+
+    it "shoud copy dir" do
+      @from.entry.copy_to @to
+      @to['dir/file2'].file?.should be_true
+    end
+
+    it "should copy file" do
+      @from['file'].entry.copy_to @to
+      @to.file.should be_true
+    end
+
+    it "should raise if entry not exist" do
+      -> {@from['non existing'].entry.copy_to @to}.should raise_error(/not exist/)
+    end
+  end
+
+  describe 'move_to'
+end