attachment_saver 1.0.0

data/test/mini_magick_processor_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_processor_test_common'))
+require 'processors/mini_magick'
+
+class MiniMagickProcessorTest < Test::Unit::TestCase
+  class MiniMagickTestModel
+    include AttachmentSaver::InstanceMethods
+    include AttachmentSaver::Processors::MiniMagick
+    include ImageProcessorTestModel
+  end
+  
+  def processor_model
+    MiniMagickTestModel
+  end
+  
+  def processor_exception
+    MiniMagickProcessorError
+  end
+
+  include ImageProcessorTests
+end

data/test/model_test.rb

@@ -0,0 +1,205 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_fixtures'))
+
+class DerivedImage < ActiveRecord::Base
+  saves_attachment
+end
+
+class Image < ActiveRecord::Base
+  FORMATS = {:thumb =>  [:cover_and_crop,  50,   50],
+           :medium => [:shrink_to_fit,  500,  500],
+           :big =>    [:shrink_to_fit, 1024, 1024]}
+  saves_attachment :formats => FORMATS
+end
+
+class OtherImage < ActiveRecord::Base
+  saves_attachment :formats => {:small => [:shrink_to_fit, 200, 200], :normal => [:shrink_to_fit, 400, 300]}
+  cattr_accessor :want_smalls
+  
+protected
+  def want_format?(format_name, width, height)
+    format_name != :small || self.class.want_smalls
+  end
+end
+
+class Unprocessed < ActiveRecord::Base
+  saves_attachment
+  validates_presence_of :original_filename, :content_type, :size
+end
+
+class LoadedImage < ActiveRecord::Base
+  set_table_name 'images'
+  saves_attachment :processor => 'image_science' # don't create any derived images, but still process the image to get the attributes
+end
+
+class AllInOneTableImages < ActiveRecord::Base
+  saves_attachment :formats => {:small => '200x200', :normal => '400x'},
+                   :derived_class => 'AllInOneTableImages'
+end
+
+class ImageScienceImage < ActiveRecord::Base
+  set_table_name 'images'
+  saves_attachment :processor => 'ImageScience', :formats => {:small => '200x200'}
+end
+
+class RMagickImage < ActiveRecord::Base
+  set_table_name 'images'
+  saves_attachment :processor => 'RMagick', :formats => {:small => '200x200'}
+end
+
+class MiniMagickImage < ActiveRecord::Base
+  set_table_name 'images'
+  saves_attachment :processor => 'RMagick', :formats => {:small => '200x200'}
+end
+
+class ModelTest < Test::Unit::TestCase
+  module ValidUploadedFileAttributes
+    def fixture=(value)
+      @fixture = value
+    end
+    
+    def original_filename
+      @fixture[:original_filename]
+    end
+    
+    def content_type
+      @fixture[:content_type]
+    end
+
+    def size
+      stat.size
+    end
+  end
+  
+  def uploaded_file_from(fixture)
+    f = File.open(fixture[:path])
+    f.extend ValidUploadedFileAttributes
+    f.fixture = fixture
+    f
+  end
+
+  def test_unprocessed_attachment
+    model = Unprocessed.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ImageFixtures::valid[:expected_content_type], model.content_type
+    assert_equal ImageFixtures::valid[:expected_extension], model.file_extension
+    assert_equal ImageFixtures::valid[:expected_extension], AttachmentSaver::split_filename(model.storage_filename).last
+    assert File.read(ImageFixtures::valid[:path]) == File.read(model.storage_filename), "stored data doesn't match!"
+  end
+  
+  def test_underived_but_processed_attachment
+    model = LoadedImage.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ImageFixtures::valid[:expected_content_type], model.content_type
+    assert_equal ImageFixtures::valid[:expected_extension], model.file_extension
+    assert_equal ImageFixtures::valid[:expected_extension], AttachmentSaver::split_filename(model.storage_filename).last
+    assert File.read(ImageFixtures::valid[:path]) == File.read(model.storage_filename), "stored data doesn't match!"
+    assert_equal ImageFixtures::valid[:width], model.width
+    assert_equal ImageFixtures::valid[:height], model.height
+    assert_equal "#{ImageFixtures::valid[:width]}x#{ImageFixtures::valid[:height]}", model.image_size
+  end
+  
+  def test_extension_and_type_correction
+    model = LoadedImage.create!(:uploaded_data => uploaded_file_from(ImageFixtures::wrong_extension))
+    assert_equal ImageFixtures::wrong_extension[:expected_content_type], model.content_type
+    assert_equal ImageFixtures::wrong_extension[:expected_extension], model.file_extension
+    assert_equal ImageFixtures::wrong_extension[:expected_extension], AttachmentSaver::split_filename(model.storage_filename).last
+    assert File.read(ImageFixtures::wrong_extension[:path]) == File.read(model.storage_filename), "stored data doesn't match!"
+    assert_equal ImageFixtures::wrong_extension[:width], model.width
+    assert_equal ImageFixtures::wrong_extension[:height], model.height
+    assert_equal "#{ImageFixtures::wrong_extension[:width]}x#{ImageFixtures::wrong_extension[:height]}", model.image_size
+  end
+  
+  def test_image_resizing
+    model = Image.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ImageFixtures::valid[:expected_content_type], model.content_type
+    assert_equal ImageFixtures::valid[:expected_extension], model.file_extension
+    assert_equal ImageFixtures::valid[:expected_extension], AttachmentSaver::split_filename(model.storage_filename).last
+    assert File.read(ImageFixtures::valid[:path]) == File.read(model.storage_filename), "stored data doesn't match!"
+    assert_equal ImageFixtures::valid[:width], model.width
+    assert_equal ImageFixtures::valid[:height], model.height
+    assert_equal "#{ImageFixtures::valid[:width]}x#{ImageFixtures::valid[:height]}", model.image_size
+    
+    # full resize operation tests are performed in image_*_processor_test, here we just check enough to ensure that they were executed
+    
+    assert_equal Image::FORMATS.keys.collect(&:to_s).sort, model.formats.collect(&:format_name).sort
+    model.formats.each {|size| assert !size.new_record?}
+    
+    thumb = model.formats.find_by_format_name('thumb')
+    assert_equal Image::FORMATS[:thumb][1], thumb.width
+    assert_equal Image::FORMATS[:thumb][1], thumb.height
+    
+    medium = model.formats.find_by_format_name('medium')
+    assert medium.width <= Image::FORMATS[:medium][1]
+    assert medium.height <= Image::FORMATS[:medium][2]
+    assert medium.width == Image::FORMATS[:medium][1] || medium.height == Image::FORMATS[:medium][2]
+  end
+  
+  def test_image_science
+    model = ImageScienceImage.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ['small'], model.formats.collect(&:format_name)
+  end
+  
+  def test_rmagick
+    model = RMagickImage.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ['small'], model.formats.collect(&:format_name)
+  end
+  
+  def test_mini_magick
+    model = MiniMagickImage.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ['small'], model.formats.collect(&:format_name)
+  end
+  
+  def test_image_rebuilding
+    model = Image.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    old_storage_filenames = [model.storage_filename] + model.formats.sort_by(&:format_name).collect(&:storage_filename)
+    model.update_attributes(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    new_storage_filenames = [model.storage_filename] + model.formats.sort_by(&:format_name).collect(&:storage_filename)
+    model.reload
+    model.formats(true)
+    reloaded_storage_filenames = [model.storage_filename] + model.formats.sort_by(&:format_name).collect(&:storage_filename)
+    
+    assert_equal Image::FORMATS.size, model.formats.size
+    assert_equal Image::FORMATS.keys.collect(&:to_s).sort, model.formats.collect(&:format_name).sort
+    
+    assert_equal old_storage_filenames.size, new_storage_filenames.size
+    assert_equal old_storage_filenames.size, reloaded_storage_filenames.size
+    old_storage_filenames.each_with_index do |f, i|
+      assert_not_equal f, new_storage_filenames[i]
+      assert_not_equal f, reloaded_storage_filenames[i]
+      assert_equal new_storage_filenames[i], reloaded_storage_filenames[i]
+    end
+  end
+  
+  def test_want_format?
+    OtherImage.want_smalls = false
+    model = OtherImage.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ["normal"], model.formats.collect(&:format_name).sort
+
+    OtherImage.want_smalls = true
+    model = OtherImage.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ["normal", "small"], model.formats.collect(&:format_name).sort
+
+    OtherImage.want_smalls = false
+    model.update_attributes!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    #assert_equal ["normal"], model.formats.collect(&:format_name).sort # because we use formats.destroy(..ids..), they really should be removed from the formats collection in memory, but aren't in Rails 1.2.3 :/.  so the normal, expected semantics is that apps must reload to see collection changes.
+    assert_equal ["normal"], model.formats(true).collect(&:format_name).sort
+    # note that the small size has not only been not regenerated, it's been deleted
+  end
+  
+  def test_all_in_one_table
+    model = AllInOneTableImages.create!(:uploaded_data => uploaded_file_from(ImageFixtures::valid))
+    assert_equal ImageFixtures::valid[:expected_content_type], model.content_type
+    assert_equal ImageFixtures::valid[:expected_extension], model.file_extension
+    assert_equal ImageFixtures::valid[:expected_extension], AttachmentSaver::split_filename(model.storage_filename).last
+    assert File.read(ImageFixtures::valid[:path]) == File.read(model.storage_filename), "stored data doesn't match!"
+    assert_equal ImageFixtures::valid[:width], model.width
+    assert_equal ImageFixtures::valid[:height], model.height
+    assert_equal "#{ImageFixtures::valid[:width]}x#{ImageFixtures::valid[:height]}", model.image_size
+    
+    assert !model.formats.empty?
+    model.formats.each do |size|
+      assert_equal AllInOneTableImages, size.class
+      assert !size.new_record?
+      assert size.formats.empty?
+    end
+  end
+end

data/test/rmagick_processor_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'image_processor_test_common'))
+require 'processors/r_magick'
+
+class RMagickProcessorTest < Test::Unit::TestCase
+  class RMagickTestModel
+    include AttachmentSaver::InstanceMethods
+    include AttachmentSaver::Processors::RMagick
+    include ImageProcessorTestModel
+  end
+  
+  def processor_model
+    RMagickTestModel
+  end
+  
+  def processor_exception
+    RMagickProcessorError
+  end
+
+  include ImageProcessorTests
+end

