wp_backup 0.1.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Aubrey Holland
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,20 @@
+# WpBackup
+
+WpBackup is a simple command-line tool for backing up Wordpress sites and their
+databases to S3. It uses mysqldump to create a database drop and then copies
+either the entire site from your wordpress directory or specific paths. The operation
+is entirely configurable by a simple file.
+
+## <a name="installation"></a>Installation
+
+    gem install wp_backup
+
+## <a name="usage"></a>Usage
+
+You'll now have acceess to the wp_backup command. Try "wp_backup help" to get a list of available tasks.
+
+## <a name="copyright"></a>Copyright
+Copyright (c) 2012 Aubrey Holland
+See [LICENSE][] for details.
+
+[license]: https://github.com/aub/tumble/blob/master/LICENSE.md

data/Rakefile

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+
+task :release => %w(man:clean man:build)
+
+require 'rspec/core/rake_task'
+require 'ronn'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-fs --color)
+  t.ruby_opts  = %w(-w)
+end
+task :spec => "man:build"
+
+task :default => :spec

data/bin/wp_backup

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'wp_backup'
+
+begin
+  require 'wp_backup/cli'
+  WpBackup::CLI.start
+rescue WpBackup::BackupError => e
+  puts e.message
+  puts e.backtrace.join("\n")
+  exit e.status_code
+rescue Interrupt => e
+  puts "\nQuitting..."
+  puts e.backtrace.join("\n")
+  exit 1
+rescue SystemExit => e
+  exit e.status
+rescue Exception => e
+  puts 'Fatal Error!'
+  puts e.message
+  puts e.backtrace.join("\n")
+  raise e
+end

data/lib/wp_backup/backup.rb

@@ -0,0 +1,56 @@
+module WpBackup
+  class Backup
+
+    def initialize(config)
+      @config = config
+    end
+
+    def create(backup_db=true, backup_site=true)
+      timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      root_dir = "/tmp/wp-backup-#{timestamp}"
+
+      begin
+        if backup_site
+          site_dir = File.join(root_dir, 'site')
+          FileUtils.mkdir_p(site_dir)
+          site_file = @config.site.dump_to(File.join(root_dir, 'site', 'site.tar'))
+        end
+
+        if backup_db
+          db_dir = File.join(root_dir, 'db')
+          FileUtils.mkdir_p(db_dir)
+          db_file = @config.database.dump_to(File.join(db_dir, 'db.sql'))
+        end
+
+        package_file = "/tmp/wp-backup-#{timestamp}.tar.gz"
+        `cd #{root_dir} && tar -czf #{package_file} db site`
+
+        @config.s3.store(package_file)
+      ensure
+        `rm -rf #{root_dir}`
+      end
+
+      timestamp
+    end
+
+    def restore(key)
+      timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      root_dir = "/tmp/wp-restore-#{timestamp}"
+
+      FileUtils.mkdir_p(root_dir)
+
+      begin
+        File.open(File.join(root_dir, 'restore.tar.gz'), 'w') do |file|
+          file.puts(@config.s3.read(key))
+        end
+
+        `cd #{root_dir} && tar -xzvf restore.tar.gz`
+
+        @config.database.restore_from(File.join(root_dir, 'db', 'db.sql'))
+        @config.site.restore_from(File.join(root_dir, 'site', 'site.tar'))
+      ensure
+        `rm -rf #{root_dir}`
+      end
+    end
+  end
+end

data/lib/wp_backup/cli.rb

