cotta 1.0.0

data/lib/cotta/file_factory.rb

@@ -0,0 +1,117 @@
+module Cotta
+# The file factory of Cotta files that handles creation of the CottaFile and CottaDir
+# instances.  This class also can be used to start command lines
+  class FileFactory
+    # file system that is backing the current file factory
+    attr_reader :system
+    # attr_accessor :command_interface
+
+    # Creates an instance of the file factory with the given system
+    def initialize(system=PhysicalSystem.new)
+      @system = system
+#      @command_interface = CommandInterface.new
+    end
+
+=begin not for 1.0 release
+    # Invoke the command line through the backing system
+    def shell(command_line, &block)
+      @system.shell(command_line, &block)
+    end
+=end
+    # Returns the current directory
+    def pwd
+      dir(@system.pwd)
+    end
+
+=begin not for 1.0 release
+    # Starts the process.  Unlike shell method, this method does not
+    # collect the output, thus suitable for starting a server in Ruby
+    # and leave it running for a long time
+    def start(command_line)
+      @system.shell(command_line) do |io|
+        if (block_given?)
+          yield io
+        else
+          while (line = io.gets)
+            puts line
+          end
+        end
+      end
+    end
+
+    def command_interface=(value)
+      if (value)
+        @command_interface = value
+      else
+        @command_interface = CommandInterface.new
+      end
+    end
+=end
+
+    # Returns a CottaDir instance with the given path
+    def dir(path)
+      return nil unless path
+      return CottaDir.new(self, Pathname.new(path))
+    end
+
+    # Returns the FileFactory instance that represents the
+    # physical file system
+    def self::physical
+      PHYSICAL
+    end
+
+    # Return the FileFactory instance that represents an
+    # in-memory file system
+    def self::in_memory
+      FileFactory.new(InMemorySystem.new)
+    end
+
+    # Returns a CottDirectory with the PhysicalSystem
+    def self::dir(path)
+      return nil unless path
+      return physical.dir(File.expand_path(path))
+    end
+
+    # Returns a CottaFile in the current system with the path
+    def file(path)
+      return nil unless path
+      return CottaFile.new(self, Pathname.new(path))
+    end
+
+    # Returns a CottaFile with the PhysicalSystem and the given path
+    def self::file(path)
+      return nil unless path
+      return physical.file(File.expand_path(path))
+    end
+
+    # Returns a CottaDir with the PhysicalSystem and is the parent of the given file path
+    def self::parent_dir(path)
+      return file(path).parent
+    end
+
+    # Creates the entry given a path.  This will return either
+    # CottaFile or CottaDirectory depending by checking the path
+    # passed in, which means that if neither a directory nor a file
+    # exists with this name it will raise an error
+    def entry(path)
+      entry_instance = file(path)
+      unless (entry_instance.exists?)
+        entry_instance = dir(path)
+        raise "#{path} exists as niether file nor directory" unless entry_instance.exists?
+      end
+      return entry_instance
+    end
+
+=begin not for release 1.0
+    def environment!(variable)
+      @system.environment!(variable)
+    end
+
+    def environment(variable, default = '')
+      @system.environment(variable, default)
+    end
+=end
+
+  end
+  PHYSICAL = FileFactory.new(PhysicalSystem.new)
+end

data/lib/cotta/file_not_found_error.rb

@@ -0,0 +1,13 @@
+module Cotta
+class FileNotFoundError < StandardError
+  attr_reader :pathname
+  
+  def initialize(pathname)
+    @pathname = pathname
+  end
+  
+  def message
+    "file not found: #{pathname}"
+  end
+end
+end

data/lib/cotta/impl/command_error.rb

@@ -0,0 +1,13 @@
+module Cotta
+  # Error class that will be thrown if
+  # a system command exit with an error
+  # code
+  class CommandError < StandardError
+    attr_reader :proc_status, :output
+
+    def initialize(proc_status, output)
+      @proc_status = proc_status
+      @output = output
+    end
+  end
+end

data/lib/cotta/impl/command_interface.rb

@@ -0,0 +1,46 @@
+module Cotta
+  # A command line interface tha can
+  # be stubbed out by InMemorySystem
+  class CommandInterface
+    def initialize(io = SystemIo.new)
+      @io = io
+    end
+
+    def puts(content)
+      @io.puts(content)
+    end
+
+    def prompt(question)
+      puts(question)
+      gets
+    end
+
+    def prompt_for_choice(question, candidates)
+      puts(question)
+      0.upto(candidates.size - 1) do |index|
+        puts "[#{index + 1}] #{candidates[index]}"
+      end
+      answer = gets.to_i
+      seletion = nil
+      if answer > 0 && answer <= candidates.size
+        selection = candidates[answer - 1]
+      end
+      return selection
+    end
+
+    def gets
+      @io.gets
+    end
+
+  end
+
+  class SystemIo
+    def puts(content)
+      $stdout.puts(content)
+    end
+
+    def gets
+      $stdin.gets
+    end
+  end
+end

