dynamic_image 1.0.0 → 1.0.1

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,104 @@
+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/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,60 @@
+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

@@ -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,107 @@
+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/dynamic_image.rb

@@ -0,0 +1,78 @@
+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/generators/dynamic_image/USAGE

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

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