dynamic_image 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6084a12d08ad9d94c391c15c4db5a1c18dd9f695
-  data.tar.gz: f2cb5d614baf98760086414f3a33585bd446a307
+  metadata.gz: b3daa2b118705fafabe134cb7f5707d4d714d67a
+  data.tar.gz: 46ea0855ee40eb1ab22787daab087369eaae5c11
 SHA512:
-  metadata.gz: 11ab636236b5ea3170b19d1649620a144f46f9bcc7c336576146c11454ab81844d4f2bf553a294c61850317d047266f1684fb767452a0572f61871b3f2aa5bcc
-  data.tar.gz: 5a3cf53be701fc82b0eec68920968f7b10446fdbec8b513191955198e4eca010da89ee61c8615967d16b2973c0adbe00448cc3fbe0ca4e4ee7d7b69bd1cca168
+  metadata.gz: a1b7ce51abac870c79574a04cc4d57dc016118590433588757748c508693d2fd7bae9e33c7d1db70d8d6be64b745ec2d364b6c8f0c42373634278bedc6e2b612
+  data.tar.gz: 16b8a043dec55f1f430860217612e6a1ba15dad53ad91e89d41611764c1265a5067f512a5d5969b8fd725a9a20b716e369950ce1f0a6e371b19ade29996d698c

data/Rakefile

@@ -1,10 +1,10 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-APP_RAKEFILE = "spec/internal/Rakefile"
+APP_RAKEFILE = 'spec/internal/Rakefile'.freeze
 load 'rails/tasks/engine.rake'
 
 RSpec::Core::RakeTask.new
 
-task :default => :spec
-task :test => :spec
+task default: :spec
+task test: :spec

data/lib/dynamic_image/belongs_to.rb

@@ -7,16 +7,16 @@ module DynamicImage
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def belongs_to_image(name, scope=nil, options={})
+      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)
+          if new_image.present? && !new_image.is_a?(DynamicImage::Model)
+            new_image = send("build_#{name}", file: new_image)
           end
           super(new_image)
         end
       end
     end
   end
-end
+end

data/lib/dynamic_image/controller.rb

@@ -29,15 +29,14 @@ module DynamicImage
 
     # Renders the original image data, without any processing.
     def original
-      if stale?(@record)
-        respond_to do |format|
-          format.any(:gif, :jpeg, :png, :tiff) do
-            send_data(
-              @record.data,
-              content_type: @record.content_type,
-              disposition:  'inline'
-            )
-          end
+      return unless stale?(@record)
+      respond_to do |format|
+        format.any(:gif, :jpeg, :png, :tiff) do
+          send_data(
+            @record.data,
+            content_type: @record.content_type,
+            disposition:  'inline'
+          )
         end
       end
     end
@@ -58,20 +57,14 @@ module DynamicImage
     end
 
     def render_image(options)
-      processed_image = DynamicImage::ProcessedImage.new(@record, options)
-      if stale?(@record)
-        respond_to do |format|
-          format.html do
-            render(file: File.join(File.dirname(__FILE__), 'templates/show'),
-                   layout: false, locals: {options: options})
-          end
-          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
+      return unless stale?(@record)
+      respond_to do |format|
+        format.html do
+          render(file: File.join(File.dirname(__FILE__), 'templates/show'),
+                 layout: false, locals: { options: options })
+        end
+        format.any(:gif, :jpeg, :png, :tiff) do
+          send_image(DynamicImage::ProcessedImage.new(@record, options))
         end
       end
     end
@@ -80,10 +73,18 @@ module DynamicImage
       params[:format]
     end
 
+    def send_image(image)
+      send_data(
+        image.cropped_and_resized(requested_size),
+        content_type: image.content_type,
+        disposition:  'inline'
+      )
+    end
+
     def verify_signed_params
-      key = [:action, :id, :size].map { |k|
+      key = [:action, :id, :size].map do |k|
         k == :id ? params.require(k).to_i : params.require(k)
-      }.join('-')
+      end.join('-')
       DynamicImage.digest_verifier.verify(key, params[:digest])
     end
   end

data/lib/dynamic_image/digest_verifier.rb

