locomotive_carrierwave 0.5.0.1.beta1

data/lib/carrierwave/uploader/configuration.rb

@@ -0,0 +1,134 @@
+module CarrierWave
+
+  module Uploader
+    module Configuration
+      extend ActiveSupport::Concern
+
+      included do
+        add_config :root
+        add_config :permissions
+        add_config :storage_engines
+        add_config :s3_access_policy
+        add_config :s3_bucket
+        add_config :s3_access_key_id
+        add_config :s3_secret_access_key
+        add_config :s3_cname
+        add_config :s3_headers
+        add_config :cloud_files_username
+        add_config :cloud_files_api_key
+        add_config :cloud_files_container
+        add_config :cloud_files_cdn_host
+        add_config :grid_fs_connection
+        add_config :grid_fs_database
+        add_config :grid_fs_host
+        add_config :grid_fs_port
+        add_config :grid_fs_username
+        add_config :grid_fs_password
+        add_config :grid_fs_access_url
+        add_config :store_dir
+        add_config :cache_dir
+        add_config :enable_processing
+        add_config :ensure_multipart_form
+
+        # Mounting
+        add_config :ignore_integrity_errors
+        add_config :ignore_processing_errors
+        add_config :validate_integrity
+        add_config :validate_processing
+        add_config :mount_on
+
+        configure do |config|
+          config.permissions = 0644
+          config.storage_engines = {
+            :file => "CarrierWave::Storage::File",
+            :s3 => "CarrierWave::Storage::S3",
+            :grid_fs => "CarrierWave::Storage::GridFS",
+            :right_s3 => "CarrierWave::Storage::RightS3",
+            :cloud_files => "CarrierWave::Storage::CloudFiles"
+          }
+          config.storage = :file
+          config.s3_headers = {}
+          config.s3_access_policy = :public_read
+          config.grid_fs_database = 'carrierwave'
+          config.grid_fs_host = 'localhost'
+          config.grid_fs_port = 27017
+          config.store_dir = 'uploads'
+          config.cache_dir = 'uploads/tmp'
+          config.ignore_integrity_errors = true
+          config.ignore_processing_errors = true
+          config.validate_integrity = true
+          config.validate_processing = true
+          config.root = CarrierWave.root
+          config.enable_processing = true
+          config.ensure_multipart_form = true
+        end
+      end
+
+      module ClassMethods
+
+        ##
+        # Sets the storage engine to be used when storing files with this uploader.
+        # Can be any class that implements a #store!(CarrierWave::SanitizedFile) and a #retrieve!
+        # method. See lib/carrierwave/storage/file.rb for an example. Storage engines should
+        # be added to CarrierWave::Uploader::Base.storage_engines so they can be referred
+        # to by a symbol, which should be more convenient
+        #
+        # If no argument is given, it will simply return the currently used storage engine.
+        #
+        # === Parameters
+        #
+        # [storage (Symbol, Class)] The storage engine to use for this uploader
+        #
+        # === Returns
+        #
+        # [Class] the storage engine to be used with this uploader
+        #
+        # === Examples
+        #
+        #     storage :file
+        #     storage CarrierWave::Storage::File
+        #     storage MyCustomStorageEngine
+        #
+        def storage(storage = nil)
+          if storage.is_a?(Symbol)
+            @storage = eval(storage_engines[storage])
+          elsif storage
+            @storage = storage
+          elsif @storage.nil?
+            # Get the storage from the superclass if there is one
+            @storage = superclass.storage rescue nil
+          end
+          return @storage
+        end
+        alias_method :storage=, :storage
+
+
+        def add_config(name)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.#{name}(value=nil)
+              @#{name} = value if value
+              return @#{name} if self.object_id == #{self.object_id} || defined?(@#{name})
+              name = superclass.#{name}
+              return nil if name.nil? && !instance_variable_defined?("@#{name}")
+              @#{name} = name && !name.is_a?(Module) && !name.is_a?(Symbol) && !name.is_a?(Numeric) && !name.is_a?(TrueClass) && !name.is_a?(FalseClass) ? name.dup : name
+            end
+
+            def self.#{name}=(value)
+              @#{name} = value
+            end
+
+            def #{name}
+              self.class.#{name}
+            end
+          RUBY
+        end
+
+        def configure
+          yield self
+        end
+      end
+
+    end
+  end
+end
+

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,64 @@
+# encoding: utf-8
+
+require 'open-uri'
+
+module CarrierWave
+  module Uploader
+    module Download
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+      include CarrierWave::Uploader::Configuration
+      include CarrierWave::Uploader::Cache
+
+      class RemoteFile
+        def initialize(uri)
+          @uri = URI.parse(URI.escape(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
+          if @file.blank?
+            @file = Kernel.open(@uri.to_s)
+            @file = @file.is_a?(String) ? StringIO.new(@file) : @file
+          end
+          @file
+        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,38 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module ExtensionWhitelist
+      extend ActiveSupport::Concern
+
+      included 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, :original_file
+
+      ##
+      # 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,85 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Processing
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+
+      included do
+        after :cache, :process!
+        after :recreate_versions, :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,23 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Remove
+      extend ActiveSupport::Concern
+
+      include 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/rename.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Rename
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+
+      included do
+        after :rename, :recreate_versions!
+      end
+
+      ##
+      # Override this method in your uploader to check if the model has been updated.
+      #
+      # === Returns
+      #
+      # [NilClass, Boolean] true if the model has been changed, false otherwise
+      #
+      # === Examples
+      #
+      #     def stale_model?
+      #       model.folder_changed? # because store_dir is based on the folder property of the model
+      #     end
+      #
+      def stale_model?
+         false
+      end
+
+      def rename?
+        @rename || false
+      end
+
+      ##
+      # Renames the file
+      #
+      def rename!
+        return true if !self.rename?
+
+        with_callbacks(:rename) do
+          @file = storage.rename!(@original_file)
+          @original_file = nil
+          @rename = false
+        end
+      end
+
+      private
+
+      def check_stale_model!
+        # the conditions below means: already an existing file, with model, model has been modified and not changing the file currently.
+        @rename = self.file && self.model && self.stale_model? && @cache_id.nil?
+
+        if self.rename?
+          @original_file = self.file.clone
+          @filename = self.model.send(:_mounter, self.mounted_as).identifier # default filename has to be the one from the model
+        end
+      end
+
+    end # Rename
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/store.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Store
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+      include CarrierWave::Uploader::Configuration
+      include 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
+
+      def delete_original_file?
+        @original_file && @original_file.path != @file.path # if the path hasn't changed, no need to delete it
+      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)
+
+            @original_file.delete if self.delete_original_file?
+
+            @cache_id = nil
+            @original_file = 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 as_json(options = nil)
+        { :url => url }
+      end
+
+    end # Url
+  end # Uploader
+end # CarrierWave