cotta 1.0.0

data/test/cotta/cotta_file_in_memory_spec.rb

@@ -0,0 +1,15 @@
+require 'spec'
+dir = File.join(File.dirname(__FILE__))
+require dir + '/cotta_file_behaviors'
+require dir + '/../test'
+
+module Cotta
+  describe InMemorySystem, 'with cotta file' do
+    it_should_behave_like 'CottaFileBehaviors'
+
+    def create_system
+      @system = Cotta.in_memory
+    end
+
+  end
+end

data/test/cotta/cotta_file_physical_spec.rb

@@ -0,0 +1,47 @@
+require 'spec'
+dir = File.dirname(__FILE__)
+require dir + '/../test'
+require dir + '/cotta_file_behaviors'
+require dir + '/physical_system_stub'
+
+module Cotta
+describe PhysicalSystem, 'with cotta file' do
+  it_should_behave_like 'CottaFileBehaviors'
+
+  def create_system
+    @system = Cotta.factory(PhysicalSystemStub.new)
+  end
+
+  before do
+    create_system unless @system
+  end
+  
+  it 'copying binary files properly' do
+    logo_gif = FileFactory.parent_dir(__FILE__).file('logo.gif')
+    content = logo_gif.read_binary {|io| io.read}
+    target = CottaFile.new(@system, Pathname.new('dir/logo.gif'))
+    target.parent.mkdirs
+    target.write_binary do |io|
+      io.write content
+    end
+    expected_stat = logo_gif.stat
+    actual_stat = target.stat
+    actual_stat.size.should == expected_stat.size
+  end
+
+  it 'zip and unzip' do
+    logo_gif = FileFactory.parent_dir(__FILE__).file('logo.gif')
+    content = logo_gif.read_binary {|io| io.read}
+    dir = CottaDir.new(@system, Pathname.new('dir'))
+    target_dir = dir.dir('target')
+    target_dir.file(logo_gif.name).write_binary {|io| io.write content}
+    zip_file = target_dir.archive.zip
+    extract_dir = dir.dir('extract')
+    file_to_unzip = zip_file.copy_to(extract_dir.file(zip_file.name))
+    extracted_dir = file_to_unzip.unzip.extract
+
+    extracted_dir.file('logo.gif').stat.size.should == logo_gif.stat.size
+  end
+
+end
+end

data/test/cotta/cotta_zip_support_spec.rb

@@ -0,0 +1,53 @@
+require 'spec'
+require File.dirname(__FILE__) + '/../test'
+
+module Cotta
+describe FileFactory, 'zip support' do
+  before do
+    @cotta = FileFactory.new(InMemorySystem.new)
+  end
+  
+  it 'extract from a tar file' do
+    tar_file = FileFactory.parent_dir(__FILE__).file('tar_test.tar')
+    dir = @cotta.dir('dir/extract')
+    tar_file.extract(dir)
+    dir.list.size.should == 3
+    dir.file('one.txt').load.should == 'one'
+    dir.file('two.txt').load.should == 'two'
+    dir.file('three.txt').load.should == 'three'
+  end
+  
+  it 'should archive files in the directory to a file' do
+    source = @cotta.dir('dir/source')
+    source.file('one.txt').save('one')
+    source.file('two.txt').save('two')
+    source.file('three.txt').save('three')
+    tar_file = @cotta.file('target.tar')
+    source.archive(tar_file)
+    
+    target_dir = @cotta.dir('target')
+    tar_file.extract(target_dir)
+    target_dir.file('one.txt').load.should == 'one'
+    target_dir.file('two.txt').load.should == 'two'
+    target_dir.file('three.txt').load.should == 'three'
+    target_dir.should have(3).list
+  end
+
+  it 'archive subdirectories' do
+      source = @cotta.dir('dir/source')
+      sub = source.dir('sub')
+      sub.file('one.txt').save('one')
+      sub.file('two.txt').save('two')
+      tar_file = @cotta.file('target.tar')
+      source.archive(tar_file)
+
+      target_dir = @cotta.dir('target')
+      tar_file.extract(target_dir)
+      target_dir.should have(1).list
+      target_dir.dir('sub').should be_exists
+      target_dir.dir('sub').should have(2).list
+      target_dir.file('sub/one.txt').load.should == 'one'
+      target_dir.file('sub/two.txt').load.should == 'two'
+  end
+end
+end

data/test/cotta/example_spec.rb

