dragonfly 0.9.15 → 1.0

data/spec/dragonfly/app_spec.rb

@@ -19,8 +19,12 @@ describe Dragonfly::App do
       Dragonfly::App.instance(:images).should == app
     end
 
-    it "should also work using square brackets" do
-      Dragonfly[:images].should == Dragonfly::App.instance(:images)
+    it "has a default instance" do
+      Dragonfly::App.instance.should be_a(Dragonfly::App)
+    end
+
+    it "returns the default instance if passed nil" do
+      Dragonfly::App.instance(nil).should == Dragonfly::App.instance
     end
 
   end
@@ -33,41 +37,97 @@ describe Dragonfly::App do
     end
   end
 
+  describe "destroy_apps" do
+    it "destroys the dragonfly apps" do
+      Dragonfly::App.instance(:gug)
+      Dragonfly::App.instance(:blug)
+      Dragonfly::App.apps.length.should == 2
+      Dragonfly::App.destroy_apps
+      Dragonfly::App.apps.length.should == 0
+    end
+  end
+
   describe "mime types" do
+    let(:app) { test_app }
+
     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'
+        app.mime_type_for(:png).should == 'image/png'
       end
       it "should work for strings" do
-        @app.mime_type_for('png').should == 'image/png'
+        app.mime_type_for('png').should == 'image/png'
       end
       it "should work with uppercase strings" do
-        @app.mime_type_for('PNG').should == 'image/png'
+        app.mime_type_for('PNG').should == 'image/png'
       end
       it "should work with a dot" do
-        @app.mime_type_for('.png').should == 'image/png'
+        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
+      it "should return the fallback if not known" do
+        app.mime_type_for(:mark).should == 'application/octet-stream'
       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'
+        app.add_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'
+        app.add_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 = Dragonfly.app(:other_app)
+        app.add_mime_type(:mark, 'first/one')
+        other_app.add_mime_type(:mark, 'second/one')
+        app.mime_type_for(:mark).should == 'first/one'
         other_app.mime_type_for(:mark).should == 'second/one'
       end
+      it "can be added via configure" do
+        app.configure{ mime_type 'mark', 'application/mark' }
+        app.mime_type_for(:mark).should == 'application/mark'
+      end
+    end
+
+    describe "#ext_for" do
+      it "returns the ext corresponding to a mime_type" do
+        app.ext_for('image/png').should == 'png'
+      end
+
+      it "returns nil if non-existent" do
+        app.ext_for('big/bum').should be_nil
+      end
+
+      it "returns txt for text/plain" do
+        app.ext_for('text/plain').should == 'txt'
+      end
+    end
+  end
+
+  describe "create" do
+    let (:app) { test_app }
+
+    it "creates a new job with the specified data/meta" do
+      job = app.create("hello", 'a' => 'b')
+      job.should be_a(Dragonfly::Job)
+      job.data.should == 'hello'
+      job.meta['a'].should == 'b'
+    end
+
+    it "accepts other jobs" do
+      job2 = app.create("other", 'c' => 'd')
+      job = app.create(job2)
+      job.data.should == 'other'
+      job.meta['c'].should == 'd'
+    end
+
+    it "accepts Attachments" do
+      Car = new_model_class('Car', :make_uid) do
+        dragonfly_accessor :make
+      end
+      car = Car.new(:make => 'jaguar')
+      car.make.meta['a'] = 'b'
+      job = app.create(car.make)
+      job.data.should == 'jaguar'
+      job.meta['a'].should == 'b'
     end
   end
 
@@ -88,86 +148,232 @@ describe Dragonfly::App do
   end
 
   describe "#store" do
-    before(:each) do
-      @app = test_app
-    end
+    let (:app) { test_app }
+
     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 do |temp_object, opts|
-        temp_object.data.should == 'HELLO'
-        temp_object.meta.should == {:egg => :head}
-        opts[:option].should == :blarney
+      app.datastore.should_receive(:write).with do |content, opts|
+        content.data.should == "HELLO"
       end