@@ -0,0 +1,50 @@
+require 'thor'
+
+module WpBackup
+  class CLI < Thor
+    desc 'backup', 'back up the blog residing in the given directory to S3'
+    method_option :config_file, :aliases => '-c', :desc => 'The location of the configuration file. This is assumed to be wp_backup.yml in the current directory unless given.'
+    method_option :db_only, :aliases => '-d', :desc => 'Only back up the database.'
+    method_option :site_only, :aliases => '-s', :desc => 'Only back up the site.'
+    def backup
+      config = Config.new(options[:config_file])
+      key = Backup.new(config).create(!options[:site_only], !options[:db_only])
+      puts "Backed up to #{key}"
+    end
+
+    desc 'list', 'list the currently saved backups'
+    method_option :config_file, :aliases => '-c', :desc => 'The location of the configuration file. This is assumed to be wp_backup.yml in the current directory unless given.'
+    def list
+      config = Config.new(options[:config_file])
+      keys = config.s3.keys
+      puts "Found #{keys.count} versions:"
+      puts "========================"
+      keys.each { |k| puts k }
+    end
+
+    desc 'cleanup', 'delete the least recent n backups'
+    method_option :keep, :aliases => '-k', :desc => 'The number of backups to keep, defaults to 10'
+    method_option :config_file, :aliases => '-c', :desc => 'The location of the configuration file. This is assumed to be wp_backup.yml in the current directory unless given.'
+    def cleanup
+      config = Config.new(options[:config_file])
+      keep = options[:keep]
+      timestamps = {}
+      config.s3.keys.each { |k| timestamps[Time.parse(k, "%Y%m%d%H%M%S")] = k }
+      remove = timestamps.keys.sort.reverse.slice(keep.to_i, timestamps.length)
+      timestamps.keep_if { |k,v| remove.include?(k) }
+      config.s3.delete_keys(timestamps.values)
+    end
+
+    desc 'restore KEY', 'restore from the given backup key. See the List command for the set of available keys.'
+    method_option :config_file, :aliases => '-c', :desc => 'The location of the configuration file. This is assumed to be wp_backup.yml in the current directory unless given.'
+    def restore(key)
+      config = Config.new(options[:config_file])
+      Backup.new(config).restore(key)
+    end
+
+    desc 'create_config file', 'create a sample config file'
+    def create_config(file)
+      Config.write_sample(file)
+    end
+  end
+end

data/lib/wp_backup/config.rb

@@ -0,0 +1,67 @@
+require 'yaml'
+
+module WpBackup
+  class Config
+
+    def initialize(file)
+      @config = YAML.load_file(file)
+      @bucket_name = @config['aws'].delete('bucket')
+    end
+    
+    def s3
+      S3.new(aws_config, @bucket_name)
+    end
+
+    def database
+      Database.new(
+        database_config['name'],
+        database_config['user'],
+        database_config['password']
+      )
+    end
+
+    def site
+      Site.new(wordpress_config['home'], wordpress_config['backup_paths'])
+    end
+
+    def self.write_sample(file)
+      File.open(file, 'w') do |file|
+        file.puts(<<-EOF
+database:
+  name:
+  user:
+  password:
+wordpress:
+  home:
+  # this allows you to specify which directories to backup. if it's not
+  # included or the list is empty the entire directory is backed up.
+  backup_paths:
+    -
+aws:
+  access_key_id:
+  secret_access_key:
+  bucket:
+          EOF
+        )
+      end
+    end
+
+    private
+
+    def aws_config
+      @aws_config ||= @config['aws']
+    end
+
+    def database_config
+      @database_config ||= @config['database']
+    end
+
+    def bucket_name
+      @bucket_name
+    end
+
+    def wordpress_config
+      @wordpress_config ||= @config['wordpress']
+    end
+  end
+end

data/lib/wp_backup/database.rb

@@ -0,0 +1,27 @@
+module WpBackup
+  class Database
+
+    def initialize(db_name, login, password)
+      @db_name = db_name
+      @login = login
+      @password = password
+    end
+
+    def dump_to(file)
+      cmd = "mysqldump --opt --skip-add-locks -u#{@login} "
+      cmd += "-p'#{@password}' " unless @password.nil? || @password.length == 0
+      cmd += " #{@db_name} > #{file}"
+      result = system(cmd)
+      raise("ERROR: mysqldump failed (#{$?})") unless result
+    end
+
+    def restore_from(file)
+      if File.exists?(file)
+        cmd = "mysql -u#{@login} "
+        cmd += "-p'#{@password}' " unless @password.nil? || @password.length == 0
+        cmd += " #{@db_name} < #{file}"
+        system(cmd)
+      end
+    end
+  end
+end

data/lib/wp_backup/s3.rb

