dragonfly 0.6.2 → 0.7.0

data/spec/dragonfly/delegatable_spec.rb

@@ -1,32 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module M
-  def m; end
-end
-
-class A
-  include Dragonfly::Delegatable
-  def a; end
-end
-
-class B < A
-  include M
-  def b; end
-end
-
-describe Dragonfly::Delegatable do
-  
-  describe "delegatable_methods" do
-    it "should include all methods defined after including, including mixed-in and inherited" do
-      B.new.delegatable_methods.should == [:b, :m, :a].map{|m| m.to_method_name }
-    end
-    
-    it "should work the second (cached) time" do
-      b = B.new
-      b.delegatable_methods
-      b.delegatable_methods.should == [:b, :m, :a].map{|m| m.to_method_name }
-    end
-    
-  end
-  
-end

data/spec/dragonfly/delegator_spec.rb

@@ -1,145 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-class CarDriver
-  include Dragonfly::Delegatable
-
-  def drive(car)
-    "Driving car #{car}"
-  end
-  def open_boot
-    :open_boot
-  end
-  def clean(car)
-    "Cleaning #{car}"
-  end
-end
-
-class LorryDriver
-  include Dragonfly::BelongsToApp
-  include Dragonfly::Delegatable
-
-  def drive(lorry)
-    "Driving lorry #{lorry}"
-  end
-  def open_back_doors
-    :open_back_doors
-  end
-  def clean(lorry)
-    throw :unable_to_handle
-  end
-  def pick_up(lorry)
-    throw :unable_to_handle
-  end
-end
-
-class BusDriver
-  include Dragonfly::Delegatable
-  include Dragonfly::Configurable
-
-  configurable_attr :height
-
-  def initialize(age); @age = age; end
-  def age; @age; end
-end
-
-describe Dragonfly::Delegator do
-  
-  before(:each) do
-    @delegator = Object.new
-    @delegator.extend Dragonfly::Delegator
-  end
-  
-  describe "when no items have been registered" do
-
-    it "should raise an error when calling an unknown method" do
-      lambda{ @delegator.drive }.should raise_error(NoMethodError)
-    end
-
-    it "should should return delegatable_methods as an empty array" do
-      @delegator.delegatable_methods.should == []
-    end
-    
-    it "should return the object registered when registering" do
-      @delegator.register(CarDriver).should be_a(CarDriver)
-    end
-    
-  end
-
-  describe "after registering a number of classes" do
-
-    before(:each) do
-      @delegator.app = Dragonfly::App[:test]
-      @car_driver = @delegator.register(CarDriver)
-      @lorry_driver = @delegator.register(LorryDriver)
-    end
-
-    it "should raise an error when calling an unknown method" do
-      lambda{ @delegator.swim }.should raise_error(NoMethodError)
-    end
-
-    it "should correctly delegate when only one item implements the method" do
-      @delegator.open_boot.should == :open_boot
-      @delegator.open_back_doors.should == :open_back_doors
-    end
-
-    it "should allow delegating explicitly" do
-      @delegator.delegate(:open_boot).should == :open_boot
-    end
-
-    it "should delegate to the last registered when more than one item implements the method" do
-      @delegator.drive('fishmonger').should == "Driving lorry fishmonger"
-    end
-
-    it "should return all the callable methods" do
-      @delegator.delegatable_methods.sort.should == %w(clean drive open_back_doors open_boot pick_up).map{|m| m.to_method_name }
-    end
-    
-    it "should say if if has a callable method (as a string)" do
-      @delegator.has_delegatable_method?('drive').should be_true
-    end
-
-    it "should say if if has a callable method (as a symbol)" do
-      @delegator.has_delegatable_method?(:drive).should be_true
-    end
-
-    it "should skip methods that throw :unable_to_handle" do
-      @delegator.clean('my car').should == "Cleaning my car"
-    end
-    
-    it "should raise an error if nothing was able to handle it" do
-      lambda{ @delegator.pick_up('my lorry') }.should raise_error(Dragonfly::Delegator::UnableToHandle)
-    end
-
-    it "should return registered objects" do
-      @delegator.registered_objects.should == [@car_driver, @lorry_driver]
-    end
-    
-    it "should set the registered object's app to its own if object should belong to an app" do
-      @lorry_driver.app.should == @delegator.app
-    end
-    
-    it "should enable unregistering classes" do
-      @delegator.unregister(LorryDriver)
-      @delegator.registered_objects.map(&:class).should == [CarDriver]
-    end
-    
-    it "should enable unregistering all" do
-      @delegator.unregister_all
-      @delegator.registered_objects.should == []
-    end
-
-  end
-  
-  describe "configuring on registration" do
-    it "should pass the args on register to the object initializer" do
-      @delegator.register(BusDriver, 43)
-      @delegator.age.should == 43
-    end
-    
-    it "should run configure if a block given" do
-      @delegator.register(BusDriver, 43){|c| c.height = 180 }
-      @delegator.height.should == 180
-    end
-  end
-
-end

