thorsson_carrierwave 0.4.5

data/lib/carrierwave/compatibility/paperclip.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Compatibility
+
+    ##
+    # Mix this module into an Uploader to make it mimic Paperclip's storage paths
+    # This will make your Uploader use the same default storage path as paperclip
+    # does. If you need to override it, you can override the +paperclip_path+ method
+    # and provide a Paperclip style path:
+    #
+    #     class MyUploader < CarrierWave::Uploader::Base
+    #       include CarrierWave::Compatibility::Paperclip
+    #       
+    #       def paperclip_path
+    #         ":rails_root/public/uploads/:id/:attachment/:style_:basename.:extension"
+    #       end
+    #     end
+    #
+    # ---
+    #
+    # This file contains code taken from Paperclip
+    # 
+    # LICENSE
+    # 
+    # The MIT License
+    # 
+    # Copyright (c) 2008 Jon Yurek and thoughtbot, inc.
+    # 
+    # Permission is hereby granted, free of charge, to any person obtaining a copy
+    # of this software and associated documentation files (the "Software"), to deal
+    # in the Software without restriction, including without limitation the rights
+    # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    # copies of the Software, and to permit persons to whom the Software is
+    # furnished to do so, subject to the following conditions:
+    # 
+    # The above copyright notice and this permission notice shall be included in
+    # all copies or substantial portions of the Software.
+    # 
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    # THE SOFTWARE.
+    #
+    module Paperclip
+
+      def store_path(for_file=filename)
+        path = paperclip_path
+        path ||= File.join(*[store_dir, paperclip_style.to_s, for_file].compact)
+        interpolate_paperclip_path(path, for_file)
+      end
+
+      def store_dir
+        ":rails_root/public/system/:attachment/:id"
+      end
+
+      def paperclip_default_style
+        :original
+      end
+
+      def paperclip_path
+      end
+
+      def paperclip_style
+        version_name || paperclip_default_style
+      end
+
+    private
+
+      def interpolate_paperclip_path(path, filename)
+        mappings.inject(path) do |agg, pair|
+          agg.gsub(":#{pair[0]}", pair[1].call(self, filename).to_s)
+        end
+      end
+
+      def mappings
+        {
+          :rails_root   => lambda{|u, f| Rails.root },
+          :rails_env    => lambda{|u, f| Rails.env },
+          :class        => lambda{|u, f| u.model.class.name.underscore.pluralize},
+          :id           => lambda{|u, f| u.model.id },
+          :id_partition => lambda{|u, f| ("%09s" % u.model.id).scan(/\d{3}/).join("/")},
+          :attachment   => lambda{|u, f| u.mounted_as.to_s.downcase.pluralize },
+          :style        => lambda{|u, f| u.paperclip_style },
+          :basename     => lambda{|u, f| f.gsub(/#{File.extname(f)}$/, "") },
+          :extension    => lambda{|u, f| File.extname(f).gsub(/^\.+/, "")}
+        }
+      end
+
+    end # Paperclip
+  end # Compatibility
+end # CarrierWave

data/lib/carrierwave/core_ext/blank.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+unless "".respond_to?(:blank?)
+  # blank? methods for several different class types
+  class Object
+    # Returns true if the object is nil or empty (if applicable)
+    def blank?
+      nil? || (respond_to?(:empty?) && empty?)
+    end
+  end # class Object
+
+  class Numeric
+    # Numerics can't be blank
+    def blank?
+      false
+    end
+  end # class Numeric
+
+  class NilClass
+    # Nils are always blank
+    def blank?
+      true
+    end
+  end # class NilClass
+
+  class TrueClass
+    # True is not blank.
+    def blank?
+      false
+    end
+  end # class TrueClass
+
+  class FalseClass
+    # False is always blank.
+    def blank?
+      true
+    end
+  end # class FalseClass
+
+  class String
+    # Strips out whitespace then tests if the string is empty.
+    def blank?
+      strip.empty?
+    end
+  end # class String
+end

data/lib/carrierwave/core_ext/inheritable_attributes.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+# Stolen from Rails 3
+
+# Copyright (c) 2005-2009 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Retain for backward compatibility.  Methods are now included in Class.
+class Class
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def extlib_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) && !ivar.is_a?(TrueClass) && !ivar.is_a?(FalseClass) ? ivar.dup : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end unless Class.respond_to?(:extlib_inheritable_reader)
+
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def extlib_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end unless Class.respond_to?(:extlib_inheritable_writer)
+
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def extlib_inheritable_accessor(*syms)
+    extlib_inheritable_reader(*syms)
+    extlib_inheritable_writer(*syms)
+  end unless Class.respond_to?(:extlib_inheritable_accessor)
+end

data/lib/carrierwave/core_ext/module_setup.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+# Stolen from Rails 3
+
+# Copyright (c) 2005-2009 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+class Module
+  attr_accessor :_setup_block
+  attr_accessor :_dependencies
+  
+  def setup(&blk)
+    @_setup_block = blk
+  end
+  
+  def use(mod)
+    return if self < mod
+    
+    (mod._dependencies || []).each do |dep|
+      use dep
+    end
+    # raise "Circular dependencies" if self < mod
+    include mod
+    extend mod.const_get("ClassMethods") if mod.const_defined?("ClassMethods")
+    class_eval(&mod._setup_block) if mod._setup_block
+  end
+  
+  def depends_on(mod)
+    return if self < mod
+    @_dependencies ||= []
+    @_dependencies << mod
+  end
+end

data/lib/carrierwave/mount.rb

@@ -0,0 +1,359 @@
+# encoding: utf-8
+
+module CarrierWave
+
+  ##
+  # If a Class is extended with this module, it gains the mount_uploader
+  # method, which is used for mapping attributes to uploaders and allowing
+  # easy assignment.
+  #
+  # You can use mount_uploader with pretty much any class, however it is
+  # intended to be used with some kind of persistent storage, like an ORM.
+  # If you want to persist the uploaded files in a particular Class, it
+  # needs to implement a `read_uploader` and a `write_uploader` method.
+  #
+  module Mount
+
+    ##
+    # === Returns
+    #
+    # [Hash{Symbol => CarrierWave}] what uploaders are mounted on which columns
+    #
+    def uploaders
+      @uploaders ||= {}
+      @uploaders = superclass.uploaders.merge(@uploaders)
+    rescue NoMethodError
+      @uploaders
+    end
+
+    def uploader_options
+      @uploader_options ||= {}
+      @uploader_options = superclass.uploader_options.merge(@uploader_options)
+    rescue NoMethodError
+      @uploader_options
+    end
+
+    ##
+    # Return a particular option for a particular uploader
+    #
+    # === Parameters
+    #
+    # [column (Symbol)] The column the uploader is mounted at
+    # [option (Symbol)] The option, e.g. validate_integrity
+    #
+    # === Returns
+    #
+    # [Object] The option value
+    #
+    def uploader_option(column, option)
+      if uploader_options[column].has_key?(option)
+        uploader_options[column][option]
+      else
+        uploaders[column].send(option)
+      end
+    end
+
+    ##
+    # Mounts the given uploader on the given column. This means that assigning
+    # and reading from the column will upload and retrieve files. Supposing
+    # that a User class has an uploader mounted on image, you can assign and
+    # retrieve files like this:
+    #
+    #     @user.image # => <Uploader>
+    #     @user.image = some_file_object
+    #
+    #     @user.store_image!
+    #
+    #     @user.image.url # => '/some_url.png'
+    #
+    # It is also possible (but not recommended) to ommit the uploader, which
+    # will create an anonymous uploader class. Passing a block to this method
+    # makes it possible to customize it. This can be convenient for brevity,
+    # but if there is any significatnt logic in the uploader, you should do
+    # the right thing and have it in its own file.
+    #
+    # === Added instance methods
+    #
+    # Supposing a class has used +mount_uploader+ to mount an uploader on a column
+    # named +image+, in that case the following methods will be added to the class:
+    #
+    # [image]                   Returns an instance of the uploader only if anything has been uploaded
+    # [image=]                  Caches the given file
+    #
+    # [image_url]               Returns the url to the uploaded file
+    #
+    # [image_cache]             Returns a string that identifies the cache location of the file 
+    # [image_cache=]            Retrieves the file from the cache based on the given cache name
+    #
+    # [remote_image_url]        Returns previously cached remote url
+    # [remote_image_url=]       Retrieve the file from the remote url
+    #
+    # [remove_image]            An attribute reader that can be used with a checkbox to mark a file for removal
+    # [remove_image=]           An attribute writer that can be used with a checkbox to mark a file for removal
+    # [remove_image?]           Whether the file should be removed when store_image! is called.
+    #
+    # [store_image!]            Stores a file that has been assigned with +image=+
+    # [remove_image!]           Removes the uploaded file from the filesystem.
+    #
+    # [image_integrity_error]   Returns an error object if the last file to be assigned caused an integrity error
+    # [image_processing_error]  Returns an error object if the last file to be assigned caused a processing error
+    #
+    # [write_image_identifier]  Uses the write_uploader method to set the identifier.
+    #
+    # === Parameters
+    #
+    # [column (Symbol)]                   the attribute to mount this uploader on
+    # [uploader (CarrierWave::Uploader)]  the uploader class to mount
+    # [options (Hash{Symbol => Object})]  a set of options
+    # [&block (Proc)]                     customize anonymous uploaders
+    #
+    # === Options
+    # 
+    # [:mount_on => Symbol] if the name of the column to be serialized to differs you can override it using this option
+    # [:ignore_integrity_errors => Boolean] if set to true, integrity errors will result in caching failing silently
+    # [:ignore_processing_errors => Boolean] if set to true, processing errors will result in caching failing silently
+    #
+    # === Examples
+    #
+    # Mounting uploaders on different columns.
+    #
+    #     class Song
+    #       mount_uploader :lyrics, LyricsUploader
+    #       mount_uploader :alternative_lyrics, LyricsUploader
+    #       mount_uploader :file, SongUploader
+    #     end
+    #
+    # This will add an anonymous uploader with only the default settings:
+    #
+    #     class Data
+    #       mount_uploader :csv
+    #     end
+    #
+    # this will add an anonymous uploader overriding the store_dir:
+    #
+    #     class Product
+    #       mount_uploader :blueprint do
+    #         def store_dir
+    #           'blueprints'
+    #         end
+    #       end
+    #     end
+    #
+    def mount_uploader(column, uploader=nil, options={}, &block)
+      unless uploader
+        uploader = Class.new(CarrierWave::Uploader::Base)
+        uploader.class_eval(&block)
+      end
+
+      uploaders[column.to_sym] = uploader
+      uploader_options[column.to_sym] = options
+
+      include CarrierWave::Mount::Extension
+
+      # Make sure to write over accessors directly defined on the class.
+      # Simply super to the included module below.
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{column}; super; end
+        def #{column}=(new_file); super; end
+      RUBY
+
+      # Mixing this in as a Module instead of class_evaling directly, so we
+      # can maintain the ability to super to any of these methods from within
+      # the class.
+      mod = Module.new
+      include mod
+      mod.class_eval <<-RUBY, __FILE__, __LINE__+1
+
+        def #{column}
+          _mounter(:#{column}).uploader
+        end
+
+        def #{column}=(new_file)
+          _mounter(:#{column}).cache(new_file)
+        end
+
+        def #{column}?
+          !_mounter(:#{column}).blank?
+        end
+
+        def #{column}_url(*args)
+          _mounter(:#{column}).url(*args)
+        end
+
+        def #{column}_cache
+          _mounter(:#{column}).cache_name
+        end
+
+        def #{column}_cache=(cache_name)
+          _mounter(:#{column}).cache_name = cache_name
+        end
+
+        def remote_#{column}_url
+          _mounter(:#{column}).remote_url
+        end
+
+        def remote_#{column}_url=(url)
+          _mounter(:#{column}).remote_url = url
+        end
+
+        def remove_#{column}
+          _mounter(:#{column}).remove
+        end
+
+        def remove_#{column}!
+          _mounter(:#{column}).remove!
+        end
+
+        def remove_#{column}=(value)
+          _mounter(:#{column}).remove = value
+        end
+
+        def remove_#{column}?
+          _mounter(:#{column}).remove?
+        end
+
+        def store_#{column}!
+          _mounter(:#{column}).store!
+        end
+
+        def #{column}_integrity_error
+          _mounter(:#{column}).integrity_error
+        end
+
+        def #{column}_processing_error
+          _mounter(:#{column}).processing_error
+        end
+
+        def write_#{column}_identifier
+          _mounter(:#{column}).write_identifier
+        end
+
+      RUBY
+
+    end
+
+    module Extension
+
+      ##
+      # overwrite this to read from a serialized attribute
+      #
+      def read_uploader(column); end
+
+      ##
+      # overwrite this to write to a serialized attribute
+      #
+      def write_uploader(column, identifier); end
+
+    private
+
+      def _mounter(column)
+        # We cannot memoize in frozen objects :(
+        return Mounter.new(self, column) if frozen?
+        @_mounters ||= {}
+        @_mounters[column] ||= Mounter.new(self, column)
+      end
+
+    end # Extension
+
+    # this is an internal class, used by CarrierWave::Mount so that
+    # we don't pollute the model with a lot of methods.
+    class Mounter #:nodoc:
+
+      attr_reader :column, :record, :remote_url, :integrity_error, :processing_error
+      attr_accessor :remove
+
+      def initialize(record, column, options={})
+        @record = record
+        @column = column
+        @options = record.class.uploader_options[column]
+      end
+
+      def write_identifier
+        if remove?
+          record.write_uploader(serialization_column, '')
+        elsif not uploader.identifier.blank?
+          record.write_uploader(serialization_column, uploader.identifier)
+        end
+      end
+      
+      def identifier
+        record.read_uploader(serialization_column)
+      end
+
+      def uploader
+        @uploader ||= record.class.uploaders[column].new(record, column)
+
+        if @uploader.blank? and not identifier.blank?
+          @uploader.retrieve_from_store!(identifier)
+        end
+        return @uploader
+      end
+
+      def cache(new_file)
+        uploader.cache!(new_file)
+        @integrity_error = nil
+        @processing_error = nil
+      rescue CarrierWave::IntegrityError => e
+        @integrity_error = e
+        raise e unless option(:ignore_integrity_errors)
+      rescue CarrierWave::ProcessingError => e
+        @processing_error = e
+        raise e unless option(:ignore_processing_errors)
+      end
+
+      def cache_name
+        uploader.cache_name
+      end
+
+      def cache_name=(cache_name)
+        uploader.retrieve_from_cache!(cache_name) unless uploader.cached?
+      rescue CarrierWave::InvalidParameter
+      end
+
+      def remote_url=(url)
+        unless uploader.cached?
+          @remote_url = url
+          uploader.download!(url) 
+        end
+      end
+
+      def store!
+        unless uploader.blank?
+          if remove?
+            uploader.remove!
+          else
+            uploader.store!
+          end
+        end
+      end
+
+      def url(*args)
+        uploader.url(*args)
+      end
+
+      def blank?
+        uploader.blank?
+      end
+
+      def remove?
+        !remove.blank? and remove !~ /\A0|false$\z/
+      end
+
+      def remove!
+        uploader.remove!
+      end
+
+    private
+      
+      def option(name)
+        record.class.uploader_option(column, name)
+      end
+
+      def serialization_column
+        option(:mount_on) || column
+      end
+
+    end # Mounter
+
+  end # Mount
+end # CarrierWave