dragonfly 0.6.2 → 0.7.0

data/lib/dragonfly/config/heroku_rails_images.rb

@@ -1,23 +0,0 @@
-module Dragonfly
-  module Config
-    
-    module HerokuRailsImages
-    
-      def self.apply_configuration(app, bucket_name)
-        app.configure_with(RMagickImages)
-        app.configure_with(RailsDefaults) do |c|
-          # Use S3 for production
-          if ::Rails.env == 'production'
-            c.datastore = Dragonfly::DataStorage::S3DataStore.new
-            c.datastore.configure do |d|
-              d.bucket_name = bucket_name
-              d.access_key_id = ENV['S3_KEY'] || raise("ENV variable 'S3_KEY' needs to be set - use\n\theroku config:add S3_KEY=XXXXXXXXX")
-              d.secret_access_key = ENV['S3_SECRET'] || raise("ENV variable 'S3_SECRET' needs to be set - use\n\theroku config:add S3_SECRET=XXXXXXXXX")
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/dragonfly/config/r_magick_images.rb

@@ -1,69 +0,0 @@
-module Dragonfly
-  module Config
-    
-    # RMagickImages is a saved configuration for Dragonfly apps, which does the following:
-    # - registers an rmagick analyser
-    # - registers an rmagick processor
-    # - registers an rmagick encoder
-    # - adds parameter shortcuts like '280x140!', etc.
-    # Look at the source code for apply_configuration to see exactly how it configures the app.
-    module RMagickImages
-    
-      def self.apply_configuration(app)
-        app.configure do |c|
-          c.register_analyser(Analysis::FileCommandAnalyser)
-          c.register_analyser(Analysis::RMagickAnalyser)
-          c.register_processor(Processing::RMagickProcessor)
-          c.register_encoder(Encoding::RMagickEncoder)
-          c.parameters.configure do |p|
-            p.default_format = :jpg
-            # Standard resizing like '30x40!', etc.
-            p.add_shortcut(Symbol) do |format|
-              {:format => format}
-            end
-            p.add_shortcut(/^\d*x\d*[><%^!]?$|^\d+@$/) do |geometry, match_data|
-              {
-                :processing_method => :resize,
-                :processing_options => {:geometry => geometry}
-              }
-            end
-            # Cropped resizing like '20x50#ne'
-            p.add_shortcut(/^(\d+)x(\d+)#(\w{1,2})?/) do |geometry, match_data|
-              {
-                :processing_method => :resize_and_crop,
-                :processing_options => {:width => match_data[1], :height => match_data[2], :gravity => match_data[3]}
-              }
-            end
-            # Cropping like '30x30+10+10ne'
-            p.add_shortcut(/^(\d+)x(\d+)([+-]\d+)([+-]\d+)(\w{1,2})?/) do |geometry, match_data|
-              {
-                :processing_method => :crop,
-                :processing_options => {
-                  :width => match_data[1],
-                  :height => match_data[2],
-                  :x => match_data[3],
-                  :y => match_data[4],
-                  :gravity => match_data[5]
-                }
-              }
-            end
-            p.add_shortcut(/^\d*x/, Symbol) do |geometry, format|
-              p.hash_from_shortcut(geometry).merge(:format => format)
-            end
-            p.add_shortcut(:rotate, Numeric) do |_, amount|
-              {
-                :processing_method => :rotate,
-                :processing_options => {:amount => amount, :background_colour => '#0000'}
-              }
-            end
-            p.add_shortcut(:rotate, Numeric, Symbol) do |a, b, format|
-              p.hash_from_shortcut(a,b).merge(:format => format)
-            end
-          end
-        end
-    
-      end
-    
-    end  
-  end
-end

data/lib/dragonfly/config/r_magick_text.rb

@@ -1,25 +0,0 @@
-module Dragonfly
-  module Config
-
-    module RMagickText
-
-      def self.apply_configuration(app)
-        app.configure do |c|
-          c.datastore = DataStorage::TransparentDataStore.new
-          c.register_analyser(Analysis::FileCommandAnalyser)
-          c.register_processor(Processing::RMagickTextProcessor)
-          c.register_encoder(Encoding::RMagickEncoder)
-          c.parameters.add_shortcut :text, Hash do |_, options|
-            {
-              :processing_method => :text,
-              :processing_options => options,
-              :format => :png
-            }
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/lib/dragonfly/config/rails_images.rb

@@ -1,13 +0,0 @@
-module Dragonfly
-  module Config
-    
-    module RailsImages
-    
-      def self.apply_configuration(app)
-        app.configure_with(RMagickImages)
-        app.configure_with(RailsDefaults)
-      end
-
-    end
-  end
-end

data/lib/dragonfly/data_storage/base.rb

@@ -1,21 +0,0 @@
-module Dragonfly
-  module DataStorage
-    class Base
-
-      include BelongsToApp
-
-      def store(temp_object)
-        raise NotImplementedError
-      end
-
-      def retrieve(uid)
-        raise NotImplementedError
-      end
-      
-      def destroy(uid)
-        raise NotImplementedError
-      end
-
-    end
-  end
-end

data/lib/dragonfly/data_storage/base64_data_store.rb

@@ -1,23 +0,0 @@
-require "base64"
-
-module Dragonfly
-  module DataStorage
-
-    class Base64DataStore < Base
-
-      def store(temp_object)
-        Base64.encode64(temp_object.data)
-      end
-
-      def retrieve(uid)
-        Base64.decode64(uid)
-      end
-      
-      def destroy(uid)
-        # Nothing to destroy!
-      end
-      
-    end
-    
-  end
-end

data/lib/dragonfly/data_storage/transparent_data_store.rb

@@ -1,21 +0,0 @@
-module Dragonfly
-  module DataStorage
-
-    class TransparentDataStore < Base
-      
-      def store(temp_object)
-        temp_object.data
-      end
-
-      def retrieve(uid)
-        uid
-      end
-      
-      def destroy(uid)
-        # Nothing to destroy!
-      end
-      
-    end
-    
-  end
-end

data/lib/dragonfly/delegatable.rb

@@ -1,14 +0,0 @@
-module Dragonfly
-  module Delegatable
-
-    def delegatable_methods
-      if @delegatable_methods
-        @delegatable_methods
-      else
-        ancestors = self.class.ancestors
-        @delegatable_methods = ancestors[0...ancestors.index(Delegatable)].map{|i| i.instance_methods(false) }.flatten
-      end
-    end
-
-  end
-end

data/lib/dragonfly/delegator.rb

@@ -1,62 +0,0 @@
-module Dragonfly
-  module Delegator
-    
-    include BelongsToApp
-    
-    # This gets raised if no delegated objects are able to handle
-    # the method call, even though they respond to that method.
-    class UnableToHandle < StandardError; end
-    
-    def register(klass, *args, &block)
-      object = klass.new(*args)
-      object.configure(&block) if block
-      object.app = self.app if app_set? && object.is_a?(BelongsToApp)
-      registered_objects << object
-      object
-    end
-    
-    def unregister(klass)
-      registered_objects.delete_if{|obj| obj.is_a?(klass) }
-    end
-    
-    def unregister_all
-      self.registered_objects = []
-    end
-    
-    def registered_objects
-      @registered_objects ||= []
-    end
-    
-    def delegate(meth, *args)
-      registered_objects.reverse.each do |object|
-        catch :unable_to_handle do
-          return object.send(meth, *args) if object.respond_to?(meth)
-        end
-      end
-      # If the code gets here, then none of the registered objects were able to handle the method call
-      raise UnableToHandle, "None of the objects registered with #{self} were able to deal with the method call " +
-        "#{meth}(#{args.map{|a| a.inspect[0..100]}.join(',')}). You need to register one that can."
-    end
-    
-    def delegatable_methods
-      registered_objects.map{|a| a.delegatable_methods }.flatten.uniq
-    end
-    
-    def has_delegatable_method?(method)
-      delegatable_methods.include?(method.to_method_name)
-    end
-    
-    private
-    
-    attr_writer :registered_objects
-    
-    def method_missing(meth, *args)
-      if has_delegatable_method?(meth)
-        delegate(meth, *args)
-      else
-        super
-      end
-    end
-    
-  end
-end

data/lib/dragonfly/encoder_list.rb

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

data/lib/dragonfly/encoding/base.rb

@@ -1,14 +0,0 @@
-module Dragonfly
-  module Encoding    
-    class Base
-
-      include BelongsToApp
-      include Delegatable
-
-      def encode(*args)
-        throw :unable_to_handle
-      end
-
-    end
-  end
-end

data/lib/dragonfly/encoding/transparent_encoder.rb

@@ -1,14 +0,0 @@
-module Dragonfly
-  module Encoding
-    
-    class TransparentEncoder < Base
-      
-      # Does nothing
-      def encode(temp_object, format, encoding={})
-        temp_object
-      end
-      
-    end
-    
-  end
-end

data/lib/dragonfly/extended_temp_object.rb

@@ -1,120 +0,0 @@
-module Dragonfly
-  
-  # An ExtendedTempObject is just a TempObject that belongs to a Dragonfly App.
-  # 
-  # Because of this, it can make use of the app's registered processors, encoders and analysers
-  #
-  # Analysis methods can be accessed on the object itself, e.g. for a registered analysis method 'width', we have
-  #   temp_object.width    # ===> 280
-  #
-  # Processing methods can be accessed using 'process', e.g. for a registered process method 'resize', we have
-  #   temp_object.process(:resize, {:some => 'option'})    # ===> processed ExtendedTempObject
-  #
-  # Similarly, encoding with the method 'encode' delegates to the app's registered encoders
-  #   temp_object.encode(:png, {:some => 'option'})    # ===> encoded ExtendedTempObject
-  #
-  # We can use bang methods to operate on the temp_object itself, rather than return a new one:
-  #   temp_object.process!(:resize, {:some => 'option'})
-  #   temp_object.encode!(:png, {:some => 'option'})
-  #
-  # You can make use of the app's registered parameter shortcuts (for processing and encoding in one go) using 'transform', e.g.
-  #   temp_object.transform('300x200', :gif)       # ===> return a new processed and encoded ExtendedTempObject
-  #   temp_object.transform!('300x200', :gif)      # ===> operate on self
-  class ExtendedTempObject < TempObject
-    
-    include BelongsToApp
-    
-    def initialize(obj, app)
-      super(obj)
-      self.app = app
-      @cache = {}
-    end
-    
-    def process(processing_method, *args)
-      self.class.new(processor.send(processing_method, self, *args), app)
-    end
-    
-    def process!(processing_method, *args)
-      modify_self!(processor.send(processing_method, self, *args))
-    end
-
-    def encode(*args)
-      self.class.new(encoder.encode(self, *args), app)
-    end
-    
-    def encode!(*args)
-      modify_self!(encoder.encode(self, *args))
-    end
-    
-    def transform(*args)
-      args.any? ? dup.transform!(*args) : self
-    end
-    
-    def transform!(*args)
-      parameters = parameters_class.from_args(*args)
-      process!(parameters.processing_method, parameters.processing_options) unless parameters.processing_method.nil?
-      encode!(parameters.format, parameters.encoding) unless parameters.format.nil?
-      self
-    end
-    
-    # Modify methods, public_methods and respond_to?, because method_missing
-    # allows methods from the analyser
-    
-    def methods(*args)
-      (super + analyser.delegatable_methods).uniq
-    end
-    
-    def public_methods(*args)
-      (super + analyser.delegatable_methods).uniq
-    end
-    
-    def respond_to?(method)
-      super || analyser.has_delegatable_method?(method)
-    end
-
-    private
-
-    attr_reader :cache
-    
-    def flush_cache!
-      @cache = {}
-    end
-
-    def reset!
-      super
-      flush_cache!
-    end
-
-    def method_missing(method, *args, &block)
-      if analyser.has_delegatable_method?(method)
-        # Define the method on the instance so we don't use method_missing next time
-        class << self; self; end.class_eval do
-          define_method method do
-            cache[method] ||= analyser.delegate(method, self)
-          end
-        end
-        # Now that it's defined (for next time)
-        send(method)
-      else
-        super
-      end
-    end
-    
-    def analyser
-      app.analysers
-    end
-    
-    def processor
-      app.processors
-    end
-    
-    def encoder
-      app.encoders
-    end
-    
-    def parameters_class
-      app.parameters_class
-    end
-    
-  end
-end