data/spec/dragonfly/extended_temp_object_spec.rb

@@ -1,71 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Dragonfly::ExtendedTempObject do
-  
-  describe "when configured correctly" do
-    
-    before(:each) do
-      @app = Dragonfly::App[:test]
-    end
-    
-    describe "analysis" do
-
-      before(:each) do
-        analyser_class = Class.new(Dragonfly::Analysis::Base) do
-          def width(temp_object); temp_object.data.size; end
-        end
-        @analyser = @app.register_analyser(analyser_class)
-        @object = Dragonfly::ExtendedTempObject.new('asdf', @app)
-      end
-      
-      it "should respond to something that the analyser responds to" do
-        @object.should respond_to(:width)
-      end
-      
-      it "should not respond to something that the analyser doesn't respond to" do
-        @object.should_not respond_to(:spaghetti)
-      end
-
-      it "should delegate the analysis to the analyser" do
-        @object.width.should == 4
-      end
-      
-      it "should cache the result so that it doesn't call it a second time" do
-        @analyser.should_receive(:width).with(@object).and_return(4)
-        @object.width.should == 4
-        @analyser.should_not_receive(:width)
-        @object.width.should == 4
-      end
-      
-      it "should do the analysis again when it has been modified" do
-        @object.width.should == 4
-        @object.modify_self!('hellothisisnew')
-        @object.width.should == 14
-        @analyser.should_not_receive(:width)
-        @object.width.should == 14
-      end
-      
-    end
-    
-    describe "encoding" do
-      before(:each) do
-        encoder_class = Class.new(Dragonfly::Encoding::Base)
-        @encoder = @app.register_encoder(encoder_class)
-        @temp_object = Dragonfly::ExtendedTempObject.new('abcde', @app)
-      end
-      
-      it "should encode the data and return the new temp object" do
-        @encoder.should_receive(:encode).with(@temp_object, :some_format, :some => 'option').and_return('ABCDE')
-        new_temp_object = @temp_object.encode(:some_format, :some => 'option')
-        new_temp_object.data.should == 'ABCDE'
-      end
-      it "should encode its own data" do
-        @encoder.should_receive(:encode).with(@temp_object, :some_format, :some => 'option').and_return('ABCDE')
-        @temp_object.encode!(:some_format, :some => 'option')
-        @temp_object.data.should == 'ABCDE'
-      end
-    end
-    
-  end
-  
-end

data/spec/dragonfly/parameters_spec.rb

