stash-magic 0.0.2

data/.gitignore

@@ -0,0 +1 @@
+pkg/*

data/MIT_LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Mickael Riga
+
+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/README.rdoc

@@ -0,0 +1,213 @@
+= 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:
+
+- Many attachments per database entry
+- ImageMagick string builder
+- after_stash hook for creating thumbnails or other styles automatically when attachment is created or updated.
+- Specs for Sequel ORM but pretty easy to adapt
+- Easy to understand (one file) module 
+
+This is still in Beta version built with simplicity in mind.
+Don't hesitate to contact me for any improvement, suggestion, or bug fixing.
+
+I've made the design choice not to build a Sequel plugin because I'd like StashMagic to work with other ORMs in the future.
+So any test or help is welcome.
+
+= How to use
+
+First you have to require the module:
+
+	require 'stash_magic'
+	
+And then inside your model class, you have to include the module and declare where your public directory is:
+
+	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:
+
+	class Treasure < ::Sequel::Model
+	  ::StashMagic.with_public_root ::File.expand_path(::File.dirname(__FILE__)+'/public')
+	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:
+
+	class Treasure < ::Sequel::Model
+	  ::StashMagic.with_public_root ::File.expand_path(::File.dirname(__FILE__)+'/public')
+		
+	  stash :map
+	  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:
+
+	class Treasure < ::Sequel::Model
+	  ::StashMagic.with_public_root ::File.expand_path(::File.dirname(__FILE__)+'/public')
+		
+	  stash :map
+	  stash :stamp, :accept_gif => false, :limit => 512000
+	end
+	
+The method Treasure.stash_reflection would return:
+
+	{ 
+	  :map => {}, 
+	  :stamp => {:accept_gif => false, :limit => 512000} 
+	}
+	
+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:
+
+	@treasure_instance.map    # { :name => 'map.pdf', :type => 'application/pdf', :size => 1024 }
+	@treasure_instance.stamp  # nil if there is no stamp yet
+	
+Please note that the file name will always be the name of the attachment with the extention of the file you've uploaded (pdf, jpg ...) 
+This makes StashMagic internals a lot easier for dealing with styles (ex: thumbnails) as we'll see later.
+	
+You can also use the setters to delete an attachment:
+
+	@treasure_instance.map = nil   # Will delete this attachment as expected
+	
+When you want to use attachment in your application, you can retrieve the file url like that:
+
+	@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:
+
+	@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
+	
+= Thumbnails and Other Styles
+
+One of the main requirements of StashMagic was to provide a way to deal quite easily with styles, and to deal with them whenever you want to, not only automaticaly when you save an attachment. The reason for that last point is because I was working at the same time on a cropping tool and realized That I needed to be able to create styles whenever I wanted without changing the way my attachment manager works.
+
+The simpliest solution I came up with was to be quite strict with names. So far, when StashMagic asks for a style, what it needs is a suffix which contains the extention you want the style to be saved to.
+
+Say for example you have an attachment called :portrait and you want a version called "mini" which is gonna be a gif. Your style should be called:
+
+	mini.gif
+	
+I just find it makes sense and saves one argument on some methods that are already verbose.
+
+Now if you really want to create styles, you need to have ImageMagick installed. ImageMagick is a very good and complete graphic library. You'll find more on the link below, but for the time being, just think of it as a Photoshop in command line:
+
+http://www.imagemagick.org
+
+Even though StashMagic provides a builder for ImageMagick scripts, I suggest you learn a little bit about them for the following reasons:
+
+- This is not much harder than learning to make things with methods and arguments
+- It makes you able to use it on it's own
+- 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:
+
+	@treasure_instance.convert :portrait, '-resize 100x75', 'mini.gif'
+	
+The middle argument is the piece of script used in the main ImageMagick command called: convert
+It is everything that happens between the source and the destination (hence its position in the list of arguments).
+
+This will create your mini version of the portrait. The url for this image will be:
+
+ @treasure_instance.file_url(:portrait, 'mini.gif')
+
+If you master ImageMagick, you can really do a lot with that. Nevertheless here is what you can use, as I have to admit that some things like geometry are not easy to get the first time. Here is the so-called string builder:
+
+	@treasure_instance.image_magick :portrait, 'mini.gif' do
+    im_resize(100, 75)
+	end
+	
+Not really much easier huh ?!?
+
+Ok so in the builder, you can use some pre-defined operations (prefixed with 'im_' standing for ImageMagick) that will occur in the order you write them. It is quite limited for the moment, but I will complete the list in time. Here is that list:
+
+== im_write( string )
+
+This is the most simple one. It is for when you know how to write a piece of the script. For example you could use:
+
+	im_write("-negate")
+
+It will negate the image at this stage.
+
+== im_crop( width, height, x, y )
+
+Self explainatory as well, it will create a crop using the values provided.
+
+== im_resize( width, height, geometry_option=nil, gravity=nil )
+
+This one is a little bit more complicated than it sounds. You can play with options a lot. 
+
+First thing to try is to give only width and height but with one of them nil. This will resize only by width or height, but keeping the original ratio.
+
+If you do the same but with both values, you have to make sure that the ratio is the same as the original. Otherwise the resulting image will be streched to fit in the proportions you provided.
+
+To solve the above problem, you can use the geometry_option. For example, the geometry option: '^' will more or less crop your image so that it keeps its original ratio while fitting perfectly the proportions you provided. In the future, I will find symbols to use instead of their cryptic names I guess. This is the most useful one (while not available on old versions of ImageMagick < 6.3.8-2). You can also use '>' and '<' which will only proceed if the original image is bigger (or smaller for '<') than the proportions you provided.
+
+For more info on geometry, read this:
+
+http://www.imagemagick.org/script/command-line-processing.php#geometry
+
+The last argument is useful when you use '^' as a third argument for example. If the image as to be cropped, we need to know how to crop it. This is the gravity. By default the gravity is 'center', but you might want to use 'north', 'south' ...
+
+More about gravity here:
+
+http://www.imagemagick.org/script/command-line-options.php#gravity
+
+== im_negate
+
+Simply negate the image
+
+= More about the builder
+
+Here a more complete example for the builder:
+
+	@treasure_instance.image_magick :portrait, 'mini.gif' do
+	  im_negate
+    im_crop(200,100,20,10)
+    im_resize(200, 100, '^', 'North')
+	end
+	
+Which will secretly do something like:
+
+	convert /path/to/portrait.jpg -negate -crop 200x100+20+10 +repage -resize '200x100^' -gravity North -extent 200x100 /path/to/portrait.mini.gif
+	
+= 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'.
+
+What you have to do is overwrite the hook. For example, say you want every attachment to have a 200x200 perfect squared version:
+
+	after_stash(attachment_name)
+	  image_magick(attachment_name, 'square.jpg') { im_resize(200, 200, '^') }
+	end
+	
+Of course you can do something different for any attachment. You just need to use the attachment name in a case statement for example. Or you can do something different depending on the type of file using the getters. For example:
+
+	after_stash(attachment_name)
+	  attachment_hash = self.send(attachment_name)
+	  image_magick(attachment_name, 'square.jpg') { im_resize(200, 200, '^') } if attachment_hash[:type][/^image\//]
+	end
+	
+Will do the same but only if the mime type of the file starts with 'image/' (which means it's an image).
+
+
+= 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
+- ImageMagick 6.5.8
+
+= Change Log
+
+- 0.0.1   Begins
+- 0.0.2   Add im_negate to the ImageMagick builder
+
+== Copyright
+
+(c) 2010 Mickael Riga - see MIT_LICENCE for details

data/spec.rb

@@ -0,0 +1,237 @@
+# =========
+# = 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'
+
+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 :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
+
+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
+D.mkdir(Treasure::PUBLIC) unless F.exists?(Treasure::PUBLIC)
+
+# =========
+# = Tests =
+# =========
+
+describe ::StashMagic 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 Include via Stash::with_public_root' do
+    Treasure.public_root.should==Treasure::PUBLIC
+  end
+  
+  it 'Should create stash and model folder when included' do
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure').should==true
+  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
+    # Normal path
+    @t = Treasure.create
+    @t.file_path.should=="/stash/Treasure/#{@t.id}"
+    # Anonymous path
+    Treasure.new.file_path.should=='/stash/Treasure/tmp'
+    # Normal path full
+    @t = Treasure.create
+    @t.file_path(true).should==Treasure::PUBLIC+"/stash/Treasure/#{@t.id}"
+    # Anonymous path full
+    Treasure.new.file_path(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'
+  end
+  
+  it "Should not raise on setters eval when value already nil" do
+    Treasure.new.map.should==nil
+  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=='/stash/Treasure/tmp/map.jpg'
+    # Style with file but not saved
+    Treasure.new(:map=>@img).file_url(:map, 'thumb.jpg').should=='/stash/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}
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.jpg').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/instructions.pdf').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.stash_thumb.gif').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/instructions.stash_thumb.gif').should==false
+  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}
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.gif').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.stash_thumb.gif').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.jpg').should==false
+  end
+  
+  it "Should destroy its folder when destroying entry" do
+    @t = Treasure.create(:map => @img)
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s).should==true
+    @t.destroy
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s).should==false
+  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}
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.jpg').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/mappy.gif').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.stash_thumb.gif').should==true
+    @t.update(:map=>nil)
+    @t.map.should==nil
+    @t.mappy.should=={:name=>'mappy.gif',:type=>'image/gif',:size=>7037}
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.jpg').should==false
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/mappy.gif').should==true
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/map.stash_thumb.gif').should==false
+  end
+  
+  it "Should be able to build image tags" do
+    @t = Treasure.create(:map => @img)
+    tag = @t.build_image_tag(:map,nil,:alt => 'Amazing Map')
+    tag.should.match(/^<img\s.+\s\/>$/)
+    tag.should.match(/\ssrc="\/stash\/Treasure\/#{@t.id}\/map.jpg"\s/)
+    tag.should.match(/\salt="Amazing 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
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/instructions.pdf').should==false
+    @t.set(:instructions => @pdf, :age => 8)
+    @t.valid?.should==false
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/instructions.pdf').should==false
+    @t.set(:age => 12)
+    @t.valid?.should==true
+    @t.save
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/instructions.pdf').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)
+    @t.instructions.should=={:type=>"application/pdf", :name=>"instructions.pdf", :size=>20956}
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/instructions.pdf').should==true
+    @t.update(:instructions=>"")
+    @t.instructions.should=={:type=>"application/pdf", :name=>"instructions.pdf", :size=>20956}
+    F.exists?(Treasure::PUBLIC+'/stash/Treasure/'+@t.id.to_s+'/instructions.pdf').should==true
+  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
+  
+  ::FileUtils.rm_rf(Treasure::PUBLIC) if F.exists?(Treasure::PUBLIC)
+  
+end

data/stash_magic.gemspec

@@ -0,0 +1,13 @@
+Gem::Specification.new do |s| 
+  s.name = 'stash-magic'
+  s.version = "0.0.2"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Simple Attachment Manager"
+  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.files = `git ls-files`.split("\n").sort
+  s.test_files = ['spec.rb']
+  s.require_path = '.'
+  s.author = "Mickael Riga"
+  s.email = "mig@mypeplum.com"
+  s.homepage = "http://github.com/mig-hub/stash_magic"
+end

data/stash_magic.rb

@@ -0,0 +1,191 @@
+require 'fileutils'
+require 'erb'
+
+# 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]"
+        # }
+        #
+        # GETTER
+        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)
+            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
+        # SETTER
+        define_method name.to_s do
+          eval(super.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 = send(attachment_name+'_tooltip') rescue nil
+    alt = send(attachment_name+'_alternative_text') rescue nil
+    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}="#{ERB::Util.h(v.to_s)}"}
+    end.join(' ')
+    
+    "<img #{html_attributes} />"
+  end
+  
+  # ===============
+  # = ImageMagick =
+  # ===============
+  # Basic
+  def convert(attachment_name, convert_steps="-resize 100x75^ -gravity center -extent 100x75", style='stash_thumb.gif')
+    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, &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 to 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) 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
+  
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: stash-magic
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Mickael Riga
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-18 00:00:00 +01: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.
+email: mig@mypeplum.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- MIT_LICENCE
+- README.rdoc
+- spec.rb
+- stash_magic.gemspec
+- stash_magic.rb
+has_rdoc: true
+homepage: http://github.com/mig-hub/stash_magic
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple Attachment Manager
+test_files: 
+- spec.rb