carrierwave_direct 0.0.12 → 0.0.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ba4e8171bac7dffd59212cdb0d05567072cae76
+  data.tar.gz: 0a1e05710c23fa992faf63773afc079187389e8b
+SHA512:
+  metadata.gz: 8263b034630c1cbc1cdf8a92a276973dc70b879273cee525246813822702c045b7aab00a933279ccfbf7828010639f227fbab3d9cf12d26137f3c95e4a2bc43a
+  data.tar.gz: 43e72d866f555d57db0dc258116a9b23ac5358f4c7d80e7dd19e9527f8e1050c04cffb89e07436ca2b8f024ed5f63a4a7571bed707fb235fb7e46ea8410d5ae3

data/.gitignore

@@ -2,6 +2,7 @@
 .bundle
 Gemfile.lock
 .rvmrc
+.ruby-version
 pkg/*
 vendor/ruby
 .ruby-version

data/README.md

@@ -6,6 +6,33 @@
 
 [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.
 
+## Project Maintainer(s) Wanted
+
+Meh. [I just want to use it already.](https://github.com/dwilkie/carrierwave_direct#example-application)
+
+### Why can't you do it?
+
+I'm no longer involved in building apps which require file uploads. Therefore I no longer feel that I can do a good job maintaining this project. I just want the community to take it where it needs to go.
+
+### What's in it for me?
+
+* Everything
+* Job Applications
+* Not much
+* What you make of it
+
+### What do I need to do?
+
+You can help by simply accepting pull requests and bumping versions. Or if you want to be more involved you could help resolve outstanding issues or develop new features.
+
+### Who are you looking for?
+
+Anybody who has previously contributed to CarrierWaveDirect (with tests) and/or who anybody who really wants to.
+
+### How can I apply?
+
+This is not a job application. I you want to maintain it, you've basically got the job. Just comment on this issue: https://github.com/dwilkie/carrierwave_direct/issues/83 and link to a contribution you've made on this gem, or some other gem.
+
 ## Example Application
 
 For a concrete example on how to use [CarrierWaveDirect](https://github.com/dwilkie/carrierwave_direct) in a Rails application check out the [Example Application](https://github.com/dwilkie/carrierwave_direct_example).
@@ -24,7 +51,9 @@ Install the latest release:
 
 In Rails, add it to your Gemfile:
 
-    gem 'carrierwave_direct'
+```ruby
+gem 'carrierwave_direct'
+```
 
 Note that CarrierWaveDirect is not compatible with Rails 2.
 
@@ -34,17 +63,19 @@ Please read the [CarrierWave readme](https://github.com/jnicklas/carrierwave) fi
 
 CarrierWaveDirect works with [fog](https://github.com/fog/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_your_aws_bucket' # required
-      # see https://github.com/jnicklas/carrierwave#using-amazon-s3
-      # for more optional configuration
-    end
+```ruby
+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_your_aws_bucket' # required
+  # see https://github.com/jnicklas/carrierwave#using-amazon-s3
+  # for more optional configuration
+end
+```
 
 If you haven't already done so generate an uploader
 
@@ -56,15 +87,19 @@ this should give you a file in:
 
 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
+```ruby
+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
+```ruby
+class AvatarUploader < CarrierWave::Uploader::Base
+  include CarrierWaveDirect::Uploader
+end
+```
 
 This adds the extra functionality for direct uploading.
 
@@ -73,100 +108,118 @@ This adds the extra functionality for direct uploading.
     /uploads/<unique_guid>/foo.png
 
 
-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.
+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"}
+```ruby
+# 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
+```
+```haml
+# 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
+```ruby
+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 %>
+```ruby
+class AvatarController < ApplicationController
+  def new
+    @uploader = User.new.avatar
+    @uploader.success_action_redirect = new_user_url
+  end
+end
+```
+```erb
+<%= direct_upload_form_for @uploader do |f| %>
+  <%= f.file_field :avatar %>
+  <%= f.submit %>
+<% end %>
+```
 
 After uploading to S3, You'll need to update the uploader object with the returned key in the controller action that corresponds to `new_user_url`:
 
-    @uploader.update_attribute :key, params[:key]
+```ruby
+@uploader.update_attribute :key, params[:key]
+```
 
 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 %>
+```erb
+<%= 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
+```ruby
+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
+```ruby
+class AvatarUploader < CarrierWave::Uploader::Base
+  include CarrierWaveDirect::Uploader
 
-      include ActiveModel::Conversion
-      extend ActiveModel::Naming
-    end
+  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
+```ruby
+# 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.
 
@@ -176,34 +229,40 @@ The default amazon content-type is "binary/octet-stream" and for many cases this
 
 First, tell CarrierWaveDirect that you will include your content type manually by adding to your initializer:
 
-    CarrierWave.configure do |config|
-      # ... fog configuration and other options ...
-      config.will_include_content_type = true
-    end
+```ruby
+CarrierWave.configure do |config|
+  # ... fog configuration and other options ...
+  config.will_include_content_type = true
+end
+```
 
 Then, just add a content-type element to the form.
 
-    <%= direct_upload_form_for @uploader do |f| %>
-      <%= text_field_tag 'Content-Type', 'video/mpeg' %><br>
-      <%= f.file_field :avatar %>
-      <%= f.submit %>
-    <% end %>
+```erb
+<%= direct_upload_form_for @uploader do |f| %>
+  <%= text_field_tag 'Content-Type', 'video/mpeg' %><br>
+  <%= f.file_field :avatar %>
+  <%= f.submit %>
+<% end %>
+```
 
 You could use a select as well.
 
-    <%= direct_upload_form_for @uploader do |f| %>
-      <%= select_tag 'Content-Type', options_for_select([
-        ['Video','video/mpeg'],
-        ['Audio','audio/mpeg'],
-        ['Image','image/jpeg']
-      ], 'video/mpeg') %><br>
-      <%= f.file_field :avatar %>
-      <%= f.submit %>
-    <% end %>
+```erb
+<%= direct_upload_form_for @uploader do |f| %>
+  <%= select_tag 'Content-Type', options_for_select([
+    ['Video','video/mpeg'],
+    ['Audio','audio/mpeg'],
+    ['Image','image/jpeg']
+  ], 'video/mpeg') %><br>
+  <%= f.file_field :avatar %>
+  <%= f.submit %>
+<% end %>
+```
 
 ## 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).
+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/resque/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`
 
@@ -211,60 +270,67 @@ The `key` is the most important piece of information as we can use it for valida
 
 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
+```ruby
+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 %>
-
+```erb
+<%= 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
+```ruby
+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
+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/resque/resque) but the same logic could be applied to [DelayedJob](https://github.com/collectiveidea/delayed_job) or any other background processor.
+
+```ruby
+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
+class AvatarProcessor
+  @queue = :avatar_processor_queue
 
-      def self.perform(attributes)
-        user = User.new(attributes)
-        user.save_and_process_avatar(:now => true)
-      end
-    end
+  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
 
@@ -272,49 +338,60 @@ The method `self.remote_avatar_url=` from [CarrierWave](https://github.com/jnick
 
 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
+```erb
+<%= 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 %>
+```
+```ruby
+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
+```ruby
+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
+```ruby
+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
+```ruby
+validates :avatar, :filename_uniqueness => true
+```
 
 Validates that the filename in the database is unique. Turned *on* by default
 
-      validates :avatar, :filename_format => true
+```ruby
+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
+```ruby
+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
 
@@ -322,60 +399,71 @@ Validates that the remote net url is valid. As well as validating the extension
 
 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.min_file_size     = 5.kilobytes         # defaults to 1.byte
-      config.max_file_size     = 10.megabytes        # defaults to 5.megabytes
-      config.upload_expiration = 1.hour              # defaults to 10.hours
-      config.will_include_content_type = true        # defaults to false; if true, content-type will be set
-                                                     # on s3, but you must include an input field named
-                                                     # Content-Type on every direct upload form
-    end
-
+```ruby
+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.min_file_size     = 5.kilobytes         # defaults to 1.byte
+  config.max_file_size     = 10.megabytes        # defaults to 5.megabytes
+  config.upload_expiration = 1.hour              # defaults to 10.hours
+  config.will_include_content_type = true        # defaults to false; if true, content-type will be set
+                                                 # on s3, but you must include an input field named
+                                                 # Content-Type on every direct upload form
+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!
+```ruby
+Fog.mock!
 
-    def fog_directory
-      ENV['AWS_FOG_DIRECTORY']
-    end
+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 = ::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)
+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
+If you're 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
+```ruby
+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')
+```ruby
+attach_file_for_direct_upload('path/to/file.ext')
+```
 
 To simulate a successful upload and redirect to S3 you can use
 
-    upload_directly(AvatarUploader.new, "Upload to S3")
+```ruby
+upload_directly(AvatarUploader.new, "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.new, "Upload to S3", :success => false)
+```ruby
+upload_directly(AvatarUploader.new, "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
 
@@ -383,12 +471,14 @@ You can also use `find_key` and `find_upload_path` to get the key and upload pat
 
 If your mounted model validates a file is uploaded you might want to make use of the `sample_key` method
 
-    include CarrierWaveDirect::Test::Helpers
+```ruby
+include CarrierWaveDirect::Test::Helpers
 
-    Factory.define :user |f|
-      f.email "some1@example.com"
-      f.key { sample_key(AvatarUploader.new) }
-    end
+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`
 
@@ -396,30 +486,34 @@ This will return a valid key based off your `upload_dir` and your `extension_whi
 
 If you wanted to fake a download in the background you could do something like this
 
-      uploader = AvatarUploader.new
+```ruby
+uploader = AvatarUploader.new
 
-      upload_path = find_upload_path
-      redirect_key = sample_key(:base => find_key, :filename => File.basename(upload_path))
+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)
+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))
+# 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. "
-          carrierwave_direct_allowed_extensions: Allowed file types are %{extensions}
-          carrierwave_direct_allowed_schemes: Allowed schemes are %{schemes}
+```yml
+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. "
+      carrierwave_direct_allowed_extensions: Allowed file types are %{extensions}
+      carrierwave_direct_allowed_schemes: Allowed schemes are %{schemes}
+```
 
 ## Caveats
 
@@ -442,6 +536,10 @@ You should now be able to run the tests
 
 After you have fixed a bug or added a feature please also use the [CarrierWaveDirect Sample Application](https://github.com/dwilkie/carrierwave_direct_example) to ensure that the gem still works correctly.
 
+## Credits
+
+Thank you to everybody who has contributed to [CarrierWaveDirect](https://github.com/dwilkie/carrierwave_direct). A special thanks to [colinyoung (Colin Young)](https://github.com/colinyoung) and [nddeluca (Nicholas DeLuca)](https://github.com/nddeluca) who help maintain the gem.
+
 ## Contributors
 
 * [cblunt (Chris Blunt)](https://github.com/cblunt) - Support for passing html options

data/lib/carrierwave_direct/form_builder.rb

@@ -4,13 +4,19 @@ module CarrierWaveDirect
   class FormBuilder < ActionView::Helpers::FormBuilder
     def file_field(method, options = {})
       options.merge!(:name => "file")
-      hidden_field(:key,                             :name => "key") <<
-      hidden_field(:aws_access_key_id,               :name => "AWSAccessKeyId") <<
-      hidden_field(:acl,                             :name => "acl") <<
-      hidden_field(:success_action_redirect,         :name => "success_action_redirect") <<
-      hidden_field(:policy,                          :name => "policy") <<
-      hidden_field(:signature,                       :name => "signature") <<
-      super
+      fields = hidden_field(:key, :name => "key")
+      fields << hidden_field(:aws_access_key_id, :name => "AWSAccessKeyId")
+      fields << hidden_field(:acl, :name => "acl")
+      fields << hidden_field(:policy, :name => "policy")
+      fields << hidden_field(:signature, :name => "signature")
+
+      if options[:use_action_status]
+        fields << hidden_field(:success_action_status, :name => "success_action_status")
+      else
+        fields << hidden_field(:success_action_redirect, :name => "success_action_redirect")
+      end
+
+      fields << super
     end
   end
 end

data/lib/carrierwave_direct/uploader.rb

@@ -11,6 +11,7 @@ module CarrierWaveDirect
       storage :fog
 
       attr_accessor :success_action_redirect
+      attr_accessor :success_action_status
 
       fog_credentials.keys.each do |key|
         define_method(key) do
@@ -41,8 +42,8 @@ module CarrierWaveDirect
 
     def key
       return @key if @key.present?
-      if url.present?
-        self.key = URI.parse(URI.encode(url)).path # explicitly set key
+      if present?
+        self.key = URI.parse(URI.encode(url)).path[1 .. -1] # explicitly set key
       else
         @key = "#{store_dir}/#{guid}/#{FILENAME_WILDCARD}"
       end
@@ -62,18 +63,26 @@ module CarrierWaveDirect
       options[:min_file_size] ||= self.class.min_file_size
       options[:max_file_size] ||= self.class.max_file_size
 
-      conditions = [ ["starts-with", "$utf8", ""], ["starts-with", "$key", store_dir] ]
+      conditions = [
+        ["starts-with", "$utf8", ""],
+        ["starts-with", "$key", key.sub(/#{Regexp.escape(FILENAME_WILDCARD)}\z/, "")]
+      ]
       conditions << ["starts-with", "$Content-Type", ""] if self.class.will_include_content_type
+      conditions << {"bucket" => fog_directory}
+      conditions << {"acl" => acl}
+
+      if self.class.use_action_status
+        conditions << {"success_action_status" => success_action_status}
+      else
+        conditions << {"success_action_redirect" => success_action_redirect}
+      end
+
+      conditions << ["content-length-range", options[:min_file_size], options[:max_file_size]]
 
       Base64.encode64(
         {
           'expiration' => Time.now.utc + options[:expiration],
-          'conditions' => conditions + [
-            {"bucket" => fog_directory},
-            {"acl" => acl},
-            {"success_action_redirect" => success_action_redirect},
-            ["content-length-range", options[:min_file_size], options[:max_file_size]]
-          ]
+          'conditions' => conditions
         }.to_json
       ).gsub("\n","")
     end

data/lib/carrierwave_direct/uploader/configuration.rb

@@ -17,6 +17,9 @@ module CarrierWaveDirect
         add_config :max_file_size
         add_config :upload_expiration
         add_config :will_include_content_type
+
+        add_config :use_action_status
+
         reset_direct_config
       end
 
@@ -32,6 +35,8 @@ module CarrierWaveDirect
             config.min_file_size = 1
             config.max_file_size = 5242880
             config.upload_expiration = 36000
+
+            config.use_action_status = false
           end
         end
       end

data/lib/carrierwave_direct/version.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
 module CarrierwaveDirect
-  VERSION = "0.0.12"
+  VERSION = "0.0.13"
 end
 

data/spec/form_builder_spec.rb

@@ -7,11 +7,15 @@ describe CarrierWaveDirect::FormBuilder do
 
   describe "#file_field" do
 
-    def form_with_file_field
+    def form_with_default_file_field
       form {|f| f.file_field :video }
     end
 
-    hidden_fields = [
+    def form_with_file_field_and_no_redirect
+      form {|f| f.file_field :video, use_action_status: true }
+    end
+
+    default_hidden_fields = [
                       :key,
                       {:aws_access_key_id => "AWSAccessKeyId"},
                       :acl,
@@ -19,11 +23,40 @@ describe CarrierWaveDirect::FormBuilder do
                       :policy,
                       :signature
                     ]
+    status_hidden_fields = [
+                      :key,
+                      {:aws_access_key_id => "AWSAccessKeyId"},
+                      :acl,
+                      :success_action_status,
+                      :policy,
+                      :signature
+                    ]
 
     # http://aws.amazon.com/articles/1434?_encoding=UTF8
     context "form" do
 
-      hidden_fields.each do |input|
+      default_hidden_fields.each do |input|
+        if input.is_a?(Hash)
+          key = input.keys.first
+          name = input[key]
+        else
+          key = name = input
+        end
+
+        it "should have a hidden field for '#{name}'" do
+          direct_uploader.stub(key).and_return(key.to_s)
+          form_with_default_file_field.should have_input(
+            :direct_uploader,
+            key,
+            :type => :hidden,
+            :name => name,
+            :value => key,
+            :required => false
+          )
+        end
+      end
+
+      status_hidden_fields.each do |input|
         if input.is_a?(Hash)
           key = input.keys.first
           name = input[key]
@@ -33,7 +66,7 @@ describe CarrierWaveDirect::FormBuilder do
 
         it "should have a hidden field for '#{name}'" do
           direct_uploader.stub(key).and_return(key.to_s)
-          form_with_file_field.should have_input(
+          form_with_file_field_and_no_redirect.should have_input(
             :direct_uploader,
             key,
             :type => :hidden,
@@ -45,7 +78,7 @@ describe CarrierWaveDirect::FormBuilder do
       end
 
       it "should have an input for a file to upload" do
-        form_with_file_field.should have_input(
+        form_with_default_file_field.should have_input(
           :direct_uploader,
           :video,
           :type => :file,

data/spec/support/form_builder_helpers.rb

@@ -2,6 +2,8 @@
 
 require 'action_view'
 require 'action_view/template'
+require 'action_controller'
+require 'active_model'
 
 require File.join(File.dirname(__FILE__), 'view_helpers')
 
@@ -12,7 +14,14 @@ module FormBuilderHelpers
   include ActionView::Helpers::FormHelper
   include CarrierWaveDirect::ActionViewExtensions::FormHelper
   include ActionView::Context
-  include ActionController::RecordIdentifier
+
+  # Try ActionView::RecrodIentifier for Rails 4
+  # else use ActionController::RecordIdentifier for Rails 3.2
+  begin
+    include ActionView::RecordIdentifier
+  rescue
+    include ActionController::RecordIdentifier
+  end
 
   include ::ViewHelpers
 

data/spec/uploader_spec.rb

@@ -68,6 +68,12 @@ describe CarrierWaveDirect::Uploader do
     end
   end
 
+  describe ".use_action_status" do
+    it "should be false" do
+      subject.class.use_action_status.should be_false
+    end
+  end
+
   DirectUploader.fog_credentials.keys.each do |key|
     describe "##{key}" do
       it "should return the #{key.to_s.capitalize}" do
@@ -81,6 +87,7 @@ describe CarrierWaveDirect::Uploader do
   end
 
   it_should_have_accessor(:success_action_redirect)
+  it_should_have_accessor(:success_action_status)
 
   describe "#key=" do
     before { subject.key = sample(:key) }
@@ -118,17 +125,26 @@ describe CarrierWaveDirect::Uploader do
         end
       end
 
+      context "and the uploaders url is #default_url" do
+        it "should return '*/\#\{guid\}/${filename}'" do
+          mounted_subject.stub(:url).and_return(sample(:s3_file_url))
+          mounted_subject.stub(:present?).and_return(false)
+          mounted_subject.key.should =~ /#{GUID_REGEXP}\/\$\{filename\}$/
+        end
+      end
+
       context "but the uploaders url is '#{sample(:s3_file_url)}'" do
         before do
           mounted_subject.stub(:url).and_return(sample(:s3_file_url))
