dragonfly 0.1.6 → 0.2.1

data/extra_docs/UsingWithRails.md

@@ -0,0 +1,104 @@
+Using With Rails
+================
+
+There are two main ways to use Dragonfly with Rails - as a {Dragonfly::Middleware middleware},
+and as a Rails Metal.
+
+Using as Middleware
+-------------------
+In environment.rb:
+
+    config.gem 'dragonfly-rails', :lib => 'dragonfly/rails/images'
+    config.middleware.use 'Dragonfly::MiddlewareWithCache', :images
+
+The gem dragonfly-rails does nothing more than tie together the gem dependencies dragonfly,
+rack-cache and rmagick.
+
+The required file 'dragonfly/rails/images.rb' initializes a dragonfly app, configures it to use rmagick processing, encoding, etc.,
+and registers the app so that you can use ActiveRecord accessors.
+
+For reference, the contents are as follows:
+
+    require 'dragonfly'
+
+    ### The dragonfly app ###
+
+    app = Dragonfly::App[:images]
+    app.configure_with(Dragonfly::RMagickConfiguration)
+    app.configure do |c|
+      c.log = RAILS_DEFAULT_LOGGER
+      c.datastore.configure do |d|
+        d.root_path = "#{Rails.root}/public/system/dragonfly/#{Rails.env}"
+      end
+      c.url_handler.configure do |u|
+        u.protect_from_dos_attacks = false
+        u.path_prefix = '/media'
+      end
+    end
+
+    ### Extend active record ###
+    ActiveRecord::Base.extend Dragonfly::ActiveRecordExtensions
+    ActiveRecord::Base.register_dragonfly_app(:image, app)
+
+The second line configures rails to use a {Dragonfly::MiddlewareWithCache middleware} which uses the named app (named `:images`), and puts
+{http://tomayko.com/src/rack-cache/ Rack::Cache} in front of it for performance.
+You can pass extra arguments to this line which will go directly to configuring Rack::Cache (see its docs for how to configure it).
+The default configuration for Rack::Cache is
+
+    {
+      :verbose     => true,
+      :metastore   => 'file:/var/cache/rack/meta',
+      :entitystore => 'file:/var/cache/rack/body'
+    }
+
+To see what you can do with the active record accessors, see {file:ActiveRecord}.
+
+Using as a Rails Metal
+----------------------
+The easiest way of setting up as a rails metal is using the supplied generator.
+(NB I've had a couple of problems with the generator with plural/singular names with early versions of metal in Rails 2.3 -
+this should be resolvable by making sure the metal name matches its filename).
+
+    ./script/generate dragonfly_app images
+    
+The argument 'images' could be anything - it is an arbitrary app name.
+
+This does two things:
+
+1. Creates and configures an app as a rails metal
+2. Registers the app for use with ActiveRecord - see {file:ActiveRecord}
+
+For reference, the contents of the metal file is given below. You could do something similar yourself without the generator.
+
+    # Allow the metal piece to run in isolation
+    require(File.dirname(__FILE__) + "/../../config/environment") unless defined?(Rails)
+    require 'dragonfly'
+
+    # Configuration of the Dragonfly App
+    Dragonfly::App[:images].configure_with(Dragonfly::RMagickConfiguration)
+    Dragonfly::App[:images].configure do |c|
+      c.log = RAILS_DEFAULT_LOGGER
+      c.datastore.configure do |d|
+        d.root_path = "#{Rails.root}/public/system/dragonfly/#{Rails.env}"
+      end
+      c.url_handler.configure do |u|
+        u.secret = '29205f3e01648d0966bd5b119cd53347390a9ba9'
+        u.path_prefix = '/images'
+      end
+    end
+
+    # The metal, for running the app
+    app = Dragonfly::App[:images]
+    Images = Rack::Builder.new do
+
+      # UNCOMMENT ME!!!
+      # ... if you want to use super-dooper middleware 'rack-cache'
+      # require 'rack/cache'
+      # use Rack::Cache,
+      #   :verbose     => true,
+      #   :metastore   => 'file:/var/cache/rack/meta',
+      #   :entitystore => 'file:/var/cache/rack/body'
+
+      run app
+
+    end

data/features/{dragonfly.feature → images.feature}

@@ -3,10 +3,11 @@ Feature: champion uses dragonfly to process images
   A user uses dragonfly
 
   Background:
+    Given we are using the app for images
     Given a stored image "beach.png" with dimensions 200x100
 
   Scenario: Go to url for original
-    When I go to the url for image "beach.png", with format 'png'
+    When I go to the url for "beach.png", with format 'png'
     Then the response should be OK
     And the response should have mime-type 'image/png'
     And the image should have width '200'
@@ -14,7 +15,7 @@ Feature: champion uses dragonfly to process images
     And the image should have format 'png'
 
   Scenario: Go to url for changed format version
-    When I go to the url for image "beach.png", with format 'gif'
+    When I go to the url for "beach.png", with format 'gif'
     Then the response should be OK
     And the response should have mime-type 'image/gif'
     And the image should have width '200'
@@ -22,7 +23,7 @@ Feature: champion uses dragonfly to process images
     And the image should have format 'gif'
 
   Scenario: Go to url for soft resized version
-    When I go to the url for image "beach.png", with format 'png' and resize geometry '100x150'
+    When I go to the url for "beach.png", with format 'png' and resize geometry '100x150'
     Then the response should be OK
     And the response should have mime-type 'image/png'
     And the image should have width '100'
@@ -30,9 +31,18 @@ Feature: champion uses dragonfly to process images
     And the image should have format 'png'
 
   Scenario: Go to url for hard resized version
-    When I go to the url for image "beach.png", with format 'png' and resize geometry '100x150!'
+    When I go to the url for "beach.png", with format 'png' and resize geometry '100x150!'
     Then the response should be OK
     And the response should have mime-type 'image/png'
     And the image should have width '100'
     And the image should have height '150'
     And the image should have format 'png'
+
+  Scenario: use a parameters shortcut
+  # Note that this scenario makes use of the configured default format
+  When I go to the url for "beach.png", with shortcut '100x150!'
+  Then the response should be OK
+  And the response should have mime-type 'image/jpeg'
+  And the image should have width '100'
+  And the image should have height '150'
+  And the image should have format 'jpeg'

data/features/no_processing.feature

@@ -0,0 +1,20 @@
+Feature: winner uses dragonfly to serve different kinds of files
+  In order to be a winner
+  As a potential loser
+  I want to be a winner
+
+  Background:
+    Given we are using the app for files
+
+  Scenario: Go to url for original, without extension
+    Given a stored file "sample.docx"
+    When I go to the url for "sample.docx"
+    Then the response should be OK
+    And the response should have mime-type 'application/zip'
+    And the response should have the same content as the file "sample.docx"
+
+  Scenario: Go to url for original, with extension
+    Given a stored file "sample.docx"
+    When I go to the url for "sample.docx", with format 'docx'
+    Then the response should be OK
+    And the response should have mime-type 'application/zip'

data/features/steps/dragonfly_steps.rb

@@ -1,28 +1,45 @@
+Given /^we are using the app for (\w+)$/ do |app_name|
+  $app = Dragonfly::App[app_name.to_sym]
+end
+
+Given /^a stored file "(.+?)"$/ do |name|
+  file = File.new(File.dirname(__FILE__) + "/../../samples/#{name}")
+  uid = $app.store(file)
+  TEMP_FILES[name] = uid
+end
+
 Given /^a stored image "(.+?)" with dimensions (\d+)x(\d+)$/ do |name, width, height|
   tempfile = Tempfile.new(name)
   `convert -resize #{width}x#{height}! #{SAMPLE_IMAGE_PATH} #{tempfile.path}`
-  temp_object = APP.create_object(tempfile)
-  uid = APP.datastore.store(temp_object)
-  TEMP_IMAGES[name] = uid
+  uid = $app.store(tempfile)
+  TEMP_FILES[name] = uid
+end
+
+When /^I go to the url for "(.+?)"$/ do |name|
+  make_request name
 end
 
-When /^I go to the url for image "(.+?)", with format '([^']+?)'$/ do |name, ext|
-  make_image_request name, :format => ext
+When /^I go to the url for "(.+?)", with format '([^']+?)'$/ do |name, ext|
+  make_request name, :format => ext
 end
 
