closync 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format Fuubar
+--color

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 1.9.3
+env:
+  - [
+    # GOOGLE_STORAGE_ACCESS_KEY_ID
+    {secure: "GOJGnwF6G7u+K9WsZxcWX2H35QdnXNDS4UCJw9ekpEJk0ymmY685lUCmZqGD\nmkZAkJLql+T4oScaGVO7XjNTZnDXN/1NivYhPXtyPbgAtThMm0GPTKT3Kt/z\nxWdDurXqUg44YqEXuFJHOXdOkmNUZM5/4dqNfgW4vtlMzAB4Rw0="},
+    # GOOGLE_STORAGE_SECRET_ACCESS_KEY
+    {secure: "P9J9ss9mRBHmbHHKPZSZHuo7Rc2o9AJx7+7L4IUnvhssxGEiKu6Umov7LKMh\n5ibQH1oaW+JGlpVyqN7EioSMj/ahrZFjK5LAaWIbG5JsttVAgd/9gdUXDuNc\nUOEwLMg9PEOPD/Q1N7VO8SlHj7CuEMPBD2FX3vRJK1kgD2SHA4M="}
+
+    # AWS_ACCESS_KEY_ID
+    # AWS_SECRET_ACCESS_KEY
+  ]
+script:
+  - bundle exec rspec

data/Gemfile

@@ -0,0 +1,30 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in closync.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rake'
+
+  gem 'rspec'
+  gem 'fuubar'
+
+  unless ENV['TRAVIS']
+    gem 'guard-rspec'
+    gem 'guard-bundler'
+
+    gem 'ruby-debug', :platform => :mri_18
+    gem 'debugger',   :platform => :mri_19
+
+    require 'rbconfig'
+    if RbConfig::CONFIG['target_os'] =~ /darwin/i
+      gem 'rb-fsevent'
+      gem 'growl'
+    end
+    if RbConfig::CONFIG['target_os'] =~ /linux/i
+      gem 'rb-inotify'
+      gem 'libnotify'
+    end
+
+  end
+end

data/Guardfile

@@ -0,0 +1,29 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  # watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  # watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  # watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  # watch('config/routes.rb')                           { "spec/routing" }
+  # watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara request specs
+  # watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Alexander Wenzowski
+
+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,49 @@
+# Closync
+
+Synchronizes local and cloud storage.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'closync'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install closync
+
+## Usage
+
+Closync reads from a yaml configuration file to determine origin and
+destination to perform a one-way synchronization.
+
+**.closync.yml**
+
+    credentials:
+      google_storage_access_key_id: ENV['GOOGLE_STORAGE_ACCESS_KEY_ID']
+      google_storage_secret_access_key: ENV['GOOGLE_STORAGE_SECRET_ACCESS_KEY']
+    storage:
+      local:
+        provider: 'Local'
+        directory: 'folder/name'
+      remote:
+        provider: 'Google'
+        directory: 'bucket_name'
+    cache-control:
+      300:
+        - .htm
+        - .html
+      3600:
+        - default
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/closync.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/closync/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Alexander Wenzowski"]
+  gem.email         = ["alexander@wenzowski.com"]
+  gem.summary       = 'A tool for synchronizing cloud storage buckets.'
+  gem.description   = <<-EOF
+    Closync is a cloud storage interaction tool designed to simplify
+    synchronization between multiple filesystems. It uses the fog gem
+    to interact with both local and remote storage.
+  EOF
+  gem.homepage      = "http://github.com/wenzowski/closync"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'closync'
+  gem.require_paths = ["lib"]
+  gem.version       = Closync::VERSION
+
+  gem.add_dependency('fog')
+end

data/lib/closync/config.rb

