dynamic_image 0.9.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2010 Inge Jørgensen
+
+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,59 @@
+= DynamicImage
+
+DynamicImage is a Rails plugin providing transparent uploading 
+and processing of image files.
+
+Images are processed and cached on demand without need for any 
+configuration.
+
+
+== Installation:
+
+Install the gem:
+
+ gem install dynamic_image
+
+Add the gem to your Gemfile:
+
+ gem 'dynamic_image'
+
+Do the migrations:
+
+ rails generate dynamic_image migrations
+ rake db:migrate
+
+
+== Getting started:
+
+Use belongs_to_image in your models:
+
+ class User
+   belongs_to_image :profile_picture
+ end
+
+Create a form:
+
+ <%= form_for @user, :html => {:multipart => true} do |f| %>
+   Name: <%= f.text_field :name %>
+   Profile picture: <%= f.file_field :profile_picture %>
+   <%= submit_tag "Save" %>
+ <% end %>
+
+Use the dynamic_image_tag helper to show images:
+
+ <%= dynamic_image_tag @user.profile_picture, :size => '64x64' %>
+ <%= dynamic_image_tag @user.profile_picture, :size => '150x' %>
+
+
+== Caching
+
+Processing images on the fly is expensive. Therefore, page caching is enabled
+by default, even in development mode. To disable page caching, add the following
+line in your initializers or environment.rb:
+
+ DynamicImage.page_caching = false
+
+== Copyright
+
+Copyright © 2006-2010 Inge Jørgensen. See LICENSE for details.
+	

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require "rake"
+
+begin
+	require "jeweler"
+	Jeweler::Tasks.new do |gem|
+		gem.name     = "dynamic_image"
+		gem.summary  = "DynamicImage is a rails plugin providing transparent uploading and processing of image files."
+		gem.email    = "inge@elektronaut.no"
+		gem.homepage = "http://github.com/elektronaut/dynamic_image"
+		gem.authors  = ["Inge Jørgensen"]
+		gem.files    = Dir["*", "{lib}/**/*", "{app}/**/*", "{config}/**/*"]
+		gem.add_dependency("rmagick", "~> 2.12.2")
+		gem.add_dependency("vector2d", "~> 1.0.0")
+	end
+	Jeweler::GemcutterTasks.new
+rescue LoadError
+	puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the dynamic_image plugin.'
+Rake::TestTask.new(:test) do |t|
+	t.libs << 'lib'
+	t.libs << 'test'
+	t.pattern = 'test/**/*_test.rb'
+	t.verbose = true
+end
+
+desc 'Generate documentation for the dynamic_image plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+	rdoc.rdoc_dir = 'rdoc'
+	rdoc.title    = 'DynamicImage'
+	rdoc.options << '--line-numbers' << '--inline-source'
+	rdoc.rdoc_files.include('README')
+	rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.9.0

data/app/controllers/images_controller.rb

@@ -0,0 +1,79 @@
+class ImagesController < ActionController::Base
+
+	after_filter :cache_dynamic_image
+	after_filter :run_garbage_collection_for_dynamic_image_controller
+
+	unloadable
+
+	public
+
+		# Return the requested image. Rescale, filter and cache it where appropriate.
+		def render_dynamic_image
+
+			render_missing_image and return unless Image.exists?(params[:id])
+			image = Image.find(params[:id])
+
+			minTime = Time.rfc2822(request.env["HTTP_IF_MODIFIED_SINCE"]) rescue nil
+			if minTime && image.created_at? && image.created_at <= minTime
+				render :text => '304 Not Modified', :status => 304
+				return
+			end
+
+			unless image.data?
+				logger.warn "Image #{image.id} exists, but has no data"
+				render_missing_image and return
+			end
+
+			if size = params[:size]
+			    if size =~ /^x[\d]+$/ || size =~ /^[\d]+x$/
+					if params[:original]
+						image.cropped = false
+					end
+			        size = Vector2d.new(size)
+				    image_size = Vector2d.new(image.size)
+				    size = image_size.constrain_both(size).round.to_s
+				end
+	    		imagedata = image.get_processed(size, params[:filterset])
+		    else
+	    		imagedata = image
+	        end
+
+			DynamicImage.dirty_memory = true # Flag memory for GC
+
+			if image
+				response.headers['Cache-Control'] = nil
+				response.headers['Last-Modified'] = imagedata.created_at.httpdate if imagedata.created_at?
+				send_data( 
+					imagedata.data, 
+					:filename    => image.filename, 
+					:type        => image.content_type, 
+					:disposition => 'inline'
+				)
+			end
+
+		end
+		
+	protected
+
+		def render_missing_image
+			if self.respond_to?(:render_error)
+				render_error 404
+			else
+				render :status => 404, :text => "404: Image not found"
+			end
+		end
+
+		# Enforce caching of dynamic images, even if caching is turned off
+		def cache_dynamic_image
+			cache_setting = ActionController::Base.perform_caching
+			ActionController::Base.perform_caching = true
+			cache_page
+			ActionController::Base.perform_caching = cache_setting
+		end
+
+		# Perform garbage collection if necessary
+		def run_garbage_collection_for_dynamic_image_controller
+			DynamicImage.clean_dirty_memory
+		end
+		
+end

