model_attachment 0.0.5

data/LICENSE

@@ -0,0 +1,23 @@
+LICENSE
+
+The MIT License
+
+Copyright (c) 2010 Stephen Walker 
+
+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/Manifest.txt

@@ -0,0 +1,12 @@
+README.rdoc
+LICENSE
+Rakefile
+init.rb
+Manifest.txt
+lib/model_attachment
+lib/model_attachment/amazon.rb
+lib/model_attachment/upfile.rb
+lib/model_attachment.rb
+test/assets
+test/assets/test.jpg
+test/model_attachment_test.rb

data/README.rdoc

@@ -0,0 +1,111 @@
+=ModelAttachment
+
+ModelAttachment is intended as an simple file attachment library for ActiveRecord. This is experimental software, the interface is subject to change and we are still adding tests.  Use with caution only in development.
+
+See the documentation for +has_attachement+ in ModelAttachment::ClassMethods for slightly more detailed options.
+
+==Quick Start
+
+In your model:
+
+  class Document < ActiveRecord::Base
+    has_attachment :path => ":domain/:folder/:document/:version/",
+      :types => {
+        :small => { :command => 'convert -geometry 100x100' },
+        :large => { :command => 'convert -geometry 500x500' }
+      },
+      :aws => :default,
+      :logging => true
+    
+    def domain
+      # returns string representing the domain
+    end
+    
+    def folder
+      # returns string representing the folder
+    end
+    
+    def document
+      # returns string representing document
+    end
+    
+    def version
+      # returns document version number
+    end
+  end
+
+In your migrations:
+
+  class AddAttachmentColumnsToDocument < ActiveRecord::Migration
+    def self.up
+      add_column :documents, :bucket,       :string # if you are using aws
+      add_column :documents, :file_name,    :string
+      add_column :documents, :content_type, :string
+      add_column :documents, :file_size,    :integer
+      add_column :documents, :version,      :integer
+      add_column :documents, :updated_at,   :datetime
+    end
+
+    def self.down
+      remove_column :documents, :bucket
+      remove_column :documents, :file_name
+      remove_column :documents, :content_type
+      remove_column :documents, :file_size
+      remove_column :documents, :version
+      remove_column :documents, :updated_at
+    end
+  end
+
+In your edit and new views:
+
+  <% form_for :document, @document, :url => document_path, :html => { :multipart => true } do |form| %>
+    <%= form.file_field :file_name %>
+  <% end %>
+
+In your controller:
+
+  def create
+    @document = Document.create( params[:user] )
+  end
+  
+  def send
+    # check permissions
+    @document = Document.find(params[:id])
+    
+    # use x_send_file w/ apache for better results - http://github.com/simmerz/x_send_file
+    x_send_file(@document.full_filename(params[:type]), :type => @document.content_type, :disposition => 'inline')
+  end
+  
+In your show view:
+
+  <%= link_to "Download", @document.url(:large) %>
+
+==Usage
+
+The basics of model_attachment are quite simple: Declare that your model has an attachment with the has_attachment method, and give it a name. ModelAttachment will wrap up up to four attributes and give the a friendly front end. The attributes are file_name, file_size, content_type, and updated_at.
+
+Attachments can be validated with ModelAttachment's validation methods, validates_attachment_presence and validates_attachment_size.
+
+Attachments can be moved to amazon with @document.move_to_amazon and from amazon with @document.move_to_filesystem.
+
+You can use @document.url(:type) to get the url to the file.
+
+==Storage
+
+The files that are assigned as attachments are, by default, placed in the directory specified by the :path option to has_attachment. By default, this location is ":rails_root/system/:document/:basename.:extention".
+
+Options currently accepted and evaluated: 
+:domain
+:folder
+:document
+:version
+
+==Post Processing
+
+ModelAttachment supports post processing by sending the types a command, this will be run on any images.
+
+==Credit
+
+This is a blatant strip down of the Paperclip module by Jon Yurek and thoughtbot, inc.
+
+

data/Rakefile

