refile 0.2.2

data/Rakefile

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.expand_path("spec", File.dirname(__FILE__)))
+
+require "bundler/gem_tasks"
+require "refile/test_app"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+Rails.application.load_tasks

data/app/assets/javascripts/refile.js

@@ -0,0 +1,50 @@
+"use strict";
+
+document.addEventListener("change", function(e) {
+  if(e.target.tagName === "INPUT" && e.target.type === "file" && e.target.dataset.direct) {
+    var input = e.target;
+    var file = input.files[0];
+    if(file) {
+      var url = e.target.dataset.url;
+      if(e.target.dataset.fields) {
+        var fields = JSON.parse(e.target.dataset.fields);
+      }
+
+      var data = new FormData();
+
+      if(fields) {
+        Object.keys(fields).forEach(function(key) {
+          data.append(key, fields[key]);
+        });
+      }
+      data.append(input.dataset.as, file);
+
+      var xhr = new XMLHttpRequest();
+      xhr.addEventListener("load", function(e) {
+        input.classList.remove("uploading")
+        input.dispatchEvent(new CustomEvent("upload:complete", { detail: xhr.responseText, bubbles: true }));
+        if((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304) {
+          var id = input.dataset.id || JSON.parse(xhr.responseText).id;
+          input.dispatchEvent(new CustomEvent("upload:success", { detail: xhr.responseText, bubbles: true }));
+          input.previousSibling.value = id;
+          input.removeAttribute("name");
+        } else {
+          input.dispatchEvent(new CustomEvent("upload:failure", { detail: xhr.responseText, bubbles: true }));
+        }
+      });
+
+      xhr.addEventListener("progress", function(e) {
+        if (e.lengthComputable) {
+          input.dispatchEvent(new CustomEvent("upload:progress", { detail: e, bubbles: true }));
+        }
+      });
+
+      xhr.open("POST", url, true);
+      xhr.send(data);
+
+      input.classList.add("uploading")
+      input.dispatchEvent(new CustomEvent("upload:start", { bubbles: true }));
+    }
+  }
+});
+

data/app/helpers/attachment_helper.rb

@@ -0,0 +1,52 @@
+module AttachmentHelper
+  def attachment_url(record, name, *args, filename: nil, format: nil)
+    file = record.send(name)
+
+    filename ||= name.to_s
+
+    backend_name = Refile.backends.key(file.backend)
+    host = Refile.host || root_url
+
+    File.join(host, refile_app_path, backend_name, *args.map(&:to_s), file.id, filename.parameterize("_"))
+  end
+
+  def attachment_image_tag(record, name, *args, fallback: nil, format: 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))
+    elsif fallback
+      classes << "fallback"
+      image_tag(fallback, options.merge(class: classes))
+    end
+  end
+
+  def attachment_field(object_name, method, options = {})
+    if options[:object]
+      cache = options[:object].send(:"#{method}_attachment").cache
+
+      if options[:direct]
+        host = Refile.host || root_url
+        backend_name = Refile.backends.key(cache)
+
+        options[:data] ||= {}
+        options[:data][:direct] = true
+        options[:data][:as] = "file"
+        options[:data][:url] = File.join(host, refile_app_path, backend_name)
+      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
+      end
+    end
+    hidden_field(object_name, :"#{method}_cache_id", options.slice(:object)) +
+    file_field(object_name, method, options)
+  end
+end

data/config.ru

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.expand_path("spec", File.dirname(__FILE__)))
+
+require "refile/test_app"
+
+Refile::TestApp.config.action_dispatch.show_exceptions = true
+Refile.host = "//localhost:9292"
+
+run Refile::TestApp

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  activerecord:
+    errors:
+      messages:
+        too_large: "is too large"

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  mount Refile.app, at: "attachments", as: :refile_app
+end

data/lib/refile.rb

