leifcr-refile 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f781b9f6d4404dc29d2b92347798a84e7208a8ad
-  data.tar.gz: d3d68577da41b921cfa349aafc142bb8d5d5550e
+SHA256:
+  metadata.gz: 207442fab5c7ffc212b6a306de4750f4c400c616c6f04bcca3d497b9cdc95cbb
+  data.tar.gz: '09ec1056de2707eeee3586a6b0bcc4ab67a88adcd4d4ba81ab14d2d63a64881d'
 SHA512:
-  metadata.gz: d605f5943011f2b8258b335b045f949f58aabf4eb66a4f1e2f3001387d682d3c60f0580543e22b8d426695b959def093858a1cb904a2915b98277c90f0d80748
-  data.tar.gz: 55e9254dc55bfccf60caa620bf1afe3257b4f630e9d459c826bc1ce88e0fecf137fa721bf13fcddc53da8a1223781648d0dd8dcdfd5b2359c5f8c2e3c3749b2e
+  metadata.gz: 0d63019644aa26fbfae2998559b4c43fceb148fd018a71bd78d1a8bb59b49f7db62c1190f6f2c01735f3fdb34659876594444003d512fb66d863a5517a314c09
+  data.tar.gz: 1415e64857f076ff3ed80c419560661e03d9a827c32e4f742c844b6289a529299101060f8fef3a4fa0b8a0f4d8f0bdcee109c895208fd26b972a008006b11888

data/app/assets/javascripts/refile.js

@@ -115,7 +115,10 @@
             return data;
           });
           if(!input.multiple) dataObj = dataObj[0];
-          if(metadataField) metadataField.value = JSON.stringify(dataObj);
+          if(metadataField) {
+            metadataField.value = JSON.stringify(dataObj);
+            metadataField.removeAttribute('disabled');
+          };
 
           input.removeAttribute("name");
         }

data/lib/refile.rb

@@ -1,13 +1,15 @@
 require "uri"
 require "fileutils"
 require "tempfile"
-require "rest_client"
 require "logger"
 require "mime/types"
 
 module Refile
   # @api private
-  class Invalid < StandardError; end
+  class Error < StandardError; end
+
+  # @api private
+  class Invalid < Error; end
 
   # @api private
   class InvalidID < Invalid; end
@@ -18,6 +20,12 @@ module Refile
   # @api private
   class InvalidFile < Invalid; end
 
+  # Raised when the given URL couldn't be parsed.
+  class InvalidUrl < Error; end
+
+  # Raised when the given URL redirects more than allowed.
+  class TooManyRedirects < Error; end
+
   # @api private
   class Confirm < StandardError
     def message
@@ -489,8 +497,10 @@ module Refile
   require "refile/type"
   require "refile/backend_macros"
   require "refile/attachment_definition"
+  require "refile/download"
   require "refile/attacher"
   require "refile/attachment"
+  require "refile/attachment/multiple_attachments"
   require "refile/random_hasher"
   require "refile/file"
   require "refile/custom_logger"

data/lib/refile/attacher.rb

@@ -73,6 +73,7 @@ module Refile
     end
 
     def set(value)
+      self.remove = false
       case value
         when nil then self.remove = true
         when String, Hash then retrieve!(value)
@@ -105,21 +106,20 @@ module Refile
 
     def download(url)
       unless url.to_s.empty?
-        response = RestClient::Request.new(method: :get, url: url, raw_response: true).execute
+        download = Refile::Download.new(url)
         @metadata = {
-          size: response.file.size,
-          filename: URI.parse(url).path.split("/").last,
-          content_type: response.headers[:content_type]
+          size: download.size,
+          filename: download.original_filename,
+          content_type: download.content_type
         }
         if valid?
-          response.file.open if response.file.closed? # https://github.com/refile/refile/pull/210
-          @metadata[:id] = cache.upload(response.file).id
+          @metadata[:id] = cache.upload(download.io).id
           write_metadata
         elsif @definition.raise_errors?
           raise Refile::Invalid, @errors.join(", ")
         end
       end
-    rescue RestClient::Exception
+    rescue Refile::Error
       @errors = [:download_failed]
       raise if @definition.raise_errors?
     end

data/lib/refile/attachment.rb

@@ -104,5 +104,63 @@ module Refile
 
       include mod
     end