@@ -0,0 +1,120 @@
+module Closync
+  class Config
+
+    # Fog config
+    attr_accessor :credentials
+    attr_accessor :storage
+    attr_accessor :cache_control
+
+    # Git
+    attr_accessor :branch
+
+
+    def initialize(opts={})
+      self.credentials    = {}
+      self.storage        = {}
+      self.cache_control  = {}
+      self.branch         = []
+
+      @yml_path = ( opts[:yml_path] || "#{Dir.pwd}/.closync.yml" )
+
+      if self.yml_exists?
+        load_yml!
+      else
+        raise "Config file not found at #{opts[:yml_path]}" if opts[:yml_path]
+      end
+    end
+
+    def yml_path
+      @yml_path
+    end
+
+    def yml_exists?
+      File.exists?(self.yml_path)
+    end
+
+    def max_age(extension)
+      self.cache_control[extension] || self.cache_control['default'] ||
+        (raise 'No default max-age configured.')
+    end
+
+    def set_max_age!(extension, max_age)
+      self.cache_control[extension] = max_age
+    end
+
+    def local
+      storage[:local] || (raise 'No local storage configured.')
+    end
+
+    def local=(config={})
+      raise 'Config must include :provider and :directory.' unless
+        config.keys == [:provider, :directory]
+      storage[:local] = {}
+      storage[:local][:provider] = config[:provider]
+      storage[:local][:directory] = config[:directory]
+    end
+
+    def remote
+      storage[:remote] || (raise 'No remote storage configured.')
+    end
+
+    def remote=(config={})
+      raise 'Config must include :provider and :directory.' unless
+        config.keys == [:provider, :directory]
+      storage[:remote] = {}
+      storage[:remote][:provider] = config[:provider]
+      storage[:remote][:directory] = config[:directory]
+    end
+
+    private
+
+      def load_yml!
+        read_yml!
+        set_credentials!
+        set_storage!
+        set_cache_control!
+        set_branch!
+      end
+
+      def read_yml
+        YAML.load(ERB.new(IO.read(self.yml_path)).result) rescue nil || {}
+      end
+
+      def read_yml!
+        @yml = read_yml
+      end
+
+      def set_credentials!
+        self.credentials = {}
+        @yml['credentials'].each do |key, val|
+          self.credentials[key.to_sym] = val
+        end
+      end
+
+      def set_storage!
+        self.storage = {}
+        @yml['storage'].each do |remote, config|
+          self.storage[remote.to_sym] = {}
+          config.each do |key, val|
+            self.storage[remote.to_sym][key.to_sym] = val
+          end
+        end
+      end
+
+      def set_cache_control!
+        @yml['cache_control'].each do |max_age, extensions|
+          extensions.each do |extension|
+            set_max_age!(extension, max_age)
+          end
+        end
+      end
+
+      def set_branch!
+        self.branch = []
+        @yml['branch'].each do |branch|
+          self.branch << branch
+        end
+      end
+
+  end
+end

data/lib/closync/storage.rb

@@ -0,0 +1,49 @@
+require 'fog'
+
+module Closync
+  class Storage
+    attr_accessor :directory
+
+    # * config (<~object) Closync::Config
+    # * opts (<~dict) Options to initialize fog connection.
+    #   * :provider (<~string): Options are ['Local', 'AWS', 'Google', 'Rackspace']
+    #   * :directory (<~string) Bucket or local directory.
+    def initialize(config, opts={})
+      dir = opts.delete(:directory)
+      case opts[:provider]
+      when 'Local'
+        opts[:local_root] = Dir.pwd
+        @storage = Fog::Storage.new(opts)
+      when 'AWS'
+        opts[:aws_access_key_id] =
+          config.credentials[:aws_access_key_id]
+        opts[:aws_secret_access_key] =
+          config.credentials[:aws_access_key_id]
+        @storage = Fog::Storage.new(opts)
+      when 'Google'
+        opts[:google_storage_access_key_id] =
+          config.credentials[:google_storage_access_key_id]
+        opts[:google_storage_secret_access_key] =
+          config.credentials[:google_storage_secret_access_key]
+        @storage = Fog::Storage.new(opts)
+      when 'Rackspace'
+        opts[:rackspace_username] =
+          config.credentials[:rackspace_username]
+        opts[:rackspace_api_key] =
+          config.credentials[:rackspace_api_key]
+        @storage = Fog::Storage.new(opts)
+      else
+        raise 'Unsupported provider'
+      end
+
+      # Get the requested bucket/directory. Create if missing.
+      if d = @storage.directories.get(dir)
+        self.directory = d
+      else
+        @storage.directories.create(key: dir, public: true)
+        self.directory = @storage.directories.get(dir)
+      end
+    end
+
+  end
+end

data/lib/closync/sync.rb

@@ -0,0 +1,64 @@
+require 'closync/storage'
+
+module Closync
+  class Sync
+
+    def initialize(config)
+      @config = config
+      raise 'Local directory not configured' unless config.local
+      raise 'Remote directory not configured' unless config.remote
+      @local = Closync::Storage.new(config, config.local)
+      @remote = Closync::Storage.new(config, config.remote)
+    end
+
+    def push!
+      push_new_data!
+      delete_old_data!
+    end
+
+    private
+
+    def push_new_data!
+      @local.directory.files.each do |file|
+        upload!(file) if upload?(file)
+      end
+    end
+
+    def delete_old_data!
+      # @remote.directory.files.each do |file|
+      #   file.delete unless @local.directory.files.head(file)
+      # end
+    end
+
+    def upload?(file)
+      upload = false
+      if ( remote_file = @remote.directory.files.head(file.key) )
+        if remote_file.last_modified < file.last_modified
+          # TODO(wenzowski): check etag to see if file has changed
+          upload = true # clobber remote file
+        end
+      else
+        upload = true
+      end
+      upload
+    end
+
+    # If file already exists on remote it will be overwritten.
+    def upload!(file)
+      @remote.directory.files.create(
+        key:            file.key,
+        body:           file.body,
+        cache_control:  max_age(file),
+        public:         true
+      )
+    end
+
+    def max_age(file)
+      @config.max_age( extension(file) )
+    end
+
+    def extension(file)
+      /(\.\w+)$/.match(file.key)[0]
+    end
+  end
+end