-      @app.store("HELLO", :meta => {:egg => :head}, :option => :blarney)
+      app.store("HELLO")
     end
-    it "should still pass in meta in the opts arg, for deprecated use of meta" do
-      @app.datastore.should_receive(:store).with do |temp_object, opts|
-        opts[:meta].should == {:egg => :head}
+
+    it "passes meta and options through too" do
+      app.datastore.should_receive(:write).with do |content, opts|
+        content.data.should == "HELLO"
+        content.meta.should == {'d' => 3}
+        opts.should == {:a => :b}
       end
-      @app.store("HELLO", :meta => {:egg => :head}, :option => :blarney)
+      app.store("HELLO", {'d' => 3}, {:a => :b})
     end
   end
 
   describe "url_for" do
-    before(:each) do
-      @app = test_app
-      @job = @app.fetch('eggs')
-    end
+    let (:app) { test_app }
+    let (:job) { app.fetch('eggs') }
+
     it "should give the server url by default" do
-      @app.url_for(@job).should =~ %r{^/\w+$}
+      app.url_for(job).should =~ %r{^/\w+$}
     end
     it "should allow configuring" do
-      @app.configure do |c|
-        c.define_url do |app, job, opts|
+      app.configure do
+        define_url do |app, job, opts|
           "doogies"
         end
       end
-      @app.url_for(@job).should == 'doogies'
+      app.url_for(job).should == 'doogies'
     end
     it "should yield the correct dooberries" do
-      @app.define_url do |app, job, opts|
+      app.define_url do |app, job, opts|
         [app, job, opts]
       end
-      @app.url_for(@job, {'chuddies' => 'margate'}).should == [@app, @job, {'chuddies' => 'margate'}]
+      app.url_for(job, {'chuddies' => 'margate'}).should == [app, job, {'chuddies' => 'margate'}]
     end
   end
 
-  describe "reflection methods" do
+  describe "adding generators" do
     before(:each) do
-      @app = test_app.configure do |c|
-        c.processor.add(:milk){}
-        c.generator.add(:butter){}
-        c.analyser.add(:cheese){}
-        c.job(:bacon){}
+      @app = test_app.configure do
+        generator(:butter){ "BUTTER" }
       end
-      
-    end
-    it "should return processor methods" do
-      @app.processor_methods.should == [:milk]
     end
     it "should return generator methods" do
       @app.generator_methods.should == [:butter]
     end
+  end
+
+  describe "adding processors" do
+    before(:each) do
+      @app = test_app.configure do
+        processor(:double){}
+      end
+    end
+    it "should add a method" do
+      job1 = @app.create("bunga")
+      job2 = job1.double
+      job1.should_not == job2
+      job1.to_a.should == []
+      job2.to_a.should == [['p', :double]]
+    end
+    it "should add a bang method" do
+      job = @app.create("bunga")
+      job.double!.should == job
+      job.to_a.should == [['p', :double]]
+    end
+    it "should return processor methods" do
+      @app.processor_methods.should == [:double]
+    end
+  end
+
+  describe "adding analysers" do
+    before(:each) do
+      @app = test_app.configure do
+        analyser(:length){|content| content.size }
+      end
+    end
+    it "should add a method" do
+      @app.create('123').length.should == 3
+    end
     it "should return analyser methods" do
-      @app.analyser_methods.should == [:cheese]
+      @app.analyser_methods.should == [:length]
     end
-    it "should return job methods" do
-      @app.job_methods.should == [:bacon]
+  end
+
+  describe "response headers" do
+    let (:app) {test_app}
+
+    it "adds a response header" do
+      app.response_header 'Cache-Control', "private"
+      app.response_headers["Cache-Control"].should == 'private'
+    end
+
+    it "adds a response header using a block" do
+      app.response_header 'Cache-Control' do "private" end
+      app.response_headers["Cache-Control"].should be_a(Proc)
+    end
+
+    it "allows calling through the config" do
+      app.configure{ response_header 'Cache-Control', "private" }
     end
   end
 
   describe "inspect" do
     it "should give a neat output" do
