carrierwave_direct 0.0.1

data/lib/carrierwave_direct/validations/active_model.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+require 'active_model/validator'
+require 'active_support/concern'
+
+module CarrierWaveDirect
+
+  module Validations
+    module ActiveModel
+      extend ActiveSupport::Concern
+
+      class UniqueFilenameValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if record.new_record? && record.errors[attribute].empty? && (record.send("has_#{attribute}_upload?") || record.send("has_remote_#{attribute}_net_url?"))
+            if record.class.where(attribute => record.send(attribute).filename).exists?
+              record.errors.add(attribute, :carrierwave_direct_filename_taken)
+            end
+          end
+        end
+      end
+
+      class FilenameFormatValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if record.new_record? && record.send("has_#{attribute}_upload?") && record.key !~ record.send(attribute).key_regexp
+            record.errors.add(
+              attribute,
+              :carrierwave_direct_filename_invalid,
+              :extension_white_list => record.send(attribute).extension_white_list
+            )
+          end
+        end
+      end
+
+      class RemoteNetUrlFormatValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if record.new_record? && record.send("has_remote_#{attribute}_net_url?")
+            remote_net_url = record.send("remote_#{attribute}_net_url")
+            uploader = record.send(attribute)
+            url_scheme_white_list = uploader.url_scheme_white_list
+            if (remote_net_url !~ URI.regexp(url_scheme_white_list) || remote_net_url !~ /#{uploader.extension_regexp}\z/)
+              record.errors.add(
+                :"remote_#{attribute}_net_url",
+                :carrierwave_direct_remote_net_url_invalid,
+                :extension_white_list => uploader.extension_white_list,
+                :url_scheme_white_list => url_scheme_white_list
+              )
+            end
+          end
+        end
+      end
+
+      class IsUploadedValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if record.new_record?
+            unless (record.send("has_#{attribute}_upload?") || record.send("has_remote_#{attribute}_net_url?"))
+              record.errors.add(
+                attribute,
+                :carrierwave_direct_upload_missing
+              )
+              record.errors.add(
+                :"remote_#{attribute}_net_url",
+                :blank
+              )
+            end
+          end
+        end
+      end
+
+      class IsAttachedValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if value.blank? && !record.skip_is_attached_validations
+            record.errors.add(
+              attribute,
+              :carrierwave_direct_attachment_missing
+            )
+          end
+        end
+      end
+
+      module HelperMethods
+
+        ##
+        # Makes the record invalid if the filename already exists
+        #
+        # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+        #
+        # === Note
+        #
+        # Set this key in your translations file for I18n:
+        #
+        #     carrierwave_direct:
+        #       errors:
+        #         filename_taken: 'Here be an error message'
+        #
+        def validates_filename_uniqueness_of(*attr_names)
+          validates_with UniqueFilenameValidator, _merge_attributes(attr_names)
+        end
+
+        def validates_filename_format_of(*attr_names)
+          validates_with FilenameFormatValidator, _merge_attributes(attr_names)
+        end
+
+        def validates_remote_net_url_format_of(*attr_names)
+          validates_with RemoteNetUrlFormatValidator, _merge_attributes(attr_names)
+        end
+
+        def validates_is_uploaded(*attr_names)
+          validates_with IsUploadedValidator, _merge_attributes(attr_names)
+        end
+
+        def validates_is_attached(*attr_names)
+          validates_with IsAttachedValidator, _merge_attributes(attr_names)
+        end
+
+      end
+
+      included do
+        extend HelperMethods
+        include HelperMethods
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) << "/../locale/*.*"].each {|file| I18n.load_path << file }
+

data/lib/carrierwave_direct/version.rb

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

data/spec/action_view_extensions/form_helper_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe CarrierWaveDirect::ActionViewExtensions::FormHelper do
+  include FormBuilderHelpers
+
+  describe "#direct_upload_form_for" do
+    it "should yield an instance of CarrierWaveDirect::FormBuilder" do
+      direct_upload_form_for(direct_uploader) do |f|
+        f.should be_instance_of(CarrierWaveDirect::FormBuilder)
+      end
+    end
+
+    context "the form" do
+      before do
+        direct_uploader.stub(:direct_fog_url).and_return("http://example.com")
+      end
+
+      it "should post to the uploader's #direct_fog_url as a multipart form" do
+        form.should submit_to(
+          :action => "http://example.com", :method => "post", :enctype => "multipart/form-data"
+        )
+      end
+    end
+  end
+end
+

