carrierwave_direct 0.0.1

data/lib/carrierwave_direct/action_view_extensions/form_helper.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module CarrierWaveDirect
+
+  module ActionViewExtensions
+    # This module creates direct upload forms to post to cloud services
+    #
+    # Example:
+    #
+    #   direct_upload_form_for @video_uploader do |f|
+    #     f.file_field :video
+    #     f.submit
+    #   end
+    #
+    module FormHelper
+
+      def direct_upload_form_for(record, *args, &block)
+        options = args.extract_options!
+        form_for(
+          record,
+          *(args << options.merge(
+            :builder => CarrierWaveDirect::FormBuilder,
+            :url => record.direct_fog_url,
+            :html => {:multipart => true},
+            :authenticity_token => false,
+            :include_id => false
+          )),
+          &block
+        )
+      end
+    end
+  end
+end
+
+ActionView::Base.send :include, CarrierWaveDirect::ActionViewExtensions::FormHelper
+

data/lib/carrierwave_direct/form_builder.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+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
+    end
+  end
+end
+

data/lib/carrierwave_direct/locale/en.rb

@@ -0,0 +1,20 @@
+{
+  :en => {
+    :errors => {
+      :messages => {
+        :carrierwave_direct_filename_invalid => lambda {|key, options|
+          message = "is invalid"
+          message << ". Allowed file types are #{options[:extension_white_list].to_sentence}" if options[:extension_white_list] && options[:extension_white_list].any?
+          message
+        },
+        :carrierwave_direct_remote_net_url_invalid => lambda {|key, options|
+          message = "is invalid"
+          message << ". Allowed file types are #{options[:extension_white_list].to_sentence}" if options[:extension_white_list] && options[:extension_white_list].any?
+          message << ". Allowed url schemes are #{options[:url_scheme_white_list].to_sentence}" if options[:url_scheme_white_list] && options[:url_scheme_white_list].any?
+          message
+        }
+      }
+    }
+  }
+}
+

data/lib/carrierwave_direct/locale/en.yml

@@ -0,0 +1,7 @@
+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
+

data/lib/carrierwave_direct/mount.rb

