dynamic_image 1.0.0 → 1.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2010 Inge Jørgensen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,19 +1,109 @@
 # DynamicImage
 
-> 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_
+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.
 
-Good riddance.
+Note: This version is currently Rails 3 specific, although the final 1.0
+version will also be compatible with 2.x.
 
-DynamicImage is being rewritten.
 
-## License
+## Installation
 
-Copyright 2006-2014 Inge Jørgensen
+Install the gem:
 
-DynamicImage is released under the [MIT License](http://www.opensource.org/licenses/MIT).
+    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.

data/Rakefile

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

@@ -0,0 +1 @@
+1.0.1

data/app/controllers/images_controller.rb

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

data/app/models/image.rb

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

data/config/routes.rb

@@ -0,0 +1,16 @@
+# 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/dynamic_image.gemspec

@@ -12,11 +12,32 @@ Gem::Specification.new do |s|
   s.date = "2014-06-12"
   s.email = "inge@elektronaut.no"
   s.extra_rdoc_files = [
+    "LICENSE",
     "README.md"
   ]
   s.files = [
+    "LICENSE",
     "README.md",
-    "dynamic_image.gemspec"
+    "Rakefile",
+    "VERSION",
+    "app/controllers/images_controller.rb",
+    "app/models/image.rb",
+    "config/routes.rb",
+    "dynamic_image.gemspec",
+    "init.rb",
+    "install.rb",
+    "lib/binary_storage.rb",
+    "lib/binary_storage/active_record_extensions.rb",
+    "lib/binary_storage/blob.rb",
+    "lib/dynamic_image.rb",
+    "lib/dynamic_image/active_record_extensions.rb",
+    "lib/dynamic_image/engine.rb",
+    "lib/dynamic_image/filterset.rb",
+    "lib/dynamic_image/helper.rb",
+    "lib/generators/dynamic_image/USAGE",
+    "lib/generators/dynamic_image/dynamic_image_generator.rb",
+    "lib/generators/dynamic_image/templates/migrations/create_images.rb",
+    "uninstall.rb"
   ]
   s.homepage = "http://github.com/elektronaut/dynamic_image"
   s.require_paths = ["lib"]

data/dynamic_image.sublime-project

@@ -0,0 +1,9 @@
+{
+	"folders":
+	[
+		{
+			"follow_symlinks": true,
+			"path": "."
+		}
+	]
+}