Revision 20080728221315-9043f-cff771...

== 1.2.2 / 2007-06-01

# 1.) all image commands return the image object (The output of the last command is saved in @output)

# 2.) identify doesn't trip over strangley named files

# 3.) TempFile uses file extention now (Thanks http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions)

# 4.) identify commands escape output path correctly

== 1.2.3 / 2007-06-15

# 1.) Image::from_file doesn't drop the file extension anymore, it and use the image_temp_file correctly

# 4.) TempFiles are stored as an instance variable in Image instances so they don't get cleaned up prematurely via garbage collection

Copyright (c) 2005 Corey Johnson probablycorey@gmail.com

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.

MIT-LICENSE

History.txt

Manifest.txt

README.txt

Rakefile

init.rb

lib/image_temp_file.rb

lib/mini_magick.rb

test/actually_a_gif.jpg

test/not_an_image.php

test/simple.gif

test/test_image_temp_file.rb

test/test_mini_magick_test.rb

test/trogdor.jpg

mini_magick

    by Coery Johnson

    FIX (url)

== DESCRIPTION:

A ruby wrapper for ImageMagick command line.

- Why?

I was using RMagick and loving it, but it was eating up huge amounts of memory. A simple script like this...

Magick::read("image.jpg") do |f|

 f.write("manipulated.jpg")

end

...would use over 100 Megs of Ram. On my local machine this wasn't a problem, but on my hosting server the ruby apps would crash because of their 100 Meg memory limit.

- Solution!