@@ -0,0 +1,38 @@
+module CarrierWaveDirect
+
+  module Mount
+    def mount_uploader(column, uploader=nil, options={}, &block)
+      super
+
+      uploader.class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{column}; self; end
+      RUBY
+
+      self.instance_eval <<-RUBY, __FILE__, __LINE__+1
+        attr_accessor :remote_#{column}_net_url
+      RUBY
+
+      mod = Module.new
+      include mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+
+        def key
+          send(:#{column}).key
+        end
+
+        def key=(k)
+          send(:#{column}).key = k
+        end
+
+        def has_#{column}_upload?
+          send(:#{column}).has_key?
+        end
+
+        def has_remote_#{column}_net_url?
+          send(:remote_#{column}_net_url).present?
+        end
+      RUBY
+    end
+  end
+end
+

data/lib/carrierwave_direct/orm/activerecord.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'active_record'
+require 'carrierwave_direct/validations/active_model'
+
+module CarrierWaveDirect
+  module ActiveRecord
+    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
+
+ActiveRecord::Base.extend CarrierWaveDirect::ActiveRecord
+

data/lib/carrierwave_direct/test/capybara_helpers.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+module CarrierWaveDirect
+  module Test
+    module CapybaraHelpers
+
+      include CarrierWaveDirect::Test::Helpers
+
+      def attach_file_for_direct_upload(path)
+        attach_file("file", path)
+      end
+
+      def find_key
+        key = page.find("input[@name='key']").value
+      end
+
+      def find_upload_path
+        page.find("input[@name='file']").value
+      end
+
+      def upload_directly(uploader, button_locator, options = {})
+        options[:success] = true unless options[:success] == false
+        options[:success] &&= !options[:fail]
+
+        if options[:success]
+          # simulate a successful upload
+
+          # form's success action redirect url
+          redirect_url = URI.parse(page.find("input[@name='success_action_redirect']").value)
+
+          unless options[:redirect_key]
+            sample_key_args = [{:base => find_key, :filename => File.basename(find_upload_path)}]
+            sample_key_args.unshift(uploader) if method(:sample_key).arity == -2
+            options[:redirect_key] = sample_key(*sample_key_args)
+          end
+
+          redirect_url.query = Rack::Utils.build_nested_query({
+            :bucket => uploader.fog_directory,
+            :key => options[:redirect_key],
+            :etag => "\"d41d8cd98f00b204e9800998ecf8427\""
+          })
+
+          # click the button
+          click_button button_locator
+
+          # simulate success redirect
+          visit redirect_url.to_s
+        else
+          # simulate an unsuccessful upload
+
+          # click the button
+          click_button button_locator
+        end
+      end
+    end
+  end
+end
+

data/lib/carrierwave_direct/test/helpers.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module CarrierWaveDirect
+  module Test
+    module Helpers
+      # Example usage:
+
+      # sample_key(ImageUploader, :base => "store_dir/guid/${filename}")
+      # => "store_dir/guid/filename.extension"
+
+      def sample_key(uploader, options = {})
+        options[:valid] = true unless options[:valid] == false
+        options[:valid] &&= !options[:invalid]
+        options[:base] ||= uploader.key
+        if options[:filename]
+          filename_parts = options[:filename].split(".")
+          options[:extension] = filename_parts.pop if filename_parts.size > 1
+          options[:filename] = filename_parts.join(".")
+        end
+        options[:filename] ||= "filename"
+        valid_extension = uploader.extension_white_list.first if uploader.extension_white_list
+        options[:extension] = options[:extension] ? options[:extension].gsub(".", "") : (valid_extension || "extension")
+        key = options[:base].split("/")
+        key.pop
+        key.pop unless options[:valid]
+        key << "#{options[:filename]}.#{options[:extension]}"
+        key.join("/")
+      end
+    end
+  end
+end
+

data/lib/carrierwave_direct/uploader.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+module CarrierWaveDirect
+  module Uploader
+
+    extend ActiveSupport::Concern
+
+    FILENAME_WILDCARD = "${filename}"
+
+    included do
+      storage :fog
+
+      attr_accessor :success_action_redirect
+
+      fog_credentials.keys.each do |key|
+        define_method(key) do
+          fog_credentials[key]
+        end
+      end
+    end
+
+    module InstanceMethods
+      def direct_fog_url(options = {})
+        fog_uri = CarrierWave::Storage::Fog::File.new(self, nil, nil).public_url
+        if options[:with_path]
+          uri = URI.parse(fog_uri)
+          path = "/#{key}"
+          uri.path = path
+          fog_uri = uri.to_s
+        end
+        fog_uri
+      end
+
+      def guid
+        UUID.generate
+      end
+
+      def key=(k)
+        @key = k
+        update_version_keys(:with => @key)
+      end
+
+      def key
+        @key ||= "#{store_dir}/#{guid}/#{FILENAME_WILDCARD}"
+      end
+
+      def has_key?
+        @key.present? && !(@key =~ /#{Regexp.escape(FILENAME_WILDCARD)}\z/)
+      end
+
+      def acl
+        s3_access_policy.to_s.gsub('_', '-')
+      end
+
+      def policy(options = {})
+        options[:expiration] ||= self.class.upload_expiration
+        options[:max_file_size] ||= self.class.max_file_size
+
+        Base64.encode64(
+          {
+            'expiration' => Time.now + options[:expiration],
+            'conditions' => [
+              ["starts-with", "$utf8", ""],
+              ["starts-with", "$key", store_dir],
+              {"bucket" => fog_directory},
+              {"acl" => acl},
+              {"success_action_redirect" => success_action_redirect},
+              ["content-length-range", 1, options[:max_file_size]]
+            ]
+          }.to_json
+        ).gsub("\n","")
+      end
+
+      def signature
+        Base64.encode64(
+          OpenSSL::HMAC.digest(
+            OpenSSL::Digest::Digest.new('sha1'),
+            aws_secret_access_key, policy
+          )
+        ).gsub("\n","")
+      end
+
+      def persisted?
+        false
+      end
+
+      def filename
+        unless has_key?
+          # Use the attached models remote url to generate a new key otherwise return nil
+          remote_url = model.send("remote_#{mounted_as}_url")
+          remote_url ? key_from_file(remote_url.split("/").pop) : return
+        end
+
+        key_path = key.split("/")
+        filename_parts = []
+        filename_parts.unshift(key_path.pop)
+        unique_key = key_path.pop
+        filename_parts.unshift(unique_key) if unique_key
+        filename_parts.join("/")
+      end
+
+      def key_regexp
+        /\A#{store_dir}\/[a-f\d\-]+\/.+\.#{extension_regexp}\z/
+      end
+
+      def extension_regexp
+        allowed_file_types = extension_white_list
+        extension_regexp = allowed_file_types.present? && allowed_file_types.any? ?  "(#{allowed_file_types.join("|")})" : "\\w+"
+      end
+
+      def url_scheme_white_list
+        nil
+      end
+
+      private
+
+      def key_from_file(fname)
+        new_key_parts = key.split("/")
+        new_key_parts.pop
+        new_key_parts << fname
+        self.key = new_key_parts.join("/")
+      end
+
+      # Update the versions to use this key
+      def update_version_keys(options)
+        versions.each do |name, uploader|
+          uploader.key = options[:with]
+        end
+      end
+    end # InstanceMethods
+
+    private
+
+    # Put the version name at the end of the filename since the guid is also stored
+    # e.g. guid/filename_thumb.jpg instead of CarrierWave's default: thumb_guid/filename.jpg
+    def full_filename(for_file)
+      extname = File.extname(for_file)
+      [for_file.chomp(extname), version_name].compact.join('_') << extname
+    end
+  end
+end
+

data/lib/carrierwave_direct/uploader/configuration.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module CarrierWaveDirect
+
+  module Uploader
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        add_config :validate_is_attached
+        add_config :validate_is_uploaded
+        add_config :validate_unique_filename
+        add_config :validate_filename_format
+        add_config :validate_remote_net_url_format
+
+        add_config :max_file_size
+        add_config :upload_expiration
+        reset_direct_config
+      end
+
+      module ClassMethods
+        def reset_direct_config
+          configure do |config|
+            config.validate_is_attached = false
+            config.validate_is_uploaded = false
+            config.validate_unique_filename = true
+            config.validate_filename_format = true
+            config.validate_remote_net_url_format = true
+
+            config.max_file_size = 5242880
+            config.upload_expiration = 36000
+          end
+        end
+      end
+    end
+  end
+end
+