dynamic_image 0.9.9 → 1.0.0

data/README.md

@@ -1,109 +1,19 @@
 # DynamicImage
 
-DynamicImage is a Rails plugin that simplifies image uploading and processing.
-No configuration is necessary, as resizing and processing is done on demand and
-cached rather than on upload.
+> We're programmers. Programmers are, in their hearts, architects, and the
+> first thing they want to do when they get to a site is to bulldoze
+> the place flat and build something grand.
+> (...)
+> When you throw away code and start from scratch, you are throwing away all
+> that knowledge. All those collected bug fixes. Years of programming work.
+> _-Joel Spolsky_
 
-Note: This version is currently Rails 3 specific, although the final 1.0
-version will also be compatible with 2.x.
+Good riddance.
 
+DynamicImage is being rewritten.
 
-## Installation
+## License
 
-Install the gem:
+Copyright 2006-2014 Inge Jørgensen
 
-    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
-
-Let's create a model with an image:
-
-    class User
-      belongs_to_image :mugshot
-    end
-
-Uploading files is pretty straightforward, just add a <tt>file_field</tt>
-to your form and update your record as usual:
-
-    <%= form_for @user, :html => {:multipart => true} do |f| %>
-       Name:    <%= f.text_field :name %>
-       Mugshot: <%= f.file_field :mugshot %>
-       <%= submit_tag "Save" %>
-    <% end %>
-
-You can now use the <tt>dynamic_image_tag</tt> helper to show off your
-new image:
-
-    <% if @user.mugshot? %>
-       <%= dynamic_image_tag @user.profile_picture, :size => '64x64' %>
-    <% end %>
-
-
-## Filters
-
-I'm cleaning up the filters syntax, watch this space.
-
-
-## Technical
-
-The original master files are stored in the file system and identified a
-SHA-1 hash of the contents. If you're familiar with the internal workings
-of git, this should seem familiar.
-
-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:
-
- DynamicImage.page_caching = false
-
-
-## History
-
-DynamicImage was originally created in early 2006 to handle images
-for the Pages CMS. It was later extracted as a Rails Engine for Rails
-1.2 in 2007, which also marked the first public release as
-dynamic_image_engine.
-
-The API has remained more or less unchanged, but the internal workings
-have been refactored a few times over the years, most notably dropping
-the Engines dependency and transitioning from database storage to file
-system.
-
-The current version is based on an internal branch targeting Rails
-2.3, and modified to work as a Rails 3 plugin. It's not directly
-compatible with earlier versions, but upgrading shouldn't be more
-trouble than migrating the files out of the database.
-
-
-## Copyright
-
-Copyright © 2006 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.
+DynamicImage is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/dynamic_image.gemspec

@@ -5,39 +5,18 @@
 
 Gem::Specification.new do |s|
   s.name = "dynamic_image"
-  s.version = "0.9.9"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Inge J\303\270rgensen"]
-  s.date = "2014-02-11"
+  s.date = "2014-06-12"
   s.email = "inge@elektronaut.no"
   s.extra_rdoc_files = [
-    "LICENSE",
     "README.md"
   ]
   s.files = [
-    "LICENSE",
     "README.md",
-    "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"
+    "dynamic_image.gemspec"
   ]
   s.homepage = "http://github.com/elektronaut/dynamic_image"
   s.require_paths = ["lib"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dynamic_image
 version: !ruby/object:Gem::Version 
-  hash: 41
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 9
-  - 9
-  version: 0.9.9
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - "Inge J\xC3\xB8rgensen"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-02-11 00:00:00 Z
+date: 2014-06-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rmagick
@@ -56,31 +56,10 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE
 - README.md
 files: 
-- LICENSE
 - README.md
-- 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
 homepage: http://github.com/elektronaut/dynamic_image
 licenses: []
 

data/LICENSE

@@ -1,20 +0,0 @@
-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/Rakefile

@@ -1,33 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-
-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.13.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
-

data/VERSION

@@ -1 +0,0 @@
-0.9.9

data/app/controllers/images_controller.rb

@@ -1,79 +0,0 @@
-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

@@ -1,188 +0,0 @@
-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

data/config/routes.rb

@@ -1,16 +0,0 @@
-# Rails 3 routes
-Rails.application.routes.draw do
-  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/init.rb

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

data/install.rb

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

data/lib/binary_storage.rb

@@ -1,28 +0,0 @@
-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/binary_storage/active_record_extensions.rb

@@ -1,144 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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)
-      options = {
-        :hash_string => nil,
-        :data        => nil
-      }
-      if args.first.kind_of?(Hash)
-        options.merge!(args.first)
-      else
-        options[:data] = args.first
-      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/dynamic_image.rb

@@ -1,78 +0,0 @@
-require 'tempfile'
-require 'digest/sha1'
-require 'open-uri'
-
-# 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/dynamic_image/active_record_extensions.rb

@@ -1,60 +0,0 @@
-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
-          def #{association_id}?
-            (self.#{association_id} && self.#{association_id}.data?) ? true : false
-          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

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

data/lib/dynamic_image/filterset.rb

@@ -1,79 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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 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         - Crop the image to the size given. (Boolean, default: <tt>false</tt>)
-    # * :no_size_attr - Do not include width and height attributes in the image tag. (Boolean, default: false)
-    # * :filterset    - Apply the given filterset to the image
-    #
-    # ==== Examples
-    #
-    #  dynamic_image_tag(@image)                                    # Original image
-    #  dynamic_image_tag(@image, :size => "100x")                   # Will be 100px wide
-    #  dynamic_image_tag(@image, :size => "100x100")                # Will fit within 100x100
-    #  dynamic_image_tag(@image, :size => "100x100", :crop => true) # Will be cropped to 100x100
-    #
-    def dynamic_image_tag(image, options = {})
-      parsed_options = dynamic_image_options(image, options)
-      image_tag(parsed_options[:url], parsed_options[:options] ).gsub(/\?[\d]+/,'').html_safe
-    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/generators/dynamic_image/USAGE

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

data/lib/generators/dynamic_image/dynamic_image_generator.rb

@@ -1,38 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-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
-    end
-  end
-
-  def self.down
-    drop_table :images
-  end
-end

data/uninstall.rb

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