@@ -0,0 +1,72 @@
+require "uri"
+require "fileutils"
+require "tempfile"
+
+module Refile
+  class Invalid < StandardError; end
+
+  class << self
+    attr_accessor :read_chunk_size, :app, :host, :direct_upload
+    attr_writer :store, :cache
+
+    def backends
+      @backends ||= {}
+    end
+
+    def processors
+      @processors ||= {}
+    end
+
+    def processor(name, processor = nil, &block)
+      processor ||= block
+      processors[name.to_s] = processor
+    end
+
+    def store
+      backends["store"]
+    end
+
+    def store=(backend)
+      backends["store"] = backend
+    end
+
+    def cache
+      backends["cache"]
+    end
+
+    def cache=(backend)
+      backends["cache"] = backend
+    end
+
+    def configure
+      yield self
+    end
+
+    def verify_uploadable(uploadable, max_size)
+      [:size, :read, :eof?, :close].each do |m|
+        unless uploadable.respond_to?(m)
+          raise ArgumentError, "does not respond to `#{m}`."
+        end
+      end
+      if max_size and uploadable.size > max_size
+        raise Refile::Invalid, "#{uploadable.inspect} is too large"
+      end
+      true
+    end
+  end
+
+  require "refile/version"
+  require "refile/attachment"
+  require "refile/random_hasher"
+  require "refile/file"
+  require "refile/app"
+  require "refile/backend/file_system"
+end
+
+Refile.configure do |config|
+  # FIXME: what is a sane default here? This is a little less than a
+  # memory page, which seemed like a good default, is there a better
+  # one?
+  config.read_chunk_size = 3000
+  config.direct_upload = ["cache"]
+end

data/lib/refile/app.rb

@@ -0,0 +1,97 @@
+require "logger"
+require "json"
+
+module Refile
+  class App
+    def initialize(logger: nil, allow_origin: nil)
+      @logger = logger
+      @logger ||= ::Logger.new(nil)
+      @allow_origin = allow_origin
+    end
+
+    class Proxy
+      def initialize(peek, file)
+        @peek = peek
+        @file = file
+      end
+
+      def close
+        @file.close
+      end
+
+      def each(&block)
+        block.call(@peek)
+        @file.each(&block)
+      end
+    end
+
+    def call(env)
+      @logger.info { "Refile: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}" }
+      if env["REQUEST_METHOD"] == "GET"
+        backend_name, *process_args, id, filename = env["PATH_INFO"].sub(/^\//, "").split("/")
+        backend = Refile.backends[backend_name]
+
+        if backend and id
+          @logger.debug { "Refile: serving #{id.inspect} from #{backend_name} backend which is of type #{backend.class}" }
+
+          file = backend.get(id)
+
+          unless process_args.empty?
+            name = process_args.shift
+            unless Refile.processors[name]
+              @logger.debug { "Refile: no such processor #{name.inspect}" }
+              return not_found
+            end
+            file = Refile.processors[name].call(file, *process_args)
+          end
+
+          peek = begin
+            file.read(Refile.read_chunk_size)
+          rescue => e
+            log_error(e)
+            return not_found
+          end
+
+          headers = {}
+          headers["Access-Control-Allow-Origin"] = @allow_origin if @allow_origin
+
+          [200, headers, Proxy.new(peek, file)]
+        else
+          @logger.debug { "Refile: must specify backend and id" }
+          not_found
+        end
+      elsif env["REQUEST_METHOD"] == "POST"
+        backend_name, *rest = env["PATH_INFO"].sub(/^\//, "").split("/")
+        backend = Refile.backends[backend_name]
+
+        return not_found unless rest.empty?
+        return not_found unless backend and Refile.direct_upload.include?(backend_name)
+
+        file = backend.upload(Rack::Request.new(env).params.fetch("file").fetch(:tempfile))
+        [200, { "Content-Type" => "application/json" }, [{ id: file.id }.to_json]]
+      else
+        @logger.debug { "Refile: request methods other than GET and POST are not allowed" }
+        not_found
+      end
+    rescue => e
+      log_error(e)
+      [500, {}, ["error"]]
+    end
+
+  private
+
+    def not_found
+      [404, {}, ["not found"]]
+    end
+
+    def log_error(e)
+      if @logger.debug?
+        @logger.debug "Refile: unable to read file"
+        @logger.debug "#{e.class}: #{e.message}"
+        e.backtrace.each do |line|
+          @logger.debug "  #{line}"
+        end
+      end
+    end
+  end
+end

data/lib/refile/attachment.rb

@@ -0,0 +1,89 @@
+module Refile
+  module Attachment
+    IMAGE_TYPES = %w[jpg jpeg gif png]
+
+    class Attachment
+      attr_reader :record, :name, :cache, :store, :cache_id, :options
+
+      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 cache_id and not cache_id == ""
+          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 cache_id=(id)
+        @cache_id = id unless @cache_file
+      end
+
+      def store!
+        if cache_id and not cache_id == ""
+          file = store.upload(cache.get(cache_id))
+          cache.delete(cache_id)
+          store.delete(id) if id
+          self.id = file.id
+          @cache_id = nil
+          @cache_file = nil
+        end
+      end
+
+      def errors
+        @errors
+      end
+    end
+
+    def attachment(name, cache: :cache, store: :store, raise_errors: true)
+      attachment = :"#{name}_attachment"
+
+      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))
+        end
+      end
+
+      define_method "#{name}=" do |uploadable|
+        send(attachment).file = uploadable
+      end
+
+      define_method name do
+        send(attachment).file
+      end
+
+      define_method "#{name}_cache_id=" do |cache_id|
+        send(attachment).cache_id = cache_id
+      end
+
+      define_method "#{name}_cache_id" do
+        send(attachment).cache_id
+      end
+    end
+  end
+end

