refile 0.4.2 → 0.5.0

data/lib/refile/signature.rb

@@ -1,7 +1,21 @@
 module Refile
+  # A signature summarizes an HTTP request a client can make to upload a file
+  # to directly upload a file to a backend. This signature is usually generated
+  # by a backend's `presign` method.
   class Signature
-    attr_reader :as, :id, :url, :fields
+    # @return [String] the name of the field that the file will be uploaded as.
+    attr_reader :as
 
+    # @return [String] the id the file will receive once uploaded.
+    attr_reader :id
+
+    # @return [String] the url the file should be uploaded to.
+    attr_reader :url
+
+    # @return [String] additional fields to be sent alongside the file.
+    attr_reader :fields
+
+    # @api private
     def initialize(as:, id:, url:, fields:)
       @as = as
       @id = id
@@ -9,6 +23,7 @@ module Refile
       @fields = fields
     end
 
+    # @return [Hash{Symbol => Object}] an object suitable for serialization to JSON
     def as_json(*)
       { as: @as, id: @id, url: @url, fields: @fields }
     end

data/lib/refile/type.rb

@@ -0,0 +1,28 @@
+module Refile
+  # A type represents an alias for one or multiple content types.
+  # By adding types, you could simplify this:
+  #
+  #     attachment :document, content_type: %w[text/plain application/pdf]
+  #
+  # To this:
+  #
+  #     attachment :document, type: :document
+  #
+  # Simply define a new type like this:
+  #
+  #     Refile.types[:document] = Refile::Type.new(:document,
+  #       content_type: %w[text/plain application/pdf]
+  #     )
+  #
+  class Type
+    # @return [String, Array<String>] The type's content types
+    attr_accessor :content_type
+
+    # @param [Symbol] name                            the name of the type
+    # @param [String, Array<String>] content_type     content types which are valid for this type
+    def initialize(name, content_type: nil)
+      @name = name
+      @content_type = content_type
+    end
+  end
+end

data/lib/refile/version.rb

@@ -1,3 +1,3 @@
 module Refile
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/refile.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |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"
 
@@ -38,4 +37,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "selenium-webdriver"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "redcarpet"
 end

data/spec/refile/active_record_helper.rb

@@ -0,0 +1,27 @@
+require "active_record"
+
+I18n.enforce_available_locales = true
+
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: File.expand_path("test_app/db/db.sqlite", File.dirname(__FILE__)),
+  verbosity: "quiet"
+)
+
+class TestMigration < ActiveRecord::Migration
+  def self.up
+    create_table :posts, force: true do |t|
+      t.column :title, :string
+      t.column :image_id, :string
+      t.column :image_content_type, :string
+      t.column :document_id, :string
+      t.column :document_filename, :string
+      t.column :document_content_type, :string
+      t.column :document_size, :integer
+    end
+  end
+end
+
+quietly do
+  TestMigration.up
+end

data/spec/refile/attachment/active_record_spec.rb

