refile 0.4.2 → 0.5.0

data/lib/refile/app.rb

@@ -3,6 +3,17 @@ require "sinatra/base"
 require "tempfile"
 
 module Refile
+  # A Rack application which can be mounted or run on its own.
+  #
+  # @example mounted in Rails
+  #   Rails.application.routes.draw do
+  #     mount Refile::App.new, at: "attachments", as: :refile_app
+  #   end
+  #
+  # @example as standalone app
+  #   require "refile"
+  #
+  #   run Refile::App.new
   class App < Sinatra::Base
     configure do
       set :show_exceptions, false
@@ -10,10 +21,10 @@ module Refile
       set :sessions, false
       set :logging, false
       set :dump_errors, false
+      use CustomLogger, "Refile::App", proc { Refile.logger }
     end
 
     before do
-      content_type ::File.extname(request.path), default: "application/octet-stream"
       if Refile.allow_origin
         response["Access-Control-Allow-Origin"] = Refile.allow_origin
         response["Access-Control-Allow-Headers"] = request.env["HTTP_ACCESS_CONTROL_REQUEST_HEADERS"].to_s
@@ -22,27 +33,22 @@ module Refile
     end
 
     get "/:backend/:id/:filename" do
-      set_expires_header
       stream_file file
     end
 
     get "/:backend/:processor/:id/:file_basename.:extension" do
-      set_expires_header
       stream_file processor.call(file, format: params[:extension])
     end
 
     get "/:backend/:processor/:id/:filename" do
-      set_expires_header
       stream_file processor.call(file)
     end
 
     get "/:backend/:processor/*/:id/:file_basename.:extension" do
-      set_expires_header
       stream_file processor.call(file, *params[:splat].first.split("/"), format: params[:extension])
     end
 
     get "/:backend/:processor/*/:id/:filename" do
-      set_expires_header
       stream_file processor.call(file, *params[:splat].first.split("/"))
     end
 
@@ -51,8 +57,7 @@ module Refile
     end
 
     post "/:backend" do
-      backend = Refile.backends[params[:backend]]
-      halt 404 unless backend && Refile.direct_upload.include?(params[:backend])
+      halt 404 unless Refile.direct_upload.include?(params[:backend])
       tempfile = request.params.fetch("file").fetch(:tempfile)
       file = backend.upload(tempfile)
       content_type :json
@@ -75,15 +80,13 @@ module Refile
 
   private
 
-    def set_expires_header
-      expires Refile.content_max_age, :public, :must_revalidate
-    end
-
     def logger
       Refile.logger
     end
 
     def stream_file(file)
+      expires Refile.content_max_age, :public, :must_revalidate
+
       if file.respond_to?(:path)
         path = file.path
       else

data/lib/refile/attacher.rb

@@ -1,9 +1,13 @@
+require "open-uri"
+
 module Refile
   # @api private
   class Attacher
-    attr_reader :record, :name, :cache, :store, :cache_id, :options, :errors, :type, :extensions, :content_types
+    attr_reader :record, :name, :cache, :store, :options, :errors, :type, :valid_extensions, :valid_content_types
     attr_accessor :remove
 
+    Presence = ->(val) { val if val != "" }
+
     def initialize(record, name, cache:, store:, raise_errors: true, type: nil, extension: nil, content_type: nil)
       @record = record
       @name = name
@@ -11,105 +15,171 @@ module Refile
       @cache = Refile.backends.fetch(cache.to_s)
       @store = Refile.backends.fetch(store.to_s)
       @type = type
-      @extensions = [extension].flatten if extension
-      @content_types = [content_type].flatten if content_type
-      @content_types ||= %w[image/jpeg image/gif image/png] if type == :image
+      @valid_extensions = [extension].flatten if extension
+      @valid_content_types = [content_type].flatten if content_type
+      @valid_content_types ||= Refile.types.fetch(type).content_type if type
       @errors = []
+      @metadata = {}
     end
 
     def id
-      record.send(:"#{name}_id")
+      Presence[read(:id)]
     end
 