data/lib/refile/attachment/active_record.rb

@@ -0,0 +1,24 @@
+module Refile
+  module ActiveRecord
+    module Attachment
+      include Refile::Attachment
+
+      def attachment(name, cache: :cache, store: :store, raise_errors: false)
+        super
+
+        attachment = "#{name}_attachment"
+
+        validate do
+          errors = send(attachment).errors
+          self.errors.add(name, *errors) unless errors.empty?
+        end
+
+        before_save do
+          send(attachment).store!
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::Base.extend(Refile::ActiveRecord::Attachment)

data/lib/refile/backend/file_system.rb

@@ -0,0 +1,70 @@
+module Refile
+  module Backend
+    class FileSystem
+      attr_reader :directory
+
+      def initialize(directory, max_size: nil, hasher: Refile::RandomHasher.new)
+        @hasher = hasher
+        @directory = directory
+        @max_size = max_size
+
+        FileUtils.mkdir_p(@directory)
+      end
+
+      def upload(uploadable)
+        Refile.verify_uploadable(uploadable, @max_size)
+
+        id = @hasher.hash(uploadable)
+
+        if uploadable.respond_to?(:path) and ::File.exist?(uploadable.path)
+          FileUtils.cp(uploadable.path, path(id))
+        else
+          ::File.open(path(id), "wb") do |file|
+            buffer = "" # reuse the same buffer
+            until uploadable.eof?
+              uploadable.read(Refile.read_chunk_size, buffer)
+              file.write(buffer)
+            end
+            uploadable.close
+          end
+        end
+
+        Refile::File.new(self, id)
+      end
+
+      def get(id)
+        Refile::File.new(self, id)
+      end
+
+      def delete(id)
+        FileUtils.rm(path(id)) if exists?(id)
+      end
+
+      def open(id)
+        ::File.open(path(id), "rb")
+      end
+
+      def read(id)
+        ::File.read(path(id)) if exists?(id)
+      end
+
+      def size(id)
+        ::File.size(path(id)) if exists?(id)
+      end
+
+      def exists?(id)
+        ::File.exists?(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
+        FileUtils.rm_rf(@directory)
+        FileUtils.mkdir_p(@directory)
+      end
+
+      def path(id)
+        ::File.join(@directory, id)
+      end
+    end
+  end
+end