data/app/models/image.rb

@@ -0,0 +1,183 @@
+class Image < ActiveRecord::Base
+	unloadable
+
+	binary_storage :data, :sha1_hash
+
+	validates_format_of :content_type, 
+	                    :with => /^image/,
+		                :message => "you can only upload pictures"
+
+	attr_accessor :filterset, :data_checked, :skip_maxsize
+
+	# Sanitize the filename and set the name to the filename if omitted
+	validate do |image|
+		image.name     = File.basename(image.filename, ".*") if !image.name || image.name.strip == ""
+		image.filename = image.friendly_file_name(image.filename)
+		if image.cropped?
+			image.errors.add(:crop_start, "must be a vector") unless image.crop_start =~ /^[\d]+x[\d]+$/
+			image.errors.add(:crop_size,  "must be a vector") unless image.crop_size  =~ /^[\d]+x[\d]+$/
+		else
+			image.crop_size  = image.original_size
+			image.crop_start = "0x0"
+		end
+	end
+
+	# Create the binary from an image file.
+	def imagefile=(image_file)
+		self.filename     = image_file.original_filename rescue File.basename( image_file.path )
+		self.content_type = image_file.content_type.chomp rescue "image/"+image_file.path.split(/\./).last.downcase.gsub(/jpg/,"jpeg") # ugly hack
+		set_image_data(image_file.read)
+	end
+
+	# Return the image hotspot
+	def hotspot
+		(self.hotspot?) ? self.hotspot : (Vector2d.new(self.size) * 0.5).round.to_s
+	end
+
+	# Check the image data
+	def set_image_data(data)
+		self.data = data
+		if self.data?
+			image     = Magick::ImageList.new.from_blob(self.data)
+			size      = Vector2d.new(image.columns, image.rows)
+			if DynamicImage.crash_size
+				crashsize = Vector2d.new(DynamicImage.crash_size)
+				if (size.x > crashsize.x || size.y > crashsize.y)
+					raise "Image too large!"
+				end
+			end
+			if DynamicImage.max_size && !self.skip_maxsize
+				maxsize = Vector2d.new(DynamicImage.max_size)
+				if (size.x > maxsize.x || size.y > maxsize.y)
+					size = size.constrain_both(maxsize).round
+					image.resize!(size.x, size.y)
+					self.data = image.to_blob
+				end
+			end
+			# Convert image to a proper format
+			unless image.format =~ /(JPEG|PNG|GIF)/
+				self.data = image.to_blob{self.format = 'JPEG'; self.quality = 90}
+				self.filename += ".jpg"
+				self.content_type = "image/jpeg"
+			end
+			self.original_size = size.round.to_s
+		end
+	end
+
+	# Returns the image width
+	def original_width
+		Vector2d.new(self.original_size).x.to_i
+	end
+
+	# Returns the image height
+	def original_height
+		Vector2d.new(self.original_size).y.to_i
+	end
+
+	def crop_start_x
+		Vector2d.new(self.crop_start).x.to_i
+	end
+	def crop_start_y
+		Vector2d.new(self.crop_start).y.to_i
+	end
+	def crop_width
+		Vector2d.new(self.crop_size).x.to_i
+	end
+	def crop_height
+		Vector2d.new(self.crop_size).y.to_i
+	end
+
+	# Returns original or cropped size
+	def size
+		(self.cropped?) ? self.crop_size : self.original_size
+	end
+
+	def size=(new_size)
+		self.original_size = new_size
+	end
+
+	# Convert file name to a more file system friendly one.
+	# TODO: international chars
+	def friendly_file_name( file_name )
+		[["æ","ae"], ["ø","oe"], ["å","aa"]].each do |int|
+			file_name = file_name.gsub(int[0], int[1])
+		end
+		File.basename(file_name).gsub(/[^\w\d\.-]/, "_")
+	end
+
+	# Get the base part of a filename
+	def base_part_of(file_name)
+		name = File.basename(file_name)
+		name.gsub(/[ˆ\w._-]/, '')
+	end
+
+	# Rescale and crop the image, and return it as a blob.
+	def rescaled_and_cropped_data(*args)
+		DynamicImage.dirty_memory = true                                                       # Flag to perform GC
+		image_data = Magick::ImageList.new.from_blob(self.data)
+
+		if self.cropped?
+			cropped_start = Vector2d.new(self.crop_start).round
+			cropped_size  = Vector2d.new(self.crop_size).round
+			image_data = image_data.crop(cropped_start.x, cropped_start.y, cropped_size.x, cropped_size.y, true)
+		end
+
+		size         = Vector2d.new(self.size)
+		rescale_size = size.dup.constrain_one(args).round                                      # Rescale dimensions
+		crop_to_size = Vector2d.new(args).round                                                # Crop size
+		new_hotspot  = Vector2d.new(hotspot) * (rescale_size / size)                           # Recalculated hotspot
+		rect = [(new_hotspot-(crop_to_size/2)).round, (new_hotspot+(crop_to_size/2)).round]    # Array containing crop coords
+
+		# Adjustments
+		x = rect[0].x; rect.each{|r| r.x += (x.abs)}            if x < 0
+		y = rect[0].y; rect.each{|r| r.y += (y.abs)}            if y < 0
+		x = rect[1].x; rect.each{|r| r.x -= (x-rescale_size.x)} if x > rescale_size.x
+		y = rect[1].y; rect.each{|r| r.y -= (y-rescale_size.y)} if y > rescale_size.y
+
+		rect[0].round!
+		rect[1].round!
+
+		image_data = image_data.resize(rescale_size.x, rescale_size.y)
+		image_data = image_data.crop(rect[0].x, rect[0].y, crop_to_size.x, crop_to_size.y)
+		image_data.to_blob{self.quality = 90}
+	end
+
+	def constrain_size(*max_size)
+		Vector2d.new(self.size).constrain_both(max_size.flatten).round.to_s
+	end
+
+	# Get a duplicate image with resizing and filters applied.
+	def get_processed(size, filterset=nil)
+		size                      = Vector2d.new(size).round.to_s
+		processed_image           = Image.new
+		processed_image.filterset = filterset || 'default'
+		processed_image.data      = self.rescaled_and_cropped_data(size)
+		processed_image.size      = size
+		processed_image.apply_filters
+		processed_image
+	end
+
+	# Apply filters to image data
+	def apply_filters
+		filterset_name = self.filterset || 'default'
+		filterset = DynamicImage::Filterset[filterset_name]
+		if filterset
+			DynamicImage.dirty_memory = true # Flag for GC
+			data = Magick::ImageList.new.from_blob(self.data)
+			data = filterset.process(data)
+			self.data = data.to_blob
+		end
+	end
+
+	# Decorates to_json with additional attributes
+	def to_json
+		attributes.merge({
+			:original_width  => self.original_width, 
+			:original_height => self.original_height,
+			:crop_width      => self.crop_width,
+			:crop_height     => self.crop_height,
+			:crop_start_x    => self.crop_start_x,
+			:crop_start_y    => self.crop_start_y
+		}).to_json
+	end
+end