-    def id=(id)
-      record.send(:"#{name}_id=", id) unless record.frozen?
+    def size
+      Presence[@metadata[:size] || read(:size)]
+    end
+
+    def filename
+      Presence[@metadata[:filename] || read(:filename)]
+    end
+
+    def content_type
+      Presence[@metadata[:content_type] || read(:content_type)]
+    end
+
+    def cache_id
+      Presence[@metadata[:id]]
+    end
+
+    def basename
+      if filename and extension
+        ::File.basename(filename, "." << extension)
+      else
+        filename
+      end
+    end
+
+    def extension
+      if filename
+        Presence[::File.extname(filename).sub(/^\./, "")]
+      elsif content_type
+        type = MIME::Types[content_type][0]
+        type.extensions[0] if type
+      end
     end
 
     def get
-      if cached?
+      if cache_id
         cache.get(cache_id)
-      elsif id and not id == ""
+      elsif id
         store.get(id)
       end
     end
 
-    def valid?(uploadable)
-      @errors = []
-      @errors << :invalid_extension if @extensions and not valid_extension?(uploadable)
-      @errors << :invalid_content_type if @content_types and not valid_content_type?(uploadable)
-      @errors << :too_large if cache.max_size and uploadable.size >= cache.max_size
-      @errors.empty?
+    def set(value)
+      if value.is_a?(String)
+        retrieve!(value)
+      else
+        cache!(value)
+      end
+    end
+
+    def retrieve!(value)
+      @metadata = JSON.parse(value, symbolize_names: true) || {}
+      write_metadata if cache_id
+    rescue JSON::ParserError
     end
 
     def cache!(uploadable)
-      if valid?(uploadable)
-        @cache_file = cache.upload(uploadable)
-        @cache_id = @cache_file.id
+      @metadata = {
+        size: uploadable.size,
+        content_type: Refile.extract_content_type(uploadable),
+        filename: Refile.extract_filename(uploadable)
+      }
+      if valid?
+        @metadata[:id] = cache.upload(uploadable).id
+        write_metadata
       elsif @raise_errors
         raise Refile::Invalid, @errors.join(", ")
       end
     end
 
     def download(url)
-      if url and not url == ""
-        cache!(RestClient::Request.new(method: :get, url: url, raw_response: true).execute.file)
+      unless url.to_s.empty?
+        file = open(url)
+        @metadata = {
+          size: file.meta["content-length"].to_i,
+          filename: ::File.basename(file.base_uri.path),
+          content_type: file.meta["content-type"]
+        }
+        if valid?
+          @metadata[:id] = cache.upload(file).id
+          write_metadata
+        elsif @raise_errors
+          raise Refile::Invalid, @errors.join(", ")
+        end
       end
-    rescue RestClient::Exception
+    rescue OpenURI::HTTPError, RuntimeError => error
+      raise if error.is_a?(RuntimeError) and error.message !~ /redirection loop/
       @errors = [:download_failed]
       raise if @raise_errors
     end
 
-    def cache_id=(id)
-      @cache_id = id unless @cache_file
-    end
-
     def store!
       if remove?
         delete!
-      elsif cached?
-        file = store.upload(cache.get(cache_id))
+        write(:id, nil)
+      elsif cache_id
+        file = store.upload(get)
         delete!
-        self.id = file.id
+        write(:id, file.id)
       end
+      write_metadata
+      @metadata = {}
     end
 
     def delete!
-      if cached?
-        cache.delete(cache_id)
-        @cache_id = nil
-        @cache_file = nil
-      end
+      cache.delete(cache_id) if cache_id
       store.delete(id) if id
-      self.id = nil
+      @metadata = {}
+    end
+
+    def accept
+      if valid_content_types
+        valid_content_types.join(",")
+      elsif valid_extensions
+        valid_extensions.map { |e| ".#{e}" }.join(",")
+      end
     end
 
     def remove?
       remove and remove != "" and remove !~ /\A0|false$\z/
     end
 
-    def accept
-      if content_types
-        content_types.join(",")
-      elsif extensions
-        extensions.map { |e| ".#{e}" }.join(",")
-      end
+    def present?
+      id or not @metadata.empty?
+    end
+
+    def valid?
+      @errors = []
+      @errors << :invalid_extension if valid_extensions and not valid_extensions.include?(extension)
+      @errors << :invalid_content_type if valid_content_types and not valid_content_types.include?(content_type)
+      @errors << :too_large if cache.max_size and size and size >= cache.max_size
+      @errors.empty?
+    end
+
+    def data
+      @metadata if valid?
     end
 
   private
 
