cotta 1.0.0

data/lib/cotta/impl/physical_system.rb

@@ -0,0 +1,90 @@
+module Cotta
+  class PhysicalSystem
+    def initialize
+    end
+
+    # Invoke the command passed in through the CommandRunner
+    # and pass in the closure.
+    def shell(command, &block)
+      runner = CommandRunner.new(command)
+      runner.execute(&block)
+    end
+
+    def environment!(variable)
+      value = ENV[variable]
+      raise "#{variable} environment variable not found" unless value
+      return value
+    end
+
+    def environment(variable, default)
+      value = ENV[variable]
+      value = default unless value
+      return value
+    end
+
+    def dir_exists?(dir_path)
+      return FileTest.directory?(dir_path)
+    end
+
+    def file_exists?(file_path)
+      return FileTest.file?(file_path)
+    end
+
+    def dir_stat(path)
+      File.stat(path)
+    end
+
+    def file_stat(path)
+      File.stat(path)
+    end
+
+    def list(dir_path)
+      Dir.entries(dir_path).find_all {|item| item != '.' && item != '..'}
+    end
+
+    def mkdir(dir_path)
+      Dir.mkdir(dir_path)
+    end
+
+    def io(file_path, argument)
+      return File.open(file_path, argument)
+    end
+
+    def delete_file(file_path)
+      return File.delete(file_path)
+    end
+
+    def delete_dir(dir_path)
+      return Dir.delete(dir_path)
+    end
+
+    def copy_file(source, target)
+      FileUtils.copy(source, target)
+    end
+
+    def move_file(source, target)
+      FileUtils.move(source, target)
+    end
+
+    def copy_dir(source, target)
+      FileUtils.copy_entry(source, target)
+    end
+
+    def move_dir(source, target)
+      FileUtils.mv(source, target)
+    end
+
+    def chdir(target, &block)
+      Dir.chdir(target, &block)
+    end
+
+    def pwd
+      Dir.pwd
+    end
+
+    def ==(other)
+      other.class == PhysicalSystem
+    end
+
+  end
+end

data/lib/cotta/version

@@ -0,0 +1 @@
+1.0.0

data/test/cotta/command_interface_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../test'
+
+module Cotta
+describe CommandInterface do
+  it 'delegate output to io' do
+    io = mock('io')
+    io.should_receive(:puts).with('content to output')
+    interface = CommandInterface.new(io)
+    interface.puts('content to output')
+  end
+  
+  it 'prompt outputs a message and get the response from io' do
+    io = mock('io')
+    io.should_receive(:puts).with('question')
+    io.should_receive(:gets).and_return('answer')
+    interface = CommandInterface.new(io)
+    actual = interface.prompt('question')
+    actual.should == 'answer'
+  end
+    
+  it 'prompt for choice' do
+    io = mock('io')
+    io.should_receive(:puts).once.with('select one of the following')
+    io.should_receive(:puts).once.with('[1] item one')
+    io.should_receive(:puts).once.with('[2] item two')
+    io.should_receive(:gets).once.and_return('2')
+    interface = CommandInterface.new(io)
+    actual = interface.prompt_for_choice('select one of the following', ['item one', 'item two'])
+    actual.should == 'item two'
+  end
+  
+  it 'prompt for choice returns nil for invalid choice' do
+    io = mock('io')
+    io.should_receive(:puts).with('select one')
+    io.should_receive(:puts).exactly(2).times
+    io.should_receive(:gets).and_return('9')
+    interface = CommandInterface.new(io)
+    actual = interface.prompt_for_choice('select one', ['one', 'two'])
+    actual.should be_nil
+  end
+end
+end

data/test/cotta/command_runner_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../test'
+
+module Cotta
+describe CommandRunner do
+  it 'return content' do
+    runner = CommandRunner.new('ruby --version')
+    runner.execute[0..3].should == 'ruby'
+  end
+  
+  it 'raise error on abnormal exits' do
+    runner = CommandRunner.new('ruby ----')
+    Proc.new{runner.execute}.should raise_error(CommandError)
+  end
+  
+  it 'take closure as io processor' do
+    runner = CommandRunner.new('echo test')
+    message_logged = nil
+    runner.execute {|io| message_logged = io.gets}
+    message_logged.should == "test\n"
+  end
+  
+end
+
+end