@@ -0,0 +1,20 @@
+require 'spec'
+
+require File.dirname(__FILE__) + '/../test'
+
+describe Cotta do
+  it 'should run example' do
+    #system implementation is injected here
+    cotta = Cotta.in_memory
+    file = cotta.file('dir/file.txt')
+    file.should_not be_exists
+    # parent directories are created automatically
+    file.save('my content')
+    file2 = cotta.file('dir/file2.txt')
+    file2.should_not be_exists
+    file.copy_to(file2)
+    file2.should be_exists
+    file2.load.should == 'my content'
+    file2.read {|file| puts file.gets}
+  end
+end

data/test/cotta/file_factory_spec.rb

@@ -0,0 +1,54 @@
+require 'spec'
+
+require File.dirname(__FILE__) + '/../test'
+
+describe Cotta do
+  before do
+    # Given
+    @system = Cotta::InMemorySystem.new
+    @cotta = Cotta::FileFactory.new(@system)
+  end
+  
+=begin not for release 1.0
+  it 'shell out command to system' do
+    # Given
+    # When
+    @system.output_for_command('shell command', 'test')
+    @cotta.shell('shell command')
+    # Ensure
+    @system.executed_commands.length.should== 1
+    @system.executed_commands[0].should == 'shell command'
+  end
+=end
+  
+  it 'instantiate dir from cotta' do
+    dir = @cotta.dir('dirname')
+    dir.name.should == 'dirname'
+  end
+  
+  it 'instantiate file from cotta' do
+    file = @cotta.file('one/two/three.txt')
+    file.name.should == 'three.txt'
+    file.parent.name.should == 'two'
+  end
+  
+  it 'entry creates file or directory based on which one exists' do
+    @cotta.file('file').save
+    @cotta.dir('dir').mkdirs
+    @cotta.entry('file').should be_exist
+    @cotta.entry('dir').should be_exist
+  end
+  
+  it 'nil in, nil out' do
+    @cotta.file(nil).should be_nil
+    @cotta.dir(nil).should be_nil
+    Cotta.file(nil).should be_nil
+    Cotta.dir(nil).should be_nil
+  end
+  
+  it 'create parent directory directly from __FILE__' do
+    actual = Cotta.parent_dir(__FILE__)
+    actual.name.should == 'cotta'
+  end
+  
+end

