smartthumbs 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+*.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in smartthumbs.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Alexander Pauly
+
+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.markdown

@@ -0,0 +1,63 @@
+## Smartthumbs
+
+This Gem helps you create any kind of thumbnails on-the-fly.
+
+## Features
+* define your various thumb-formats inside of your model and let smartthumbs do the rest.
+* writes created thumbs to the public directory - every thumb is only created once and only if needed
+* Works with blob-based records and filename-based records
+* can be implemented in several models
+* define which strategy should be used to resize your images
+
+## Install
+Add the Gem and then create an initializer-script in config/initializers:
+
+		Smartthumbs::Config.run do |config|
+			config[:valid_classes] = ["Image"]
+		# optional
+		  config[:assume_klass] = "Image"
+		end
+
+Smartthumbs needs to know all classes that you want to use smartthumbs with.
+Pass them as an array of strings via :valid_classes .
+
+By default smartthumbs generates urls like "/th/<klass-name>/<format>/<record-id>.<extension>". If you only have a single class you can set the default-class and prevent this class name from appering in that url. 
+
+
+## Examples
+
+### In your models
+	class Image < ActiveRecord::Base
+		smartthumbs :file => :file_path, :extension => "jpg", :formats => {
+		  "thumb" => ["800x200", :cut, :w],
+			"small" => ["100x100", :fit],
+			"tiny" => ["15x15", :fill]
+		}
+
+	  def file_path
+	    "#{Rails.root}/tmp/uploads/#{self.id}.jpg"
+	  end
+	end  
+
+
+
+	class Image < ActiveRecord::Base  
+	  smartthumbs :blob => :db_blob_column, :extension => :my_extension, :formats => {
+	   "thumb" => ["800x100", :fit, :e]
+	  }
+    
+	  def my_extension
+	    "jpg"
+	  end
+	end
+
+### In your View
+
+    <%= thumb_tag, @image, "tiny", :class => "red-border" %>
+
+will generate something like:
+
+    <img src="/th/my_image/tiny/5.jpg" class="red-border"/>
+
+
+Copyright (c) 2011 Alexander Pauly, released under the MIT license

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/controllers/thumbs_controller.rb

@@ -0,0 +1,35 @@
+class ThumbsController < ApplicationController
+  
+  require 'RMagick'
+  include Magick
+
+  def deliver_crop
+    klass, format, id = parse_params
+    
+    @obj = klass.find(id)
+    @obj.create_thumb_for(format)
+
+    send_file(@obj.thumb_path_for(format), :type => 'image/jpeg', :disposition => 'inline')
+  end
+
+private
+  def parse_params
+    parsed = params[:path].split(".")[0..-2].first.split("/")
+    
+    if parsed.length < 3 &&  Smartthumbs::Config.options[:assume_klass].present?
+      parsed.unshift(
+        Smartthumbs::Config.options[:assume_klass]
+      )
+    else
+      parsed[0] = parsed.first.gsub("-", "/").classify  
+    end
+    
+    unless Smartthumbs::Config.options[:valid_classes].include?(parsed[0])
+      raise "Bad Request"
+    else
+      parsed[0] = parsed.first.constantize
+    end
+    parsed
+  end
+  
+end

data/app/helpers/smartthumbs_helper.rb

@@ -0,0 +1,7 @@
+module SmartthumbsHelper
+  
+  def thumb_tag(record, format, opts={})
+    image_tag record.thumb_url_for(format), opts
+  end
+    
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails::Application.routes.draw do
+  match '/th/*path', :controller => "thumbs", :action => "deliver_crop"
+end

data/lib/smartthumbs/engine.rb

@@ -0,0 +1,13 @@
+require 'smartthumbs'
+require 'rails'
+require 'action_controller'
+
+#http://www.themodestrubyist.com/2010/03/05/rails-3-plugins---part-2---writing-an-engine/
+
+module Smartthumbs
+  class Engine < Rails::Engine
+    config.to_prepare do
+      ApplicationController.helper("Smartthumbs")
+    end
+  end
+end