data/test/cotta/content.txt

@@ -0,0 +1,3 @@
+line one
+line two
+line three

data/test/cotta/cotta_dir_behaviors.rb

@@ -0,0 +1,202 @@
+require File.dirname(__FILE__) + '/../test'
+require 'spec'
+require 'pathname'
+
+describe 'CottaDirBehaviors', :shared=>true do
+  before do
+    @system = create_system
+    @root = Cotta::CottaDir.new(@system, Pathname.new('.'))
+    @dir = @root.dir('dir')
+    @current = Dir.pwd
+  end
+
+  after do
+    Dir.chdir @current
+  end
+
+  it 'load dir with basic information' do
+    @dir.name.should == 'dir'
+  end
+
+  it 'should show path on to_s for convenience in scripting' do
+    @dir.to_s.should == 'dir'
+    "#{@dir}".should == 'dir'
+  end
+
+  it 'dir objects are value objects, equal on system and path' do
+    (Cotta::CottaDir.new(@system, Pathname.new('dir')) == @dir).should == true
+  end
+
+  it 'dir should not be equal if path different' do
+    (Cotta::CottaDir.new(@system, Pathname.new('/dir')) == @dir).should == false
+  end
+
+  it 'should support relative path' do
+    sub_dir = @dir.dir('one/two/three')
+    sub_dir.relative_path_from(@dir).to_s.should == 'one/two/three'
+  end
+
+  it 'should know its parent' do
+    @dir.parent.name.should == '.'
+    @dir.parent.parent.should be_nil
+  end
+
+  it 'should look up parent' do
+    sub_dir = @dir.dir('one/two/three')
+    result = sub_dir.parent {|dir| dir.name == 'one'}
+    result.should == @dir.dir('one')
+  end
+
+  it 'should return nil if parent lookup fails' do
+    sub_dir = @dir.dir('one/two/three')
+    sub_dir.parent {|dir| false}.should be_nil
+  end
+
+  it 'should raise error if not exits stat' do
+    Proc.new {
+      @dir.stat
+    }.should raise_error(Errno::ENOENT)
+  end
+
+  it 'support stat' do
+    @dir.mkdirs
+    @dir.stat.should_not be_nil
+  end
+
+  it 'dir should handle root dir' do
+    dir = Cotta::CottaDir.new(@system, Pathname.new('/root'))
+    dir.parent.path.should == Pathname.new('/')
+    dir.parent.name.should == '/'
+    dir.parent.exists?.should == true
+    dir.parent.root?.should == true
+    dir.parent.parent.should be_nil
+  end
+
+  it 'dir should handle root dir for drive letters' do
+    dir = Cotta::CottaDir.new(@system, Pathname.new('C:/Windows'))
+    dir.name.should == 'Windows'
+    dir.parent.path.should == Pathname.new('C:/')
+    dir.parent.name.should == 'C:/'
+  end
+
+  it 'dir should return sub directory' do
+    @dir.dir('sub').path.should == Pathname.new('dir/sub')
+    @dir.dir('sub').parent.should == @dir
+  end
+
+  it 'dir should return a directory from a relative pathname' do
+    @dir.dir(Pathname.new('one/two/three')).should == @dir.dir('one').dir('two').dir('three')
+  end
+
+  it 'should get file in current directory' do
+    file = @dir.file('file.txt')
+    file.name.should == 'file.txt'
+    file.path.should == Pathname.new('dir/file.txt')
+    file.parent.should == @dir
+  end
+
+  it 'should create dir and its parent' do
+    dir = @dir.dir('one').dir('two')
+    dir.exists?.should == false
+    dir.parent.exists?.should == false
+    dir.mkdirs
+    dir.exists?.should == true
+    dir.parent.exists?.should == true
+  end
+
+  it 'should delete dir and its children' do
+    dir = @dir.dir('one').dir('two').dir('three')
+    dir.mkdirs
+    @dir.exists?.should == true
+    @dir.delete
+    dir.exists?.should == false
+    @dir.exists?.should == false
+  end
+
+  it 'should do nothing if dir does not exist' do
+    dir = @dir.dir('one/two')
+    dir.delete
+    dir.delete
+  end
+
+  it 'should do nothing on mkdir if dir already exists' do
+    dir = @dir.dir('one').dir('two')
+    dir.mkdirs
+    dir.mkdirs
+  end
+
+  it 'should list dirs' do
+    @dir.dir('one').mkdirs
+    @dir.file('one.txt').save
+    actual_dir_list = @dir.list
+    actual_dir_list.size.should == 2
+    actual_dir_list[0].name.should == 'one'
+    actual_dir_list[0].list.size.should == 0
+    actual_dir_list[1].name.should == 'one.txt'
+    actual_dir_list[1].save
+  end
+
+  it 'should move directory with its children' do
+    dir = Cotta::CottaDir.new(@system, Pathname.new('targetdir/child_dir'))
+    @dir.file('file.txt').save('file.txt')
+    @dir.dir('subdir').mkdirs
+    @dir.list.size.should == 2
+    @dir.move_to(dir)
+    @dir.exists?.should == false
+    dir.list.size.should == 2
+    dir.file('file.txt').load.should == 'file.txt'
+    dir.dir('subdir').exists?.should == true
+  end
+
+  it 'should copy directory with its children' do
+    dir = Cotta::CottaDir.new(@system, Pathname.new('targetdir/child_dir'))
+    @dir.file('file.txt').save('file.txt')
+    @dir.dir('subdir').mkdirs
+    @dir.list.size.should == 2
+    @dir.copy_to(dir)
+    @dir.exists?.should == true
+    dir.list.size.should == 2
+    dir.file('file.txt').load.should == 'file.txt'
+    dir.dir('subdir').exists?.should == true
+  end
+
+  it 'dir takes relative path' do
+    dir = Cotta::CottaDir.new(@system, Pathname.new('targetdir/dir'))
+    @dir.dir('one/two/three').mkdirs
+    @dir.dir('one').exists?.should == true
+    @dir.dir('one').dir('two').exists?.should == true
+    @dir.dir('one').dir('two').dir('three').exists?.should == true
+  end
+
+  it 'list on not existing directory' do
+    dir = Cotta::CottaDir.new(@system, Pathname.new('no/such/directory'))
+    Proc.new do
+      dir.list
+    end.should raise_error(Errno::ENOENT)
+  end
+
+  it 'allow filter for archive' do
+    @dir.file('in/in.txt').save('test')
+    @dir.file('out/out.txt').save('test')
+    result = @dir.archive {|entry|entry.name != 'out' }
+    target = result.extract(@dir.dir('extract'))
+    target.dir('out').should_not be_exist
+    target.dir('in').should be_exist
+  end
+
+  it 'should support changing directory' do
+    dir = @dir.dir('one/two')
+    file = @dir.file('marker').save('marker')
+    dir.mkdirs
+    result = dir.chdir
+    result.should == 0
+    current = dir.factory.pwd
+    value = @root.chdir do
+      dir.factory.pwd.should == @root
+      'value'
+    end
+    value.should == 'value'
+    dir.factory.pwd.should == current
+  end
+
+end