+
+    # Macro which generates accessors in pure Ruby classes for assigning
+    # multiple attachments at once. This is primarily useful together with
+    # multiple file uploads. There is also an Active Record version of
+    # this macro.
+    #
+    # The name of the generated accessors will be the name of the association
+    # (represented by an attribute accessor) and the name of the attachment in
+    # the associated class. So if a `Post` accepts attachments for `images`, and
+    # the attachment in the `Image` class is named `file`, then the accessors will
+    # be named `images_files`.
+    #
+    # @example in associated class
+    #   class Document
+    #     extend Refile::Attachment
+    #     attr_accessor :file_id
+    #
+    #     attachment :file
+    #
+    #     def initialize(attributes = {})
+    #       self.file = attributes[:file]
+    #     end
+    #   end
+    #
+    # @example in class
+    #   class Post
+    #     extend Refile::Attachment
+    #     include ActiveModel::Model
+    #
+    #     attr_accessor :documents
+    #
+    #     accepts_attachments_for :documents, accessor_prefix: 'documents_files', collection_class: Document
+    #
+    #     def initialize(attributes = {})
+    #       @documents = attributes[:documents] || []
+    #     end
+    #   end
+    #
+    # @example in form
+    #   <%= form_for @post do |form| %>
+    #     <%= form.attachment_field :documents_files, multiple: true %>
+    #   <% end %>
+    #
+    # @param [Symbol]  collection_name      Name of the association
+    # @param [Class]   collection_class     Associated class
+    # @param [String]  accessor_prefix      Name of the generated accessors
+    # @param [Symbol]  attachment           Name of the attachment in the associated class
+    # @param [Boolean] append               If true, new files are appended instead of replacing the entire list of associated classes.
+    # @return [void]
+    def accepts_attachments_for(collection_name, collection_class:, accessor_prefix:, attachment: :file, append: false)
+      include MultipleAttachments.new(
+        collection_name,
+        collection_class: collection_class,
+        name: accessor_prefix,
+        attachment: attachment,
+        append: append
+      )
+    end
   end
 end

data/lib/refile/attachment/active_record.rb

@@ -47,8 +47,9 @@ module Refile
         end
       end
 
-      # Macro which generates accessors for assigning multiple attachments at
-      # once. This is primarily useful together with multiple file uploads.
+      # Macro which generates accessors in Active Record classes for assigning
+      # multiple attachments at once. This is primarily useful together with
+      # multiple file uploads. There is also a pure Ruby version of this macro.
       #
       # The name of the generated accessors will be the name of the association
       # and the name of the attachment in the associated model. So if a `Post`
@@ -71,55 +72,29 @@ module Refile
       #     <%= form.attachment_field :images_files, multiple: true %>
       #   <% end %>
       #
-      # @param [Symbol] association_name     Name of the association
-      # @param [Symbol] attachment           Name of the attachment in the associated model
-      # @param [Symbol] append               If true, new files are appended instead of replacing the entire list of associated models.
+      # @param [Symbol]  association_name     Name of the association
+      # @param [Symbol]  attachment           Name of the attachment in the associated model
+      # @param [Boolean] append               If true, new files are appended instead of replacing the entire list of associated models.
       # @return [void]
       def accepts_attachments_for(association_name, attachment: :file, append: false)
         association = reflect_on_association(association_name)
         attachment_pluralized = attachment.to_s.pluralize
         name = "#{association_name}_#{attachment_pluralized}"
+        collection_class = association && association.klass
 
-        mod = Module.new do
-          define_method :"#{name}_attachment_definition" do
-            association.klass.send("#{attachment}_attachment_definition")
-          end
+        options = {
+          collection_class: collection_class,
+          name: name,
+          attachment: attachment,
+          append: append
+        }
 
-          define_method(:method_missing) do |method|
+        mod = MultipleAttachments.new association_name, **options do
+          define_method(:method_missing) do |method, *args|
             if method == attachment_pluralized.to_sym
               raise NoMethodError, "wrong association name #{method}, use like this #{name}"
             else
-              super(method)
-            end
-          end
-
-          define_method :"#{name}_data" do
-            if send(association_name).all? { |record| record.send("#{attachment}_attacher").valid? }
-              send(association_name).map(&:"#{attachment}_data").select(&:present?)
-            end
-          end
-
-          define_method :"#{name}" do
-            send(association_name).map(&attachment)
-          end
-
-          define_method :"#{name}=" do |files|
-            cache, files = files.partition { |file| file.is_a?(String) }
-
-            cache = Refile.parse_json(cache.first)
-
-            if not append and (files.present? or cache.present?)
-              send("#{association_name}=", [])
-            end
-
-            if files.empty? and cache.present?
-              cache.select(&:present?).each do |file|
-                send(association_name).build(attachment => file.to_json)
-              end
-            else
-              files.select(&:present?).each do |file|
-                send(association_name).build(attachment => file)
-              end
+              super(method, *args)
             end
           end
         end

