oahu-dragonfly 0.8.2

data/spec/dragonfly/active_model_extensions/spec_helper.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'active_model'
+
+# --------------------------------------------------------------- #
+# MODELS
+# --------------------------------------------------------------- #
+class MyModel
+  
+  # Callbacks
+  extend ActiveModel::Callbacks
+  define_model_callbacks :save, :destroy
+  
+  include ActiveModel::Validations
+  
+  class << self
+    def create!(attrs={})
+      new(attrs).save!
+    end
+    
+    def find(id)
+      new(instances[id])
+    end
+    
+    def instances
+      @instances ||= {}
+    end
+  end
+
+  def initialize(attrs={})
+    attrs.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+  
+  attr_accessor :id
+  
+  def to_hash
+    self.class::ATTRIBUTES.inject({}) do |hash, attr|
+      hash[attr] = send(attr)
+      hash
+    end
+  end
+  
+  def save
+    _run_save_callbacks {
+      self.id ||= rand(1000)
+      self.class.instances[id] = self.to_hash
+    }
+  end
+  def save!
+    save
+    self
+  end
+  
+  def destroy
+    _run_destroy_callbacks {}
+  end
+end
+
+class Item < MyModel
+  
+  ATTRIBUTES = [
+    :title,
+    :preview_image_uid,
+    :preview_image_some_analyser_method,
+    :preview_image_size,
+    :preview_image_name,
+    :preview_image_blah_blah,
+    :other_image_uid,
+    :yet_another_image_uid,
+    :otra_imagen_uid,
+    :trailer_video_uid,
+    :created_at,
+    :updated_at
+  ]
+  attr_accessor *ATTRIBUTES
+end
+
+class Car < MyModel
+  ATTRIBUTES = [
+    :image_uid,
+    :reliant_image_uid,
+    :type
+  ]
+  attr_accessor *ATTRIBUTES
+end
+
+class Photo < MyModel
+  ATTRIBUTES = [:image_uid]
+  attr_accessor *ATTRIBUTES
+end

data/spec/dragonfly/analyser_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Dragonfly::Analyser do
+  
+  before(:each) do
+    @analyser = Dragonfly::Analyser.new
+    @analyser.log = Logger.new(LOG_FILE)
+  end
+  
+  describe "analysis_methods module" do
+    
+    before(:each) do
+      @analyser.add(:num_letters){|temp_object, letter| temp_object.data.count(letter) }
+      @obj = Object.new
+      @obj.extend @analyser.analysis_methods
+    end
+    
+    it "should return a module" do
+      @analyser.analysis_methods.should be_a(Module)
+    end
+    
+    it "should provide the object with the analyser method" do
+      @obj.analyser.should == @analyser
+    end
+    
+    it "should provide the object with the direct analysis method, provided that analyse method exists" do
+      def @obj.analyse(meth, *args)
+        analyser.analyse Dragonfly::TempObject.new('HELLO'), meth, *args
+      end
+      @obj.num_letters('L').should == 2
+    end
+    
+  end
+  
+  describe "analyse" do
+    it "should return nil if the function isn't defined" do
+      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
+    end
+    it "should return nil if the function can't be handled" do
+      @analyser.add(:width){ throw :unable_to_handle }
+      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
+    end
+  end
+  
+  describe "analysis_method_names" do
+    it "should return the analysis methods" do
+      @analyser.add(:width){}
+      @analyser.add(:height){}
+      @analyser.analysis_method_names.should == [:width, :height]
+    end
+  end
+  
+  describe "cache" do
+    before(:each) do
+      @temp_object = Dragonfly::TempObject.new('HELLO')
+    end
+
+    def it_should_analyse_using(meth, temp_object, *args)
+      result = mock('result')
+      @analyser.should_receive(:call_last).with(meth, temp_object, *args).exactly(:once).and_return result
+      @analyser.analyse(temp_object, meth, *args).should == result
+      result
+    end
+
+    it "should do the analysis the first time" do
+      it_should_analyse_using(:blah, @temp_object, :arg1)
+    end
+
+    describe "when already called" do
+      before(:each) do
+        @result = it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+
+      it "should not do it subsequent times but still return the result" do
+        @analyser.should_not_receive(:call_last)
+        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
+        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
+      end
+      
+      it "should not use the cache if the temp_object is different" do
+        temp_object = Dragonfly::TempObject.new('aaa')
+        it_should_analyse_using(:blah, temp_object, :arg1)
+      end
+      
+      it "should not use the cache if the method name is different" do
+        it_should_analyse_using(:egghead, @temp_object, :arg1)
+      end
+      
+      it "should not use the cache if the args are different" do
+        it_should_analyse_using(:blah, @temp_object, :arg2)
+      end
+      
+      it "should do it again if the cache has been cleared" do
+        @analyser.clear_cache!
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+
+      it "should not use the cache if it has been turned off" do
+        @analyser.enable_cache = false
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+      end
+      
+    end
+
+    describe "cache size" do
+      it "should not exceed the cache size" do
+        @analyser.cache_size = 2
+
+        res1 = it_should_analyse_using(:blah, @temp_object, :arg1)
+        res2 = it_should_analyse_using(:blah, @temp_object, :arg2)
+        res3 = it_should_analyse_using(:blah, @temp_object, :arg3) # Should kick out first one
+        
+        it_should_analyse_using(:blah, @temp_object, :arg1)
+
+        # Third analysis should still be cached
+        @analyser.should_not_receive(:call_last)
+        @analyser.analyse(@temp_object, :blah, :arg3).should == res3
+      end
+    end
+
+  end
+  
+end