@@ -0,0 +1,92 @@
+require "refile/active_record_helper"
+require "refile/attachment/active_record"
+
+describe Refile::ActiveRecord::Attachment do
+  let(:options) { {} }
+  let(:klass) do
+    opts = options
+    Class.new(ActiveRecord::Base) do
+      self.table_name = :posts
+
+      def self.name
+        "Post"
+      end
+
+      attachment :document, **opts
+    end
+  end
+
+  describe "#valid?" do
+    let(:options) { { type: :image } }
+
+    context "with file" do
+      it "returns true when no file is assigned" do
+        post = klass.new
+        expect(post.valid?).to be_truthy
+        expect(post.errors[:document]).to be_empty
+      end
+
+      it "returns false when type is invalid" do
+        post = klass.new
+        post.document = Refile::FileDouble.new("hello", content_type: "text/plain")
+        expect(post.valid?).to be_falsy
+        expect(post.errors[:document].length).to eq(1)
+      end
+
+      it "returns true when type is invalid" do
+        post = klass.new
+        post.document = Refile::FileDouble.new("hello", content_type: "image/png")
+        expect(post.valid?).to be_truthy
+        expect(post.errors[:document]).to be_empty
+      end
+    end
+
+    context "with metadata" do
+      it "returns false when metadata doesn't have an id" do
+        Refile.cache.upload(StringIO.new("hello"))
+        post = klass.new
+        post.document = { content_type: "text/png" }.to_json
+        expect(post.valid?).to be_falsy
+        expect(post.errors[:document].length).to eq(1)
+      end
+
+      it "returns false when type is invalid" do
+        file = Refile.cache.upload(StringIO.new("hello"))
+        post = klass.new
+        post.document = { id: file.id, content_type: "text/png" }.to_json
+        expect(post.valid?).to be_falsy
+        expect(post.errors[:document].length).to eq(1)
+      end
+
+      it "returns true when type is invalid" do
+        file = Refile.cache.upload(StringIO.new("hello"))
+        post = klass.new
+        post.document = { id: file.id, content_type: "image/png" }.to_json
+        expect(post.valid?).to be_truthy
+        expect(post.errors[:document]).to be_empty
+      end
+    end
+  end
+
+  describe "#save" do
+    it "stores the assigned file" do
+      post = klass.new
+      post.document = Refile::FileDouble.new("hello")
+      post.save
+      post = klass.find(post.id)
+      expect(post.document.read).to eq("hello")
+      expect(Refile.store.read(post.document.id)).to eq("hello")
+    end
+  end
+
+  describe "#destroy" do
+    it "removes the stored file" do
+      post = klass.new
+      post.document = Refile::FileDouble.new("hello")
+      post.save
+      file = post.document
+      post.destroy
+      expect(file.exists?).to be_falsy
+    end
+  end
+end

data/spec/refile/attachment_spec.rb

@@ -5,7 +5,7 @@ describe Refile::Attachment do
     Class.new do
       extend Refile::Attachment
 
-      attr_accessor :document_id, :document_name, :document_size
+      attr_accessor :document_id, :document_filename, :document_size, :document_content_type
 
       attachment :document, **opts
     end
@@ -14,10 +14,46 @@ describe Refile::Attachment do
 
   describe ":name=" do
     it "receives a file, caches it and sets the _id parameter" do
-      instance.document = Refile::FileDouble.new("hello")
+      instance.document = Refile::FileDouble.new("hello", "foo.txt", content_type: "text/plain")
+
+      expect(instance.document.read).to eq("hello")
+
+      expect(instance.document_attacher.data[:filename]).to eq("foo.txt")
+      expect(instance.document_attacher.data[:size]).to eq(5)
+      expect(instance.document_attacher.data[:content_type]).to eq("text/plain")
+
+      expect(instance.document_filename).to eq("foo.txt")
+      expect(instance.document_size).to eq(5)
+      expect(instance.document_content_type).to eq("text/plain")
+    end
+
+    it "receives serialized data and retrieves file from it" do
+      file = Refile.cache.upload(Refile::FileDouble.new("hello"))
+      instance.document = { id: file.id, filename: "foo.txt", content_type: "text/plain", size: 5 }.to_json
+
+      expect(instance.document.read).to eq("hello")
+
+      expect(instance.document_attacher.data[:filename]).to eq("foo.txt")
+      expect(instance.document_attacher.data[:size]).to eq(5)
+      expect(instance.document_attacher.data[:content_type]).to eq("text/plain")
 
-      expect(Refile.cache.get(instance.document.id).read).to eq("hello")
-      expect(Refile.cache.get(instance.document_cache_id).read).to eq("hello")
+      expect(instance.document_filename).to eq("foo.txt")
+      expect(instance.document_size).to eq(5)
+      expect(instance.document_content_type).to eq("text/plain")
+    end
+
+    it "does nothing when assigned string lacks an id" do
+      instance.document = { size: 5 }.to_json
+
+      expect(instance.document).to be_nil
+      expect(instance.document_size).to be_nil
+    end
+
+    it "does nothing when assigned string is not valid JSON" do
+      instance.document = "size:f{oo}"
+
+      expect(instance.document).to be_nil
+      expect(instance.document_size).to be_nil
     end
   end
 
