carrierwave_direct_mongoid 0.0.6

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+.rvmrc
+pkg/*

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+ - 1.8.7
+ - 1.9.2
+

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) David Wilkie
+
+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,404 @@
+# CarrierWaveDirect
+
+[![Build Status](https://secure.travis-ci.org/dwilkie/carrierwave_direct.png)](http://travis-ci.org/dwilkie/carrierwave_direct)
+
+[CarrierWave](https://github.com/jnicklas/carrierwave) is a great way to upload files from Ruby applications, but since processing and saving is done in-process, it doesn't scale well. A better way is to upload your files directly then handle the processing and saving in a background process.
+
+[CarrierWaveDirect](https://github.com/dwilkie/carrierwave_direct) works on top of [CarrierWave](https://github.com/jnicklas/carrierwave) and provides a simple way to achieve this.
+
+## Compatibility
+
+Right now, CarrierWaveDirect works with [Amazon S3](http://aws.amazon.com/s3/). Adding support for [Google Storage for Developers](http://code.google.com/apis/storage/) should be fairly straight forward since the direct upload form is essentially the same. Please see the contributing section if you would like support for Google Storage for Developers or any other service that provides direct upload capabilities.
+
+Please be aware that this gem (and S3 in general) only support single file uploads. If you want to upload multiple files simultaneously you'll have to use a javascript or flash uploader.
+
+## Information
+
+More information, and how-tos [available on the wiki](https://github.com/dwilkie/carrierwave_direct/wiki)
+
+## Installation
+
+Install the latest release:
+
+    gem install carrierwave_direct
+
+In Rails, add it to your Gemfile:
+
+    gem 'carrierwave_direct'
+
+Note that CarrierWaveDirect is not compatible with Rails 2.
+
+## Getting Started
+
+Please read the [CarrierWave readme](https://github.com/jnicklas/carrierwave) first
+
+CarrierWaveDirect works with [fog](https://github.com/geemus/fog) so make sure you have [CarrierWave](https://github.com/jnicklas/carrierwave) set up and initialized with your fog credentials, for example:
+
+    CarrierWave.configure do |config|
+      config.fog_credentials = {
+        :provider               => 'AWS',       # required
+        :aws_access_key_id      => 'xxx',       # required
+        :aws_secret_access_key  => 'yyy',       # required
+        :region                 => 'eu-west-1'  # optional, defaults to 'us-east-1'
+      }
+      config.fog_directory  = 'name_of_directory'                     # required
+      config.fog_host       = 'https://assets.example.com'            # optional, defaults to nil
+      config.fog_public     = false                                   # optional, defaults to true
+      config.fog_attributes = {'Cache-Control'=>'max-age=315576000'}  # optional, defaults to {}
+    end
+
+If you haven't already done so generate an uploader
+
+    rails generate uploader Avatar
+
+this should give you a file in:
+
+    app/uploaders/avatar_uploader.rb
+
+Check out this file for some hints on how you can customize your uploader. It should look something like this:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      storage :file
+    end
+
+Remove the line `storage :file` and replace it with `include CarrierWaveDirect::Uploader` so it should look something like:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include CarrierWaveDirect::Uploader
+    end
+
+This adds the extra functionality for direct uploading.
+
+Finally, remove the `store_dir` method in order to default CarrierWaveDirect to its own storage directory.
+
+If you're *not* using Rails you can generate a direct upload form to S3 similar to [this example](http://doc.s3.amazonaws.com/proposals/post.html#A_Sample_Form)) by making use of the CarrierWaveDirect helper methods.
+
+### Sinatra
+
+Here is an example using Sinatra and Haml
+
+    # uploader_test.rb
+
+    CarrierWave.configure do |config|
+      config.fog_credentials = {
+        :provider               => 'AWS',
+        :aws_access_key_id      => ENV['AWS_ACCESS_KEY_ID'],
+        :aws_secret_access_key  => ENV['AWS_SECRET_ACCESS_KEY']
+      }
+      config.fog_directory  = ENV['AWS_FOG_DIRECTORY'] # bucket name
+    end
+
+    class ImageUploader < CarrierWave::Uploader::Base
+      include CarrierWaveDirect::Uploader
+    end
+
+    class UploaderTest < Sinatra::Base
+      get "/" do
+        @uploader = ImageUploader.new
+        @uploader.success_action_redirect = request.url
+        haml :index
+      end
+    end
+
+    # index.haml
+
+    %form{:action => @uploader.direct_fog_url, :method => "post", :enctype => "multipart/form-data"}
+      %input{:name => "utf8", :type => "hidden"}
+      %input{:type => "hidden", :name => "key", :value => @uploader.key}
+      %input{:type => "hidden", :name => "AWSAccessKeyId", :value => @uploader.aws_access_key_id}
+      %input{:type => "hidden", :name => "acl", :value => @uploader.acl}
+      %input{:type => "hidden", :name => "success_action_redirect", :value => @uploader.success_action_redirect}
+      %input{:type => "hidden", :name => "policy", :value => @uploader.policy}
+      %input{:type => "hidden", :name => "signature", :value => @uploader.signature}
+      %input{:name => "file", :type => "file"}
+      %input{:type => "submit", :value => "Upload to S3"}
+
+### Rails
+
+If you *are* using Rails and you've mounted your uploader like this:
+
+    class User < ActiveRecord::Base
+      mount_uploader :avatar, AvatarUploader
+    end
+
+things just got a whole lot easier. You can generate a direct upload form like this:
+
+    class AvatarController < ApplicationController
+      def new
+        @uploader = User.new.avatar
+        @uploader.success_action_redirect = new_user_url
+      end
+    end
+
+    <%= direct_upload_form_for @uploader do |f| %>
+      <%= f.file_field :avatar %>
+      <%= f.submit %>
+    <% end %>
+
+You can also pass html options like this:
+
+    <%= direct_upload_form_for @uploader, :html => { :target => "_blank_iframe" } do |f| %>
+      <%= f.file_field :avatar %>
+      <%= f.submit %>
+    <% end %>
+
+Note if `User` is not an ActiveRecord object e.g.
+
+    class User
+      mount_uploader :avatar, AvatarUploader
+    end
+
+you can still use the form helper by including the ActiveModel modules your uploader:
+
+    class AvatarUploader < CarrierWave::Uploader::Base
+      include CarrierWaveDirect::Uploader
+
+      include ActiveModel::Conversion
+      extend ActiveModel::Naming
+    end
+
+Note if you're using Rails 3.0.x you'll also need to disable forgery protection
+
+    # config/application.rb
+    config.action_controller.allow_forgery_protection = false
+
+Once you've uploaded your file directly to the cloud you'll probably need a way to reference it with an ORM and process it.
+
+## Processing and referencing files in a background process
+
+Processing and saving file uploads are typically long running tasks and should be done in a background process. CarrierWaveDirect gives you a few methods to help you do this with your favorite background processor such as [DelayedJob](https://github.com/collectiveidea/delayed_job) or [Resque](https://github.com/defunkt/resque).
+
+If your upload was successful then you will be redirected to the `success_action_redirect` url you specified in your uploader. S3 replies with a redirect like this: `http://example.com?bucket=your_fog_directory&key=uploads%2Fguid%2Ffile.ext&etag=%22d41d8cd98f00b204e9800998ecf8427%22`
+
+The `key` is the most important piece of information as we can use it for validating the file extension, downloading the file from S3, processing it and re-uploading it.
+
+If you're using ActiveRecord, CarrierWaveDirect will by default validate the file extension based off your `extension_white_list` in your uploader. See the [CarrierWave readme](https://github.com/jnicklas/carrierwave) for more info. You can then use the helper `filename_valid?` to check if the filename is valid. e.g.
+
+    class UsersController < ApplicationController
+      def new
+        @user = User.new(params)
+        unless @user.filename_valid?
+          flash[:error] = @user.errors.full_messages.to_sentence
+          redirect_to new_avatar_path
+        end
+      end
+    end
+
+CarrierWaveDirect automatically gives you an accessible `key` attribute in your mounted model when using ActiveRecord. You can use this to put a hidden field for the `key` into your model's form.
+
+    <%= form_for @user do |f| %>
+      <%= f.hidden_field :key %>
+      <%= f.label :email %>
+      <%= f.text_field :email %>
+      <%= f.submit %>
+    <% end %>
+
+then in your controller you can do something like this:
+
+    def create
+      @user = User.new(params[:user])
+      if @user.save_and_process_avatar
+        flash[:notice] = "User being created"
+        redirect_to :action => :index
+      else
+        render :new
+      end
+    end
+
+### Background processing
+
+Now that the basic building blocks are in place you can process and save your avatar in the background. This example uses [Resque](https://github.com/defunkt/resque) but the same logic could be applied to [DelayedJob](https://github.com/collectiveidea/delayed_job) or any other background processor.
+
+    class User < ActiveRecord::Base
+      def save_and_process_avatar(options = {})
+        if options[:now]
+          self.remote_avatar_url = avatar.direct_fog_url(:with_path => true)
+          save
+        else
+          Resque.enqueue(AvatarProcessor, attributes)
+        end
+      end
+    end
+
+    class AvatarProcessor
+      @queue = :avatar_processor_queue
+
+      def self.perform(attributes)
+        user = User.new(attributes)
+        user.save_and_process_avatar(:now => true)
+      end
+    end
+
+The method `self.remote_avatar_url=` from [CarrierWave](https://github.com/jnicklas/carrierwave) downloads the avatar from S3 and processes it. `save` then re-uploads the processed avatar to to S3
+
+## Uploading from a remote location
+
+Your users may find it convenient to upload a file from a location on the Internet via a URL. CarrierWaveDirect gives you another accessor to achieve this.
+
+    <%= form_for @user do |f| %>
+      <%= f.hidden_field :key %>
+      <% unless @user.has_avatar_upload? %>
+        <%= f.label :remote_avatar_net_url %>
+        <%= f.text_field :remote_avatar_net_url %>
+      <%= f.submit %>
+    <% end %>
+
+
+    class User < ActiveRecord::Base
+      def save_and_process_avatar(options = {})
+        if options[:now]
+          self.remote_avatar_url = has_remote_avatar_net_url? ? remote_avatar_net_url : avatar.direct_fog_url(:with_path => true)
+          save
+        else
+          Resque.enqueue(AvatarProcessor, attributes)
+        end
+      end
+    end
+
+The methods `has_avatar_upload?`, `remote_avatar_net_url` and `has_remote_avatar_net_url?` are automatically added to your mounted model
+
+## Validations
+
+Along with validating the extension of the filename, CarrierWaveDirect also gives you some other validations:
+
+      validates :avatar :is_uploaded => true
+
+Validates that your mounted model has an avatar uploaded from file or specified by remote url. It does not check that an your mounted model actually has a valid avatar after the download has taken place. Turned *off* by default
+
+      validates :avatar, :is_attached => true
+
+Validates that your mounted model has an avatar attached. This checks whether there is an actual avatar attached to the mounted model after downloading. Turned *off* by default
+
+      validates :avatar, :filename_uniqueness => true
+
+Validates that the filename in the database is unique. Turned *on* by default
+
+      validates :avatar :filename_format => true
+
+Validates that the uploaded filename is valid. As well as validating the extension against the `extension_white_list` it also validates that the `upload_dir` is correct. Turned *on* by default
+
+      validates :avatar :remote_net_url_format => true
+
+Validates that the remote net url is valid. As well as validating the extension against the `extension_white_list` it also validates that url is valid and has only the schemes specified in the `url_scheme_whitelist`. Turned *on* by default
+
+## Configuration
+
+As well as the built in validations CarrierWaveDirect provides, some validations, such as max file size and upload expiration can be performed on the S3 side.
+
+    CarrierWave.configure do |config|
+      config.validate_is_attached = true             # defaults to false
+      config.validate_is_uploaded = true             # defaults to false
+      config.validate_unique_filename = false        # defaults to true
+      config.validate_filename_format = false        # defaults to true
+      config.validate_remote_net_url_format = false  # defaults to true
+
+      config.max_file_size     = 10.megabytes        # defaults to 5.megabytes
+      config.upload_expiration = 1.hour              # defaults to 10.hours
+    end
+
+## Testing with CarrierWaveDirect
+
+CarrierWaveDirect provides a couple of helpers to help with integration and unit testing. You don't want to contact the Internet during your tests as this is slow, expensive and unreliable. You should first put fog into mock mode by doing something like this.
+
+    Fog.mock!
+
+    def fog_directory
+      ENV['AWS_FOG_DIRECTORY']
+    end
+
+    connection = ::Fog::Storage.new(
+      :aws_access_key_id      => ENV['AWS_ACCESS_KEY_ID'],
+      :aws_secret_access_key  => ENV['AWS_SECRET_ACCESS_KEY'],
+      :provider               => 'AWS'
+    )
+
+    connection.directories.create(:key => fog_directory)
+
+### Using Capybara
+
+If your using Capybara with Cucumber or RSpec, CarrierWaveDirect gives you a few useful helpers. To get the Capybara helpers, include the module into your test file or helper
+
+    describe AvatarUploadSpec
+      include CarrierWaveDirect::Test::CapybaraHelpers
+    end
+
+To attach a file to the direct upload form you can use
+
+    attach_file_for_direct_upload('path/to/file.ext')
+
+To simulate a successful upload and redirect to S3 you can use
+
+    upload_directly(AvatarUploader, "Upload to S3")
+
+This will click the Upload to S3 button on the form and redirect you to the `success_action_redirect` url (in the form) with a sample response from S3
+
+To simulate an unsuccessful upload you can pass `:success => false` and you'll remain on the upload page e.g.
+
+    upload_directly(AvatarUploader, "Upload to S3", :success => false)
+
+You can also use `find_key` and `find_upload_path` to get the key and upload path from the form
+
+### Unit tests
+
+If your mounted model validates a file is uploaded you might want to make use of the `sample_key` method
+
+    include CarrierWaveDirect::Test::Helpers
+
+    Factory.define :user |f|
+      f.email "some1@example.com"
+      f.key { sample_key(AvatarUploader.new) }
+    end
+
+This will return a valid key based off your `upload_dir` and your `extension_white_list`
+
+### Faking a background download
+
+If you wanted to fake a download in the background you could do something like this
+
+      uploader = AvatarUploader.new
+
+      upload_path = find_upload_path
+      redirect_key = sample_key(:base => find_key, :filename => File.basename(upload_path))
+
+      uploader.key = redirect_key
+      download_url = uploader.direct_fog_url(:with_path => true)
+
+      # Register the download url and return the uploaded file in the body
+      FakeWeb.register_uri(:get, download_url, :body => File.open(upload_path))
+
+## i18n
+
+The Active Record validations use the Rails i18n framework. Add these keys to your translations file:
+
+    en:
+      errors:
+        messages:
+          carrierwave_direct_filename_taken: filename was already taken
+          carrierwave_direct_upload_missing: upload is missing
+          carrierwave_direct_attachment_missing: attachment is missing
+          carrierwave_direct_filename_invalid: is invalid. Allowed file types are %{extension_white_list}
+          carrierwave_direct_remote_net_url_invalid: is invalid. Allowed file types are %{extension_white_list}. Allowed url schemes are %{url_scheme_white_list}
+
+## Caveats
+
+Don't name your string column `file`. It will result in a stack level too deep exception. See [this issue](https://github.com/dwilkie/carrierwave_direct/issues/10) for more info
+
+## Contributing to CarrierWaveDirect
+
+Pull requests are very welcome. Before submitting a pull request, please make sure that your changes are well tested.
+
+    gem install bundler
+    bundle install
+
+You should now be able to run the tests
+
+    bundle exec rake
+
+## Contributors
+
+* [cblunt (Chris Blunt)](https://github.com/cblunt) - Support for passing html options
+* [robyurkowski (Rob Yurkowski)](https://github.com/robyurkowski) - Fix deprecation warnings for Rails 3.2
+* [tylr (Tyler Love)](https://github.com/tylr) - Bug fix
+* [vlado (Vlado Cingel)](https://github.com/vlado) - Properly sanitize filename
+* [travisp (Travis Pew)](https://github.com/travisp) - Compatibility for CarrierWave 0.6.0
+* [jgorset (Johannes Gorset)](https://github.com/jgorset) - Added note about removing 'store_dir' in README

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+end
+
+task :default => [:spec]
+

data/carrierwave_direct_mongoid.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "carrierwave_direct/mongoid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "carrierwave_direct_mongoid"
+  s.version     = CarrierwaveDirect::Mongoid::VERSION
+  s.authors     = ["David Wilkie"]
+  s.email       = ["dwilkie@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Upload direct to S3 using CarrierWave}
+  s.description = %q{Process your uploads in the background by uploading directly to S3}
+
+  # s.rubyforge_project = "carrierwave_direct_mongoid"
+
+  s.add_dependency "carrierwave-mongoid"
+  s.add_dependency "carrierwave_direct"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "timecop"
+  s.add_development_dependency "rails"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "capybara"
+  s.add_development_dependency "bson_ext"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end
+

data/lib/carrierwave_direct/mongoid/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+module CarrierwaveDirect
+  module Mongoid
+    VERSION = "0.0.6"
+  end
+end
+

data/lib/carrierwave_direct/mongoid.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'mongoid'
+require 'carrierwave/mongoid'
+require 'carrierwave_direct'
+require 'carrierwave_direct/mount'
+require 'carrierwave_direct/validations/active_model'
+
+module CarrierWaveDirect
+  module Mongoid
+    include CarrierWaveDirect::Mount
+
+    def mount_uploader(column, uploader=nil, options={}, &block)
+      super
+
+      uploader.instance_eval <<-RUBY, __FILE__, __LINE__+1
+        include ActiveModel::Conversion
+        extend ActiveModel::Naming
+      RUBY
+
+      include CarrierWaveDirect::Validations::ActiveModel
+
+      validates_is_attached column if uploader_option(column.to_sym, :validate_is_attached)
+      validates_is_uploaded column if uploader_option(column.to_sym, :validate_is_uploaded)
+      validates_filename_uniqueness_of column if uploader_option(column.to_sym, :validate_unique_filename)
+      validates_filename_format_of column if uploader_option(column.to_sym, :validate_filename_format)
+      validates_remote_net_url_format_of column if uploader_option(column.to_sym, :validate_remote_net_url_format)
+
+      self.instance_eval <<-RUBY, __FILE__, __LINE__+1
+        attr_accessor   :skip_is_attached_validations
+        attr_accessible :key, :remote_#{column}_net_url
+      RUBY
+
+      mod = Module.new
+      include mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+        def filename_valid?
+          if has_#{column}_upload?
+            self.skip_is_attached_validations = true
+            valid?
+            self.skip_is_attached_validations = false
+            column_errors = errors[:#{column}]
+            errors.clear
+            column_errors.each do |column_error|
+              errors.add(:#{column}, column_error)
+            end
+            errors.empty?
+          else
+            true
+          end
+        end
+      RUBY
+    end
+  end
+end
+
+Mongoid::Document::ClassMethods.send :include, CarrierWaveDirect::Mongoid

data/lib/carrierwave_direct_mongoid.rb

@@ -0,0 +1 @@
+require 'carrierwave_direct/mongoid'

data/spec/mongoid_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'carrierwave_direct/mongoid'
+
+describe CarrierWaveDirect::Mongoid do
+  class MyDocument
+    include Mongoid::Document
+    mount_uploader :video, DirectUploader
+  end
+
+  subject { MyDocument.new }
+
+  describe "#key" do
+    it "should be accessible" do
+      MyDocument.new(:key => "some key").key.should == "some key"
+    end
+  end
+
+  describe "Uploader#model_name" do
+    it "should work" do
+      MyDocument.new.video.model_name.should == "DirectUploader"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'carrierwave_direct'
+require 'json'
+require 'timecop'
+
+require File.dirname(__FILE__) << '/support/view_helpers' # Catch dependency order
+
+Dir[ File.dirname(__FILE__) << "/support/**/*.rb"].each {|file| require file }
+

