locomotive_carrierwave 0.5.0.1.beta1

data/lib/carrierwave/sanitized_file.rb

@@ -0,0 +1,306 @@
+# encoding: utf-8
+
+require 'pathname'
+
+module CarrierWave
+
+  ##
+  # SanitizedFile is a base class which provides a common API around all
+  # the different quirky Ruby File libraries. It has support for Tempfile,
+  # File, StringIO, Merb-style upload Hashes, as well as paths given as
+  # Strings and Pathnames.
+  #
+  # It's probably needlessly comprehensive and complex. Help is appreciated.
+  #
+  class SanitizedFile
+
+    attr_accessor :file
+
+    def initialize(file)
+      self.file = file
+    end
+
+    ##
+    # Returns the filename as is, without sanizting it.
+    #
+    # === Returns
+    #
+    # [String] the unsanitized filename
+    #
+    def original_filename
+      return @original_filename if @original_filename
+      if @file and @file.respond_to?(:original_filename)
+        @file.original_filename
+      elsif path
+        File.basename(path)
+      end
+    end
+
+    ##
+    # Returns the filename, sanitized to strip out any evil characters.
+    #
+    # === Returns
+    #
+    # [String] the sanitized filename
+    #
+    def filename
+      sanitize(original_filename) if original_filename
+    end
+
+    alias_method :identifier, :filename
+
+    ##
+    # Returns the part of the filename before the extension. So if a file is called 'test.jpeg'
+    # this would return 'test'
+    #
+    # === Returns
+    #
+    # [String] the first part of the filename
+    #
+    def basename
+      split_extension(filename)[0] if filename
+    end
+
+    ##
+    # Returns the file extension
+    #
+    # === Returns
+    #
+    # [String] the extension
+    #
+    def extension
+      split_extension(filename)[1] if filename
+    end
+
+    ##
+    # Returns the file's size.
+    #
+    # === Returns
+    #
+    # [Integer] the file's size in bytes.
+    #
+    def size
+      if is_path?
+        exists? ? File.size(path) : 0
+      elsif @file.respond_to?(:size)
+        @file.size
+      elsif path
+        exists? ? File.size(path) : 0
+      else
+        0
+      end
+    end
+
+    ##
+    # Returns the full path to the file. If the file has no path, it will return nil.
+    #
+    # === Returns
+    #
+    # [String, nil] the path where the file is located.
+    #
+    def path
+      unless @file.blank?
+        if is_path?
+          File.expand_path(@file)
+        elsif @file.respond_to?(:path) and not @file.path.blank?
+          File.expand_path(@file.path)
+        end
+      end
+    end
+
+    ##
+    # === Returns
+    #
+    # [Boolean] whether the file is supplied as a pathname or string.
+    #
+    def is_path?
+      !!((@file.is_a?(String) || @file.is_a?(Pathname)) && !@file.blank?)
+    end
+
+    ##
+    # === Returns
+    #
+    # [Boolean] whether the file is valid and has a non-zero size
+    #
+    def empty?
+      @file.nil? || self.size.nil? || self.size.zero?
+    end
+
+    alias_method :blank?, :empty?
+
+    ##
+    # === Returns
+    #
+    # [Boolean] Whether the file exists
+    #
+    def exists?
+      return File.exists?(self.path) if self.path
+      return false
+    end
+
+    ##
+    # Returns the contents of the file.
+    #
+    # === Returns
+    #
+    # [String] contents of the file
+    #
+    def read
+      if is_path?
+        File.open(@file, "rb").read
+      else
+        @file.rewind if @file.respond_to?(:rewind)
+        @file.read
+      end
+    end
+
+    ##
+    # Moves the file to the given path
+    #
+    # === Parameters
+    #
+    # [new_path (String)] The path where the file should be moved.
+    # [permissions (Integer)] permissions to set on the file in its new location.
+    #
+    def move_to(new_path, permissions=nil)
+      return if self.empty?
+      new_path = File.expand_path(new_path)
+
+      mkdir!(new_path)
+      if exists?
+        FileUtils.mv(path, new_path) unless new_path == path
+      else
+        File.open(new_path, "wb") { |f| f.write(read) }
+      end
+      chmod!(new_path, permissions)
+      self.file = new_path
+    end
+
+    ##
+    # Creates a copy of this file and moves it to the given path. Returns the copy.
+    #
+    # === Parameters
+    #
+    # [new_path (String)] The path where the file should be copied to.
+    # [permissions (Integer)] permissions to set on the copy
+    #
+    # === Returns
+    #
+    # @return [CarrierWave::SanitizedFile] the location where the file will be stored.
+    #
+    def copy_to(new_path, permissions=nil)
+      return if self.empty?
+      new_path = File.expand_path(new_path)
+
+      mkdir!(new_path)
+      if exists?
+        FileUtils.cp(path, new_path) unless new_path == path
+      else
+        File.open(new_path, "wb") { |f| f.write(read) }
+      end
+      chmod!(new_path, permissions)
+      self.class.new({:tempfile => new_path, :content_type => content_type})
+    end
+
+    # ##
+    # # Rename this move. Returns the a copy of the file
+    # #
+    # # === Parameters
+    # #
+    # # [new_path (String)] The path where the file should be copied to.
+    # # [permissions (Integer)] permissions to set on the copy
+    # #
+    # # === Returns
+    # #
+    # # @return [CarrierWave::SanitizedFile] the location where the file will be stored.
+    # #
+    # def rename(new_path, permissions=nil)
+    #   f = self.copy_to(new_path, permissions=nil)
+    #   self.delete
+    #   f
+    # end
+
+    ##
+    # Removes the file from the filesystem.
+    #
+    def delete
+      FileUtils.rm(self.path) if exists?
+    end
+
+    # ##
+    # # Rename the file in the filesystem
+    # #
+    # def rename(new_path, permissions=nil)
+    #   return if self.empty?
+    #   new_path = File.expand_path(new_path)
+    #
+    #   mkdir!(new_path)
+    #   if exists?
+    #     FileUtils.mv(path, new_path) unless new_path == path
+    #   end
+    #   chmod!(new_path, permissions)
+    #   self.file = new_path
+    # end
+
+    ##
+    # Returns the content type of the file.
+    #
+    # === Returns
+    #
+    # [String] the content type of the file
+    #
+    def content_type
+      return @content_type if @content_type
+      @file.content_type.chomp if @file.respond_to?(:content_type) and @file.content_type
+    end
+
+  private
+
+    def file=(file)
+      if file.is_a?(Hash)
+        @file = file["tempfile"] || file[:tempfile]
+        @original_filename = file["filename"] || file[:filename]
+        @content_type = file["content_type"] || file[:content_type]
+      else
+        @file = file
+        @original_filename = nil
+        @content_type = nil
+      end
+    end
+
+    # create the directory if it doesn't exist
+    def mkdir!(path)
+      FileUtils.mkdir_p(File.dirname(path)) unless File.exists?(File.dirname(path))
+    end
+
+    def chmod!(path, permissions)
+      File.chmod(permissions, path) if permissions
+    end
+
+    # Sanitize the filename, to prevent hacking
+    def sanitize(name)
+      name = name.gsub("\\", "/") # work-around for IE
+      name = File.basename(name)
+      name = name.gsub(/[^a-zA-Z0-9\.\-\+_]/,"_")
+      name = "_#{name}" if name =~ /\A\.+\z/
+      name = "unnamed" if name.size == 0
+      return name.downcase
+    end
+
+    def split_extension(filename)
+      # regular expressions to try for identifying extensions
+      extension_matchers = [
+        /\A(.+)\.(tar\.gz)\z/, # matches "something.tar.gz"
+        /\A(.+)\.([^\.]+)\z/ # matches "something.jpg"
+      ]
+
+      extension_matchers.each do |regexp|
+        if filename =~ regexp
+          return $1, $2
+        end
+      end
+      return filename, "" # In case we weren't able to split the extension
+    end
+
+  end # SanitizedFile
+end # CarrierWave

