dynamic_image 0.9.5 → 0.9.6

data/README.rdoc

@@ -88,7 +88,7 @@ trouble than migrating the files out of the database.
 == Copyright
 
 Copyright © 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

data/Rakefile

@@ -5,20 +5,20 @@ 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
+  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"
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
 desc 'Default: run unit tests.'
@@ -26,17 +26,17 @@ 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
+  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')
+  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

@@ -1 +1 @@
-0.9.5
+0.9.6

data/app/controllers/images_controller.rb

@@ -1,79 +1,79 @@
 class ImagesController < ActionController::Base
 
-	after_filter :cache_dynamic_image
-	after_filter :run_garbage_collection_for_dynamic_image_controller
+  after_filter :cache_dynamic_image
+  after_filter :run_garbage_collection_for_dynamic_image_controller
 
-	unloadable
+  unloadable
 
-	public
+  public
 
-		# Return the requested image. Rescale, filter and cache it where appropriate.
-		def render_dynamic_image
+    # 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])
+      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
+      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
+      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
+      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
+      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
+      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
+    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
+    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
+    # 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
+    # Perform garbage collection if necessary
+    def run_garbage_collection_for_dynamic_image_controller
+      DynamicImage.clean_dirty_memory
+    end
+    
+end

data/app/models/image.rb

@@ -1,188 +1,188 @@
 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)
-		if image_file.kind_of?(String) && image_file =~ /^(ht|f)tps?:\/\//
-			self.filename = File.basename(image_file)
-			image_file    = open(image_file)
-		else
-			self.filename = image_file.original_filename rescue File.basename(image_file.path)
-		end
-		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
+  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)
+    if image_file.kind_of?(String) && image_file =~ /^(ht|f)tps?:\/\//
+      self.filename = File.basename(image_file)
+      image_file    = open(image_file)
+    else
+      self.filename = image_file.original_filename rescue File.basename(image_file.path)
+    end
+    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