data/test/cotta/file_system_behaviors.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/../test'
+
+module Cotta
+  describe 'FileSystemBehaviors', :shared=>true do
+    before do
+      create_system
+    end
+
+    it 'current directory always exists' do
+      @system.dir_exists?(Pathname.new('.')).should == true
+    end
+
+    it 'mkdir should create directory' do
+      pathname = Pathname.new('/one')
+      @system.dir_exists?(pathname).should == false
+      @system.mkdir(pathname)
+      @system.dir_exists?(pathname).should == true
+    end
+
+    it 'mkdir raise error if dir already exists' do
+      pathname = Pathname.new('/one')
+      @system.mkdir(pathname)
+      lambda {
+        @system.mkdir
+      }.should raise_error(StandardError)
+    end
+
+    it 'io returns IO handle' do
+      pathname = Pathname.new('file.txt')
+      @system.file_exists?(pathname).should == false
+      write_io = load_io(pathname, 'w')
+      write_io.puts 'content'
+      write_io.close
+      @system.file_exists?(pathname).should == true
+      read_io = load_io(pathname, 'r')
+      read_io.gets.should == "content\n"
+      read_io.close
+      @system.delete_file(pathname)
+    end
+
+    it 'file creation should leave file system consistent' do
+      pathname = Pathname.new('dir/sub/file.txt')
+      @system.mkdir(pathname.parent.parent)
+      @system.mkdir(pathname.parent)
+      @system.file_exists?(pathname).should == false
+      @system.dir_exists?(pathname.parent).should == true
+      load_io(pathname, 'w').close
+      @system.file_exists?(pathname).should == true
+      @system.dir_exists?(pathname).should == false
+      @system.dir_exists?(pathname.parent).should == true
+      children = @system.list(pathname.parent)
+      children.size.should == 1
+      children[0].should == pathname.basename.to_s
+    end
+
+    it 'directory creation should leave file system consistent' do
+      pathname = Pathname.new('root/dir/sub')
+      @system.dir_exists?(pathname).should == false
+      @system.file_exists?(pathname).should == false
+      @system.dir_exists?(pathname.parent).should == false
+      @system.mkdir(pathname.parent.parent)
+      @system.mkdir(pathname.parent)
+      @system.mkdir(pathname)
+      @system.dir_exists?(pathname).should == true
+      @system.file_exists?(pathname).should == false
+      @system.dir_exists?(pathname.parent).should == true
+      list = @system.list(pathname.parent)
+      list.size.should == 1
+      list[0].should ==(pathname.basename.to_s)
+    end
+
+    it 'read io should raise error if file does not exists' do
+      pathname = Pathname.new('dir/file.txt')
+      Proc.new {
+        @system.io(pathname, 'r')
+      }.should raise_error(Errno::ENOENT)
+    end
+
+    it 'delete dir' do
+      pathname = Pathname.new('dir')
+      @system.mkdir(pathname)
+      @system.delete_dir(pathname)
+      @system.dir_exists?(pathname).should == false
+    end
+
+    it 'deleting dir that does not exist should raise error' do
+      pathname = Pathname.new('dir/dir2')
+      Proc.new {
+        @system.delete_dir(pathname)
+      }.should raise_error(Errno::ENOENT)
+    end
+
+    it 'copy file' do
+      pathname = Pathname.new('file1')
+      write_io = load_io(pathname, 'w')
+      write_io.puts 'line'
+      write_io.close
+      target = Pathname.new('target')
+      @system.copy_file(pathname, target)
+      @system.file_exists?(target).should == true
+      read_io = load_io(target, 'r')
+      read_io.gets.should == "line\n"
+      read_io.close
+    end
+
+    it 'move file' do
+      pathname = Pathname.new('file1')
+      write_content(pathname, 'line')
+      target = Pathname.new('target')
+      @system.move_file(pathname, target)
+      @system.file_exists?(target).should == true
+      read_io = load_io(target, 'r')
+      read_io.gets.should == "line\n"
+      read_io.close
+      @system.file_exists?(pathname).should == false
+    end
+
+    it 'move dir' do
+      source = Pathname.new('source')
+      @system.mkdir source
+      source_file = Pathname.new('source/file.txt')
+      write_content(source_file, 'file.txt')
+      @system.mkdir source.join('subdir')
+      target = Pathname.new('target')
+      @system.move_dir(source, target)
+      @system.list(target).size.should == 2
+      @system.dir_exists?(source).should == false
+      @system.dir_exists?(target).should == true
+      @system.file_exists?(Pathname.new('target/file.txt')).should == true
+      @system.dir_exists?(Pathname.new('target/subdir')).should == true
+    end
+
+    it 'copy dir' do
+      source = Pathname.new('source')
+      @system.mkdir source
+      source_file = Pathname.new('source/file.txt')
+      write_content(source_file, 'file.txt')
+      @system.mkdir source.join('subdir')
+      target = Pathname.new('target')
+      @system.copy_dir(source, target)
+      @system.list(target).size.should == 2
+      @system.dir_exists?(source).should == true
+      @system.dir_exists?(target).should == true
+      @system.file_exists?(Pathname.new('target/file.txt')).should == true
+    end
+
+    def write_content(pathname, content)
+      write_io = load_io(pathname, 'w')
+      write_io.puts content
+      write_io.close
+    end
+
+    def load_io(*args)
+      io = @system.io(*args)
+      if (io)
+        @ios.push(io)
+      else
+        raise "IO is null for: #{args}"
+      end
+      return io
+    end
+  end
+end

data/test/cotta/in_memory_system_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../test'
+require File.dirname(__FILE__) + '/file_system_behaviors'
+
+module Cotta
+
+describe InMemorySystem do
+  it_should_behave_like 'FileSystemBehaviors'
+
+  def create_system
+    @system = InMemorySystem.new
+    @ios = Array.new
+  end
+  
+  after do
+    @ios.each {|io| io.close unless io.closed?}
+  end
+  
+  it 'root directory always exists' do
+    @system.dir_exists?(Pathname.new('/')).should == true
+    @system.dir_exists?(Pathname.new('D:/')).should == true
+  end
+  
+end
+end

data/test/cotta/pathname_spec.rb

@@ -0,0 +1,20 @@
+require 'spec'
+require File.dirname(__FILE__) + '/../test'
+
+describe Pathname do
+  it 'parent check for unix path' do
+    pathname = Pathname.new('/')
+    pathname.cotta_parent.should be_nil
+  end
+  
+  it 'parent check for windows path' do
+    pathname = Pathname.new('D:/')
+    pathname.cotta_parent.should be_nil
+  end
+  
+  it 'parent check for normal ppl' do
+    pathname = Pathname.new('/test')
+    pathname.cotta_parent.should == Pathname.new('/')
+  end
+  
+end

data/test/cotta/physical_system_spec.rb