data/test/cotta/cotta_dir_in_memory_spec.rb

@@ -0,0 +1,23 @@
+require 'spec'
+
+dir = File.dirname(__FILE__)
+require dir + '/../test'
+require dir + '/cotta_dir_behaviors'
+
+describe Cotta::InMemorySystem, 'with Cotta Dir' do
+  it_should_behave_like 'CottaDirBehaviors'
+
+  def create_system
+    @system = Cotta.in_memory
+  end
+
+  it 'dir should not be equal if system different' do
+    (Cotta::CottaDir.new(Cotta.in_memory, Pathname.new('dir')) == @dir).should == false
+  end
+
+  it 'to_s and inspect' do
+    file = Cotta::CottaFile.new(@system, '/one/two/file.txt')
+    "#{file.to_s}".should == '/one/two/file.txt'
+  end
+
+end

data/test/cotta/cotta_dir_physical_spec.rb

@@ -0,0 +1,14 @@
+require 'spec'
+require File.join(File.dirname(__FILE__)) + '/../test'
+require File.join(File.dirname(__FILE__)) + '/cotta_dir_behaviors'
+
+module Cotta
+describe PhysicalSystem, 'work with CottaDir' do
+  it_should_behave_like 'CottaDirBehaviors'
+
+  def create_system
+    @system = Cotta::FileFactory.new(PhysicalSystemStub.new)
+  end
+  
+end
+end

