durran-carrierwave 0.3.2.3

data/lib/carrierwave/test/matchers.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Test
+
+    ##
+    # These are some matchers that can be used in RSpec specs, to simplify the testing
+    # of uploaders.
+    #
+    module Matchers
+
+      class BeIdenticalTo # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+        def matches?(actual)
+          @actual = actual
+          FileUtils.identical?(@actual, @expected)
+        end
+        def failure_message
+          "expected #{@actual.inspect} to be identical to #{@expected.inspect}"
+        end
+        def negative_failure_message
+          "expected #{@actual.inspect} to not be identical to #{@expected.inspect}"
+        end
+      end
+
+      def be_identical_to(expected)
+        BeIdenticalTo.new(expected)
+      end
+
+      class HavePermissions # :nodoc:
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          (File.stat(@actual.path).mode & 0777) == @expected
+        end
+
+        def failure_message
+          "expected #{@actual.inspect} to have permissions #{@expected.to_s(8)}, but they were #{(File.stat(@actual.path).mode & 0777).to_s(8)}"
+        end
+
+        def negative_failure_message
+          "expected #{@actual.inspect} not to have permissions #{@expected.to_s(8)}, but it did"
+        end
+      end
+
+      def have_permissions(expected)
+        HavePermissions.new(expected)
+      end
+
+      class BeNoLargerThan # :nodoc:
+        def initialize(width, height)
+          @width, @height = width, height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          require 'RMagick'
+          img = ::Magick::Image.read(@actual.path).first
+          @actual_width = img.columns
+          @actual_height = img.rows
+          @actual_width <= @width && @actual_height <= @height
+        end
+
+        def failure_message
+          "expected #{@actual.inspect} to be no larger than #{@width} by #{@height}, but it was #{@actual_height} by #{@actual_width}."
+        end
+
+        def negative_failure_message
+          "expected #{@actual.inspect} to be larger than #{@width} by #{@height}, but it wasn't."
+        end
+      end
+
+      def be_no_larger_than(width, height)
+        BeNoLargerThan.new(width, height)
+      end
+
+      class HaveDimensions # :nodoc:
+        def initialize(width, height)
+          @width, @height = width, height
+        end
+
+        def matches?(actual)
+          @actual = actual
+          # Satisfy expectation here. Return false or raise an error if it's not met.
+          require 'RMagick'
+          img = ::Magick::Image.read(@actual.path).first
+          @actual_width = img.columns
+          @actual_height = img.rows
+          @actual_width == @width && @actual_height == @height
+        end
+
+        def failure_message
+          "expected #{@actual.inspect} to have an exact size of #{@width} by #{@height}, but it was #{@actual_height} by #{@actual_width}."
+        end
+
+        def negative_failure_message
+          "expected #{@actual.inspect} not to have an exact size of #{@width} by #{@height}, but it did."
+        end
+      end
+
+      def have_dimensions(width, height)
+        HaveDimensions.new(width, height)
+      end
+      
+    end # SpecHelper
+  end # Test
+end # CarrierWave

data/lib/carrierwave/uploader.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module CarrierWave
+
+  ##
+  # See CarrierWave::Uploader::Base
+  #
+  module Uploader
+
+    ##
+    # An uploader is a class that allows you to easily handle the caching and storage of
+    # uploaded files. Please refer to the README for configuration options.
+    #
+    # Once you have an uploader you can use it in isolation:
+    #
+    #     my_uploader = MyUploader.new
+    #     my_uploader.cache!(File.open(path_to_file))
+    #     my_uploader.retrieve_from_store!('monkey.png')
+    #
+    # Alternatively, you can mount it on an ORM or other persistence layer, with
+    # +CarrierWave::Mount#mount_uploader+. There are extensions for activerecord and datamapper
+    # these are *very* simple (they are only a dozen lines of code), so adding your own should
+    # be trivial.
+    #
+    class Base
+      attr_reader :file
+
+      use CarrierWave::Uploader::Paths
+      use CarrierWave::Uploader::Callbacks
+      use CarrierWave::Uploader::Proxy
+      use CarrierWave::Uploader::Url
+      use CarrierWave::Uploader::Mountable
+      use CarrierWave::Uploader::Cache
+      use CarrierWave::Uploader::Store
+      use CarrierWave::Uploader::Remove
+      use CarrierWave::Uploader::ExtensionWhitelist
+      use CarrierWave::Uploader::DefaultPath
+      use CarrierWave::Uploader::Processing
+      use CarrierWave::Uploader::Versions
+    end # Base
+
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/cache.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Cache
+
+      depends_on CarrierWave::Uploader::Paths
+      depends_on CarrierWave::Uploader::Callbacks
+
+      ##
+      # Returns true if the uploader has been cached
+      #
+      # === Returns
+      #
+      # [Bool] whether the current file is cached
+      #
+      def cached?
+        @cache_id
+      end
+
+      ##
+      # Override this in your Uploader to change the directory where files are cached.
+      #
+      # === Returns
+      #
+      # [String] a directory
+      #
+      def cache_dir
+        CarrierWave.config[:cache_dir]
+      end
+
+      ##
+      # Returns a String which uniquely identifies the currently cached file for later retrieval
+      #
+      # === Returns
+      #
+      # [String] a cache name, in the format YYYYMMDD-HHMM-PID-RND/filename.txt
+      #
+      def cache_name
+        File.join(cache_id, full_original_filename) if cache_id and original_filename
+      end
+
+      ##
+      # Caches the given file. Calls process! to trigger any process callbacks.
+      #
+      # === Parameters
+      #
+      # [new_file (File, IOString, Tempfile)] any kind of file object
+      #
+      # === Raises
+      #
+      # [CarrierWave::FormNotMultipart] if the assigned parameter is a string
+      #
+      def cache!(new_file)
+        new_file = CarrierWave::SanitizedFile.new(new_file)
+        raise CarrierWave::FormNotMultipart if new_file.is_path?
+
+        unless new_file.empty?
+          with_callbacks(:cache, new_file) do
+            self.cache_id = CarrierWave.generate_cache_id unless cache_id
+
+            @filename = new_file.filename
+            self.original_filename = new_file.filename
+
+            if CarrierWave.config[:cache_to_cache_dir]
+              @file = new_file.copy_to(cache_path, CarrierWave.config[:permissions])
+            else
+              @file = new_file
+            end
+          end
+        end
+      end
+
+      ##
+      # Retrieves the file with the given cache_name from the cache.
+      #
+      # === Parameters
+      #
+      # [cache_name (String)] uniquely identifies a cache file
+      #
+      # === Raises
+      #
+      # [CarrierWave::InvalidParameter] if the cache_name is incorrectly formatted.
+      #
+      def retrieve_from_cache!(cache_name)
+        with_callbacks(:retrieve_from_cache, cache_name) do
+          self.cache_id, self.original_filename = cache_name.to_s.split('/', 2)
+          @filename = original_filename
+          @file = CarrierWave::SanitizedFile.new(cache_path)
+        end
+      end
+
+    private
+
+      def cache_path
+        File.expand_path(File.join(cache_dir, cache_name), public)
+      end
+
+      attr_reader :cache_id, :original_filename
+
+      # We can override the full_original_filename method in other modules
+      alias_method :full_original_filename, :original_filename
+
+      def cache_id=(cache_id)
+        raise CarrierWave::InvalidParameter, "invalid cache id" unless cache_id =~ /\A[\d]{8}\-[\d]{4}\-[\d]+\-[\d]{4}\z/
+        @cache_id = cache_id
+      end
+
+      def original_filename=(filename)
+        raise CarrierWave::InvalidParameter, "invalid filename" unless filename =~ /\A[a-z0-9\.\-\+_]+\z/i
+        @original_filename = filename
+      end
+
+    end # Cache
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/callbacks.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Callbacks
+
+      setup do
+        extlib_inheritable_accessor :_before_callbacks, :_after_callbacks
+      end
+
+      def with_callbacks(kind, *args)
+        self.class._before_callbacks_for(kind).each { |callback| self.send(callback, *args) }
+        yield
+        self.class._after_callbacks_for(kind).each { |callback| self.send(callback, *args) }
+      end
+
+      module ClassMethods
+        
+        def _before_callbacks_for(kind) #:nodoc:
+          self._before_callbacks ||= {}
+          self._before_callbacks[kind] ||= []
+          self._before_callbacks[kind]
+        end
+
+        def _after_callbacks_for(kind) #:nodoc:
+          self._after_callbacks ||= {}
+          self._after_callbacks[kind] ||= []
+          self._after_callbacks[kind]
+        end
+
+        def before(kind, callback)
+          _before_callbacks_for(kind) << callback
+        end
+
+        def after(kind, callback)
+          _after_callbacks_for(kind) << callback
+        end
+      end # ClassMethods
+
+    end # Callbacks
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/default_path.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module DefaultPath
+
+      def initialize(*args)
+        super
+        if default_path
+          @file = CarrierWave::SanitizedFile.new(File.expand_path(default_path, public))
+          def @file.blank?; true; end
+        end
+      end
+
+      ##
+      # Override this method in your uploader to provide a default path
+      # in case no file has been cached/stored yet.
+      #
+      def default_path; end
+
+    end # DefaultPath
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/extension_whitelist.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module ExtensionWhitelist
+
+      setup do
+        before :cache, :check_whitelist!
+      end
+
+      ##
+      # Override this method in your uploader to provide a white list of extensions which
+      # are allowed to be uploaded.
+      #
+      # === Returns
+      #
+      # [NilClass, Array[String]] a white list of extensions which are allowed to be uploaded
+      #
+      # === Examples
+      #
+      #     def extension_white_list
+      #       %w(jpg jpeg gif png)
+      #     end
+      #
+      def extension_white_list; end
+
+    private
+
+      def check_whitelist!(new_file)
+        if extension_white_list and not extension_white_list.include?(new_file.extension.to_s)
+          raise CarrierWave::IntegrityError, "You are not allowed to upload #{new_file.extension.inspect} files, allowed types: #{extension_white_list.inspect}"
+        end
+      end
+
+    end # ExtensionWhitelist
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/mountable.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Mountable
+
+      attr_reader :model, :mounted_as
+
+      ##
+      # If a model is given as the first parameter, it will stored in the uploader, and
+      # available throught +#model+. Likewise, mounted_as stores the name of the column
+      # where this instance of the uploader is mounted. These values can then be used inside
+      # your uploader.
+      #
+      # If you do not wish to mount your uploaders with the ORM extensions in -more then you
+      # can override this method inside your uploader. Just be sure to call +super+
+      #
+      # === Parameters
+      #
+      # [model (Object)] Any kind of model object
+      # [mounted_as (Symbol)] The name of the column where this uploader is mounted
+      #
+      # === Examples
+      #
+      #     class MyUploader < CarrierWave::Uploader::Base
+      #
+      #       def store_dir
+      #         File.join('public', 'files', mounted_as, model.permalink)
+      #       end
+      #     end
+      #
+      def initialize(model=nil, mounted_as=nil)
+        @model = model
+        @mounted_as = mounted_as
+      end
+
+    end # Mountable
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/paths.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Paths
+
+      ##
+      # === Returns
+      #
+      # [String] the directory that is the root of the application
+      #
+      def root
+        CarrierWave.config[:root]
+      end
+
+      ##
+      # === Returns
+      #
+      # [String] the directory where files will be publically accessible
+      #
+      def public
+        CarrierWave.config[:public]
+      end
+
+    end # Paths
+  end # Uploader
+end # CarrierWave