data/lib/cotta/impl/command_runner.rb

@@ -0,0 +1,55 @@
+=begin
+if RUBY_PLATFORM =~ /mswin|mingw/
+  begin
+    require 'win32/open3'
+  rescue LoadError
+    warn "You must 'gem install win32-open3' to use Cotta on Windows"
+    exit 1
+  end
+else
+  require 'open3'
+end
+=end
+
+module Cotta
+  
+# Command runner
+class CommandRunner
+  attr_reader :outputs
+
+  def initialize(command)
+    @command = command
+  end
+  
+  # executs the command.  If a closure is
+  # given, it will be called with the io to the process
+  # If not, it will print out the log pre-fixed with a random number for the process,
+  # collects the output and return the output when the process finishes.
+  # This method will also raise CommandError if the process fails.
+  def execute
+    id = rand(10000)
+    puts "[#{id}]$> #{@command}"
+    output = nil
+    IO.popen(@command) do |io|
+      if (block_given?)
+        output = yield io
+      else
+        output = load_output(id, io)
+      end
+    end
+    last_process = $?
+    raise CommandError.new(last_process, output), @command unless last_process.exitstatus == 0
+    return output
+  end
+  
+  private
+  def load_output(id, io)
+    output = ''
+    while (line = io.gets) do
+      puts "[#{id}] #{line}"
+      output << line
+    end
+    return output
+  end
+end
+end

data/lib/cotta/impl/cotta_pathname.rb

@@ -0,0 +1,9 @@
+class Pathname
+  def cotta_parent
+    parent_path = parent
+    if (parent_path == self || parent_path.to_s == '..')
+      return nil
+    end
+    return parent_path
+  end
+end

data/lib/cotta/impl/in_memory_system.rb