data/lib/refile/attachment/multiple_attachments.rb

@@ -0,0 +1,54 @@
+module Refile
+  module Attachment
+    # Builds a module to be used by "accepts_attachments_for"
+    #
+    # @api private
+    module MultipleAttachments
+      def self.new(collection_name, collection_class:, name:, attachment:, append:, &block)
+        Module.new do
+          define_method :"#{name}_attachment_definition" do
+            collection_class.send("#{attachment}_attachment_definition")
+          end
+
+          define_method :"#{name}_data" do
+            collection = send(collection_name)
+
+            all_attachers_valid = collection.all? do |record|
+              record.send("#{attachment}_attacher").valid?
+            end
+
+            collection.map(&:"#{attachment}_data") if all_attachers_valid
+          end
+
+          define_method :"#{name}" do
+            send(collection_name).map(&attachment)
+          end
+
+          define_method :"#{name}=" do |files|
+            cache, files = [files].flatten.partition { |file| file.is_a?(String) }
+            cache = Refile.parse_json(cache.first) || []
+            cache = cache.reject(&:empty?)
+            files = files.compact
+
+            if not append and (!files.empty? or !cache.empty?)
+              send("#{collection_name}=", [])
+            end
+
+            collection = send(collection_name)
+
+            if files.empty? and !cache.empty?
+              cache.each do |file|
+                collection << collection_class.new(attachment => file.to_json)
+              end
+            else
+              files.each do |file|
+                collection << collection_class.new(attachment => file)
+              end
+            end
+          end
+          module_eval(&block) if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/refile/download.rb

@@ -0,0 +1,98 @@
+require "open-uri"
+require "forwardable"
+require "cgi"
+
+module Refile
+  # This class downloads a given URL and returns its IO, size, content type and
+  # original file name.
+  #
+  # Usage:
+  #
+  #     download = Refile::Download.new('http://example.com/my/data.bin')
+  #     download.io
+  #     #=> #<StringIO:0x00007fdcb3932fc8 ...>
+  #     download.size
+  #     #=> 389620
+  #     download.content_type
+  #     #=> "application/octet-stream"
+  #     download.original_file_name
+  #     #=> "data.bin"
+  class Download
+    OPTIONS = {
+      "User-Agent" => "Refile/#{Refile::VERSION}",
+      open_timeout: 30,
+      read_timeout: 30,
+      redirect: false
+    }.freeze
+
+    extend Forwardable
+    def_delegators :@io, :size, :content_type
+
+    attr_reader :io, :original_filename
+
+    def initialize(uri)
+      @io = download(uri)
+      @original_filename = extract_original_filename
+    end
+
+  private
+
+    def download(uri)
+      uri = ensure_uri(uri)
+      follows_remaining = 10
+
+      begin
+        uri.open(OPTIONS)
+      rescue OpenURI::HTTPRedirect => exception
+        raise Refile::TooManyRedirects if follows_remaining.zero?
+
+        uri = ensure_uri(exception.uri)
+        follows_remaining -= 1
+
+        retry
+      rescue OpenURI::HTTPError => exception
+        if exception.message.include?("(Invalid Location URI)")
+          raise Refile::InvalidUrl, "Invalid Redirect URI: #{response["Location"]}"
+        end
+
+        raise exception
+      end
+    end
+
+    def ensure_uri(url)
+      begin
+        uri = URI(url)
+      rescue URI::InvalidURIError
+        raise Refile::InvalidUrl, "Invalid URI: #{uri.inspect}"
+      end
+
+      unless uri.is_a?(URI::HTTP)
+        raise Refile::InvalidUrl, "URL scheme needs to be http or https: #{uri}"
+      end
+
+      uri
+    end
+
+    def extract_original_filename
+      filename_from_content_disposition || filename_from_path
+    end
+
+    def filename_from_content_disposition
+      content_disposition = @io.meta["content-disposition"].to_s
+
+      escaped_filename =
+        content_disposition[/filename\*=UTF-8''(\S+)/, 1] ||
+        content_disposition[/filename="([^"]*)"/, 1] ||
+        content_disposition[/filename=(\S+)/, 1]
+
+      filename = CGI.unescape(escaped_filename.to_s)
+
+      filename unless filename.empty?
+    end
+
+    def filename_from_path
+      filename = @io.base_uri.path.split("/").last
+      CGI.unescape(filename) if filename
+    end
+  end
+end