data/test/schema.rb

@@ -0,0 +1,41 @@
+def add_generic_attachment_columns(t, want_image_columns)
+  t.string   :storage_key,         :null => false
+  t.string   :content_type,        :null => false
+  t.integer  :size,                :null => false
+  t.datetime :created_at,          :null => false
+  t.datetime :updated_at
+  t.integer  :width,               :null => false if want_image_columns
+  t.integer  :height,              :null => false if want_image_columns
+end
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :unprocesseds, :force => true do |t|
+    t.string   :original_filename, :null => false
+    add_generic_attachment_columns(t, false)
+  end
+
+  create_table :images, :force => true do |t|
+    t.string   :original_filename, :null => false
+    add_generic_attachment_columns(t, true)
+  end
+  
+  create_table :derived_images, :force => true do |t|
+    t.string   :original_type,     :null => false
+    t.integer  :original_id,       :null => false
+    t.string   :format_name,       :null => false
+    add_generic_attachment_columns(t, true)
+  end
+  
+  create_table :other_images, :force => true do |t| # for testing derived_image owner polymorphism
+    t.string   :original_filename, :null => false
+    add_generic_attachment_columns(t, true)
+  end
+  
+  create_table :all_in_one_table_images, :force => true do |t|
+    t.string   :original_filename # will be null for deriveds
+    t.string   :original_type     # will be null for originals
+    t.integer  :original_id       # ditto
+    t.string   :format_name       # ditto
+    add_generic_attachment_columns(t, true)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,49 @@
+if File.exist?("../../../config/boot.rb")
+  require "../../../config/boot.rb"
+else
+  require 'rubygems'
+end
+
+gem 'activesupport', ENV['RAILS_VERSION']
+gem 'activerecord',  ENV['RAILS_VERSION']
+
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'active_record'
+require 'active_record/fixtures'
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+  # ruby-debug not installed, no debugging for you
+end
+
+RAILS_ROOT = File.dirname(__FILE__)
+RAILS_ENV = ENV['RAILS_ENV'] ||= 'test'
+TEST_TEMP_DIR = File.join(File.dirname(__FILE__), 'tmp', 'attachment_saver_test')
+
+class Rails
+  def self.root; RAILS_ROOT; end
+  def self.env;  RAILS_ENV;  end
+end
+
+class DummyLogger
+  def method_missing(*args)
+  end
+end
+
+ActiveRecord::Base.logger = DummyLogger.new
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.join(File.dirname(__FILE__), "database.yml")))
+ActiveRecord::Base.establish_connection ActiveRecord::Base.configurations[ENV['RAILS_ENV']]
+load(File.join(File.dirname(__FILE__), "/schema.rb"))
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../init')) # load the plugin
+
+at_exit do # at_exits are run in reverse of declaration order, and Test::Unit runs from an at_exit, so we must declare ours before that require below
+  FileUtils.rm_rf(File.join(File.dirname(__FILE__), 'tmp'))
+end
+
+require 'test/unit'