@@ -0,0 +1,295 @@
+require 'stringio'
+
+module Cotta
+class InMemorySystem
+  
+  attr_reader :executed_commands, :pwd
+
+  def initialize
+    @executed_commands = []
+    @content = ""
+    @file_system = Hash.new
+    @file_system[nil] = DirectoryContent.new('')
+    @file_system[Pathname.new('/')] = DirectoryContent.new('/')
+    @file_system[Pathname.new('.')] = DirectoryContent.new('.')
+    @output_map = Hash.new
+  end
+  
+  def shell(command)
+    @executed_commands.push(command)
+    result = @output_map[command]
+    raise "#{command} not found in expectation" unless result
+    return result
+  end
+  
+  def output_for_command(command, output)
+    @output_map[command] = output
+  end
+  
+  def expect_command(command)
+    Entry.new(command)
+  end
+
+  def dir_exists?(pathname)
+   content = path_content(pathname)
+    return !content.nil? && content.directory?
+  end
+  
+  def file_exists?(pathname)
+    content = path_content(pathname)
+    return !content.nil? && content.file?
+  end
+  
+  def dir_stat(pathname)
+    check_dir_exists(pathname)
+    path_content(pathname).stat
+  end
+  
+  def file_stat(pathname)
+    check_file_exists(pathname)
+    path_content(pathname).stat
+  end
+  
+  def list(pathname)
+    check_dir_exists(pathname)
+    content = path_content(pathname)
+    return content.children.collect {|item| item.name}
+  end
+
+  def check_dir_exists(pathname)
+    raise Errno::ENOENT, pathname unless dir_exists? pathname
+  end
+
+  def check_file_exists(pathname)
+    raise Errno::ENOENT, pathname unless file_exists? pathname
+  end
+  
+  def mkdir(pathname)
+    path_content!(pathname.cotta_parent).add(create_dir(pathname))
+  end
+  
+  def io(*args)
+    file_content = retrieve_file_content(args[0], args[1])
+    return StringIO.new(file_content.content, *args[1, args.size - 1])
+  end
+  
+  def copy(source, target)
+    copy_file(source, target)
+  end
+  
+  def copy_file(source, target)
+    file_content = retrieve_file_content(source, 'r').content
+    create_file(target).content = file_content.clone
+  end
+  
+  def move(source, target)
+    move_file(source, target)
+  end
+  
+  def move_file(source, target)
+    copy(source, target)
+    delete_file(source)
+  end
+  
+  def copy_dir(source, target)
+    check_dir_exists(source)
+    mkdir(target)
+    path_content(source).children.each do |item|
+      item.copy_to_dir(self, source, target)
+    end
+  end
+  
+  def move_dir(source, target)
+    copy_dir(source, target)
+    delete_dir(source)
+  end
+  
+  def delete_file(pathname)
+    raise Errno::ENOENT.new(pathname) unless file_exists? pathname
+    delete_entry(pathname)
+  end
+  
+  def delete_dir(pathname)
+    raise Errno::ENOENT.new(pathname) unless dir_exists? pathname
+    delete_entry(pathname)
+  end
+  
+  def to_s
+    return 'InMemorySystem'
+  end
+  
+  def chdir(path)
+    last_pwd = @pwd
+    @pwd = path.to_s
+    result = 0
+    if (block_given?)
+      begin
+        result = yield
+      ensure
+        @pwd = last_pwd
+      end
+    end
+    result
+  end
+  
+  private
+  def gather_paths_to_create(pathname)
+    paths = Array.new
+    path_to_create = pathname   
+    while (! dir_exists?(path_to_create))
+      paths.push(path_to_create)
+      path_to_create = path_to_create.cotta_parent
+    end
+    return paths
+  end  
+  
+  def create_dir(pathname)
+    content = DirectoryContent.new(pathname.basename.to_s)
+    @file_system[pathname] = content
+    return content
+  end
+  
+  def create_file(pathname)
+    content = FileContent.new(pathname.basename.to_s)
+    parent_dir = pathname.cotta_parent
+    path_content(parent_dir).add(content)
+    @file_system[pathname] = content
+    return content
+  end
+  
+  def path_content(pathname)
+    content = path_content!(pathname)
+    if (content.nil? && pathname.cotta_parent.nil?)
+      mkdir(pathname)
+      content = @file_system[pathname]
+    end
+    return content
+  end
+  
+  def path_content!(pathname)
+    @file_system[pathname]
+  end
+  
+  def retrieve_file_content(pathname, options)
+    file_content = path_content(pathname)
+    if (file_content.nil?)
+      if (options =~ /r/)
+        raise Errno::ENOENT.new(pathname)
+      end
+      file_content = create_file(pathname)
+    end
+    if (options =~ /w/)
+      file_content.touch
+    end
+    return file_content
+  end
+  
+  def delete_entry(pathname)
+    @file_system.delete pathname
+    @file_system[pathname.cotta_parent].delete(pathname.basename.to_s)
+  end
+    
+end
+
+class DirectoryContent
+  attr_reader :name, :children, :stat
+
+  def initialize(name)
+    @name = name
+    @children = Array.new
+    @stat = ContentStat.new(self)
+  end 
+
+  def file?
+    return false
+  end
+  
+  def directory?
+    return true
+  end
+  
+  def add(content)
+    @children.push(content)
+  end
+  
+  def delete(name)
+    @children.delete_if {|file_content| file_content.name == name}
+  end
+  
+  def copy_to_dir(system, parent_dir, target_dir)
+    source_path = parent_dir.join(name)
+    target_path = target_dir.join(name)
+    system.copy_dir(source_path, target_path)
+  end
+end
+
+class FileContent
+  attr_reader :name, :content, :stat
+  attr_writer :content
+  
+  def initialize(name)
+    @name = name
+    @content = ''
+    @stat = ContentStat.new(self)
+  end
+  
+  def file?
+    return true
+  end
+  
+  def directory?
+    return false
+  end
+  
+  def size
+    content.size
+  end
+  
+  def copy_to_dir(system, parent_dir, target_dir)
+    target_path = target_dir.join(name)
+    source_path = parent_dir.join(name)
+    system.copy_file(source_path, target_path)
+  end
+
+  def touch
+    @stat.touch
+  end
+end
+
+class ContentStat
+  attr_reader :mtime
+
+  def initialize(content)
+    @content = content
+    @mtime = Time.new
+  end
+  
+  def mode
+    '10777'
+  end
+  
+  def size
+    @content.size
+  end
+
+  def file?
+    @content.file?
+  end
+
+  def directory?
+      @content.directory?
+  end
+
+  def touch
+    @mtime = Time.new
+  end
+
+  def writable?
+    true
+  end
+
+  def <=> stat
+    mtime <=> stat.mtime
+  end
+end
+end