defog 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in defog.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ronen Barzel
+
+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.rdoc

@@ -0,0 +1,124 @@
+= defog
+
+Defog wraps the [fog](https://rubygems.org/gems/fog) gem (specifically,
+[Fog::Storage](http://fog.io/1.3.1/storage/)), providing access to files
+stored in the cloud via proxy files on the local file system.
+A proxy file can be
+* Read-only:  A local cached copy of a cloud file.
+* Write-only:  A local file that will be uploaded to the cloud.
+* Read-Write:  A local file that mirrors a cloud file, propogating changes back to the cloud.
+
+Defog thus lets you use ordinary programmatic tools to access and
+manipulate your cloud data.  Thanks to the magic of
+[fog](https://rubygems.org/gems/fog) it works across cloud providers, and
+it also works with the local file system as a "provider" so that you can,
+e.g. use the local file system for development and the cloud for
+production.
+
+== Usage Summary
+
+Full Rdoc is available at http://rubydoc.info/gems/defog
+
+=== Create proxy connection
+
+Connect to the remote storage by creating a <code>Defog::Proxy</code>
+object, which proxies files in a specific remote location, e.g.:
+
+        defog = Defog::Proxy.new(:provider => :AWS,
+                                 :aws_access_key_id => "yourid",
+                                 :aws_secret_access_key => "yoursecret",
+                                 :region => "optional-s3-region",
+                                 :bucket => "s3-bucket-name")
+
+        defog = Defog::Proxy.new(:provider => :Local,
+                                 :directory => "/path/to/directory")
+
+=== Proxy a file
+
+Proxy a remote file by creating a <code>Defog::File</code> object:
+
+        file = defog.file("key/of/file", mode)
+        # ... access file ...
+        file.close
+
+        defog.file("key/of/file", mode) do |file|
+           # ... access file ...
+        end
+
+<code>mode</code> can be "r", "r+", "w", "w+", "a", or "a+" with the usual
+semantics.  Closing the file object (explicitly or implicitly at the end of
+the block) synchronizes the local proxy with the remote storage and (by
+default) deletes the local proxy file.
+
+The <code>Defog::File</code> class inherits from <code>::File</code>.  So
+you can use it directly for I/O operations, such as
+  
+     defog.file("key", "r") do |file|
+        file.readlines
+     end
+
+You can also access the proxy file via its path, allowing things such as
+
+  defog.file("image100x100.jpg", "w") do |file|
+    system("convert souce.png -scale 100x100 #{file.path}")
+  end
+
+(Note that the proxy file path has the same file extension as the cloud key string.)
+
+
+To suppress updating the remote storage, delete the local proxy file before
+closing (e.g. via <code>File.unlink(file.path)</code>) or pass
+<code>:synchronize => false</code> to the <code>#close</code> method.
+
+
+=== Persistence
+
+By default, the local proxy files are deleted when closed.  However, it is
+possible to persist the local proxy, so that it if the remote is accessed
+again-- whether in the same program execution or at a later time or by a
+different program--the data will not need to be transferred again.  Do so
+via
+
+        file = defog.file("key/of/file", mode, :persist => true)
+
+or
+
+        file.close(:persist => true) # overrides setting at runtime
+
+When opening a file whose local proxy has been persisted, Defog checks to see if
+the local proxy is out of date and if so replaces it.
+
+Currently, Defog does not natively support a way to explictly delete the
+locally persisted file (other than opening and closing it again without
+:persist => true).  But it's fair game to delete it outside of Defog, such
+as via a cron job that cleans out old files.
+
+=== Local Proxy File Location
+
+Local proxy files are stored by default in
+
+        #{tmproot}/defog/#{provider}/#{location}/#{key}
+
+where <code>tmproot</code> is <code>Rails.root+"tmp"</code> if Rails is
+defined, otherwise <code>Dir.tmpdir()</code>.  For AWS,
+  <code>location</code> is the bucket name, and for Local it's the
+  local_root directory path with slashes replaced with dashes
+
+See the documentation for configuring other locations.
+
+== Installation
+
+Gemfile:
+        gem 'defog'
+
+== Compatibility
+
+Defog has (so far) been tested using MRI 1.9.3 and
+[fog](https://rubygems.org/gems/fog) storage providers :Local and :AWS
+
+== History
+
+== Copyright
+
+Released under the MIT License.  See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,16 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = '-Ispec'
+end
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+    require File.dirname(__FILE__) + '/lib/defog/version'
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title = "defog #{Defog::VERSION}"
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/defog.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/defog/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["ronen barzel"]
+  gem.email         = ["ronen@barzel.org"]
+  gem.description   = %q{Wrapper to fog gem, proxying access to cloud files as local files.}
+  gem.summary       = %q{Wrapper to fog gem, proxying access to cloud files as local files.  Access can be read-only (local cache), write-only (upload), or read-write (mirror)}
+  gem.homepage      = "http://github.com/ronen/defog"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "defog"
+  gem.require_paths = ["lib"]
+  gem.version       = Defog::VERSION
+
+  gem.add_dependency 'fog'
+  gem.add_dependency 'hash_keyword_args'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'simplecov-gem-adapter'
+end

data/lib/defog.rb

@@ -0,0 +1,5 @@
+require 'defog/error'
+require 'defog/file'
+require 'defog/fog_wrapper'
+require 'defog/proxy'
+require 'defog/version'

data/lib/defog/error.rb

@@ -0,0 +1,8 @@
+module Defog
+  class Error < RuntimeError
+
+    class NoCloudFile < Error
+    end
+  end
+
+end

data/lib/defog/file.rb

@@ -0,0 +1,83 @@
+module Defog
+  # Create a Defog::File proxy instance via Defog::Proxy#file, such as
+  #
+  #    defog = Defog::Proxy.new(:provider => :AWS, :aws_access_key_id => access_key, ...)
+  #
+  #    defog.file("key/to/my/file", "w") do |file|
+  #       # ... access the proxy file ...
+  #    end
+  #
+  # or
+  #
+  #    file = defog.file("key/to/my/file", "w")
+  #    # ... access the proxy file ...
+  #    file.close
+  #  
+  # Defog::File inherits from ::File, so you can act on the proxy file using
+  # ordinary IO methods, such as
+  #
+  #    defog.file("key", "r") do |file|
+  #       file.readlines
+  #    end
+  #
+  # You can also access the proxy file via its path, allowing things such
+  # as
+  #    defog.file("image100x100.jpg", "w") do |file|
+  #       system("convert souce.png -scale 100x100 #{file.path}")
+  #    end
+  # 
+  # (Note that the proxy file path has the same file extension as the cloud key string.)
+  #
+  # Upon closing the proxy file, in normal use the cloud storage gets synchronized and
+  # the proxy deleted.  See File#close for more details.
+  class File < ::File
+    def self.get(opts={}, &block) #:nodoc:
+      opts = opts.keyword_args(:proxy => :required, :key => :required, :mode => :required, :persist => :optional)
+
+      proxy_path = opts[:proxy_path] = Pathname.new("#{opts.proxy.proxy_root}/#{opts.key}").expand_path
+      proxy_path.dirname.mkpath
+
+      case opts.mode
+      when "r" then
+        opts.proxy.fog_wrapper.get_file(opts.key, proxy_path)
+      when "w", "w+" then
+        opts[:upload] = true
+      when "r+", "a", "a+" then
+        opts.proxy.fog_wrapper.get_file(opts.key, proxy_path)
+        opts[:upload] = true
+      else
+        raise ArgumentError, "Invalid mode #{opts.mode.inspect}"
+      end
+
+      self.open(opts, &block)
+    end
+
+    def initialize(opts={}, &block) #:nodoc:
+      @defog = opts.keyword_args(:proxy => :required, :mode => :required, :key => :required, :proxy_path => :required, :upload => :optional, :persist => :optional)
+      super(@defog.proxy_path, @defog.mode, &block)
+    end
+
+    # Closes the proxy file and, in the common case, synchronizes the cloud storage
+    # then deletes the proxy file.
+    #
+    # Synchronization can be suppressed by passing the option
+    #    :synchronize => false
+    # Synchronization will also be implicitly suppressed if the proxy file
+    # was deleted before this call, e.g., via <code>::File.unlink(file.path)</code>.
+    #
+    #
+    # Whether the proxy file gets deleted vs persisted after the close can
+    # be set by passing the option
+    #    :persist => true or false
+    # (This will override the setting of <code>:persist</code> passed to Proxy#file)
+    #
+    def close(opts={})
+      opts = opts.keyword_args(:persist => @defog.persist, :synchronize => true)
+      super()
+      if @defog.proxy_path.exist?
+        @defog.proxy.fog_wrapper.put_file(@defog.key, @defog.proxy_path) if @defog.upload and opts.synchronize
+        @defog.proxy_path.unlink unless opts.persist
+      end
+    end
+  end
+end

data/lib/defog/fog_wrapper.rb

@@ -0,0 +1,73 @@
+require "fog"
+require "hash_keyword_args"
+require "pathname"
+
+module Defog #:nodoc: all
+  class FogWrapper #:nodoc: all
+
+    attr_reader :location
+    attr_reader :fog_directory
+
+    def self.connect(opts={})
+      opts = opts.keyword_args(:provider => :required, :OTHERS => :optional)
+      provider = opts.delete(:provider)
+      klass = begin
+                self.const_get(provider.to_s.capitalize, false)
+              rescue NameError
+                raise ArgumentError, "#{provider.inspect} is not a supported fog storage provider"
+              end
+      klass.new(opts)
+    end
+
+    def get_file(key, path)
+      raise Error::NoCloudFile, "No such file in #{provider} #{location}: #{key}" unless fog_head(key)
+      return if path.exist? and Digest::MD5.hexdigest(path.read) == get_md5(key)
+      path.open("w") do |f|
+        f.write(fog_head(key).body)
+      end
+    end
+
+    def put_file(key, path)
+      fog_directory.files.create(:key => key, :body => path.open)
+    end
+
+    def fog_head(key)
+      fog_directory.files.head(key)
+    end
+
+    class Local < FogWrapper
+      def provider ; :local ; end
+
+      def initialize(opts={})
+        opts = opts.keyword_args(:local_root => :required)
+        directory = Pathname.new(opts.local_root).realpath
+        @location = directory.to_s.gsub(%r{/},'_')
+        @fog_connection = Fog::Storage.new(:provider => provider, :local_root => directory)
+        @fog_directory = @fog_connection.directories.get('.')
+      end
+
+      def get_md5(key)
+        Digest::MD5.hexdigest(fog_head(key).body)
+      end
+
+    end
+
+    class Aws < FogWrapper
+      def provider ; :AWS ; end
+
+      def initialize(opts={})
+        opts = opts.keyword_args(:aws_access_key_id => :required, :aws_secret_access_key => :required, :region => :optional, :bucket => :required)
+        @location = opts.delete(:bucket)
+        @fog_connection = Fog::Storage.new(opts.merge(:provider => provider))
+        @fog_connection.directories.create :key => @location unless @fog_connection.directories.map(&:key).include? @location
+        @fog_directory = @fog_connection.directories.get(@location)
+      end
+
+      def get_md5(key)
+        fog_head(key).content_md5
+      end
+
+    end
+  end
+end
+

data/lib/defog/proxy.rb

@@ -0,0 +1,85 @@
+require "hash_keyword_args"
+require "tmpdir"
+require "pathname"
+
+module Defog
+  class Proxy
+
+    attr_reader :proxy_root     # 
+    attr_reader :fog_wrapper    # :nodoc:
+
+    # Opens a <code>Fog</code> cloud storage connection to map to a corresponding proxy
+    # directory.  Use via, e.g.,
+    #
+    #     Defog::Proxy.new(:provider => :AWS, :aws_access_key_id => access_key, ...)
+    #
+    # The <code>:provider</code> and its corresponding options must be
+    # specified as per <code>Fog::Storage.new</code>.  Currently, only
+    # <code>:local</code> and <code>:AWS</code> are supported.  When using
+    # <code>:AWS</code>, an additional option <code>:bucket</code> must be
+    # specified; all files proxied by this instance must be in a single
+    # bucket.
+    #
+    # By default, each proxy's root directory is placed in a reasonable
+    # safe place, under <code>Rails.root/tmp</code> if Rails is defined
+    # otherwise under <code>Dir.tmpdir</code>.  (More details: within that
+    # directory, the root directory is disambiguated by #provider and
+    # #location, so that multiple Defog::Proxy instances can be
+    # created without collision.)
+    #
+    # The upshot is that if you have no special constraints you don't need
+    # to worry about it.  But if you do care, you can specify the option:
+    #   :proxy_root => "/root/for/this/proxy/files"
+    #
+    def initialize(opts={})
+      opts = opts.keyword_args(:provider => :required, :proxy_root => :optional, :OTHERS => :optional)
+
+      @proxy_root = Pathname.new(opts.delete(:proxy_root)) if opts.proxy_root
+
+      @fog_wrapper = FogWrapper.connect(opts)
+
+      @proxy_root ||= case
+                      when defined?(Rails) then Rails.root
+                      else Pathname.new(Dir.tmpdir)
+                      end + "defog" + provider.to_s + location
+
+    end
+
+    # Returns the provider for this proxy.  I.e., <code>:local</code> or
+    # <code>:AWS</code>
+    def provider
+      @fog_wrapper.provider
+    end
+
+    # Returns a 'location' handle to use in the default proxy root path,
+    # to disambiguate it from other proxies with the same provider.  For
+    # :AWS it's the bucket name, for :Local it's derived from the local
+    # root path.
+    def location
+      @fog_wrapper.location
+    end
+
+    # Proxy a remote cloud file.  Returns a Defog::File object, which is a
+    # specialization of ::File. 
+    #
+    # <code>key</code> is the cloud storage key for the file.
+    #
+    # <code>mode</code> can be "r", "r+", "w", "w+", "a", or "a+" with the
+    # usual semantics.
+    #
+    # Like ::File.open, if called with a block yields the file object to
+    # the block and ensures the file will be closed when leaving the block.
+    #
+    # Normally the proxy file is synchronized and then deleted upon close.
+    # Pass
+    #    :persist => true
+    # to maintain the file after closing.   See File#close for more
+    # details.
+    #
+    def file(key, mode, opts={}, &block)
+      opts = opts.keyword_args(:persist)
+      File.get(opts.merge(:proxy => self, :key => key, :mode => mode), &block)
+    end
+
+  end
+end

data/lib/defog/version.rb

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

data/spec/.gitignore

@@ -0,0 +1 @@
+tmp/

data/spec/file_spec.rb

@@ -0,0 +1,257 @@
+require 'spec_helper'
+
+shared_examples "get proxy" do
+  it "should create proxy if remote exists" do
+    create_remote("hello")
+    file = @proxy.file(key, @mode)
+    File.exist?(file.path).should be_true
+  end
+
+  it "should raise error if remote doesn't exist" do
+    expect { @proxy.file("nonesuch", @mode) }.should raise_error(Defog::Error::NoCloudFile)
+  end
+
+  it "should overwrite existing proxy if it's not valid " do
+    create_remote("hello")
+    create_proxy("goodbye")
+    proxy_path.read.should == "goodbye"
+    @proxy.file(key, @mode)
+    proxy_path.read.should == "hello"
+  end
+
+  it "should use existing proxy if it's valid" do
+    create_remote("hello")
+    create_proxy("hello")
+    Pathname.any_instance.should_not_receive(:open).with("w")
+    @proxy.file(key, @mode)
+
+    # doublecheck that should_not_receive was the right
+    # thing to test.  will it be received for an invalid proxy?
+    create_proxy("goodbye")
+    Pathname.any_instance.should_receive(:open).with("w")
+    @proxy.file(key, @mode)
+  end
+end
+
+shared_examples "read" do
+  it "should correctly read" do
+    create_remote("read me")
+    @proxy.file(key, @mode) do |file|
+      file.rewind
+      file.read.should == "read me"
+    end
+  end
+end
+
+shared_examples "read after write" do
+  it "should correctly read after write" do
+    @proxy.file(key, @mode) do |file|
+      file.write "read me"
+      file.rewind
+      file.read.should == "read me"
+    end
+  end
+end
+
+shared_examples "write" do
+  it "should correctly write" do
+    create_remote("dummy")
+    @proxy.file(key, @mode, :persist => true) do |file|
+      file.write "write me"
+    end
+    proxy_path.read.should =~ /write me$/
+  end
+end
+
+shared_examples "append" do
+  it "should correctly append" do
+    create_remote("hello")
+    @proxy.file(key, @mode, :persist => true) do |file|
+      file.write "goodbye"
+    end
+    proxy_path.read.should == "hellogoodbye"
+  end
+end
+
+shared_examples "create" do
+
+  it "should create remote" do
+    file = @proxy.file(key, @mode)
+    create_proxy("upload me")
+    file.close
+    remote_body.should == "upload me"
+  end
+
+  it "should not create remote if proxy is deleted" do
+    @proxy.file(key, @mode) do |file|
+      file.write("ignore me")
+      proxy_path.unlink
+    end
+    expect {remote_body}.should raise_error
+  end
+
+  it "should not create remote if :synchronize => false" do
+    file = @proxy.file(key, @mode)
+    create_proxy("ignore me")
+    file.close(:synchronize => false)
+    expect {remote_body}.should raise_error
+  end
+
+end
+
+shared_examples "update" do
+
+  it "should overwrite remote" do
+    create_remote("overwrite me")
+    remote_body.should == "overwrite me"
+    file = @proxy.file(key, @mode)
+    create_proxy("upload me")
+    file.close
+    remote_body.should == "upload me"
+  end
+
+  it "should not overwrite remote if proxy is deleted" do
+    create_remote("keep me")
+    @proxy.file(key, @mode) do |file|
+      file.write("ignore me")
+      proxy_path.unlink
+    end
+    remote_body.should == "keep me"
+  end
+
+  it "should not overwrite remote if :synchronize => false" do
+    create_remote("keep me")
+    file = @proxy.file(key, @mode)
+    create_proxy("ignore me")
+    file.close(:synchronize => false)
+    remote_body.should == "keep me"
+  end
+
+end
+
+shared_examples "persistence" do
+  it "should delete proxy on close" do
+    create_remote("whatever")
+    file = @proxy.file(key, @mode)
+    proxy_path.should be_exist
+    file.close
+    proxy_path.should_not be_exist
+  end
+
+  it "should delete proxy on close (block form)" do
+    create_remote("whatever")
+    @proxy.file(key, @mode) do |file|
+      proxy_path.should be_exist
+    end
+    proxy_path.should_not be_exist
+  end
+
+  it "should not delete proxy if persisting" do
+    create_remote("whatever")
+    @proxy.file(key, @mode, :persist => true) do |file|
+      proxy_path.should be_exist
+    end
+    proxy_path.should be_exist
+  end
+
+  it "close should override persist true" do
+    create_remote("whatever")
+    file = @proxy.file(key, @mode)
+    proxy_path.should be_exist
+    file.close(:persist => true)
+    proxy_path.should be_exist
+  end
+
+  it "close should override persist false" do
+    create_remote("whatever")
+    file = @proxy.file(key, @mode, :persist => true)
+    proxy_path.should be_exist
+    file.close(:persist => false)
+    proxy_path.should_not be_exist
+  end
+
+end
+
+
+shared_examples "a proxy file" do |proxyargs|
+
+  before(:all) do
+    @proxy = Defog::Proxy.new(proxyargs) 
+  end
+
+  %W[r r+ w w+ a a+].each do |mode|
+
+    context "mode #{mode.inspect}" do
+      before(:each) do 
+        @mode = mode
+      end
+      it_should_behave_like "get proxy" if mode =~ %r{[ra]}
+      it_should_behave_like "read" if mode == "r" or mode == "a+"
+      it_should_behave_like "write" if mode =~ %r{[wa+]}
+      it_should_behave_like "read after write" if mode == "w+"
+      it_should_behave_like "append" if mode =~ %r{a}
+      it_should_behave_like "create" if mode =~ %r{wa}
+      it_should_behave_like "update" if mode =~ %r{[wa+]}
+      it_should_behave_like "persistence"
+    end
+  end
+
+  it "should raise error on bad mode" do
+    expect { @proxy.file(key, "xyz") }.should raise_error(ArgumentError)
+  end
+
+
+end
+
+describe "Defog::Proxy::File" do
+
+  context "Local" do
+
+    before(:all) do
+      Fog.unmock!
+    end
+
+    args = {:provider => :local, :local_root => LOCAL_CLOUD_PATH, :proxy_root => PROXY_BASE_PATH + "local" }
+
+    it_should_behave_like "a proxy file", args
+
+  end
+
+  context "AWS" do
+
+    before(:all) do
+      Fog.mock!
+    end
+
+    args = {:provider => :AWS, :aws_access_key_id => "dummyid", :aws_secret_access_key => "dummysecret", :region => "eu-west-1", :bucket => "tester", :proxy_root => PROXY_BASE_PATH + "AWS"}
+
+    it_should_behave_like "a proxy file", args
+
+  end
+
+  def key
+    example.metadata[:full_description].gsub(/\+/,'plus').gsub(/\W/,'-') + "/filename"
+  end
+
+  def create_remote(body)
+    @proxy.fog_wrapper.fog_directory.files.create(:key => key, :body => body)
+  end
+
+  def proxy_path
+    Pathname.new("#{@proxy.proxy_root}/#{key}").expand_path
+  end
+
+  def create_proxy(body)
+    path = proxy_path
+    path.dirname.mkpath
+    path.open("w") do |f|
+      f.write(body)
+    end
+  end
+
+  def remote_body
+    @proxy.fog_wrapper.fog_directory.files.get(key).body
+  end
+
+
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+shared_examples "a proxy" do |args|
+
+  it "should default proxy root to tmpdir/defog" do
+    proxy = Defog::Proxy.new(args)
+    proxy.proxy_root.should == Pathname.new(Dir.tmpdir) + "defog" + proxy.provider.to_s + proxy.location
+  end
+
+  it "should default proxy root to Rails.root" do
+    begin
+      Kernel.const_set("Rails", Struct.new(:root).new("/dummy/rails/app/"))
+      proxy = Defog::Proxy.new(args)
+      proxy.proxy_root.should == Rails.root + "defog" + proxy.provider.to_s + proxy.location
+    ensure
+      Kernel.send :remove_const, "Rails"
+    end
+  end
+
+  it "should accept proxy root parameter" do
+    path = Pathname.new("/a/random/path")
+    proxy = Defog::Proxy.new(args.merge(:proxy_root => path))
+    proxy.proxy_root.should == path
+  end
+
+
+end
+
+describe Defog::Proxy do
+
+  context "Local" do
+    before(:all) do
+      Fog.unmock!
+    end
+
+    args = {:provider => :local, :local_root => LOCAL_CLOUD_PATH}
+
+    it_should_behave_like "a proxy", args
+
+    it "should use the deslashed local_root as the location" do
+      Defog::Proxy.new(args).location.should == LOCAL_CLOUD_PATH.to_s.gsub(%r{/},"_")
+    end
+
+  end
+
+  context "AWS" do
+    before(:all) do
+      Fog.mock!
+    end
+
+    args = {:provider => :AWS, :aws_access_key_id => "dummyid", :aws_secret_access_key => "dummysecret", :region => "eu-west-1", :bucket => "tester"}
+    it_should_behave_like "a proxy", args
+
+    it "should use the bucket name as the location" do
+      Defog::Proxy.new(args).location.should == args[:bucket]
+    end
+  end
+
+  it "should raise error on bad provider" do
+    expect { Defog::Proxy.new(:provider => :nonesuch) }.should raise_error(ArgumentError)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+if RUBY_VERSION > "1.9"
+  require 'simplecov'
+  require 'simplecov-gem-adapter'
+  SimpleCov.start 'gem'
+end
+
+require 'rspec'
+require 'defog'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end
+
+RSPEC_TMP_PATH = Pathname.new(__FILE__).dirname + "tmp"
+PROXY_BASE_PATH = RSPEC_TMP_PATH + "proxy"
+LOCAL_CLOUD_PATH = RSPEC_TMP_PATH + "cloud"
+
+[PROXY_BASE_PATH, LOCAL_CLOUD_PATH].each do |path|
+  path.rmtree if path.exist?
+  path.mkpath
+end
+

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: defog
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ronen barzel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &70247567066900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70247567066900
+- !ruby/object:Gem::Dependency
+  name: hash_keyword_args
+  requirement: &70247567066480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70247567066480
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70247567066040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70247567066040
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70247567065600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70247567065600
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70247567065000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70247567065000
+- !ruby/object:Gem::Dependency
+  name: simplecov-gem-adapter
+  requirement: &70247567064460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70247567064460
+description: Wrapper to fog gem, proxying access to cloud files as local files.
+email:
+- ronen@barzel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- defog.gemspec
+- lib/defog.rb
+- lib/defog/error.rb
+- lib/defog/file.rb
+- lib/defog/fog_wrapper.rb
+- lib/defog/proxy.rb
+- lib/defog/version.rb
+- spec/.gitignore
+- spec/file_spec.rb
+- spec/proxy_spec.rb
+- spec/spec_helper.rb
+- spec/support/connections.rb
+homepage: http://github.com/ronen/defog
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Wrapper to fog gem, proxying access to cloud files as local files.  Access
+  can be read-only (local cache), write-only (upload), or read-write (mirror)
+test_files:
+- spec/file_spec.rb
+- spec/proxy_spec.rb
+- spec/spec_helper.rb
+- spec/support/connections.rb
+has_rdoc: