samlown-carrierwave 0.4.5

data/lib/carrierwave/uploader/default_url.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module DefaultUrl
+
+      def url(*args)
+        super || default_url
+      end
+
+      ##
+      # Override this method in your uploader to provide a default url
+      # in case no file has been cached/stored yet.
+      #
+      def default_url; end
+
+    end # DefaultPath
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/download.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'net/http'
+
+module CarrierWave
+  module Uploader
+    module Download
+
+      depends_on CarrierWave::Uploader::Callbacks
+      depends_on CarrierWave::Uploader::Configuration
+      depends_on CarrierWave::Uploader::Cache
+
+      class RemoteFile
+        def initialize(uri)
+          @uri = URI.parse(uri)
+        end
+
+        def original_filename
+          File.basename(@uri.path)
+        end
+
+        def respond_to?(*args)
+          super or file.respond_to?(*args)
+        end
+
+        def http?
+          @uri.scheme =~ /^https?$/
+        end
+
+      private
+
+        def file
+          @file ||= StringIO.new(Net::HTTP.get_response(@uri).body)
+        end
+
+        def method_missing(*args, &block)
+          file.send(*args, &block)
+        end
+      end
+
+      ##
+      # Caches the file by downloading it from the given URL.
+      #
+      # === Parameters
+      #
+      # [url (String)] The URL where the remote file is stored
+      #
+      def download!(uri)
+        unless uri.blank?
+          file = RemoteFile.new(uri)
+          raise CarrierWave::DownloadError, "trying to download a file which is not served over HTTP" unless file.http?
+          cache!(file) 
+        end
+      end
+
+    end # Download
+  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/processing.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Processing
+
+      depends_on CarrierWave::Uploader::Callbacks
+
+      setup do
+        after :cache, :process!
+      end
+
+      module ClassMethods
+
+        ##
+        # Lists processor callbacks declared
+        #
+        # === Returns
+        #
+        # [Array[Array[Symbol, Array]]] a list of processor callbacks which have been declared for this uploader
+        #
+        def processors
+          @processors ||= []
+        end
+
+        ##
+        # Adds a processor callback which applies operations as a file is uploaded.
+        # The argument may be the name of any method of the uploader, expressed as a symbol,
+        # or a list of such methods, or a hash where the key is a method and the value is
+        # an array of arguments to call the method with
+        #
+        # === Parameters
+        #
+        # args (*Symbol, Hash{Symbol => Array[]})
+        #
+        # === Examples
+        #
+        #     class MyUploader < CarrierWave::Uploader::Base
+        #
+        #       process :sepiatone, :vignette
+        #       process :scale => [200, 200]
+        #
+        #       def sepiatone
+        #         ...
+        #       end
+        #
+        #       def vignette
+        #         ...
+        #       end
+        #
+        #       def scale(height, width)
+        #         ...
+        #       end
+        #     end
+        #
+        def process(*args)
+          args.each do |arg|
+            if arg.is_a?(Hash)
+              arg.each do |method, args|
+                processors.push([method, args])
+              end
+            else
+              processors.push([arg, []])
+            end
+          end
+        end
+
+      end # ClassMethods
+
+      ##
+      # Apply all process callbacks added through CarrierWave.process
+      #
+      def process!(new_file=nil)
+        if enable_processing
+          self.class.processors.each do |method, args|
+            self.send(method, *args)
+          end
+        end
+      end
+
+    end # Processing
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/proxy.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Proxy
+
+      ##
+      # === Returns
+      #
+      # [Boolean] Whether the uploaded file is blank
+      #
+      def blank?
+        file.blank?
+      end
+
+      ##
+      # === Returns
+      #
+      # [String] the path where the file is currently located.
+      #
+      def current_path
+        file.path if file.respond_to?(:path)
+      end
+
+      alias_method :path, :current_path
+
+      ##
+      # Returns a string that uniquely identifies the last stored file
+      #
+      # === Returns
+      #
+      # [String] uniquely identifies a file
+      #
+      def identifier
+        storage.identifier if storage.respond_to?(:identifier)
+      end
+
+      ##
+      # Read the contents of the file
+      #
+      # === Returns
+      #
+      # [String] contents of the file
+      #
+      def read
+        file.read if file.respond_to?(:read)
+      end
+
+      ##
+      # Fetches the size of the currently stored/cached file
+      #
+      # === Returns
+      #
+      # [Integer] size of the file
+      #
+      def size
+        file.respond_to?(:size) ? file.size : 0
+      end
+
+    end # Proxy
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/remove.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Remove
+
+      depends_on CarrierWave::Uploader::Callbacks
+
+      ##
+      # Removes the file and reset it
+      #
+      def remove!
+        with_callbacks(:remove) do
+          @file.delete if @file
+          @file = nil
+          @cache_id = nil
+        end
+      end
+
+    end # Remove
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/store.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Store
+
+      depends_on CarrierWave::Uploader::Callbacks
+      depends_on CarrierWave::Uploader::Configuration
+      depends_on CarrierWave::Uploader::Cache
+
+      ##
+      # Override this in your Uploader to change the filename.
+      #
+      # Be careful using record ids as filenames. If the filename is stored in the database
+      # the record id will be nil when the filename is set. Don't use record ids unless you
+      # understand this limitation.
+      #
+      # Do not use the version_name in the filename, as it will prevent versions from being
+      # loaded correctly.
+      #
+      # === Returns
+      #
+      # [String] a filename
+      #
+      def filename
+        @filename
+      end
+
+      ##
+      # Calculates the path where the file should be stored. If +for_file+ is given, it will be
+      # used as the filename, otherwise +CarrierWave::Uploader#filename+ is assumed.
+      #
+      # === Parameters
+      #
+      # [for_file (String)] name of the file <optional>
+      #
+      # === Returns
+      #
+      # [String] the store path
+      #
+      def store_path(for_file=filename)
+        File.join([store_dir, full_filename(for_file)].compact)
+      end
+
+      ##
+      # Stores the file by passing it to this Uploader's storage engine.
+      #
+      # If new_file is omitted, a previously cached file will be stored.
+      #
+      # === Parameters
+      #
+      # [new_file (File, IOString, Tempfile)] any kind of file object
+      #
+      def store!(new_file=nil)
+        cache!(new_file) if new_file
+        if @file and @cache_id
+          with_callbacks(:store, new_file) do
+            @file = storage.store!(@file)
+            @cache_id = nil
+          end
+        end
+      end
+
+      ##
+      # Retrieves the file from the storage.
+      #
+      # === Parameters
+      #
+      # [identifier (String)] uniquely identifies the file to retrieve
+      #
+      def retrieve_from_store!(identifier)
+        with_callbacks(:retrieve_from_store, identifier) do
+          @file = storage.retrieve!(identifier)
+        end
+      end
+
+    private
+
+      def full_filename(for_file)
+        for_file
+      end
+
+      def storage
+        @storage ||= self.class.storage.new(self)
+      end
+
+    end # Store
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/url.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Url
+
+      ##
+      # === Returns
+      #
+      # [String] the location where this file is accessible via a url
+      #
+      def url
+        if file.respond_to?(:url) and not file.url.blank?
+          file.url
+        elsif current_path
+          File.expand_path(current_path).gsub(File.expand_path(root), '')
+        end
+      end
+
+      alias_method :to_s, :url
+
+      ##
+      # === Returns
+      #
+      # [String] A JSON serializtion containing this uploader's URL
+      #
+      def to_json(*args)
+        { 'url' => url }.to_json(*args)
+      end
+
+    end # Url
+  end # Uploader
+end # CarrierWave