-      Dragonfly[:hello].inspect.should == "<Dragonfly::App name=:hello >"
+      Dragonfly.app(:hello).inspect.should == "<Dragonfly::App name=:hello >"
+    end
+  end
+
+  describe "configuration" do
+
+    let(:app){ test_app }
+
+    describe "datastore" do
+      it "sets the datastore" do
+        store = double('datastore')
+        app.configure{ datastore store }
+        app.datastore.should == store
+      end
+
+      {
+        :file => Dragonfly::FileDataStore,
+        :memory => Dragonfly::MemoryDataStore
+      }.each do |symbol, klass|
+        it "recognises the #{symbol.inspect} shortcut for S3DataStore" do
+          app.configure{ datastore symbol }
+          app.datastore.should be_a(klass)
+        end
+      end
+    end
+
+    it "raises an error if it doesn't know the symbol" do
+      expect{
+        app.configure{ datastore :hello }
+      }.to raise_error(Dragonfly::App::UnregisteredDataStore)
+    end
+
+    it "passes args through to the initializer if a symbol is given" do
+      app.configure{ datastore :file, :root_path => '/some/path' }
+      app.datastore.root_path.should == '/some/path'
+    end
+
+    it "complains if extra args are given but first is not a symbol" do
+      store = double('datastore')
+      expect{
+        app.configure{ datastore store, :some => 'args' }
+      }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "define" do
+    let(:app){ test_app }
+
+    before :each do
+      app.define :exclaim do |n|
+        data.upcase + "!"*n
+      end
+    end
+
+    it "allows defining methods on jobs" do
+      app.create("snowman").exclaim(3).should == 'SNOWMAN!!!'
+    end
+
+    it "can be added through configure" do
+      app.configure{ define(:googie){} }
+      app.create("snowman").googie.should be_nil
+    end
+  end
+
+  describe "shell" do
+    let(:app){ test_app }
+
+    it "has a shell" do
+      app.shell.should be_a(Dragonfly::Shell)
+    end
+  end
+
+  describe "env" do
+    let(:app){ test_app }
+
+    it "stores environment variables" do
+      app.env.should == {}
+      app.env[:doogie] = 'blisto'
+      app.env[:doogie].should == 'blisto'
+    end
+  end
+
+  describe "deprecations" do
+    it "raises a message when using App#[]" do
+      expect {
+        Dragonfly::App[:images]
+      }.to raise_error(/Dragonfly::App\[:images\] .* Dragonfly\.app /)
+    end
+
+    it "raises a message when configuring with an old datastore" do
+      expect {
+        Dragonfly.app.use_datastore(double("datastore", :store => "asdf", :retrieve => "ASDF", :destroy => nil))
+      }.to raise_error(/read/)
+    end
+
+    it "raises a messages when configuring with a bad parameter" do
+      expect {
+        Dragonfly.app.configure do |c|
+          c.url_format = '/media/:job'
+        end
+      }.to raise_error(/no method.*changed.*docs/)
+    end
+
+    it "raises a message when calling App#define_macro" do
+      expect {
+        Dragonfly.app.define_macro(Object, :image_accessor)
+      }.to raise_error(/dragonfly_accessor/)
+    end
+
+    it "raises a message when calling App#define_macro_on_include" do
+      expect {
+        Dragonfly.app.define_macro_on_include(Module.new, :image_accessor)
+      }.to raise_error(/dragonfly_accessor/)
     end
   end
 
 end
+

data/spec/dragonfly/configurable_spec.rb

@@ -2,478 +2,202 @@ 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
+  describe "Configurer" do
 
-    it "should provide attr_writers for configurable attributes" do
-      @car.colour = 'verde'
-      @car.colour.should == 'verde'
-    end
+    let (:configurer) { Dragonfly::Configurable::Configurer.new do
+      def colour(colour)
+        obj.colour = colour
+      end
+    end }
 
