attacheable 1.1 → 1.2

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/gempackagetask'
 
 spec = Gem::Specification.new do |s|
   s.name = 'attacheable'
-  s.version = '1.1'
+  s.version = '1.2'
   s.summary = 'Library to handle image uploads'
   s.autorequire = 'attacheable'
   s.author  = "Max Lapshin"
@@ -25,7 +25,7 @@ spec = Gem::Specification.new do |s|
   5. create only one row in table for one image. No separate rows for each thumbnail."
   s.rubyforge_project = "attacheable"
   s.has_rdoc          = false
-  s.files = FileList["**"].exclude(".git").to_a
+  s.files = FileList["**/**"].exclude(".git").to_a
   
 end
 

data/lib/attacheable.rb

@@ -0,0 +1,239 @@
+require File.dirname(__FILE__)+"/attacheable/file_naming"
+require File.dirname(__FILE__)+"/attacheable/uploading"
+class ActiveRecord::Base
+  #
+  # In model write has_attachment (conflicts with acts_as_attachment) with options:
+  # 
+  # :thumbnails => list of thumbnails, i.e.  {:medium => "120x", :large => "800x600"}
+  # :croppable_thumbnails => list of thumbnails, which must be cropped to center, i.e.:  [:large, :preview]
+  # :path_prefix => path, where to store photos, i.e.: "public/system/photos"
+  # :replicas => [{:user => "user1", :host => "host1"}], list of hosts, where to clone all loaded originals
+  # :autocreate => true/false, whether to autocreate thumbnails on requesting thumbnail
+  #
+  # After this, add to routes:
+  #  map.assets 'system/photos/*path_info', :controller => "photos", :action => "show"
+  # and add to PhotosController:
+  # def show
+  #   photo, data = Photo.data_by_path_info(params[:path_info])
+  #   render :text => data, :content_type => photo && photo.content_type
+  # end
+  # This will enable creation on demand
+  #
+  # You can also add 
+  #  uri "/system/photos/", :handler => Attacheable::PhotoHandler.new("/system/photos"), :in_front => true 
+  # to any mongrel scripts for nonblocking image creation
+  # 
+  # Table for this plugin should have fields:
+  #       filename : string
+  #   content_type : string  (optional)
+  #          width : integer (optional)
+  #         heigth : integer (optional)
+  #
+  #
+  def self.has_attachment(options = {})
+    class_inheritable_accessor :attachment_options
+    self.attachment_options = options
+    
+    options.with_indifferent_access
+    options[:autocreate] ||= false
+    options[:thumbnails] ||= {}
+    options[:thumbnails].symbolize_keys!.with_indifferent_access
+    options[:croppable_thumbnails] ||= []
+    options[:croppable_thumbnails] = options[:croppable_thumbnails].map(&:to_sym)
+    options[:path_prefix] ||= "public/system/#{table_name}"
+    options[:valid_filetypes] ||= %w(jpeg gif png psd)
+    include(Attacheable)
+  end
+  
+  #
+  # Currently it will check valid filetype (unless option valid_filetypes set to :all)
+  #
+  def self.validates_as_attachment(options = {})
+    options[:message] ||= "Incorrect file type. Valid file types include: #{attachment_options[:valid_filetypes].to_sentence}"
+    self.attachment_options[:validation_message] = options[:message]
+    
+    validate :valid_filetype?
+  end
+end
+
+
+module Attacheable
+  include Attacheable::Uploading
+  include Attacheable::FileNaming
+
+  def self.included(base) #:nodoc:
+    base.before_update :rename_file
+    base.after_save :save_to_storage
+    base.after_destroy :remove_files
+    base.extend(ClassMethods)
+  end
+  
+  
+  def self.root
+    return RAILS_ROOT if defined?(RAILS_ROOT)
+    return Merb.root if defined?(Merb)
+    return File.dirname(__FILE__)+"/../.."
+  end
+
+  module ClassMethods
+
+    #
+    # You can delete all thumbnails or with selected type
+    #
+    def regenerate_thumbnails!(thumbnail = nil)
+      connection.select_values("select id from #{table_name}").each do |object_id|
+        object = find_by_id(object_id)
+        if object && object.filename
+          if thumbnail
+            FileUtils.rm_f(object.full_filename_without_creation(thumbnail))
+          else
+            to_remove = Dir["#{File.dirname(object.full_filename_without_creation)}/*"] - [object.full_filename_without_creation]
+            FileUtils.rm_f(to_remove)
+          end
+          #object.full_filename_with_creation(thumbnail)
+        end
+      end
+    end
+  
+    #
+    # It is designed to read  params[:path_info], or splitted PATH_INFO in mongrel handler
+    # It assumes, that path_info is of the following format ["0000", "0001", "file_medium.jpg"]
+    def data_by_path_info(path_info)
+      id1, id2, path = path_info
+      return [nil, nil] unless id1 && id2 && path
+      object = find(id1.to_i*1000 + id2.to_i)
+      if path = object.full_filename_by_path(path)
+        return [object, File.read(path)] if File.exists?(path)
+      end
+      [object, nil]
+    end
+  end
+
+  def attachment_options #:nodoc:
+    self.class.attachment_options
+  end
+
+  #
+  # Returns real path to original file if thumbnail is nil or path with thumbnail part inserted
+  # If options[:autocreate] is set to true, this method will autogenerate thumbnail
+  #
+  def full_filename(thumbnail = nil)
+    return "" if filename.blank?
+    attachment_options[:autocreate] ? full_filename_with_creation(thumbnail) : full_filename_without_creation(thumbnail)
+  end
+
+  def full_filename_by_path(path) #:nodoc:
+    return if filename.blank?
+    thumbnail = path.gsub(%r((^#{Regexp.escape(attachment_basename)}_)(\w+)(#{Regexp.escape(attachment_extname)})$), '\2')
+    return unless thumbnail
+    return unless attachment_options[:thumbnails][thumbnail.to_sym]
+    full_filename_with_creation(thumbnail.to_sym)
+  end
+
+  # Gets the public path to the file, visible to browser
+  # The optional thumbnail argument will output the thumbnail's filename.
+  # If options[:autocreate] is set to true, this method will autogenerate thumbnail
+  def public_filename(thumbnail = nil)
+    return "" if filename.blank?
+    full_filename(thumbnail).gsub %r(^#{Regexp.escape(base_path)}), ''
+  end
+
+  protected
+
+  # overrwrite this to do your own app-specific partitioning. 
+  # you can thank Jamis Buck for this: http://www.37signals.com/svn/archives2/id_partitioning.php
+  def partitioned_path(*args)
+    ("%08d" % id).scan(/..../) + args
+  end
+
+  def create_thumbnail_if_required(thumbnail)
+    thumbnail_path = full_filename_without_creation(thumbnail)
+    return thumbnail_path unless thumbnail
+    return thumbnail_path if File.exists?(thumbnail_path)
+    return unless /image\//.match(content_type)
+    if attachment_options[:croppable_thumbnails].include?(thumbnail.to_sym)
+      crop_and_thumbnail(thumbnail, thumbnail_path)
+    else
+      create_thumbnail(thumbnail, thumbnail_path)
+    end
+    thumbnail_path
+  end
+
+  def create_thumbnail(thumbnail, thumbnail_path)
+    return nil unless File.exists?(full_filename)
+    return nil unless attachment_options[:thumbnails][thumbnail.to_sym]
+    `convert -thumbnail #{attachment_options[:thumbnails][thumbnail.to_sym]} "#{full_filename}" "#{thumbnail_path}"`
+    thumbnail_path
+  end
+
+
+  public
+
+  def valid_filetype? #:nodoc:
+    errors.add("uploaded_data", attachment_options[:validation_message]) if @save_new_attachment && !@valid_filetype
+  end
+
+  # Main method, that accepts uploaded data
+  #
+  def uploaded_data=(file_data)
+    prepare_uploaded_file(file_data)
+    file_type = identify_uploaded_file_type
+    if accepts_file_type_for_upload?(file_type)
+      handle_uploaded_file
+    end
+  end
+  
+  def image_size
+    [width.to_s, height.to_s] * 'x'
+  end
+
+  def filename=(value)
+    @old_filename = full_filename unless filename.nil? || @old_filename
+    write_attribute :filename, sanitize_filename(value)
+  end
+
+  protected
+
+
+  def crop_and_thumbnail(thumbnail, thumbnail_path)
+    if !respond_to?(:width) || !respond_to?(:height)
+      file_type, width, height = identify_image_properties(full_filename)
+    end
+    album_x, album_y = attachment_options[:thumbnails][thumbnail.to_sym].split("x").map &:to_i
+    scale_x = width.to_f / album_x
+    scale_y = height.to_f / album_y
+    if scale_x > scale_y
+      x, y = (album_x*scale_y).floor, height
+      shift_x, shift_y = (width.to_i - x)/2, 0
+    else
+      x, y = width, (album_y*scale_x).floor
+      shift_x, shift_y = 0, (height.to_i - y)/2
+    end
+#    FileUtils.cp(full_filename_without_creation, thumbnail_path)
+    `convert -crop #{x}x#{y}+#{shift_x}+#{shift_y} "#{full_filename}" "#{thumbnail_path}"`
+    `mogrify  -geometry #{album_x}x#{album_y} "#{thumbnail_path}"`
+    thumbnail_path
+  end
+
+  # Destroys the file.  Called in the after_destroy callback
+  def remove_files
+    return unless filename
+    FileUtils.rm_rf(File.dirname(full_filename_without_creation))
+  rescue
+    logger.info "Exception destroying  #{full_filename.inspect}: [#{$!.class.name}] #{$1.to_s}"
+    logger.warn $!.backtrace.collect { |b| " > #{b}" }.join("\n")
+  end
+
+  # Renames the given file before saving
+  def rename_file
+    return unless @old_filename && @old_filename != full_filename
+    if @save_new_attachment && File.exists?(@old_filename)
+      FileUtils.rm @old_filename
+    elsif File.exists?(@old_filename)
+      FileUtils.mv @old_filename, full_filename
+    end
+    @old_filename =  nil
+    true
+  end
+ 
+end

data/lib/attacheable/file_naming.rb

@@ -0,0 +1,48 @@
+module Attacheable
+  module FileNaming
+    def full_filename_with_creation(thumbnail = nil) #:nodoc:
+      create_thumbnail_if_required(thumbnail)
+    end
+
+    def full_filename_without_creation(thumbnail = nil) #:nodoc:
+      file_system_path = attachment_options[:path_prefix]
+      File.join(Attacheable.root, file_system_path, *partitioned_path(thumbnail_name_for(thumbnail)))
+    end
+
+    def thumbnail_name_for(thumbnail = nil) #:nodoc:
+      return filename if thumbnail.blank?
+      ext = nil
+      basename = filename.gsub /\.\w+$/ do |s|
+        ext = s; ''
+      end
+      "#{basename}_#{thumbnail}#{ext}"
+    end
+
+    def public_filename_without_creation(thumbnail = nil)
+      full_filename_without_creation(thumbnail).gsub %r(^#{Regexp.escape(base_path)}), ''
+    end
+
+    def base_path #:nodoc:
+      @base_path ||= File.join(Attacheable.root, 'public')
+    end
+    
+    def attachment_basename
+      filename && filename.gsub(/\.[^\.]+$/, '')
+    end
+
+    def attachment_extname
+      filename && filename.gsub(/^(.*)(\.[^\.]+)$/, '\2')
+    end
+    
+    def sanitize_filename(filename)
+      returning filename.strip do |name|
+        # NOTE: File.basename doesn't work right with Windows paths on Unix
+        # get only the filename, not the whole path
+        name.gsub! /^.*(\\|\/)/, ''
+
+        # Finally, replace all non alphanumeric, underscore or periods with underscore
+        name.gsub! /[^\w\.\-]/, '_'
+      end
+    end
+  end
+end

data/lib/attacheable/photo_handler.rb

@@ -0,0 +1,48 @@
+module Attacheable
+  class PhotoHandler < Mongrel::HttpHandler
+    def initialize(prefix, options)
+      @prefix = prefix
+      @class_name = options[:class_name]
+    end
+
+    def logger
+      ActiveRecord::Base.logger
+    end
+    
+    def klass
+      @class_name.constantize
+    end
+
+    def process(request, response)
+      if File.exists?(Attacheable.root+"/public#{@prefix}/#{request.params["PATH_INFO"]}")
+        response.start(200) do |headers, out|
+          headers["Content-Type"] = "image/jpeg"
+          out.write(File.read(Attacheable.root+"/public#{@prefix}/#{request.params["PATH_INFO"]}"))
+        end
+        return
+      end
+
+      start_time = Time.now
+      photo, data = klass.data_by_path_info(request.params["PATH_INFO"].split("/"))
+      if photo
+        response.start(200) do |headers, out|
+          headers["Content-Type"] = photo.content_type
+          out.write(data)
+        end
+      else
+        response.start(404) do |headers, out|
+          headers["Content-Type"] = "text/plain"
+          out.write("No such image\n")
+        end
+      end
+      logger.info "Processed request in #{Time.now - start_time} seconds\n  URI: #{request.params["REQUEST_URI"]}\n\n"
+    rescue Exception => e
+      logger.info "!! Internal server error\nURI: #{request.params["REQUEST_URI"]}\n#{e}\n#{e.backtrace.join("\n")}"
+      logger.flush
+      response.start(200) do |headers, out|
+        headers["Content-Type"] = "text/plain"
+        out.write("Some error on server\n")
+      end
+    end
+  end
+end

data/lib/attacheable/uploading.rb

@@ -0,0 +1,93 @@
+module Attacheable
+  module Uploading
+    def prepare_uploaded_file(file_data)
+      return prepare_merb_uploaded_file(file_data) if file_data.is_a?(Hash) && file_data["content_type"] && file_data["tempfile"]
+      return nil if file_data.nil? || !file_data.respond_to?(:original_filename) || !respond_to?(:filename=)
+      
+      self.filename = file_data.original_filename
+      if file_data.is_a?(StringIO)
+        file_data.rewind
+        @tempfile = Tempfile.new(filename)
+        @tempfile.write(file_data.read)
+        @tempfile.close
+      else
+        @tempfile = file_data
+      end
+      if respond_to?(:size=)
+        self.size = file_data.respond_to?(:size) ? file_data.size : @tempfile.respond_to?(:size) ? @tempfile.size : File.size(@tempfile.path)
+      end
+      @save_new_attachment = true
+      @valid_filetype = false
+    end
+    
+    def prepare_merb_uploaded_file(file_data)
+      return nil if file_data["tempfile"].blank? || file_data["filename"].blank? || file_data["content_type"].blank?
+      self.filename = file_data["filename"]
+      self.size = file_data["size"] if respond_to?(:size=)
+      @tempfile = file_data["tempfile"]
+      @save_new_attachment = true
+      @valid_filetype = false
+    end
+    
+    def identify_uploaded_file_type
+      return unless @tempfile
+      self.content_type = @tempfile.content_type if @tempfile.respond_to?(:content_type)
+
+      if content_type.blank? || content_type =~ /image\//
+        file_type, width, height = identify_image_properties(@tempfile.path)
+        if file_type
+          self.width = width if(respond_to?(:width=))
+          self.height = height if(respond_to?(:height=))
+          self.content_type = "image/#{file_type}"
+          file_type
+        end
+      end
+    end
+    
+    def identify_image_properties(path)
+      return [nil,nil,nil] if path.blank?
+      
+      output = nil
+      silence_stderr do
+        output = `identify "#{path}"`
+      end
+      if output && match_data = / (\w+) (\d+)x(\d+) /.match(output)
+        file_type = match_data[1].to_s.downcase
+        width = match_data[2]
+        height = match_data[3]
+        return [file_type, width, height]
+      end
+    end
+    
+    def accepts_file_type_for_upload?(file_type)
+      return false unless @tempfile
+      return true if attachment_options[:valid_filetypes] == :all
+      return true if attachment_options[:valid_filetypes].include?(file_type)
+    end
+    
+    def handle_uploaded_file
+      @save_new_attachment = true
+      @valid_filetype = true
+    end
+    
+    # Saves the file to the file system
+    def save_to_storage
+      if @save_new_attachment
+        FileUtils.mkdir_p(File.dirname(full_filename))
+        FileUtils.cp(@tempfile.path, full_filename)
+        File.chmod(0644, full_filename)
+        save_to_replicas
+      end
+      @save_new_attachment = false
+      @tempfile = nil
+      true
+    end
+
+    def save_to_replicas
+      attachment_options[:replicas].each do |replica|
+        system("ssh #{replica[:user]}@#{replica[:host]} mkdir -p \"#{File.dirname(full_filename)}\"")
+        system("scp \"#{full_filename}\" \"#{replica[:user]}@#{replica[:host]}:#{full_filename}\"")
+      end if attachment_options[:replicas]
+    end
+  end
+end

data/test/attacheable_test.rb

@@ -0,0 +1,194 @@
+require File.dirname(__FILE__)+'/test_helper'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+
+def setup_db
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :images do |t|
+      t.string :something
+      t.string :filename
+      t.string :content_type
+      #t.integer :width
+      #t.integer :height
+      t.string :type
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+class Image < ActiveRecord::Base
+  has_attachment :thumbnails => {:medium => "120x", :large => "800x600", :preview => "100x100"},
+    :croppable_thumbnails => %w(preview)
+  validates_as_attachment :message => "Please upload an image file."
+end
+
+class Photo < Image
+end
+
+module TestUploadExtension
+  attr_accessor :content_type
+  def original_filename
+    File.basename(path)
+  end
+  
+  def size
+    File.stat(path).size
+  end
+end
+
+class AttacheableTest < Test::Unit::TestCase
+  def setup
+    setup_db
+  end
+  
+  def teardown
+    teardown_db
+    FileUtils.rm_rf(File.dirname(__FILE__)+"/public")
+    Image.attachment_options[:autocreate] = false
+    Image.attachment_options[:valid_filetypes] = %w(jpeg gif png psd)
+  end
+  
+  def test_image_autoconf
+    assert_equal "public/system/images", Image.attachment_options[:path_prefix], "Should guess path prefix right"
+  end
+  
+  def test_image_creation
+    input = File.open(File.dirname(__FILE__)+"/fixtures/life.jpg")
+    input.extend(TestUploadExtension)
+    assert_equal "life.jpg", input.original_filename, "should look like uploaded file"
+    image = Image.new(:uploaded_data => input)
+    assert_equal "life_medium.jpg", image.send(:thumbnail_name_for, :medium), "should generate right thumbnail filename"
+    assert image.save, "Image should be saved"
+    assert_equal "life", image.attachment_basename
+    assert_equal ".jpg", image.attachment_extname
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life.jpg"), "File should be saved"
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life_medium.jpg"), "Thumbnails should not be generated"
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+  
+  def test_merb_image_creation
+    path = File.dirname(__FILE__)+"/fixtures/life.jpg"
+    input = {"content_type"=>"image/jpeg", "size"=>File.size(path), "tempfile"=>File.open(path), "filename"=>"life.jpg"}
+    image = Image.new(:uploaded_data => input)
+    assert image.save, "Image should be saved"
+    assert_equal "life", image.attachment_basename
+    assert_equal ".jpg", image.attachment_extname
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life.jpg"), "File should be saved"
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life_medium.jpg"), "Thumbnails should not be generated"
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+  
+  def test_image_with_autocreation
+    Image.attachment_options[:autocreate] = true
+    input = File.open(File.dirname(__FILE__)+"/fixtures/life.jpg")
+    input.extend(TestUploadExtension)
+    image = Image.new(:uploaded_data => input)
+    assert image.save, "Image should be saved"
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life.jpg"), "File should be saved"
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life_medium.jpg"), "Thumbnails should not be generated"
+    assert_equal "life_medium.jpg", image.send(:thumbnail_name_for, :medium), "should generate right thumbnail filename"
+    image.public_filename(:medium)
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life_medium.jpg"), "Thumbnails should be generated on demand"
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+
+  def test_autocrop_image
+    Image.attachment_options[:autocreate] = true
+    input = File.open(File.dirname(__FILE__)+"/fixtures/life.jpg")
+    input.extend(TestUploadExtension)
+    image = Image.new(:uploaded_data => input)
+    assert image.save, "Image should be saved"
+    image.public_filename(:preview)
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life_preview.jpg"), "Thumbnails should be generated on demand"
+    identify = `identify "#{File.dirname(__FILE__)+"/public/system/images/0000/0001/life_preview.jpg"}"`
+    assert Regexp.new(" JPEG 100x100 ").match(identify), "Image should be cropped to format"
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+  
+  def test_image_with_wrong_type
+   input = File.open(File.dirname(__FILE__)+"/fixtures/wrong_type")
+   input.extend(TestUploadExtension)
+   image = Image.new(:uploaded_data => input)
+   assert !image.save, "Image should not be saved"
+   assert image.errors.on(:uploaded_data).size > 0, "Uploaded data is of wrong type"
+   assert_equal "Please upload an image file.", image.errors.on(:uploaded_data), "Validation message is the one used with :message"
+  end
+
+  def test_with_sti
+    input = File.open(File.dirname(__FILE__)+"/fixtures/life.jpg")
+    input.extend(TestUploadExtension)
+    image = Photo.new(:uploaded_data => input)
+    assert image.save, "Image should be saved"
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life.jpg"), "File should be uploaded as for Image"
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+  
+  def test_save_raw_binary
+    Image.attachment_options[:valid_filetypes] = :all
+    input = File.open(File.dirname(__FILE__)+"/fixtures/wrong_type")
+    input.extend(TestUploadExtension)
+    image = Image.new(:uploaded_data => input)
+    assert image.save, "Image should be saved"
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/wrong_type"), "File should be uploaded"
+    assert !image.send(:full_filename_with_creation, :preview)
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+  
+  def test_save_msword
+    Image.attachment_options[:valid_filetypes] = :all
+    input = File.open(File.dirname(__FILE__)+"/fixtures/test.doc")
+    input.extend(TestUploadExtension)
+    input.content_type = "application/ms-word"
+    image = Image.new(:uploaded_data => input)
+    assert image.save, "Image should be saved"
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/test.doc"), "File should be uploaded"
+    assert !image.send(:full_filename_with_creation, :preview)
+    assert_equal "/system/images/0000/0001/test.doc", image.public_filename
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+  
+  def test_create_thumbnail
+    input = File.open(File.dirname(__FILE__)+"/fixtures/life.jpg")
+    input.extend(TestUploadExtension)
+    assert_equal "life.jpg", input.original_filename, "should look like uploaded file"
+    image = Image.new(:uploaded_data => input)
+    assert_equal "life_medium.jpg", image.send(:thumbnail_name_for, :medium), "should generate right thumbnail filename"
+    assert image.save, "Image should be saved"
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life.jpg"), "File should be saved"
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life_medium.jpg"), "Thumbnails should not be autogenerated"
+    photo, data = Image.data_by_path_info(%w(0000 0001 life_medium.jpg))
+    assert photo, "Image should be guessed"
+    assert File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001/life_medium.jpg"), "Thumbnails should be generated on demand"
+    assert data, "New file should be generated"
+    image.destroy
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000/0001"), "Directory should be cleaned"
+  end
+  
+  def test_nil_upload
+    image = Image.new(:uploaded_data => nil)
+    assert image.save, "Image should be saved with empty file"
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000"), "nothing should be created"
+    assert image.update_attributes(:something => "empty"), "should be updateable"
+    assert image.destroy, "should be destroyable"
+  end
+
+  def test_string_upload
+    image = Image.new(:uploaded_data => "life.jpg")
+    assert image.save, "Image should be saved with empty file"
+    assert !File.exists?(File.dirname(__FILE__)+"/public/system/images/0000"), "nothing should be created"
+    assert image.destroy, "should be destroyable"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'rubygems'
+require 'active_support'
+require 'active_record'
+require 'action_pack'
+$KCODE = 'u'
+
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+if defined?(RAILS_ROOT)
+  RAILS_ROOT.replace(File.dirname(__FILE__))
+else
+  RAILS_ROOT = File.dirname(__FILE__) 
+end
+require 'attacheable'
+
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: attacheable
 version: !ruby/object:Gem::Version 
-  version: "1.1"
+  version: "1.2"
 platform: ruby
 authors: 
 - Max Lapshin
@@ -24,12 +24,24 @@ extra_rdoc_files: []
 files: 
 - init.rb
 - lib
+- lib/attacheable
+- lib/attacheable/file_naming.rb
+- lib/attacheable/photo_handler.rb
+- lib/attacheable/uploading.rb
+- lib/attacheable.rb
 - MIT-LICENSE
 - pkg
+- pkg/attacheable-1.1.gem
 - Rakefile
 - README
 - README.ru
 - test
+- test/attacheable_test.rb
+- test/fixtures
+- test/fixtures/life.jpg
+- test/fixtures/test.doc
+- test/fixtures/wrong_type
+- test/test_helper.rb
 has_rdoc: false
 homepage: 
 post_install_message: