jnicklas-carrierwave 0.2.2 → 0.2.3

data/lib/carrierwave/uploader/store.rb

@@ -0,0 +1,154 @@
+module CarrierWave
+  module Uploader
+    module Store
+
+      depends_on CarrierWave::Uploader::Paths
+      depends_on CarrierWave::Uploader::Callbacks
+      depends_on CarrierWave::Uploader::Cache
+
+      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.config[: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 = get_storage_by_symbol(storage)
+            @storage.setup!
+          elsif storage
+            @storage = storage
+            @storage.setup!
+          elsif @storage.nil?
+            # Get the storage from the superclass if there is one
+            @storage = superclass.storage rescue nil
+          end
+          if @storage.nil?
+            # If we were not able to find a store any other way, setup the default store
+            @storage ||= get_storage_by_symbol(CarrierWave.config[:storage])
+            @storage.setup!
+          end
+          return @storage
+        end
+
+        alias_method :storage=, :storage
+
+      private
+
+        def get_storage_by_symbol(symbol)
+          eval(CarrierWave.config[:storage_engines][symbol])
+        end
+
+      end
+
+      ##
+      # 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
+
+      ##
+      # Override this in your Uploader to change the directory where the file backend stores files.
+      #
+      # Other backends may or may not use this method, depending on their specific needs.
+      #
+      # === Returns
+      #
+      # [String] a directory
+      #
+      def store_dir
+        CarrierWave.config[:store_dir]
+      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))
+      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!(self, @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!(self, identifier)
+        end
+      end
+
+    private
+
+      def full_filename(for_file)
+        for_file
+      end
+
+      def storage
+        self.class.storage
+      end
+
+    end # Store
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/url.rb

@@ -0,0 +1,22 @@
+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(public), '')
+        end
+      end
+
+      alias_method :to_s, :url
+
+    end # Url
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/versions.rb

@@ -0,0 +1,145 @@
+module CarrierWave
+  module Uploader
+    module Versions
+
+      setup do
+        after :cache, :cache_versions!
+        after :store, :store_versions!
+        after :remove, :remove_versions!
+        after :retrieve_from_cache, :retrieve_versions_from_cache!
+        after :retrieve_from_store, :retrieve_versions_from_store!
+      end
+
+      module ClassMethods
+
+        def version_names
+          @version_names ||= []
+        end
+
+        ##
+        # Adds a new version to this uploader
+        #
+        # === Parameters
+        #
+        # [name (#to_sym)] name of the version
+        # [&block (Proc)] a block to eval on this version of the uploader
+        #
+        def version(name, &block)
+          name = name.to_sym
+          unless versions[name]
+            versions[name] = Class.new(self)
+            versions[name].version_names.push(*version_names)
+            versions[name].version_names.push(name)
+            class_eval <<-RUBY
+              def #{name}
+                versions[:#{name}]
+              end
+            RUBY
+          end
+          versions[name].class_eval(&block) if block
+          versions[name]
+        end
+
+        ##
+        # === Returns
+        #
+        # [Hash{Symbol => Class}] a list of versions available for this uploader
+        #
+        def versions
+          @versions ||= {}
+        end
+
+      end # ClassMethods
+
+      ##
+      # Returns a hash mapping the name of each version of the uploader to an instance of it
+      #
+      # === Returns
+      #
+      # [Hash{Symbol => CarrierWave::Uploader}] a list of uploader instances
+      #
+      def versions
+        return @versions if @versions
+        @versions = {}
+        self.class.versions.each do |name, klass|
+          @versions[name] = klass.new(model, mounted_as)
+        end
+        @versions
+      end
+
+      ##
+      # === Returns
+      #
+      # [String] the name of this version of the uploader
+      #
+      def version_name
+        self.class.version_names.join('_').to_sym unless self.class.version_names.blank?
+      end
+
+      ##
+      # When given a version name as a parameter, will return the url for that version
+      # This also works with nested versions.
+      #
+      # === Example
+      #
+      #     my_uploader.url                 # => /path/to/my/uploader.gif
+      #     my_uploader.url(:thumb)         # => /path/to/my/thumb_uploader.gif
+      #     my_uploader.url(:thumb, :small) # => /path/to/my/thumb_small_uploader.gif
+      #
+      # === Parameters
+      #
+      # [*args (Symbol)] any number of versions
+      #
+      # === Returns
+      #
+      # [String] the location where this file is accessible via a url
+      #
+      def url(*args)
+        if(args.first)
+          raise ArgumentError, "Version #{args.first} doesn't exist!" if versions[args.first.to_sym].nil?
+          # recursively proxy to version
+          versions[args.first.to_sym].url(*args[1..-1])
+        else
+          super()
+        end
+      end
+
+    private
+
+      def full_filename(for_file)
+        [version_name, super(for_file)].compact.join('_')
+      end
+
+      def full_original_filename
+        [version_name, super].compact.join('_')
+      end
+
+      def cache_versions!(new_file)
+        versions.each do |name, v|
+          v.send(:cache_id=, cache_id)
+          v.cache!(new_file)
+        end
+      end
+
+      def store_versions!(new_file)
+        versions.each { |name, v| v.store!(new_file) }
+      end
+
+      def remove_versions!
+        versions.each do |name, v|
+          CarrierWave.logger.info "CarrierWave: removing file for version #{v.version_name}"
+          v.remove!
+        end
+      end
+
+      def retrieve_versions_from_cache!(cache_name)
+        versions.each { |name, v| v.retrieve_from_cache!(cache_name) }
+      end
+
+      def retrieve_versions_from_store!(identifier)
+        versions.each { |name, v| v.retrieve_from_store!(identifier) }
+      end
+
+    end # Versions
+  end # Uploader
+end # CarrierWave