data/spec/dragonfly/analysis/file_command_analyser_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+png_path = File.dirname(__FILE__) + '/../../../samples/egg.png'
+
+describe Dragonfly::Analysis::FileCommandAnalyser do
+  
+  before(:each) do
+    @analyser = Dragonfly::Analysis::FileCommandAnalyser.new
+  end
+  
+  describe "mime_type" do
+    
+    describe "when using the filesystem" do
+      before(:each) do
+        @analyser.use_filesystem = true
+        @temp_object = Dragonfly::TempObject.new(File.new(png_path))
+      end
+      it "should give the mime-type" do
+        @analyser.mime_type(@temp_object).should == 'image/png'
+      end
+      it "should not have initialized the data string" do
+        @analyser.mime_type(@temp_object)
+        @temp_object.instance_eval{@data}.should be_nil
+      end
+    end
+    
+    describe "when not using the filesystem" do
+      before(:each) do
+        @analyser.use_filesystem = false
+        @temp_object = Dragonfly::TempObject.new(File.read(png_path))
+      end
+      it "should give the mime-type" do
+        @analyser.mime_type(@temp_object).should == 'image/png'
+      end
+      it "should not have initialized the file" do
+        @analyser.mime_type(@temp_object)
+        @temp_object.instance_eval{@tempfile}.should be_nil
+      end
+      it "should work properly (without a broken pipe error) for big files of format jpg" do
+        data = Dragonfly::ImageMagick::Generator.new.plasma(1000, 1000, :jpg).first
+        temp_object = Dragonfly::TempObject.new(data)
+        @analyser.mime_type(temp_object).should == "image/jpeg"
+      end
+    end
+  
+  end
+  
+end