+          mounted_subject.stub(:present?).and_return(true)
         end
 
-        it "should return '/#{sample(:s3_key)}'" do
-          mounted_subject.key.should == "/#{sample(:s3_key)}"
+        it "should return '#{sample(:s3_key)}'" do
+          mounted_subject.key.should == sample(:s3_key)
         end
 
         it "should set the key explicitly in order to update the version keys" do
-          mounted_subject.should_receive("key=").with("/#{sample(:s3_key)}")
+          mounted_subject.should_receive("key=").with(sample(:s3_key))
           mounted_subject.key
         end
       end
@@ -415,13 +431,18 @@ describe CarrierWaveDirect::Uploader do
 
         # S3 conditions
         it "'key'" do
-          mounted_subject.stub(:store_dir).and_return(sample(:s3_key))
-          mounted_subject.key
+          mounted_subject.stub(:key).and_return(sample(:s3_key))
           conditions(
             :subject => mounted_subject
           ).should have_condition(:key, sample(:s3_key))
         end
 
+        it "'key' without FILENAME_WILDCARD" do
+          conditions(
+            :subject => mounted_subject
+          ).should have_condition(:key, mounted_subject.key.sub("${filename}", ""))
+        end
+
         it "'bucket'" do
           conditions.should have_condition("bucket" => subject.fog_directory)
         end