data/lib/smartthumbs/thumbable.rb

@@ -0,0 +1,141 @@
+module Smartthumbs
+
+  module Thumbable
+    require 'RMagick'
+    include Magick
+
+    # return the rmagick instance
+    def rmagick_img
+      if self.class.st_config[:blob].present?
+        @rmagick_img ||= Magick::ImageList.new.from_blob(
+          self.send(self.class.st_config[:blob])
+        ).first
+      elsif self.class.st_config[:file].present?
+        @rmagick_img ||= Magick::ImageList.new.from_blob(
+          File.read(self.send(self.class.st_config[:file]))
+        ).first
+      else
+        raise "No thumb source defined. You have to define neither :blob or :file"
+      end
+    end
+
+    # returns all possible @formats for the current image 
+    def st_format(f)
+      self.class.st_config[:formats][f]
+    end
+    
+    # returns the file extension for the current image
+    def st_extension
+      return "jpg" unless self.class.st_config[:extension].present?
+      if self.class.st_config[:extension].is_a?(String)
+        self.class.st_config[:extension]
+      else
+        self.send(self.class.st_config[:extension])
+      end
+    end
+
+    # creates the directory for a certain @format if it doesn't exist
+    def create_directory
+      dest = File.dirname(thumb_path_for(@format))
+      FileUtils.mkdir_p(dest) unless File.exists?(dest)
+    end
+
+    # Creates the thumb for a certain @format
+    def create_thumb_for(format)
+      @format = format
+      return if st_format(@format).blank?
+      
+      create_directory
+      
+      method = st_format(@format)[1] || :cut
+      @x, @y = st_format(@format).first.split("x").map(&:to_i)
+
+      if self.respond_to?(method)
+        self.send(method) 
+      end
+      
+      rounding_error
+      rmagick_img.write(thumb_path_for(@format)) { self.quality = 80 }
+      nil
+    end
+
+    # returns the gravity for the current resizing process and
+    # provides some shrotcuts
+    def gravity
+      return Magick::CenterGravity unless (st_format(@format) || []).length >= 3
+      {
+        :new => Magick::NorthWestGravity,
+        :n =>   Magick::NorthGravity,
+        :ne =>  Magick::NorthEastGravity,
+        :w =>   Magick::WestGravity,
+        :c =>   Magick::CenterGravity,
+        :e =>   Magick::EastGravity,
+        :sw =>  Magick::SouthWestGravity,
+        :s =>   Magick::SouthGravity,
+        :se =>  Magick::SouthEastGravity
+      }[st_format(@format).last]
+    end
+
+    # Does a thumb already exist?
+    def thumb_exists_for?(format)
+      File.exists?(self.thumb_path_for(format))
+    end
+
+    # returns the cache-path for a certain image
+    def thumb_path_for(format)
+      "#{Rails.root}/public#{thumb_url_for(format)}"
+    end
+
+    # return the http url to the resized image
+    # this one has to be route from which the image is
+    # availabe - otherwise the caching benefit is gone 
+    def thumb_url_for(format)
+      if Smartthumbs::Config.options[:assume_klass] == self.class.to_s
+        "/th/#{format.to_s}/#{self.id}.#{st_extension}"
+      else
+        "/th/#{self.class.to_s.underscore.parameterize}/#{format.to_s}/#{self.id}.#{st_extension}"
+      end
+    end
+
+    # resizes the image in a manner that both edges fit the needs.
+    # usually one of the edges is smaller than the needs afterwards
+    def fit
+      if self.needs_to_be_resized?
+        rmagick_img.resize_to_fit!(@x, @y)
+      else
+        rmagick_img.resize_to_fit(@x, @y)
+      end
+    end
+
+    # the same as +fit+, except the fact that the image
+    # get's filled up with a border
+    def fill
+      fit
+      rounding_error
+      border_x = (@x - rmagick_img.columns)/2
+      border_y = (@y - rmagick_img.rows)/2
+
+      rmagick_img.border!(border_x,border_y,"white")
+    end
+
+    # resizes and cuts the image, so it that it fits exactly
+    def cut
+      rmagick_img.crop_resized!(@x, @y, gravity)
+    end
+
+    # if there's just a small difference between the needs and the result,
+    # we'll make it fit exaclty
+    def rounding_error
+      dif = (@y-rmagick_img.rows) + (@x-rmagick_img.columns)
+
+      if dif > 0 && dif < 10 then
+        rmagick_img.resize!(@x, @y)
+      end
+    end
+
+    # checks whether the image needs to be resized to fit the current @format or not
+    def needs_to_be_resized?
+      rmagick_img.rows > @y || rmagick_img.columns > @x
+    end
+  end
+end

