stash-magic 0.0.9 → 0.1.0

data/.gitignore

@@ -1 +1,3 @@
 pkg/*
+private/*
+*.swp

data/README.rdoc

@@ -2,13 +2,15 @@
 
 = Stash Magic (BETA)
 
-Stash Magic provides a very simple interface for dealing with file system attachments in a database and help you with thumbnails or other styles via ImageMagick (hence, the name). Features are:
+Stash Magic provides a very simple interface for dealing with attachments on file system or Amazon S3 in a database and help you with thumbnails or other styles via ImageMagick (hence, the name). Features are:
 
 - Many attachments per database entry
 - ImageMagick string builder
-- after_stash hook for creating thumbnails or other styles automatically when attachment is created or updated.
+- `after_stash` hook for creating thumbnails or other styles automatically when attachment is created or updated.
+- `after_stash` hook also allow you to recreate all styles when you changed one
 - Specs for Sequel ORM but pretty easy to adapt
-- Easy to understand (one file) module 
+- Easy to understand (due to the lack of bells and whistles which makes it more dangerous as well. Gniark gniark.)
+- Storage on filesystem or Amazon S3
 
 This is still in Beta version built with simplicity in mind.
 It tries to do a lot with less code that anybody would be able to understand quickly.
@@ -20,16 +22,8 @@ So any test or help is welcome.
 
 = How to install
 
-  gem install stash-magic
-
-Use Sudo if you want to install it for all users of your server:
-
   sudo gem install stash-magic
 
-If you have Ruby 1.9, this is most likely that you have to replace the command gem by gem19:
-
-  sudo gem19 install stash-magic 
-
 = How to use
 
 First you have to require the module:
@@ -42,12 +36,25 @@ And then inside your model class, you have to include the module and declare whe
     include ::StashMagic
     self.public_root = ::File.expand_path(::File.dirname(__FILE__)+'/public')
   end
+
+Or if you want to use Amazon S3, replace `public_root` by `bucket:
+
+  class Treasure < ::Sequel::Model
+    include ::StashMagic
+    self.public_root = ::File.expand_path(::File.dirname(__FILE__)+'/public')
+  end
   
-The module has a method to do both in one line though:
+The module has a method to include and set it at once though:
 
   class Treasure < ::Sequel::Model
     ::StashMagic.with_public_root ::File.expand_path(::File.dirname(__FILE__)+'/public')
   end
+
+Or for Amazon S3:
+
+  class Treasure < ::Sequel::Model
+    ::StashMagic.bucket 'my-bucket-on-amazon-s3'
+  end
   
 After that, for each attachment you want, you need to have a column in the database as a string. And then you declare them with method Model#stash:
 
@@ -58,7 +65,7 @@ After that, for each attachment you want, you need to have a column in the datab
     stash :stamp
   end
   
-This method accepts an optional hash as a second argument which is not used by the module itself, but could be handy for you as you can have it in the stash reflection:
+This method accepts an optional hash as a second argument which could be handy for you as you can have it in the stash reflection:
 
   class Treasure < ::Sequel::Model
     ::StashMagic.with_public_root ::File.expand_path(::File.dirname(__FILE__)+'/public')
@@ -73,6 +80,17 @@ The method Treasure.stash_reflection would return:
     :map => {}, 
     :stamp => {:accept_gif => false, :limit => 512000} 
   }
+
+It is also used for setting Amazon S3 in order to declare the options when storing.
+The key is `:s3_store_options`.
+For instance you can declare an attachment to be private (StashMagic uses :public_read by default):
+
+  class Treasure < ::Sequel::Model
+    ::StashMagic.with_public_root ::File.expand_path(::File.dirname(__FILE__)+'/public')
+    
+    stash :map
+    stash :stamp, :s3_store_options => { :access => :private }
+  end
   
 When building your html forms, just make sure that your stash inputs are of the type 'file', and StashMagic will deal with everything else. The getters will return a hash with the following values:
 
@@ -91,10 +109,12 @@ When you want to use attachment in your application, you can retrieve the file u
   @treasure_instance.file_url(:map)                # The original file
   @treasure_instance.file_url(:map, 'thumb.gif')   # The picture in a thumb.gif style (see next chapter to learn about styles)
   
-You might also want to do things on the server side like changing rights on the image or whatever. For that purpose, there is a third argument which is a boolean. When set to true, it will give you the absolute path to the file:
+You might also want to do things on the server side like changing rights on the image or whatever. For that purpose, there is a similar method `file_path` with a boolean. When set to true, it will give you the absolute path to the file (file system only):
+
+  @treasure_instance.file_path(:map, nil, true)            # /absolute/path/to/public/stash/Treasure/1/map.pdf
+  @treasure_instance.file_path(:map, 'thumb.gif', true)    # /absolute/path/to/public/stash/Treasure/1/map.thumb.gif
 
-  @treasure_instance.file_url(:map, nil, true)            # /absolute/path/to/public/stash/Treasure/1/map.pdf
-  @treasure_instance.file_url(:map, 'thumb.gif', true)    # /absolute/path/to/public/stash/Treasure/1/map.thumb.gif
+When using Amazon S3, there is a 3rd argument to `file_url` which is a boolean that says if you want ssl or not (false by default). Because the `file_url` is an absolute path when using S3.
   
 = Thumbnails and Other Styles
 
@@ -119,7 +139,7 @@ Even though StashMagic provides a builder for ImageMagick scripts, I suggest you
 - The builder is limited, not as complete as real ImageMagick ruby wrapper like RMagick
 - I like to believe it's fun as well (not only powerful)
 
-So for the couragous amongst you, here is the way you create a very simple style for the portrait attachment:
+So for the courageous amongst you, here is the way you create a very simple style for the portrait attachment:
 
   @treasure_instance.convert :portrait, '-resize 100x75', 'mini.gif'
   
@@ -192,7 +212,7 @@ Which will secretly do something like:
   
 = How to create thumbnails on the flight (The Hook)
 
-It is of course possible. StashMagic provides a hook called after_stash which takes the attachment_name as an argument. This hook is implemented by default and create automaticaly for every image a thumbnail called 'stash_thumb.gif'.
+It is of course possible. StashMagic provides a hook called `after_stash` which takes the attachment_name as an argument. This hook is implemented by default and create automatically for every image a thumbnail called 'stash_thumb.gif'.
 
 What you have to do is overwrite the hook. For example, say you want every attachment to have a 200x200 perfect squared version:
 
@@ -216,6 +236,24 @@ This is done by using `nil` as a style:
     image_magick(attachment_name) { im_resize(400,300) }
   end
 
+= More about `after_stash` hook
+
+If you need to reprocess all the images for a specific attachment, you can use the hook manually:
+
+    @my_instance.after_stash(:illustration)
+
+Now if you want to do it on all the instances of the class:
+
+    MyModelClass.all{ |i| i.after_stash(:illustration) }
+
+But you might want to do the same for all attachments:
+
+    MyModelClass.all{ |i| MyModelClass.stash_reflection.keys.each { |k| i.after_stash(k) } }
+
+And finally there is a simple method that does the same for all the Classes using StashMagic:
+
+    StashMagic.all_after_stash
+
 = How my files are then saved on my file system
 
 I like to believe that one don't have to think about that as long as the module provides enough methods to do what you need to do.
@@ -247,13 +285,19 @@ Please note that the class name is a simple #to_s. I've realized recently that m
   BootStrap
   BootsTrap 
 
+Amazon S3 filenames follow the same sort of logic.
+
+= Reprocess your thumbnails
+
+Sometimes you need to change your `after_stash`
+
 = More Details
 
 For more details, you can have a look at the specs to see how it's used or contact me on github if you have any question: http://github.com/mig-hub
 
 The project is speced with 
 - Bacon 1.1.0
-- Sequel 3.14.0
+- Sequel 3.19.0
 - ImageMagick 6.5.8
 
 = Change Log
@@ -265,6 +309,7 @@ The project is speced with
 - 0.0.7   Make it possible to overwrite the original image with another style in after_stash
 - 0.0.8   Default thumb does not break when file name has signs in the name
 - 0.0.9   Fix a bug when Model#build_image_tag uses a symbol for the attachment name
+- 0.1.0   Now with the option to use S3 instead of file system and a method to reprocess thumbnails
 
 == Copyright
 

data/lib/stash_magic/image_magick_string_builder.rb

@@ -0,0 +1,31 @@
+module StashMagic
+  module ImageMagickStringBuilder
+  
+    def image_magick(attachment_name, style=nil, &block)
+      @image_magick_strings = []
+      instance_eval &block
+      convert_string = @image_magick_strings.join(' ')
+      convert(attachment_name, convert_string, style)
+      @image_magick_strings = nil
+      convert_string
+    end
+  
+    def im_write(s)
+      @image_magick_strings << s
+    end
+    def im_resize(width, height, geometry_option=nil, gravity=nil)
+      if width.nil? || height.nil?
+        @image_magick_strings << "-resize '#{width}x#{height}#{geometry_option}'"
+      else
+        @image_magick_strings << "-resize '#{width}x#{height}#{geometry_option}' -gravity #{gravity || 'center'} -extent #{width}x#{height}"
+      end
+    end
+    def im_crop(width, height, x, y)
+      @image_magick_strings <<  "-crop #{width}x#{height}+#{x}+#{y} +repage"
+    end
+    def im_negate
+      @image_magick_strings << '-negate'
+    end
+    
+  end
+end

data/lib/stash_magic/storage_filesystem.rb

@@ -0,0 +1,74 @@
+module StashMagic
+  module StorageFilesystem
+  
+    # ===========
+    # = Helpers =
+    # ===========
+  
+    def public_root; self.class.public_root; end
+  
+    # This is the path of the instance
+    # Full is when you want a computer path as opposed to a browser path
+    def file_root(full=false)
+      "#{public_root if full}/stash/#{self.class.to_s}/#{self.id || 'tmp'}"
+    end
+     
+    # This is the path of an attachment in a special style
+    # Full is when you want a computer path as opposed to a browser path
+    def file_path(attachment_name, style=nil, full=false)
+      f = __send__(attachment_name)
+      return nil if f.nil?
+      fn = style.nil? ? f[:name] : "#{attachment_name}.#{style}"
+      "#{file_root(full)}/#{fn}"
+    end
+  
+    # The actual URL for a link to the attachment
+    # Here it is the same as file_path
+    # But that gives a unified version for filesystem and S3
+    def file_url(attachment_name, style=nil); file_path(attachment_name, style); end
+  
+    # =========
+    # = Hooks =
+    # =========
+  
+    def after_save
+      super rescue nil
+      unless (@tempfile_path.nil? || @tempfile_path.empty?)
+        stash_path = file_root(true)
+        D::mkdir(stash_path) unless F::exist?(stash_path)
+        @tempfile_path.each do |k,v|
+          url = file_path(k, nil, true)
+          destroy_files_for(k, url) # Destroy previously saved files
+          FU.move(v, url) # Save the new one
+          FU.chmod(0777, url)
+          after_stash(k)
+        end
+        # Reset in case we access two times the entry in the same session
+        # Like setting an attachment and destroying it in a row
+        # Dummy ex:    Model.create(:img => file).update(:img => nil)
+        @tempfile_path = nil
+      end
+    end
+  
+    def destroy_files_for(attachment_name, url=nil)
+      url ||= file_path(attachment_name, nil, true)
+      D[url.sub(/\.[^.]+$/, '.*')].each {|f| FU.rm(f) }
+    end
+    alias destroy_file_for destroy_files_for
+  
+    def after_destroy
+      super rescue nil
+      p = file_root(true)
+      FU.rm_rf(p) if F.exists?(p)
+    end
+  
+    # ===============
+    # = ImageMagick =
+    # ===============
+  
+    def convert(attachment_name, convert_steps="", style=nil)
+      system "convert \"#{file_path(attachment_name, nil, true)}\" #{convert_steps} \"#{file_path(attachment_name, style, true)}\""
+    end
+    
+  end
+end

data/lib/stash_magic/storage_s3.rb

@@ -0,0 +1,108 @@
+module StashMagic
+  module StorageS3
+    
+    require 'aws/s3'
+  
+    # ===========
+    # = Helpers =
+    # ===========
+  
+    def bucket; self.class.bucket; end
+  
+    def s3_store_options(attachment_name)
+      {:access=>:public_read}.update(self.class.stash_reflection[attachment_name][:s3_store_options]||{})
+    end
+  
+    # This is the path of the instance
+    def file_root; "#{self.class.to_s}/#{self.id || 'tmp'}"; end
+     
+    # This is the path of an attachment in a special style
+    def file_path(attachment_name, style=nil)
+      f = __send__(attachment_name)
+      return nil if f.nil?
+      fn = style.nil? ? f[:name] : "#{attachment_name}.#{style}"
+      "#{file_root}/#{fn}"
+    end
+  
+    # URL to access the file in browser
+    # But it only gives a URL with no credentials, when the file is public
+    # Otherwise it is better to use Model#s3object.url
+    # Careful with the later if you have private files
+    def file_url(attachment_name, style=nil, ssl=false)
+      f = file_path(attachment_name, style)
+      return nil if f.nil?
+      "http#{'s' if ssl}://s3.amazonaws.com/#{bucket}/#{f}"
+    end
+  
+    def s3object(attachment_name,style=nil)
+      u = file_path(attachment_name,style)
+      return nil if u.nil?
+      AWS::S3::S3Object.find(u, bucket)
+    end
+  
+    def get_file(attachment_name, style=nil)
+      u = file_path(attachment_name,style)
+      f = Tempfile.new('StashMagic_src')
+      f.binmode
+      f.write(AWS::S3::S3Object.value(u, bucket))
+      f.rewind
+      f
+    end
+  
+    # =========
+    # = Hooks =
+    # =========
+  
+    def after_save
+      super rescue nil
+      unless (@tempfile_path.nil? || @tempfile_path.empty?)
+        stash_path = file_root
+        @tempfile_path.each do |k,v|
+          url = file_path(k, nil)
+          destroy_files_for(k, url) # Destroy previously saved files
+          AWS::S3::S3Object.store(url, open(v), bucket, s3_store_options(k))
+          after_stash(k)
+        end
+        # Reset in case we access two times the entry in the same session
+        # Like setting an attachment and destroying it in a row
+        # Dummy ex:    Model.create(:img => file).update(:img => nil)
+        @tempfile_path = nil
+      end
+    end
+  
+    def destroy_files_for(attachment_name, url=nil)
+      url ||= file_path(attachment_name, nil)
+      AWS::S3::Bucket.objects(bucket, :prefix=>url.sub(/[^.]+$/, '')).each do |o|
+        o.delete
+      end
+    end
+    alias destroy_file_for destroy_files_for
+  
+    def after_destroy
+      super rescue nil
+      AWS::S3::Bucket.objects(bucket, :prefix=>file_root).each do |o|
+        o.delete
+      end
+    end
+  
+    # ===============
+    # = ImageMagick =
+    # ===============
+  
+    def convert(attachment_name, convert_steps="", style=nil)
+      @tempfile_path ||= {}
+      tempfile_path = @tempfile_path[attachment_name.to_sym]
+      if !tempfile_path.nil? && F.exists?(tempfile_path)
+        src_path = tempfile_path
+      else
+        src_path = get_file(attachment_name).path
+      end
+      dest = Tempfile.new('StashMagic_dest')
+      dest.binmode
+      dest.close
+      system "convert \"#{src_path}\" #{convert_steps} \"#{dest.path}\""
+      AWS::S3::S3Object.store(file_path(attachment_name,style), dest.open, bucket, s3_store_options(attachment_name))
+    end
+    
+  end
+end

data/lib/stash_magic.rb

@@ -0,0 +1,164 @@
+require 'fileutils'
+require 'stash_magic/image_magick_string_builder'
+require 'stash_magic/storage_filesystem'
+require 'stash_magic/storage_s3'
+
+module StashMagic
+  
+  F = ::File
+  D = ::Dir
+  FU = ::FileUtils
+  include ImageMagickStringBuilder
+  
+  # ====================
+  # = Module Inclusion =
+  # ====================
+  
+  class << self
+    attr_accessor :classes
+    StashMagic.classes = []
+    
+    # Include and declare public root in one go
+    def with_public_root(location, into=nil)
+      into ||= into_from_backtrace(caller)
+      into.__send__(:include, self)
+      into.public_root = location
+      into
+    end
+    # Include and declare bucket in one go
+    def with_bucket(bucket, into=nil)
+      into ||= into_from_backtrace(caller)
+      into.__send__(:include, self)
+      into.bucket = bucket
+      into
+    end
+    # Trick stolen from Innate framework
+    # Allows not to pass self all the time
+    def into_from_backtrace(backtrace)
+      filename, lineno = backtrace[0].split(':', 2)
+      regexp = /^\s*class\s+(\S+)/
+      F.readlines(filename)[0..lineno.to_i].reverse.find{|ln| ln =~ regexp }
+      const_get($1)
+    end
+    
+    def all_after_stash
+      StashMagic.classes.each do |m|
+        m.all do |i|
+          m.stash_reflection.keys.each do |k|
+            i.after_stash(k)
+          end
+        end
+      end
+    end
+    
+  end
+  
+  # ============
+  # = Included =
+  # ============
+  
+  def self.included(into)
+    
+    StashMagic.classes << into
+    
+    class << into
+      attr_accessor :stash_reflection, :storage
+      attr_reader :public_root, :bucket
+      
+      #include(ImageMagickStringBuilder)
+      
+      def public_root=(location)
+        @public_root = location
+        FU.mkdir_p(location+'/stash/'+self.name.to_s)
+        include(StorageFilesystem)
+        @storage = :filesystem
+      end
+      
+      def bucket=(b)
+        @bucket = b.to_s
+        include(StorageS3)
+        @storage = :s3
+      end
+      
+      # Declare a stash entry
+      def stash(name, options={})
+        stash_reflection.store name.to_sym, options
+        # Exemple of upload hash for attachments:
+        # { :type=>"image/jpeg", 
+        #   :filename=>"default.jpeg", 
+        #   :tempfile=>#<File:/var/folders/J0/J03dF6-7GCyxMhaB17F5yk+++TI/-Tmp-/RackMultipart.12704.0>, 
+        #   :head=>"Content-Disposition: form-data; name=\"model[attachment]\"; filename=\"default.jpeg\"\r\nContent-Type: image/jpeg\r\n", 
+        #   :name=>"model[attachment]"
+        # }
+        #
+        # SETTER
+        define_method name.to_s+'='  do |upload_hash|
+          return if upload_hash=="" # File in the form is unchanged
+          
+          if upload_hash.nil?
+            destroy_files_for(name) unless self.__send__(name).nil?
+            super('')
+          else
+          
+            @tempfile_path ||= {}
+            @tempfile_path[name.to_sym] = upload_hash[:tempfile].path
+            h = {
+              :name => name.to_s + upload_hash[:filename][/\.[^.]+$/], 
+              :type => upload_hash[:type], 
+              :size => upload_hash[:tempfile].size
+            }
+            super(h.inspect)
+            
+          end
+        end
+        # GETTER
+        define_method name.to_s do |*args|
+          eval(super(*args).to_s)
+        end
+      end
+      
+    end
+    into.stash_reflection = {}
+  end
+  
+  # ===========
+  # = Helpers =
+  # ===========
+  
+  # Build the image tag with all SEO friendly info
+  # It's possible to add html attributes in a hash
+  def build_image_tag(attachment_name, style=nil, html_attributes={})
+    title_field, alt_field = (attachment_name.to_s+'_tooltip').to_sym, (attachment_name.to_s+'_alternative_text').to_sym
+    title = __send__(title_field) if columns.include?(title_field)
+    alt = __send__(alt_field) if columns.include?(alt_field)
+    html_attributes = {:src => file_url(attachment_name, style), :title => title, :alt => alt}.update(html_attributes)
+    html_attributes = html_attributes.map do |k,v|
+      %{#{k.to_s}="#{html_escape(v.to_s)}"}
+    end.join(' ')
+    
+    "<img #{html_attributes} />"
+  end
+  
+  # =========
+  # = Hooks =
+  # =========
+  
+  def after_stash(attachment_name)
+    current = self.__send__(attachment_name)
+    convert(attachment_name, "-resize '100x75^' -gravity center -extent 100x75", 'stash_thumb.gif') if !current.nil? && current[:type][/^image\//]
+  end
+  
+  def method_missing(m,*args)
+    raise(NoMethodError, "You have to choose a strorage system") if self.class.storage.nil?
+    super
+  end
+  
+  private
+  
+  # Stolen from ERB
+  def html_escape(s)
+    s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+  end
+  
+  
+end

data/stash_magic.gemspec

@@ -1,12 +1,11 @@
 Gem::Specification.new do |s| 
   s.name = 'stash-magic'
-  s.version = "0.0.9"
+  s.version = "0.1.0"
   s.platform = Gem::Platform::RUBY
   s.summary = "File Attachment Made Simple"
-  s.description = "A simple attachment system that also handles thumbnails or other styles via ImageMagick. Originaly tested on Sequel ORM but purposedly easy to plug to something else."
+  s.description = "A simple attachment system (file system or Amazon S3) that also handles thumbnails or other styles via ImageMagick. Originaly tested on Sequel ORM but purposedly easy to plug to something else."
   s.files = `git ls-files`.split("\n").sort
-  s.test_files = ['spec.rb']
-  s.require_path = '.'
+  s.require_path = './lib'
   s.author = "Mickael Riga"
   s.email = "mig@mypeplum.com"
   s.homepage = "http://github.com/mig-hub/stash_magic"

data/test/spec_builder.rb

@@ -0,0 +1,105 @@
+F = ::File
+D = ::Dir
+
+require 'rubygems'
+require 'bacon'
+
+require 'sequel'
+DB = Sequel.sqlite
+
+require 'tempfile'
+
+$:.unshift(F.dirname(__FILE__)+'/../lib')
+require 'stash_magic'
+
+class Treasure < ::Sequel::Model
+  PUBLIC = F.expand_path(F.dirname(__FILE__)+'/public')
+  ::StashMagic.with_public_root(PUBLIC)
+  
+  plugin :schema
+  set_schema do
+    primary_key :id
+    Integer :age
+    String :map # jpeg
+    String :map_tooltip
+    String :map_alternative_text
+    String :mappy # jpeg - Used to see if mappy files are not destroyed when map is (because it starts the same)
+    String :instructions #pdf
+  end
+  create_table unless table_exists?
+  
+  stash :map
+  stash :mappy
+  stash :instructions
+  
+  def validate
+    errors[:age] << "Not old enough" unless (self.age.nil? || self.age>10)
+    errors[:instructions] << "Too big" if (!self.instructions.nil? && self.instructions[:size].to_i>46000)
+  end
+end
+
+# Make temporary public folder
+D.mkdir(Treasure::PUBLIC) unless F.exists?(Treasure::PUBLIC)
+
+describe 'StashMagic ImageMagickStringBuilder' do
+  
+  `convert rose: #{Treasure::PUBLIC}/rose.jpg` unless F.exists?(Treasure::PUBLIC+'/rose.jpg') # Use ImageMagick to build a tmp image to use
+  `convert granite: #{Treasure::PUBLIC}/granite.gif` unless F.exists?(Treasure::PUBLIC+'/granite.gif') # Use ImageMagick to build a tmp image to use
+  `convert rose: #{Treasure::PUBLIC}/rose.pdf` unless F.exists?(Treasure::PUBLIC+'/rose.pdf') # Use ImageMagick to build a tmp image to use
+  `convert logo: #{Treasure::PUBLIC}/logo.pdf` unless F.exists?(Treasure::PUBLIC+'/logo.pdf')
+  
+  def mock_upload(uploaded_file_path, content_type, binary=false)
+    n = F.basename(uploaded_file_path)
+    f = ::Tempfile.new(n)
+    f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
+    f.binmode if binary
+    ::FileUtils.copy_file(uploaded_file_path, f.path)
+    {
+      :filename => n, 
+      :type => content_type,
+      :tempfile => f
+    }
+  end
+  
+  before do
+    @img = mock_upload(Treasure::PUBLIC+'/rose.jpg', 'image/jpeg', true)
+    @img2 = mock_upload(Treasure::PUBLIC+'/granite.gif', 'image/gif', true)
+    @pdf = mock_upload(Treasure::PUBLIC+'/rose.pdf', 'application/pdf', true)
+    @pdf2 = mock_upload(Treasure::PUBLIC+'/logo.pdf', 'application/pdf', true)
+  end
+  
+  it "Should have ImageMagick building strings correctly" do
+    @t = Treasure.create(:map=>@img)
+    
+    @t.image_magick(:map, 'test.gif') do
+      im_write("-negate")
+      im_crop(200,100,20,10)
+      im_resize(nil, 100)
+    end.should=="-negate -crop 200x100+20+10 +repage -resize 'x100'"
+    F.exists?(@t.file_path(:map,'test.gif',true)).should==true
+    
+    @t.image_magick(:map, 'test2.gif') do
+      im_write("-negate")
+      im_crop(200,100,20,10)
+      im_resize(nil, 100, '>')
+    end.should=="-negate -crop 200x100+20+10 +repage -resize 'x100>'"
+    F.exists?(@t.file_path(:map,'test2.gif',true)).should==true
+    
+    @t.image_magick(:map, 'test3.gif') do
+      im_write("-negate")
+      im_crop(200,100,20,10)
+      im_resize(200, 100, '^')
+    end.should=="-negate -crop 200x100+20+10 +repage -resize '200x100^' -gravity center -extent 200x100"
+    F.exists?(@t.file_path(:map,'test3.gif',true)).should==true
+    
+    @t.image_magick(:map, 'test4.gif') do
+      im_write("-negate")
+      im_crop(200,100,20,10)
+      im_resize(200, 100, '^', 'North')
+    end.should=="-negate -crop 200x100+20+10 +repage -resize '200x100^' -gravity North -extent 200x100"
+    F.exists?(@t.file_path(:map,'test4.gif',true)).should==true    
+  end
+  
+  ::FileUtils.rm_rf(Treasure::PUBLIC) if F.exists?(Treasure::PUBLIC)
+  
+end

data/{spec.rb → test/spec_filesystem.rb}

@@ -1,20 +1,16 @@
-# =========
-# = Setup =
-# =========
-
 F = ::File
 D = ::Dir
 
 require 'rubygems'
 require 'bacon'
-Bacon.summary_on_exit
 
 require 'sequel'
 DB = Sequel.sqlite
 
 require 'tempfile'
 
-require F.dirname(__FILE__)+'/stash_magic'
+$:.unshift(F.dirname(__FILE__)+'/../lib')
+require 'stash_magic'
 
 class Treasure < ::Sequel::Model
   PUBLIC = F.expand_path(F.dirname(__FILE__)+'/public')
@@ -61,7 +57,7 @@ D.mkdir(Treasure::PUBLIC) unless F.exists?(Treasure::PUBLIC)
 # = Tests =
 # =========
 
-describe ::StashMagic do
+describe 'StashMagic Filesystem' do
   
   `convert rose: #{Treasure::PUBLIC}/rose.jpg` unless F.exists?(Treasure::PUBLIC+'/rose.jpg') # Use ImageMagick to build a tmp image to use
   `convert granite: #{Treasure::PUBLIC}/granite.gif` unless F.exists?(Treasure::PUBLIC+'/granite.gif') # Use ImageMagick to build a tmp image to use
@@ -96,26 +92,31 @@ describe ::StashMagic do
     F.exists?(Treasure::PUBLIC+'/stash/Treasure').should==true
   end
   
+  it 'Should keep a list of Classes that included it' do
+    StashMagic.classes.should==[Treasure, BadTreasure]
+  end
+  
   it "Should stash entries with Class::stash and have reflection" do
     Treasure.stash_reflection.keys.include?(:map).should==true
     Treasure.stash_reflection.keys.include?(:instructions).should==true
   end
   
-  it "Should give instance its own file_path" do
+  it "Should give instance its own file_root" do
     # Normal path
     @t = Treasure.create
-    @t.file_path.should=="/stash/Treasure/#{@t.id}"
+    @t.file_root.should=="/stash/Treasure/#{@t.id}"
     # Anonymous path
-    Treasure.new.file_path.should=='/stash/Treasure/tmp'
+    Treasure.new.file_root.should=='/stash/Treasure/tmp'
     # Normal path full
     @t = Treasure.create
-    @t.file_path(true).should==Treasure::PUBLIC+"/stash/Treasure/#{@t.id}"
+    @t.file_root(true).should==Treasure::PUBLIC+"/stash/Treasure/#{@t.id}"
     # Anonymous path full
-    Treasure.new.file_path(true).should==Treasure::PUBLIC+'/stash/Treasure/tmp'
+    Treasure.new.file_root(true).should==Treasure::PUBLIC+'/stash/Treasure/tmp'
   end
   
-  it "Should always raise on file_path if public_root is not declared" do
-    lambda { BadTreasure.new.file_path }.should.raise(RuntimeError).message.should=='BadTreasure.public_root is not declared'
+  it "Should warn you when you have no storage chosen" do
+    lambda { Treasure.new.zzz }.should.raise(NoMethodError).message.should.not=='You have to choose a strorage system'
+    lambda { BadTreasure.new.public_root }.should.raise(NoMethodError).message.should=='You have to choose a strorage system'
   end
   
   it "Should not raise on setters eval when value already nil" do
@@ -215,46 +216,22 @@ describe ::StashMagic do
     lambda { @t.update(:instructions=>nil) }.should.not.raise
   end
   
-  it "Should have ImageMagick string builder" do
-    @t = Treasure.create(:map=>@img)
-    
-    @t.image_magick(:map, 'test.gif') do
-      im_write("-negate")
-      im_crop(200,100,20,10)
-      im_resize(nil, 100)
-    end.should=="-negate -crop 200x100+20+10 +repage -resize 'x100'"
-    F.exists?(@t.file_url(:map,'test.gif',true)).should==true
-    
-    @t.image_magick(:map, 'test2.gif') do
-      im_write("-negate")
-      im_crop(200,100,20,10)
-      im_resize(nil, 100, '>')
-    end.should=="-negate -crop 200x100+20+10 +repage -resize 'x100>'"
-    F.exists?(@t.file_url(:map,'test2.gif',true)).should==true
-    
-    @t.image_magick(:map, 'test3.gif') do
-      im_write("-negate")
-      im_crop(200,100,20,10)
-      im_resize(200, 100, '^')
-    end.should=="-negate -crop 200x100+20+10 +repage -resize '200x100^' -gravity center -extent 200x100"
-    F.exists?(@t.file_url(:map,'test3.gif',true)).should==true
-    
-    @t.image_magick(:map, 'test4.gif') do
-      im_write("-negate")
-      im_crop(200,100,20,10)
-      im_resize(200, 100, '^', 'North')
-    end.should=="-negate -crop 200x100+20+10 +repage -resize '200x100^' -gravity North -extent 200x100"
-    F.exists?(@t.file_url(:map,'test4.gif',true)).should==true    
-  end
-  
   it "Should be possible to overwrite the original image" do
     @t = Treasure.create(:map=>@img)
-    url = @t.file_url(:map,nil,true)
+    url = @t.file_path(:map,nil,true)
     size_before = F.size(url)
     @t.convert(:map, '-resize 100x75')
     F.size(url).should.not==size_before
   end
   
+  it "Should be able to re-run all the after_stash in one method" do
+    @t = Treasure.create(:map=>@img)
+    url = @t.file_path(:map,'stash_thumb.gif',true)
+    time_before = F.mtime(url)
+    StashMagic.all_after_stash
+    F.mtime(url).should.not==time_before
+  end
+  
   ::FileUtils.rm_rf(Treasure::PUBLIC) if F.exists?(Treasure::PUBLIC)
   
 end

data/test/spec_s3.rb

@@ -0,0 +1,258 @@
+F = ::File
+D = ::Dir
+
+require 'rubygems'
+require 'bacon'
+
+require 'sequel'
+DB = Sequel.sqlite
+
+require 'tempfile'
+
+$:.unshift(F.dirname(__FILE__)+'/../lib')
+require 'stash_magic'
+
+# S3 credentials
+pseudo_env = File.join(F.dirname(__FILE__), '..', 'private', 'pseudo_env.rb')
+load(pseudo_env) if File.exists?(pseudo_env)
+AWS::S3::Base.establish_connection!(
+  :access_key_id     => ENV['S3_KEY'],
+  :secret_access_key => ENV['S3_SECRET']
+)
+AWS::S3::Bucket.delete('campbellhay-stashmagictest', :force=>true)
+AWS::S3::Bucket.create('campbellhay-stashmagictest')
+
+class Treasure < ::Sequel::Model
+  BUCKET = 'campbellhay-stashmagictest'
+  ::StashMagic.with_bucket(BUCKET)
+  
+  plugin :schema
+  set_schema do
+    primary_key :id
+    Integer :age
+    String :map # jpeg
+    String :map_tooltip
+    String :map_alternative_text
+    String :mappy # jpeg - Used to see if mappy files are not destroyed when map is (because it starts the same)
+    String :instructions #pdf
+  end
+  create_table unless table_exists?
+  
+  stash :map
+  stash :mappy
+  stash :instructions, :s3_store_options=>{:access=>:private}
+  
+  def validate
+    errors[:age] << "Not old enough" unless (self.age.nil? || self.age>10)
+    errors[:instructions] << "Too big" if (!self.instructions.nil? && self.instructions[:size].to_i>46000)
+  end
+end
+
+class BadTreasure < ::Sequel::Model
+  include ::StashMagic
+  
+  plugin :schema
+  set_schema do
+    primary_key :id
+    String :map # jpeg
+    String :instructions #pdf
+  end
+  create_table unless table_exists?
+end
+
+# Make temporary public folder
+PUBLIC = F.expand_path(F.dirname(__FILE__)+'/public')
+D.mkdir(PUBLIC) unless F.exists?(PUBLIC)
+
+# =========
+# = Tests =
+# =========
+
+describe 'StashMagic S3' do
+  
+  `convert rose: #{PUBLIC}/rose.jpg` unless F.exists?(PUBLIC+'/rose.jpg') # Use ImageMagick to build a tmp image to use
+  `convert granite: #{PUBLIC}/granite.gif` unless F.exists?(PUBLIC+'/granite.gif') # Use ImageMagick to build a tmp image to use
+  `convert rose: #{PUBLIC}/rose.pdf` unless F.exists?(PUBLIC+'/rose.pdf') # Use ImageMagick to build a tmp image to use
+  `convert logo: #{PUBLIC}/logo.pdf` unless F.exists?(PUBLIC+'/logo.pdf')
+  
+  def mock_upload(uploaded_file_path, content_type, binary=false)
+    n = F.basename(uploaded_file_path)
+    f = ::Tempfile.new(n)
+    f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
+    f.binmode if binary
+    ::FileUtils.copy_file(uploaded_file_path, f.path)
+    {
+      :filename => n, 
+      :type => content_type,
+      :tempfile => f
+    }
+  end
+  
+  before do
+    @img = mock_upload(PUBLIC+'/rose.jpg', 'image/jpeg', true)
+    @img2 = mock_upload(PUBLIC+'/granite.gif', 'image/gif', true)
+    @pdf = mock_upload(PUBLIC+'/rose.pdf', 'application/pdf', true)
+    @pdf2 = mock_upload(PUBLIC+'/logo.pdf', 'application/pdf', true)
+  end
+  
+  it 'Should build S3 store options correctly' do
+    @t = Treasure.new
+    @t.s3_store_options(:map).should=={:access=>:public_read}
+    @t.s3_store_options(:instructions).should=={:access=>:private}
+  end
+  
+  it 'Should Include via Stash::with_bucket' do
+    Treasure.bucket.should==Treasure::BUCKET
+  end
+
+  it "Should stash entries with Class::stash and have reflection" do
+    Treasure.stash_reflection.keys.include?(:map).should==true
+    Treasure.stash_reflection.keys.include?(:instructions).should==true
+  end
+  
+  it "Should give instance its own file_root" do
+    # Normal path
+    @t = Treasure.create
+    @t.file_root.should=="Treasure/#{@t.id}"
+    # Anonymous path
+    Treasure.new.file_root.should=='Treasure/tmp'
+  end
+  
+  it "Should warn you when you have no storage chosen" do
+    lambda { Treasure.new.zzz }.should.raise(NoMethodError).message.should.not=='You have to choose a strorage system'
+    lambda { BadTreasure.new.bucket }.should.raise(NoMethodError).message.should=='You have to choose a strorage system'
+  end
+  
+  it "Should not raise on setters eval when value already nil" do
+    Treasure.new.map.should==nil
+  end
+  
+  it "Should have correct file_path values" do
+    # Original with no file - so we are not sure about extention
+    Treasure.new.file_path(:map).should==nil
+    # Original with file but not saved
+    Treasure.new(:map=>@img).file_path(:map).should=='Treasure/tmp/map.jpg'
+    # Style with file but not saved
+    Treasure.new(:map=>@img).file_path(:map, 'thumb.jpg').should=='Treasure/tmp/map.thumb.jpg' #not the right extention
+  end
+  
+  it "Should have correct file_url values" do
+    # Original with no file - so we are not sure about extention
+    Treasure.new.file_url(:map).should==nil
+    # Original with file but not saved
+    Treasure.new(:map=>@img).file_url(:map).should=='http://s3.amazonaws.com/campbellhay-stashmagictest/Treasure/tmp/map.jpg'
+    # Same with SSL
+    Treasure.new(:map=>@img).file_url(:map, nil, true).should=='https://s3.amazonaws.com/campbellhay-stashmagictest/Treasure/tmp/map.jpg'
+    # Style with file but not saved
+    Treasure.new(:map=>@img).file_url(:map, 'thumb.jpg').should=='http://s3.amazonaws.com/campbellhay-stashmagictest/Treasure/tmp/map.thumb.jpg' #not the right extention
+  end
+  
+  it "Should save the attachments when creating entry" do
+    @t = Treasure.create(:map => @img, :instructions => @pdf)
+    @t.map.should=={:name=>'map.jpg',:type=>'image/jpeg',:size=>2074}
+    AWS::S3::S3Object.exists?(@t.file_path(:map), Treasure.bucket).should==true
+    AWS::S3::S3Object.exists?(@t.file_path(:instructions), Treasure.bucket).should==true
+    AWS::S3::S3Object.exists?(@t.file_path(:map, 'stash_thumb.gif'), Treasure.bucket).should==true
+    AWS::S3::Bucket.objects(Treasure.bucket).map{|o|o.key}.member?(@t.file_path(:instructions, 'stash_thumb.gif')).should==false # https://github.com/marcel/aws-s3/issues/43
+  end
+  
+  it "Should update attachment when updating entry" do
+    @t = Treasure.create(:map => @img).update(:map=>@img2)
+    @t.map.should=={:name=>'map.gif',:type=>'image/gif',:size=>7037}
+    AWS::S3::S3Object.exists?(@t.file_path(:map), Treasure.bucket).should==true
+    AWS::S3::S3Object.exists?(@t.file_path(:map).sub(/gif/, 'jpg'), Treasure.bucket).should==false
+    AWS::S3::S3Object.exists?(@t.file_path(:map, 'stash_thumb.gif'), Treasure.bucket).should==true
+  end
+  
+  it "Should be able to remove attachments when column is set to nil" do
+    @t = Treasure.create(:map => @img, :mappy => @img2)
+    @t.map.should=={:name=>'map.jpg',:type=>'image/jpeg',:size=>2074}
+    @t.mappy.should=={:name=>'mappy.gif',:type=>'image/gif',:size=>7037}
+    AWS::S3::S3Object.exists?(@t.file_path(:map), Treasure.bucket).should==true
+    AWS::S3::S3Object.exists?(@t.file_path(:mappy), Treasure.bucket).should==true
+    AWS::S3::S3Object.exists?(@t.file_path(:map, 'stash_thumb.gif'), Treasure.bucket).should==true
+    @t.update(:map=>nil)
+    @t.map.should==nil
+    @t.mappy.should=={:name=>'mappy.gif',:type=>'image/gif',:size=>7037}
+    # AWS::S3::S3Object.exists?(@t.file_path(:map), Treasure.bucket).should==false
+    AWS::S3::Bucket.objects(Treasure.bucket).map{|o|o.key}.member?(@t.file_path(:map)).should==false # https://github.com/marcel/aws-s3/issues/43
+    AWS::S3::S3Object.exists?(@t.file_path(:mappy), Treasure.bucket).should==true
+    AWS::S3::Bucket.objects(Treasure.bucket).map{|o|o.key}.member?(@t.file_path(:map, 'stash_thumb.gif')).should==false # https://github.com/marcel/aws-s3/issues/43
+    # F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.stash_thumb.gif').should==false
+  end
+  
+  it "Should have a function to retrieve the S3Object" do
+    t = Treasure.exclude(:map=>nil).first
+    obj = Treasure.new.s3object(:map, 'imaginary.gif')
+    obj.should==nil
+    
+    lambda{ t.s3object(:map, 'imaginary.gif') }.should.raise(AWS::S3::NoSuchKey)
+
+    obj = t.s3object(:map)
+    obj.content_type.should=='image/jpeg'
+  end
+  
+  it "Should be able to build image tags" do
+    @t = Treasure.create(:map => @img, :map_alternative_text => "Wonderful")
+    tag = @t.build_image_tag(:map)
+    tag.should.match(/^<img\s.+\s\/>$/)
+    tag.should.match(/\ssrc="http:\/\/s3.amazonaws.com\/campbellhay-stashmagictest\/Treasure\/#{@t.id}\/map.jpg"\s/)
+    tag.should.match(/\salt="Wonderful"\s/)
+    tag.should.match(/\stitle=""\s/)
+  end
+  
+  it "Should be able to build image tags and override alt and title" do
+    @t = Treasure.create(:map => @img, :map_alternative_text => "Wonderful")
+    tag = @t.build_image_tag(:map,nil,:alt => 'Amazing & Beautiful Map')
+    tag.should.match(/^<img\s.+\s\/>$/)
+    tag.should.match(/\ssrc="http:\/\/s3.amazonaws.com\/campbellhay-stashmagictest\/Treasure\/#{@t.id}\/map.jpg"\s/)
+    tag.should.match(/\salt="Amazing &amp; Beautiful Map"\s/)
+    tag.should.match(/\stitle=""\s/)
+  end
+  
+  it "Should be able to handle validations" do
+    @t = Treasure.new(:instructions => @pdf2)
+    @t.valid?.should==false
+    AWS::S3::Bucket.objects(Treasure.bucket).map{|o|o.key}.member?(@t.file_path(:instructions)).should==false # https://github.com/marcel/aws-s3/issues/43
+    @t.set(:instructions => @pdf, :age => 8)
+    @t.valid?.should==false
+    AWS::S3::Bucket.objects(Treasure.bucket).map{|o|o.key}.member?(@t.file_path(:instructions)).should==false # https://github.com/marcel/aws-s3/issues/43
+    @t.set(:age => 12)
+    @t.valid?.should==true
+    @t.save
+    AWS::S3::S3Object.exists?(@t.file_path(:instructions), Treasure.bucket).should==true
+  end
+  
+  it "Should not raise when updating the entry with blank string - which means the attachment is untouched" do
+    @t = Treasure.create(:instructions => @pdf)
+    before = @t.instructions
+    AWS::S3::S3Object.exists?(@t.file_path(:instructions), Treasure.bucket).should==true
+    @t.update(:instructions=>"")
+    @t.instructions.should==before
+    AWS::S3::S3Object.exists?(@t.file_path(:instructions), Treasure.bucket).should==true
+  end
+  
+  it "Should not raise when the setter tries to destroy files when there is nothing to destroy" do
+    lambda { @t = Treasure.create(:instructions=>nil) }.should.not.raise
+    lambda { @t.update(:instructions=>nil) }.should.not.raise
+  end
+  
+  it "Should be possible to overwrite the original image" do
+    @t = Treasure.create(:map=>@img)
+    url = @t.file_path(:map,nil)
+    size_before = AWS::S3::S3Object.find(url, Treasure.bucket).size
+    @t.convert(:map, '-resize 100x75')
+    AWS::S3::S3Object.find(url, Treasure.bucket).size.should.not==size_before
+  end
+  
+  it "Should be able to re-run all the after_stash in one method" do
+    @t = Treasure.create(:map=>@img)
+    url = @t.file_path(:map,'stash_thumb.gif')
+    time_before = AWS::S3::S3Object.find(url, Treasure.bucket).about['last-modified']
+    StashMagic.all_after_stash
+    AWS::S3::S3Object.find(url, Treasure.bucket).about['last-modified'].should.not==time_before
+  end
+  
+  ::FileUtils.rm_rf(PUBLIC) if F.exists?(PUBLIC)
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: stash-magic
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 9
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors: 
 - Mickael Riga
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-05 00:00:00 +01:00
+date: 2011-12-20 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
-description: A simple attachment system that also handles thumbnails or other styles via ImageMagick. Originaly tested on Sequel ORM but purposedly easy to plug to something else.
+description: A simple attachment system (file system or Amazon S3) that also handles thumbnails or other styles via ImageMagick. Originaly tested on Sequel ORM but purposedly easy to plug to something else.
 email: mig@mypeplum.com
 executables: []
 
@@ -31,9 +31,14 @@ files:
 - .gitignore
 - MIT_LICENCE
 - README.rdoc
-- spec.rb
+- lib/stash_magic.rb
+- lib/stash_magic/image_magick_string_builder.rb
+- lib/stash_magic/storage_filesystem.rb
+- lib/stash_magic/storage_s3.rb
 - stash_magic.gemspec
-- stash_magic.rb
+- test/spec_builder.rb
+- test/spec_filesystem.rb
+- test/spec_s3.rb
 has_rdoc: true
 homepage: http://github.com/mig-hub/stash_magic
 licenses: []
@@ -42,7 +47,7 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-- .
+- ./lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
@@ -68,5 +73,5 @@ rubygems_version: 1.4.2
 signing_key: 
 specification_version: 3
 summary: File Attachment Made Simple
-test_files: 
-- spec.rb
+test_files: []
+

data/stash_magic.rb

@@ -1,198 +0,0 @@
-require 'fileutils'
-
-# A replacement for our current attachment system
-# New requirements being:
-# - More than one attachment per model
-# - Easiest way to deal with folders (a bit like on our internal blog: the_wall)
-# - Another way to deal with convert styles so that you can interract with it after saving the images (cropping for example)
-# - Some facilities for pre-defined ImageMagick scripts
-module StashMagic
-  
-  F = ::File
-  D = ::Dir
-  FU = ::FileUtils
-  
-  def self.included(into)
-    class << into
-      attr_reader :public_root
-      attr_accessor :stash_reflection
-      # Setter
-      def public_root=(location)
-        @public_root = location
-        FU.mkdir_p(location+'/stash/'+self.name.to_s)
-      end
-      # Declare a stash entry
-      def stash(name, options={})
-        stash_reflection.store name.to_sym, options
-        # Exemple of upload hash for attachments:
-        # { :type=>"image/jpeg", 
-        #   :filename=>"default.jpeg", 
-        #   :tempfile=>#<File:/var/folders/J0/J03dF6-7GCyxMhaB17F5yk+++TI/-Tmp-/RackMultipart.12704.0>, 
-        #   :head=>"Content-Disposition: form-data; name=\"model[attachment]\"; filename=\"default.jpeg\"\r\nContent-Type: image/jpeg\r\n", 
-        #   :name=>"model[attachment]"
-        # }
-        #
-        # SETTER
-        define_method name.to_s+'='  do |upload_hash|
-          return if upload_hash=="" # File in the form is unchanged
-          
-          if upload_hash.nil?
-            destroy_files_for(name) unless self.__send__(name).nil?
-            super('')
-          else
-          
-            @tempfile_path ||= {}
-            @tempfile_path[name.to_sym] = upload_hash[:tempfile].path
-            h = {
-              :name => name.to_s + upload_hash[:filename][/\.[^.]+$/], 
-              :type => upload_hash[:type], 
-              :size => upload_hash[:tempfile].size
-            }
-            super(h.inspect)
-            
-          end
-        end
-        # GETTER
-        define_method name.to_s do |*args|
-          eval(super(*args).to_s)
-        end
-      end
-      
-    end
-    into.stash_reflection = {}
-  end
-  
-  # Sugar
-  def public_root
-    self.class.public_root
-  end
-  
-  # This method the path for images of a specific style(original by default)
-  # The argument 'full' means it returns the absolute path(used to save files)
-  # This could be a private method only used by file_url, but i keep it public just in case
-  def file_path(full=false)
-    raise "#{self.class}.public_root is not declared" if public_root.nil?
-    "#{public_root if full}/stash/#{self.class.to_s}/#{self.id || 'tmp'}"
-  end
-     
-  # Returns the url of an attachment in a specific style(original if nil)
-  # The argument 'full' means it returns the absolute path(used to save files)
-  def file_url(attachment_name, style=nil, full=false)
-    f = __send__(attachment_name)
-    return nil if f.nil?
-    fn = style.nil? ? f[:name] : "#{attachment_name}.#{style}"
-    "#{file_path(full)}/#{fn}"
-  end
-  
-  # Build the image tag with all SEO friendly info
-  # It's possible to add html attributes in a hash
-  def build_image_tag(attachment_name, style=nil, html_attributes={})
-    title_field, alt_field = (attachment_name.to_s+'_tooltip').to_sym, (attachment_name.to_s+'_alternative_text').to_sym
-    title = __send__(title_field) if columns.include?(title_field)
-    alt = __send__(alt_field) if columns.include?(alt_field)
-    html_attributes = {:src => file_url(attachment_name, style), :title => title, :alt => alt}.update(html_attributes)
-    html_attributes = html_attributes.map do |k,v|
-      %{#{k.to_s}="#{html_escape(v.to_s)}"}
-    end.join(' ')
-    
-    "<img #{html_attributes} />"
-  end
-  
-  # ===============
-  # = ImageMagick =
-  # ===============
-  # Basic
-  def convert(attachment_name, convert_steps="", style=nil)
-    system "convert \"#{file_url(attachment_name, nil, true)}\" #{convert_steps} \"#{file_url(attachment_name, style, true)}\""
-  end
-  # IM String builder
-  def image_magick(attachment_name, style=nil, &block)
-    @image_magick_strings = []
-    instance_eval &block
-    convert_string = @image_magick_strings.join(' ')
-    convert(attachment_name, convert_string, style)
-    @image_magick_strings = nil
-    convert_string
-  end
-  def im_write(s)
-    @image_magick_strings << s
-  end
-  def im_resize(width, height, geometry_option=nil, gravity=nil)
-    if width.nil? || height.nil?
-      @image_magick_strings << "-resize '#{width}x#{height}#{geometry_option}'"
-    else
-      @image_magick_strings << "-resize '#{width}x#{height}#{geometry_option}' -gravity #{gravity || 'center'} -extent #{width}x#{height}"
-    end
-  end
-  def im_crop(width, height, x, y)
-    @image_magick_strings <<  "-crop #{width}x#{height}+#{x}+#{y} +repage"
-  end
-  def im_negate
-    @image_magick_strings << '-negate'
-  end
-  # ===================
-  # = End ImageMagick =
-  # ===================
-  
-  def after_save
-    super rescue nil
-    unless (@tempfile_path.nil? || @tempfile_path.empty?)
-      stash_path = file_path(true)
-      D::mkdir(stash_path) unless F::exist?(stash_path)
-      @tempfile_path.each do |k,v|
-        url = file_url(k, nil, true)
-        destroy_files_for(k, url) # Destroy previously saved files
-        FU.move(v, url) # Save the new one
-        FU.chmod(0777, url)
-        after_stash(k)
-      end
-      # Reset in case we access two times the entry in the same session
-      # Like setting an attachment and destroying it consecutively
-      # Dummy ex:    Model.create(:img => file).update(:img => nil)
-      @tempfile_path = nil
-    end
-  end
-  
-  def after_stash(attachment_name)
-    current = self.__send__(attachment_name)
-    convert(attachment_name, "-resize '100x75^' -gravity center -extent 100x75", 'stash_thumb.gif') if !current.nil? && current[:type][/^image\//]
-  end
-  
-  def destroy_files_for(attachment_name, url=nil)
-    url ||= file_url(attachment_name, nil, true)
-    D[url.sub(/\.[^.]+$/, '.*')].each {|f| FU.rm(f) }
-  end
-  alias destroy_file_for destroy_files_for
-  
-  def after_destroy
-    super rescue nil
-    p = file_path(true)
-    FU.rm_rf(p) if F.exists?(p)
-  end
-  
-  class << self
-    # Include and declare public root in one go
-    def with_public_root(location, into=nil)
-      into ||= into_from_backtrace(caller)
-      into.__send__(:include, StashMagic)
-      into.public_root = location
-      into
-    end
-    # Trick stolen from Innate framework
-    # Allows not to pass self all the time
-    def into_from_backtrace(backtrace)
-      filename, lineno = backtrace[0].split(':', 2)
-      regexp = /^\s*class\s+(\S+)/
-      F.readlines(filename)[0..lineno.to_i].reverse.find{|ln| ln =~ regexp }
-      const_get($1)
-    end
-  end
-  
-  private
-  
-  # Stolen from ERB
-  def html_escape(s)
-    s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
-  end
-  
-end