dragonfly 0.6.2 → 0.7.0

data/extra_docs/Shortcuts.md

@@ -1,118 +0,0 @@
-Shortcuts
-=========
-
-When you call {Dragonfly::App#fetch fetch}, {Dragonfly::ExtendedTempObject#transform transform},
-{Dragonfly::UrlHandler#url_for url_for}, (or {Dragonfly::ActiveRecordExtensions::Attachment#url url} on an ActiveRecord attachment), you can specify all the job parameters
-necessary to fetch the appropriate content.
-
-The parameters are the following:
-
-  - `:uid` - the uid used by the datastore to retrieve the data (was returned when stored)
-  - `:processing_method` - the method used to do the processing
-  - `:processing_options` - options hash passed to the processing method
-  - `:format` - the format to encode the data with, e.g. 'png'
-  - `:encoding` - an options hash passed to the encoder for other options, e.g. bitrate, etc.
-
-Say we have an app configured with the {Dragonfly::Config::RMagickImages RMagickImages}
-
-    app = Dragonfly::App[:my_app]
-    app.configure_with(Dragonfly::Config::RMagickImages)
-
-we can call things like
-
-    app.fetch 'some_uid',
-      :processing_method => :resize_and_crop,
-      :processing_options => {:width => 100, :height => 50, :gravity => 'ne'},
-      :format => :jpg,
-      :encoding => {:some => 'option'}           # => gets a processed and encoded temp_object
-    
-    app.url_for 'some_uid',
-      :processing_method => :resize_and_crop,
-      :processing_options => {:width => 100, :height => 50, :gravity => 'ne'},
-      :format => :jpg,
-      :encoding => {:some => 'option'}           # => "/images/some_uid.tif?m=resize_and_crop&o[width]=...."
-
-YIKES!!!!!
-
-That's an awful lot of code every time, especially if we reuse the same parameters over and over.
-That's why for the arguments after the uid, you can register {Dragonfly::Parameters parameter shortcuts}.
-
-Simple shortcuts
-----------------
-If we were to use the parameters in the example above a number of times, we could register a simple named shortcut, say 'thumb', using a symbol.
-
-    app.parameters.add_shortcut(:thumb,
-      :processing_method => :resize_and_crop,
-      :processing_options => {:width => 100, :height => 50, :gravity => 'ne'},
-      :format => :jpg,
-      :encoding => {:some => 'option'}
-    )
-
-We can now use this named shortcut, `:thumb`, in place of the parameters elsewhere
-
-    app.fetch 'some_uid', :thumb           # => gets a processed and encoded temp_object as before    
-    app.url_for 'some_uid', :thumb         # => "/images/some_uid.tif?m=resize_and_crop&o[width]=....", as before
-    
-Complex shortcuts
------------------
-Rather than create a new named shortcut for every different set of parameters, we can make life easier by defining shortcuts
-which match a set of arguments, then form parameters from them.
-
-For example, take the shortcut
-
-    app.parameters.add_shortcut(/\d+x\d+/, Symbol) do |geometry, format|
-      {
-        :processing_method => :my_resize_method,
-        :processing_options => {:geometry => geometry},
-        :format => format
-      }
-    end
-
-It will match where there are two arguments, a string matching `/\d+x\d+/` and a symbol, and convert to a hash of job parameters.
-Note that the matching arguments are yielded to the block.
-So, for example,
-
-    app.url_for('some_uid', '100x50', :jpg)
-    
-generates the same url as if we'd used
-
-    app.url_for 'some_uid',
-      :processing_method => :my_resize_method,
-      :processing_options => {:geometry => 100},
-      :format => :jpg
-
-The following examples would not match
-
-    app.url_for('some_uid', '100xg50', :jpg)           # '100xg50' doesn't match /\d+x\d+/
-    app.url_for('some_uid', '100x50', 'jpg')           # 'jpg' is not a Symbol
-    app.url_for('some_uid', '100x50')                  # not enough arguments
-    app.url_for('some_uid', '100x50', :jpg, 4)         # too many arguments
-
-The arguments are matched using the `===` operator (as used in `case` statements), which is why, for example, `:jpg` matches `Symbol`.
-
-Regexp shortcuts
-----------------
-If we register a complex shortcut as a single regexp, then the match data is also yielded, for convenience.
-
-    app.parameters.add_shortcut(/(\d+)x(\d+)/) do |geometry, match_data|
-      {
-        :processing_method => :my_resize_method,
-        :processing_options => {:width => match_data[1], :height => match_data[2]}
-      }
-    end
-
-
-Default parameters
-------------------
-If we've configured a default parameter, e.g.
-
-    app.parameters.default_format = :jpg
-    
-then this will be used in these methods whenever that parameter is not given, such as in the example above.
-
-Avoiding processing/encoding
-----------------------------
-If `:processing_method` is set to nil, then no processing takes place when methods like {Dragonfly::App#fetch fetch}, {Dragonfly::ExtendedTempObject#transform transform},
-{Dragonfly::UrlHandler#url_for url_for}, and {Dragonfly::ActiveRecordExtensions::Attachment#url url} are called.
-
-Similarly, if `:format` is set to nil, then no encoding takes place.

data/extra_docs/UsingWithRails.md

@@ -1,81 +0,0 @@
-Using With Rails
-================
-
-Dragonfly works with both Rails 2.3 and Rails 3.
-
-The main way to use Dragonfly with Rails is as a {Dragonfly::Middleware middleware}.
-
-1. Setting up
-------------------
-
-The quick way
--------------
-There is a ready-made file which sets up Dragonfly for image processing for your rails app.
-If image resizing, etc. is all you want to do, then put this in an initializer, e.g config/initializers/dragonfly.rb:
-
-    require 'dragonfly/rails/images'
-
-This file initializes a dragonfly app, configures it to use rmagick processing, encoding, etc.,
-registers the app so that you can use ActiveRecord accessors, and inserts it into the Rails middleware stack.
-
-The more explicit way
----------------------
-You can do the above explicitly.
-
-config/initializers/dragonfly.rb:
-
-    require 'dragonfly'
-
-    app = Dragonfly::App[:images]
-    app.configure_with(Dragonfly::Config::RailsImages)
-    
-    # Define the method 'image_accessor' in ActiveRecord models
-    Dragonfly.active_record_macro(:image, app)
-
-environment.rb (application.rb in Rails 3):
-
-    config.middleware.insert_after 'Rack::Lock', 'Dragonfly::Middleware', :images
-    config.middleware.insert_before 'Dragonfly::Middleware', 'Rack::Cache', {
-      :verbose     => true,
-      :metastore   => "file:#{Rails.root}/tmp/dragonfly/cache/meta",
-      :entitystore => "file:#{Rails.root}/tmp/dragonfly/cache/body"
-    }
-
-2. Gem dependencies
--------------------
-
-Tell Rails about the gem dependencies in the usual way:
-
-For Rails 2.3 add this to config/environment.rb:
-
-    config.gem 'rmagick',    :lib => 'RMagick'      # only if used
-    config.gem 'rack-cache', :lib => 'rack/cache'   # only if used
-    config.gem 'dragonfly'
-
-For Rails 3 add it to the Gemfile, e.g.:
-
-    gem 'rmagick',    :require => 'RMagick'         # only if used
-    gem 'rack-cache', :require => 'rack/cache'      # only if used
-    gem 'dragonfly'
-
-You only need the lines above for {http://tomayko.com/src/rack-cache/ rack-cache} and
-{http://rmagick.rubyforge.org/ rmagick} if you've used the file 'dragonfly/rails/images', or manually used them yourself.
-
-3. Use it!
-----------
-
-Now that you have a parasitic Dragonfly app living inside your Rails app, you can upload media to your models, display/play around with them, etc.
-
-To see what you can do with the active record accessors, see {file:ActiveRecord}.
-
-For more info about general Dragonfly setup, including avoiding denial-of-service attacks, see {file:GettingStarted}.
-
-Extra Config
-------------
-There are one or two config options you may commonly want to tweak.
-In this case, add something like the following to your initializer:
-
-    Dragonfly::App[:images].configure do |c|
-      c.url_handler.path_prefix = '/attachments'   # configures where the Dragonfly app is served from - default '/media'
-      c.url_handler.secret = 'PUT A SECRET HERE!!' # for protecting from Denial-Of-Service attacks
-    end

data/features/rails_3.0.0.beta3.feature

@@ -1,7 +0,0 @@
-Feature: champion uses dragonfly in his Rails 3.0.0.beta3 application
-  In order to be a champion
-  A user uses dragonfly in his Rails 3.0.0.beta3 application
-
-  Scenario: Set up dragonfly using initializer
-    Given a Rails 3.0.0.beta3 application set up for using dragonfly
-    Then the cucumber features in my Rails 3.0.0.beta3 app should pass

data/fixtures/rails_3.0.0.beta3/template.rb

@@ -1,16 +0,0 @@
-gem 'rack-cache', :require => 'rack/cache'
-gem 'rmagick', :require => 'RMagick'
-
-gem 'capybara'
-gem 'cucumber-rails'
-gem 'cucumber', '0.7.2'
-gem 'rspec-rails', '2.0.0.beta.8'
-
-generate 'cucumber:skeleton'
-
-generate 'scaffold albums cover_image_uid:string'
-rake 'db:migrate'
-
-# Copy over all files from the template dir
-files_dir = File.expand_path(File.dirname(__FILE__) + '/../../files')
-run "cp -r #{files_dir}/** ."

data/lib/dragonfly/active_record_extensions/attachment.rb

@@ -1,170 +0,0 @@
-require 'forwardable'
-
-module Dragonfly
-  module ActiveRecordExtensions
-    
-    class PendingUID; def to_s; 'PENDING'; end; end
-    
-    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
-      
-      def assign(value)
-        if value.nil?
-          self.temp_object = nil
-          self.uid = nil
-          reset_magic_attributes
-        else
-          self.temp_object = app.create_object(value)
-          self.uid = PendingUID.new
-          set_magic_attributes
-        end
-        value
-      end
-
-      def destroy!
-        app.datastore.destroy(previous_uid) if previous_uid
-      rescue DataStorage::DataNotFound => e
-        app.log.warn("*** WARNING ***: tried to destroy data with uid #{previous_uid}, but got error: #{e}")
-      end
-      
-      def fetch(*args)
-        app.fetch(uid, *args)
-      end
-      
-      def save!
-        destroy! if uid_changed?
-        self.uid = app.datastore.store(temp_object) if has_data_to_store?
-      end
-      
-      def temp_object
-        if @temp_object
-          @temp_object
-        elsif been_persisted?
-          @temp_object = fetch
-        end
-      end
-      
-      def to_value
-        self if been_assigned?
-      end
-      
-      def url(*args)
-        unless uid.nil? || uid.is_a?(PendingUID)
-          app.url_for(uid, *args)
-        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_method_name)
-      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?
-        uid
-      end
-      
-      def been_persisted?
-        uid && !uid.is_a?(PendingUID)
-      end
-      
-      def has_data_to_store?
-        uid.is_a?(PendingUID)
-      end
-      
-      def uid_changed?
-        parent_model.send("#{attribute_name}_uid_changed?")
-      end
-      
-      def uid=(uid)
-        parent_model.send("#{attribute_name}_uid=", uid)
-      end
-      
-      def uid
-        parent_model.send("#{attribute_name}_uid")
-      end
-      
-      def previous_uid
-        parent_model.send("#{attribute_name}_uid_was")
-      end
-      
-      attr_reader :app, :parent_model, :attribute_name
-      
-      attr_writer :temp_object
-      
-      def analyser
-        app.analysers
-      end
-      
-      def methods_to_delegate_to_temp_object
-        analyser.delegatable_methods
-      end
-      
-      def can_delegate_to_temp_object?(meth)
-        methods_to_delegate_to_temp_object.include?(meth.to_method_name)
-      end
-      
-      def magic_attributes
-        parent_model.class.column_names.select { |name|
-          name =~ /^#{attribute_name}_(.+)$/ &&
-            (can_delegate_to_temp_object?($1) || %w(size ext name).include?($1))
-        }
-      end
-      
-      def set_magic_attributes
-        magic_attributes.each do |attribute|
-          method = attribute.sub("#{attribute_name}_", '')
-          parent_model.send("#{attribute}=", temp_object.send(method))
-        end
-      end
-      
-      def reset_magic_attributes
-        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 can_delegate_to_temp_object?(meth)
-          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/analyser_list.rb

@@ -1,9 +0,0 @@
-module Dragonfly
-  class AnalyserList
-    include Delegator
-    
-    def initialize(app)
-      @app = app
-    end
-  end
-end

data/lib/dragonfly/analysis/base.rb

@@ -1,10 +0,0 @@
-module Dragonfly
-  module Analysis
-    class Base
-
-      include BelongsToApp
-      include Delegatable
-
-    end
-  end
-end

data/lib/dragonfly/belongs_to_app.rb

@@ -1,24 +0,0 @@
-require 'logger'
-
-module Dragonfly
-  module BelongsToApp
-    
-    # Exceptions
-    class NotConfigured < RuntimeError; end
-    
-    attr_writer :app
-    
-    def app
-      @app || raise(NotConfigured, "#{self.inspect} has no app set")
-    end
-    
-    def app_set?
-      !!@app
-    end
-    
-    def log
-      app_set? ? app.log : (@log ||= Logger.new(STDOUT))
-    end
-    
-  end
-end