dragonfly 0.6.2 → 0.7.0

data/lib/dragonfly/parameters.rb

@@ -1,163 +0,0 @@
-require 'rack'
-
-module Dragonfly
-  class Parameters
-    
-    # Exceptions
-    class InvalidParameters < RuntimeError; end
-    class InvalidShortcut < RuntimeError; end
-
-    # Class methods
-    class << self
-      
-      include Configurable
-      
-      configurable_attr :default_processing_method
-      configurable_attr :default_processing_options, {}
-      configurable_attr :default_format
-      configurable_attr :default_encoding, {}
-      
-      def new_with_defaults(attributes={})
-        new({
-          :processing_method => default_processing_method,
-          :processing_options => default_processing_options,
-          :format => default_format,
-          :encoding => default_encoding
-        }.merge(attributes))
-      end
-      
-      def add_shortcut(*args, &block)
-        if block
-          block_shortcuts_of_length(args.length).unshift([args, block])
-        else
-          shortcut_name, attributes = args
-          simple_shortcuts[shortcut_name] = attributes
-        end
-      end
-      configuration_method :add_shortcut
-      
-      def hash_from_shortcut(*args)
-        if attributes = matching_simple_shortcut(args)
-          attributes
-        elsif attributes = matching_block_shortcut(args)
-          attributes
-        else
-          raise InvalidShortcut, "No shortcut was found matching (#{args.map{|a| a.inspect }.join(', ')})"
-        end
-      end
-      configuration_method :hash_from_shortcut
-      
-      def from_shortcut(*args)
-        new_with_defaults(hash_from_shortcut(*args))
-      end
-      
-      def from_args(*args)
-        if args.empty? then new_with_defaults
-        elsif args.length == 1 && args.first.is_a?(Hash) then new_with_defaults(args.first)
-        elsif args.length == 1 && args.first.is_a?(Parameters) then args.first.dup
-        else from_shortcut(*args)
-        end
-      end
-      
-      private
-      
-      def simple_shortcuts
-        @simple_shortcuts ||= {}
-      end
-      
-      # block_shortcuts is actually a hash (keyed on the number of
-      # arguments) of arrays (of argument lists)
-      def block_shortcuts
-        @block_shortcuts ||= {}
-      end
-      
-      def block_shortcuts_of_length(arg_length)
-        block_shortcuts[arg_length] ||= []
-      end
-      
-      def matching_simple_shortcut(args)
-        if args.length == 1 && args.first.is_a?(Symbol)
-          simple_shortcuts[args.first]
-        end
-      end
-      
-      def matching_block_shortcut(args)
-        block_shortcuts_of_length(args.length).each do |(args_to_match, block)|
-          if all_args_match?(args, args_to_match)
-            # If the block shortcut arg is a single regexp, then also yield the match data
-            if args_to_match.length == 1 && args_to_match.first.is_a?(Regexp)
-              match_data = args_to_match.first.match(args.first)
-              return block.call(args.first, match_data)
-            # ...otherwise just yield the args
-            else
-              return block.call(*args)
-            end
-          end
-        end
-        nil
-      end
-      
-      def all_args_match?(args, args_to_match)
-        (0...args.length).inject(true){|current_result, i| current_result &&= args_to_match[i] === args[i] }
-      end
-
-    end
-
-    # Instance methods
-
-    def initialize(attributes={})
-      attributes = attributes.dup
-      self.uid                = attributes.delete(:uid)
-      self.processing_method  = attributes.delete(:processing_method)
-      self.processing_options = attributes.delete(:processing_options) || {}
-      self.format             = attributes.delete(:format)
-      self.encoding           = attributes.delete(:encoding) || {}
-      raise ArgumentError, "Parameters doesn't recognise the following parameters: #{attributes.keys.join(', ')}" if attributes.any?
-    end
-
-    attr_accessor :uid, :processing_method, :processing_options, :format, :encoding
-    
-    def [](attribute)
-      send(attribute)
-    end
-    
-    def []=(attribute, value)
-      send("#{attribute}=", value)
-    end
-    
-    def ==(other_parameters)
-      self.to_hash == other_parameters.to_hash
-    end
-    
-    def generate_sha(salt, sha_length)
-      Digest::SHA1.hexdigest("#{to_sorted_array}#{salt}")[0...sha_length]
-    end
-    
-    def unique_signature
-      generate_sha('I like cheese', 10)
-    end
-
-    def to_hash
-      {
-        :uid => uid,
-        :processing_method => processing_method,
-        :processing_options => processing_options,
-        :format => format,
-        :encoding => encoding
-      }
-    end
-
-    private
-    
-    def to_sorted_array
-      [
-        uid,
-        format.to_s,
-        processing_method.to_s,
-        processing_options.sort{|a,b| a[0].to_s <=> b[0].to_s },
-        encoding.sort{|a,b| a[0].to_s <=> b[0].to_s }
-      ]
-    end
-
-  end
-end