@@ -434,11 +455,31 @@ describe CarrierWaveDirect::Uploader do
           subject.success_action_redirect = "http://example.com/some_url"
           conditions.should have_condition("success_action_redirect" => "http://example.com/some_url")
         end
-        
+
         it "'content-type' only if enabled" do
           conditions.should have_condition('Content-Type') if subject.class.will_include_content_type
         end
 
+        context 'when use_action_status is true' do
+          before(:all) do
+            DirectUploader.use_action_status = true
+          end
+
+          after(:all) do
+            DirectUploader.use_action_status = false
+          end
+
+          it "'success_action_status'" do
+            subject.success_action_status = '200'
+            conditions.should have_condition("success_action_status" => "200")
+          end
+
+          it "does not have 'success_action_redirect'" do
+            subject.success_action_redirect = "http://example.com/some_url"
+            conditions.should_not have_condition("success_action_redirect" => "http://example.com/some_url")
+          end
+        end
+
         context "'content-length-range of'" do
           def have_content_length_range(options = {})
             include([

metadata

@@ -1,142 +1,125 @@
 --- !ruby/object:Gem::Specification
 name: carrierwave_direct
 version: !ruby/object:Gem::Version
-  version: 0.0.12
-  prerelease: 
+  version: 0.0.13
 platform: ruby
 authors:
 - David Wilkie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2013-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carrierwave
   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'
 - !ruby/object:Gem::Dependency
   name: uuidtools
   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'
 - !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'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.2.12
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.2.12
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Process your uploads in the background by uploading directly to S3
@@ -184,27 +167,26 @@ files:
 - spec/uploader_spec.rb
 homepage: https://github.com/dwilkie/carrierwave_direct
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: carrierwave_direct
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Upload direct to S3 using CarrierWave
 test_files:
 - spec/action_view_extensions/form_helper_spec.rb