data/lib/refile/rails/attachment_helper.rb

@@ -106,10 +106,13 @@ module Refile
       options[:data] ||= {}
       options[:data][:reference] ||= SecureRandom.hex
 
+      attacher_value = object.send("#{method}_data")
+
       hidden_options = {
         multiple: options[:multiple],
-        value: object.send("#{method}_data").try(:to_json),
+        value: attacher_value.try(:to_json),
         object: object,
+        disabled: attacher_value.blank?,
         id: nil,
         data: { reference: options[:data][:reference] }
       }

data/lib/refile/version.rb

@@ -1,3 +1,3 @@
 module Refile
-  VERSION = "0.6.3"
+  VERSION = "0.7.0"
 end

data/spec/refile/active_record_helper.rb

@@ -8,7 +8,7 @@ ActiveRecord::Base.establish_connection(
   verbosity: "quiet"
 )
 
-class TestMigration < ActiveRecord::Migration
+class TestMigration < ActiveRecord::Migration[5.0]
   def self.up
     create_table :posts, force: true do |t|
       t.integer :user_id

data/spec/refile/attachment/active_record_spec.rb

@@ -1,5 +1,6 @@
 require "refile/active_record_helper"
 require "refile/attachment/active_record"
+require_relative "../support/accepts_attachments_for_shared_examples"
 
 describe Refile::ActiveRecord::Attachment do
   let(:options) { {} }
@@ -273,6 +274,18 @@ describe Refile::ActiveRecord::Attachment do
       expect(Refile.store.read(post.document.id)).to eq("hello")
       expect(post.document.id).not_to be eq old_document.id
     end
+
+    it "replaces a attachment which was nil" do
+      post = klass.new
+      post.document = nil
+      post.save
+
+      post.document = Refile::FileDouble.new("hello")
+      post.save
+
+      expect(Refile.store.read(post.document.id)).to eq("hello")
+      expect(post.document).not_to be_nil
+    end
   end
 
   describe "#destroy" do
@@ -339,119 +352,31 @@ describe Refile::ActiveRecord::Attachment do
           "Document"
         end
 
-        attachment :file
+        attachment :file, type: :image
       end
     end
 
     let(:post) { post_class.new }
 
-    describe "#:association_:name" do
+    it_should_behave_like "accepts_attachments_for"
+
+    it "shouldn't raise error on setter method_missing" do
+      expect { post.creator = nil }.to_not raise_error(ArgumentError)
+    end
+
+    context "when a wrong association is called" do
       let(:wrong_method) { "files" }
       let(:wrong_association_message) do
         "wrong association name #{wrong_method}, use like this documents_files"
       end
 
-      it "returns a friendly error message for wrong association name" do
+      it "returns a friendly error message" do
         expect { post.send(wrong_method) }.to raise_error(wrong_association_message)
       end
 
       it "return method missing" do
         expect { post.foo }.to_not raise_error(wrong_association_message)
       end