data/spec/form_builder_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe CarrierWaveDirect::FormBuilder do
+  include FormBuilderHelpers
+
+  describe "#file_field" do
+
+    def form_with_file_field
+      form {|f| f.file_field :video }
+    end
+
+    hidden_fields = [
+                      :key,
+                      {:aws_access_key_id => "AWSAccessKeyId"},
+                      :acl,
+                      :success_action_redirect,
+                      :policy,
+                      :signature
+                    ]
+
+    # http://aws.amazon.com/articles/1434?_encoding=UTF8
+    context "form" do
+
+      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_file_field.should have_input(
+            :direct_uploader,
+            key,
+            :type => :hidden,
+            :name => name,
+            :value => key,
+            :required => false
+          )
+        end
+      end
+
+      it "should have an input for a file to upload" do
+        form_with_file_field.should have_input(
+          :direct_uploader,
+          :video,
+          :type => :file,
+          :name => :file,
+          :required => false
+        )
+      end
+    end
+  end
+end
+

data/spec/mount_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe CarrierWaveDirect::Mount do
+  include ModelHelpers
+
+  class Gathering
+    extend CarrierWave::Mount
+    extend CarrierWaveDirect::Mount
+    mount_uploader :video, DirectUploader
+  end
+
+  context "class Gathering; extend CarrierWave::Mount; extend CarrierWaveDirect::Mount; mount_uploader :video, DirectUploader; end" do
+    let(:subject) { Gathering.new }
+
+    it_should_have_accessor(:remote_video_net_url)
+
+    describe "#has_video_upload?" do
+      context "video does not have a key" do
+        before { subject.video.stub(:has_key?).and_return(false) }
+
+        it "should return false" do
+          subject.should_not have_video_upload
+        end
+      end
+
+      context "video has a key" do
+        before { subject.video.stub(:has_key?).and_return(true) }
+
+        it "should return true" do
+          subject.should have_video_upload
+        end
+      end
+    end
+
+    describe "#has_remote_video_net_url?" do
+      context "remote_video_net_url is nil" do
+        before { subject.remote_video_net_url = nil }
+
+        it "should return false" do
+          subject.should_not have_remote_video_net_url
+        end
+      end
+
+      context "remote_video_net_url is not nil" do
+        before { subject.remote_video_net_url = "something" }
+
+        it "should return true" do
+          subject.should have_remote_video_net_url
+        end
+      end
+    end
+
+    it_should_delegate(:key, :to => "video#key", :accessible => {"has_video_upload?" => false})
+
+  end
+end
+

data/spec/orm/activerecord_spec.rb

