refile 0.3.0 → 0.4.0

data/lib/refile/attachment.rb

@@ -1,89 +1,5 @@
 module Refile
   module Attachment
-    # @api private
-    class Attachment
-      attr_reader :record, :name, :cache, :store, :cache_id, :options, :errors
-      attr_accessor :remove
-
-      def initialize(record, name, **options)
-        @record = record
-        @name = name
-        @options = options
-        @cache = Refile.backends.fetch(@options[:cache].to_s)
-        @store = Refile.backends.fetch(@options[:store].to_s)
-        @errors = []
-      end
-
-      def id
-        record.send(:"#{name}_id")
-      end
-
-      def id=(id)
-        record.send(:"#{name}_id=", id)
-      end
-
-      def file
-        if cached?
-          cache.get(cache_id)
-        elsif id and not id == ""
-          store.get(id)
-        end
-      end
-
-      def file=(uploadable)
-        @cache_file = cache.upload(uploadable)
-        @cache_id = @cache_file.id
-        @errors = []
-      rescue Refile::Invalid
-        @errors = [:too_large]
-        raise if @options[:raise_errors]
-      end
-
-      def download(url)
-        if url and not url == ""
-          raw_response = RestClient::Request.new(method: :get, url: url, raw_response: true).execute
-          self.file = raw_response.file
-        end
-      rescue RestClient::Exception
-        @errors = [:download_failed]
-        raise if @options[: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))
-          delete!
-          self.id = file.id
-        end
-      end
-
-      def delete!
-        if cached?
-          cache.delete(cache_id)
-          @cache_id = nil
-          @cache_file = nil
-        end
-        store.delete(id) if id
-        self.id = nil
-      end
-
-      def remove?
-        remove and remove != "" and remove !~ /\A0|false$\z/
-      end
-
-    private
-
-      def cached?
-        cache_id and not cache_id == ""
-      end
-    end
-
     # Macro which generates accessors for the given column which make it
     # possible to upload and retrieve previously uploaded files through the
     # generated accessors.
@@ -92,50 +8,67 @@ module Refile
     # should immediately raise an error, or save the error and defer handling
     # it until later.
     #
-    # @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 [true, false] raise_errors    Whether to raise errors in case an invalid file is assigned
-    def attachment(name, cache: :cache, store: :store, raise_errors: true)
-      attachment = :"#{name}_attachment"
+    # @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 [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 [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
+    # @ignore
+    #   rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def attachment(name, cache: :cache, store: :store, raise_errors: true, type: nil, extension: nil, content_type: nil)
+      mod = Module.new do
+        attacher = :"#{name}_attacher"
+
+        define_method attacher do
+          ivar = :"@#{attacher}"
+          instance_variable_get(ivar) or begin
+            instance_variable_set(ivar, Attacher.new(self, name,
+              cache: cache,
+              store: store,
+              raise_errors: raise_errors,
+              type: type,
+              extension: extension,
+              content_type: content_type
+            ))
+          end
+        end
 
-      define_method attachment do
-        ivar = :"@#{attachment}"
-        instance_variable_get(ivar) or begin
-          instance_variable_set(ivar, Attachment.new(self, name, cache: cache, store: store, raise_errors: raise_errors))
+        define_method "#{name}=" do |uploadable|
+          send(attacher).cache!(uploadable)
         end
-      end
 
-      define_method "#{name}=" do |uploadable|
-        send(attachment).file = uploadable
-      end
+        define_method name do
+          send(attacher).get
+        end
 
-      define_method name do
-        send(attachment).file
-      end
+        define_method "#{name}_cache_id=" do |cache_id|
+          send(attacher).cache_id = cache_id
+        end
 
-      define_method "#{name}_cache_id=" do |cache_id|
-        send(attachment).cache_id = cache_id
-      end
+        define_method "#{name}_cache_id" do
+          send(attacher).cache_id
+        end
 
-      define_method "#{name}_cache_id" do
-        send(attachment).cache_id
-      end
+        define_method "remove_#{name}=" do |remove|
+          send(attacher).remove = remove
+        end
 