-    def valid_content_type?(uploadable)
-      content_type = Refile.extract_content_type(uploadable) or return false
-      @content_types.include?(content_type)
+    def read(column)
+      m = "#{name}_#{column}"
+      value ||= record.send(m) if record.respond_to?(m)
+      value
     end
 
-    def valid_extension?(uploadable)
-      filename = Refile.extract_filename(uploadable) or return false
-      extension = ::File.extname(filename).sub(/^\./, "")
-      @extensions.include?(extension)
+    def write(column, value)
+      m = "#{name}_#{column}="
+      record.send(m, value) if record.respond_to?(m) and not record.frozen?
     end
 
-    def cached?
-      cache_id and not cache_id == ""
+    def write_metadata
+      write(:size, size)
+      write(:content_type, content_type)
+      write(:filename, filename)
     end
   end
 end

data/lib/refile/attachment.rb

@@ -4,20 +4,38 @@ module Refile
     # possible to upload and retrieve previously uploaded files through the
     # generated accessors.
     #
-    # The +raise_errors+ option controls whether assigning an invalid file
+    # The `raise_errors` option controls whether assigning an invalid file
     # should immediately raise an error, or save the error and defer handling
     # it until later.
     #
+    # Given a record with an attachment named `image`, the following methods
+    # will be added:
+    #
+    # - `image`
+    # - `image=`
+    # - `remove_image`
+    # - `remove_image=`
+    # - `remote_image_url`
+    # - `remote_image_url=`
+    #
+    # @example
+    #   class User
+    #     extends Refile::Attachment
+    #
+    #     attachment :image
+    #     attr_accessor :image_id
+    #   end
+    #
     # @param [String] name                              Name of the column which accessor are generated for
-    # @param [#to_s] cache                              Name of a backend in +Refile.backends+ to use as transient cache
-    # @param [#to_s] store                              Name of a backend in +Refile.backends+ to use as permanent store
+    # @param [#to_s] cache                              Name of a backend in {Refile.backends} to use as transient cache
+    # @param [#to_s] store                              Name of a backend in {Refile.backends} to use as permanent store
     # @param [true, false] raise_errors                 Whether to raise errors in case an invalid file is assigned
-    # @param [:image, nil] type                         The type of file that can be uploaded, currently +:image+ is the
-    #                                                   only valid value and restricts uploads to JPEG, PNG and GIF images
+    # @param [Symbol, nil] type                         The type of file that can be uploaded, see {Refile.types}
     # @param [String, Array<String>, nil] extension     Limit the uploaded file to the given extension or list of extensions
     # @param [String, Array<String>, nil] content_type  Limit the uploaded file to the given content type or list of content types
+    # @return [void]
     # @ignore
-    #   rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    #   rubocop:disable Metrics/MethodLength
     def attachment(name, cache: :cache, store: :store, raise_errors: true, type: nil, extension: nil, content_type: nil)
       mod = Module.new do
         attacher = :"#{name}_attacher"
@@ -36,22 +54,14 @@ module Refile
           end
         end
 
-        define_method "#{name}=" do |uploadable|
-          send(attacher).cache!(uploadable)
+        define_method "#{name}=" do |value|
+          send(attacher).set(value)
         end
 
         define_method name do
           send(attacher).get
         end
 
-        define_method "#{name}_cache_id=" do |cache_id|
-          send(attacher).cache_id = cache_id
-        end
-
-        define_method "#{name}_cache_id" do
-          send(attacher).cache_id
-        end
-
         define_method "remove_#{name}=" do |remove|
           send(attacher).remove = remove
         end
@@ -66,6 +76,9 @@ module Refile
 
         define_method "remote_#{name}_url" do
         end
+
+        define_singleton_method("to_s")    { "Refile::Attachment(#{name})" }
+        define_singleton_method("inspect") { "Refile::Attachment(#{name})" }
       end
 
       include mod

data/lib/refile/attachment/active_record.rb