data/lib/closync/version.rb

@@ -0,0 +1,3 @@
+module Closync
+  VERSION = "0.0.1"
+end

data/lib/closync.rb

@@ -0,0 +1,26 @@
+require 'closync/version'
+require 'closync/config'
+require 'closync/storage'
+require 'closync/sync'
+
+module Closync
+  class << self
+    def config=(data)
+      @config = data
+    end
+
+    def config
+      @config ||= Config.new
+      @config
+    end
+
+    def configure(&proc)
+      @config ||= Config.new
+      yield @config
+    end
+
+    def push!
+      Sync.new(config).push!
+    end
+  end
+end

data/spec/lib/closync/config_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'closync/config'
+
+describe Closync::Config do
+  context 'no yml config file' do
+    subject { Closync::Config.new() }
+
+    it { subject.yml_path.should == "#{Dir.pwd}/.closync.yml" }
+    it { subject.yml_exists?.should be_false }
+
+    it { subject.credentials.should == {} }
+    it { subject.storage.should == {} }
+    it { subject.cache_control.should == {} }
+
+    it { subject.branch.should == [] }
+  end
+
+  context 'yml config file missing' do
+    let(:yml_path) { "#{Dir.pwd}/.closync.yml" }
+    it 'raises error if yml_path does not point to a file' do
+      lambda { Closync::Config.new(yml_path: yml_path) }.should raise_error
+    end
+  end
+
+  context 'yml config file exists' do
+    let(:yml_path) { "#{Dir.pwd}/spec/support/closync.yml" }
+    subject { Closync::Config.new(yml_path: yml_path) }
+
+    it { subject.yml_path.should == yml_path }
+    it { subject.yml_exists?.should be_true }
+
+    # Fog credentials
+    it { subject.credentials.keys.should == [:google_storage_access_key_id, :google_storage_secret_access_key] }
+
+    # Remotes to interact with
+    it { subject.storage.keys.should == [:local, :remote] }
+    it { subject.local.keys.should == [:provider, :directory] }
+    it { subject.local[:provider].should == 'Local' }
+    it { subject.local[:directory].should == 'folder/name' }
+    it { subject.remote.keys.should == [:provider, :directory] }
+    it { subject.remote[:provider].should == 'Google' }
+    it { subject.remote[:directory].should == 'bucket_name' }
+
+    #  Cache-Control headers
+    it { subject.cache_control.should == {'.htm' => 300, '.html' => 300, 'default' => 3600} }
+    it { subject.max_age('.htm').should == 300 }
+    it { subject.max_age('.jpg').should == 3600 }
+
+    # Git branch to check for before performing actions
+    it { subject.branch.should == ['master'] }
+  end
+end

data/spec/lib/closync/storage_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'closync/storage'
+require 'closync/config'
+
+describe Closync::Storage do
+  let(:yml_path) { "#{Dir.pwd}/spec/support/closync.yml" }
+  let(:dir) { SecureRandom.hex }
+  let(:config) { Closync::Config.new(yml_path: yml_path) }
+
+  context 'local storage' do
+    # DIRTY HACK: Fog's Local Storage is not mocked.
+    before(:each) do
+      FileUtils.rm_rf 'tmp'
+      FileUtils.mkdir 'tmp'
+    end
+    subject { Closync::Storage.new(Closync::Config.new, provider: 'Local', directory: "tmp/#{dir}") }
+    it { subject.directory.class.should be(Fog::Storage::Local::Directory) }
+    it { subject.directory.key.should eq("tmp/#{dir}") }
+  end
+
+  context 'google storage' do
+    # WARNING: THESE TESTS CREATE BUCKETS ON GOOGLE STORAGE
+    # subject { Closync::Storage.new(config, provider: 'Google', directory: dir) }
+    # it { subject.directory.class.should be(Fog::Storage::Google::Directory) }
+    # it { subject.directory.key.should == dir }
+  end
+
+end