-    it "should set default values for configurable attributes" do
-      @car.top_speed.should == 216
-    end
+    let (:obj) { Object.new }
 
-    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'
+    it "allows configuring" do
+      obj.should_receive(:colour=).with('red')
+      configurer.configure(obj) do
+        colour 'red'
       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 "configuration method" do
-    
-    before(:each) do
-      class ClassWithMethod
-        include Dragonfly::Configurable
-        def add_thing(thing)
-          'poo'
-        end
-        def remove_thing(thing)
-          'bum'
+    it "doesn't allow non-existent methods" do
+      expect{
+        configurer.configure(obj) do
+          color 'red'
         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
+      }.to raise_error(NoMethodError)
     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
+    it "doesn't call non-existent methods on the object" do
+      obj.should_not_receive(:color=)
+      begin
+        configurer.configure(obj) do
+          color 'red'
         end
-        configuration_method :some_method
-        attr_reader :some_thing
+      rescue NoMethodError
       end
+    end
 
-      class Car
-        def nested_thing
-          @nested_thing ||= NestedThing.new
-        end
-        nested_configurable :nested_thing
+    it "provides a 'writer' shortcut" do
+      configurer = Dragonfly::Configurable::Configurer.new do
+        writer :colour, :size
       end
-
-      @car.configure do |c|
-        c.nested_thing.configure do |nt|
-          nt.age = 50
-          nt.some_method('yo')
-        end
+      obj.should_receive(:colour=).with('blue')
+      obj.should_receive(:size=).with('big')
+      configurer.configure(obj) do
+        colour 'blue'
+        size 'big'
       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
+    it "allows using the writer on another object" do
+      configurer = Dragonfly::Configurable::Configurer.new do
+        writer :colour, :for => :egg
       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'
+      egg = double('egg')
+      obj.should_receive(:egg).and_return(egg)
+      egg.should_receive(:colour=).with('pink')
+      configurer.configure(obj) do
+        colour 'pink'
       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 }
+    it "provides a 'meth' shortcut" do
+      configurer = Dragonfly::Configurable::Configurer.new do
+        meth :jobby, :nobby
       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)
+      obj.should_receive(:jobby).with('beans', :make => 5)
+      obj.should_receive(:nobby).with(['nuts'])
+      configurer.configure(obj) do
+        jobby 'beans', :make => 5
+        nobby ['nuts']
       end
+    end
 
-      it "should throw an error if an unknown symbol is passed in" do
-        lambda {
-          @car.configure_with(:eggs)
-        }.should raise_error(ArgumentError)
+    it "allows using 'meth' on another object" do
+      configurer = Dragonfly::Configurable::Configurer.new do
+        meth :jobby, :for => :egg
       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/)
+      egg = double('egg')
+      obj.should_receive(:egg).and_return(egg)
+      egg.should_receive(:jobby).with('beans', :make => 5)
+      configurer.configure(obj) do
+        jobby 'beans', :make => 5
       end
     end
-    
   end
-  
-  describe "falling back to another config" do
-    before(:each) do
-      class Garage
-        include Dragonfly::Configurable
-        configurable_attr :top_speed, 100
-      end
-      @garage = Garage.new
-      @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
+
+  describe "plugins" do
+
+    let (:configurer) { Dragonfly::Configurable::Configurer.new{} }
+    let (:obj) { Object.new }
+
+    it "provides 'plugin' for using plugins" do
+      pluggy = double('plugin')
+      pluggy.should_receive(:call).with(obj, :a, 'few' => ['args'])
+      configurer.configure(obj) do
+        plugin pluggy, :a, 'few' => ['args']
       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
+
+    it "allows using 'plugin' with symbols" do
+      pluggy = double('plugin')
+      pluggy.should_receive(:call).with(obj, :a, 'few' => ['args'])
+      configurer.register_plugin(:pluggy){ pluggy }
+      configurer.configure(obj) do
+        plugin :pluggy, :a, 'few' => ['args']
       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