@@ -52,11 +52,17 @@ module DynamicImage
 
     def generate_digest(data)
       require 'openssl' unless defined?(OpenSSL)
-      OpenSSL::HMAC.hexdigest(OpenSSL::Digest.const_get(@digest).new, @secret, data)
+      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))
+      data.present? &&
+        digest.present? &&
+        secure_compare(digest, generate_digest(data))
     end
   end
-end
+end

data/lib/dynamic_image/errors.rb

@@ -4,7 +4,8 @@ module DynamicImage
   module Errors
     class Error < StandardError; end
     class InvalidImage < DynamicImage::Errors::Error; end
+    class InvalidHeader < DynamicImage::Errors::Error; end
     class InvalidSignature < DynamicImage::Errors::Error; end
     class InvalidSizeOptions < DynamicImage::Errors::Error; end
   end
-end
+end

data/lib/dynamic_image/helper.rb

@@ -7,7 +7,7 @@ module DynamicImage
   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={})
+    def dynamic_image_path(record_or_array, options = {})
       dynamic_image_url(record_or_array, { routing_type: :path }.merge(options))
     end
 
@@ -29,24 +29,18 @@ module DynamicImage
     #   # => <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={})
+    def dynamic_image_tag(record_or_array, options = {})
       record = extract_dynamic_image_record(record_or_array)
-      options = {
-        alt: image_alt(record.filename)
-      }.merge(options)
+      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
-      )
+      image_tag(dynamic_image_path_with_size(record_or_array,
+                                             size,
+                                             url_options),
+                html_options)
     end
 
     # Returns the URL for a DynamicImage::Model record.
@@ -71,38 +65,38 @@ module DynamicImage
     #   # => "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={})
+    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
 
     # 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={})
+    def original_dynamic_image_path(record_or_array, options = {})
       dynamic_image_path(record_or_array, { action: :original }.merge(options))
     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={})
+    def original_dynamic_image_url(record_or_array, options = {})
       dynamic_image_url(record_or_array, { action: :original }.merge(options))
     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={})
+    def uncropped_dynamic_image_path(record_or_array, options = {})
       dynamic_image_path(record_or_array, { action: :uncropped }.merge(options))
     end
 
     # Same as +dynamic_image_tag+, but renders an image with any
     # pre-cropping disabled.
-    def uncropped_dynamic_image_tag(record_or_array, options={})
+    def uncropped_dynamic_image_tag(record_or_array, options = {})
       dynamic_image_tag(record_or_array, { action: :uncropped }.merge(options))
     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={})
+    def uncropped_dynamic_image_url(record_or_array, options = {})
       dynamic_image_url(record_or_array, { action: :uncropped }.merge(options))
     end
 
@@ -120,16 +114,18 @@ module DynamicImage
       Mime::Type.lookup(record.safe_content_type).to_sym
     end
 
-    def dynamic_image_digest(record, action, size=nil)
+    def dynamic_image_digest(record, action, size = nil)
       key = [action || 'show', record.id, size].compact.join('-')
       DynamicImage.digest_verifier.generate(key)
     end
 
-    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))
+    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
 
-    def dynamic_image_url_with_size(record_or_array, size=nil, options={})
+    def dynamic_image_url_with_size(record_or_array, size = nil, options = {})
       record = extract_dynamic_image_record(record_or_array)
       options = {
         routing_type: :url,
@@ -137,7 +133,8 @@ module DynamicImage
         format: default_format_for_image(record),
         size: size
       }.merge(options)
-      options[:digest] = dynamic_image_digest(record, options[:action], options[:size])
+      options[:digest] =
+        dynamic_image_digest(record, options[:action], options[:size])
       polymorphic_url(record_or_array, options)
     end
 
@@ -154,17 +151,17 @@ module DynamicImage
       record = extract_dynamic_image_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.real_size.floor.to_s
+        image_sizing(record, size_opts, (action == 'uncropped'))
       else
-        record.size.floor.to_s
+        (action == 'original' ? record.real_size : record.size).floor.to_s
       end
     end
+
+    def image_sizing(record, size_opts, uncropped)
+      ImageSizing
+        .new(record, uncropped: uncropped)
+        .fit(size_opts[:size], size_opts).floor.to_s
+    end
   end
 end