@@ -0,0 +1,42 @@
+require 'aws-sdk'
+
+module WpBackup
+  class S3
+    def initialize(aws_config, root_bucket)
+      AWS.config(aws_config)
+      @s3 = AWS::S3.new
+      @root_bucket = root_bucket
+
+      @bucket = @s3.buckets.create(@root_bucket)
+    end
+
+    def store(file_name)
+      basename = File.basename(file_name)
+      object = @bucket.objects[basename]
+      object.write(:file => file_name)
+    end
+
+    def read(key)
+      use_key = "wp-backup-#{key}.tar.gz"
+      @bucket.objects[use_key].read
+    end
+
+    def keys
+      [].tap do |keys|
+        @bucket.objects.each do |obj|
+          if obj.key =~ /wp-backup-(\d+).tar.gz/
+            keys <<  $1
+          end
+        end
+      end
+    end
+
+    def delete_keys(keys)
+      keys.each do |key|
+        puts "Deleting #{key}"
+        use_key = "wp-backup-#{key}.tar.gz"
+        @bucket.objects[use_key].delete
+      end
+    end
+  end
+end

data/lib/wp_backup/site.rb

@@ -0,0 +1,20 @@
+module WpBackup
+  class Site
+
+    def initialize(root_dir, backup_paths)
+      @root_dir = root_dir
+      @backup_paths = backup_paths || []
+    end
+
+    def dump_to(file)
+      result = `cd #{@root_dir} && tar -cf #{file} #{@backup_paths.any? ? @backup_paths.join(' ') : '.'}`
+      raise("Copy of site failed (#{$?})") unless result
+    end
+
+    def restore_from(file)
+      if File.exists?(file)
+        `cd #{@root_dir} && tar -xf #{file}`
+      end
+    end
+  end
+end

data/lib/wp_backup/version.rb

@@ -0,0 +1,3 @@
+module WpBackup
+  VERSION = '0.1.1'
+end

data/lib/wp_backup.rb

@@ -0,0 +1,8 @@
+%w(backup cli config  database s3 site).each do |file|
+  require_relative "wp_backup/#{file}"
+end
+
+module WpBackup
+  class BackupError < StandardError
+  end
+end

data/sample.rb

