awshucks 0.0.1

data/lib/awshucks/gemspec.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'awshucks/specification'
+require 'awshucks/version'
+require 'rake'
+
+# The Gem Specification plus some extras for awshucks.
+module Awshucks
+  SPEC = Awshucks::Specification.new do |spec|
+    spec.name               = "awshucks"
+    spec.version            = Awshucks::VERSION
+    spec.rubyforge_project  = "awshucks"
+    spec.author             = "Nathan Witmer"
+    spec.email              = "nathan-ruby@otherward.net"
+    spec.homepage           = "http://awshucks.rubyforge.org/"
+
+    spec.summary            = "A Summary of awshucks."
+    spec.description        = <<-DESC
+TODO: A longer more detailed description of awshucks.
+    DESC
+
+    spec.extra_rdoc_files   = FileList["[A-Z]*"]
+    spec.has_rdoc           = true
+    spec.rdoc_main          = "README"
+    spec.rdoc_options       = [ "--line-numbers" , "--inline-source" ]
+
+    spec.test_files         = FileList["spec/**/*.rb", "test/**/*.rb"]
+    spec.executable         = spec.name
+    spec.files              = spec.test_files + spec.extra_rdoc_files + 
+                              FileList["lib/**/*.rb", "resources/**/*"]
+
+    # add dependencies
+    # spec.add_dependency("somegem", ">= 0.4.2")
+    spec.add_dependency("aws-s3", ">= 0.4.0")
+    # spec.add_dependency("main", ">= 0.2.0")
+    
+    spec.platform           = Gem::Platform::RUBY
+
+    spec.local_rdoc_dir     = "doc/rdoc"
+    spec.remote_rdoc_dir    = "#{spec.name}/rdoc"
+    spec.local_coverage_dir = "doc/coverage"
+    spec.remote_coverage_dir= "#{spec.name}/coverage"
+
+    spec.remote_site_dir    = "#{spec.name}/"
+
+         end
+end
+
+

data/lib/awshucks/scanner.rb

@@ -0,0 +1,58 @@
+module Awshucks
+  
+  class Scanner
+
+    def self.each_file(dir, ignore = [])
+      new(dir, ignore).each_file {|entry| yield entry }
+    end
+
+    def initialize(dir, ignore = [])
+      @base_dir, @ignored = dir, ignore
+    end
+
+    # yields FileInfo object for each non-ignored file in the specified directory
+    def each_file
+      directory_stack << ''
+      while dir = directory_stack.pop
+        scan_directory(dir) { |entry| yield entry }
+      end
+    end
+
+    #######
+    private
+    #######
+
+    attr_reader :base_dir
+    attr_reader :ignored
+
+    def scan_directory(dir_name)
+      Dir.open(File.join(base_dir, dir_name)) do |dir|
+        while entry = dir.read
+          next if entry == '.' || entry == '..' || ignored?(entry)
+
+          stat = File.lstat(File.join(base_dir, dir_name, entry))      
+          next if stat.symlink?
+
+          relative_path = File.join(dir_name, entry)
+
+          if stat.directory?
+            directory_stack << relative_path
+          else
+            # strip off the leading / in the relative path
+            yield FileInfo.new(relative_path[1..-1], File.join(base_dir, relative_path), stat)
+          end
+        end
+      end
+    end
+
+    def directory_stack
+      @directory_stack ||= []
+    end
+
+    def ignored?(filename)
+      ignored.any? {|ignore| File.fnmatch(ignore, filename) }
+    end
+
+  end
+  
+end

data/lib/awshucks/specification.rb