-      define_method "remove_#{name}=" do |remove|
-        send(attachment).remove = remove
-      end
+        define_method "remove_#{name}" do
+          send(attacher).remove
+        end
 
-      define_method "remove_#{name}" do
-        send(attachment).remove
-      end
+        define_method "remote_#{name}_url=" do |url|
+          send(attacher).download(url)
+        end
 
-      define_method "remote_#{name}_url=" do |url|
-        send(attachment).download(url)
+        define_method "remote_#{name}_url" do
+        end
       end
 
-      define_method "remote_#{name}_url" do
-      end
+      include mod
     end
   end
 end

data/lib/refile/backend/file_system.rb

@@ -1,7 +1,7 @@
 module Refile
   module Backend
     class FileSystem
-      attr_reader :directory
+      attr_reader :directory, :max_size
 
       def initialize(directory, max_size: nil, hasher: Refile::RandomHasher.new)
         @hasher = hasher
@@ -53,11 +53,11 @@ module Refile
       end
 
       def exists?(id)
-        ::File.exists?(path(id))
+        ::File.exist?(path(id))
       end
 
       def clear!(confirm = nil)
-        raise ArgumentError, "are you sure? this will remove all files in the backend, call as `clear!(:confirm)` if you're sure you want to do this" unless confirm == :confirm
+        raise Refile::Confirm unless confirm == :confirm
         FileUtils.rm_rf(@directory)
         FileUtils.mkdir_p(@directory)
       end

data/lib/refile/backend/s3.rb

@@ -2,10 +2,8 @@ require "aws-sdk"
 
 module Refile
   module Backend
-
     # A refile backend which stores files in Amazon S3
     class S3
-
       # Emulates an IO-object like interface on top of S3Object#read. To avoid
       # memory allocations and unnecessary complexity, this treats the `length`
       # parameter to read as a boolean flag instead. If given, it will read the
@@ -21,9 +19,7 @@ module Refile
           result = if length
             raise "closed" if @closed
 
-            unless eof? # sets @peek
-              @peek
-            end
+            @peek unless eof? # sets @peek
           else
             @object.read
           end
@@ -55,14 +51,13 @@ module Refile
         end
       end
 
-      Signature = Struct.new(:as, :id, :url, :fields)
-
-      attr_reader :access_key_id
+      attr_reader :access_key_id, :max_size
 
-      def initialize(access_key_id:, secret_access_key:, bucket:, max_size: nil, prefix: nil, hasher: Refile::RandomHasher.new)
+      def initialize(access_key_id:, secret_access_key:, bucket:, max_size: nil, prefix: nil, hasher: Refile::RandomHasher.new, **s3_options)
         @access_key_id = access_key_id
         @secret_access_key = secret_access_key
-        @s3 = AWS::S3.new(access_key_id: access_key_id, secret_access_key: secret_access_key)
+        @s3_options = { access_key_id: access_key_id, secret_access_key: secret_access_key }.merge s3_options
+        @s3 = AWS::S3.new @s3_options
         @bucket_name = bucket
         @bucket = @s3.buckets[@bucket_name]
         @hasher = hasher
@@ -113,7 +108,7 @@ module Refile
       end
 
       def clear!(confirm = nil)
-        raise ArgumentError, "are you sure? this will remove all files in the backend, call as `clear!(:confirm)` if you're sure you want to do this" unless confirm == :confirm
+        raise Refile::Confirm unless confirm == :confirm
         @bucket.objects.with_prefix(@prefix).delete_all
       end
 
@@ -121,7 +116,7 @@ module Refile
         id = RandomHasher.new.hash
         signature = @bucket.presigned_post(key: [*@prefix, id].join("/"))
         signature.where(content_length: @max_size) if @max_size
-        Signature.new("file", id, signature.url.to_s, signature.fields)
+        Signature.new(as: "file", id: id, url: signature.url.to_s, fields: signature.fields)
       end
 
       def object(id)

data/lib/refile/file.rb

@@ -48,9 +48,7 @@ module Refile
 
     def each
       if block_given?