data/spec/lib/closync/sync_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'closync/sync'
+require 'closync/config'
+
+describe Closync::Storage do
+  let(:dir) { SecureRandom.hex }
+  let(:local_dir) { "tmp/local/#{dir}" }
+  let(:remote_dir) { "tmp/remote/#{dir}" }
+
+  let(:yml_path) { "#{Dir.pwd}/spec/support/closync.yml" }
+  let(:config) {
+    config = Closync::Config.new(yml_path: yml_path)
+    config.local = { provider: 'Local', directory: local_dir }
+    config.remote = { provider: 'Local', directory: remote_dir }
+    config
+  }
+
+  context 'local sync' do
+    before(:each) do
+      FileUtils.mkdir_p local_dir
+      FileUtils.mkdir_p remote_dir
+      FileUtils.touch "#{local_dir}/index.html"
+      FileUtils.touch "#{local_dir}/pic.jpg"
+    end
+    after(:each) do
+      FileUtils.rm_rf local_dir
+      FileUtils.rm_rf remote_dir
+    end
+
+    it { lambda {Closync::Sync.new(config)}.should_not raise_error }
+
+    it 'pushes files to remote' do
+      File.exists?("#{remote_dir}/index.html").should be_false
+      File.exists?("#{remote_dir}/pic.jpg").should be_false
+      Closync::Sync.new(config).push!
+      File.exists?("#{remote_dir}/index.html").should be_true
+      File.exists?("#{remote_dir}/pic.jpg").should be_true
+    end
+  end
+
+end

data/spec/lib/closync/version_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'closync/version'
+
+describe Closync do
+  it { Closync::VERSION.should eq('0.0.1'), "Please don't bump the version." }
+end

data/spec/lib/closync_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'closync'
+
+describe Closync do
+  it 'should be configured by block' do
+    Closync.configure do |config|
+      config.credentials = {
+        google_storage_access_key_id: ENV['GOOGLE_STORAGE_ACCESS_KEY_ID'],
+        google_storage_secret_access_key: ENV['GOOGLE_STORAGE_SECRET_ACCESS_KEY']
+      }
+      config.local = {provider: 'Local', directory: 'folder/name'}
+      config.remote = {provider: 'Google', directory: 'bucket_name'}
+      config.branch = ['master']
+      config.set_max_age!('default', 3600)
+      config.set_max_age!('.htm', 300)
+      config.set_max_age!('.html', 300)
+    end
+    Closync.config.credentials.should_not be_nil
+    Closync.config.storage.should_not be_nil
+    Closync.config.branch.should_not be_nil
+    Closync.config.cache_control.should_not be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+# require 'fog'
+# Fog.mock!

data/spec/support/closync.yml

@@ -0,0 +1,18 @@
+credentials: # symbol names per fog gem
+  google_storage_access_key_id: <%= ENV['GOOGLE_STORAGE_ACCESS_KEY_ID'] || 'mock_key' %>
+  google_storage_secret_access_key: <%= ENV['GOOGLE_STORAGE_SECRET_ACCESS_KEY'] || 'mock_secret' %>
+storage: # provider strings per fog gem
+  local:
+    provider: 'Local'
+    directory: 'folder/name'
+  remote:
+    provider: 'Google'
+    directory: 'bucket_name'
+branch: # restrict push to git branch
+  - master
+cache_control:
+  300:
+    - .htm
+    - .html
+  3600:
+    - default

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: closync
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Wenzowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    Closync is a cloud storage interaction tool designed to simplify\n
+  \   synchronization between multiple filesystems. It uses the fog gem\n    to interact
+  with both local and remote storage.\n"
+email:
+- alexander@wenzowski.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- closync.gemspec
+- lib/closync.rb
+- lib/closync/config.rb
+- lib/closync/storage.rb
+- lib/closync/sync.rb
+- lib/closync/version.rb
+- spec/lib/closync/config_spec.rb
+- spec/lib/closync/storage_spec.rb
+- spec/lib/closync/sync_spec.rb
+- spec/lib/closync/version_spec.rb
+- spec/lib/closync_spec.rb
+- spec/spec_helper.rb
+- spec/support/closync.yml
+homepage: http://github.com/wenzowski/closync
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2016661747058335688
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2016661747058335688
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A tool for synchronizing cloud storage buckets.
+test_files:
+- spec/lib/closync/config_spec.rb
+- spec/lib/closync/storage_spec.rb
+- spec/lib/closync/sync_spec.rb
+- spec/lib/closync/version_spec.rb
+- spec/lib/closync_spec.rb
+- spec/spec_helper.rb
+- spec/support/closync.yml