@@ -0,0 +1,128 @@
+require 'rubygems'
+require 'rubygems/specification'
+require 'rake'
+
+module Awshucks 
+    # Add some additional items to Gem::Specification
+    # A Awshucks::Specification adds additional pieces of information the
+    # typical gem specification
+    class Specification 
+
+        RUBYFORGE_ROOT = "/var/www/gforge-projects/"
+      
+        # user that accesses remote site
+        attr_accessor :remote_user
+
+        # remote host, default 'rubyforge.org'
+        attr_accessor :remote_host
+
+        # name the rdoc main
+        attr_accessor :rdoc_main
+
+        # local directory in development holding the generated rdoc
+        # default 'doc'
+        attr_accessor :local_rdoc_dir
+
+        # remote directory for storing rdoc, default 'doc'
+        attr_accessor :remote_rdoc_dir
+
+        # local directory for coverage report
+        attr_accessor :local_coverage_dir
+        
+        # remote directory for storing coverage reports
+        # This defaults to 'coverage'
+        attr_accessor :remote_coverage_dir
+
+        # local directory for generated website, default +site/public+
+        attr_accessor :local_site_dir
+       
+        # remote directory relative to +remote_root+ for the website.
+        # website.
+        attr_accessor :remote_site_dir
+
+        # is a .tgz to be created?, default 'true'
+        attr_accessor :need_tar
+
+        # is a .zip to be created, default 'true'
+        attr_accessor :need_zip
+
+
+        def initialize
+            @remote_user = nil
+            @remote_host = "rubyforge.org"
+
+            @rdoc_main              = "README"
+            @local_rdoc_dir         = "doc"
+            @remote_rdoc_dir        = "doc"
+            @local_coverage_dir     = "coverage"
+            @remote_coverage_dir    = "coverage"
+            @local_site_dir         = "site/public"
+            @remote_site_dir        = "."
+            
+            @need_tar   = true
+            @need_zip   = true
+
+            @spec                   = Gem::Specification.new
+
+            yield self if block_given?
+
+            # update rdoc options to take care of the rdoc_main if it is
+            # there, and add a default title if one is not given
+            if not @spec.rdoc_options.include?("--main") then
+                @spec.rdoc_options.concat(["--main", rdoc_main])
+            end
+
+            if not @spec.rdoc_options.include?("--title") then
+                @spec.rdoc_options.concat(["--title","'#{name} -- #{summary}'"])
+            end
+        end
+
+        # if this gets set then it overwrites what would be the
+        # rubyforge default.  If rubyforge project is not set then use
+        # name.  If rubyforge project and name are set, but they are
+        # different then assume that name is a subproject of the
+        # rubyforge project
+        def remote_root 
+            if rubyforge_project.nil? or 
+                rubyforge_project == name then
+                return RUBYFORGE_ROOT + "#{name}/"
+            else
+                return RUBYFORGE_ROOT + "#{rubyforge_project}/#{name}/"
+            end
+        end
+
+        # rdoc files is the same as what would be generated during gem
+        # installation. That is, everything in the require paths plus
+        # the rdoc_extra_files
+        #
+        def rdoc_files 
+            flist = extra_rdoc_files.dup
+            @spec.require_paths.each do |rp|
+                flist << FileList["#{rp}/**/*.rb"]
+            end
+            flist.flatten.uniq
+        end
+
+        # calculate the remote directories
+        def remote_root_location
+            "#{remote_user}@#{remote_host}:#{remote_root}"
+        end
+           
+        def remote_rdoc_location
+            remote_root_location + @remote_rdoc_dir
+        end
+
+        def remote_coverage_location
+            remote_root_location + @remote_coverage_dir
+        end
+
+        def remote_site_location
+            remote_root_location + @remote_site_dir
+        end
+
+        # we delegate any other calls to spec
+        def method_missing(method_id,*params,&block)
+            @spec.send method_id, *params, &block
+        end
+    end
+end

data/lib/awshucks/version.rb

@@ -0,0 +1,18 @@
+module Awshucks
+    class Version
+        MAJOR   = 0
+        MINOR   = 0
+        BUILD   = 1
+
+        class << self
+            def to_a
+                [MAJOR, MINOR, BUILD]
+            end
+
+            def to_s
+                to_a.join(".")
+            end
+        end
+    end
+    VERSION = Version.to_s
+end

data/resources/awshucks.yml

@@ -0,0 +1,21 @@
+---
+# awshucks-generated config file
+# The default filename is awshucks.yml, but can be overridden.
+
+# Amazon S3 configuration
+access_key_id: insert your access key here
+secret_access_key: insert your secret access key here
+
+# This is where awshucks will store all of your backed-up files.
+bucket: bucket name
+
+# Backup location configurations. Add as many of them as you like.
+# Currently the only required key is location.
+
+# For example (replace these with your own):
+
+photos:
+  location: "~/pictures"
+
+email:
+  location: "~/mail"