data/spec/support/carrier_wave_config.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+CarrierWave.configure do |config|
+  config.fog_credentials = {
+    :provider               => 'AWS',
+    :aws_access_key_id      => 'AWS_ACCESS_KEY_ID',
+    :aws_secret_access_key  => 'AWS_SECRET_ACCESS_KEY'
+  }
+  config.fog_directory = 'AWS_FOG_DIRECTORY' # bucket name
+end
+

data/spec/support/direct_uploader.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) << "/carrier_wave_config"
+
+class DirectUploader < CarrierWave::Uploader::Base
+  include CarrierWaveDirect::Uploader
+end
+

data/spec/support/form_builder_helpers.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'action_view'
+require 'action_view/template'
+
+require File.join(File.dirname(__FILE__), 'view_helpers') 
+
+require 'carrierwave_direct/form_builder'
+require 'carrierwave_direct/action_view_extensions/form_helper'
+
+module FormBuilderHelpers
+  include ActionView::Helpers::FormHelper
+  include CarrierWaveDirect::ActionViewExtensions::FormHelper
+  include ActionView::Context
+  include ActionController::RecordIdentifier
+
+  include ::ViewHelpers
+
+  def direct_uploader
+    defined?(super) ? super : @direct_uploader ||= MountedClass.new.video
+  end
+
+  def self.included(base)
+    DirectUploader.send(:include, ActiveModel::Conversion)
+    DirectUploader.extend ActiveModel::Naming
+  end
+
+  def protect_against_forgery?
+    false
+  end
+
+  def form(options = {}, &block)
+    blk = block_given? ? block : Proc.new {|f|}
+    direct_upload_form_for(direct_uploader, options, &blk)
+  end
+end
+