data/spec/dragonfly/app_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require 'rack/mock'
+
+def request(app, path)
+  Rack::MockRequest.new(app).get(path)
+end
+
+describe Dragonfly::App do
+
+  describe ".instance" do
+
+    it "should create a new instance if it didn't already exist" do
+      app = Dragonfly::App.instance(:images)
+      app.should be_a(Dragonfly::App)
+    end
+
+    it "should return an existing instance if called by name" do
+      app = Dragonfly::App.instance(:images)
+      Dragonfly::App.instance(:images).should == app
+    end
+
+    it "should also work using square brackets" do
+      Dragonfly[:images].should == Dragonfly::App.instance(:images)
+    end
+
+  end
+
+  describe ".new" do
+    it "should not be callable" do
+      lambda{
+        Dragonfly::App.new
+      }.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "mime types" do
+    describe "#mime_type_for" do
+      before(:each) do
+        @app = test_app
+      end
+      it "should return the correct mime type for a symbol" do
+        @app.mime_type_for(:png).should == 'image/png'
+      end
+      it "should work for strings" do
+        @app.mime_type_for('png').should == 'image/png'
+      end
+      it "should work with uppercase strings" do
+        @app.mime_type_for('PNG').should == 'image/png'
+      end
+      it "should work with a dot" do
+        @app.mime_type_for('.png').should == 'image/png'
+      end
+      it "should return nil if not known" do
+        @app.mime_type_for(:mark).should be_nil
+      end
+      it "should allow for configuring extra mime types" do
+        @app.register_mime_type 'mark', 'application/mark'
+        @app.mime_type_for(:mark).should == 'application/mark'
+      end
+      it "should override existing mime types when registered" do
+        @app.register_mime_type :png, 'ping/pong'
+        @app.mime_type_for(:png).should == 'ping/pong'
+      end
+      it "should have a per-app mime-type configuration" do
+        other_app = Dragonfly[:other_app]
+        @app.register_mime_type(:mark, 'first/one')
+        other_app.register_mime_type(:mark, 'second/one')
+        @app.mime_type_for(:mark).should == 'first/one'
+        other_app.mime_type_for(:mark).should == 'second/one'
+      end
+    end
+  end
+
+  describe "remote_url_for" do
+    before(:each) do
+      @app = test_app
+      @app.datastore = Object.new
+    end
+    it "should raise an error if the datastore doesn't provide it" do
+      lambda{
+        @app.remote_url_for('some_uid')
+      }.should raise_error(NotImplementedError)
+    end
+    it "should correctly call it if the datastore provides it" do
+      @app.datastore.should_receive(:url_for).with('some_uid', :some => :opts).and_return 'http://egg.head'
+      @app.remote_url_for('some_uid', :some => :opts).should == 'http://egg.head'
+    end
+  end
+
+  describe "#store" do
+    before(:each) do
+      @app = test_app
+    end
+    it "should allow just storing content" do
+      @app.datastore.should_receive(:store).with(a_temp_object_with_data("HELLO"), {})
+      @app.store("HELLO")
+    end
+    it "should allow storing using a TempObject" do
+      temp_object = Dragonfly::TempObject.new("HELLO")
+      @app.datastore.should_receive(:store).with(temp_object, {})
+      @app.store(temp_object)
+    end
+    it "should allow storing with extra stuff" do
+      @app.datastore.should_receive(:store).with(
+        a_temp_object_with_data("HELLO"), :meta => {:egg => :head}, :option => :blarney
+      )
+      @app.store("HELLO", :meta => {:egg => :head}, :option => :blarney)
+    end
+  end
+
+  describe "url_for" do
+    before(:each) do
+      @app = test_app
+      @job = @app.fetch('eggs')
+    end
+    it "should give the server url by default" do
+      @app.url_for(@job).should =~ %r{^/\w+$}
+    end
+    it "should allow configuring" do
+      @app.configure do |c|
+        c.define_url do |app, job, opts|
+          "doogies"
+        end
+      end
+      @app.url_for(@job).should == 'doogies'
+    end
+    it "should yield the correct dooberries" do
+      @app.define_url do |app, job, opts|
+        [app, job, opts]
+      end
+      @app.url_for(@job, {'chuddies' => 'margate'}).should == [@app, @job, {'chuddies' => 'margate'}]
+    end
+  end
+
+end

data/spec/dragonfly/configurable_spec.rb