data/config/routes.rb

@@ -0,0 +1,16 @@
+# Rails 3 routes
+Rails.application.routes.draw do |map|
+	match "dynamic_images/:id/:original(/:size(/:filterset))/*filename" => "images#render_dynamic_image", :size => /\d*x\d*/, :original => /original/
+	match "dynamic_images/:id(/:size(/:filterset))/*filename" => "images#render_dynamic_image", :size => /\d*x\d*/
+	# Legacy
+	match "dynamic_image/:id/:original(/:size(/:filterset))/*filename" => "images#render_dynamic_image", :size => /\d*x\d*/, :original => /original/
+	match "dynamic_image/:id(/:size(/:filterset))/*filename" => "images#render_dynamic_image", :size => /\d*x\d*/
+end
+
+# Rails 2 routes
+#@set.add_route('dynamic_image/:id/:original/:size/:filterset/*filename', {:controller => 'images', :action => 'render_dynamic_image', :requirements => { :size => /[\d]*x[\d]*/, :original => /original/ }})
+#@set.add_route('dynamic_image/:id/:original/:size/*filename', {:controller => 'images', :action => 'render_dynamic_image', :requirements => { :size => /[\d]*x[\d]*/, :original => /original/ }})
+#@set.add_route('dynamic_image/:id/:original/*filename', {:controller => 'images', :action => 'render_dynamic_image', :requirements => { :original => /original/ }})
+#@set.add_route('dynamic_image/:id/:size/:filterset/*filename', {:controller => 'images', :action => 'render_dynamic_image', :requirements => { :size => /[\d]*x[\d]*/ }})
+#@set.add_route('dynamic_image/:id/:size/*filename', {:controller => 'images', :action => 'render_dynamic_image', :requirements => { :size => /[\d]*x[\d]*/ }})
+#@set.add_route('dynamic_image/:id/*filename', {:controller => 'images', :action => 'render_dynamic_image'})