-
-      it "builds records from assigned files" do
-        post.documents_files = [Refile::FileDouble.new("hello"), Refile::FileDouble.new("world")]
-        expect(post.documents[0].file.read).to eq("hello")
-        expect(post.documents[1].file.read).to eq("world")
-        expect(post.documents.size).to eq(2)
-      end
-
-      it "builds records from cache" do
-        post.documents_files = [
-          [
-            { id: Refile.cache.upload(Refile::FileDouble.new("hello")).id },
-            { id: Refile.cache.upload(Refile::FileDouble.new("world")).id }
-          ].to_json
-        ]
-        expect(post.documents[0].file.read).to eq("hello")
-        expect(post.documents[1].file.read).to eq("world")
-        expect(post.documents.size).to eq(2)
-      end
-
-      it "prefers newly uploaded files over cache" do
-        post.documents_files = [
-          [
-            { id: Refile.cache.upload(Refile::FileDouble.new("moo")).id }
-          ].to_json,
-          Refile::FileDouble.new("hello"),
-          Refile::FileDouble.new("world")
-        ]
-        expect(post.documents[0].file.read).to eq("hello")
-        expect(post.documents[1].file.read).to eq("world")
-        expect(post.documents.size).to eq(2)
-      end
-
-      it "clears previously assigned files" do
-        post.documents_files = [
-          Refile::FileDouble.new("hello"),
-          Refile::FileDouble.new("world")
-        ]
-        post.save
-        post.update_attributes documents_files: [
-          Refile::FileDouble.new("foo")
-        ]
-        retrieved = post_class.find(post.id)
-        expect(retrieved.documents[0].file.read).to eq("foo")
-        expect(retrieved.documents.size).to eq(1)
-      end
-
-      context "with append: true" do
-        let(:options) { { append: true } }
-
-        it "appends to previously assigned files" do
-          post.documents_files = [
-            Refile::FileDouble.new("hello"),
-            Refile::FileDouble.new("world")
-          ]
-          post.save
-          post.update_attributes documents_files: [
-            Refile::FileDouble.new("foo")
-          ]
-          retrieved = post_class.find(post.id)
-          expect(retrieved.documents[0].file.read).to eq("hello")
-          expect(retrieved.documents[1].file.read).to eq("world")
-          expect(retrieved.documents[2].file.read).to eq("foo")
-          expect(retrieved.documents.size).to eq(3)
-        end
-
-        it "appends to previously assigned files with cached files" do
-          post.documents_files = [
-            Refile::FileDouble.new("hello"),
-            Refile::FileDouble.new("world")
-          ]
-          post.save
-          post.update_attributes documents_files: [
-            [{
-              id: Refile.cache.upload(Refile::FileDouble.new("hello")).id,
-              filename: "some.jpg",
-              content_type: "image/jpeg",
-              size: 1234
-            }].to_json
-          ]
-          retrieved = post_class.find(post.id)
-          expect(retrieved.documents.size).to eq(3)
-        end
-      end
-    end
-
-    describe "#:association_:name_data" do
-      it "returns metadata of all files" do
-        post.documents_files = [nil, Refile::FileDouble.new("hello"), Refile::FileDouble.new("world")]
-        data = post.documents_files_data
-        expect(Refile.cache.read(data[0][:id])).to eq("hello")
-        expect(Refile.cache.read(data[1][:id])).to eq("world")
-        expect(data.size).to eq(2)
-      end
     end
   end
 

data/spec/refile/attachment_helper_spec.rb

@@ -39,13 +39,36 @@ describe Refile::AttachmentHelper do
   end
 
   describe "#attachment_field" do
+    subject(:field) { attachment_field("post", :document, field_options) }
+    let(:field_options) { { object: klass.new } }
+    let(:html) { Capybara.string(field) }
+    let(:expected_field_name) { "post[0][document]" }
+    let(:selector_css) { "input[name='#{expected_field_name}'][type=hidden]" }
+    let(:input_css) { "input[name='post[document]'][type=hidden]" }
+
     context "with index given" do
-      let(:html) { Capybara.string(attachment_field("post", :document, object: klass.new, index: 0)) }
+      let(:field_options) { super().merge index: 0 }
 
       it "generates file and hidden inputs with identical names" do
-        field_name = "post[0][document]"
-        expect(html).to have_field(field_name, type: "file")
-        expect(html).to have_selector(:css, "input[name='#{field_name}'][type=hidden]", visible: false, count: 1)
+        expect(html).to have_field(expected_field_name, type: "file")
+        expect(html).to have_selector(:css, selector_css, visible: false, count: 1)
+      end
+    end
+
+    context "when attacher value is blank" do
+      let(:field_options) { super().merge object: klass.new(document: nil) }
+      it "generates metadata hidden with disabled attribute" do
+        expect(html.find(input_css, visible: false)["disabled"]).to eq "disabled"
+      end
+    end
+
+    context "when attacher value is present" do
+      let(:field_options) do
+        super().merge object: klass.new(document: StringIO.new("New params"))
+      end
+
+      it "generates metadata input without disabled attribute" do
+        expect(html.find(input_css, visible: false)["disabled"]).to be_nil
       end
     end
   end

data/spec/refile/attachment_spec.rb

@@ -1,3 +1,6 @@
+require "refile/active_record_helper"
+require_relative "support/accepts_attachments_for_shared_examples"
+
 describe Refile::Attachment do
   let(:options) { {} }
   let(:klass) do
@@ -189,7 +192,7 @@ describe Refile::Attachment do
         it "handles redirect loops by trowing errors" do
           expect do
             instance.remote_document_url = "http://www.example.com/loop"
-          end.to raise_error(RestClient::Exception)
+          end.to raise_error(Refile::TooManyRedirects)
         end
       end
 
@@ -586,4 +589,55 @@ describe Refile::Attachment do
     expect { p klass.ancestors }
       .to output(/Refile::Attachment\(document\)/).to_stdout
   end