data/lib/dynamic_image/image_reader.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module DynamicImage
+  class ImageReader
+    def initialize(data)
+      @data = data
+    end
+
+    def read
+      raise DynamicImage::Errors::InvalidHeader unless valid_header?
+      MiniMagick::Image.read(@data)
+    end
+
+    def valid_header?
+      magic_bytes.each do |expr|
+        if (expr.is_a?(Regexp) && file_header =~ /^#{expr}/) ||
+           (expr.is_a?(String) && file_header.start_with?(expr))
+          return true
+        end
+      end
+      false
+    end
+
+    private
+
+    def file_header
+      @file_header ||= StringIO.new(@data, "rb").read(10)
+    end
+
+    def magic_bytes
+      [
+        # GIF
+        "\x47\x49\x46\x38\x37\x61".force_encoding("binary"),
+        "\x47\x49\x46\x38\x39\x61".force_encoding("binary"),
+        # PNG
+        "\x89\x50\x4e\x47\x0d\x0a\x1a\x0a".force_encoding("binary"),
+        # JPEG
+        "\xff\xd8\xff\xdb".force_encoding("binary"),
+        Regexp.new("\xff\xd8\xff\xe0(.*){2}JFIF".force_encoding("binary")),
+        Regexp.new("\xff\xd8\xff\xe1(.*){2}Exif".force_encoding("binary")),
+        "\xff\xd8\xff\xee\x00\x0e".force_encoding("binary"), # Adobe JPEG
+        # TIFF
+        "\x49\x49\x2a\x00".force_encoding("binary"),
+        "\x4d\x4d\x00\x2a".force_encoding("binary"),
+      ]
+    end
+  end
+end

data/lib/dynamic_image/image_sizing.rb

@@ -5,7 +5,7 @@ module DynamicImage
   #
   # Calculates cropping and fitting for image sizes.
   class ImageSizing
-    def initialize(record, options={})
+    def initialize(record, options = {})
       @record = record
       @uncropped = options[:uncropped] ? true : false
     end
@@ -76,7 +76,7 @@ module DynamicImage
     #   sizing.fit(Vector2d(500, 500), upscale: true)
     #   # => Vector2d(500.0, 312.5)
     #
-    def fit(fit_size, options={})
+    def fit(fit_size, options = {})
       fit_size = parse_vector(fit_size)
       require_dimensions!(fit_size)     if options[:crop]
       fit_size = size.fit(fit_size)     unless options[:crop]
@@ -122,12 +122,10 @@ module DynamicImage
     end
 
     def parse_vector(v)
-      v.kind_of?(String) ? str_to_vector(v) : v
+      v.is_a?(String) ? str_to_vector(v) : v
     end
 
-    def record
-      @record
-    end
+    attr_reader :record
 
     def require_dimensions!(v)
       raise DynamicImage::Errors::InvalidSizeOptions unless v.x > 0 && v.y > 0
@@ -141,7 +139,7 @@ module DynamicImage
     end
 
     def str_to_vector(str)
-      x, y = str.match(/(\d*)x(\d*)/)[1,2].map(&:to_i)
+      x, y = str.match(/(\d*)x(\d*)/)[1, 2].map(&:to_i)
       Vector2d.new(x, y)
     end
 
@@ -153,4 +151,4 @@ module DynamicImage
       Vector2d.new(x, y)
     end
   end
-end
+end

data/lib/dynamic_image/metadata.rb

@@ -16,27 +16,23 @@ module DynamicImage
       if valid?
         case metadata[:colorspace]
         when /rgb/i
-          "rgb"
+          'rgb'
         when /cmyk/i
-          "cmyk"
+          'cmyk'
         when /gray/i
-          "gray"
+          'gray'
         end
       end
     end
 
     # Returns the content type of the image.
     def content_type
-      if valid?
-        "image/#{format.downcase}"
-      end
+      "image/#{format.downcase}" if valid?
     end
 
     # Returns the dimensions of the image as a vector.
     def dimensions
-      if valid?
-        Vector2d.new(*metadata[:dimensions])
-      end
+      Vector2d.new(*metadata[:dimensions]) if valid?
     end
 
     # Returns the width of the image.
@@ -51,14 +47,12 @@ module DynamicImage
 
     # Returns the format of the image.
     def format
-      if valid?
-        metadata[:format]
-      end
+      metadata[:format] if valid?
     end
 
     # Returns true if the image is valid.
     def valid?
-      @data && metadata != :invalid
+      @data && reader.valid_header? && metadata != :invalid
     end
 
     private
@@ -67,18 +61,28 @@ module DynamicImage
       @metadata ||= read_metadata
     end
 
-    def read_metadata
-      image = MiniMagick::Image.read(@data)
+    def read_image
+      image = reader.read
       image.auto_orient
-      metadata = {
-        colorspace: image[:colorspace],
-        dimensions: image[:dimensions],
-        format:     image[:format]
-      }
+      result = yield image
       image.destroy!
-      metadata
+      result
     rescue MiniMagick::Invalid
       :invalid
     end
+
+    def reader
+      @reader ||= DynamicImage::ImageReader.new(@data)
+    end
+
+    def read_metadata
+      read_image do |image|
+        {
+          colorspace: image[:colorspace],
+          dimensions: image[:dimensions],
+          format:     image[:format]
+        }
+      end
+    end
   end
-end
+end

data/lib/dynamic_image/model/dimensions.rb

@@ -5,7 +5,6 @@ module DynamicImage
     # = DynamicImage Model Dimensions
     #
     module Dimensions
-
       # Returns the crop gravity.
       #
       # DynamicImage will try to keep the pixel represented by
@@ -33,9 +32,7 @@ module DynamicImage
 
       # Returns the crop size, or nil if no cropping is applied.
       def crop_size
-        if crop_size?
-          vector(crop_width, crop_height)
-        end
+        vector(crop_width, crop_height) if crop_size?
       end
 
       # Returns true if crop size has been set.
@@ -64,9 +61,7 @@ module DynamicImage
 
       # Returns the real size of the image, without any cropping applied.
       def real_size
-        if real_size?
-          vector(real_width, real_height)
-        end
+        vector(real_width, real_height) if real_size?
       end
 
       # Returns true if the size has been set.
@@ -92,4 +87,4 @@ module DynamicImage
       end
     end
   end
-end
+end

data/lib/dynamic_image/model/validations.rb

@@ -13,34 +13,34 @@ module DynamicImage
         validates_data_presence
 
         validates :colorspace,
-          presence: true,
-          inclusion: { in: allowed_colorspaces }
+                  presence: true,
+                  inclusion: { in: allowed_colorspaces }
 
         validates :content_type,
-          presence: true,
-          inclusion: { in: allowed_content_types }
+                  presence: true,
+                  inclusion: { in: allowed_content_types }
 
         validates :content_length,
-          presence: true,
-          numericality: { greater_than: 0, only_integer: true }
+                  presence: true,
+                  numericality: { greater_than: 0, only_integer: true }
 
         validates :filename,
-          presence: true,
-          length: { maximum: 255 }
+                  presence: true,
+                  length: { maximum: 255 }
 
         validates :real_width, :real_height,
-          numericality: { greater_than: 0, only_integer: true }
+                  numericality: { greater_than: 0, only_integer: true }
 
         validates :real_width, :real_height,
-          numericality: { greater_than: 0, only_integer: true }
+                  numericality: { greater_than: 0, only_integer: true }
 
         validates :crop_width, :crop_height,
-          :crop_gravity_x, :crop_gravity_y,
-          numericality: { greater_than: 0, only_integer: true },
-          allow_nil: true
+                  :crop_gravity_x, :crop_gravity_y,
+                  numericality: { greater_than: 0, only_integer: true },
+                  allow_nil: true
 
         validates :real_width, :real_height,
-          presence: true
+                  presence: true
 
         validates :crop_width, presence: true, if: :crop_height?
         validates :crop_height, presence: true, if: :crop_width?
@@ -57,21 +57,21 @@ module DynamicImage
 
       module ClassMethods
         def allowed_colorspaces
-          %w{
+          %w(
             rgb
             cmyk
             gray
-          }
+          )
         end
 
         def allowed_content_types
-          %w{
+          %w(
             image/gif
             image/jpeg
             image/pjpeg
             image/png
             image/tiff
-          }
+          )
         end
       end
 
@@ -80,15 +80,13 @@ module DynamicImage
       def validate_crop_bounds
         required_size = crop_start + crop_size
         if required_size.x > real_size.x || required_size.y > real_size.y
-          self.errors.add(:crop_size, "is out of bounds")
+          errors.add(:crop_size, 'is out of bounds')
         end
       end
 
       def validate_image
-        unless valid_image?
-         self.errors.add(:data, :invalid)
-        end
+        errors.add(:data, :invalid) unless valid_image?
       end
     end
   end
-end
+end

data/lib/dynamic_image/model.rb

@@ -70,17 +70,17 @@ module DynamicImage
 
     # Returns true if the image is in the CMYK colorspace
     def cmyk?
-      colorspace == "cmyk"
+      colorspace == 'cmyk'
     end
 
     # Returns true if the image is in the grayscale colorspace
     def gray?
-      colorspace == "gray"
+      colorspace == 'gray'
     end
 
     # Returns true if the image is in the RGB colorspace
     def rgb?
-      colorspace == "rgb"
+      colorspace == 'rgb'
     end
 
     # Finds a web safe content type. GIF, JPEG and PNG images are allowed,
@@ -102,15 +102,14 @@ module DynamicImage
     private
 
     def read_image_metadata
-      metadata = DynamicImage::Metadata.new(self.data)
+      metadata = DynamicImage::Metadata.new(data)
+      @valid_image = false
       if metadata.valid?
         self.colorspace = metadata.colorspace
         self.real_width = metadata.width
         self.real_height = metadata.height
         self.content_type = metadata.content_type
         @valid_image = true
-      else
-        @valid_image = false
       end
       true
     end
@@ -120,11 +119,11 @@ module DynamicImage
     end
 
     def safe_content_types
-      %w{
+      %w(
         image/png
         image/gif
         image/jpeg
-      }
+      )
     end
   end
-end
+end

data/lib/dynamic_image/processed_image.rb

@@ -6,11 +6,11 @@ module DynamicImage
   # Handles all processing of images. Takes an instance of
   # +DynamicImage::Model+ as argument.
   class ProcessedImage
-    def initialize(record, options={})
+    def initialize(record, options = {})
       @record    = record
       @uncropped = options[:uncropped] ? true : false
       @format    = options[:format].to_s.upcase if options[:format]
-      @format    = "JPEG" if defined?(@format) && @format == "JPG"
+      @format    = 'JPEG' if defined?(@format) && @format == 'JPG'
     end
 
     # Returns the content type of the processed image.
@@ -57,7 +57,7 @@ module DynamicImage
     #   jpg_data = processed.normalized
     #
     # Returns a binary string.
-    def normalized(&block)
+    def normalized
       require_valid_image!
       process_data do |image|
         image.combine_options do |combined|
@@ -75,7 +75,7 @@ module DynamicImage
     def coalesced(image)
       if gif?
         image.coalesce
-        image = MiniMagick::Image.read(image.to_blob)
+        image = DynamicImage::ImageReader.new(image.to_blob).read
       end
       image
     end
@@ -89,7 +89,8 @@ module DynamicImage
     end
 
     def image_sizing
-      @image_sizing ||= DynamicImage::ImageSizing.new(record, uncropped: @uncropped)
+      @image_sizing ||= DynamicImage::ImageSizing.new(record,
+                                                      uncropped: @uncropped)
     end
 
     def needs_colorspace_conversion?
@@ -101,23 +102,19 @@ module DynamicImage
     end
 
     def optimize(image)
-      if gif?
-        image.layers 'optimize'
-      end
+      image.layers 'optimize' if gif?
       image.strip
     end
 
-    def process_data(&block)
-      image = coalesced(MiniMagick::Image.read(record.data))
+    def process_data
+      image = coalesced(DynamicImage::ImageReader.new(record.data).read)
       yield(image)
       result = image.to_blob
       image.destroy!
       result
     end
 
-    def record
-      @record
-    end
+    attr_reader :record
 
     def record_format
       case record.content_type
@@ -133,9 +130,7 @@ module DynamicImage
     end
 
     def require_valid_image!
-      unless record.valid?
-        raise DynamicImage::Errors::InvalidImage
-      end
+      raise DynamicImage::Errors::InvalidImage unless record.valid?
     end
   end
 end

data/lib/dynamic_image/railtie.rb

@@ -2,7 +2,7 @@
 
 module DynamicImage
   class Railtie < ::Rails::Railtie
-    initializer "dynamic_image" do
+    initializer 'dynamic_image' do
       ActionDispatch::Routing::Mapper.send :include, DynamicImage::Routing
 
       config.after_initialize do |app|

data/lib/dynamic_image/routing.rb

@@ -9,7 +9,7 @@ module DynamicImage
     # Declares an image resource.
     #
     #   image_resources :avatars
-    def image_resources(resource_name, options={})
+    def image_resources(resource_name, options = {})
       options = {
         path:        "#{resource_name}/:digest(/:size)",
         constraints: { size: /\d+x\d+/ },

data/lib/dynamic_image/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module DynamicImage
-  VERSION = "2.0.0"
+  VERSION = '2.0.1'.freeze
 end

data/lib/dynamic_image.rb

@@ -9,6 +9,7 @@ require 'dynamic_image/controller'
 require 'dynamic_image/digest_verifier'
 require 'dynamic_image/errors'
 require 'dynamic_image/helper'
+require 'dynamic_image/image_reader'
 require 'dynamic_image/image_sizing'
 require 'dynamic_image/metadata'
 require 'dynamic_image/model'

data/lib/rails/generators/dynamic_image/resource/resource_generator.rb

@@ -6,7 +6,7 @@ require 'rails/generators/rails/resource/resource_generator'
 module DynamicImage
   module Generators
     class ResourceGenerator < Rails::Generators::ResourceGenerator
-      desc "Creates a DynamicImage resource"
+      desc 'Creates a DynamicImage resource'
 
       def initialize(args, *options)
         super(inject_dynamic_image_attributes(args), *options)
@@ -14,14 +14,14 @@ module DynamicImage
 
       def add_controller_extension
         inject_into_file(
-          File.join('app/controllers', class_path, "#{file_name.pluralize}_controller.rb"),
+          File.join(
+            'app/controllers',
+            class_path,
+            "#{file_name.pluralize}_controller.rb"),
           after: "ApplicationController\n"
         ) do
-          "  include DynamicImage::Controller\n\n" +
-          "  private\n\n" +
-          "  def model\n" +
-          "    #{class_name}\n" +
-          "  end\n"
+          "  include DynamicImage::Controller\n\n  private\n\n" \
+            "  def model\n    #{class_name}\n  end\n"
         end
       end
 
@@ -46,29 +46,24 @@ module DynamicImage
 
       def inject_dynamic_image_attributes(args)
         if args.any?
-          args = [args[0]] + dynamic_image_attributes + args[1..args.length]
+          [args[0]] + dynamic_image_attributes + args[1..args.length]
         else
           args
         end
       end
 
       def dynamic_image_attributes
-        %w{
-          content_hash:string
-          content_type:string
+        %w(
+          content_hash:string    content_type:string
           content_length:integer
           filename:string
           colorspace:string
-          real_width:integer
-          real_height:integer
-          crop_width:integer
-          crop_height:integer
-          crop_start_x:integer
-          crop_start_y:integer
-          crop_gravity_x:integer
-          crop_gravity_y:integer
-        }
+          real_width:integer     real_height:integer
+          crop_width:integer     crop_height:integer
+          crop_start_x:integer   crop_start_y:integer
+          crop_gravity_x:integer crop_gravity_y:integer
+        )
       end
     end
   end
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_image
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Inge Jørgensen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-26 00:00:00.000000000 Z
+date: 2016-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -116,6 +116,7 @@ files:
 - lib/dynamic_image/digest_verifier.rb
 - lib/dynamic_image/errors.rb
 - lib/dynamic_image/helper.rb
+- lib/dynamic_image/image_reader.rb
 - lib/dynamic_image/image_sizing.rb
 - lib/dynamic_image/metadata.rb
 - lib/dynamic_image/model.rb