@@ -0,0 +1,551 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'carrierwave/orm/activerecord'
+require 'carrierwave_direct/orm/activerecord'
+
+describe CarrierWaveDirect::ActiveRecord do
+  dbconfig = {
+    :adapter => 'sqlite3',
+    :database => ':memory:'
+  }
+
+  class TestMigration < ActiveRecord::Migration
+    def self.up
+      create_table :parties, :force => true do |t|
+        t.column :video, :string
+      end
+    end
+
+    def self.down
+      drop_table :parties
+    end
+  end
+
+  class Party < ActiveRecord::Base
+    mount_uploader :video, DirectUploader
+  end
+
+  ActiveRecord::Base.establish_connection(dbconfig)
+
+  # turn off migration output
+  ActiveRecord::Migration.verbose = false
+
+  before(:all) { TestMigration.up }
+  after(:all) { TestMigration.down }
+  after { Party.delete_all }
+
+  describe "class Party < ActiveRecord::Base; mount_uploader :video, DirectUploader; end" do
+    $arclass = 0
+    include UploaderHelpers
+    include ModelHelpers
+
+    let(:party_class) do
+      Class.new(Party)
+    end
+
+    let(:subject) do
+      party = party_class.new
+    end
+
+    def mount_uploader
+      party_class.mount_uploader :video, DirectUploader
+    end
+
+    before do
+      # see https://github.com/jnicklas/carrierwave/blob/master/spec/orm/activerecord_spec.rb
+      $arclass += 1
+      Object.const_set("Party#{$arclass}", party_class)
+      party_class.table_name = "parties"
+    end
+
+    shared_examples_for "an invalid filename" do
+      it "should not be valid on create" do
+        subject.should_not be_valid
+      end
+
+      it "should be valid on update" do
+        subject.save(:validate => false)
+        subject.should be_valid
+      end
+
+      it "should use i18n for the error messages" do
+        subject.valid?
+        subject.errors[:video].should == [
+          I18n.t("errors.messages.carrierwave_direct_filename_invalid", :extension_white_list => %w{avi mp4})
+        ]
+      end
+    end
+
+    shared_examples_for "a remote net url i18n error message" do
+      it "should use i18n for the error messages" do
+        subject.valid?
+        subject.errors[:remote_video_net_url].should == [I18n.t("errors.messages.carrierwave_direct_remote_net_url_invalid", i18n_options)]
+      end
+    end
+
+    shared_examples_for "without an upload" do
+      before do
+        subject.remote_video_net_url = remote_video_net_url
+        subject.key = upload_path
+      end
+
+      it "should not be valid on create" do
+        subject.should_not be_valid
+      end
+
+      it "should use i18n for the file upload error message" do
+        subject.valid?
+        subject.errors[:video].should == [I18n.t("errors.messages.carrierwave_direct_upload_missing")]
+      end
+
+      it "should use i18n for the remote net url error message" do
+        subject.valid?
+        subject.errors[:remote_video_net_url].should == [I18n.t("errors.messages.blank")]
+      end
+
+      it "should be valid on update" do
+        subject.save(:validate => false)
+        subject.should be_valid
+      end
+    end
+
+    shared_examples_for "a blank or empty attachment" do
+      it "should not be valid" do
+        subject.should_not be_valid
+      end
+
+      context "on update" do
+        it "should not be valid" do
+          subject.save(:validate => false)
+          subject.should_not be_valid
+        end
+      end
+
+      it "should use i18n for the error messages" do
+        subject.valid?
+        subject.errors[:video].should == [I18n.t("errors.messages.carrierwave_direct_attachment_missing")]
+      end
+    end
+
+    describe ".validates_filename_uniqueness_of" do
+      it "should be turned on by default" do
+        party_class.should_receive(:validates_filename_uniqueness_of).with(:video)
+        mount_uploader
+      end
+
+      context "another Party with a duplicate video filename" do
+        before do
+          subject.video.key = sample_key
+          subject.save
+        end
+
+        let(:another_party) do
+          another_party = party_class.new
+          another_party.video.key = subject.video.key
+          another_party
+        end
+
+        it "should not be valid" do
+          another_party.should_not be_valid
+        end
+
+        it "should use I18n for the error messages" do
+          another_party.valid?
+          another_party.errors[:video].should == [I18n.t("errors.messages.carrierwave_direct_filename_taken")]
+        end
+      end
+
+      context "is turned off in the configuration" do
+        before do
+          DirectUploader.validate_unique_filename = false
+        end
+
+        it "should not validate the filename uniqueness" do
+          party_class.should_not_receive(:validates_filename_uniqueness_of)
+          mount_uploader
+        end
+      end
+    end
+
+    describe ".validates_filename_format_of" do
+      it "should be turned on by default" do
+        party_class.should_receive(:validates_filename_format_of).with(:video)
+        mount_uploader
+      end
+
+      context "where the file upload is" do
+        context "nil" do
+          before do
+            subject.key = nil
+          end
+
+          it "should be valid" do
+            subject.should be_valid
+          end
+        end
+
+        context "blank" do
+          before do
+            subject.key = ""
+          end
+
+          it "should be valid" do
+            subject.should be_valid
+          end
+        end
+      end
+
+      context "where the uploader has an extension white list" do
+        before do
+          subject.video.stub(:extension_white_list).and_return(%w{avi mp4})
+        end
+
+        context "and the uploaded file's extension is included in the list" do
+          before do
+            subject.key = sample_key(:extension => "avi")
+          end
+
+          it "should be valid" do
+            subject.should be_valid
+          end
+        end
+
+        context "but uploaded file's extension is not included in the list" do
+          before do
+            subject.key = sample_key(:extension => "mp3")
+          end
+
+          it_should_behave_like "an invalid filename"
+
+          it "should include the white listed extensions in the error message" do
+            subject.valid?
+            subject.errors[:video].first.should include("avi and mp4")
+          end
+        end
+
+        context "and the video's key does not contain a guid" do
+          before do
+            subject.video.key = sample_key(:valid => false)
+          end
+
+          it_should_behave_like "an invalid filename"
+        end
+      end
+
+      context "is turned off in the configuration" do
+        before do
+          DirectUploader.validate_filename_format = false
+        end
+
+        it "should not validate the filename format" do
+          party_class.should_not_receive(:validates_filename_format_of)
+          mount_uploader
+        end
+      end
+    end
+
+    describe ".validates_remote_net_url_format_of" do
+      it "should be turned on by default" do
+        party_class.should_receive(:validates_remote_net_url_format_of).with(:video)
+        mount_uploader
+      end
+
+      context "with an invalid remote image net url" do
+
+        context "on create" do
+          context "where the uploader has an extension white list" do
+            before do
+              subject.video.stub(:extension_white_list).and_return(%w{avi mp4})
+            end
+
+            context "and the url's extension is included in the list" do
+              before do
+                subject.remote_video_net_url = "http://example.com/some_video.mp4"
+              end
+
+              it "should be valid" do
+                subject.should be_valid
+              end
+            end
+
+            context "but the url's extension is not included in the list" do
+              before do
+                subject.remote_video_net_url = "http://example.com/some_video.mp3"
+              end
+
+              it "should not be valid" do
+                subject.should_not be_valid
+              end
+
+              it_should_behave_like "a remote net url i18n error message" do
+                let(:i18n_options) { {:extension_white_list => %w{avi mp4} } }
+              end
+
+              it "should include the white listed extensions in the error message" do
+                subject.valid?
+                subject.errors[:remote_video_net_url].first.should include("avi and mp4")
+              end
+            end
+          end
+
+          context "where the url is invalid" do
+            before do
+              subject.remote_video_net_url = "http$://example.com/some_video.mp4"
+            end
+
+            it "should not be valid" do
+              subject.should_not be_valid
+            end
+
+            it_should_behave_like "a remote net url i18n error message" do
+              let(:i18n_options) { nil }
+            end
+          end
+
+          context "where the url is" do
+            context "nil" do
+              before do
+                subject.remote_video_net_url = nil
+              end
+
+              it "should be valid" do
+                subject.should be_valid
+              end
+            end
+
+            context "blank" do
+              before do
+                subject.remote_video_net_url = ""
+              end
+
+              it "should be valid" do
+                subject.should be_valid
+              end
+            end
+          end
+
+          context "where the uploader specifies valid url schemes" do
+            before do
+              subject.video.stub(:url_scheme_white_list).and_return(%w{http https})
+            end
+
+            context "and the url's scheme is included in the list" do
+              before do
+                subject.remote_video_net_url = "https://example.com/some_video.mp3"
+              end
+
+              it "should be valid" do
+                subject.should be_valid
+              end
+            end
+
+            context "but the url's scheme is not included in the list" do
+              before do
+                subject.remote_video_net_url = "ftp://example.com/some_video.mp3"
+              end
+
+              it "should not be valid" do
+                subject.should_not be_valid
+              end
+
+              it_should_behave_like "a remote net url i18n error message" do
+                let(:i18n_options) { {:url_scheme_white_list => %w{http https} } }
+              end
+
+              it "should include the white listed url schemes in the error message" do
+                subject.valid?
+                subject.errors[:remote_video_net_url].first.should include("http and https")
+              end
+            end
+          end
+        end
+
+        context "on update" do
+          before do
+            subject.remote_video_net_url = "http$://example.com/some_video.mp4"
+          end
+
+          it "should be valid" do
+            subject.save(:validate => false)
+            subject.should be_valid
+          end
+        end
+      end
+
+      context "is turned off in the configuration" do
+        before do
+          DirectUploader.validate_remote_net_url_format = false
+        end
+
+        it "should not validate the format of the remote net url" do
+          party_class.should_not_receive(:validates_remote_net_url_format_of)
+          mount_uploader
+        end
+      end
+    end
+
+    describe ".validates_is_uploaded" do
+      it "should be turned off by default" do
+        party_class.should_not_receive(:validates_is_uploaded)
+        mount_uploader
+      end
+
+      context "is turned on in the configuration" do
+        before do
+          DirectUploader.validate_is_uploaded = true
+        end
+
+        it "should validate that a file has been uploaded" do
+          party_class.should_receive(:validates_is_uploaded).with(:video)
+          mount_uploader
+        end
+      end
+
+      context "is on" do
+        before do
+          party_class.validates_is_uploaded :video
+        end
+
+        context "where there is no upload" do
+          it_should_behave_like "without an upload" do
+            let(:remote_video_net_url) { nil }
+            let(:upload_path) { nil }
+          end
+        end
+
+        context "where the remote net url is blank" do
+          it_should_behave_like "without an upload" do
+            let(:remote_video_net_url) { "" }
+            let(:upload_path) { nil }
+          end
+        end
+
+        context "with an upload by remote url" do
+          before do
+            subject.remote_video_net_url = "http://example.com/some_url.anything"
+          end
+
+          it "should be valid" do
+            subject.should be_valid
+          end
+        end
+
+        context "with an upload by file" do
+          before do
+            subject.key = sample_key
+          end
+
+          it "should be valid" do
+            subject.should be_valid
+          end
+        end
+      end
+    end
+
+    describe ".validates_is_attached" do
+      it "should be turned off by default" do
+        party_class.should_not_receive(:validates_is_attached)
+        mount_uploader
+      end
+
+      context "is turned on in the configuration" do
+        before do
+          DirectUploader.validate_is_attached = true
+        end
+
+        it "should validate that a file has been attached" do
+          party_class.should_receive(:validates_is_attached).with(:video)
+          mount_uploader
+        end
+      end
+
+      context "is on" do
+        before do
+          party_class.validates_is_attached :video
+        end
+
+        context "where the attachment" do
+          context "is blank" do
+            it_should_behave_like "a blank or empty attachment"
+          end
+
+          context "is nil" do
+            before do
+              subject.video = nil
+            end
+
+            it_should_behave_like "a blank or empty attachment"
+          end
+        end
+      end
+    end
+
+    it_should_have_accessor(:skip_is_attached_validations)
+
+    describe "#key" do
+      it "should be accessible" do
+        party_class.new(:key => "some key").key.should == "some key"
+      end
+    end
+
+    describe "#remote_\#\{column\}_net_url" do
+      it "should be accessible" do
+        party_class.new(:remote_video_net_url => "some url").remote_video_net_url.should == "some url"
+      end
+    end
+
+    describe "#filename_valid?" do
+      shared_examples_for "having empty errors" do
+        before do
+          subject.filename_valid?
+        end
+
+        context "where after the call, #errors" do
+          it "should be empty" do
+            subject.errors.should be_empty
+          end
+        end
+      end
+
+      context "does not have an upload" do
+        it "should be true" do
+          subject.filename_valid?.should be_true
+        end
+
+        it_should_behave_like "having empty errors"
+      end
+
+      context "has an upload" do
+        context "with a valid filename" do
+          before do
+            subject.key = sample_key(:model_class => subject.class)
+          end
+
+          it "should be true" do
+            subject.filename_valid?.should be_true
+          end
+
+          it_should_behave_like "having empty errors"
+        end
+
+        context "with an invalid filename" do
+          before { subject.key = sample_key(:model_class => subject.class, :valid => false) }
+
+          it "should be false" do
+            subject.filename_valid?.should be_false
+          end
+
+          context "after the call, #errors" do
+            before { subject.filename_valid? }
+
+            it "should only contain '\#\{column\}' errors" do
+              subject.errors.count.should == subject.errors[:video].count
+            end
+          end
+        end
+      end
+    end
+  end
+end
+