@@ -43,13 +79,26 @@ describe Refile::Attachment do
 
     context "without redirects" do
       before(:each) do
-        stub_request(:get, "http://www.example.com/some_file").to_return(status: 200, body: "abc", headers: { "Content-Length" => 3 })
+        stub_request(:get, "http://www.example.com/some_file.txt").to_return(
+          status: 200,
+          body: "abc",
+          headers: { "Content-Length" => 3, "Content-Type" => "text/plain" }
+        )
       end
 
-      it "downloads file, caches it and sets the _id parameter" do
-        instance.remote_document_url = "http://www.example.com/some_file"
+      it "downloads file, caches it and sets the _id parameter and metadata" do
+        instance.remote_document_url = "http://www.example.com/some_file.txt"
+        expect(instance.document.read).to eq("abc")
+
+        expect(instance.document_attacher.data[:filename]).to eq("some_file.txt")
+        expect(instance.document_attacher.data[:size]).to eq(3)
+        expect(instance.document_attacher.data[:content_type]).to eq("text/plain")
+
+        expect(instance.document_filename).to eq("some_file.txt")
+        expect(instance.document_size).to eq(3)
+        expect(instance.document_content_type).to eq("text/plain")
+
         expect(Refile.cache.get(instance.document.id).read).to eq("abc")
-        expect(Refile.cache.get(instance.document_cache_id).read).to eq("abc")
       end
     end
 
@@ -62,8 +111,9 @@ describe Refile::Attachment do
 
       it "follows redirects and fetches the file, caches it and sets the _id parameter" do
         instance.remote_document_url = "http://www.example.com/1"
+        expect(instance.document_filename).to eq("2")
+        expect(instance.document.read).to eq("woop")
         expect(Refile.cache.get(instance.document.id).read).to eq("woop")
-        expect(Refile.cache.get(instance.document_cache_id).read).to eq("woop")
       end
 
       context "when errors enabled" do
@@ -71,7 +121,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::MaxRedirectsReached)
+          end.to raise_error(RuntimeError, /redirection loop/)
         end
       end
 
@@ -88,15 +138,6 @@ describe Refile::Attachment do
     end
   end
 
-  describe ":name_cache_id" do
-    it "doesn't overwrite a cached file" do
-      instance.document = Refile::FileDouble.new("hello")
-      instance.document_cache_id = "xyz"
-
-      expect(instance.document.read).to eq("hello")
-    end
-  end
-
   describe ":name_attacher.store!" do
     it "puts a cached file into the store" do
       instance.document = Refile::FileDouble.new("hello")
@@ -107,7 +148,8 @@ describe Refile::Attachment do
       expect(Refile.store.get(instance.document_id).read).to eq("hello")
       expect(Refile.store.get(instance.document.id).read).to eq("hello")
 
-      expect(instance.document_cache_id).to be_nil
+      expect(instance.document.read).to eq("hello")
+      expect(instance.document_size).to eq(5)
       expect(Refile.cache.get(cache.id).exists?).to be_falsy
     end
 
@@ -133,7 +175,7 @@ describe Refile::Attachment do
       expect(Refile.store.get(instance.document_id).read).to eq("world")
       expect(Refile.store.get(instance.document.id).read).to eq("world")
 
-      expect(instance.document_cache_id).to be_nil
+      expect(instance.document.read).to eq("world")
       expect(Refile.cache.get(cache.id).exists?).to be_falsy
       expect(Refile.store.get(file.id).exists?).to be_falsy
     end
@@ -146,29 +188,28 @@ describe Refile::Attachment do
       instance.document_attacher.store!
 
       expect(instance.document_id).to be_nil
+      expect(instance.document_size).to be_nil
       expect(Refile.store.exists?(file.id)).to be_falsy
     end
   end
 
   describe ":name_attacher.delete!" do
     it "deletes a stored file" do