data/lib/smartthumbs/version.rb

@@ -0,0 +1,3 @@
+module Smartthumbs
+  VERSION = "0.0.1"
+end

data/lib/smartthumbs.rb

@@ -0,0 +1,31 @@
+module Smartthumbs
+  require 'smartthumbs/engine' if defined?(Rails)
+  
+  module ActiceRecord
+    module ClassMethods
+      attr_accessor :st_config
+      def smartthumbs(opts={})
+        self.st_config = opts
+        self.send(:include, Smartthumbs::Thumbable)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end  
+  end
+  
+  class Config
+    class << self
+      attr_accessor :options
+      def run
+        self.options ||= {}
+        yield self.options
+      end
+    end
+  end
+  
+  require "smartthumbs/thumbable"
+  ::ActiveRecord::Base.send(:include, Smartthumbs::ActiceRecord)
+ 
+end

data/lib/tasks/smartthumbs.rake

@@ -0,0 +1,15 @@
+namespace :smartthumbs do
+  
+  desc "Delte all created thumbs"
+  task :delete_all do
+    `rm -rf #{Rails.root}/public/th`
+  end
+  
+  desc "delete all thumbs that are older than 1 day"
+  task :delete_old do
+    Dir["#{Rails.root}/public/th/**/**/*.jpg"].each do |f|
+      File.delete(f) if File.mtime(f) < 1.day.ago
+    end
+  end  
+  
+end

data/smartthumbs.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "smartthumbs/version"
+
+Gem::Specification.new do |s|
+  s.name        = "smartthumbs"
+  s.version     = Smartthumbs::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Alexander Pauly"]
+  s.email       = ["railsninja@gmx.net"]
+  s.homepage    = "http://rubygems.org/gems/smartthumbs"
+  s.summary     = %q{Smart on-the-fly thumbnail creation for blob or filesystem based images}
+  s.description = %q{Smartthumbs let's you define several different formats. By default, every image is available in any format. Once a thumb is requested, it will be generated on the fly and then be saved to the public directory. The next user who accesses the image will get the static image from disk.'}
+
+  s.rubyforge_project = "smartthumbs"
+
+  s.add_dependency 'rmagick'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: smartthumbs
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alexander Pauly
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-22 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Smartthumbs let's you define several different formats. By default, every image is available in any format. Once a thumb is requested, it will be generated on the fly and then be saved to the public directory. The next user who accesses the image will get the static image from disk.'
+email: 
+- railsninja@gmx.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- app/controllers/thumbs_controller.rb
+- app/helpers/smartthumbs_helper.rb
+- config/routes.rb
+- lib/smartthumbs.rb
+- lib/smartthumbs/engine.rb
+- lib/smartthumbs/thumbable.rb
+- lib/smartthumbs/version.rb
+- lib/tasks/smartthumbs.rake
+- smartthumbs.gemspec
+has_rdoc: true
+homepage: http://rubygems.org/gems/smartthumbs
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: smartthumbs
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Smart on-the-fly thumbnail creation for blob or filesystem based images
+test_files: []
+