-When /^I go to the url for image "(.+?)", with format '(.+?)' and resize geometry '(.+?)'$/ do |name, ext, geometry|
-  make_image_request(name,
+When /^I go to the url for "(.+?)", with format '(.+?)' and resize geometry '(.+?)'$/ do |name, ext, geometry|
+  make_request(name,
     :format => ext,
     :processing_method => :resize,
     :processing_options => {:geometry => geometry}
   )
 end
 
+When /^I go to the url for "(.+?)", with shortcut '([^']+?)'$/ do |name, arg1|
+  make_request name, arg1
+end
+
 Then "the response should be OK" do
   @response.status.should == 200
 end
 
-Then "the response should have mime-type '(.+?)'" do |mime_type|
+Then /the response should have mime-type '(.+?)'/ do |mime_type|
   @response.headers['Content-Type'].should == mime_type
 end
 
@@ -37,3 +54,7 @@ end
 Then "the image should have format '(.+?)'" do |format|
   @response.body.should have_format(format)
 end
+
+Then /^the response should have the same content as the file "([^\"]*)"$/ do |name|
+  @response.body.should == $app.fetch(TEMP_FILES[name]).data
+end

data/features/support/env.rb

@@ -3,23 +3,35 @@ require 'dragonfly'
 require 'spec/expectations'
 require 'test/unit/assertions'
 require 'ruby-debug'