metadata

@@ -0,0 +1,223 @@
+--- !ruby/object:Gem::Specification 
+name: attachment_saver
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Will Bryant
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-04-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: image_science
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mini_magick
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: |
+  This plugin implements attachment storage and processing, integrated with
+  ActiveRecord models and Ruby CGI/Rails-style uploads.  Image processing
+  operations including a number of different resizing & thumbnailing modes are
+  provided, and the architecture simplifies clean implementation of other types
+  of processing.  Errors are carefully handled to minimize the possibility of
+  broken uploads leaving incomplete or corrupt data.
+  
+  RMagick, MiniMagick, and ImageScience image processors are supported.
+  
+  
+  Compatibility
+  =============
+  
+  Currently tested against Rails 3.2.13 and 3.1.8, on Ruby 1.8.7 and 2.0.0p0.
+  Was also tested compatible with 2.3.14 and 3.0.17.
+
+email: will.bryant@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- MIT-LICENSE
+- README
+- Rakefile
+- attachment_saver.gemspec
+- init.rb
+- lib/attachment_saver.rb
+- lib/attachment_saver/version.rb
+- lib/attachment_saver_errors.rb
+- lib/datastores/file_system.rb
+- lib/datastores/in_column.rb
+- lib/misc/extended_tempfile.rb
+- lib/misc/file_size.rb
+- lib/misc/image_science_extensions.rb
+- lib/misc/mini_magick_extensions.rb
+- lib/processors/image.rb
+- lib/processors/image_science.rb
+- lib/processors/mini_magick.rb
+- lib/processors/r_magick.rb
+- test/attachment_saver_test.rb
+- test/database.yml
+- test/file_system_datastore_test.rb
+- test/fixtures/broken.jpg
+- test/fixtures/emptyextension.
+- test/fixtures/noextension
+- test/fixtures/test.jpg
+- test/fixtures/test.js
+- test/fixtures/wrongextension.png
+- test/image_fixtures.rb
+- test/image_operations.rb
+- test/image_processor_test.rb
+- test/image_processor_test_common.rb
+- test/image_science_processor_test.rb
+- test/in_column_datastore_test.rb
+- test/mini_magick_processor_test.rb
+- test/model_test.rb
+- test/public/.empty
+- test/rmagick_processor_test.rb
+- test/schema.rb
+- test/test_helper.rb
+homepage: http://github.com/willbryant/attachment_saver
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Saves attachments in files, models, or columns.
+test_files: 
+- test/attachment_saver_test.rb
+- test/database.yml
+- test/file_system_datastore_test.rb
+- test/fixtures/broken.jpg
+- test/fixtures/emptyextension.
+- test/fixtures/noextension
+- test/fixtures/test.jpg
+- test/fixtures/test.js
+- test/fixtures/wrongextension.png
+- test/image_fixtures.rb
+- test/image_operations.rb
+- test/image_processor_test.rb
+- test/image_processor_test_common.rb
+- test/image_science_processor_test.rb
+- test/in_column_datastore_test.rb
+- test/mini_magick_processor_test.rb
+- test/model_test.rb
+- test/public/.empty
+- test/rmagick_processor_test.rb
+- test/schema.rb
+- test/test_helper.rb