dynamic_image 1.0.4 → 2.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fa4635730b705cb0d3d48024139359bc7bbbfef6
+  data.tar.gz: ededec9d42f262502983c22c8c753b8de8498a9b
+SHA512:
+  metadata.gz: 3558ebbfb2e0f5e2744bbdc028da4e73515134fa88100749bf072af97f61707dfb56a969d31a482d409e24818548dab1cd09207b46a4925552b5d051ce714cb5
+  data.tar.gz: be91b398098093248afd99558fe3101eedd1917193efba2632d36e3617d5929f5c3d1709745e2ddd8427b612b4a7024ad4c148e1e4adcf95044c0feb19564995

data/{LICENSE → MIT-LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2006-2010 Inge Jørgensen
+Copyright 2006-2014 Inge Jørgensen
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,109 +1,86 @@
-# 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.
-
-Note: This version is currently Rails 3 specific, although the final 1.0
-version will also be compatible with 2.x.
+# DynamicImage [![Build Status](https://travis-ci.org/elektronaut/dynamic_image.png)](https://travis-ci.org/elektronaut/dynamic_image) [![Code Climate](https://codeclimate.com/github/elektronaut/dynamic_image.png)](https://codeclimate.com/github/elektronaut/dynamic_image) [![Code Climate](https://codeclimate.com/github/elektronaut/dynamic_image/coverage.png)](https://codeclimate.com/github/elektronaut/dynamic_image)
 
+Requires Rails 4.1+ and Ruby 1.9.3+.
 
 ## Installation
 
-Install the gem:
-
-    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
+Add the gem to your Gemfile and run `bundle install`.
 
-Let's create a model with an image:
+```ruby
+gem "dynamic_image"
+```
 
-    class User
-      belongs_to_image :mugshot
-    end
+Run the `dis:install` generator to set up your storage.
 
-Uploading files is pretty straightforward, just add a <tt>file_field</tt>
-to your form and update your record as usual:
+```sh
+bin/rails generate dis:install
+```
 
-    <%= form_for @user, :html => {:multipart => true} do |f| %>
-       Name:    <%= f.text_field :name %>
-       Mugshot: <%= f.file_field :mugshot %>
-       <%= submit_tag "Save" %>
-    <% end %>
+You can edit the generated initializer to configure your storage, by default it
+will store files in `db/dis`. See the
+[Dis](https://github.com/elektronaut/dis) documentation for more
+information.
 
-You can now use the <tt>dynamic_image_tag</tt> helper to show off your
-new image:
+## Creating your resource
 
-    <% if @user.mugshot? %>
-       <%= dynamic_image_tag @user.profile_picture, :size => '64x64' %>
-    <% end %>
+Run the `dynamic_image:resource` generator to create your resource.
 
+```sh
+bin/rails generate dynamic_image:resource image
+```
 
-## Filters
+This will create an `Image` model and a controller, along with a migration and
+the necessary routes.
 
-I'm cleaning up the filters syntax, watch this space.
+Note that in this case, the route with collide with any static images stored
+in `public/images`. You can customize the path if you want in the route
+declaration.
 
+```ruby
+image_resources :images, path: "dynamic_images/:digest(/:size)"
+```
 
-## Technical
+## Rendering images in your views
 
-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.
+You should use the provided helpers for displaying images, this will ensure
+that the generated URLs are properly signed and timestamped.
 
-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:
+To display the image at it's original size, use `dynamic_image_tag` without
+any options.
 
- DynamicImage.page_caching = false
+```html
+<%= dynamic_image_tag image %>
+```
 
+To resize it, specify a max size. This will scale the image down to fit, but
+no cropping will occur.
 
-## History
+```html
+<%= dynamic_image_tag image, size: '400x400' %>
+```
 
-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.
+Setting `crop: true` will crop the image to the exact size.
 
-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.
+```html
+<%= dynamic_image_tag image, size: '400x400', crop: true %>
+```
 
-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.
+Omitting either dimension will render the image at an exact width or height.
 
+```html
+<%= dynamic_image_tag image, size: '400x' %>
+```
 
-## Copyright
+`dynamic_image_path` and `dynamic_image_url` act pretty much like regular URL
+helpers.
 
-Copyright © 2006 Inge Jørgensen.
+```html
+<%= link_to "See image", dynamic_image_path(image) %>
+```
 
-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:
+## License
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+Copyright 2006-2014 Inge Jørgensen
 
-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/Rakefile

@@ -1,33 +1,10 @@
-require 'rake'
-require 'rake/testtask'
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-require "rake"
+APP_RAKEFILE = "spec/internal/Rakefile"
+load 'rails/tasks/engine.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
+RSpec::Core::RakeTask.new
 
+task :default => :spec
+task :test => :spec

data/lib/dynamic_image/belongs_to.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module DynamicImage
+  # = DynamicImage Belongs To
+  #
+  module BelongsTo
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def belongs_to_image(name, scope=nil, options={})
+        belongs_to(name, scope, options)
+
+        define_method "#{name}=" do |new_image|
+          if new_image.present? && !new_image.kind_of?(DynamicImage::Model)
+            new_image = self.send("build_#{name}", file: new_image)
+          end
+          super(new_image)
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_image/controller.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+module DynamicImage
+  # = DynamicImage Controller
+  #
+  # Generating images is rather expensive, so all requests must be
+  # signed with a HMAC digest in order to avoid denial of service attacks.
+  # The methods in +DynamicImage::Helper+ handles this transparently.
+  # As a bonus, this also prevents unauthorized URL enumeration.
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :verify_signed_params
+      before_action :find_record
+      after_action :cache_expiration_header
+      respond_to :gif, :jpeg, :png, :tiff
+    end
+
+    # Renders the image.
+    def show
+      render_image(format: requested_format)
+    end
+
+    # Same as +show+, but renders the image without any pre-cropping applied.
+    def uncropped
+      render_image(format: requested_format, uncropped: true)
+    end
+
+    # Renders the original image data, without any processing.
+    def original
+      if stale?(@record)
+        respond_with(@record) do |format|
+          format.any(:gif, :jpeg, :png, :tiff) do
+            send_data(
+              @record.data,
+              content_type: @record.content_type,
+              disposition:  'inline'
+            )
+          end
+        end
+      end
+    end
+
+    private
+
+    def cache_expiration_header
+      expires_in 30.days, public: true
+    end
+
+    def find_record
+      @record = model.find(params[:id])
+    end
+
+    def render_image(options)
+      processed_image = DynamicImage::ProcessedImage.new(@record, options)
+      if stale?(@record)
+        respond_with(@record) do |format|
+          format.any(:gif, :jpeg, :png, :tiff) do
+            send_data(
+              processed_image.cropped_and_resized(requested_size),
+              content_type: processed_image.content_type,
+              disposition:  'inline'
+            )
+          end
+        end
+      end
+    end
+
+    def requested_format
+      params[:format]
+    end
+
+    def requested_size
+      Vector2d.parse(params[:size])
+    end
+
+    def signed_params
+      case request[:action]
+      when "show", "uncropped"
+        [:action, :id, :size]
+      else
+        [:action, :id]
+      end
+    end
+
+    def verify_signed_params
+      key = signed_params.map { |k|
+        k == :id ? params.require(k).to_i : params.require(k)
+      }.join('-')
+      DynamicImage.digest_verifier.verify(key, params[:digest])
+    end
+  end
+end

data/lib/dynamic_image/digest_verifier.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module DynamicImage
+  # = DynamicImage Digest Verifier
+  #
+  # ==== Usage
+  #
+  #   verifier = DynamicImage::DigestVerifier.new("super secret!")
+  #
+  #   digest = verifier.generate("foo")
+  #
+  #   digest.verify("foo", digest)
+  #   # => true
+  #   digest.verify("bar", digest)
+  #   # => raises DynamicImage::Errors::InvalidSignature
+  #
+  # Credit where credit is due: adapted and simplified from
+  # +ActiveSupport::MessageVerifier+, since we don't need to handle
+  # arbitrary data structures and ship the serialized data to the client.
+  class DigestVerifier
+    def initialize(secret, options = {})
+      @secret = secret
+      @digest = options[:digest] || 'SHA1'
+    end
+
+    # Generates a digest for a string.
+    def generate(data)
+      generate_digest(data)
+    end
+
+    # Verifies that <tt>digest</tt> is valid for <tt>data</tt>.
+    # Raises a +DynamicImage::Errors::InvalidSignature+ error if not.
+    def verify(data, digest)
+      if valid_digest?(data, digest)
+        true
+      else
+        raise DynamicImage::Errors::InvalidSignature
+      end
+    end
+
+    private
+
+    def secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      l = a.unpack "C#{a.bytesize}"
+
+      res = 0
+      b.each_byte { |byte| res |= byte ^ l.shift }
+      res == 0
+    end
+
+    def generate_digest(data)
+      require 'openssl' unless defined?(OpenSSL)
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
+    end
+
+    def valid_digest?(data, digest)
+      data.present? && digest.present? && secure_compare(digest, generate_digest(data))
+    end
+  end
+end

data/lib/dynamic_image/errors.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module DynamicImage
+  module Errors
+    class Error < StandardError; end
+    class InvalidImage < DynamicImage::Errors::Error; end
+    class InvalidSignature < DynamicImage::Errors::Error; end
+    class InvalidSizeOptions < DynamicImage::Errors::Error; end
+  end
+end

data/lib/dynamic_image/helper.rb

@@ -1,107 +1,161 @@
-require 'dynamic_image'
+# encoding: utf-8
 
 module DynamicImage
+  # = DynamicImage Helper
+  #
+  # Provides helper methods for rendering and linking to images.
   module Helper
+    # Returns the path for a DynamicImage::Model record.
+    # Takes the same options as +dynamic_image_url+
+    def dynamic_image_path(record_or_array, options={})
+      dynamic_image_url(record_or_array, { routing_type: :path }.merge(options))
+    end
 
-    # 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}
+    # Returns an HTML image tag for the record. If no size is given, it will
+    # render at the original size.
+    #
+    # ==== Options
+    # * <tt>:alt</tt>: If no alt text is given, it will default to the
+    #   filename of the uploaded image.
+    #
+    # See +dynamic_image_url+ for info on how to size and cropping. Options
+    # supported by +polymorphic_url+ will be passed to the router. Any other
+    # options will be added as HTML attributes.
+    #
+    # ==== Examples
+    #
+    #   image = Image.find(params[:id])
+    #   dynamic_image_tag(image)
+    #   # => <img alt="My file" height="200" src="..." width="320" />
+    #   dynamic_image_tag(image, size: "100x100", alt="Avatar")
+    #   # => <img alt="Avatar" height="62" src="..." width="100" />
+    def dynamic_image_tag(record_or_array, options={})
+      record = extract_record(record_or_array)
+      options = {
+        alt: image_alt(record.filename)
+      }.merge(options)
+
+      size = fit_size!(record_or_array, options)
+      url_options = options.extract!(*allowed_dynamic_image_url_options)
+      html_options = { size: size }.merge(options)
+
+      image_tag(
+        dynamic_image_path_with_size(
+          record_or_array,
+          size,
+          url_options
+        ),
+        html_options
+      )
+    end
 
-      if options[:original]
-        url_options[:original] = 'original'
-        options.delete(:original)
-      end
+    # Returns the URL for a DynamicImage::Model record.
+    #
+    # ==== Options
+    #
+    # * <tt>:size</tt> - Desired image size, supplied as "{width}x{height}".
+    #   The image will be scaled to fit. A partial size like "100x" or "x100"
+    #   can be given, if you want a fixed width or height.
+    # * <tt>:crop</tt> - If true, the image will be cropped to the given size.
+    # * <tt>:upscale</tt> - By default, DynamicImage only scale images down,
+    #   never up. Pass <tt>upscale: true</tt> to force upscaling.
+    #
+    # Any options supported by +polymorphic_url+ are also accepted.
+    #
+    # ==== Examples
+    #
+    #   image = Image.find(params[:id])
+    #   dynamic_image_url(image)
+    #   # => "http://example.com/images/96...d1/300x187/1-2014062020...00.jpg"
+    #   dynamic_image_url(image, size: '100x100')
+    #   # => "http://example.com/images/72...c2/100x62/1-2014062020...00.jpg"
+    #   dynamic_image_url(image, size: '100x100', crop: true)
+    #   # => "http://example.com/images/a4...6b/100x100/1-2014062020...00.jpg"
+    def dynamic_image_url(record_or_array, options={})
+      size = fit_size!(record_or_array, options)
+      dynamic_image_url_with_size(record_or_array, size, options)
+    end
 
-      # Image sizing
-      if options[:size]
-        new_size   = Vector2d.new(options[:size])
-        image_size = Vector2d.new(image.size)
+    # Returns a path to the original uploaded file, without any processing
+    # applied. Sizing options are not supported.
+    def original_dynamic_image_path(record_or_array, options={})
+      dynamic_image_path(record_or_array, { action: :original }.merge(options))
+    end
 
-              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
+    # Returns a URL to the original uploaded file, without any processing
+    # applied. Sizing options are not supported.
+    def original_dynamic_image_url(record_or_array, options={})
+      dynamic_image_url(record_or_array, { action: :original }.merge(options))
+    end
 
-        unless options[:crop]
-          new_size = image_size.constrain_both(new_size)
-        end
+    # Same as +dynamic_image_path+, but points to an image with any
+    # pre-cropping disabled.
+    def uncropped_dynamic_image_path(record_or_array, options={})
+      dynamic_image_path(record_or_array, { action: :uncropped }.merge(options))
+    end
 
-        options[:size] = new_size.round.to_s
-        url_options[:size] = options[:size]
-      end
-      options.delete :crop
+    # Same as +dynamic_image_tag+, but renders an image with any
+    # pre-cropping disabled.
+    def uncropped_dynamic_image_tag(record_or_array, options={})
+      dynamic_image_tag(record_or_array, { action: :uncropped }.merge(options))
+    end
 
-      if options[:no_size_attr]
-        options.delete :no_size_attr
-        options.delete :size
-      end
+    # Same as +dynamic_image_url+, but points to an image with any
+    # pre-cropping disabled.
+    def uncropped_dynamic_image_url(record_or_array, options={})
+      dynamic_image_url(record_or_array, { action: :uncropped }.merge(options))
+    end
 
-      # Filterset
-      if options[:filterset]
-        url_options[:filterset] = options[:filterset]
-        options.delete :filterset
-      end
+    private
 
-      # 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
+    def allowed_dynamic_image_url_options
+      [
+        :format, :only_path, :protocol, :host, :subdomain, :domain,
+        :tld_length, :port, :anchor, :trailing_slash, :script_name,
+        :action, :routing_type
+      ]
+    end
 
-      # Alt attribute
-      options[:alt] ||= image.name if image.name?
-      options[:alt] ||= image.filename.split('.').first.capitalize
+    def default_format_for_image(record)
+      Mime::Type.lookup(record.safe_content_type).to_sym
+    end
 
-      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
+    def dynamic_image_digest(record, action, size=nil)
+      key = [action || 'show', record.id, size].compact.join('-')
+      DynamicImage.digest_verifier.generate(key)
+    end
 
-      {:url => url_for(url_options), :options => options}
+    def dynamic_image_path_with_size(record_or_array, size=nil, options={})
+      dynamic_image_url_with_size(record_or_array, size, { routing_type: :path }.merge(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
+    def dynamic_image_url_with_size(record_or_array, size=nil, options={})
+      record = extract_record(record_or_array)
+      options = {
+        routing_type: :url,
+        action: nil,
+        format: default_format_for_image(record),
+        size: size
+      }.merge(options)
+      options[:digest] = dynamic_image_digest(record, options[:action], options[:size])
+      polymorphic_url(record_or_array, options)
     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]
+    def fit_size!(record_or_array, options)
+      record = extract_record(record_or_array)
+      action = options[:action].try(:to_s)
+      size_opts = options.extract!(:size, :crop, :upscale)
+
+      if size_opts[:size]
+        DynamicImage::ImageSizing.new(
+          record,
+          uncropped: (action == "uncropped")
+        ).fit(size_opts[:size], size_opts).floor.to_s
+      elsif action != "original"
+        record.size.floor.to_s
+      else
+        nil
+      end
     end
   end
 end
-
-ActionView::Base.send(:include, DynamicImage::Helper)