-require File.dirname(__FILE__) + '/image_helpers.rb'
 require File.dirname(__FILE__) + '/../../spec/image_matchers.rb'
 
 # A hash of <name for reference> => <dragonfly uid> pairs
-TEMP_IMAGES = {}
+TEMP_FILES = {}
 
-APP = Dragonfly::App[:images]
-APP.configure_with(Dragonfly::RMagickConfiguration)
+Dragonfly::App[:images].configure_with(Dragonfly::RMagickConfiguration)
+Dragonfly::App[:files].configure do |c|
+  c.register_analyser(Dragonfly::Analysis::FileCommandAnalyser)
+  c.register_encoder(Dragonfly::Encoding::TransparentEncoder)
+end
 
 SAMPLE_IMAGE_PATH = File.dirname(__FILE__)+'/../../samples/beach.png'
 
 Before do
   # Remove temporary images
-  TEMP_IMAGES.each do |name, uid|
-    APP.datastore.destroy(uid)
-    TEMP_IMAGES.delete(name)
+  TEMP_FILES.each do |name, uid|
+    $app.datastore.destroy(uid)
+    TEMP_FILES.delete(name)
+  end
+end
+
+module MyHelpers
+  
+  def make_request(name, *args)
+    request = Rack::MockRequest.new($app)
+    url = $app.url_for(TEMP_FILES[name], *args)
+    @response = request.get(url)
   end
+  
 end
 
-World(ImageHelpers)
+World(MyHelpers)

data/generators/dragonfly_app/USAGE

@@ -11,6 +11,5 @@ This will:
     image_accessor :preview_image
     
   in your models.
-- create an empty placeholder for putting your own custom processing methods
 
 ------------------------------------------------------------------------

data/generators/dragonfly_app/dragonfly_app_generator.rb

@@ -7,7 +7,6 @@ class DragonflyAppGenerator < Rails::Generator::NamedBase
     metal_name = plural_name.camelize
     path_prefix = plural_name
     single_name = singular_name.singularize
-    custom_processor_name = "Custom#{single_name.camelize}Processing"
     
     record do |m|
       # The initializer
@@ -33,18 +32,7 @@ class DragonflyAppGenerator < Rails::Generator::NamedBase
           :app_name => app_name,
           :metal_name => metal_name,
           :path_prefix => path_prefix,
-          :random_secret => Digest::SHA1.hexdigest(Time.now.to_s),
-          :custom_processor_name => custom_processor_name
-        }
-      )
-      
-      # The custom processor
-      m.template(
-        'custom_processing.erb',
-        "lib/#{custom_processor_name.underscore}.rb",
-        :assigns => {
-          :module_name => custom_processor_name,
-          :temp_object_name => single_name
+          :random_secret => Digest::SHA1.hexdigest(Time.now.to_s)
         }
       )
       

data/generators/dragonfly_app/templates/metal_file.erb

@@ -9,7 +9,7 @@ Dragonfly::App[:<%= app_name %>].configure do |c|
   c.datastore.configure do |d|
     d.root_path = "#{Rails.root}/public/system/dragonfly/#{Rails.env}"
   end
-  c.url_handler do |u|
+  c.url_handler.configure do |u|
     u.secret = '<%= random_secret %>'
     u.path_prefix = '/<%= path_prefix %>'
   end

data/lib/dragonfly/active_record_extensions.rb

@@ -1,4 +1,5 @@
 module Dragonfly
+
   module ActiveRecordExtensions
 
     def self.extended(klass)

data/lib/dragonfly/active_record_extensions/attachment.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Dragonfly
   module ActiveRecordExtensions
     
@@ -5,6 +7,10 @@ module Dragonfly
     
     class Attachment
       
+      extend Forwardable
+      def_delegators :temp_object,
+        :data, :to_file, :file, :tempfile, :path, :process, :process!, :encode, :encode!, :transform, :transform!
+      
       def initialize(app, parent_model, attribute_name)
         @app, @parent_model, @attribute_name = app, parent_model, attribute_name
       end