@@ -12,8 +12,11 @@ module Refile
         attacher = "#{name}_attacher"
 
         validate do
-          errors = send(attacher).errors
-          self.errors.add(name, *errors) unless errors.empty?
+          if send(attacher).present?
+            send(attacher).valid?
+            errors = send(attacher).errors
+            self.errors.add(name, *errors) unless errors.empty?
+          end
         end
 
         before_save do

data/lib/refile/backend/file_system.rb

@@ -1,8 +1,23 @@
 module Refile
   module Backend
+    # A backend which stores uploaded files in the local filesystem
+    #
+    # @example
+    #   backend = Refile::Backend::FileSystem.new("some/path")
+    #   file = backend.upload(StringIO.new("hello"))
+    #   backend.read(file.id) # => "hello"
     class FileSystem
-      attr_reader :directory, :max_size
+      # @return [String] the directory where files are stored
+      attr_reader :directory
 
+      # @return [String] the maximum size of files stored in this backend
+      attr_reader :max_size
+
+      # Creates the given directory if it doesn't exist.
+      #
+      # @param [String] directory         The path to a directory where files should be stored
+      # @param [Integer, nil] max_size    The maximum size of an uploaded file
+      # @param [#hash] hasher             A hasher which is used to generate ids from files
       def initialize(directory, max_size: nil, hasher: Refile::RandomHasher.new)
         @hasher = hasher
         @directory = directory
@@ -11,6 +26,10 @@ module Refile
         FileUtils.mkdir_p(@directory)
       end
 
+      # Upload a file into this backend
+      #
+      # @param [IO] uploadable      An uploadable IO-like object.
+      # @return [Refile::File]      The uploaded file
       def upload(uploadable)
         Refile.verify_uploadable(uploadable, @max_size)
 
@@ -20,36 +39,77 @@ module Refile
         Refile::File.new(self, id)
       end
 
+      # Get a file from this backend.
+      #
+      # Note that this method will always return a {Refile::File} object, even
+      # if a file with the given id does not exist in this backend. Use
+      # {FileSystem#exists?} to check if the file actually exists.
+      #
+      # @param [Sring] id           The id of the file
+      # @return [Refile::File]      The retrieved file
       def get(id)
         Refile::File.new(self, id)
       end
 
+      # Delete a file from this backend
+      #
+      # @param [Sring] id           The id of the file
+      # @return [void]
       def delete(id)
         FileUtils.rm(path(id)) if exists?(id)
       end
 
+      # Return an IO object for the uploaded file which can be used to read its
+      # content.
+      #
+      # @param [Sring] id           The id of the file
+      # @return [IO]                An IO object containing the file contents
       def open(id)
         ::File.open(path(id), "rb")
       end
 
+      # Return the entire contents of the uploaded file as a String.
+      #
+      # @param [Sring] id           The id of the file
+      # @return [String]            The file's contents
       def read(id)
         ::File.read(path(id)) if exists?(id)
       end
 
+      # Return the size in bytes of the uploaded file.
+      #
+      # @param [Sring] id           The id of the file
+      # @return [Integer]           The file's size
       def size(id)
         ::File.size(path(id)) if exists?(id)
       end
 
+      # Return whether the file with the given id exists in this backend.
+      #
+      # @param [Sring] id           The id of the file
+      # @return [Boolean]
       def exists?(id)
         ::File.exist?(path(id))
       end
 
+      # Remove all files in this backend. You must confirm the deletion by
+      # passing the symbol `:confirm` as an argument to this method.
+      #
+      # @example
+      #   backend.clear!(:confirm)
+      # @raise [Refile::Confirm]     Unless the `:confirm` symbol has been passed.
+      # @param [:confirm] confirm    Pass the symbol `:confirm` to confirm deletion.
+      # @return [void]
       def clear!(confirm = nil)
         raise Refile::Confirm unless confirm == :confirm
         FileUtils.rm_rf(@directory)
         FileUtils.mkdir_p(@directory)
       end
 
+      # Return the full path of the uploaded file with the given id.
+      #
+      # @param [Sring] id           The id of the file
+      # @return [String]
       def path(id)
         ::File.join(@directory, id)
       end