+
+  describe ".accepts_nested_attributes_for" do
+    it_should_behave_like "accepts_attachments_for" do
+      let(:options) { {} }
+
+      # This class is a PORO, but it's implementing an interface that's similar
+      # to ActiveRecord's in order to simplify specs via shared examples.
+      let(:post_class) do
+        opts = options
+        foo = document_class
+
+        Class.new do
+          extend Refile::Attachment
+
+          attr_accessor :documents
+
+          accepts_attachments_for(
+            :documents,
+            accessor_prefix: "documents_files",
+            collection_class: foo,
+            **opts
+          )
+
+          def initialize(attributes)
+            @documents = attributes[:documents]
+          end
+
+          def save!; end
+
+          def update_attributes!(attributes)
+            attributes.each { |k, v| public_send("#{k}=", v) }
+          end
+        end
+      end
+
+      let(:document_class) do
+        Class.new do
+          extend Refile::Attachment
+          attr_accessor :file_id
+
+          attachment :file, type: :image, extension: %w[jpeg], raise_errors: false
+
+          def initialize(attributes = {})
+            self.file = attributes[:file]
+          end
+        end
+      end
+
+      let(:post) { post_class.new(documents: []) }
+    end
+  end
 end

data/spec/refile/download_spec.rb

@@ -0,0 +1,51 @@
+describe Refile::Download do
+  context "without redirects" do
+    it "fetches the file" do
+      stub_request(:get, "http://www.example.com/dummy").to_return(
+        status: 200,
+        body: "dummy",
+        headers: { "Content-Length" => 5, "Content-Type" => "text/plain" }
+      )
+
+      download = described_class.new("http://www.example.com/dummy")
+
+      expect(download.io.read).to eq("dummy")
+      expect(download.size).to eq(5)
+      expect(download.content_type).to eq("text/plain")
+      expect(download.original_filename).to eq("dummy")
+    end
+  end
+
+  context "with redirects" do
+    it "follows redirects and fetches the file" do
+      stub_request(:get, "http://www.example.com/1").to_return(
+        status: 302,
+        headers: { "Location" => "http://www.example.com/2" }
+      )
+
+      stub_request(:get, "http://www.example.com/2").to_return(
+        status: 200,
+        body: "dummy",
+        headers: { "Content-Length" => 5 }
+      )
+
+      download = described_class.new("http://www.example.com/1")
+
+      expect(download.io.read).to eq("dummy")
+      expect(download.size).to eq(5)
+      expect(download.content_type).to eq("application/octet-stream")
+      expect(download.original_filename).to eq("2")
+    end
+
+    it "handles redirect loops by throwing errors" do
+      stub_request(:get, "http://www.example.com/loop").to_return(
+        status: 302,
+        headers: { "Location" => "http://www.example.com/loop" }
+      )
+
+      expect do
+        described_class.new("http://www.example.com/loop")
+      end.to raise_error(Refile::TooManyRedirects)
+    end
+  end
+end

data/spec/refile/features/normal_upload_spec.rb

@@ -139,6 +139,6 @@ feature "Normal HTTP Post file uploads" do
     expect(download_link("Document")).to eq("abc")
     expect(page).to have_selector(".content-type", text: "image/png")
     expect(page).to have_selector(".size", text: "3")
-    expect(page).to have_selector(".filename", text: "some_file.png", exact: true)
+    expect(page).to have_selector(".filename", text: "some_file.png")
   end
 end

data/spec/refile/features/single_upload_spec.rb

@@ -0,0 +1,38 @@
+require "refile/test_app"
+
+feature "single attribute form upload" do
+  scenario "upload a single file insteaf of an array of files" do
+    visit "/single/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", path("hello.txt")
+    click_button "Create"
+
+    expect(download_link("Document: hello.txt")).to eq("hello")
+  end
+
+  scenario "Edit with changes" do
+    visit "/single/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", path("hello.txt")
+    click_button "Create"
+
+    visit "/single/posts/#{Post.last.id}/edit"
+    attach_file "Documents", path("monkey.txt")
+    click_button "Update"
+
+    expect(download_link("Document: monkey.txt")).to eq("monkey")
+    expect(page).not_to have_link("Document: hello.txt")
+  end
+
+  scenario "Edit without changes" do
+    visit "/single/posts/new"
+    fill_in "Title", with: "A cool post"
+    attach_file "Documents", path("hello.txt")
+    click_button "Create"
+
+    visit "/single/posts/#{Post.last.id}/edit"
+    click_button "Update"
+
+    expect(download_link("Document: hello.txt")).to eq("hello")
+  end
+end