-        until eof?
-          yield(read(Refile.read_chunk_size))
-        end
+        yield(read(Refile.read_chunk_size)) until eof?
       else
         to_enum
       end

data/lib/refile/image_processing.rb

@@ -19,14 +19,17 @@ module Refile
       img.resize "#{width}x#{height}"
     end
 
-    def fill(img, width, height, gravity = 'Center')
+    # @ignore
+    #   rubocop:disable Metrics/AbcSize
+    #   FIXME: test and rewrite to simpler implementation!
+    def fill(img, width, height, gravity = "Center")
       width = width.to_i
       height = height.to_i
       cols, rows = img[:dimensions]
       img.combine_options do |cmd|
         if width != cols || height != rows
-          scale_x = width/cols.to_f
-          scale_y = height/rows.to_f
+          scale_x = width / cols.to_f
+          scale_y = height / rows.to_f
           if scale_x >= scale_y
             cols = (scale_x * (cols + 0.5)).round
             rows = (scale_x * (rows + 0.5)).round

data/lib/refile/rails/attachment_helper.rb

@@ -1,58 +1,55 @@
 module Refile
   module AttachmentHelper
-    def attachment_url(record, name, *args, filename: nil, format: nil)
+    def attachment_url(record, name, *args, filename: nil, format: nil, host: nil)
       file = record.send(name)
       return unless file
 
       filename ||= name.to_s
 
       backend_name = Refile.backends.key(file.backend)
-      host = Refile.host || request.base_url
+      host = host || Refile.host || request.base_url
 
       filename = filename.parameterize("_")
       filename << "." << format.to_s if format
 
-      ::File.join(host, main_app.refile_app_path, backend_name, *args.map(&:to_s), file.id, filename)
+      ::File.join(host, main_app.refile_app_path, backend_name, *args.map(&:to_s), file.id.to_s, filename)
     end
 
-    def attachment_image_tag(record, name, *args, fallback: nil, format: nil, **options)
+    def attachment_image_tag(record, name, *args, fallback: nil, format: nil, host: nil, **options)
       file = record.send(name)
       classes = ["attachment", record.class.model_name.singular, name, *options[:class]]
 
       if file
-        image_tag(attachment_url(record, name, *args, format: format), options.merge(class: classes))
+        image_tag(attachment_url(record, name, *args, format: format, host: host), options.merge(class: classes))
       elsif fallback
         classes << "fallback"
         image_tag(fallback, options.merge(class: classes))
       end
     end
 
+    # @ignore
+    #   rubocop:disable Metrics/AbcSize
     def attachment_field(object_name, method, options = {})
+      options[:data] ||= {}
+
       if options[:object]
-        cache = options[:object].send(:"#{method}_attachment").cache
+        attacher = options[:object].send(:"#{method}_attacher")
+        options[:accept] = attacher.accept
 
         if options[:direct]
-          host = Refile.host || request.base_url
-          backend_name = Refile.backends.key(cache)
+          host = options[:host] || Refile.host || request.base_url
+          backend_name = Refile.backends.key(attacher.cache)
 
-          options[:data] ||= {}
-          options[:data][:direct] = true
-          options[:data][:as] = "file"
-          options[:data][:url] = ::File.join(host, main_app.refile_app_path, backend_name)
+          url = ::File.join(host, main_app.refile_app_path, backend_name)
+          options[:data].merge!(direct: true, as: "file", url: url)
         end
 
-        if options[:presigned] and cache.respond_to?(:presign)
-          signature = cache.presign
-          options[:data] ||= {}
-          options[:data][:direct] = true
-          options[:data][:id] = signature.id
-          options[:data][:url] = signature.url
-          options[:data][:fields] = signature.fields
-          options[:data][:as] = signature.as
+        if options[:presigned] and attacher.cache.respond_to?(:presign)
+          options[:data].merge!(direct: true).merge!(attacher.cache.presign.as_json)
         end
       end
       hidden_field(object_name, :"#{method}_cache_id", options.slice(:object)) +
-      file_field(object_name, method, options)
+        file_field(object_name, method, options)
     end
   end
 end

data/lib/refile/rails.rb