data/spec/support/global_helpers.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+GUID_REGEXP = "[a-f\\d\\-]+"
+
+def sample(data)
+  SAMPLE_DATA[data]
+end
+

data/spec/support/model_helpers.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module ModelHelpers
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def it_should_be_accessible(name, sample_data, options = {})
+      describe "when initialized with .new(:#{name} => '#{sample_data}')" do
+
+        let(:accessor_value) do
+          subject.class.send(:new, { name => sample_data }).send(name)
+        end
+
+        if options[:accessible]
+          if options[:accessible] == true
+            it "should == '#{sample_data}'" do
+              accessor_value.should == sample_data
+            end
+          else
+            it "##{options[:accessible].keys.first} should be #{options[:accessible].values.first}" do
+              subject.send(options[:accessible].keys.first).should == options[:accessible].values.first
+            end
+          end
+        else
+          it "should be nil" do
+            accessor_value.should be_nil
+          end
+        end
+      end
+    end
+
+    def it_should_delegate(name, options = {})
+      sample_data = "sample_#{name.to_s}"
+      delegation_object, delegation_method = options[:to].split("#")
+
+      describe "##{name} = '#{sample_data}'" do
+        it "should set the #{delegation_object}'s #{delegation_method}" do
+          subject.send("#{name}=", sample_data)
+          subject.send(delegation_object).send(delegation_method).should == sample_data
+        end
+      end
+
+      describe "##{name}" do
+        it "should return the #{delegation_method} from the #{delegation_object}" do
+          subject.send(delegation_object).send("#{delegation_method}=", sample_data)
+          subject.send(name).should == sample_data
+        end
+
+        it_should_be_accessible(name, sample_data, options)
+      end
+    end
+
+    def it_should_have_accessor(name, options = {})
+      if name.is_a?(Hash)
+        key = name.keys.first
+        sample_data = name[key]
+        name = key
+      else
+        sample_data = "sample_#{name.to_s}"
+      end
+
+      it "should respond to ##{name}=" do
+        subject.should respond_to("#{name}=")
+      end
+
+      describe "##{name}" do
+        context "where the #{name} is set to '#{sample_data}'" do
+          before { subject.send("#{name}=", sample_data) }
+
+          it "should == '#{sample_data}'" do
+            subject.send(name).should == sample_data
+          end
+        end
+
+        it_should_be_accessible(name, sample_data, options) if options[:accessible].present?
+      end
+    end
+  end
+end
+