data/spec/refile/support/accepts_attachments_for_shared_examples.rb

@@ -0,0 +1,232 @@
+RSpec.shared_examples "accepts_attachments_for" do
+  describe "#:association_:name=" do
+    it "builds records from assigned files" do
+      post.documents_files = [
+        Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+        Refile::FileDouble.new("world", content_type: "image/jpeg")
+      ]
+      post.save!
+
+      expect(post.documents.size).to eq(2)
+      expect(post.documents[0].file.read).to eq("hello")
+      expect(post.documents[1].file.read).to eq("world")
+    end
+
+    it "clears previously assigned files" do
+      post.documents_files = [
+        Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+        Refile::FileDouble.new("world", content_type: "image/jpeg")
+      ]
+      post.save!
+      post.update_attributes! documents_files: [
+        Refile::FileDouble.new("foo", content_type: "image/jpeg")
+      ]
+
+      expect(post.documents[0].file.read).to eq("foo")
+      expect(post.documents.size).to eq(1)
+    end
+
+    it "ignores nil assigned files" do
+      post.documents_files = [
+        Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+        nil,
+        nil
+      ]
+      post.save!
+
+      expect(post.documents.size).to eq(1)
+      expect(post.documents[0].file.read).to eq("hello")
+    end
+
+    it "builds records from cache" do
+      post.documents_files = [
+        [
+          {
+            id: Refile.cache.upload(Refile::FileDouble.new("hello")).id,
+            filename: "some.jpg",
+            content_type: "image/jpeg",
+            size: 1234
+          },
+          {
+            id: Refile.cache.upload(Refile::FileDouble.new("world")).id,
+            filename: "some.jpg",
+            content_type: "image/jpeg",
+            size: 1234
+          }
+        ].to_json
+      ]
+      post.save!
+
+      expect(post.documents.size).to eq(2)
+      expect(post.documents[0].file.read).to eq("hello")
+      expect(post.documents[1].file.read).to eq("world")
+    end
+
+    it "prefers uploaded files over cache when both are present" do
+      post.documents_files = [
+        [
+          {
+            id: Refile.cache.upload(Refile::FileDouble.new("moo")).id,
+            filename: "some.jpg",
+            content_type: "image/jpeg",
+            size: 1234
+          }
+        ].to_json,
+        Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+        Refile::FileDouble.new("world", content_type: "image/jpeg")
+      ]
+      post.save!
+
+      expect(post.documents.size).to eq(2)
+      expect(post.documents[0].file.read).to eq("hello")
+      expect(post.documents[1].file.read).to eq("world")
+    end
+
+    it "ignores empty caches" do
+      post.documents_files = [
+        [
+          {
+            id: Refile.cache.upload(Refile::FileDouble.new("moo")).id,
+            filename: "some.jpg",
+            content_type: "image/jpeg",
+            size: 1234
+          },
+          {},
+          {}
+        ].to_json
+      ]
+      post.save!
+
+      expect(post.documents.size).to eq(1)
+      expect(post.documents[0].file.read).to eq("moo")
+    end
+
+    it "ignores caches with malformed json" do
+      post.documents_files = [
+        "[{id: 'this is a ruby hash'}]"
+      ]
+
+      expect(post.documents.size).to be_zero
+    end
+
+    context "with append: true" do
+      let(:options) { { append: true } }
+
+      it "appends to previously assigned files" do
+        post.documents_files = [
+          Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+          Refile::FileDouble.new("world", content_type: "image/jpeg")
+        ]
+        post.save!
+        post.update_attributes! documents_files: [
+          Refile::FileDouble.new("foo", content_type: "image/jpeg")
+        ]
+
+        expect(post.documents.size).to eq(3)
+        expect(post.documents[0].file.read).to eq("hello")
+        expect(post.documents[1].file.read).to eq("world")
+        expect(post.documents[2].file.read).to eq("foo")
+      end
+
+      it "appends to previously assigned files with cached files" do
+        post.documents_files = [
+          Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+          Refile::FileDouble.new("world", content_type: "image/jpeg")
+        ]
+        post.save!
+        post.update_attributes! documents_files: [
+          [{
+            id: Refile.cache.upload(Refile::FileDouble.new("hello world")).id,
+            filename: "some.jpg",
+            content_type: "image/jpeg",
+            size: 1234
+          }].to_json
+        ]
+
+        expect(post.documents.size).to eq(3)
+        expect(post.documents[0].file.read).to eq("hello")
+        expect(post.documents[1].file.read).to eq("world")
+        expect(post.documents[2].file.read).to eq("hello world")
+      end
+
+      it "appends to previously cached files with cached files" do
+        post.documents_files = [
+          [
+            {
+              id: Refile.cache.upload(Refile::FileDouble.new("moo")).id,
+              filename: "some1.jpg",
+              content_type: "image/jpeg",
+              size: 123
+            }
+          ].to_json
+        ]
+        post.documents_files = [
+          [
+            {
+              id: Refile.cache.upload(Refile::FileDouble.new("hello")).id,
+              filename: "some2.jpg",
+              content_type: "image/jpeg",
+              size: 1234
+            }
+          ].to_json
+        ]
+        post.save!
+
+        expect(post.documents.size).to eq(2)
+        expect(post.documents[0].file.read).to eq("moo")
+        expect(post.documents[1].file.read).to eq("hello")
+      end
+    end
+  end
+
+  describe "#:association_:name_data" do
+    it "returns metadata for all files" do
+      post.documents_files = [
+        nil,
+        Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+        Refile::FileDouble.new("world", content_type: "image/jpeg")
+      ]
+      data = post.documents_files_data
+
+      expect(data.size).to eq(2)
+      expect(Refile.cache.read(data[0][:id])).to eq("hello")
+      expect(Refile.cache.read(data[1][:id])).to eq("world")
+    end
+
+    context "when there are invalid files" do
+      it "only returns metadata for valid files " do
+        invalid_file = Refile::FileDouble.new("world", content_type: "text/plain")
+
+        post.documents_files = [invalid_file]
+        data = post.documents_files_data
+
+        expect(data).to be_nil
+      end
+    end
+  end
+
+  describe "#:association_:name" do
+    it "builds records from assigned files" do
+      post.documents_files = [
+        Refile::FileDouble.new("hello", content_type: "image/jpeg"),
+        Refile::FileDouble.new("world", content_type: "image/jpeg")
+      ]
+
+      expect(post.documents_files.size).to eq(2)
+      expect(post.documents_files[0].read).to eq("hello")
+      expect(post.documents_files[1].read).to eq("world")
+    end
+  end
+
+  describe "#:association_:name_attachment_definition" do
+    it "returns attachment definition" do
+      post.documents_files = [
+        Refile::FileDouble.new("hello", content_type: "image/jpeg")
+      ]
+
+      definition = post.documents_files_attachment_definition
+      expect(definition).to be_a Refile::AttachmentDefinition
+      expect(definition.name).to eq(:file)
+    end
+  end
+end