data/spec/awshucks_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+
+describe Awshucks do
+  it "should require the aws/s3 gem" do
+    require('aws/s3').should be_false
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,130 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+
+describe Awshucks::CLI, '#execute' do
+    
+  before(:each) do
+    @cli = Awshucks::CLI.new
+    @cmd = mock('pretend command')
+    @cmd.stub!(:command).and_return('pretend')
+    @old_stdout, $stdout = $stdout, StringIO.new
+    @old_stderr, $stderr = $stderr, StringIO.new
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+    $stderr = @old_stderr
+  end
+  
+  it "fails with a help message with empty arguments" do
+    @cli.execute([])
+    $stdout.string.should include("--help")
+  end
+  
+  it "loads the configuration from awshucks.yml in the current working directory by default" do
+    config = mock('config')
+    Awshucks::Config.should_receive(:new).with('awshucks.yml').and_return(config)
+    config.stub!(:help_message=)
+    Dir.chdir(dummy_fs_path) do
+      @cli.execute([])
+      @cli.send(:config) # lazily loaded, so force it
+    end
+  end
+  
+  it "assigns the main help method to the config object as a way to piggyback it for commands" do
+    config = mock('config')
+    Awshucks::Config.should_receive(:new).with('awshucks.yml').and_return(config)
+    config.should_receive(:help_message=).with(/-h, --help/)
+    Dir.chdir(dummy_fs_path) do
+      @cli.execute([])
+      @cli.send(:config) # lazily loaded, so force it
+    end
+  end
+  
+  it "runs the specified subcommand if a command is provided" do
+    @cmd.should_receive(:execute)
+    Awshucks::Command.should_receive(:commands).at_least(1).times.and_return({'pretend' => @cmd})
+    @cli.execute(['pretend'])
+  end
+  
+  it "prints an error and exit if a specified subcommand is not found" do
+    Awshucks::Command.should_receive(:parse_and_execute).and_raise(Awshucks::UnknownCommandError.new('pretend'))
+    lambda { @cli.execute(['pretend']) }.should raise_error(SystemExit)
+    $stderr.string.should =~ /could not find.*pretend/i
+  end
+  
+  it "prints an error and exit if a subcommand raises an error" do
+    Awshucks::Command.should_receive(:parse_and_execute).and_raise(Awshucks::CommandError.new('pretend error'))
+    lambda { @cli.execute(['pretend']) }.should raise_error(SystemExit)
+    $stderr.string.should =~ /pretend error/
+  end
+  
+end
+
+describe Awshucks::CLI, '#execute with no command-line arguments provided' do
+  
+  before(:each) do
+    @old_stdout, $stdout = $stdout, StringIO.new
+    @cli = Awshucks::CLI.new
+    @cli.execute([])
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+  end
+  
+  it "prints out a help message to stdout" do
+    $stdout.string.should =~ /-h, --help/
+  end
+  
+  it "prints out a list of available commands" do
+    $stdout.string.should =~ /    help/
+  end
+  
+end
+
+describe Awshucks::CLI, '#execute with the -h argument' do
+  
+  before(:each) do
+    @old_stdout, $stdout = $stdout, StringIO.new
+    @cli = Awshucks::CLI.new
+    @cli.execute(%w(-h))
+  end
+  
+  after(:each) do
+    $stdout = @old_stdout
+  end
+  
+  it "prints out a help message to stdout" do
+    $stdout.string.should =~ /-h, --help/
+  end
+  
+  it "includes the version string" do
+    $stdout.string.should include("version #{Awshucks::VERSION}")
+  end
+  
+end
+
+describe Awshucks::CLI, '#execute with the -c argument' do
+  
+  before(:each) do
+    @cli = Awshucks::CLI.new
+  end
+  
+  it "executes the given command with the specified config" do
+    config = mock('config')
+    Awshucks::Config.should_receive(:new).with('asdf.yml').and_return(config)
+    config.stub!(:help_message=)
+    Awshucks::Command.should_receive(:parse_and_execute)
+    @cli.execute(['-c', 'asdf.yml', 'command'])
+  end
+  
+end
+
+describe Awshucks::CLI, '.execute' do
+  it "instantiates the CLI and calls execute with ARGV" do
+    @cli = mock('cli')
+    Awshucks::CLI.should_receive(:new).and_return(@cli)
+    @cli.should_receive(:execute).with(ARGV)
+    Awshucks::CLI.execute
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(__FILE__),"spec_helper.rb")
+
+describe Awshucks::Command, '.commands' do
+  
+  it "should return a list of commands stored at the class level" do
+    Awshucks::Command.commands.should be_kind_of(Hash)
+  end
+    
+  it "should have the standard commands loaded via the inherited callback" do
+    Awshucks::Command.commands['help'].should == Awshucks::HelpCommand
+    Awshucks::Command.commands['backup'].should == Awshucks::BackupCommand
+    Awshucks::Command.commands['backups'].should == Awshucks::BackupsCommand
+    Awshucks::Command.commands['list'].should == Awshucks::ListCommand
+    Awshucks::Command.commands['new_config'].should == Awshucks::NewConfigCommand
+    Awshucks::Command.commands['reset_metadata_cache'].should == Awshucks::ResetMetadataCacheCommand
+    Awshucks::Command.commands['restore'].should == Awshucks::RestoreCommand
+  end
+  
+end
+
+describe Awshucks::Command, '.parse_and_execute' do
+  
+  before(:each) do
+    @cmd = mock('command')
+    @config = mock('config')
+    Awshucks::Command.commands['mock'] = @cmd
+  end
+  
+  it "should call execute on the command matching the first argument" do
+    @cmd.should_receive(:execute)
+    Awshucks::Command.parse_and_execute(['mock'], @config)
+  end
+  
+  it "should strip the first argument from the arguments passed in when calling execute" do
+    @cmd.should_receive(:execute).with(['arg', 'arg2'], @config)
+    Awshucks::Command.parse_and_execute(['mock', 'arg', 'arg2'], @config)
+  end
+  
+  it "should raise an unknown command error if the command isn't one that's registered" do
+    lambda { Awshucks::Command.parse_and_execute(['blahblah'], nil) }.should raise_error(Awshucks::UnknownCommandError)
+  end
+end
+
+describe Awshucks::Command, '.execute' do
+  it "should instantiate and call execute on the command class" do
+    class MockCommand < Awshucks::Command
+    end
+    
+    @mock = mock('dummy command instance')
+    MockCommand.should_receive(:new).and_return(@mock)
+    @mock.should_receive(:execute)
+    
+    MockCommand.execute(nil, nil)
+  end
+end
+
+describe Awshucks::Command, '.option_string, when no custom options are defined' do
+    
+  before(:each) do
+    class DummyCommand < Awshucks::Command
+      self.command = 'command name'
+      self.usage = 'usage string'
+      self.description = 'description'
+    end
+  end
+  
+  it "should include usage in the option parser string" do
+    DummyCommand.option_string.should include('usage string')
+  end
+  
+  it "should include description in the option parser string" do
+    DummyCommand.option_string.should include('description')
+  end
+  
+  it "should state 'no options' in option parser string" do
+    DummyCommand.option_string.should include('No options')
+  end
+  
+end
+
+describe Awshucks::Command, '.option_string, with custom options defined' do
+  
+  before(:each) do
+    class DummyCommand < Awshucks::Command
+      self.command = 'command name'
+      self.usage = 'usage string'
+      self.description = 'description'
+      def custom_options(opts)
+        opts.on('-v', "be verbose")
+      end
+    end
+  end
+  
+  it "should include custom options in option parser string if a block was used" do
+    DummyCommand.option_string.should include('Options:')
+    DummyCommand.option_string.should include('be verbose')
+  end
+  
+end
+
+describe Awshucks::Command, '#parsed_options' do
+  it "should return an OpenStruct by default for use in option definitions" do
+    Awshucks::Command.new.send(:parsed_options).should be_instance_of(OpenStruct)
+  end
+end
+
+describe Awshucks::Command, '#execute' do
+  it "raises an exception since it's meant to be an abstract method" do
+    lambda {Awshucks::Command.new.execute(nil, nil) }.should raise_error(Awshucks::CommandError)
+  end
+end