defile 0.2.0

data/Rakefile

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

data/app/assets/javascripts/defile.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,50 @@
+module AttachmentHelper
+  def attachment_url(record, name, *args, filename: nil, format: nil)
+    file = record.send(name)
+
+    filename ||= name.to_s
+
+    backend_name = Defile.backends.key(file.backend)
+    host = Defile.host || root_url
+
+    File.join(host, defile_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)
+
+    if file
+      image_tag(attachment_url(record, name, *args, format: format), options)
+    elsif fallback
+      image_tag(fallback, options)
+    end
+  end
+
+  def attachment_field(object_name, method, options = {})
+    if options[:object]
+      cache = options[:object].send(:"#{method}_attachment").cache
+
+      if options[:direct]
+        host = Defile.host || root_url
+        backend_name = Defile.backends.key(cache)
+
+        options[:data] ||= {}
+        options[:data][:direct] = true
+        options[:data][:as] = "file"
+        options[:data][:url] = File.join(host, defile_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) +
+    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 "defile/test_app"
+
+Defile::TestApp.config.action_dispatch.show_exceptions = true
+Defile.host = "//localhost:9292"
+
+run Defile::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 Defile.app, at: "attachments", as: :defile_app
+end

data/defile.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'defile/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "defile"
+  spec.version       = Defile::VERSION
+  spec.authors       = ["Jonas Nicklas"]
+  spec.email         = ["jonas.nicklas@gmail.com"]
+  spec.summary       = %q{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.required_ruby_version = ">= 2.1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails", "~> 3.0"
+  spec.add_development_dependency "jquery-rails"
+  spec.add_development_dependency "capybara"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "aws-sdk"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "rails"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "selenium-webdriver"
+end

data/lib/defile.rb

@@ -0,0 +1,72 @@
+require "uri"
+require "fileutils"
+require "tempfile"
+
+module Defile
+  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 Defile::Invalid, "#{uploadable.inspect} is too large"
+      end
+      true
+    end
+  end
+
+  require "defile/version"
+  require "defile/attachment"
+  require "defile/random_hasher"
+  require "defile/file"
+  require "defile/app"
+  require "defile/backend/file_system"
+end
+
+Defile.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/defile/app.rb

@@ -0,0 +1,97 @@
+require "logger"
+require "json"
+
+module Defile
+  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 { "Defile: #{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}" }
+      if env["REQUEST_METHOD"] == "GET"
+        backend_name, *process_args, id, filename = env["PATH_INFO"].sub(/^\//, "").split("/")
+        backend = Defile.backends[backend_name]
+
+        if backend and id
+          @logger.debug { "Defile: 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 Defile.processors[name]
+              @logger.debug { "Defile: no such processor #{name.inspect}" }
+              return not_found
+            end
+            file = Defile.processors[name].call(file, *process_args)
+          end
+
+          peek = begin
+            file.read(Defile.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 { "Defile: must specify backend and id" }
+          not_found
+        end
+      elsif env["REQUEST_METHOD"] == "POST"
+        backend_name, *rest = env["PATH_INFO"].sub(/^\//, "").split("/")
+        backend = Defile.backends[backend_name]
+
+        return not_found unless rest.empty?
+        return not_found unless backend and Defile.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 { "Defile: 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 "Defile: 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/defile/attachment.rb

@@ -0,0 +1,89 @@
+module Defile
+  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 = Defile.backends.fetch(@options[:cache].to_s)
+        @store = Defile.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 Defile::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/defile/attachment/active_record.rb

@@ -0,0 +1,24 @@
+module Defile
+  module ActiveRecord
+    module Attachment
+      include Defile::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(Defile::ActiveRecord::Attachment)