@@ -0,0 +1,34 @@
+require 'spec'
+dir = File.dirname(__FILE__)
+require dir + '/../test'
+require dir + '/file_system_behaviors'
+
+module Cotta
+
+describe PhysicalSystem do
+  it_should_behave_like "FileSystemBehaviors"
+  def create_system
+    @system = PhysicalSystemStub.new
+    @ios = Array.new
+  end
+  
+  after do
+    @ios.each {|io| io.close unless io.closed?}
+  end
+
+  it 'root directory always exists' do
+    @system = PhysicalSystem.new
+    @system.dir_exists?(Pathname.new('/')).should == true
+    @system.dir_exists?(Pathname.new('D:/')).should == true
+  end
+  
+  it 'shell command should return output' do
+    @system = PhysicalSystem.new
+    @system.shell('ruby --version')[0..3].should == 'ruby'
+  end
+
+  it 'should equals to any other physical system' do
+    PhysicalSystem.new.should == PhysicalSystem.new
+  end
+end
+end

data/test/cotta/physical_system_stub.rb

@@ -0,0 +1,122 @@
+module Cotta
+class PhysicalSystemStub
+  attr_reader :executed_commands
+
+  def initialize
+    @executed_commands = Array.new
+    tmp_path = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'tmp'))
+    @system = PhysicalSystem.new
+    ensure_clean_directory(tmp_path)
+    Dir.mkdir(File.join(tmp_path, 'current'))
+    Dir.mkdir(File.join(tmp_path, 'root'))
+    @tmp_path = Pathname.new(tmp_path)
+  end
+  
+  def shell(command, &block)
+    @executed_commands.push command
+  end
+  
+  def dir_exists?(pathname)
+    @system.dir_exists?(relative_from_tmp(pathname))
+  end
+  
+  def file_exists?(pathname)
+    @system.file_exists?(relative_from_tmp(pathname))
+  end
+  
+  def dir_stat(pathname)
+    @system.dir_stat(relative_from_tmp(pathname))
+  end
+  
+  def file_stat(pathname)
+    @system.file_stat(relative_from_tmp(pathname))
+  end
+  
+  def list(pathname)
+    @system.list(relative_from_tmp(pathname))
+  end
+  
+  def mkdir(pathname)
+    @system.mkdir(relative_from_tmp(pathname))
+  end
+  
+  def delete_file(pathname)
+    @system.delete_file(relative_from_tmp(pathname))
+  end
+  
+  def delete_dir(pathname)
+    @system.delete_dir(relative_from_tmp(pathname))
+  end
+  
+  def io(pathname, arguments)
+    @system.io(relative_from_tmp(pathname), arguments)
+  end
+  
+  def copy_file(source, target)
+    @system.copy_file(relative_from_tmp(source), relative_from_tmp(target))
+  end
+  
+  def move_file(source, target)
+    @system.move_file(relative_from_tmp(source), relative_from_tmp(target))
+  end
+  
+  def copy_dir(source, target)
+    @system.copy_dir(relative_from_tmp(source), relative_from_tmp(target))
+  end
+  
+  def move_dir(source, target)
+    @system.move_dir(relative_from_tmp(source), relative_from_tmp(target))
+  end
+  
+  def copy_dir(source, target)
+    @system.copy_dir(relative_from_tmp(source), relative_from_tmp(target))
+  end
+  
+  def chdir(path, &block)
+    @system.chdir(relative_from_tmp(path), &block)
+  end
+  
+  def pwd
+    path = @system.pwd
+    candidate = relative_from_tmp(Pathname.new('/')).expand_path.to_s
+    if (path.index(candidate) == 0)
+      result = path[candidate.length, path.length - candidate.length]
+    else
+      candidate = relative_from_tmp(Pathname.new('.')).expand_path.to_s
+      if candidate == path
+        result = '.'
+      else
+        result = path[candidate.length + 1, path.length - candidate.length - 1]
+      end
+    end
+    result
+  end
+  
+  private
+  def relative_from_tmp(pathname)
+    tmp_pathname = nil
+    if (pathname.absolute?)
+      tmp_pathname = Pathname.new("root#{pathname}")
+    else
+      tmp_pathname = Pathname.new("current").join(pathname)
+    end
+    return @tmp_path.join(tmp_pathname)
+  end
+  
+  def ensure_clean_directory(path)
+    Dir.mkdir path unless File.directory? path
+    Dir.foreach(path) do |name|
+      if (name != '.' && name != '..')
+        child_path = File.join(path, name)
+        if (File.directory? child_path)
+          ensure_clean_directory(child_path)
+          Dir.rmdir(child_path)
+        else
+          File.delete(child_path)
+        end
+      end
+    end
+  end
+    
+end
+end