@@ -0,0 +1,193 @@
+#  $ rake -f wordpress.rake -T
+#    rake wordpress:backup              # Backup both the WordPress database and site
+#    rake wordpress:backup:db           # Backup the WordPress database to S3
+#    rake wordpress:backup:site         # Backup the WordPress site to S3
+#    rake wordpress:manage:list         # List all your backups
+#    rake wordpress:manage:cleanup      # Remove all but the last 10 most recent backups or optionally specify KEEP=5 to keep the last 5
+#    rake wordpress:retrieve            # Retrieve the latest WordPress database and site backup from S3 (optionally specify VERSION=file_name)
+#    rake wordpress:retrieve:db         # Retrieve the latest WordPress database backup from S3 (optionally specify VERSION=file_name)
+#    rake wordpress:retrieve:site       # Retrieve the latest WordPress site backup from S3 (optionally specify VERSION=file_name)
+DBNAME = "your wordpress database name"
+DBUSER = "your wordpress database username"
+DBPASSWORD = "your wordpress database password"
+PATHTOSITE = "/YOUR/HOME/public_html"
+S3ACCESSKEYID = "your Amazon S3 access id"
+S3SECRETKEY = "your Amazon S3 secret key"
+S3BUCKETNAME = "name_of_your_blog"
+
+
+
+namespace :wordpress do
+
+  desc "Backup WordPress database and site to Amazon S3"
+  task :backup => [ "wordpress:backup:db", "wordpress:backup:site"]
+
+  namespace :backup do
+    desc "Backup the WordPress database to S3"
+    task :db  do
+      s3_connect
+      
+      msg "Initiating database backup"
+      make_bucket('db')
+      backup = "/tmp/#{backup_name('db')}"
+
+      msg "Dumping database"
+      cmd = "mysqldump --opt --skip-add-locks -u#{DBUSER} "
+      puts cmd + "... [password filtered]"
+      cmd += " -p'#{DBPASSWORD}' " unless DBPASSWORD.empty?
+      cmd += " #{DBNAME} > #{backup}"
+      result = system(cmd)
+      raise("ERROR: mysqldump failed (#{$?})") unless result
+
+      s3_transmit('db', backup)
+    end
+
+    desc "Backup the WordPress site to S3"
+    task :site  do
+      s3_connect
+
+      msg "Initiating site backup"
+      make_bucket('site')
+      backup = "/tmp/#{backup_name('site')}"
+
+      cmd = "cp -rp #{PATHTOSITE} #{backup}"
+      msg "Making copy of site"
+      puts cmd
+      result = system(cmd)      
+      raise("Copy of site failed (#{$?})") unless result
+
+      s3_transmit('site', backup)
+    end
+
+  end # end backup namespace
+
+  desc "Retrieve the latest WordPress database and site backup from S3.  If you need to specify a specific version, call the individual retrieve tasks."
+  task :retrieve => [ "wordpress:retrieve:db",  "wordpress:retrieve:site"]
+
+  namespace :retrieve do
+    desc "Retrieve the latest WordPress database backup from S3 (optionally specify VERSION=file_name)"
+    task :db  do
+      retrieve_file 'db', ENV['VERSION']
+    end
+
+    desc "Retrieve the latest WordPress site backup from S3 (optionally specify VERSION=file_name)"
+    task :site do
+      retrieve_file 'site', ENV['VERSION']
+    end
+
+  end #end retrieve namespace
+  
+  namespace :manage do
+    desc "Remove all but the last 10 most recent backups or optionally specify KEEP=5 to keep the last 5"
+    task :cleanup  do
+      s3_connect
+      keep_num = ENV['KEEP'] ? ENV['KEEP'].to_i : 10
+      puts "Keeping the last #{keep_num}"
+      cleanup_bucket('db', keep_num)
+      cleanup_bucket('site', keep_num)
+    end
+
+    desc "Vist all your WordPress backups"
+    task :list  do
+      s3_connect
+      print_bucket 'db'
+      print_bucket 'site'
+    end
+
+  end #end manage namespace
+end
+
+  private
+  
+  # Open a connection to Amazon S3  
+  def s3_connect
+    s3 = AWS::S3.new
+    AWS::S3::Base.establish_connection!(:access_key_id => "#{S3ACCESSKEYID}", :secret_access_key => "#{S3SECRETKEY}", :use_ssl => true)
+  end
+
+  # Zip up the files and send to S3
+  def s3_transmit(name, tmp_file)
+    backup = "/tmp/#{backup_name(name)}.tar.gz"
+
+    msg "Building tar backup for #{name}"
+    cmd = "tar -cpzf #{backup} #{tmp_file}"
+    puts cmd
+    system cmd
+
+    msg "Sending #{name} backup to S3"
+    AWS::S3::S3Object.store(backup.split('/').last, open(backup), bucket_name(name), :access => :private)
+    msg "Finished sending #{name} to S3"
+
+    msg "Cleaning up"
+    cmd = "rm -rf #{backup} #{tmp_file}"
+    puts cmd
+    system cmd  
+  end
+  
+  # Obtain a file from S3
+  def s3_retrieve(bucket, specific_file)
+    msg "Retrieving #{specific_file} from #{bucket} on S3"
+    open(specific_file, 'w') do |file|
+      AWS::S3::S3Object.stream(specific_file, bucket) do |chunk|
+        file.write chunk
+      end
+    end
+    msg "Retrieved #{specific_file} from #{bucket} on S3"
+  end
+  
+  def retrieve_file(name, specific_file)
+    s3_connect
+
+    if specific_file
+      if AWS::S3::S3Object.exists?(specific_file, bucket_name(name))
+        s3_retrieve(bucket_name(name), specific_file)
+      else
+        msg "Couldn't find #{specific_file} in #{bucket_name(name)} on S3"
+      end
+    else
+      # Just get the latest backup file
+      objects = AWS::S3::Bucket.objects(bucket_name(name))
+      s3_retrieve(bucket_name(name), objects[objects.size-1].key)
+    end
+    
+  end
+
+  # Print all backups in a particular bucket
+  def print_bucket(name)
+    msg "Showing contents of #{bucket_name(name)}"
+    bucket = AWS::S3::Bucket.find(bucket_name(name))
+    bucket.objects.each do |object|
+      size = format("%.2f", object.size.to_f/1048576)
+      puts "Name: #{object.key} (#{size}MB)"
+    end
+  end
+
+  # Remove all but KEEP_NUM objects from a particular bucket
+  def cleanup_bucket(name, keep_num)
+    msg "Cleaning up #{bucket_name(name)} (keeping last #{keep_num})"
+    bucket = AWS::S3::Bucket.find(bucket_name(name))
+    objects = bucket.objects
+    remove = objects.size-keep_num-1
+    objects[0..remove].each do |object|
+      response = object.delete
+    end unless remove < 0
+  end
+
+  def make_bucket(name)
+    AWS::S3::Bucket.create(bucket_name(name))
+    msg "Using bucket #{bucket_name(name)}"
+  end
+  
+  def bucket_name(name)
+    "#{S3BUCKETNAME}_#{name}"
+  end
+
+  def backup_name(name)
+    @timestamp ||= Time.now.utc.strftime("%Y%m%d%H%M%S")
+    name.sub('_', '.') + ".#{@timestamp}"
+  end
+
+  def msg(text)
+    puts " -- WordPress backup status: #{text}"
+  end
+