data/lib/dragonfly/processing/base.rb

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

data/lib/dragonfly/processor_list.rb

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

data/lib/dragonfly/url_handler.rb

@@ -1,147 +0,0 @@
-require 'digest/sha1'
-require 'rack'
-
-module Dragonfly
-  class UrlHandler
-    
-    # Exceptions
-    class IncorrectSHA < RuntimeError; end
-    class SHANotGiven < RuntimeError; end
-    class UnknownUrl < RuntimeError; end
-    
-    include Rack::Utils
-    include Configurable
-
-    MAPPINGS = {
-      :processing_method => 'm',
-      :processing_options => 'o',
-      :encoding => 'e',
-      :sha => 's'
-    }
- 
-    configurable_attr :protect_from_dos_attacks, true
-    configurable_attr :secret, 'This is a secret!'
-    configurable_attr :sha_length, 16
-    configurable_attr :path_prefix, ''
-
-    def initialize(parameters_class = Parameters)
-      @parameters_class = parameters_class
-    end
-
-    def url_for(uid, *args)
-      parameters = parameters_class.from_args(*args)
-      parameters.uid = uid
-      parameters_to_url(parameters)
-    end
-
-    def url_to_parameters(path, query_string)
-      path = unescape(path)
-      validate_format!(path)
-      path = remove_path_prefix(path)
-      query = parse_nested_query(query_string)
-      attributes = {
-        :uid => extract_uid(path, query),
-        :processing_method => extract_processing_method(path, query),
-        :processing_options => extract_processing_options(path, query),
-        :format => extract_format(path, query),
-        :encoding => extract_encoding(path, query)
-      }.reject{|k,v| v.nil? }
-      parameters = parameters_class.new(attributes)
-      validate_parameters(parameters, query)
-      parameters
-    end
-
-    def parameters_to_url(parameters)
-      query_string = [:processing_method, :processing_options, :encoding].map do |attribute|
-        build_query(MAPPINGS[attribute] => parameters[attribute]) unless parameters[attribute].blank?
-      end.compact.join('&')
-      sha_string = "&#{MAPPINGS[:sha]}=#{sha_from_parameters(parameters)}" if protect_from_dos_attacks?
-      ext = ".#{parameters.format}" if parameters.format
-      url = "#{path_prefix}/#{escape_except_for_slashes(parameters.uid)}#{ext}?#{query_string}#{sha_string}"
-      url.sub!(/\?$/,'')
-      url
-    end
-
-    private
-
-    def remove_path_prefix(path)
-      path.sub(path_prefix, '')
-    end
-
-    def extract_uid(path, query)
-      path.sub(/^\//,'').sub(/\.[^.]+$/, '')
-    end
-  
-    def extract_processing_method(path, query)
-      query[MAPPINGS[:processing_method]]
-    end
-  
-    def extract_processing_options(path, query)
-      processing_options = query[MAPPINGS[:processing_options]]
-      symbolize_keys(processing_options) if processing_options
-    end
-  
-    def extract_format(path, query)
-      bits = path.sub(/^\//,'').split('.')
-      bits.last if bits.length > 1
-    end
-  
-    def extract_encoding(path, query)
-      encoding = query[MAPPINGS[:encoding]]
-      symbolize_keys(encoding) if encoding
-    end
-
-    attr_reader :parameters_class
-
-    def symbolize_keys(hash)
-      hash.inject({}) do |memo, (key, value)|
-        memo[key.to_sym] = hash[key]
-        memo
-      end
-    end
-
-    def validate_parameters(parameters, query)
-      if protect_from_dos_attacks?
-        sha = query[MAPPINGS[:sha]]
-        raise SHANotGiven, "You need to give a SHA" if sha.nil?
-        raise IncorrectSHA, "The SHA parameter you gave is incorrect" if sha_from_parameters(parameters) != sha
-      end
-    end
-    
-    def protect_from_dos_attacks?
-      protect_from_dos_attacks
-    end
-    
-    def sha_from_parameters(parameters)
-      parameters.generate_sha(secret, sha_length)
-    end
-    
-    
-    # Annoyingly, the 'build_query' in Rack::Utils doesn't seem to work
-    # properly for nested parameters/arrays
-    # Taken from http://github.com/sinatra/sinatra/commit/52658061d1205753a8afd2801845a910a6c01ffd
-    def build_query(value, prefix = nil)
-      case value
-      when Array
-        value.map { |v|
-          build_query(v, "#{prefix}[]")
-        } * "&"
-      when Hash
-        value.map { |k, v|
-          build_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-        } * "&"
-      else
-        "#{prefix}=#{escape(value)}"
-      end
-    end
-    
-    def escape_except_for_slashes(string)
-      string.split('/').map{|s| escape(s) }.join('/')
-    end
-    
-    def validate_format!(path)
-      raise UnknownUrl, "path '#{path}' not found" unless path =~ %r(^#{path_prefix}/[^.]+)
-    end
-    
-  end
-end

data/spec/dragonfly/active_record_extensions/attachment_spec.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe Dragonfly::ActiveRecordExtensions::Attachment do  
-
-  # See model_spec - tests are less brittle if doing mini integration tests
-  # at the model level
-
-end

data/spec/dragonfly/active_record_extensions/migration.rb

@@ -1,42 +0,0 @@
-# Seems to blow up on Rails 3 without this
-begin
-  require 'active_support/all'
-rescue LoadError => e
-  puts "Couldn't load activesupport: #{e}"
-end
-
-class MigrationForTest < ActiveRecord::Migration
-  
-  def self.up
-    create_table :items, :force => true do |t|
-      t.string  :title
-      t.string  :preview_image_uid
-      t.string  :preview_image_some_analyser_method
-      t.integer :preview_image_size
-      t.string  :preview_image_name
-      t.string  :preview_image_ext
-      t.string  :preview_image_blah_blah
-      t.string  :other_image_uid
-      t.string  :yet_another_image_uid
-      t.string  :otra_imagen_uid
-      t.string  :trailer_video_uid
-      t.timestamps
-    end
-    
-    create_table :cars do |t|
-      t.string :image_uid
-      t.string :reliant_image_uid
-      t.string :type
-    end
-
-    create_table :photos do |t|
-      t.string :image_uid
-    end
-
-  end
-
-  def self.down
-    drop_table :items
-  end
-
-end

data/spec/dragonfly/active_record_extensions/models.rb

@@ -1,6 +0,0 @@
-class Item < ActiveRecord::Base
-end
-class Car < ActiveRecord::Base
-end
-class Photo < ActiveRecord::Base
-end

data/spec/dragonfly/active_record_extensions/spec_helper.rb

@@ -1,24 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'ginger'
-require 'active_record'
-
-DB_FILE = File.expand_path(File.dirname(__FILE__)+'/db.sqlite3')
-
-%w{migration models}.each do |file|
-  require "#{File.dirname(__FILE__)}/#{file}"
-end 
-
-Spec::Runner.configure do |config|
-  
-  config.before(:all) do
-    FileUtils.rm_f(DB_FILE)
-    ActiveRecord::Base.establish_connection(
-       :adapter => "sqlite3",
-       :database  => DB_FILE
-     )
-     MigrationForTest.verbose = false
-     MigrationForTest.up
-  end
-  
-end

data/spec/dragonfly/belongs_to_app_spec.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-class Testoast
-  include Dragonfly::BelongsToApp
-end
-
-describe Dragonfly::BelongsToApp do
-  
-  before(:each) do
-    @object = Testoast.new
-  end
-
-  describe "when the app is not set" do
-    it "should raise an error if the app is accessed" do
-      lambda{
-        @object.app
-      }.should raise_error(Dragonfly::BelongsToApp::NotConfigured)
-    end
-    it "should say it's not set" do
-      @object.app_set?.should be_false
-    end
-    it "should still return a log" do
-      @object.log.should be_a(Logger)
-    end
-    it "should cache the log" do
-      @object.log.should == @object.log
-    end
-    it "should return the app's log if it's subsequently set" do
-      @object.log.should be_a(Logger)
-      @object.app = (app = mock('app', :log => mock))
-      @object.log.should == app.log
-    end
-  end
-
-  describe "when the app is set" do
-    before(:each) do
-      @app = mock('app', :log => mock)
-      @object.app = @app
-    end
-    
-    it "should return the app" do
-      @object.app.should == @app
-    end
-    
-    it "should return the app's log" do
-      @object.log.should == @app.log
-    end
-    
-    it "should say it's set" do
-      @object.app_set?.should be_true
-    end
-
-  end
-  
-end