+
+    it "adds the plugin to the object's 'plugins' if it responds to it when using symbols" do
+      def obj.plugins; @plugins ||= {}; end
+      pluggy = proc{}
+      configurer.register_plugin(:pluggy){ pluggy }
+      configurer.configure(obj) do
+        plugin :pluggy
       end
+      obj.plugins[:pluggy].should == pluggy
     end
-    
-    describe "falling back multiple levels" do
-      before(:each) do
-        @klass = Class.new
-        @klass.class_eval do
-          include Dragonfly::Configurable
-          configurable_attr :veg, 'carrot'
+
+    it "raises an error when a wrong symbol is used" do
+      expect{
+        configurer.configure(obj) do
+          plugin :pluggy, :a, 'few' => ['args']
         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
+      }.to raise_error(Dragonfly::Configurable::UnregisteredPlugin)
     end
-    
-    describe "objects with different methods" do
-      before(:each) do
-        class Dad
-          include Dragonfly::Configurable
-        end
-        @dad = Dad.new
-        class Kid
-          include Dragonfly::Configurable
-          configurable_attr :lug, 'default-lug'
-        end
-        @kid = Kid.new
-        @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
+  end
 
-      it "should not have the fallback obj respond to the method" do
-        @dad.should_not respond_to(:lug=)
-      end
+  describe "extending with Configurable" do
 
-      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
-        class Grandkid
-          include Dragonfly::Configurable
-          configurable_attr :oogie, 'boogie'
-        end
-        grandkid = Grandkid.new
-        grandkid.use_as_fallback_config(@kid)
-        @dad.configure{|c| c.oogie = 'duggen' }
-        grandkid.oogie.should == 'duggen'
-      end
+    let (:car_class) { Class.new do
+      extend Dragonfly::Configurable
+      attr_accessor :colour
+    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'
+    it "adds the set_up_config method to the class" do
+      car_class.set_up_config do
+        writer :colour
       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'
+
+    it "adds the configure method to the instance" do
+      car_class.set_up_config do
+        writer :colour
       end
-      
-      it "should still use its own defaults" do
-        obj = @class.new
-        obj.tree.should == 'elm'
+      car = car_class.new
+      car.should_receive(:colour=).with('mauve')
+      car.configure do
+        colour 'mauve'
       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
+    end
 
-        it "should override the default from the parent" do
-          @obj.tree.should == 'oak'
-        end
+    it "adds the plugins method to the instance" do
+      car_class.set_up_config do
+        writer :colour
       end
+      car = car_class.new
+      car.plugins.should == {}
+    end
 
+    it "doesn't allow configuring if the class hasn't been set up" do
+      car = car_class.new
+      expect{
+        car.configure{}
+      }.to raise_error(NoMethodError)
     end
-    
+
   end
 
-  describe "inheriting configurable_attrs from multiple places" do
+  describe "nested configures" do
+
     before(:each) do
-      module A
-        include Dragonfly::Configurable
-        configurable_attr :a
-      end
-      module B
-        include Dragonfly::Configurable
-        configurable_attr :b
-      end
-      class K
-        include Dragonfly::Configurable
-        include A
-        include B
-        configurable_attr :c
+      @car_class = Class.new do
+        extend Dragonfly::Configurable
+        def initialize
+          @numbers = []
+        end
+        attr_accessor :numbers
       end
-      class L < K
+      @car_class.set_up_config do
+        def add(number)
+          obj.numbers << number
+        end
       end
     end
-    
-    it "should include configuration from all of its mixins" do
-      l = L.new
-      l.configure do |c|
-        c.a = 'something'
-        c.b = 'something'
-        c.c = 'something'
+
+    it "should still work (as some plugins will configure inside a configure)" do
+      car = @car_class.new
+      car.configure do
+        add 1
+        car.configure do
+          add 2
+        end
+        add 3
       end
+      car.numbers.should == [1,2,3]
     end
   end
+
 end
+