@@ -23,7 +23,8 @@ module Refile
     end
 
     initializer "refile.app" do
-      Refile.app = Refile::App.new(logger: Rails.logger)
+      Refile.logger = Rails.logger
+      Refile.app = Refile::App.new
     end
   end
 end

data/lib/refile/random_hasher.rb

@@ -1,10 +1,11 @@
-# A file hasher which ignores the file contents and always returns a random string.
-class Refile::RandomHasher
-
-  # Generate a random string
-  #
-  # @return [String]
-  def hash(uploadable=nil)
-    SecureRandom.hex(30)
+module Refile
+  # A file hasher which ignores the file contents and always returns a random string.
+  class RandomHasher
+    # Generate a random string
+    #
+    # @return [String]
+    def hash(_uploadable = nil)
+      SecureRandom.hex(30)
+    end
   end
 end

data/lib/refile/signature.rb

@@ -0,0 +1,16 @@
+module Refile
+  class Signature
+    attr_reader :as, :id, :url, :fields
+
+    def initialize(as:, id:, url:, fields:)
+      @as = as
+      @id = id
+      @url = url
+      @fields = fields
+    end
+
+    def as_json(*)
+      { as: @as, id: @id, url: @url, fields: @fields }
+    end
+  end
+end

data/lib/refile/version.rb

@@ -1,3 +1,3 @@
 module Refile
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/refile.rb

@@ -2,12 +2,20 @@ require "uri"
 require "fileutils"
 require "tempfile"
 require "rest_client"
+require "logger"
+require "mime/types"
 
 module Refile
   class Invalid < StandardError; end
+  class Confirm < StandardError
+    def message
+      "are you sure? this will remove all files in the backend, call as \
+      `clear!(:confirm)` if you're sure you want to do this"
+    end
+  end
+  ONE_YEAR_IN_SECONDS = 31_557_600
 
   class << self
-
     # The number of bytes to read when files are streamed. Refile
     # uses this in a couple of places where files should be streamed
     # in a memory efficient way instead of reading the entire file into
@@ -40,6 +48,29 @@ module Refile
     # @return [Array[String]]
     attr_accessor :direct_upload
 
+    # Logger that should be used by rack application
+    #
+    # @return [Logger]
+    attr_accessor :logger
+
+    # Value for Access-Control-Allow-Origin header
+    #
+    # @return [String]
+    attr_accessor :allow_origin
+
+    # Value for Cache-Control: max-age=<value in seconds> header
+    attr_accessor :content_max_age
+
+    # Where should the rack application be mounted?
+    # The default is 'attachments'
+    attr_accessor :mount_point
+
+    # Should the rack application be automounted in a Rails app?
+    # The default is true.
+    # If set to false then Refile.app should be mounted in the Rails application
+    # routes.rb with the options `at: Refile.mount_point, as: :refile_app`
+    attr_accessor :automount
+
     # A global registry of backends.
     #
     # @return [Hash{String => Backend}]
@@ -146,9 +177,31 @@ module Refile
       end
       true
     end
+
+    def extract_filename(uploadable)
+      path = if uploadable.respond_to?(:original_filename)
+        uploadable.original_filename
+      elsif uploadable.respond_to?(:path)
+        uploadable.path
+      end
+      ::File.basename(path) if path
+    end
+
+    def extract_content_type(uploadable)
+      if uploadable.respond_to?(:content_type)
+        uploadable.content_type
+      else
+        filename = extract_filename(uploadable)
+        if filename
+          content_type = MIME::Types.of(filename).first
+          content_type.to_s if content_type
+        end
+      end
+    end
   end
 
   require "refile/version"
+  require "refile/attacher"
   require "refile/attachment"
   require "refile/random_hasher"
   require "refile/file"
@@ -162,4 +215,9 @@ Refile.configure do |config|
   # one?
   config.read_chunk_size = 3000
   config.direct_upload = ["cache"]
+  config.allow_origin = "*"
+  config.logger = Logger.new(STDOUT)
+  config.mount_point = "attachments"
+  config.automount = true
+  config.content_max_age = Refile::ONE_YEAR_IN_SECONDS
 end