data/lib/carrierwave/storage/abstract.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Storage
+
+    ##
+    # This file serves mostly as a specification for Storage engines. There is no requirement
+    # that storage engines must be a subclass of this class.
+    #
+    class Abstract
+
+      attr_reader :uploader
+
+      def initialize(uploader)
+        @uploader = uploader
+      end
+
+      def identifier
+        uploader.filename
+      end
+
+      def store!(file)
+      end
+
+      def retrieve!(identifier)
+      end
+
+      def rename!(file)
+      end
+
+    end # Abstract
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/cloud_files.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+require 'cloudfiles'
+
+module CarrierWave
+  module Storage
+
+    ##
+    # Uploads things to Rackspace Cloud Files webservices using the Rackspace libraries (cloudfiles gem). 
+    # In order for CarrierWave to connect to Cloud Files, you'll need to specify an username, api key
+    # and container
+    #
+    #     CarrierWave.configure do |config|
+    #       config.cloud_files_username = "xxxxxx"
+    #       config.cloud_files_api_key = "xxxxxx"
+    #       config.cloud_files_container = "my_container"
+    #     end
+    #
+    # You can optionally include your CDN host name in the configuration.
+    # This is *highly* recommended, as without it every request requires a lookup
+    # of this information.
+    #
+    #   config.cloud_files_cdn_host = "c000000.cdn.rackspacecloud.com"
+    #
+    #
+    class CloudFiles < Abstract
+
+      class File
+
+        def initialize(uploader, base, path)
+          @uploader = uploader
+          @path = path
+          @base = base
+        end
+
+        ##
+        # Returns the current path/filename of the file on Cloud Files. 
+        #
+        # === Returns
+        #
+        # [String] A path
+        #
+        def path
+          @path
+        end
+
+        ##
+        # Reads the contents of the file from Cloud Files
+        #
+        # === Returns
+        #
+        # [String] contents of the file
+        #
+        def read
+          object = cf_container.object(@path)
+          @content_type = object.content_type
+          object.data
+        end
+
+        ##
+        # Remove the file from Cloud Files
+        #
+        def delete
+          cf_container.delete_object(@path)
+        end
+
+        ##
+        # Returns the url on the Cloud Files CDN.  Note that the parent container must be marked as
+        # public for this to work.
+        #
+        # === Returns
+        #
+        # [String] file's url
+        #
+        def url
+          if @uploader.cloud_files_cdn_host
+            "http://" + @uploader.cloud_files_cdn_host + "/" + @path
+          else
+            cf_container.object(@path).public_url
+          end
+        end
+
+        def content_type
+          cf_container.object(@path).content_type
+        end
+
+        def content_type=(new_content_type)
+          headers["content-type"] = new_content_type
+        end
+
+        ##
+        # Writes the supplied data into the object on Cloud Files.
+        #
+        # === Returns
+        #
+        # boolean
+        #
+        def store(data,headers={})
+          object = cf_container.create_object(@path)
+          object.write(data,headers)
+        end
+
+        private
+
+          def headers
+            @headers ||= {  }
+          end
+
+          def container
+            @uploader.cloud_files_container
+          end
+
+          def connection
+            @base.connection
+          end
+          
+          def cf_connection
+            @cf_connection ||= ::CloudFiles::Connection.new(@uploader.cloud_files_username, @uploader.cloud_files_api_key)
+          end
+
+          def cf_container
+            if @cf_container
+              @cf_container
+            else
+              @cf_container = cf_connection.create_container(container)
+              @cf_container.make_public
+              @cf_container
+            end
+          end
+          
+
+      end
+
+      ##
+      # Store the file on Cloud Files
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::CloudFiles::File] the stored file
+      #
+      def store!(file)
+        cloud_files_options = {'Content-Type' => file.content_type}
+        f = CarrierWave::Storage::CloudFiles::File.new(uploader, self, uploader.store_path)
+        f.store(file.read,cloud_files_options)
+        f
+      end
+
+      # Do something to retrieve the file
+      #
+      # @param [String] identifier uniquely identifies the file
+      #
+      # [identifier (String)] uniquely identifies the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::CloudFiles::File] the stored file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::CloudFiles::File.new(uploader, self, uploader.store_path(identifier))
+      end
+
+
+    end # CloudFiles
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/file.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Storage
+
+    ##
+    # File storage stores file to the Filesystem (surprising, no?). There's really not much
+    # to it, it uses the store_dir defined on the uploader as the storage location. That's
+    # pretty much it.
+    #
+    class File < Abstract
+
+      ##
+      # Move the file to the uploader's store path.
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def store!(file)
+        path = ::File.expand_path(uploader.store_path, uploader.root)
+        file.move_to(path, uploader.permissions)
+        file
+      end
+
+      ##
+      # Retrieve the file from its store path
+      #
+      # === Parameters
+      #
+      # [identifier (String)] the filename of the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def retrieve!(identifier)
+        path = ::File.expand_path(uploader.store_path(identifier), uploader.root)
+        CarrierWave::SanitizedFile.new(path)
+      end
+
+      def rename!(file)
+        path = ::File.expand_path(uploader.store_path, uploader.root)
+        file.move_to(path, uploader.permissions)
+        file
+      end
+
+    end # File
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/grid_fs.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+require 'mongo'
+
+module CarrierWave
+  module Storage
+
+    ##
+    # The GridFS store uses MongoDB's GridStore file storage system to store files
+    #
+    # There are two ways of configuring the GridFS connection. Either you create a
+    # connection or you reuse an existing connection.
+    #
+    # Creating a connection looks something like this:
+    # 
+    #     CarrierWave.configure do |config|
+    #       config.storage = :grid_fs
+    #       config.grid_fs_host = "your-host.com"
+    #       config.grid_fs_port = "27017"
+    #       config.grid_fs_database = "your_dbs_app_name"
+    #       config.grid_fs_username = "user"
+    #       config.grid_fs_password = "verysecret"
+    #       config.grid_fs_access_url = "/images"
+    #     end
+    #
+    #   In the above example your documents url will look like:
+    #   
+    #      http://your-app.com/images/:document-identifier-here
+    #
+    # When you already have a Mongo connection object (for example through Mongoid)
+    # you can also reuse this connection:
+    #
+    #     CarrierWave.configure do |config|
+    #       config.storage = :grid_fs
+    #       config.grid_fs_connection = Mongoid.database
+    #       config.grid_fs_access_url = "/images"
+    #     end
+    #
+    class GridFS < Abstract
+
+      class File
+
+        def initialize(uploader, path)
+          @path = path
+          @uploader = uploader
+        end
+
+        def path
+          nil
+        end
+
+        def url
+          unless @uploader.grid_fs_access_url
+            nil
+          else
+            [@uploader.grid_fs_access_url, @path].join("/")
+          end
+        end
+
+        def read
+          grid.open(@path, 'r').data
+        end
+
+        def write(file)
+          grid.open(@uploader.store_path, 'w', :content_type => file.content_type) do |f| 
+            f.write(file.read)
+          end
+        end
+
+        def delete
+          grid.delete(@path)
+        end
+
+        def content_type
+          grid.open(@path, 'r').content_type
+        end
+        
+        def file_length
+          grid.open(@path, 'r').file_length
+        end
+
+      protected
+
+        def database
+          @connection ||= @uploader.grid_fs_connection || begin
+            host = @uploader.grid_fs_host
+            port = @uploader.grid_fs_port
+            database = @uploader.grid_fs_database
+            username = @uploader.grid_fs_username
+            password = @uploader.grid_fs_password
+            db = Mongo::Connection.new(host, port).db(database)
+            db.authenticate(username, password) if username && password
+            db
+          end
+        end
+        
+        def grid
+          @grid ||= Mongo::GridFileSystem.new(database)
+        end
+
+      end
+
+      ##
+      # Store the file in MongoDB's GridFS GridStore
+      #
+      # === Parameters
+      #
+      # [file (CarrierWave::SanitizedFile)] the file to store
+      #
+      # === Returns
+      #
+      # [CarrierWave::SanitizedFile] a sanitized file
+      #
+      def store!(file)
+        stored = CarrierWave::Storage::GridFS::File.new(uploader, uploader.store_path)
+        stored.write(file)
+        stored
+      end
+
+      ##
+      # Retrieve the file from MongoDB's GridFS GridStore
+      #
+      # === Parameters
+      #
+      # [identifier (String)] the filename of the file
+      #
+      # === Returns
+      #
+      # [CarrierWave::Storage::GridFS::File] a sanitized file
+      #
+      def retrieve!(identifier)
+        CarrierWave::Storage::GridFS::File.new(uploader, uploader.store_path(identifier))
+      end
+
+    end # File
+  end # Storage
+end # CarrierWave

data/lib/carrierwave/storage/right_s3.rb

@@ -0,0 +1 @@
+raise "The right_aws library is no longer supported. Please install the 'fog' gem instead."