data/spec/support/mounted_class.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) << "/direct_uploader"
+
+class MountedClass
+  extend CarrierWave::Mount
+  extend CarrierWaveDirect::Mount
+  mount_uploader :video, DirectUploader
+end
+

data/spec/support/uploader_helpers.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) << "/mounted_class"
+
+module UploaderHelpers
+  include CarrierWaveDirect::Test::Helpers
+
+  def sample_key(options = {})
+    super(MountedClass.new.video, options)
+  end
+end
+

data/spec/support/view_helpers.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'capybara/rspec'
+
+module ViewHelpers
+  include Capybara::RSpecMatchers
+
+  def parent_selector
+    defined?(super) ? super : @parent_selector ||= []
+  end
+
+  def have_parent_selector(options = {})
+    have_selector(:xpath, parent_selector_xpath, options)
+  end
+
+  def parent_selector_xpath
+    xpath = parent_selector.join("/")
+    xpath = ".//#{xpath}" unless xpath[0..2] == ".//"
+    xpath
+  end
+
+  def submit_to(options = {})
+    xpath_attributes = to_xpath_attributes(options)
+    parent_selector << "form[#{xpath_attributes}]"
+    have_parent_selector
+  end
+
+  def to_xpath_attributes(options = {})
+    attributes = []
+
+    options.each do |key, value|
+      attributes << ((value == false) ? "not(@#{key})" : "@#{key}='#{value}'")
+    end
+
+    attributes.join(" and ")
+  end
+
+  def have_input(resource_name, input, options = {})
+    options[:type] ||= input
+    options[:id] ||= "#{resource_name}_#{input}"
+    options[:name] ||= "#{resource_name}[#{input}]"
+    options[:required] ||= "required" unless options[:required] == false
+    parent_selector << "input[#{to_xpath_attributes(options)}]"
+    have_parent_selector
+  end
+end
+

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: carrierwave_direct_mongoid
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+  prerelease: 
+platform: ruby
+authors:
+- David Wilkie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: carrierwave-mongoid
+  requirement: &70245758983840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245758983840
+- !ruby/object:Gem::Dependency
+  name: carrierwave_direct
+  requirement: &70245758983000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70245758983000
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70245758982120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245758982120
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70245758981360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245758981360
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70245759033540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245759033540
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70245759032700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245759032700
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: &70245759032200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245759032200
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70245759031620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70245759031620
+description: Process your uploads in the background by uploading directly to S3
+email:
+- dwilkie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- carrierwave_direct_mongoid.gemspec
+- lib/carrierwave_direct/mongoid.rb
+- lib/carrierwave_direct/mongoid/version.rb
+- lib/carrierwave_direct_mongoid.rb
+- spec/mongoid_spec.rb
+- spec/spec_helper.rb
+- spec/support/carrier_wave_config.rb
+- spec/support/direct_uploader.rb
+- spec/support/form_builder_helpers.rb
+- spec/support/global_helpers.rb
+- spec/support/model_helpers.rb
+- spec/support/mounted_class.rb
+- spec/support/uploader_helpers.rb
+- spec/support/view_helpers.rb
+homepage: ''
+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.15
+signing_key: 
+specification_version: 3
+summary: Upload direct to S3 using CarrierWave
+test_files:
+- spec/mongoid_spec.rb
+- spec/spec_helper.rb
+- spec/support/carrier_wave_config.rb
+- spec/support/direct_uploader.rb
+- spec/support/form_builder_helpers.rb
+- spec/support/global_helpers.rb
+- spec/support/model_helpers.rb
+- spec/support/mounted_class.rb
+- spec/support/uploader_helpers.rb
+- spec/support/view_helpers.rb