data/dynamic_image.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dynamic_image}
+  s.version = "0.9.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Inge J\303\270rgensen"]
+  s.date = %q{2010-05-19}
+  s.email = %q{inge@elektronaut.no}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "app/controllers/images_controller.rb",
+     "app/models/image.rb",
+     "config/routes.rb",
+     "dynamic_image.gemspec",
+     "init.rb",
+     "install.rb",
+     "lib/binary_storage.rb",
+     "lib/binary_storage/active_record_extensions.rb",
+     "lib/binary_storage/blob.rb",
+     "lib/dynamic_image.rb",
+     "lib/dynamic_image/active_record_extensions.rb",
+     "lib/dynamic_image/engine.rb",
+     "lib/dynamic_image/filterset.rb",
+     "lib/dynamic_image/helper.rb",
+     "lib/generators/dynamic_image/USAGE",
+     "lib/generators/dynamic_image/dynamic_image_generator.rb",
+     "lib/generators/dynamic_image/templates/migrations/create_images.rb",
+     "uninstall.rb"
+  ]
+  s.homepage = %q{http://github.com/elektronaut/dynamic_image}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{DynamicImage is a rails plugin providing transparent uploading and processing of image files.}
+  s.test_files = [
+    "test/dynamic_image_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rmagick>, ["~> 2.12.2"])
+      s.add_runtime_dependency(%q<vector2d>, ["~> 1.0.0"])
+    else
+      s.add_dependency(%q<rmagick>, ["~> 2.12.2"])
+      s.add_dependency(%q<vector2d>, ["~> 1.0.0"])
+    end
+  else
+    s.add_dependency(%q<rmagick>, ["~> 2.12.2"])
+    s.add_dependency(%q<vector2d>, ["~> 1.0.0"])
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+require 'dynamic_image'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/binary_storage/active_record_extensions.rb

@@ -0,0 +1,144 @@
+require 'binary_storage'
+
+module BinaryStorage
+	module ActiveRecordExtensions
+
+		def self.included(base)
+			base.send(:extend, BinaryStorage::ActiveRecordExtensions::ClassMethods)
+		end
+		
+		module ClassMethods
+			
+			def register_binary(klass, binary_name, binary_column)
+				@@binary_columns ||= {}
+				@@binary_columns[klass] ||= {}
+				@@binary_columns[klass][binary_name] = binary_column
+			end
+			
+			def binary_column(klass, binary_name)
+				if @@binary_columns && @@binary_columns[klass] && @@binary_columns[klass][binary_name]
+					@@binary_columns[klass][binary_name]
+				else
+					nil
+				end
+			end
+			
+			# Count existing references to a binary
+			def binary_reference_count(hash_string)
+				references = 0
+				if @@binary_columns
+					@@binary_columns.each do |klass, binaries|
+						binaries.each do |binary_name, binary_column|
+							references += klass.count(:all, :conditions => ["`#{binary_column} = ?`", hash_string])
+						end
+					end
+				end
+			end
+			
+			def binary_storage(binary_name, binary_column)
+				binary_name   = binary_name.to_s
+				binary_column = binary_column.to_s
+
+				register_binary(self, binary_name, binary_column)
+
+				class_eval <<-end_eval
+					before_save do |binary_model|
+						binary_model.save_binary("#{binary_name}")
+					end
+					
+					after_destroy do |model|
+						binary_model.destroy_binary("#{binary_name}")
+					end
+
+					def #{binary_name}
+						self.get_binary_data("#{binary_name}")
+					end
+
+					def #{binary_name}=(binary_data)
+						self.set_binary_data("#{binary_name}", binary_data)
+					end
+
+					def #{binary_name}?
+						self.has_binary_data?("#{binary_name}")
+					end
+				end_eval
+
+				send(:include, BinaryStorage::ActiveRecordExtensions::InstanceMethods)
+			end
+		end
+		
+		module InstanceMethods
+			
+			def binaries
+				@binaries ||= {}
+			end
+
+			def binary_column(binary_name)
+				if column_name = self.class.binary_column(self.class, binary_name) 
+					column_name
+				else 
+					raise "Binary column #{binary_name} not defined!"
+				end
+			end
+			
+			def binary_hash_string(binary_name)
+				self.attributes[binary_column(binary_name)]
+			end
+
+			def save_binary(binary_name)
+				if binaries.has_key?(binary_name)
+					if binary = binaries[binary_name]
+						binary.save
+						self.attributes = self.attributes.merge({binary_column(binary_name).to_sym => binary.hash_string})
+					else
+						self.attributes = self.attributes.merge({binary_column(binary_name).to_sym => nil})
+					end
+				end
+			end
+
+			def destroy_binary(binary_name)
+				if binary = binaries[binary_name]
+					if hash_string = binary.hash_string
+						references = self.class.binary_reference_count
+						if references < 1
+							binary.delete!
+						end
+					end
+				end
+			end
+			
+			def get_binary_data(binary_name)
+				# Set directly?
+				if binary = binaries[binary_name]
+					binary.data
+
+				# Try loading
+				elsif hash_string = binary_hash_string(binary_name)
+					if binary = BinaryStorage::Blob.find(hash_string)
+						binaries[binary_name] = binary # Cache it
+						binary.data
+					else
+						nil
+					end
+				end
+			end
+			
+			def set_binary_data(binary_name, binary_data)
+				binary = (binary_data) ? BinaryStorage::Blob.new(binary_data) : nil
+				binaries[binary_name] = binary
+			end
+			
+			def has_binary_data?(binary_name)
+				if binaries[binary_name]
+					true
+				else
+					hash_string = binary_hash_string(binary_name)
+					(hash_string && BinaryStorage::Blob.exists?(hash_string)) ? true : false
+				end
+			end
+		end
+
+	end
+end
+
+ActiveRecord::Base.send(:include, BinaryStorage::ActiveRecordExtensions)

data/lib/binary_storage/blob.rb

@@ -0,0 +1,105 @@
+module BinaryStorage
+	class Blob
+		
+		class << self
+			def find(hash_string)
+				blob = self.new(:hash_string => hash_string)
+				return nil unless blob.exists?
+				blob.load
+				blob
+			end
+
+			def exists?(hash_string)
+				self.new(:hash_string => hash_string).exists?
+			end
+
+			def create(data)
+				blob = self.new(data)
+				blob.save
+				blob
+			end
+			
+			def storage_dir(hash_string=nil)
+				root = BinaryStorage.storage_dir
+				(hash_string) ? File.join(root, hash_string.match(/^(..)/)[1]) : root
+			end
+			
+			def storage_path(hash_string)
+				File.join(storage_dir(hash_string), hash_string.gsub(/^(..)/, ''))
+			end
+		end
+		
+		def initialize(*args)
+			args = *args
+			options = {
+				:hash_string => nil,
+				:data        => nil
+			}
+			if args.kind_of?(Hash)
+				options.merge!(args)
+			else
+				options[:data] = args
+			end
+			@hash_string = options[:hash_string]
+			@data        = options[:data]
+		end
+		
+		def data
+			@data
+		end
+		
+		def data=(new_data)
+			@hash_string = nil
+			@data        = new_data
+		end
+		
+		def hash_string
+			unless @hash_string
+				if @data
+					@hash_string = BinaryStorage.hexdigest(data)
+				else
+					raise "Binary has no data!" 
+				end
+			end
+			@hash_string
+		end
+		
+		def storage_dir
+			BinaryStorage::Blob.storage_dir(hash_string)
+		end
+
+		def storage_path
+			BinaryStorage::Blob.storage_path(hash_string)
+		end
+		
+		def exists?
+			File.exists?(storage_path)
+		end
+		
+		def empty?
+			(hash_string && !exists?) || !data || data.empty?
+		end
+		
+		def load
+			raise "File not found" unless exists?
+			@data = File.open(storage_path, "rb") {|io| io.read }
+		end
+		
+		def delete
+			if exists?
+				FileUtils.rm(storage_path)
+			end
+		end
+
+		def save
+			unless exists?
+				FileUtils.mkdir_p(storage_dir)
+				file = File.new(storage_path, 'wb')
+				file.write(@data)
+				file.close
+			end
+			return true
+		end
+		
+	end
+end

data/lib/binary_storage.rb

@@ -0,0 +1,28 @@
+require 'tempfile'
+require 'digest/sha1'
+
+require 'rails'
+require 'active_record'
+
+require File.join(File.dirname(__FILE__), 'binary_storage/active_record_extensions')
+require File.join(File.dirname(__FILE__), 'binary_storage/blob')
+
+module BinaryStorage
+	class << self
+		def storage_dir
+			@@storage_dir ||= Rails.root.join('db/binary_storage', Rails.env)
+		end
+		
+		def storage_dir=(new_storage_dir)
+			@@storage_dir = new_storage_dir
+		end
+		
+		def hexdigest_file(path)
+			Digest::SHA1.file(path).hexdigest
+		end
+
+		def hexdigest(string)
+			Digest::SHA1.hexdigest(string)
+		end
+	end
+end

data/lib/dynamic_image/active_record_extensions.rb

@@ -0,0 +1,57 @@
+require 'dynamic_image'
+
+module DynamicImage
+	module ActiveRecordExtensions
+
+		def self.included(base)
+			base.send :extend, ClassMethods
+		end
+
+		module ClassMethods
+			# By using <tt>belongs_to_image</tt> over <tt>belongs_to</tt>, you gain the ability to
+			# set the image directly from an uploaded file. This works exactly like <tt>belongs_to</tt>,
+			# except the class name will default to 'Image' - not the name of the association.
+			# 
+			# Example:
+			#
+			#   # Model code
+			#   class Person < ActiveRecord::Base
+			#     belongs_to_image :mugshot
+			#   end
+			#
+			#   # View code
+			#   <% form_for 'person', @person, :html => {:multipart => true} do |f| %>
+			#     <%= f.file_field :mugshot %>
+			#   <% end %>
+			#
+			def belongs_to_image(association_id, options={})
+				options[:class_name] ||= 'Image'
+				options[:foreign_key] ||= options[:class_name].downcase+'_id'
+				belongs_to association_id, options
+
+				# Overwrite the setter method
+				class_eval <<-end_eval
+					alias_method :associated_#{association_id}=, :#{association_id}=
+					def #{association_id}=(img_obj)
+						# Convert a Tempfile to a proper Image
+						unless img_obj.kind_of?(ActiveRecord::Base)
+							DynamicImage.dirty_memory = true # Flag for GC
+							img_obj = Image.create(:imagefile => img_obj)
+						end
+						# Quietly skip blank strings
+						unless img_obj.kind_of?(String) && img_obj.blank?
+							self.associated_#{association_id} = img_obj
+						end
+					end
+				end_eval
+
+				send :include, DynamicImage::ActiveRecordExtensions::InstanceMethods
+			end 
+		end
+
+		module InstanceMethods
+		end
+	end
+end
+
+ActiveRecord::Base.send(:include, DynamicImage::ActiveRecordExtensions)

data/lib/dynamic_image/engine.rb

@@ -0,0 +1,6 @@
+require 'dynamic_image'
+
+module DynamicImage
+	class Engine < Rails::Engine
+	end
+end

data/lib/dynamic_image/filterset.rb

@@ -0,0 +1,79 @@
+require 'dynamic_image'
+
+module DynamicImage
+
+	@@filtersets = Hash.new
+	
+	# Singleton methods for the filtersets hash.
+	class << @@filtersets
+		def names; keys; end
+	end
+	
+	# Accessor for the filtersets hash. Installed filter names are available through the <tt>names</tt> method. Example:
+	#   @filter_names = DynamicImage.filtersets.names
+	def self.filtersets
+		@@filtersets
+	end
+	
+	# Base class for filter sets. Extending this with your own subclasses will automatically enable them for use.
+	# You'll need to overwrite <tt>Filterset.process</tt> in order to make your filter useful. Note that it's a class
+	# method.
+	#
+	# === Example
+	#
+	#   class BlogThumbnailsFilterset < DynamicImage::Filterset
+	#     def self.process(image)
+	#       image = image.sepiatone     # convert the image to sepia tones
+	#     end
+	#   end
+	#
+	# The filter set is now available for use in your application:
+	#
+	#   <%= dynamic_image_tag( @blog_post.image, :size => "120x100", :filterset => 'blog_thumbnails' ) %>
+	#
+	# === Applying effects by default
+	#
+	# If <tt>Image.get_oricessed</tt> is called without filters, it will look for a set named 'default'.
+	# This means that you can automatically apply effects on resized images by defining a class called <tt>DefaultFilterset</tt>:
+	#
+	#   class DefaultFilterset < DynamicImage::Filterset
+	#     def self.process(image)
+	#       image = image.unsharp_mask  # apply unsharp mask on images by default.
+	#     end
+	#   end
+	#
+	# === Chaining filters
+	#
+	# You can only apply one filterset on an image, but compound filters can easily be created:
+	#
+	#   class CompoundFilterset < DynamicImage::Filterset
+	#     def self.process(image)
+	#       image = MyFirstFilterset.process(image)
+	#       image = SomeOtherFilterset.process(image)
+	#       image = DefaultFilterset.process(image)
+	#     end
+	#   end
+	#
+	class Filterset
+		include ::Magick
+
+		# Detect inheritance and store the new filterset in the lookup table.
+		def self.inherited(sub)
+			filter_name = sub.name.gsub!( /Filterset$/, '' ).underscore
+			DynamicImage.filtersets[filter_name] = sub
+		end
+
+		# Get a Filterset class by name. Accepts a symbol or string, CamelCase and under_scores both work.
+		def self.[](filter_name)
+			filter_name = filter_name.to_s if filter_name.kind_of? Symbol
+			filter_name = filter_name.underscore
+			DynamicImage.filtersets[filter_name] || nil
+		end
+
+		# Process the image. This is a dummy method, you should overwrite it in your subclass.
+		def self.process(image)
+			# This is a stub
+		end
+		
+	end
+end

data/lib/dynamic_image/helper.rb

@@ -0,0 +1,121 @@
+require 'dynamic_image'
+
+module DynamicImage
+	module Helper
+
+		# Returns an hash consisting of the URL to the dynamic image and parsed options. This is mostly for internal use by 
+		# dynamic_image_tag and dynamic_image_url.
+		def dynamic_image_options(image, options = {})
+			options.symbolize_keys!
+
+			options     = {:crop => false}.merge(options)
+			url_options = {:controller => "/images", :action => :render_dynamic_image, :id => image}
+		
+			if options[:original]
+				url_options[:original] = 'original'
+				options.delete(:original)
+			end
+
+			# Image sizing
+			if options[:size]
+				new_size   = Vector2d.new(options[:size])
+				image_size = Vector2d.new(image.size)
+
+	            unless options[:upscale]
+				    new_size.x = image_size.x if new_size.x > 0 && new_size.x > image_size.x
+				    new_size.y = image_size.y if new_size.y > 0 && new_size.y > image_size.y
+			    end
+
+				unless options[:crop]
+					new_size = image_size.constrain_both(new_size)
+				end
+
+				options[:size] = new_size.round.to_s
+				url_options[:size] = options[:size]
+			end
+			options.delete :crop
+
+			if options[:no_size_attr]
+				options.delete :no_size_attr
+				options.delete :size
+			end
+
+			# Filterset
+			if options[:filterset]
+				url_options[:filterset] = options[:filterset]
+				options.delete :filterset
+			end
+
+			# Filename
+			if options[:filename]
+				filename = options[:filename]
+				unless filename =~ /\.[\w]{1,4}$/
+					filename += "." + image.filename.split(".").last
+				end
+				url_options[:filename] = filename
+			else
+				url_options[:filename] = image.filename
+			end
+
+			# Alt attribute
+			options[:alt] ||= image.name if image.name?
+			options[:alt] ||= image.filename.split('.').first.capitalize
+		
+			if options.has_key?(:only_path)
+				url_options[:only_path] = options[:only_path]
+				options[:only_path] = nil
+			end
+			if options.has_key?(:host)
+				url_options[:host] = options[:host]
+				options[:host] = nil
+			end
+		
+			{:url => url_for(url_options), :options => options}
+		end
+	
+		# Returns an image tag for the provided image model, works similar to the rails <tt>image_tag</tt> helper. 
+		# The <tt>alt</tt> tag is set to the image title unless explicitly provided.
+		#
+		# The following options are supported (the rest will be forwarded to <tt>image_tag</tt>):
+		#
+		#   :size         - Resize the image to fit these proportions. Size is given as a string with the format
+		#                   '100x100'. Either dimension can be omitted, for example: '100x'
+		#   :crop         - Boolean, default: false. Crop the image to the size given.
+		#   :no_size_attr - Boolean, default: false. Do not include width and height attributes in the image tag.
+		#   :filterset    - Apply the given filterset to the image
+		#
+		# == Examples
+		#
+		# Tag for original image, without rescaling:
+		#   <%= dynamic_image_tag(@image) %>
+		#
+		# Tag for image, rescaled to fit within 100x100 (size will be 100x100 or smaller):
+		#   <%= dynamic_image_tag(@image, :size => "100x100") %>
+		#
+		# Tag for image, cropped and rescaled to 100x100 (size will be 100x100 in all cases):
+		#   <%= dynamic_image_tag(@image, :size => "100x100", :crop => true) %>
+		#
+		# Tag for image with a filter set applied:
+		#   <%= dynamic_image_tag(@image, :size => "100x100", :filterset => @filterset) %>
+		#
+		# Tag for image with a named filter set applied:
+		#   <%= dynamic_image_tag(@image, :size => "100x100", :filterset => "thumbnails") %>
+		#
+		# Tag for image without the width/height attributes, and with a custom alt attribute
+		#   <%= dynamic_image_tag(@image, :size => "100x100", :no_size_attr => true, :alt => "Thumbnail for post" %>
+	
+		def dynamic_image_tag(image, options = {})
+			parsed_options = dynamic_image_options(image, options)
+			image_tag(parsed_options[:url], parsed_options[:options] ).gsub(/\?[\d]+/,'')
+		end
+	
+		# Returns an url corresponding to the provided image model.
+		# Special options are documented in ApplicationHelper.dynamic_image_tag, only <tt>:size</tt>, <tt>:filterset</tt> and <tt>:crop</tt> apply.
+		def dynamic_image_url(image, options = {})
+			parsed_options = dynamic_image_options(image, options)
+			parsed_options[:url]
+		end
+	end
+end
+
+ActionView::Base.send(:include, DynamicImage::Helper)

data/lib/dynamic_image.rb

@@ -0,0 +1,77 @@
+require 'tempfile'
+require 'digest/sha1'
+
+# Gem dependencies
+require 'rmagick'
+require 'vector2d'
+require 'rails'
+require 'action_controller'
+require 'active_support'
+require 'active_record'
+
+require 'binary_storage'
+
+if Rails::VERSION::MAJOR == 3
+	# Load the engine
+	require 'dynamic_image/engine' if defined?(Rails)
+end
+
+require 'dynamic_image/active_record_extensions'
+require 'dynamic_image/filterset'
+require 'dynamic_image/helper'
+
+module DynamicImage
+	@@dirty_memory = false
+	@@page_caching = true
+	
+	class << self
+		
+		def dirty_memory=(flag)
+			@@dirty_memory = flag
+		end
+		
+		def dirty_memory
+			@@dirty_memory
+		end
+		
+		def page_caching=(flag)
+			@@page_caching = flag
+		end
+		
+		def page_caching
+			@@page_caching
+		end
+		
+		def max_size
+			@@max_size ||= "2000x2000"
+		end
+		
+		def max_size=(new_max_size)
+			@@max_size = new_max_size
+		end
+
+		def crash_size
+			@@crash_size ||= "10000x10000"
+		end
+		
+		def crash_size=(new_crash_size)
+			@@crash_size = new_crash_size
+		end
+
+		# RMagick stores image data internally, Ruby doesn't see the used memory.
+		# This method performs garbage collection if @@dirty_memory has been flagged.
+		# More details here: http://rubyforge.org/forum/message.php?msg_id=1995
+		def clean_dirty_memory(options={})
+			options.symbolize_keys!
+			if @@dirty_memory || options[:force]
+				gc_disabled = GC.enable
+				GC.start
+				GC.disable if gc_disabled
+				@@dirty_memory = false
+				true
+			else
+				false
+			end
+		end
+	end
+end

data/lib/generators/dynamic_image/USAGE

@@ -0,0 +1,6 @@
+Description:
+    Creates the migrations
+
+Usage:
+    rails generate dynamic_image
+

data/lib/generators/dynamic_image/dynamic_image_generator.rb

@@ -0,0 +1,38 @@
+# Rails 2: class DynamicImageGenerator < Rails::Generator::NamedBase
+
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class DynamicImageGenerator < Rails::Generators::Base
+	
+	include Rails::Generators::Migration
+
+	class << self
+		def source_root
+			@source_root ||= File.join(File.dirname(__FILE__), 'templates')
+		end
+
+		def next_migration_number(dirname)
+			if ActiveRecord::Base.timestamped_migrations
+				Time.now.utc.strftime("%Y%m%d%H%M%S")
+			else
+				"%.3d" % (current_migration_number(dirname) + 1)
+			end
+		end
+
+	end
+
+	def migrations
+		migration_template 'migrations/create_images.rb', 'db/migrate/create_images.rb'
+	end
+
+	# def manifest
+	# 	record do |m|
+	# 		#m.file 'controllers/images_controller.rb', 'app/controllers/images_controller.rb'
+	# 		#m.file 'models/image.rb', 'app/models/image.rb'
+	# 		#m.file 'models/binary.rb', 'app/models/binary.rb'
+	# 		m.file 'migrations/20090909231629_create_binaries.rb', 'db/migrate/20090909231629_create_binaries.rb'
+	# 		m.file 'migrations/20090909231630_create_images.rb', 'db/migrate/20090909231630_create_images.rb'
+	# 	end
+	# end
+end

data/lib/generators/dynamic_image/templates/migrations/create_images.rb

@@ -0,0 +1,22 @@
+class CreateImages < ActiveRecord::Migration
+  def self.up
+    create_table :images do |t|
+      t.column :name,          :string
+      t.column :filename,      :string
+      t.column :content_type,  :string
+      t.column :original_size, :string
+      t.column :hotspot,       :string
+      t.column :sha1_hash,     :string
+      t.column :cropped,       :boolean, :null => false, :default => false
+      t.column :crop_start,    :string
+      t.column :crop_size,     :string
+      t.column :created_at,    :datetime
+      t.column :updated_at,    :datetime
+      t.column :filters,       :text
+    end
+  end
+
+  def self.down
+    drop_table :images
+  end
+end

data/test/dynamic_image_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class DynamicImageTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: dynamic_image
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- "Inge J\xC3\xB8rgensen"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-19 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 12
+        - 2
+        version: 2.12.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: vector2d
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+description: 
+email: inge@elektronaut.no
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- app/controllers/images_controller.rb
+- app/models/image.rb
+- config/routes.rb
+- dynamic_image.gemspec
+- init.rb
+- install.rb
+- lib/binary_storage.rb
+- lib/binary_storage/active_record_extensions.rb
+- lib/binary_storage/blob.rb
+- lib/dynamic_image.rb
+- lib/dynamic_image/active_record_extensions.rb
+- lib/dynamic_image/engine.rb
+- lib/dynamic_image/filterset.rb
+- lib/dynamic_image/helper.rb
+- lib/generators/dynamic_image/USAGE
+- lib/generators/dynamic_image/dynamic_image_generator.rb
+- lib/generators/dynamic_image/templates/migrations/create_images.rb
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/elektronaut/dynamic_image
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: DynamicImage is a rails plugin providing transparent uploading and processing of image files.
+test_files: 
+- test/dynamic_image_test.rb
+- test/test_helper.rb