data/spec/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Aubrey Holland
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/README.md

@@ -0,0 +1,29 @@
+# Bundler: a gem to bundle gems
+
+Bundler is a tool that manages gem dependencies for your ruby application. It
+takes a gem manifest file and is able to fetch, download, and install the gems
+and all child dependencies specified in this manifest. It can manage any update
+to the gem manifest file and update the bundle's gems accordingly. It also lets
+you run any ruby code in context of the bundle's gem environment.
+
+### Installation and usage
+
+See [gembundler.com](http://gembundler.com) for up-to-date installation and usage instructions.
+
+### Troubleshooting
+
+For help with common problems, see [ISSUES](https://github.com/carlhuda/bundler/blob/master/ISSUES.md).
+
+### Development
+
+To see what has changed in recent versions of bundler, see the [CHANGELOG](https://github.com/carlhuda/bundler/blob/master/CHANGELOG.md).
+
+The `master` branch contains our current progress towards version 1.1. Because of that, please submit bugfix pull requests against the `1-0-stable` branch.
+
+### Upgrading from Bundler 0.8 to 0.9 and above
+
+See [UPGRADING](https://github.com/carlhuda/bundler/blob/master/UPGRADING.md).
+
+### Other questions
+
+Feel free to chat with the Bundler core team (and many other users) on IRC in the  [#bundler](irc://irc.freenode.net/bundler) channel on Freenode, or via email on the [Bundler mailing list](http://groups.google.com/group/ruby-bundler).

data/spec/Rakefile

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+
+task :release => %w(man:clean man:build)
+
+require 'rspec/core/rake_task'
+require 'ronn'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-fs --color)
+  t.ruby_opts  = %w(-w)
+end
+task :spec => "man:build"
+
+task :default => :spec

data/wp_backup.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'wp_backup/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'wp_backup'
+  s.version     = WpBackup::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Aubrey Holland']
+  s.email       = ['aubreyholland@gmail.com']
+  s.homepage    = 'http://github.com/aub/wp_backup'
+  s.summary     = %q{A tool for backing up wordpress blogs to s3}
+  s.description = %q{}
+
+  s.required_ruby_version     = '>= 1.8.7'
+  s.required_rubygems_version = '>= 1.3.6'
+  s.rubyforge_project         = 'wp_backup'
+
+  s.add_dependency 'aws-sdk', '1.5.2'
+  s.add_dependency 'thor', '0.15.2'
+  s.add_development_dependency 'ronn'
+  s.add_development_dependency 'rspec', '~> 2.0'
+
+  # Man files are required because they are ignored by git
+  man_files            = Dir.glob('lib/wp_backup/man/**/*')
+  git_files            = `git ls-files`.split("\n") rescue ''
+  s.files              = git_files + man_files
+  s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables        = %w(wp_backup)
+  s.require_paths      = %w(lib)
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: wp_backup
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Aubrey Holland
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: &70285341402020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70285341402020
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70285341401540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.15.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70285341401540
+- !ruby/object:Gem::Dependency
+  name: ronn
+  requirement: &70285341401080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70285341401080
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70285341400220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70285341400220
+description: ''
+email:
+- aubreyholland@gmail.com
+executables:
+- wp_backup
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- bin/wp_backup
+- lib/wp_backup.rb
+- lib/wp_backup/backup.rb
+- lib/wp_backup/cli.rb
+- lib/wp_backup/config.rb
+- lib/wp_backup/database.rb
+- lib/wp_backup/s3.rb
+- lib/wp_backup/site.rb
+- lib/wp_backup/version.rb
+- sample.rb
+- spec/LICENSE
+- spec/README.md
+- spec/Rakefile
+- wp_backup.gemspec
+homepage: http://github.com/aub/wp_backup
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: wp_backup
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A tool for backing up wordpress blogs to s3
+test_files:
+- spec/LICENSE
+- spec/README.md
+- spec/Rakefile