paperclip-storage-tmp 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+/.bundle
+/Gemfile.lock
+/pkg
+/.rvmrc
+/vendor/paperclip

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## 0.0.1 (2012-05-11):
+
+* Implement `Paperclip::Storage::Tmp.clear` which clears all
+  attachments from the filesystem (and from the "virtual" filesystem)
+* Provide a `:tmp` storage option for Paperclip attachments

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in paperclip-storage-tmp.gemspec
+gemspec
+
+gem 'paperclip', path: 'vendor/paperclip'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Olek Janiszewski
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,154 @@
+# paperclip-storage-tmp
+
+This gem allows you to configure Paperclip 2.x to use your temporary directory to store the attachments. The attachments are deleted as soon as your Ruby process exits, or whenever you ask the gem to delete them (e.g. after every test), ensuring isolated state for each test.
+
+Thanks to this gem your `public/system` directory is no longer cluttered with attachments dangling in there after your test suite has finished running.
+
+It also prevents the attachments created by tests from conflicting with attachments uploaded in development. Storing the images using the default, `filesystem` storage both in development and test environments may lead to false positives and other unexpected behaviour in your tests.
+
+As an example, imagine you upload an avatar in development. It will probably land in a path similar to `public/system/users/123/avatars/original/hey_mom_its_me.png` (assuming the user's ID is 123). If you feed your application with some kind of fixtures, you probably have hundreds of such files. Now imagine you also have the following test:
+
+    describe User do
+      it 'assigns a default avatar' do
+        user = User.new
+
+        # This method is supposed to assign a default
+        # avatar to the user (called "hey_mom_its_me.png"),
+        # and save the record
+        user.assign_default_avatar!
+
+        # Yikes! False positive alert!
+        user.avatar.should be_present
+      end
+    end
+
+In the test above, `user.avatar.present?` will check if a file `public/system/users/:id/avatars/original/hey_mom_its_me.jpg` exists. That file could as well have been uploaded in development, and even if your method `assign_default_avatar!` is not doing what you expect it to, your test is still passing.
+
+Just like you wouldn't want to use the same database in development and test, you probably don't want to use the same storage directory (which also is a kind of a database).
+
+## Compatibility with Paperclip versions
+
+Please note that this gem has been written with Paperclip 2.x in mind (extracted from and battle-tested in an application dependent on Paperclip 2.4.0). The gemspec declares a rather loose dependency on Paperclip of '~> 2.0', so make sure the gem is behaving as expected. Since it's supposed to be used only in test environment, it shouldn't be harmful to just give it a try. If you confirm that it's working for the version of Paperclip you're using, let me know.
+
+Any pull requests increasing compatibility with other versions welcome!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'paperclip-storage-tmp', group: 'test'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install paperclip-storage-tmp
+
+## Usage
+
+### Configuring Paperclip to use the temporary storage
+
+To use the tmp storage, simply provide the `:storage` option with the value of `:tmp`, e.g.:
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar, storage: :tmp
+    end
+
+Unless you're drunk, you probably want to do this conditionally:
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar, storage: (Rails.env.test? ? :tmp : :filesystem)
+    end
+
+Or use some kind of environment-aware config parameter:
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar, storage: MyApp.config.paperclip.storage
+    end
+
+If you want to configure this option globally for all attachments, use an initializer:
+
+    # in config/initializers/paperclip.rb
+    Paperclip::Attachment.default_options[:storage] = MyApp.config.paperclip.storage
+
+### Configuring your tests to delete the attachments after every test
+
+The most important part is actually "rolling back the filesystem" after every test, so that the next test will run with isolated state. That's where the `Paperclip::Storage::Tmp.clear` method comes in handy. Call this method in the `teardown`/`after` block of your test framework. Here's an example for `RSpec`:
+
+    # in spec/spec_helper.rb
+    RSpec.configure do |config|
+      config.after do
+        Paperclip::Storage::Tmp.clear
+      end
+    end
+
+## Caveats
+
+Beware that the file name assigned to the model attribute (`<attachment>_file_name`) is different than the name of the assigned/uploaded file (it's the name of the temporary file - a unique string).
+
+Also, Paperclip doesn't know that the file doesn't physically exist in `public/system`, so you can't use `Attachment#path` to access the physical file. You can use `attachment.to_file.path` to find the actual location of the attachment on disk.
+
+Here are a couple of specs, which expose the expected behaviour of this gem. The specs markes with `# FAIL` expose the caveats:
+
+    describe User do
+      describe 'avatar' do
+        let(:user) { User.create!(avatar: File.new('spec/fixtures/hey_mom_its_me.png')) }
+        subject { user.avatar }
+
+        it { should exist }
+        its(:content_type) { should eq('image/png') }
+        its(:original_filename) { should eq('hey_mom_its_me.png') }
+
+        its(:path) { should eq(Rails.root + "/public/system/avatars/1/original/hey_mom_its_me.png") }
+        its(:to_file) { should be_a(File) }
+
+        it 'is actually stored in /tmp' do
+          File.exists?(subject.path).should be_false # FAIL
+          subject.to_file.path.should match(%r{^/tmp/})
+        end
+
+        it 'copies the assigned file' do
+          File.read(subject.to_file).should eq(File.read(avatar_file))
+        end
+
+        it 'stores the file in an imagemagick-friendly way' do
+          geometry = Paperclip::Geometry.from_file(subject.to_file)
+          geometry.width.should eq(256)
+          geometry.height.should eq(256)
+        end
+
+        it 'stores the file attributes in the model' do
+          user.avatar_file_name.should eq('hey_mom_its_me.png')
+          user.avatar_content_type.should eq('image/png')
+          user.avatar_file_size.should eq(File.size(avatar_file))
+        end
+
+        it 'can handle assignment from File' do
+          new_user = User.new(avatar: avatar_file)
+          new_user.avatar_file_name.should eq('hey_mom_its_me.png')
+        end
+
+        it 'can persist assignment from File' do
+          new_user = User.create!(avatar: avatar_file)
+          new_user.reload.avatar_file_name.should eq('hey_mom_its_me.png')
+        end
+
+        # :(
+        it 'cannot handle assignment from Paperclip::Attachment' do
+          new_user = User.new(avatar: subject)
+          new_user.avatar_file_name.should_not eq('hey_mom_its_me.png') # FAIL
+        end
+      end
+    end
+
+## Contributing
+
+In development, the Gemfile points to a version of Paperclip from `vendor/paperclip`, so make sure you have a clone of Paperclip there (e.g. `git clone git://github.com/thoughtbot/paperclip vendor`). You can checkout any version you want to test against.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/paperclip-storage-tmp.rb

@@ -0,0 +1,3 @@
+require 'paperclip-storage-tmp/version'
+require 'paperclip'
+require 'paperclip/storage/tmp'

data/lib/paperclip-storage-tmp/version.rb

@@ -0,0 +1,7 @@
+module Paperclip
+  module Storage
+    module Tmp
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/paperclip/storage/tmp.rb

@@ -0,0 +1,42 @@
+module Paperclip
+  module Storage
+    module Tmp
+      def self.fs
+        @fs ||= {}
+      end
+
+      # Deletes the temporary files and releases references to them
+      def self.clear
+        fs.each_value {|f| f.unlink }
+        @fs = nil
+      end
+
+      def exists?(style_name = default_style)
+        Tmp.fs.key?(path(style_name))
+      end
+
+      def to_file(style_name = default_style)
+        @queued_for_write[style_name] || (File.new(Tmp.fs[path(style_name)], 'rb') if exists?(style_name))
+      end
+
+      def flush_writes
+        @queued_for_write.each do |style_name, file|
+          Tmp.fs[path(style_name)] = to_tempfile(file)
+        end
+
+        after_flush_writes
+        @queued_for_write = {}
+      end
+
+      def flush_deletes
+        @queued_for_delete.each do |path|
+          if file = Tmp.fs.delete(path)
+            file.unlink
+          end
+        end
+
+        @queued_for_delete = []
+      end
+    end
+  end
+end

data/paperclip-storage-tmp.gemspec

@@ -0,0 +1,20 @@
+# encoding: utf-8
+require File.expand_path('../lib/paperclip-storage-tmp/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Olek Janiszewski']
+  gem.email         = ['olek.janiszewski@gmail.com']
+  gem.description   = %q{Store Paperclip attachments in your temporary directory}
+  gem.summary       = %q{Keep your tests clean by isolating test attachments from development, and between tests}
+  gem.homepage      = 'https://github.com/exviva/paperclip-storage-tmp'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.name          = 'paperclip-storage-tmp'
+  gem.require_paths = ['lib']
+  gem.version       = Paperclip::Storage::Tmp::VERSION
+
+  gem.add_runtime_dependency 'paperclip', '~> 2.0'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'sqlite3'
+end

data/spec/fixtures/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  has_attached_file :avatar, storage: :tmp
+end

data/spec/lib/paperclip/storage/tmp_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Paperclip::Storage::Tmp do
+  after do
+    Paperclip::Storage::Tmp.clear
+  end
+
+  let(:avatar_file) { File.new('spec/fixtures/hey_mom_its_me.png') }
+
+  [proc { user.avatar }, proc { user.reload.avatar }].each do |subject_proc|
+    describe 'assigning an attachment' do
+      let(:user) { User.create!(avatar: avatar_file) }
+      subject(&subject_proc)
+
+      it { should exist }
+      its(:content_type) { should eq('image/png') }
+      its(:original_filename) { should eq('hey_mom_its_me.png') }
+
+      its(:path) { should eq(Rails.root + "/public/system/avatars/1/original/hey_mom_its_me.png") }
+      its(:to_file) { should be_a(File) }
+
+      it 'is actually stored in /tmp' do
+        File.exists?(subject.path).should be_false
+        subject.to_file.path.should match(%r{^/tmp/})
+      end
+
+      it 'copies the assigned file' do
+        File.read(subject.to_file).should eq(File.read(avatar_file))
+      end
+
+      it 'stores the file in an imagemagick-friendly way' do
+        geometry = Paperclip::Geometry.from_file(subject.to_file)
+        geometry.width.should eq(256)
+        geometry.height.should eq(256)
+      end
+
+      it 'stores the file attributes in the model' do
+        user.avatar_file_name.should eq('hey_mom_its_me.png')
+        user.avatar_content_type.should eq('image/png')
+        user.avatar_file_size.should eq(File.size(avatar_file))
+      end
+
+      it 'can handle assignment from File' do
+        new_user = User.new(avatar: avatar_file)
+        new_user.avatar_file_name.should eq('hey_mom_its_me.png')
+      end
+
+      it 'can persist assignment from File' do
+        new_user = User.create!(avatar: avatar_file)
+        new_user.reload.avatar_file_name.should eq('hey_mom_its_me.png')
+      end
+
+      # :(
+      it 'cannot handle assignment from Paperclip::Attachment' do
+        new_user = User.new(avatar: subject)
+        new_user.avatar_file_name.should_not eq('hey_mom_its_me.png')
+      end
+    end
+
+    describe 'not assigning an attachment' do
+      let(:user) { User.create! }
+      subject(&subject_proc)
+
+      it { should_not exist }
+      its(:content_type) { should be_nil }
+      its(:original_filename) { should be_nil }
+      its(:path) { should be_nil }
+      its(:to_file) { should be_nil }
+    end
+  end
+
+  describe 'destroying an attachment' do
+    let(:user) { User.create!(avatar: avatar_file) }
+    subject do
+      @path_before_destroy = user.avatar.to_file.path
+      user.destroy
+
+      user.avatar
+    end
+
+    it { should_not exist }
+
+    it 'should be deleted from the filesystem' do
+      subject
+      File.exists?(@path_before_destroy).should be_false
+    end
+  end
+
+  describe 'clear' do
+    let(:user) { User.create!(avatar: avatar_file) }
+    subject { Paperclip::Storage::Tmp.clear }
+
+    it 'deletes files' do
+      path = user.avatar.to_file.path
+      subject
+      File.exists?(path).should be_false
+    end
+
+    it 'deletes the files from virtual fs' do
+      user.avatar.should exist
+      subject
+      user.avatar.should_not exist
+    end
+  end
+end

data/spec/meta_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe 'spec_helper' do
+  it 'successfully connects to an in-memory database' do
+    User.connection_config[:adapter].should eq('sqlite3')
+    User.connection_config[:database].should eq(':memory:')
+    User.create!
+    User.count.should eq(1)
+  end
+
+  it 'rolls back between examples' do
+    User.count.should eq(0)
+  end
+
+  it 'defines Rails.root' do
+    Rails.root.should eq(File.expand_path('../..', __FILE__))
+  end
+end
+
+describe User do
+  it 'is an active record' do
+    User.new.should be_an(ActiveRecord::Base)
+  end
+
+  it 'has an avatar' do
+    User.new.avatar.should be_a(Paperclip::Attachment)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'bundler'
+Bundler.setup
+
+require 'paperclip-storage-tmp'
+Dir[File.dirname(__FILE__) + '/support/*.rb'].each {|f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+end

data/spec/support/active_record.rb

@@ -0,0 +1,15 @@
+require 'active_record'
+ActiveRecord::Base.send(:include, Paperclip::Glue)
+require 'fixtures/user'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define do
+  create_table :users do |t|
+    t.string   :avatar_file_name
+    t.string   :avatar_content_type
+    t.integer  :avatar_file_size
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+end

data/spec/support/fake_rails.rb

@@ -0,0 +1,3 @@
+module Rails
+  def self.root; File.expand_path('../../..', __FILE__); end
+end

data/spec/support/paperclip.rb

@@ -0,0 +1 @@
+Paperclip.logger = Logger.new(STDOUT).tap {|l| l.level = Logger::WARN }

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: paperclip-storage-tmp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Olek Janiszewski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: paperclip
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Store Paperclip attachments in your temporary directory
+email:
+- olek.janiszewski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/paperclip-storage-tmp.rb
+- lib/paperclip-storage-tmp/version.rb
+- lib/paperclip/storage/tmp.rb
+- paperclip-storage-tmp.gemspec
+- spec/fixtures/hey_mom_its_me.png
+- spec/fixtures/user.rb
+- spec/lib/paperclip/storage/tmp_spec.rb
+- spec/meta_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/fake_rails.rb
+- spec/support/paperclip.rb
+- vendor/.gitkeep
+homepage: https://github.com/exviva/paperclip-storage-tmp
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Keep your tests clean by isolating test attachments from development, and
+  between tests
+test_files:
+- spec/fixtures/hey_mom_its_me.png
+- spec/fixtures/user.rb
+- spec/lib/paperclip/storage/tmp_spec.rb
+- spec/meta_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/fake_rails.rb
+- spec/support/paperclip.rb