metadata

@@ -1,35 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: leifcr-refile
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.7.0
 platform: ruby
 authors:
 - Jonas Nicklas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-08 00:00:00.000000000 Z
+date: 2019-06-17 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rest-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -79,11 +59,13 @@ files:
 - lib/refile/attacher.rb
 - lib/refile/attachment.rb
 - lib/refile/attachment/active_record.rb
+- lib/refile/attachment/multiple_attachments.rb
 - lib/refile/attachment_definition.rb
 - lib/refile/backend/file_system.rb
 - lib/refile/backend/s3.rb
 - lib/refile/backend_macros.rb
 - lib/refile/custom_logger.rb
+- lib/refile/download.rb
 - lib/refile/file.rb
 - lib/refile/file_double.rb
 - lib/refile/image_processing.rb
@@ -103,17 +85,20 @@ files:
 - spec/refile/backend_examples.rb
 - spec/refile/backend_macros_spec.rb
 - spec/refile/custom_logger_spec.rb
+- spec/refile/download_spec.rb
 - spec/refile/features/direct_upload_spec.rb
 - spec/refile/features/multiple_upload_spec.rb
 - spec/refile/features/normal_upload_spec.rb
 - spec/refile/features/presigned_upload_spec.rb
 - spec/refile/features/simple_form_spec.rb
+- spec/refile/features/single_upload_spec.rb
 - spec/refile/fixtures/hello.txt
 - spec/refile/fixtures/image.jpg
 - spec/refile/fixtures/large.txt
 - spec/refile/fixtures/monkey.txt
 - spec/refile/fixtures/world.txt
 - spec/refile/spec_helper.rb
+- spec/refile/support/accepts_attachments_for_shared_examples.rb
 - spec/refile_spec.rb
 homepage: https://github.com/refile/refile
 licenses:
@@ -135,8 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Simple and powerful file upload library