@@ -0,0 +1,461 @@
+require 'spec_helper'
+
+describe Dragonfly::Configurable do
+
+  before(:each) do
+    class Car
+      include Dragonfly::Configurable
+      configurable_attr :colour
+      configurable_attr :top_speed, 216
+      def self.other_thing=(thing); end
+    end
+    @car = Car.new
+  end
+
+  describe "setup" do
+    it "should provide attr_readers for configurable attributes" do
+      @car.should respond_to(:colour)
+    end
+
+    it "should provide attr_writers for configurable attributes" do
+      @car.colour = 'verde'
+      @car.colour.should == 'verde'
+    end
+
+    it "should set default values for configurable attributes" do
+      @car.top_speed.should == 216
+    end
+
+    it "should set the default as nil if not specified" do
+      @car.colour.should be_nil
+    end
+    
+    it "should allow setting to nil" do
+      @car.top_speed = nil
+      @car.top_speed.should be_nil
+    end
+    
+    it "should allow specifying configurable attrs as strings" do
+      class Bike
+        include Dragonfly::Configurable
+        configurable_attr 'colour', 'rude'
+      end
+      Bike.new.colour.should == 'rude'
+    end
+  end
+
+  describe "configuring" do    
+    it "should allow you to change values" do
+      @car.configure do |c|
+        c.colour = 'red'
+      end
+      @car.colour.should == 'red'
+    end
+    
+    it "should not allow you to call other methods on the object via the configuration" do
+      lambda{
+        @car.configure do |c|
+          c.other_thing = 5
+        end
+      }.should raise_error(Dragonfly::Configurable::BadConfigAttribute)
+    end
+    
+    it "should return itself" do
+      @car.configure{|c|}.should == @car
+    end
+  end
+  
+  describe "getting configuration" do
+    it "should return the configuration when nothing is set" do
+      @car.configuration.should == {}
+    end
+    it "should return the configuration when something is set" do
+      @car.top_speed = 10
+      @car.configuration.should == {:top_speed => 10}
+    end
+  end
+  
+  describe "multiple objects" do
+    it "should return the default configuration" do
+      Car.default_configuration.should == {:colour => nil, :top_speed => 216}
+    end
+    it "should allow instances to be configured differently" do
+      car1 = Car.new
+      car1.configure{|c| c.colour = 'green'}
+      car2 = Car.new
+      car2.configure{|c| c.colour = 'yellow'}
+      car1.configuration.should == {:colour => 'green'}
+      car2.configuration.should == {:colour => 'yellow'}
+    end
+  end
+  
+  describe "lazy attributes" do
+    before(:each) do
+      cow = @cow = mock('cow')
+      class Lazy; end
+      Lazy.class_eval do
+        include Dragonfly::Configurable
+        configurable_attr(:sound){ cow.moo }
+      end
+      @lazy = Lazy.new
+    end
+    it "should not call the block if the configurable attribute is set to something else" do
+      @cow.should_not_receive(:moo)
+      @lazy.configure{|c| c.sound = 'baa' }
+      @lazy.sound.should == 'baa'
+    end
+    it "should call the block if it's not been changed, once it's accessed" do
+      @cow.should_receive(:moo).and_return('mooo!')
+      @lazy.sound.should == 'mooo!'
+    end
+    it "should not call the block when accessed again" do
+      @cow.should_receive(:moo).exactly(:once).and_return('mooo!')
+      @lazy.sound.should == 'mooo!'
+      @lazy.sound.should == 'mooo!'
+    end
+    it "should not call an explicitly passed in proc" do
+      @lazy.configure{|c| c.sound = lambda{ @cow.fart }}
+      @lazy.sound.should be_a(Proc)
+    end
+  end
+  
+  describe "using in the singleton class" do
+    it "should work" do
+      class OneOff
+        class << self
+          include Dragonfly::Configurable
+          configurable_attr :food, 'bread'
+        end
+      end
+      OneOff.food.should == 'bread'
+    end
+  end
+  
+  describe "configuration method" do
+    
+    before(:each) do
+      class ClassWithMethod
+        include Dragonfly::Configurable
+        def add_thing(thing)
+          'poo'
+        end
+        def remove_thing(thing)
+          'bum'
+        end
+        configuration_method :add_thing, :remove_thing
+      end
+      @thing = ClassWithMethod.new
+    end
+    
+    it "should allow calling the method through 'configure'" do
+      @thing.configure do |c|
+        c.add_thing('duck')
+        c.remove_thing('dog')
+      end
+    end
+    
+  end
+  
+  describe "nested configurable objects" do
+
+    before(:each) do
+      class NestedThing
+        include Dragonfly::Configurable
+        configurable_attr :age, 29
+        def some_method(val)
+          @some_thing = val
+        end
+        configuration_method :some_method
+        attr_reader :some_thing
+      end
+
+      class Car
+        def nested_thing
+          @nested_thing ||= NestedThing.new
+        end
+        nested_configurable :nested_thing
+      end
+
+      @car.configure do |c|
+        c.nested_thing.configure do |nt|
+          nt.age = 50
+          nt.some_method('yo')
+        end
+      end
+    end
+
+    it "should allow configuring nested configurable accessors" do
+      @car.nested_thing.age.should == 50
+    end
+
+    it "should allow configuring nested configurable normal methods" do
+      @car.nested_thing.some_thing.should == 'yo'
+    end
+    
+    it "should not allow configuring directly on the config object" do
+      expect{
+        @car.configure do |c|
+          c.some_method('other')
+        end
+      }.to raise_error(Dragonfly::Configurable::BadConfigAttribute)
+    end
+  end
+  
+  describe "configuring with a saved config" do
+    before(:each) do
+      @cool_configuration = Object.new
+      def @cool_configuration.apply_configuration(car, colour=nil)
+        car.configure do |c|
+          c.colour = (colour || 'vermelho')
+        end
+      end
+    end
+    
+    it "should allow configuration by a saved config" do
+      @car.configure_with(@cool_configuration)
+      @car.colour.should == 'vermelho'
+      @car.top_speed.should == 216
+    end
+    
+    it "should pass any args through to the saved config" do
+      @car.configure_with(@cool_configuration, 'preto')
+      @car.colour.should == 'preto'
+    end
+    
+    it "should yield a block for any extra configuration" do
+      @car.configure_with(@cool_configuration) do |c|
+        c.colour = 'branco'
+      end
+      @car.colour.should == 'branco'
+    end
+    
+    it "should return itself" do
+      @car.configure_with(@cool_configuration).should == @car
+    end
+    
+    describe "using a symbol to specify the config" do
+
+      before(:all) do
+        @rally_config = Object.new
+        Car.register_configuration(:rally, @rally_config)
+        @long_journey_config = Object.new
+        Car.register_configuration(:long_journey){ @long_journey_config }
+        Car.register_configuration(:some_library){ SomeLibrary }
+      end
+
+      it "should map the symbol to the correct configuration" do
+        @rally_config.should_receive(:apply_configuration).with(@car)
+        @car.configure_with(:rally)
+      end
+
+      it "should map the symbol to the correct configuration lazily" do
+        @long_journey_config.should_receive(:apply_configuration).with(@car)
+        @car.configure_with(:long_journey)
+      end
+
+      it "should throw an error if an unknown symbol is passed in" do
+        lambda {
+          @car.configure_with(:eggs)
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should only try to load the library when asked to" do
+        lambda{
+          @car.configure_with(:some_library)
+        }.should raise_error(NameError, /uninitialized constant.*SomeLibrary/)
+      end
+    end
+    
+  end
+  
+  describe "falling back to another config" do
+    before(:each) do
+      @garage = Object.new
+      class << @garage
+        include Dragonfly::Configurable
+        configurable_attr :top_speed, 100
+      end
+      @car.use_as_fallback_config(@garage)
+    end
+    
+    describe "when nothing set" do
+      it "should use its default" do
+        @car.top_speed.should == 216
+      end
+      it "shouldn't affect the fallback config object" do
+        @garage.top_speed.should == 100
+      end
+    end
+    
+    describe "if set" do
+      before(:each) do
+        @car.top_speed = 444
+      end
+      it "should work normally" do
+        @car.top_speed.should == 444
+      end
+      it "shouldn't affect the fallback config object" do
+        @garage.top_speed.should == 100
+      end
+    end
+    
+    describe "both set" do
+      before(:each) do
+        @car.top_speed = 444
+        @garage.top_speed = 3000
+      end
+      it "should prefer its own setting" do
+        @car.top_speed.should == 444
+      end
+      it "shouldn't affect the fallback config object" do
+        @garage.top_speed.should == 3000
+      end
+    end
+    
+    describe "the fallback config is set" do
+      before(:each) do
+        @garage.top_speed = 3000
+      end
+      it "should use the fallback config" do
+        @car.top_speed.should == 3000
+      end
+      it "shouldn't affect the fallback config object" do
+        @garage.top_speed.should == 3000
+      end
+    end
+    
+    describe "falling back multiple levels" do
+      before(:each) do
+        @klass = Class.new
+        @klass.class_eval do
+          include Dragonfly::Configurable
+          configurable_attr :veg, 'carrot'
+        end
+        @a = @klass.new
+        @b = @klass.new
+        @b.use_as_fallback_config(@a)
+        @c = @klass.new
+        @c.use_as_fallback_config(@b)
+      end
+      
+      it "should be the default if nothing set" do
+        @c.veg.should == 'carrot'
+      end
+      
+      it "should fall all the way back to the top one if necessary" do
+        @a.veg = 'turnip'
+        @c.veg.should == 'turnip'
+      end
+      
+      it "should prefer the closer one over the further away one" do
+        @b.veg = 'tatty'
+        @a.veg = 'turnip'
+        @c.veg.should == 'tatty'
+      end
+      
+      it "should work properly with nils" do
+        @a.veg = nil
+        @c.veg = 'broc'
+        @a.veg.should be_nil
+        @b.veg.should be_nil
+        @c.veg.should == 'broc'
+      end
+    end
+    
+    describe "objects with different methods" do
+      before(:each) do
+        @dad = Object.new
+        class << @dad
+          include Dragonfly::Configurable
+        end
+        @kid = Object.new
+        class << @kid
+          include Dragonfly::Configurable
+          configurable_attr :lug, 'default-lug'
+        end
+        @kid.use_as_fallback_config(@dad)
+      end
+
+      it "should not allow setting on the fallback obj directly" do
+        lambda{
+          @dad.lug = 'leg'
+        }.should raise_error(NoMethodError)
+      end
+
+      it "should not have the fallback obj respond to the method" do
+        @dad.should_not respond_to(:lug=)
+      end
+
+      it "should allow configuring through the fallback object even if it doesn't have that method" do
+        @dad.configure do |c|
+          c.lug = 'leg'
+        end
+        @kid.lug.should == 'leg'
+      end
+      
+      it "should work when a grandchild config is added later" do
+        grandkid = Object.new
+        class << grandkid
+          include Dragonfly::Configurable
+          configurable_attr :oogie, 'boogie'
+        end
+        grandkid.use_as_fallback_config(@kid)
+        @dad.configure{|c| c.oogie = 'duggen' }
+        grandkid.oogie.should == 'duggen'
+      end
+
+      it "should allow configuring twice through the fallback object" do
+        @dad.configure{|c| c.lug = 'leg' }
+        @dad.configure{|c| c.lug = 'blug' }
+        @kid.lug.should == 'blug'
+      end
+    end
+    
+    describe "clashing with configurable modules" do
+      before(:each) do
+        @mod = mod = Module.new
+        @mod.module_eval do
+          include Dragonfly::Configurable
+          configurable_attr :team, 'spurs'
+        end
+        @class = Class.new
+        @class.class_eval do
+          include mod
+          include Dragonfly::Configurable
+          configurable_attr :tree, 'elm'
+        end
+      end
+      
+      it "should not override the defaults from the module" do
+        obj = @class.new
+        obj.team.should == 'spurs'
+      end
+      
+      it "should still use its own defaults" do
+        obj = @class.new
+        obj.tree.should == 'elm'
+      end
+      
+      describe "when the configurable_attr is specified in a subclass that doesn't include Configurable" do
+        before(:each) do
+          @subclass = Class.new(@class)
+          @subclass.class_eval do
+            configurable_attr :car, 'mazda'
+            configurable_attr :tree, 'oak'
+          end
+          @obj = @subclass.new
+        end
+
+        it "should still work with default values" do
+          @obj.car.should == 'mazda'
+        end
+
+        it "should override the default from the parent" do
+          @obj.tree.should == 'oak'
+        end
+      end
+
+    end
+    
+  end
+end