data/refile.gemspec

@@ -1,24 +1,27 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'refile/version'
+require "refile/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "refile"
   spec.version       = Refile::VERSION
   spec.authors       = ["Jonas Nicklas"]
   spec.email         = ["jonas.nicklas@gmail.com"]
-  spec.summary       = %q{Simple and powerful file upload library}
+  spec.summary       = "Simple and powerful file upload library"
   spec.homepage      = ""
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib", "spec"]
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = %w[lib spec]
 
   spec.required_ruby_version = ">= 2.1.0"
+
   spec.add_dependency "rest-client", "~> 1.7.2"
+  spec.add_dependency "sinatra", "~> 1.4.5"
+  spec.add_dependency "mime-types"
 
   spec.add_development_dependency "webmock", "~> 1.20.4"
   spec.add_development_dependency "bundler", "~> 1.6"
@@ -34,4 +37,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "selenium-webdriver"
   spec.add_development_dependency "yard"
+  spec.add_development_dependency "rubocop"
 end

data/spec/refile/app_spec.rb

@@ -18,11 +18,12 @@ describe Refile::App do
     end
 
     it "returns a 404 if the file doesn't exist" do
-      file = Refile.store.upload(StringIO.new("hello"))
+      Refile.store.upload(StringIO.new("hello"))
 
       get "/store/doesnotexist/hello"
 
       expect(last_response.status).to eq(404)
+      expect(last_response.content_type).to eq("text/plain;charset=utf-8")
       expect(last_response.body).to eq("not found")
     end
 
@@ -32,12 +33,13 @@ describe Refile::App do
       get "/doesnotexist/#{file.id}/hello"
 
       expect(last_response.status).to eq(404)
+      expect(last_response.content_type).to eq("text/plain;charset=utf-8")
       expect(last_response.body).to eq("not found")
     end
 
     context "with allow origin" do
-      def app
-        Refile::App.new(allow_origin: "example.com")
+      before(:each) do
+        allow(Refile).to receive(:allow_origin).and_return("example.com")
       end
 
       it "sets CORS header" do
@@ -51,12 +53,31 @@ describe Refile::App do
       end
     end
 
+    it "returns a 200 for head requests" do
+      file = Refile.store.upload(StringIO.new("hello"))
+
+      head "/store/#{file.id}/hello"
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.body).to be_empty
+    end
+
+    it "returns a 404 for head requests if the file doesn't exist" do
+      Refile.store.upload(StringIO.new("hello"))
+
+      head "/store/doesnotexist/hello"
+
+      expect(last_response.status).to eq(404)
+      expect(last_response.body).to be_empty
+    end
+
     it "returns a 404 for non get requests" do
       file = Refile.store.upload(StringIO.new("hello"))
 
       post "/store/#{file.id}/hello"
 
       expect(last_response.status).to eq(404)
+      expect(last_response.content_type).to eq("text/plain;charset=utf-8")
       expect(last_response.body).to eq("not found")
     end
   end
@@ -68,6 +89,7 @@ describe Refile::App do
       get "/store/doesnotexist/#{file.id}/hello"
 
       expect(last_response.status).to eq(404)
+      expect(last_response.content_type).to eq("text/plain;charset=utf-8")
       expect(last_response.body).to eq("not found")
     end
 
@@ -114,6 +136,7 @@ describe Refile::App do
       post "/store", file: file
 
       expect(last_response.status).to eq(404)
+      expect(last_response.content_type).to eq("text/plain;charset=utf-8")
       expect(last_response.body).to eq("not found")
     end
 
@@ -130,6 +153,7 @@ describe Refile::App do
     get "/store"
 
     expect(last_response.status).to eq(404)
+    expect(last_response.content_type).to eq("text/plain;charset=utf-8")
     expect(last_response.body).to eq("not found")
   end
 
@@ -137,7 +161,7 @@ describe Refile::App do
     get "/"
 
     expect(last_response.status).to eq(404)
+    expect(last_response.content_type).to eq("text/plain;charset=utf-8")
     expect(last_response.body).to eq("not found")
   end
 end
-