@@ -1,298 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Dragonfly::Parameters do
-  
-  def standard_attributes
-    {
-      :uid => 'ahaha',
-      :processing_method => :round,
-      :format => :gif,
-      :processing_options => {:radius => 5},
-      :encoding => {:flumps_per_minute => 56}
-    }
-  end
-  
-  describe "initializing" do
-    it "should allow initializing without a hash" do
-      parameters = Dragonfly::Parameters.new
-      parameters.uid.should be_nil
-    end
-    it "should allow initializing with a hash" do
-      parameters = Dragonfly::Parameters.new(:uid => 'b')
-      parameters.uid.should == 'b'
-    end
-    it "should raise an error if initialized with a bad hash key" do
-      lambda{
-        Dragonfly::Parameters.new(:fridge => 'cold')
-      }.should raise_error(ArgumentError)
-    end
-  end
-  
-  describe "accessors" do
-    before(:each) do
-      @parameters = Dragonfly::Parameters.new
-    end
-    it "should give the accessors the correct defaults" do
-      @parameters.uid.should be_nil
-      @parameters.processing_method.should be_nil
-      @parameters.format.should be_nil
-      @parameters.processing_options.should == {}
-      @parameters.encoding.should == {}
-    end
-    it "should provide writers too" do
-      @parameters.uid = 'hello'
-      @parameters.uid.should == 'hello'
-    end
-  end
-  
-  describe "array style accessors" do
-    before(:each) do
-      @parameters = Dragonfly::Parameters.new(:uid => 'hello')
-    end
-    it "should be the same as calling the corresponding reader" do
-      @parameters[:uid].should == @parameters.uid
-    end
-    it "should be the same as calling the corresponding writer" do
-      @parameters[:uid] = 'goodbye'
-      @parameters.uid.should == 'goodbye'
-    end
-  end
-  
-  describe "comparing" do
-    before(:each) do
-      @parameters1 = Dragonfly::Parameters.new(standard_attributes)
-      @parameters2 = Dragonfly::Parameters.new(standard_attributes)      
-    end
-    it "should return true when two have all the same attributes" do
-      @parameters1.should == @parameters2
-    end
-    %w(uid processing_method format processing_options encoding).each do |attribute|
-      it "should return false when #{attribute} is different" do
-        @parameters2[attribute.to_sym] = 'fish'
-        @parameters1.should_not == @parameters2
-      end
-    end
-  end
-  
-  describe "to_hash" do
-    it "should return the attributes as a hash" do
-      parameters = Dragonfly::Parameters.new(standard_attributes)
-      parameters.to_hash.should == standard_attributes
-    end
-  end
-  
-  describe "custom parameters classes" do
-    
-    before(:each) do
-      @parameters_class = Class.new(Dragonfly::Parameters)
-    end
-    
-    describe "when defaults are not set" do
-      it "should return the standard defaults" do
-        parameters = @parameters_class.new_with_defaults
-        parameters.processing_method.should be_nil
-        parameters.processing_options.should == {}
-        parameters.format.should be_nil
-        parameters.encoding.should == {}
-      end
-    end
-    
-    describe "when defaults are set" do
-      before(:each) do
-        @parameters_class.configure do |c|
-          c.default_processing_method = :resize
-          c.default_processing_options = {:scale => '0.5'}
-          c.default_format = :png
-          c.default_encoding = {:bit_rate => 24}
-        end
-      end
-      it "should not affect .new" do
-        parameters = @parameters_class.new
-        parameters.processing_method.should be_nil
-        parameters.processing_options.should == {}
-        parameters.format.should be_nil
-        parameters.encoding.should == {}
-      end
-      it "should return the default if not set on parameters" do
-        parameters = @parameters_class.new_with_defaults
-        parameters.processing_method.should == :resize
-        parameters.processing_options.should == {:scale => '0.5'}
-        parameters.format.should == :png
-        parameters.encoding.should == {:bit_rate => 24}
-      end
-      it "should return the correct parameter if set" do
-        parameters = @parameters_class.new_with_defaults(
-          :processing_method => :yo,
-          :processing_options => {:a => 'b'},
-          :format => :txt,
-          :encoding => {:ah => :arg}
-        )
-        parameters.processing_method.should == :yo
-        parameters.processing_options.should == {:a => 'b'}
-        parameters.format.should == :txt
-        parameters.encoding.should == {:ah => :arg}
-      end
-      it "should not override nil if explicity set" do
-        @parameters_class.new_with_defaults(:format => nil).format.should be_nil
-      end
-    end
-    
-  end
-  
-  describe "shortcuts" do
-    
-    before(:each) do
-      @parameters_class = Class.new(Dragonfly::Parameters)
-    end
-    
-    it "should allow for setting simple shortcuts" do
-      attributes = {
-        :processing_method => :duncan,
-        :processing_options => {:bill => :gates},
-        :format => 'mamamia',
-        :encoding => {:doogie => :howser}
-      }
-      @parameters_class.add_shortcut(:doobie, attributes)
-      @parameters_class.hash_from_shortcut(:doobie).should == attributes
-    end
-    
-    it "should raise an error if the shortcut doesn't exist" do
-      lambda{
-        @parameters_class.hash_from_shortcut(:idontexist)
-      }.should raise_error(Dragonfly::Parameters::InvalidShortcut)
-    end
-    
-    describe "block shortcuts" do
-      
-      before(:each) do
-        @parameters_class.add_shortcut(/^hello.*$/, Symbol) do |processing_method, format, matches|
-          {:processing_method => processing_method, :format => format}
-        end
-      end
-      
-      it "should allow for more complex shortcuts by using a block and matching args" do
-        @parameters_class.hash_from_shortcut('hellothere', :tif).should == {:processing_method => 'hellothere', :format => :tif}
-      end
-
-      it "should raise an error if the shortcut doesn't match properly" do
-        lambda{
-          @parameters_class.hash_from_shortcut('hellothere', 'tif')
-        }.should raise_error(Dragonfly::Parameters::InvalidShortcut)
-      end
-      
-      it "should raise an error if the shortcut matches but has the wrong number of args" do
-        lambda{
-          @parameters_class.hash_from_shortcut('hellothere', :tif, 'YO')
-        }.should raise_error(Dragonfly::Parameters::InvalidShortcut)
-      end
-
-      it "should let later shortcuts have priority over earlier ones" do
-        @parameters_class.add_shortcut(/hello/, :tif) do |a, b|
-          {:processing_method => :bumble}
-        end
-        @parameters_class.hash_from_shortcut('hellothere', :tif).should == {:processing_method => :bumble}
-      end
-
-    end
-    
-    describe "single regexp shortcuts" do
-      
-      it "should yield regexp match data if the args is just one regexp" do
-        @parameters_class.add_shortcut(/^hello(.*)$/) do |arg, match_data|
-          {:processing_options => {:arg => arg, :match_data => match_data}}
-        end
-        processing_options = @parameters_class.hash_from_shortcut('hellothere')[:processing_options]
-        processing_options[:arg].should == 'hellothere'
-        processing_options[:match_data].should be_a(MatchData)
-        processing_options[:match_data][1].should == 'there'
-      end
-      
-    end
-    
-    describe ".from_shortcut" do
-      before(:each) do
-        @parameters_class.add_shortcut(/^hello.*$/) do |processing_method, matches|
-          {:processing_method => processing_method}
-        end
-        @parameters_class.default_format = :tif
-      end
-      it "should just be the parameters equivalent of 'hash_from_shortcut', including defaults" do
-        @parameters_class.from_shortcut('hellothere').should == 
-          @parameters_class.new(@parameters_class.hash_from_shortcut('hellothere').merge(:format => :tif))
-      end
-    end
-    
-  end
-  
-  describe ".from_args" do
-    
-    before(:each) do
-      @parameters_class = Class.new(Dragonfly::Parameters)
-      @parameters_class.default_format = :tif
-    end
-    
-    it "should be the same as 'new_with_defaults' if empty args" do
-      @parameters_class.from_args.should == @parameters_class.new_with_defaults
-    end
-    
-    it "should treat the arguments as actual parameter values (including defaults) if args is a single hash" do
-      @parameters_class.from_args(:uid => 'some_uid', :processing_method => :resize).
-        should == @parameters_class.new_with_defaults(:uid => 'some_uid', :processing_method => :resize)
-    end
-
-    it "should simply return the same parameters if args is a single parameters object" do
-      @parameters_class.from_args(@parameters_class.new(:uid => 'some_uid', :processing_method => :resize)).
-        should == @parameters_class.new(:uid => 'some_uid', :processing_method => :resize)
-    end
-    
-    it "should treat the arguments as shortcut arguments otherwise" do
-      @parameters_class.should_receive(:from_shortcut).with('innit').and_return(parameters = mock('parameters'))
-      @parameters_class.from_args('innit').should == parameters
-    end
-    
-  end
-  
-  describe "unique_signature" do
-    
-    before(:each) do
-      @parameters = Dragonfly::Parameters.new(standard_attributes)
-      @parameters2 = Dragonfly::Parameters.new(standard_attributes)
-    end
-    
-    it "should a unique identifier based on its attributes" do
-      @parameters.unique_signature.should be_a(String)
-      @parameters.unique_signature.length.should > 0
-    end
-    
-    it "should be the same if the attributes are the same" do
-      @parameters.unique_signature.should == @parameters2.unique_signature
-    end
-    
-    it "should be different when the uid is changed" do
-      @parameters2.uid = 'different yo'
-      @parameters.unique_signature.should_not == @parameters2.unique_signature
-    end
-   
-    it "should be different when the format is changed" do
-      @parameters2.format = :tif
-      @parameters.unique_signature.should_not == @parameters2.unique_signature
-    end
-    
-    it "should be different when the processing_method is changed" do
-      @parameters2.processing_method = :doogie
-      @parameters.unique_signature.should_not == @parameters2.unique_signature
-    end
-   
-    it "should be different when the processing_options are changed" do
-      @parameters2.processing_options[:slumdog] = 'millionaire'
-      @parameters.unique_signature.should_not == @parameters2.unique_signature
-    end
-    
-    it "should be different when the encoding options are changed" do
-      @parameters2.encoding[:flumps_per_minute] = 50.3
-      @parameters.unique_signature.should_not == @parameters2.unique_signature
-    end
-
-  end
-  
-end