data/test/cotta/cotta_file_behaviors.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../test'
+require 'spec'
+require 'pathname'
+
+module Cotta
+  describe 'CottaFileBehaviors', :shared => true do
+    before do
+      @system = create_system
+      @file = CottaFile.new(@system, Pathname.new('dir/file.txt'))
+    end
+    it 'file can be created with system and pathname' do
+      @file.name.should == 'file.txt'
+      @file.path.should == Pathname.new('dir/file.txt')
+      @file.exists?.should == false
+    end
+
+    it 'should return path on to_s for scripting convenience' do
+      @file.to_s.should == 'dir/file.txt'
+      "#{@file}".should == 'dir/file.txt'
+    end
+
+    it 'file should know properties like parent, name, etc.' do
+      @file.parent.should == CottaDir.new(@system, Pathname.new('dir'))
+      @file.name.should == 'file.txt'
+      @file.path.should == Pathname.new('dir/file.txt')
+      @file.extname.should == '.txt'
+      @file.basename.should == 'file'
+    end
+
+    it 'should support relative path' do
+      parent = @file.parent
+      file = parent.file('one/two/three.txt')
+      file.relative_path_from(parent).to_s.should == 'one/two/three.txt'
+    end
+
+    it 'file should support stat' do
+      @file.save('test')
+      @file.stat.should_not be_nil
+      @file.stat.size.should == 4
+      @file.stat.writable?.should == true
+    end
+
+    it 'should raise error if does not exist' do
+      Proc.new {
+        @file.stat
+      }.should raise_error(Errno::ENOENT)
+    end
+
+    it 'should load and save file content' do
+      @file.exists?.should == false
+      @file.parent.exists?.should == false
+      @file.save("content to save\nsecond line")
+      @file.exists?.should == true
+      @file.load.should ==("content to save\nsecond line")
+    end
+
+    it 'should open file to read' do
+      @file.save("one\ntwo")
+      @file.read do |file|
+        file.gets.should ==("one\n")
+        file.gets.should ==('two')
+      end
+    end
+
+    it 'should equal if same system and pathname' do
+      file2 = CottaFile.new(@system, Pathname.new('dir/file.txt'))
+      file2.should == @file
+    end
+
+    it 'should copy to another file' do
+      file2 = CottaFile.new(@system, Pathname.new('dir2/file.txt'))
+      file2.exists?.should == false
+      @file.save('my content')
+      @file.copy_to(file2)
+      file2.exists?.should == true
+      file2.load.should == 'my content'
+    end
+
+    it 'should move file' do
+      file2 = CottaFile.new(@system, Pathname.new('dir2/file.txt'))
+      file2.exists?.should == false
+      @file.save('content')
+      @file.move_to(file2)
+      file2.exists?.should == true
+      file2.load.should == 'content'
+      @file.exists?.should == false
+    end
+
+    it 'should support foreach' do
+      @file.write do |file|
+        file.puts 'line one'
+        file.puts 'line two'
+      end
+      collected = Array.new
+      @file.foreach do |line|
+        collected.push line
+      end
+      collected.size.should == 2
+      collected[0].should == "line one\n"
+      collected[1].should == "line two\n"
+    end
+
+    it 'should delete file' do
+      @file.save
+      @file.exists?.should == true
+      @file.delete
+      @file.exists?.should == false
+    end
+
+    it 'should raise error if file to delete does not exist' do
+      lambda {
+        @file.delete
+      }.should raise_error(Errno::ENOENT)
+    end
+
+    it 'should check timestamp to see which one is older' do
+      @file.save
+      file2 = @file.parent.file('another.txt')
+      sleep 1
+      file2.save
+      file2.older_than?(@file).should == false
+      @file.older_than?(file2).should == true
+    end
+
+    it 'copy binary io' do
+      file = FileFactory.parent_dir(__FILE__).file('logo.gif')
+      target = @file
+      file.read_binary do |input|
+        target.write_binary do |output|
+          CottaFile.copy_io(input, output)
+        end
+      end
+      expect_stat = file.stat
+      actual_stat = target.stat
+      actual_stat.size.should == expect_stat.size
+    end
+  end
+
+end