-      file = Refile.store.upload(Refile::FileDouble.new("hello"))
-      instance.document_id = file.id
+      instance.document = Refile::FileDouble.new("hello")
+      instance.document_attacher.store!
+      file = instance.document
 
       instance.document_attacher.delete!
 
-      expect(instance.document_id).to be_nil
       expect(Refile.store.exists?(file.id)).to be_falsy
     end
 
     it "deletes a cached file" do
-      file = Refile.cache.upload(Refile::FileDouble.new("hello"))
-      instance.document_cache_id = file.id
+      instance.document = Refile::FileDouble.new("hello")
+      file = instance.document
 
       instance.document_attacher.delete!
 
-      expect(instance.document_id).to be_nil
-      expect(instance.document_cache_id).to be_nil
       expect(Refile.cache.exists?(file.id)).to be_falsy
     end
   end
@@ -200,6 +241,83 @@ describe Refile::Attachment do
     end
   end
 
+  describe ":name_attacher.valid?" do
+    let(:options) { { type: :image, raise_errors: false } }
+
+    it "returns false if no file is attached" do
+      expect(instance.document_attacher.valid?).to be_falsy
+    end
+
+    it "returns false and if valid file is attached" do
+      file = Refile::FileDouble.new("hello", content_type: "image/png")
+
+      instance.document = file
+
+      expect(instance.document_attacher.valid?).to be_truthy
+    end
+
+    it "returns false and sets errors if invalid file is attached" do
+      file = Refile::FileDouble.new("hello", content_type: "text/plain")
+
+      instance.document = file
+
+      expect(instance.document_attacher.valid?).to be_falsy
+      expect(instance.document_attacher.errors).to eq([:invalid_content_type])
+    end
+  end
+
+  describe ":name_attacher.extension" do
+    it "is nil when not inferrable" do
+      file = Refile::FileDouble.new("hello")
+      instance.document = file
+      expect(instance.document_attacher.extension).to be_nil
+    end
+
+    it "is inferred from the filename" do
+      file = Refile::FileDouble.new("hello", "hello.txt")
+      instance.document = file
+      expect(instance.document_attacher.extension).to eq("txt")
+    end
+
+    it "is inferred from the content type" do
+      file = Refile::FileDouble.new("hello", content_type: "image/png")
+      instance.document = file
+      expect(instance.document_attacher.extension).to eq("png")
+    end
+
+    it "returns nil with unknown content type" do
+      file = Refile::FileDouble.new("hello", content_type: "foo/doesnotexist")
+      instance.document = file
+      expect(instance.document_attacher.extension).to be_nil
+    end
+
+    it "is nil when filename has no extension" do
+      file = Refile::FileDouble.new("hello", "hello")
+      instance.document = file
+      expect(instance.document_attacher.extension).to be_nil
+    end
+  end
+
+  describe ":name_attacher.basename" do
+    it "is nil when not inferrable" do
+      file = Refile::FileDouble.new("hello")
+      instance.document = file
+      expect(instance.document_attacher.basename).to be_nil
+    end
+
+    it "is inferred from the filename" do
+      file = Refile::FileDouble.new("hello", "hello.txt")
+      instance.document = file
+      expect(instance.document_attacher.basename).to eq("hello")
+    end
+
+    it "returns filename if filename has no extension" do
+      file = Refile::FileDouble.new("hello", "hello")
+      instance.document = file
+      expect(instance.document_attacher.basename).to eq("hello")
+    end
+  end
+
   describe ":name_attacher.error" do
     let(:options) { { cache: :limited_cache, raise_errors: false } }
 
@@ -358,4 +476,11 @@ describe Refile::Attachment do
       expect(instance.document).to be_nil
     end
   end
+
+  it "includes the module with methods in an instrospectable way" do
+    expect { puts klass.ancestors }
+      .to output(/Refile::Attachment\(document\)/).to_stdout
+    expect { p klass.ancestors }
+      .to output(/Refile::Attachment\(document\)/).to_stdout
+  end
 end