@@ -38,10 +44,6 @@ module Dragonfly
         end
       end
       
-      def size
-        temp_object.size
-      end
-      
       def temp_object
         if @temp_object
           @temp_object
@@ -60,6 +62,30 @@ module Dragonfly
         end
       end
       
+      def methods(*args)
+        (super + methods_to_delegate_to_temp_object).uniq
+      end
+
+      def public_methods(*args)
+        (super + methods_to_delegate_to_temp_object).uniq
+      end
+
+      def respond_to?(method)
+        super || methods_to_delegate_to_temp_object.include?(method.to_s)
+      end
+
+      def ext
+        has_magic_attribute_for?(:ext) ? magic_attribute_for(:ext) : temp_object.ext
+      end
+
+      def name
+        has_magic_attribute_for?(:name) ? magic_attribute_for(:name) : temp_object.name
+      end
+      
+      def size
+        has_magic_attribute_for?(:size) ? magic_attribute_for(:size) : temp_object.size
+      end
+      
       private
       
       def been_assigned?
@@ -91,13 +117,17 @@ module Dragonfly
       attr_writer :temp_object
       
       def analyser
-        app.analyser
+        app.analysers
+      end
+      
+      def methods_to_delegate_to_temp_object
+        analyser.callable_methods
       end
       
       def magic_attributes
         parent_model.class.column_names.select { |name|
           name =~ /^#{attribute_name}_(.+)$/ &&
-            (analyser.has_analysis_method?($1) || %w(size name ext).include?($1))
+            (methods_to_delegate_to_temp_object.include?($1) || %w(size ext name).include?($1))
         }
       end
       
@@ -112,6 +142,22 @@ module Dragonfly
         magic_attributes.each{|attribute| parent_model.send("#{attribute}=", nil) }
       end
       
+      def has_magic_attribute_for?(property)
+        magic_attributes.include?("#{attribute_name}_#{property}")
+      end
+      
+      def magic_attribute_for(property)
+        parent_model.send("#{attribute_name}_#{property}")
+      end
+      
+      def method_missing(meth, *args, &block)
+        if methods_to_delegate_to_temp_object.include?(meth.to_s)
+          has_magic_attribute_for?(meth) ? magic_attribute_for(meth) : temp_object.send(meth, *args, &block)
+        else
+          super
+        end
+      end
+      
     end
   end
 end

data/lib/dragonfly/active_record_extensions/validations.rb

@@ -2,16 +2,36 @@ module Dragonfly
   module ActiveRecordExtensions
     module Validations
       
-      def validates_mime_type_of(*args)
-        opts = args.last
-        raise ArgumentError, "you must provide either :in => [(mime-types)] or :as => '(mime-type)' to validates_mime_type_of" unless opts.is_a?(::Hash) &&
-          (allowed_mime_types = opts[:in] || [opts[:as]])
+      private
+      
+      def validates_property(property_name, opts)
+        attrs = opts[:of] or raise ArgumentError, "you need to provide the attribute which has the property, using :of => <attribute_name>"
+        attrs = [attrs].flatten #(make sure it's an array)
+
+        raise ArgumentError, "you must provide either :in => [<value1>, <value2>..] or :as => <value>" unless opts[:in] || opts[:as]
+        allowed_values = opts[:in] || [opts[:as]]
+        
+        args = attrs + [opts]
         validates_each(*args) do |record, attr, attachment|
           if attachment
-            mime_type = attachment.temp_object.mime_type
-            record.errors.add attr, "doesn't have the correct MIME-type. It needs to be #{'one of ' if allowed_mime_types.length > 1}'#{allowed_mime_types.join('\', \'')}', but was '#{mime_type || 'unknown'}'" unless allowed_mime_types.include?(mime_type)
+            property = attachment.send(property_name)
+            record.errors.add attr, "#{property_name.to_s.humanize.downcase} is incorrect. It needs to be #{expected_values_string(allowed_values)}," +
+                                    " but was '#{property}'" unless allowed_values.include?(property)
           end
         end
+
+      end
+      
+      def validates_mime_type_of(attribute, opts)
+        validates_property :mime_type, opts.merge(:of => attribute)
+      end
+      
+      def expected_values_string(allowed_values)
+        if allowed_values.is_a?(Range)
+          "between #{allowed_values.first} and #{allowed_values.last}"
+        else
+          allowed_values.length > 1 ? "one of '#{allowed_values.join('\', \'')}'" : "'#{allowed_values.first.to_s}'"
+        end
       end
 
     end