@@ -0,0 +1,96 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'model_attachment'
+
+desc 'Default: run unit tests.'
+task :default => [:clean, :test]
+
+desc 'Test the model_attachment plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'profile'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Start an IRB session with all necessary files required.'
+task :shell do |t|
+  chdir File.dirname(__FILE__)
+  exec 'irb -I lib/ -I lib/model_attachment -r rubygems -r active_record -r tempfile -r init'
+end
+
+desc 'Generate documentation for the model_attachment plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = 'ModelAttachment'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Update documentation on website'
+task :sync_docs => 'rdoc' do
+  `rsync -ave ssh doc/ steve@rsweb2:/var/sites/stephenwalker/shared/system/docs/model_attachment`
+end
+
+desc 'Clean up files.'
+task :clean do |t|
+  FileUtils.rm_rf "doc"
+  FileUtils.rm_rf "tmp"
+  FileUtils.rm_rf "pkg"
+  FileUtils.rm "test/debug.log" rescue nil
+  FileUtils.rm "test/model_attachment.db" rescue nil
+  Dir.glob("model_attachment-*.gem").each{|f| FileUtils.rm f }
+end
+
+include_file_globs = ["README*",
+                      "LICENSE",
+                      "Rakefile",
+                      "init.rb",
+                      "Manifest.txt",
+                      "{generators,lib,tasks,test}/**/*"]
+
+exclude_file_globs = ["test/amazon.yml",
+                      "test/test.log"]
+
+spec = Gem::Specification.new do |s| 
+  s.name              = "model_attachment"
+  s.description       = "Simple file attachment for ActiveRecord models"
+  s.version           = ModelAttachment::VERSION
+  s.author            = "Steve Walker"
+  s.email             = "steve@blackboxweb.com"
+  s.homepage          = "http://github.com/stw/model_attachment"
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = "Attach files to ActiveRecord models and run commands on images"
+  s.files             = FileList[include_file_globs].to_a - FileList[exclude_file_globs].to_a
+  s.require_path      = "lib"
+  s.test_files        = FileList["test/**/test_*.rb"].to_a
+  s.rubyforge_project = "model_attachment"
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = FileList["README*"].to_a
+  s.rdoc_options << '--line-numbers' << '--inline-source'
+  s.requirements << "ImageMagick"
+  s.add_development_dependency 'sqlite3-ruby'
+  s.add_development_dependency 'activerecord'
+end
+
+desc "Print a list of the files to be put into the gem"
+task :manifest => :clean do
+  spec.files.each do |file|
+    puts file
+  end
+end
+ 
+desc "Generate a gemspec file for GitHub"
+task :gemspec => :clean do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end 
+
+desc "Build the gem into the current directory"
+task :gem => :gemspec do
+  `gem build #{spec.name}.gemspec`
+end

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "lib", "model_attachment")

data/lib/model_attachment.rb

