cotta 1.0.0

data/README

@@ -0,0 +1,75 @@
+Welcome to the Ruby version of the {Cotta file API}[http://cotta.rubyforge.org]
+
+= Introduction
+
+Cotta project is created to provide a lightweight, simple and sensible API to file operation and testing.
+See {Cotta Power}[http://cotta.sourceforge.net/power.html] for its motivation
+
+
+= Install It
+
+The easiest way to install the install cotta using RubyGems:
+
+  sudo gem install cotta
+
+= Features
+
+Cotta is just a plain Ruby API, so you can use it wherever you can use Ruby.
+
+To used the new API just require the client driver:
+
+   require "rubygems"
+   require "cotta"
+
+For a fully backward compatible API you can start with:
+
+   require "rubygems"
+   gem "cotta"
+   require "cotta"
+
+For instance
+to write a little Ruby script using cotta you could write something like:
+
+    #!/usr/bin/env ruby
+    #
+    # Sample Ruby script using the Cotta API
+    #
+    require "rubygems"
+    gem "cotta", ">=1.0.0"
+    require "cotta"
+
+    #system implementation is injected here
+    cotta = Cotta.physical
+    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}
+
+= Writing Tests
+
+To test your code that uses Cotta API, you just need to pass in a Cotta instance that is backed by an in-memory
+file system:
+
+    cotta = Cotta.in_memory
+
+= Resources
+
+* Source Code at http://github.com/wolfdancer/cotta
+* Report bugs at http://github.com/wolfdancer/cotta/issues
+* Browse API at http://cotta.rubyforge.org
+* Discuss at http://groups.google.com/group/cotta
+
+= Reports
+
+* rSpec: {rspec}[link:rspec/index.html]
+* code coverage:{rcov}[link:rcov/index.html]
+
+= Team
+
+* Shane Duan

data/lib/cotta.rb

@@ -0,0 +1,12 @@
+require 'pathname'
+require File.dirname(__FILE__) + '/cotta/cotta'
+require File.dirname(__FILE__) + '/cotta/cotta_dir'
+require File.dirname(__FILE__) + '/cotta/cotta_file'
+require File.dirname(__FILE__) + '/cotta/impl/cotta_pathname'
+require File.dirname(__FILE__) + '/cotta/impl/in_memory_system'
+require File.dirname(__FILE__) + '/cotta/impl/physical_system'
+require File.dirname(__FILE__) + '/cotta/impl/command_error'
+require File.dirname(__FILE__) + '/cotta/impl/command_interface'
+require File.dirname(__FILE__) + '/cotta/file_not_found_error'
+require File.dirname(__FILE__) + '/cotta/impl/command_runner'
+require File.dirname(__FILE__) + '/cotta/file_factory'

data/lib/cotta/cotta.rb

@@ -0,0 +1,37 @@
+# Cotta module that contains all the classes used for file operations
+# see link:files/README.html
+# There are also four methods on the module for the most common ways to
+# start with Cotta API
+module Cotta
+  # Creates CottaFile repersenting physical file
+  def self::file(path)
+    FileFactory.file(path)
+  end
+
+  # Creates CottaDir representing physical directory
+  def self::dir(path)
+    FileFactory.dir(path)
+  end
+
+  # Creates CottaDir that is the parent of the path
+  # This is typically used with __FILE__
+  # e.g. dir = Cotta.parent_dir(__FILE__)
+  def self.parent_dir(path)
+    FileFactory.parent_dir(path)
+  end
+
+  # Returns the file facotry backed by physical system
+  def self::physical
+    FileFactory.physical
+  end
+
+  # Returns the file factory backed by in-memory system
+  def self::in_memory
+    FileFactory.in_memory
+  end
+
+  # returns the file factory backed by the given system
+  def self::factory(system)
+    FileFactory.new(system)
+  end
+end

data/lib/cotta/cotta_dir.rb

@@ -0,0 +1,184 @@
+module Cotta
+  # This class represents a directory
+  class CottaDir
+    # Path of the directory
+    attr_reader :path
+    
+    # file factory of the directory
+    attr_reader :factory
+
+    # Create an instance of CottaDir that is on
+    # the given path and
+    # backed by the given system
+    def initialize(factory, path)
+      @path = path
+      @factory = factory
+      @name = @path.basename.to_s
+    end
+
+    # name of the directory
+    def name
+      name = nil
+      if root?
+        name = path.to_s
+      else
+        name = @path.basename.to_s
+      end
+      return name
+    end
+
+    # returns true if this directory is the root directory
+    def root?
+      parent.nil?
+    end
+
+    # returns true if this directory exists
+    def exists?
+      factory.system.dir_exists?(@path)
+    end
+
+    # returns the stat of the current directory
+    def stat
+      factory.system.dir_stat(@path)
+    end
+
+    # returns the parent directory of this directory
+    # or nil if this is root
+    def parent
+      parent_path = @path.cotta_parent
+      return nil unless parent_path
+      candidate = CottaDir.new(factory, parent_path)
+      if (block_given?)
+        candidate = candidate.parent until candidate.nil? or yield candidate
+      end
+      candidate
+    end
+
+    # returns the relative path from the given file or directory
+    def relative_path_from(entry)
+      @path.relative_path_from(entry.path)
+    end
+
+    # returns the sub-directory with the given name
+    def dir(name)
+      return CottaDir.new(factory, @path.join(name))
+    end
+
+    # returns the file under this directory with the given name
+    def file(name)
+      return CottaFile.new(factory, @path.join(name))
+    end
+
+    # creates this directory and its parent directory
+    def mkdirs
+      if (not exists?)
+        parent.mkdirs
+        factory.system.mkdir @path
+      end
+    end
+
+    # deletes this directory and all its children
+    def delete
+      if (exists?)
+        list.each do |children|
+          children.delete
+        end
+        factory.system.delete_dir(@path)
+      end
+    end
+
+    # move this directory to target directory
+    # this method assumes that this directory and the target directory
+    # are backed by the same file system
+    def move_to(target)
+      target.parent.mkdirs
+      factory.system.move_dir(@path, target.path)
+    end
+
+    # move this directory to target path
+    # this method assumes that this directory and the target directory
+    # are backed by the same file system
+    def move_to_path(target_path)
+      move_to(cotta.dir(target_path))
+    end
+
+    # copy this directory to target directory
+    # this method assumes that this directory and the target directory
+    # are backed by the same file system
+    def copy_to(target)
+      target.parent.mkdirs
+      factory.system.copy_dir(@path, target.path)
+    end
+
+    # archive this directory and call the given block
+    # to determine if a file or directory should be included
+    def archive(target = nil, &block)
+      require 'rubygems/package'
+      unless target
+        target = parent.file("#{name}.tar")
+      end
+      target.write_binary do |io|
+        writer = Gem::Package::TarWriter.new(io) do |tar_io|
+          archive_dir(tar_io, self, &block)
+        end
+      end
+      target
+    end
+
+    def archive_dir(tar_io, dir, &block)
+      dir.list.each do |child|
+        if (block_given? and not yield child)
+          next
+        end
+        stat = child.stat
+        entry_name = child.relative_path_from(self).to_s
+        mode = stat.mode
+        if (stat.file?)
+          tar_io.add_file(entry_name, mode) do |entry_output|
+            child.read_binary do |input|
+              CottaFile.copy_io(input, entry_output)
+            end
+          end
+        elsif (stat.directory?)
+          tar_io.mkdir(entry_name, mode)
+          archive_dir(tar_io, child, &block)
+        end
+      end
+    end
+
+    private :archive_dir
+
+    def copy_to_path(target_path)
+      copy_to(cotta.dir(target_path))
+    end
+
+    # returns the content of this directory
+    # as an array of CottaFile and CottaDirectory
+    def list
+      factory.system.list(@path).collect do |item|
+        candidate = dir(item)
+        if (not candidate.exists?)
+          candidate = file(item)
+        end
+        candidate
+      end
+    end
+
+    def chdir(&block)
+      factory.system.chdir(@path, &block)
+    end
+
+    def ==(other)
+      return @path == other.path && factory.system == other.factory.system
+    end
+
+    def inspect
+      return "#{self.class}:#{self.object_id}-#@path"
+    end
+
+    def to_s
+      @path.to_s
+    end
+
+  end
+end

data/lib/cotta/cotta_file.rb

@@ -0,0 +1,253 @@
+require 'fileutils'
+
+module Cotta
+  # This class represents a file
+  class CottaFile
+    # factory with the backing system
+    attr_reader :factory
+    # path of this file
+    attr_reader :path
+    # stats of this file
+    attr_reader :stat
+
+    # creates an instance of file with the given factory and path
+    def initialize(factory, path)
+      @path = path
+      @factory = factory
+    end
+
+    # name of this file
+    def name
+      return @path.basename.to_s
+    end
+
+    # extension of this file, with '.'
+    def extname
+      return @path.extname
+    end
+
+    # basename of this file
+    def basename
+      return @path.basename(extname).to_s
+    end
+
+    # stats of this file
+    def stat
+      factory.system.file_stat(@path)
+    end
+
+    # returns true if this file is older than the given file
+    def older_than?(file)
+      (stat <=> file.stat) == -1
+    end
+
+    # returns true if this file exists
+    def exists?
+      return factory.system.file_exists?(@path)
+    end
+
+    # returns the relative path from the given file or directory
+    def relative_path_from(entry)
+      path.relative_path_from(entry.path)
+    end
+
+    # returns the parent directory
+    def parent
+      return CottaDir.new(factory, @path.parent)
+    end
+
+    # copy this file to the target file
+    def copy_to(target_file)
+      target_file.parent.mkdirs
+      factory.system.copy_file(path, target_file.path)
+      target_file
+    end
+
+    # copy this file to the target path
+    def copy_to_path(target_path)
+      copy_to(cotta.file(target_path))
+    end
+
+    # move this file to the target file
+    def move_to(target_file)
+      target_file.parent.mkdirs
+      factory.system.move_file(path, target_file.path)
+    end
+
+    # move this file to the target path
+    def move_to_path(target_path)
+      move_to(cotta.file(target_path))
+    end
+
+    # save conent to this file
+    # this will create the parent directory if necessary
+    def save(content = '')
+      write {|file| file.printf content.to_s}
+      self
+    end
+
+    # Calls open with 'w' argument and makes sure that the
+    # parent directory of the file exists
+    def write(&block)
+      parent.mkdirs
+      open('w', &block)
+    end
+
+    # Calls open with 'a' argument and make sure that the
+    # parent directory of the file exists
+    def append(&block)
+      parent.mkdirs
+      open('a', &block)
+    end
+
+    # Calls open with 'wb' argument, sets the io to binmode
+    # and make sure that the parent directory of the file exists
+    def write_binary(&block)
+      parent.mkdirs
+      if (block_given?)
+        open('wb') do |io|
+          io.binmode
+          yield io
+        end
+      else
+        io = open('wb')
+        io.binmode
+        io
+      end
+    end
+
+=begin rdoc
+    Loading the file full total.  This is used generally for loading
+    an ascii file content.  It does not work with binary file on
+    windows system because it does no put the system on binary mode
+=end
+    def load
+      content = nil
+      size = stat.size
+      read do |io|
+        content = io.read
+      end
+      return content
+    end
+
+    # calls open with 'r' as argument.
+    def read(&block)
+      open('r', &block)
+    end
+
+    # Calls open with 'r' as argument and sets the io to binary mode
+    def read_binary
+      if block_given?
+        open('r') do |io|
+          io.binmode
+          yield io
+        end
+      else
+        io = open('r')
+        io.binmode
+        io
+      end
+    end
+
+    # reads the file and calls back for each line
+    def foreach()
+      open('r') do |file|
+        file.each {|line| yield line}
+      end
+    end
+
+    # opens the file with the g iven arguments
+    def open(*args)
+      result = f = factory.system.io(@path, *args)
+      if block_given?
+        begin
+          result = yield f
+        ensure
+          f.close unless f.closed?
+        end
+      end
+      result
+    end
+
+    # deletes the file
+    def delete
+      factory.system.delete_file(@path)
+    end
+
+    # reads this file as an archive and extracts the content
+    # to the target directory.  If the target directory
+    # is missing, it will create a directory in the same
+    # directory as this file with the same basename
+    def extract(directory = nil)
+      require 'rubygems/package'
+      directory = parent.dir(basename) unless directory
+      read_binary do |io|
+        reader = Gem::Package::TarReader.new(io)
+        reader.each do |entry|
+          full_name = entry.full_name
+          if (entry.file?)
+            directory.file(full_name).write_binary do |output|
+              CottaFile.copy_io(entry, output)
+            end
+          elsif (entry.directory?)
+            directory.dir(full_name).mkdirs
+          end
+        end
+      end
+      directory
+    end
+
+    # Create the zip file from current file
+    # When target is nil, the output will be the name of the current file appended with ".zip"
+    def zip(target = nil, level=nil, strategy=nil)
+      target = parent.file("#{name}.zip") unless target
+      read_binary do |read_io|
+        target.write_binary do |write_io|
+          gz = Zlib::GzipWriter.new(write_io, level, strategy)
+          CottaFile.copy_io(read_io, gz)
+          gz.close
+        end
+      end
+      target
+    end
+
+    # unzips the file
+    def unzip
+      name = basename
+      if (extname.length == 0)
+        name = "#{name}.unzip"
+      end
+      target = parent.file(name)
+      read_binary do |read_io|
+        target.write_binary do |write_io|
+          gz = Zlib::GzipReader.new(read_io)
+          CottaFile.copy_io(gz, write_io)
+          gz.close
+        end
+      end
+      target
+    end
+
+    # copy from input handle to output handle
+    def self::copy_io(input, output)
+  #    output.write input.read
+      while (content = input.read(1024)) do
+        output.write content
+      end
+    end
+
+    def ==(other)
+      return false unless other.kind_of? CottaFile
+      return factory.system == other.factory.system && @path == other.path
+    end
+
+    def to_s
+      @path.to_s
+    end
+
+    def inspect
+      return "#{self.class}:#{self.object_id}-#{factory.system.inspect}-#@path"
+    end
+
+  end
+end