Using MiniMagick the ruby processes memory remains small (it spawns ImageMagick's command line program mogrify which takes up some memory as well, but is much smaller compared to RMagick)

== FEATURES/PROBLEMS:

MiniMagick gives you access to all the commandline options ImageMagick has (Found here http://www.imagemagick.org/script/mogrify.php)

== SYNOPSIS:

Want to make a thumbnail from a file...

image = MiniMagick::Image.from_file("input.jpg")

image.resize "100x100"

image.write("output.jpg")

Want to make a thumbnail from a blob...

image = MiniMagick::Image.from_blob(blob)

image.resize "100x100"

image.write("output.jpg")

Need to combine several options?

image = MiniMagick::Image.from_file("input.jpg")

image.combine_options do |c|

  c.sample "50%"

  c.rotate "-90>"

end

image.write("output.jpg")

Want to manipulate an image at its source (You won't have to write it out because the transformations are done on that file)

image = MiniMagick::Image.new("input.jpg")

image.resize "100x100"

Want to get some meta-information out?

image = MiniMagick::Image.from_file("input.jpg")

image[:width] # will get the width (you can also use :height and :format)

image["EXIF:BitsPerSample"] # It also can get all the EXIF tags

image["%m:%f %wx%h"] # Or you can use one of the many options of the format command found here http://www.imagemagick.org/script/command-line-options.php#format

== REQUIREMENTS:

You must have ImageMagick installed.

== INSTALL:

If you downloaded the plugin version, just drop the plugin into RAILS_ROOT/plugins/

If you installed this as a gem, then to get it to work add <require "mini_magick"> to RAILS_ROOT/config/environment.rb

If you have just downloaded this files then copy the mini_magick.rb file into your RAILS_ROOT/lib directory and add <require "mini-magick"> to RAILS_ROOT/config/environment.rb

MiniMagick does NOT require rails though. All the code you need to use MiniMagick is located in the mini_magick/lib/mini_magick.rb file.

== LICENSE:

(The MIT License)

Copyright (c) 2007 FIX

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.

# -*- ruby -*-

require 'rubygems'

require 'hoe'

require './lib/mini_magick.rb'

Hoe.new('mini_magick', MiniMagick::VERSION) do |p|

  p.rubyforge_name = 'mini_magick'

  p.author = 'Corey Johnson'

  p.email = 'probablycorey+ruby@gmail.com'

  p.summary = 'A simple image manipulation library based on ImageMagick.'

  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")

  #p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]

  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")

end

# vim: syntax=Ruby

require 'mini_magick'

require 'image_temp_file'

require "tempfile"

module MiniMagick

  class ImageTempFile < Tempfile

    def make_tmpname(basename, n)

      # force tempfile to use basename's extension if provided

      ext = File.extname(basename)

      # force hyphens instead of periods in name

      sprintf('%s%d-%d%s', File.basename(basename, ext), $$, n, ext)

    end

  end

end

require "open-uri"

require "stringio"

require "fileutils"

require File.join(File.dirname(__FILE__), '/image_temp_file')

module MiniMagick

  class MiniMagickError < RuntimeError; end

  VERSION = '1.2.3'

  class Image

    attr :path

    attr :tempfile

    attr :output

    # Class Methods

    # -------------

    class <<self

      def from_blob(blob, extension=nil)

        begin

          tempfile = ImageTempFile.new("minimagick#{extension}")

          tempfile.binmode

          tempfile.write(blob)

        ensure

          tempfile.close

        end

        return self.new(tempfile.path, tempfile)

      end

      # Use this if you don't want to overwrite the image file

      def from_file(image_path)

        File.open(image_path, "rb") do |f|

          self.from_blob(f.read, File.extname(image_path))

        end

      end

    end

    # Instance Methods

    # ----------------

    def initialize(input_path, tempfile=nil)

      @path = input_path

      @tempfile = tempfile # ensures that the tempfile will stick around until this image is garbage collected.

      # Ensure that the file is an image

      run_command("identify", @path)

    end

    # For reference see http://www.imagemagick.org/script/command-line-options.php#format

    def [](value)

      # Why do I go to the trouble of putting in newlines? Because otherwise animated gifs screw everything up

      case value.to_s

      when "format"

        run_command("identify", "-format", format_option("%m"), @path).split("\n")[0]

      when "height"

        run_command("identify", "-format", format_option("%h"), @path).split("\n")[0].to_i

      when "width"

        run_command("identify", "-format", format_option("%w"), @path).split("\n")[0].to_i

      when "original_at"

        # Get the EXIF original capture as a Time object

        Time.local(*self["EXIF:DateTimeOriginal"].split(/:|\s+/)) rescue nil

      when /^EXIF\:/i

        run_command('identify', '-format', "\"%[#{value}]\"", @path).chop

      else

        run_command('identify', '-format', "\"#{value}\"", @path).split("\n")[0]

      end

    end

    # This is a 'special' command because it needs to change @path to reflect the new extension

    def format(format)

      run_command("mogrify", "-format", format, @path)

      @path = @path.sub(/(\.\w+)?$/, ".#{format}")

      raise "Unable to format to #{format}" unless File.exists?(@path)

    end

    # Writes the temporary image that we are using for processing to the output path

    def write(output_path)

      FileUtils.copy_file @path, output_path

      run_command "identify", output_path # Verify that we have a good image

    end

    # Give you raw data back

    def to_blob

      File.read @path

    end

    # If an unknown method is called then it is sent through the morgrify program

    # Look here to find all the commands (http://www.imagemagick.org/script/mogrify.php)

    def method_missing(symbol, *args)

      args.push(@path) # push the path onto the end

      run_command("mogrify", "-#{symbol}", *args)

      self

    end

    # You can use multiple commands together using this method

    def combine_options(&block)

      c = CommandBuilder.new

      block.call c

      run_command("mogrify", *c.args << @path)

    end

    # Check to see if we are running on win32 -- we need to escape things differently

    def windows?

      !(RUBY_PLATFORM =~ /win32/).nil?

    end

    # Outputs a carriage-return delimited format string for Unix and Windows

    def format_option(format)

      windows? ? "#{format}\\n" : "#{format}\\\\n"

    end

    def run_command(command, *args)

      args.collect! do |arg|

        arg = arg.to_s

        arg = %|"#{arg}"| unless arg[0] == ?- # values quoted because they can contain characters like '>', but don't quote switches          

        arg

      end

      @output = `#{command} #{args.join(' ')}`

      if $? != 0

        raise MiniMagickError, "ImageMagick command (#{command} #{args.join(' ')}) failed: Error Given #{$?}"

      else

        @output

      end

    end

  end

  class CommandBuilder

    attr :args

    def initialize

      @args = []

    end

    def method_missing(symbol, *args)

      @args << "-#{symbol}"

      @args += args

    end

    def +(value)

      @args << "+#{value}"

    end

  end

end

require File.join(File.dirname(__FILE__), 'mini_magick-1.2.3/lib/mini_magick')

test/amazon_s3.yml

test/debug.log

* Apr 17 2008 *

* amazon_s3.yml is now passed through ERB before being passed to AWS::S3 [François Beausoleil]

* Mar 22 2008 *

* Some tweaks to support Rails 2.0 and Rails 2.1 due to ActiveSupport::Callback changes.  

  Thanks to http://blog.methodmissing.com/2008/1/19/edge-callback-refactorings-attachment_fu/

* Feb. 26, 2008 *

* remove breakpoint from test_helper, makes test suite crazy (at least Rails 2+) [Rob Sanheim]

* make S3 test really optional [Rob Sanheim]

* Nov 27, 2007 *

* Handle properly ImageScience thumbnails resized from a gif file [Matt Aimonetti]

* Save thumbnails file size properly when using ImageScience [Matt Aimonetti]

* fixed s3 config file loading with latest versions of Rails [Matt Aimonetti]

* April 2, 2007 *

* don't copy the #full_filename to the default #temp_paths array if it doesn't exist

* add default ID partitioning for attachments

* add #binmode call to Tempfile (note: ruby should be doing this!) [Eric Beland]

* Check for current type of :thumbnails option.

* allow customization of the S3 configuration file path with the :s3_config_path option.

* Don't try to remove thumbnails if there aren't any.  Closes #3 [ben stiglitz]

* BC * (before changelog)

* add default #temp_paths entry [mattly]

* add MiniMagick support to attachment_fu [Isacc]

* update #destroy_file to clear out any empty directories too [carlivar]

* fix references to S3Backend module [Hunter Hillegas]

* make #current_data public with db_file and s3 backends [ebryn]

* oops, actually svn add the files for s3 backend. [Jeffrey Hardy]

* experimental s3 support, egad, no tests.... [Jeffrey Hardy]

* doh, fix a few bad references to ActsAsAttachment [sixty4bit]

attachment-fu

=============

attachment_fu is a plugin by Rick Olson (aka technoweenie <http://techno-weenie.net>) and is the successor to acts_as_attachment.  To get a basic run-through of its capabilities, check out Mike Clark's tutorial <http://clarkware.com/cgi/blosxom/2007/02/24#FileUploadFu>.

attachment_fu functionality

===========================

attachment_fu facilitates file uploads in Ruby on Rails.  There are a few storage options for the actual file data, but the plugin always at a minimum stores metadata for each file in the database.

There are three storage options for files uploaded through attachment_fu:

  File system

  Database file

  Amazon S3

Each method of storage many options associated with it that will be covered in the following section.  Something to note, however, is that the Amazon S3 storage requires you to modify config/amazon_s3.yml and the Database file storage requires an extra table.

attachment_fu models

====================

For all three of these storage options a table of metadata is required.  This table will contain information about the file (hence the 'meta') and its location.  This table has no restrictions on naming, unlike the extra table required for database storage, which must have a table name of db_files (and by convention a model of DbFile).

In the model there are two methods made available by this plugins: has_attachment and validates_as_attachment.

has_attachment(options = {})

  This method accepts the options in a hash:

    :content_type     # Allowed content types.

                      # Allows all by default.  Use :image to allow all standard image types.

    :min_size         # Minimum size allowed.

                      # 1 byte is the default.

    :max_size         # Maximum size allowed.

                      # 1.megabyte is the default.

    :size             # Range of sizes allowed.

                      # (1..1.megabyte) is the default.  This overrides the :min_size and :max_size options.

    :resize_to        # Used by RMagick to resize images.

                      # Pass either an array of width/height, or a geometry string.

    :thumbnails       # Specifies a set of thumbnails to generate.

                      # This accepts a hash of filename suffixes and RMagick resizing options.

                      # This option need only be included if you want thumbnailing.

    :thumbnail_class  # Set which model class to use for thumbnails.

                      # This current attachment class is used by default.

    :path_prefix      # path to store the uploaded files.

                      # Uses public/#{table_name} by default for the filesystem, and just #{table_name} for the S3 backend.  

                      # Setting this sets the :storage to :file_system.

    :storage          # Specifies the storage system to use..

                      # Defaults to :db_file.  Options are :file_system, :db_file, and :s3.

    :processor        # Sets the image processor to use for resizing of the attached image.

                      # Options include ImageScience, Rmagick, and MiniMagick.  Default is whatever is installed.

  Examples:

    has_attachment :max_size => 1.kilobyte

    has_attachment :size => 1.megabyte..2.megabytes

    has_attachment :content_type => 'application/pdf'

    has_attachment :content_type => ['application/pdf', 'application/msword', 'text/plain']

    has_attachment :content_type => :image, :resize_to => [50,50]

    has_attachment :content_type => ['application/pdf', :image], :resize_to => 'x50'

    has_attachment :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }

    has_attachment :storage => :file_system, :path_prefix => 'public/files'

    has_attachment :storage => :file_system, :path_prefix => 'public/files', 

                   :content_type => :image, :resize_to => [50,50]

    has_attachment :storage => :file_system, :path_prefix => 'public/files',

                   :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }

    has_attachment :storage => :s3

validates_as_attachment

  This method prevents files outside of the valid range (:min_size to :max_size, or the :size range) from being saved.  It does not however, halt the upload of such files.  They will be uploaded into memory regardless of size before validation.

  Example:

    validates_as_attachment

attachment_fu migrations

========================

Fields for attachment_fu metadata tables...

  in general:

    size,         :integer  # file size in bytes

    content_type, :string   # mime type, ex: application/mp3

    filename,     :string   # sanitized filename

  that reference images:

    height,       :integer  # in pixels

    width,        :integer  # in pixels

  that reference images that will be thumbnailed:

    parent_id,    :integer  # id of parent image (on the same table, a self-referencing foreign-key).

                            # Only populated if the current object is a thumbnail.

    thumbnail,    :string   # the 'type' of thumbnail this attachment record describes.  

                            # Only populated if the current object is a thumbnail.

                            # Usage:

                            # [ In Model 'Avatar' ]

                            #   has_attachment :content_type => :image, 

                            #                  :storage => :file_system, 

                            #                  :max_size => 500.kilobytes,

                            #                  :resize_to => '320x200>',

                            #                  :thumbnails => { :small => '10x10>',

                            #                                   :thumb => '100x100>' }

                            # [ Elsewhere ]

                            # @user.avatar.thumbnails.first.thumbnail #=> 'small'

  that reference files stored in the database (:db_file):

    db_file_id,   :integer  # id of the file in the database (foreign key)

Field for attachment_fu db_files table:

  data, :binary # binary file data, for use in database file storage

attachment_fu views

===================

There are two main views tasks that will be directly affected by attachment_fu: upload forms and displaying uploaded images.

There are two parts of the upload form that differ from typical usage.

  1. Include ':multipart => true' in the html options of the form_for tag.

    Example:

      <% form_for(:attachment_metadata, :url => { :action => "create" }, :html => { :multipart => true }) do |form| %>

  2. Use the file_field helper with :uploaded_data as the field name.

    Example:

      <%= form.file_field :uploaded_data %>

Displaying uploaded images is made easy by the public_filename method of the ActiveRecord attachment objects using file system and s3 storage.

public_filename(thumbnail = nil)

  Returns the public path to the file.  If a thumbnail prefix is specified it will return the public file path to the corresponding thumbnail.

  Examples:

    attachment_obj.public_filename          #=> /attachments/2/file.jpg

    attachment_obj.public_filename(:thumb)  #=> /attachments/2/file_thumb.jpg

    attachment_obj.public_filename(:small)  #=> /attachments/2/file_small.jpg

When serving files from database storage, doing more than simply downloading the file is beyond the scope of this document.

attachment_fu controllers

=========================

There are two considerations to take into account when using attachment_fu in controllers.

The first is when the files have no publicly accessible path and need to be downloaded through an action.

Example:

  def readme

    send_file '/path/to/readme.txt', :type => 'plain/text', :disposition => 'inline'

  end

See the possible values for send_file for reference.

The second is when saving the file when submitted from a form.

Example in view:

 <%= form.file_field :attachable, :uploaded_data %>

Example in controller:

  def create

    @attachable_file = AttachmentMetadataModel.new(params[:attachable])

    if @attachable_file.save

      flash[:notice] = 'Attachment was successfully created.'

      redirect_to attachable_url(@attachable_file)     

    else

      render :action => :new

    end

  end

require 'rake'

require 'rake/testtask'

require 'rake/rdoctask'

desc 'Default: run unit tests.'

task :default => :test

desc 'Test the attachment_fu plugin.'

Rake::TestTask.new(:test) do |t|

  t.libs << 'lib'

  t.pattern = 'test/**/*_test.rb'

  t.verbose = true

end

desc 'Generate documentation for the attachment_fu plugin.'

Rake::RDocTask.new(:rdoc) do |rdoc|

  rdoc.rdoc_dir = 'rdoc'

  rdoc.title    = 'ActsAsAttachment'

  rdoc.options << '--line-numbers --inline-source'

  rdoc.rdoc_files.include('README')

  rdoc.rdoc_files.include('lib/**/*.rb')

end

development:

  bucket_name: appname_development

  access_key_id: 

  secret_access_key: 

test:

  bucket_name: appname_test

  access_key_id: 

  secret_access_key: 

production:

  bucket_name: appname

  access_key_id: 

  secret_access_key: 

require 'tempfile'

Tempfile.class_eval do

  # overwrite so tempfiles use the extension of the basename.  important for rmagick and image science

  def make_tmpname(basename, n)

    ext = nil

    sprintf("%s%d-%d%s", basename.to_s.gsub(/\.\w+$/) { |s| ext = s; '' }, $$, n, ext)

  end

end

require 'geometry'

ActiveRecord::Base.send(:extend, Technoweenie::AttachmentFu::ActMethods)

Technoweenie::AttachmentFu.tempfile_path = ATTACHMENT_FU_TEMPFILE_PATH if Object.const_defined?(:ATTACHMENT_FU_TEMPFILE_PATH)

FileUtils.mkdir_p Technoweenie::AttachmentFu.tempfile_path

$:.unshift(File.dirname(__FILE__) + '/vendor')

require 'fileutils'

s3_config = File.dirname(__FILE__) + '/../../../config/amazon_s3.yml'

FileUtils.cp File.dirname(__FILE__) + '/amazon_s3.yml.tpl', s3_config unless File.exist?(s3_config)

puts IO.read(File.join(File.dirname(__FILE__), 'README'))

# This Geometry class was yanked from RMagick.  However, it lets ImageMagick handle the actual change_geometry.

# Use #new_dimensions_for to get new dimensons

# Used so I can use spiffy RMagick geometry strings with ImageScience

class Geometry

  # ! and @ are removed until support for them is added

  FLAGS = ['', '%', '<', '>']#, '!', '@']

  RFLAGS = { '%' => :percent,

             '!' => :aspect,

             '<' => :>,

             '>' => :<,

             '@' => :area }

  attr_accessor :width, :height, :x, :y, :flag

  def initialize(width=nil, height=nil, x=nil, y=nil, flag=nil)

    # Support floating-point width and height arguments so Geometry

    # objects can be used to specify Image#density= arguments.

    raise ArgumentError, "width must be >= 0: #{width}"   if width < 0

    raise ArgumentError, "height must be >= 0: #{height}" if height < 0

    @width  = width.to_f

    @height = height.to_f

    @x      = x.to_i

    @y      = y.to_i

    @flag   = flag

  end

  # Construct an object from a geometry string

  RE = /\A(\d*)(?:x(\d+))?([-+]\d+)?([-+]\d+)?([%!<>@]?)\Z/

  def self.from_s(str)

    raise(ArgumentError, "no geometry string specified") unless str

    if m = RE.match(str)

      new(m[1].to_i, m[2].to_i, m[3].to_i, m[4].to_i, RFLAGS[m[5]])

    else

      raise ArgumentError, "invalid geometry format"

    end

  end

  # Convert object to a geometry string

  def to_s

    str = ''

    str << "%g" % @width if @width > 0

    str << 'x' if (@width > 0 || @height > 0)

    str << "%g" % @height if @height > 0

    str << "%+d%+d" % [@x, @y] if (@x != 0 || @y != 0)

    str << FLAGS[@flag.to_i]

  end

  # attempts to get new dimensions for the current geometry string given these old dimensions.

  # This doesn't implement the aspect flag (!) or the area flag (@).  PDI

  def new_dimensions_for(orig_width, orig_height)

    new_width  = orig_width

    new_height = orig_height

    case @flag

      when :percent

        scale_x = @width.zero?  ? 100 : @width

        scale_y = @height.zero? ? @width : @height

        new_width    = scale_x.to_f * (orig_width.to_f  / 100.0)

        new_height   = scale_y.to_f * (orig_height.to_f / 100.0)

      when :<, :>, nil

        scale_factor =

          if new_width.zero? || new_height.zero?

            1.0

          else

            if @width.nonzero? && @height.nonzero?

              [@width.to_f / new_width.to_f, @height.to_f / new_height.to_f].min

            else

              @width.nonzero? ? (@width.to_f / new_width.to_f) : (@height.to_f / new_height.to_f)

            end

          end

        new_width  = scale_factor * new_width.to_f

        new_height = scale_factor * new_height.to_f

        new_width  = orig_width  if @flag && orig_width.send(@flag,  new_width)

        new_height = orig_height if @flag && orig_height.send(@flag, new_height)

    end

    [new_width, new_height].collect! { |v| v.round }

  end

end

class Array

  # allows you to get new dimensions for the current array of dimensions with a given geometry string

  #

  #   [50, 64] / '40>' # => [40, 51]

  def /(geometry)

    raise ArgumentError, "Only works with a [width, height] pair" if size != 2

    raise ArgumentError, "Must pass a valid geometry string or object" unless geometry.is_a?(String) || geometry.is_a?(Geometry)

    geometry = Geometry.from_s(geometry) if geometry.is_a?(String)

    geometry.new_dimensions_for first, last

  end

end

module Technoweenie # :nodoc:

  module AttachmentFu # :nodoc:

    module Backends

      # Methods for DB backed attachments

      module DbFileBackend

        def self.included(base) #:nodoc:

          Object.const_set(:DbFile, Class.new(ActiveRecord::Base)) unless Object.const_defined?(:DbFile)

          base.belongs_to  :db_file, :class_name => '::DbFile', :foreign_key => 'db_file_id'

        end

        # Creates a temp file with the current db data.

        def create_temp_file

          write_to_temp_file current_data

        end

        # Gets the current data from the database

        def current_data

          db_file.data

        end

        protected

          # Destroys the file.  Called in the after_destroy callback

          def destroy_file

            db_file.destroy if db_file

          end

          # Saves the data to the DbFile model

          def save_to_storage

            if save_attachment?

              (db_file || build_db_file).data = temp_data

              db_file.save!

              self.class.update_all ['db_file_id = ?', self.db_file_id = db_file.id], ['id = ?', id]

            end

            true

          end

      end

    end

  end

end

require 'ftools'

module Technoweenie # :nodoc:

  module AttachmentFu # :nodoc:

    module Backends

      # Methods for file system backed attachments

      module FileSystemBackend

        def self.included(base) #:nodoc:

          base.before_update :rename_file

        end

        # Gets the full path to the filename in this format:

        #

        #   # This assumes a model name like MyModel

        #   # public/#{table_name} is the default filesystem path 

        #   RAILS_ROOT/public/my_models/5/blah.jpg

        #

        # Overwrite this method in your model to customize the filename.

        # The optional thumbnail argument will output the thumbnail's filename.

        def full_filename(thumbnail = nil)

          file_system_path = (thumbnail ? thumbnail_class : self).attachment_options[:path_prefix].to_s

          File.join(RAILS_ROOT, file_system_path, *partitioned_path(thumbnail_name_for(thumbnail)))

        end

        # Used as the base path that #public_filename strips off full_filename to create the public path

        def base_path

          @base_path ||= File.join(RAILS_ROOT, 'public')

        end

        # The attachment ID used in the full path of a file

        def attachment_path_id

          ((respond_to?(:parent_id) && parent_id) || id).to_i

        end

        # 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" % attachment_path_id).scan(/..../) + args

        end

        # Gets the public path to the file

        # The optional thumbnail argument will output the thumbnail's filename.

        def public_filename(thumbnail = nil)

          full_filename(thumbnail).gsub %r(^#{Regexp.escape(base_path)}), ''

        end

        def filename=(value)

          @old_filename = full_filename unless filename.nil? || @old_filename

          write_attribute :filename, sanitize_filename(value)

        end

        # Creates a temp file from the currently saved file.

        def create_temp_file

          copy_to_temp_file full_filename

        end

        protected

          # Destroys the file.  Called in the after_destroy callback

          def destroy_file

            FileUtils.rm full_filename

            # remove directory also if it is now empty

            Dir.rmdir(File.dirname(full_filename)) if (Dir.entries(File.dirname(full_filename))-['.','..']).empty?

          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_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

          # Saves the file to the file system

          def save_to_storage

            if save_attachment?

              # TODO: This overwrites the file if it exists, maybe have an allow_overwrite option?

              FileUtils.mkdir_p(File.dirname(full_filename))

              File.cp(temp_path, full_filename)

              File.chmod(attachment_options[:chmod] || 0644, full_filename)

            end

            @old_filename = nil

            true

          end

          def current_data

            File.file?(full_filename) ? File.read(full_filename) : nil

          end

      end

    end

  end

end

module Technoweenie # :nodoc:

  module AttachmentFu # :nodoc:

    module Backends

      # = AWS::S3 Storage Backend

      #

      # Enables use of {Amazon's Simple Storage Service}[http://aws.amazon.com/s3] as a storage mechanism

      #

      # == Requirements

      #

      # Requires the {AWS::S3 Library}[http://amazon.rubyforge.org] for S3 by Marcel Molina Jr. installed either

      # as a gem or a as a Rails plugin.

      #

      # == Configuration

      #

      # Configuration is done via <tt>RAILS_ROOT/config/amazon_s3.yml</tt> and is loaded according to the <tt>RAILS_ENV</tt>.

      # The minimum connection options that you must specify are a bucket name, your access key id and your secret access key.

      # If you don't already have your access keys, all you need to sign up for the S3 service is an account at Amazon.

      # You can sign up for S3 and get access keys by visiting http://aws.amazon.com/s3.

      #

      # Example configuration (RAILS_ROOT/config/amazon_s3.yml)

      # 

      #   development:

      #     bucket_name: appname_development

      #     access_key_id: <your key>

      #     secret_access_key: <your key>

      #   

      #   test:

      #     bucket_name: appname_test

      #     access_key_id: <your key>

      #     secret_access_key: <your key>

      #   

      #   production:

      #     bucket_name: appname

      #     access_key_id: <your key>

      #     secret_access_key: <your key>

      #

      # You can change the location of the config path by passing a full path to the :s3_config_path option.

      #

      #   has_attachment :storage => :s3, :s3_config_path => (RAILS_ROOT + '/config/s3.yml')

      #

      # === Required configuration parameters

      #

      # * <tt>:access_key_id</tt> - The access key id for your S3 account. Provided by Amazon.

      # * <tt>:secret_access_key</tt> - The secret access key for your S3 account. Provided by Amazon.

      # * <tt>:bucket_name</tt> - A unique bucket name (think of the bucket_name as being like a database name).

      #

      # If any of these required arguments is missing, a MissingAccessKey exception will be raised from AWS::S3.

      #

      # == About bucket names

      #

      # Bucket names have to be globaly unique across the S3 system. And you can only have up to 100 of them,

      # so it's a good idea to think of a bucket as being like a database, hence the correspondance in this

      # implementation to the development, test, and production environments.

      #

      # The number of objects you can store in a bucket is, for all intents and purposes, unlimited.

      #

      # === Optional configuration parameters

      #

      # * <tt>:server</tt> - The server to make requests to. Defaults to <tt>s3.amazonaws.com</tt>.

      # * <tt>:port</tt> - The port to the requests should be made on. Defaults to 80 or 443 if <tt>:use_ssl</tt> is set.

      # * <tt>:use_ssl</tt> - If set to true, <tt>:port</tt> will be implicitly set to 443, unless specified otherwise. Defaults to false.

      #

      # == Usage

      #

      # To specify S3 as the storage mechanism for a model, set the acts_as_attachment <tt>:storage</tt> option to <tt>:s3</tt>.

      #

      #   class Photo < ActiveRecord::Base

      #     has_attachment :storage => :s3

      #   end

      #

      # === Customizing the path

      #

      # By default, files are prefixed using a pseudo hierarchy in the form of <tt>:table_name/:id</tt>, which results

      # in S3 urls that look like: http(s)://:server/:bucket_name/:table_name/:id/:filename with :table_name

      # representing the customizable portion of the path. You can customize this prefix using the <tt>:path_prefix</tt>

      # option:

      #

      #   class Photo < ActiveRecord::Base

      #     has_attachment :storage => :s3, :path_prefix => 'my/custom/path'

      #   end

      #

      # Which would result in URLs like <tt>http(s)://:server/:bucket_name/my/custom/path/:id/:filename.</tt>

      #

      # === Permissions

      #

      # By default, files are stored on S3 with public access permissions. You can customize this using

      # the <tt>:s3_access</tt> option to <tt>has_attachment</tt>. Available values are 

      # <tt>:private</tt>, <tt>:public_read_write</tt>, and <tt>:authenticated_read</tt>.

      #

      # === Other options

      #

      # Of course, all the usual configuration options apply, such as content_type and thumbnails:

      #

      #   class Photo < ActiveRecord::Base

      #     has_attachment :storage => :s3, :content_type => ['application/pdf', :image], :resize_to => 'x50'

      #     has_attachment :storage => :s3, :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }

      #   end

      #

      # === Accessing S3 URLs

      #

      # You can get an object's URL using the s3_url accessor. For example, assuming that for your postcard app

      # you had a bucket name like 'postcard_world_development', and an attachment model called Photo:

      #

      #   @postcard.s3_url # => http(s)://s3.amazonaws.com/postcard_world_development/photos/1/mexico.jpg

      #

      # The resulting url is in the form: http(s)://:server/:bucket_name/:table_name/:id/:file.

      # The optional thumbnail argument will output the thumbnail's filename (if any).

      #

      # Additionally, you can get an object's base path relative to the bucket root using

      # <tt>base_path</tt>:

      #

      #   @photo.file_base_path # => photos/1

      #

      # And the full path (including the filename) using <tt>full_filename</tt>:

      #

      #   @photo.full_filename # => photos/

      #

      # Niether <tt>base_path</tt> or <tt>full_filename</tt> include the bucket name as part of the path.

      # You can retrieve the bucket name using the <tt>bucket_name</tt> method.

      module S3Backend

        class RequiredLibraryNotFoundError < StandardError; end

        class ConfigFileNotFoundError < StandardError; end

        def self.included(base) #:nodoc:

          mattr_reader :bucket_name, :s3_config

          begin

            require 'aws/s3'

            include AWS::S3

          rescue LoadError

            raise RequiredLibraryNotFoundError.new('AWS::S3 could not be loaded')

          end

          begin

            @@s3_config_path = base.attachment_options[:s3_config_path] || (RAILS_ROOT + '/config/amazon_s3.yml')

            @@s3_config = @@s3_config = YAML.load(ERB.new(File.read(@@s3_config_path)).result)[RAILS_ENV].symbolize_keys

          #rescue

          #  raise ConfigFileNotFoundError.new('File %s not found' % @@s3_config_path)

          end

          @@bucket_name = s3_config[:bucket_name]

          Base.establish_connection!(s3_config.slice(:access_key_id, :secret_access_key, :server, :port, :use_ssl, :persistent, :proxy))

          # Bucket.create(@@bucket_name)

          base.before_update :rename_file

        end

        def self.protocol

          @protocol ||= s3_config[:use_ssl] ? 'https://' : 'http://'

        end

        def self.hostname

          @hostname ||= s3_config[:server] || AWS::S3::DEFAULT_HOST

        end

        def self.port_string

          @port_string ||= (s3_config[:port].nil? || s3_config[:port] == (s3_config[:use_ssl] ? 443 : 80)) ? '' : ":#{s3_config[:port]}"

        end

        module ClassMethods

          def s3_protocol

            Technoweenie::AttachmentFu::Backends::S3Backend.protocol

          end

          def s3_hostname

            Technoweenie::AttachmentFu::Backends::S3Backend.hostname

          end

          def s3_port_string

            Technoweenie::AttachmentFu::Backends::S3Backend.port_string

          end

        end

        # Overwrites the base filename writer in order to store the old filename

        def filename=(value)

          @old_filename = filename unless filename.nil? || @old_filename

          write_attribute :filename, sanitize_filename(value)

        end

        # The attachment ID used in the full path of a file

        def attachment_path_id

          ((respond_to?(:parent_id) && parent_id) || id).to_s

        end

        # The pseudo hierarchy containing the file relative to the bucket name

        # Example: <tt>:table_name/:id</tt>

        def base_path

          File.join(attachment_options[:path_prefix], attachment_path_id)

        end

        # The full path to the file relative to the bucket name

        # Example: <tt>:table_name/:id/:filename</tt>

        def full_filename(thumbnail = nil)

          File.join(base_path, thumbnail_name_for(thumbnail))

        end