@@ -0,0 +1,305 @@
+# 
+#  model_attachment.rb
+#  
+#  Created by Stephen Walker on 2010-04-22.
+#  Copyright 2010 Stephen Walker. All rights reserved.
+# 
+
+# TODO - Add exception handling and validation testing
+
+require 'rubygems'
+require 'yaml'
+require 'model_attachment/upfile'
+require 'model_attachment/amazon'
+
+# The base module that gets included in ActiveRecord::Base.
+module ModelAttachment
+  VERSION = "0.0.5"
+  
+  class << self
+    
+    def included base #:nodoc:
+      base.extend ClassMethods
+    end
+    
+  end
+  
+  module ClassMethods
+    # +has_attachment+ adds the ability to upload files and make thumbnails of images
+    # * +path+: the path format for saving the documents
+    # * +types+: a hash of thumbnails to create for images
+    #            :types => {
+    #                 :small => { :command => 'convert -geometry 100x100' },
+    #                 :large => { :command => 'convert -geometry 500x500' }
+    #            }
+    # * +aws+: the path to the aws config file or :default for rails config/amazon.yml
+    #          access_key_id:
+    #          secret_access_key: 
+    # * +logging+: set to true to see logging
+    def has_attachment(options = {})
+      include InstanceMethods
+      
+      if options[:aws]
+        begin
+          require 'aws/s3'
+        rescue LoadError => e
+          e.messages << "You man need to install the aws-s3 gem"
+          raise e
+        end
+      end
+    
+      if options[:aws] == :default
+        config_file = File.join(RAILS_ROOT, "config", "amazon.yml")
+        if File.exist?(config_file)
+          options[:aws] = config_file
+          include AmazonInstanceMethods
+        else
+          raise("You must provide a config/amazon.yml setup file")
+        end
+      elsif !options[:aws].nil? && File.exist?(options[:aws])
+        include AmazonInstanceMethods
+      end
+      
+      write_inheritable_attribute(:attachment_options, options)
+        
+      # must be before the save to save the attributes
+      before_save :save_attributes
+      
+      # must be after save to get the id for the path
+      after_save :save_attached_files
+      before_destroy :destroy_attached_files
+      
+    end
+    
+    # Places ActiveRecord-style validations on the size of the file assigned. The
+    # possible options are:
+    # * +in+: a Range of bytes (i.e. +1..1.megabyte+),
+    # * +less_than+: equivalent to :in => 0..options[:less_than]
+    # * +greater_than+: equivalent to :in => options[:greater_than]..Infinity
+    # * +message+: error message to display, use :min and :max as replacements
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +unless+: Same as +if+ but validates if lambda or method returns false.
+    def validates_attachment_size name, options = {}
+      min     = options[:greater_than] || (options[:in] && options[:in].first) || 0
+      max     = options[:less_than]    || (options[:in] && options[:in].last)  || (1.0/0)
+      range   = (min..max)
+      message = options[:message] || "file size must be between :min and :max bytes."
+      message = message.gsub(/:min/, min.to_s).gsub(/:max/, max.to_s)
+
+      validates_inclusion_of name,
+                             :in      => range,
+                             :message => message,
+                             :if      => options[:if],
+                             :unless  => options[:unless]
+    end
+
+    # Places ActiveRecord-style validations on the presence of a file.
+    # Options:
+    # * +if+: A lambda or name of a method on the instance. Validation will only
+    #   be run is this lambda or method returns true.
+    # * +unless+: Same as +if+ but validates if lambda or method returns false.
+    def validates_attachment_presence name, options = {}
+      message = options[:message] || "must be set."
+      validates_presence_of name, 
+                            :message => message,
+                            :if      => options[:if],
+                            :unless  => options[:unless]
+    end
+    
+    # Returns attachment options defined by each call to acts_as_attachment.
+    def attachment_options
+      read_inheritable_attribute(:attachment_options)
+    end
+    
+  end
+  
+  module InstanceMethods #:nodoc:
+    
+    # return the url based on location
+    # * +proto+: set the protocol, defaults to http
+    # * +port+: sets the port if required
+    # * +server_name+: sets the server name, defaults to localhost
+    # * +path+: sets the path, defaults to /documents/send
+    # * +type+: sets the type, types come from the has_attachment method, ex. small, large
+    def url(options = {})
+      proto       = options[:proto]        || "http"
+      port        = options[:port]
+      server_name = options[:server_name]  || "localhost"
+      url_path    = options[:path]         || "/documents/send"
+      type        = options[:type]
+      server_name += ":" + port if port
+      
+      url = (bucket.nil? ? "#{proto}://#{server_name}#{url_path}?id=#{id}" : aws_url(type))
+      log("Providing URL: #{url}")
+      return url
+    end
+    
+    # returns the rails path of the file
+    def path 
+      if (self.class.attachment_options[:path]) 
+        return "/system" + interpolate(self.class.attachment_options[:path])
+      else 
+        return "/system/" + sprintf("%04d", id) + "/"
+      end
+    end
+    
+    # returns the full system path of the file
+    def full_path
+      RAILS_ROOT + path
+    end
+    
+    # returns the filename, including any type modifier
+    # +type+: type from has_attachment, ex. small, large
+    def filename(type = "")
+      type      = "_#{type}" if type != ""
+      "#{basename}#{type}#{extension}"
+    end
+    
+    def extension #:nodoc:
+      File.extname(file_name)
+    end
+    
+    def basename #:nodoc:
+      File.basename(file_name, extension)
+    end
+     
+    # returns the full system path/filename
+    # +type+: type from has_attachment, ex. small, large
+    def full_filename(type = "")
+      full_path + filename(type)
+    end
+    
+    # decide whether or not this is an image
+    def image?
+      content_type =~ /^image\//
+    end
+    
+    private
+    
+    def process_image_types #:nodoc:
+      if self.class.attachment_options[:types]
+        self.class.attachment_options[:types].each do |name, value|
+          if image?
+            yield(name, value)
+          end
+        end
+      end
+    end
+    
+    # save the correct attribute info before the save
+    def save_attributes
+      return if file_name.class.to_s == "String"
+      @temp_file = self.file_name
+      
+      # get original filename info and clean up for storage
+      ext  = File.extname(@temp_file.original_filename)
+      base = File.basename(@temp_file.original_filename, ext).strip.gsub(/[^A-Za-z\d\.\-_]+/, '_')
+      
+      # save attributes
+      self.file_name    = base + ext
+      self.content_type = @temp_file.content_type.strip
+      self.file_size    = @temp_file.size.to_i
+      self.updated_at   = Time.now
+      
+    end
+    
+    # Does all the file processing, moves from temp, processes images
+    def save_attached_files
+      return if @temp_file.nil? or @temp_file == ""
+      options = self.class.attachment_options
+            
+      log("Path: #{path} Basename: #{basename} Extension: #{extension}")
+
+      # copy image to correct path
+      FileUtils.mkdir_p(full_path)
+      FileUtils.chmod(0755, full_path)
+      FileUtils.mv(@temp_file.path, full_path + basename + extension)
+
+      # run any processing passed in on images
+      process_images
+      
+      @dirty = true 
+      @temp_file.close if @temp_file.respond_to?(:close)
+      @temp_file = nil
+    end
+        
+    # run each processor on file
+    def process_images
+      process_image_types do |name, value|
+        command = value[:command]
+        old_filename = full_filename
+        new_filename = full_filename(name)
+        log("Create #{name} by running #{command} on #{old_filename}")
+        log("Created: #{new_filename}")
+        `#{command} #{old_filename} #{new_filename}`
+      end
+    end
+    
+    # create the path based on the template
+    def interpolate(path, *args)
+      methods = ["domain", "folder", "document", "version"]
+      methods.reverse.inject( path.dup ) do |result, tag|
+        result.gsub(/:#{tag}/) do |match|
+          send( tag, *args )
+        end
+      end
+    end
+    
+    # removes any files associated with this instance
+    def destroy_attached_files
+      begin
+        
+        if bucket.nil?
+          log("Deleting #{full_filename}")
+          FileUtils.rm(full_filename) if File.exist?(full_filename)
+        
+          # delete thumbnails if image
+          process_image_types do |name, value|
+            log("Deleting #{name}")
+            FileUtils.rm(full_filename(name)) if File.exists?(full_filename(name))
+          end
+        
+        else 
+          remove_from_amazon
+        end
+        
+      rescue Errno::ENOENT => e
+        # ignore file-not-found, let everything else pass
+      end
+      begin
+        while(true)
+          dir_path = File.dirname(full_filename)
+          FileUtils.rmdir(dir_path)
+        end
+      rescue Errno::EEXIST, Errno::ENOTEMPTY, Errno::ENOENT, Errno::EINVAL, Errno::ENOTDIR
+        # Stop trying to remove parent directories
+      rescue SystemCallError => e
+        log("There was an unexpected error while deleting directories: #{e.class}")
+        # Ignore it
+      end 
+    end
+    
+    def logging? #:nodoc:
+      self.class.attachment_options[:logging]
+    end
+    
+    # Log a ModelAttachment specific message
+    # +message+: message to be logged if logging? true
+    def log(message)
+      logger.info("[model_attachment] #{message}") if logging?
+    end
+  
+    def dirty? #:nodoc:
+      @dirty
+    end
+    
+  end
+  
+end
+
+# Set it up in our model
+if Object.const_defined?("ActiveRecord")
+  ActiveRecord::Base.send(:include, ModelAttachment)
+  File.send(:include, ModelAttachment::Upfile)
+end

data/lib/model_attachment/amazon.rb

@@ -0,0 +1,143 @@
+module ModelAttachment
+  module AmazonInstanceMethods
+    
+    # returns the aws url
+    # +type+: type passed to has_attachment, ex. small, large
+    def aws_url(type = "")
+      begin
+        return AWS::S3::S3Object.find(aws_key(type), default_bucket).url
+      rescue
+        log("Could not get object: #{aws_key(type)}")
+      end
+    end
+    
+    # sets the default aws bucket
+    # +current_bucket+: set the current bucket, default 'globalfolders'
+    def default_bucket(current_bucket = 'globalfolders')
+      current_bucket
+    end
+
+    # creates the aws_key
+    # +type+: type passed to has_attachment, ex. small, large
+    def aws_key(type = "")
+      file = (type.nil? || type == "" ? filename : basename + "_" + type + extension)
+      (path + file).gsub!(/^\//,'')
+    end
+      
+    # connect to aws, uses access_key_id and secret_access_key in config/amazon.yml
+    def aws_connect
+      return if AWS::S3::Base.connected?
+    
+      begin
+        config = YAML.load_file(self.class.attachment_options[:aws]) 
+        if config
+          log("Connect to Amazon")
+          AWS::S3::Base.establish_connection!(
+            :access_key_id     => config['access_key_id'],
+            :secret_access_key => config['secret_access_key'],
+            :use_ssl           => true,
+            :persistent        => true  # if issues with disconnections, set to false
+          )
+        else
+          raise "You must provide an amazon.yml config file"
+        end
+      rescue AWS::S3::ResponseError => error
+        log("Could not connect to amazon: #{error.message}")
+      end
+    end
+  
+    # moves file to amazon along with modified images, removes local images once object existence is confirmed
+    def move_to_amazon
+      aws_connect
+      
+      log("Move #{aws_key} to Amazon.")
+      begin
+        AWS::S3::S3Object.store(aws_key, open(full_filename), default_bucket, :content_type => content_type)
+        
+        # copy over modified files
+        process_image_types do |name, value|
+          AWS::S3::S3Object.store(aws_key(name.to_s), open(full_filename), default_bucket, :content_type => content_type)
+        end
+        
+        self.bucket = default_bucket
+        @dirty = true
+        save!
+      rescue AWS::S3::ResponseError => error
+        log("Store Object Failed: #{error.message}")
+      rescue StandardError => e
+        log("Move to Amazon Failed: #{e.message}")
+      end
+    
+      begin 
+        if AWS::S3::S3Object.exists?(aws_key, default_bucket)
+          log("Remove Filename #{full_path + filename}")
+          FileUtils.rm(full_path + filename)
+        end
+        
+        # remove any modified local files
+        process_image_types do |name, value|
+          if AWS::S3::S3Object.exists?(aws_key(name.to_s), default_bucket)
+            log("Remove Filename #{full_path + filename(name)}")
+            FileUtils.rm(full_path + filename(name.to_s))
+          end
+        end
+      rescue AWS::S3::ResponseError => error
+        log("Could not check objects existence: #{error.message}")
+      rescue StandardError => error
+        log("Removing file failed: #{error.message}.")
+      end
+    end
+  
+    # moves files back to local filesystem, along with modified images, removes from amazon once they are confirmed locally
+    def move_to_filesystem
+      aws_connect
+      begin 
+        open(full_filename, 'w') do |file|
+          AWS::S3::S3Object.stream(path + file_name, default_bucket) do |chunk|
+            file.write chunk
+          end
+        end
+        
+        # copy over modified files
+        process_image_types do |name, value|
+          open(full_filename(name), 'w') do |file|
+            AWS::S3::S3Object.stream(path + filename(name), default_bucket) do |chunk|
+              file.write chunk
+            end
+          end
+        end
+        
+      rescue AWS::S3::ResponseError => error
+        log("Copying File to local filesystem failed: #{error.message}")
+      end
+    
+      if File.size(full_filename) == file_size
+        remove_from_amazon
+      end
+    end
+
+    # removes files from amazon
+    def remove_from_amazon
+      begin
+        log("Removing #{aws_key} from Amazon")
+        object = AWS::S3::S3Object.find(aws_key, default_bucket)
+        object.delete
+        
+        # remove modified files
+        process_image_types do |name, value|
+          AWS::S3::S3Object.find(aws_key(name.to_s), default_bucket).delete
+        end
+
+        # make sure we set the bucket to nil so we know they're local
+        self.bucket = nil
+        @dirty = true
+        save!
+      rescue AWS::S3::ResponseError => error
+        log("Removing file from amazon failed: #{error.message}")
+      rescue StandardError => e
+        log("Failed remove from Amazon: #{e.message}")
+      end
+    end
+  
+  end
+end

data/lib/model_attachment/upfile.rb

@@ -0,0 +1,49 @@
+module ModelAttachment
+  # The Upfile module is a convenience module for adding uploaded-file-type methods
+  # to the +File+ class. Useful for testing.
+  #   user.avatar = File.new("test/test_avatar.jpg")
+  module Upfile
+
+    # Infer the MIME-type of the file from the extension.
+    def content_type
+      type = (self.path.match(/\.(\w+)$/)[1] rescue "octet-stream").downcase
+      case type
+      when %r"jp(e|g|eg)"            then "image/jpeg"
+      when %r"tiff?"                 then "image/tiff"
+      when %r"png", "gif", "bmp"     then "image/#{type}"
+      when "txt"                     then "text/plain"
+      when %r"html?"                 then "text/html"
+      when "js"                      then "application/js"
+      when "csv", "xml", "css"       then "text/#{type}"
+      else
+        Paperclip.run("file", "--mime-type #{self.path}").split(':').last.strip rescue "application/x-#{type}"
+      end
+    end
+
+    # Returns the file's normal name.
+    def original_filename
+      File.basename(self.path)
+    end
+
+    # Returns the size of the file.
+    def size
+      File.size(self)
+    end
+  end
+end
+
+if defined? StringIO
+  class StringIO
+    attr_accessor :original_filename, :content_type
+    def original_filename
+      @original_filename ||= "stringio.txt"
+    end
+    def content_type
+      @content_type ||= "text/plain"
+    end
+  end
+end
+
+class File #:nodoc:
+  include ModelAttachment::Upfile
+end

data/test/model_attachment_test.rb

@@ -0,0 +1,197 @@
+# 
+#  model_attachment_test.rb
+#  
+#  Created by Stephen Walker on 2010-04-22.
+#  Copyright 2010 Stephen Walker. All rights reserved.
+# 
+
+require 'test/unit'
+
+require 'rubygems'
+require 'active_record'
+require 'fileutils'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require File.dirname(__FILE__) + '/../init'
+
+RAILS_ROOT = File.dirname(__FILE__)
+
+class Test::Unit::TestCase
+end
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+# keep AR from printing schema statements
+$stdout = StringIO.new
+
+def setup_db
+  #FileUtils.rm(RAILS_ROOT + "/test.log")
+  ActiveRecord::Base.logger = Logger.new(RAILS_ROOT + "/test.log")
+  
+  ActiveRecord::Schema.define(:version => 1) do
+    create_table :documents do |t|
+      t.string :name
+      t.string :bucket
+      t.string :file_name
+      t.string :content_type
+      t.integer :file_size
+      t.timestamps
+    end
+  end
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |t|
+    ActiveRecord::Base.connection.drop_table(t)
+  end
+end
+
+class Document < ActiveRecord::Base  
+  def domain
+    "bbs"
+  end
+  
+  def folder
+    "1"
+  end
+  
+  def document
+    "1"
+  end
+  def version
+    "0"
+  end
+end
+
+class DocumentDefault < Document
+  has_attachment
+end
+
+class DocumentNoResize < Document
+  has_attachment :path => "/:domain/:folder/:document/:version/"
+end
+
+class DocumentWithResize < Document
+  has_attachment :path => "/:domain/:folder/:document/:version/",
+    :types => {
+      :small => { :command => '/opt/local/bin/convert -geometry 100x100' } 
+    }
+end
+
+class DocumentWithAWS < Document
+  has_attachment :path => "/:domain/:folder/:document/:version/", 
+    :aws => File.join(File.dirname(__FILE__), "amazon.yml"),
+    :types => {
+      :small => { :command => '/opt/local/bin/convert -geometry 100x100' } 
+    },
+    :logging => true
+end
+
+class ModelAttachmentTest < Test::Unit::TestCase
+  
+  def setup
+    setup_db
+  end
+  
+  def teardown
+    teardown_db
+  end
+  
+  def test_creation
+    document = Document.new
+    assert_equal document.class.to_s, "Document"
+  end
+  
+  def test_no_resize_creation
+    document = DocumentNoResize.new
+    assert_equal document.class.to_s, "DocumentNoResize"
+  end
+  
+  def test_with_resize
+    document = DocumentWithResize.new
+    assert_equal document.class.to_s, "DocumentWithResize"
+  end
+  
+  def test_save_default
+    FileUtils.cp(RAILS_ROOT + "/assets/test.jpg", RAILS_ROOT + "/assets/test1.jpg")
+    file = File.open(RAILS_ROOT + "/assets/test1.jpg")
+    
+    document = DocumentDefault.new(:name => "Test", :file_name => file)
+    document.save
+    
+    assert_equal "test1.jpg", document.file_name
+    assert_equal "image/jpeg", document.content_type
+    
+    assert File.exists?(RAILS_ROOT + "/system/0001/test1.jpg")
+    
+    document.destroy
+    assert !File.exists?(RAILS_ROOT + "/system/0001/test1.jpg")
+  end
+  
+  def test_save_with_no_resize
+    FileUtils.cp(RAILS_ROOT + "/assets/test.jpg", RAILS_ROOT + "/assets/test1.jpg")
+    file = File.open(RAILS_ROOT + "/assets/test1.jpg")
+    
+    document = DocumentNoResize.new(:name => "Test", :file_name => file)
+    document.save
+    
+    assert_equal document.file_name, "test1.jpg"
+    assert_equal document.content_type, "image/jpeg"
+    
+    assert File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test1.jpg")
+    
+    document.destroy
+    assert !File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test1.jpg")
+  end
+  
+  def test_save_with_resize
+    FileUtils.cp(RAILS_ROOT + "/assets/test.jpg", RAILS_ROOT + "/assets/test2.jpg")
+    file = File.open(RAILS_ROOT + "/assets/test2.jpg")
+    
+    document = DocumentWithResize.new(:name => "Test", :file_name => file)
+    document.save
+    
+    assert_equal document.file_name, "test2.jpg"
+    assert_equal document.content_type, "image/jpeg"
+    
+    assert File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test2.jpg")
+    assert File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test2_small.jpg")
+    
+    document.destroy
+    assert !File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test2.jpg")
+    assert !File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test2_small.jpg")  
+  end
+
+  def test_save_with_aws
+    FileUtils.cp(RAILS_ROOT + "/assets/test.jpg", RAILS_ROOT + "/assets/test3.jpg")
+    file = File.open(RAILS_ROOT + "/assets/test3.jpg")
+    
+    document = DocumentWithAWS.new(:name => "Test", :file_name => file)
+    document.save
+    assert File.exist?(RAILS_ROOT + "/system/bbs/1/1/0/test3.jpg")
+    
+    assert_equal "http://localhost:3000/documents/send?id=1", document.url(:port => "3000")
+    assert_equal "test3.jpg", document.file_name
+    assert_equal String, document.file_name.class
+    assert_equal "image/jpeg", document.content_type
+    
+    document.move_to_amazon
+    
+    assert_match /https:\/\/s3.amazonaws.com\/globalfolders\/system\/bbs\/1\/1\/0\/test3\.jpg/, document.url
+    assert_match /https:\/\/s3.amazonaws.com\/globalfolders\/system\/bbs\/1\/1\/0\/test3_small\.jpg/, document.url(:type => "small")
+    
+    assert_equal 'globalfolders', document.bucket
+    assert !File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test3.jpg")
+    assert !File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test3_small.jpg")
+    
+    document.move_to_filesystem
+    
+    assert File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test3.jpg")
+    assert File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test3_small.jpg")
+    
+    document.destroy
+    assert !File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test3.jpg")
+    assert !File.exists?(RAILS_ROOT + "/system/bbs/1/1/0/test3_small.jpg")
+  end
+end
+

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: model_attachment
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Steve Walker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Simple file attachment for ActiveRecord models
+email: steve@blackboxweb.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- LICENSE
+- Rakefile
+- init.rb
+- Manifest.txt
+- lib/model_attachment/amazon.rb
+- lib/model_attachment/upfile.rb
+- lib/model_attachment.rb
+- test/assets/test.jpg
+- test/model_attachment_test.rb
+has_rdoc: true
+homepage: http://github.com/stw/model_attachment
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- ImageMagick
+rubyforge_project: model_attachment
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Attach files to ActiveRecord models and run commands on images
+test_files: []
+