puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/parser/templatewrapper_spec.rb

@@ -70,6 +70,12 @@ describe Puppet::Parser::TemplateWrapper do
     tw.tags.should == ["tag1","tag2"]
   end
 
+  it "warns about deprecated access to in-scope variables via method calls" do
+    Puppet.expects(:deprecation_warning).with("Variable access via 'in_scope_variable' is deprecated. Use '@in_scope_variable' instead. template[inline]:1")
+    scope["in_scope_variable"] = "is good"
+    tw.result("<%= in_scope_variable %>")
+  end
+
   it "provides access to in-scope variables via method calls" do
     scope["in_scope_variable"] = "is good"
     tw.result("<%= in_scope_variable %>").should == "is good"
@@ -93,11 +99,6 @@ describe Puppet::Parser::TemplateWrapper do
     tw.result("<%= @one %>").should == "foo"
   end
 
-  it "should not error out if one of the variables is a symbol" do
-    scope.expects(:to_hash).returns(:_timestamp => "1234")
-    tw.result("<%= @_timestamp %>").should == "1234"
-  end
-
   %w{! . ; :}.each do |badchar|
     it "translates #{badchar} to _ in instance variables" do
       scope["one#{badchar}"] = "foo"

data/spec/unit/parser/type_loader_spec.rb

@@ -2,6 +2,8 @@
 require 'spec_helper'
 
 require 'puppet/parser/type_loader'
+require 'puppet/parser/parser_factory'
+require 'puppet/parser/e_parser_adapter'
 require 'puppet_spec/modules'
 require 'puppet_spec/files'
 
@@ -9,222 +11,246 @@ describe Puppet::Parser::TypeLoader do
   include PuppetSpec::Modules
   include PuppetSpec::Files
 
-  before do
-    @loader = Puppet::Parser::TypeLoader.new(:myenv)
-    Puppet.expects(:deprecation_warning).never
-  end
-
-  it "should support an environment" do
-    loader = Puppet::Parser::TypeLoader.new(:myenv)
-    loader.environment.name.should == :myenv
-  end
-
-  it "should include the Environment Helper" do
-    @loader.class.ancestors.should be_include(Puppet::Node::Environment::Helper)
-  end
-
-  it "should delegate its known resource types to its environment" do
-    @loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
-  end
-
-  describe "when loading names from namespaces" do
-    it "should do nothing if the name to import is an empty string" do
-      @loader.expects(:name2files).never
-      @loader.try_load_fqname(:hostclass, "") { |filename, modname| raise :should_not_occur }.should be_nil
+  shared_examples_for 'the typeloader' do
+    before do
+      @loader = Puppet::Parser::TypeLoader.new(:myenv)
+      Puppet.expects(:deprecation_warning).never
     end
 
-    it "should attempt to import each generated name" do
-      @loader.expects(:import).with("foo/bar",nil).returns([])
-      @loader.expects(:import).with("foo",nil).returns([])
-      @loader.try_load_fqname(:hostclass, "foo::bar") { |f| false }
+    it "should support an environment" do
+      loader = Puppet::Parser::TypeLoader.new(:myenv)
+      loader.environment.name.should == :myenv
     end
-  end
 
-  describe "when importing" do
-    before do
-      Puppet::Parser::Files.stubs(:find_manifests).returns ["modname", %w{file}]
-      Puppet::Parser::Parser.any_instance.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
-      Puppet::Parser::Parser.any_instance.stubs(:file=)
+    it "should include the Environment Helper" do
+      @loader.class.ancestors.should be_include(Puppet::Node::Environment::Helper)
     end
 
-    it "should return immediately when imports are being ignored" do
-      Puppet::Parser::Files.expects(:find_manifests).never
-      Puppet[:ignoreimport] = true
-      @loader.import("foo").should be_nil
+    it "should delegate its known resource types to its environment" do
+      @loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
     end
 
-    it "should find all manifests matching the file or pattern" do
-      Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| pat == "myfile" }.returns ["modname", %w{one}]
-      @loader.import("myfile")
-    end
+    describe "when loading names from namespaces" do
+      it "should do nothing if the name to import is an empty string" do
+        @loader.expects(:name2files).never
+        @loader.try_load_fqname(:hostclass, "") { |filename, modname| raise :should_not_occur }.should be_nil
+      end
 
-    it "should use the directory of the current file if one is set" do
-      Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:cwd] == make_absolute("/current") }.returns ["modname", %w{one}]
-      @loader.import("myfile", make_absolute("/current/file"))
+      it "should attempt to import each generated name" do
+        @loader.expects(:import).with("foo/bar",nil).returns([])
+        @loader.expects(:import).with("foo",nil).returns([])
+        @loader.try_load_fqname(:hostclass, "foo::bar") { |f| false }
+      end
     end
 
-    it "should pass the environment when looking for files" do
-      Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:environment] == @loader.environment }.returns ["modname", %w{one}]
-      @loader.import("myfile")
-    end
+    describe "when importing" do
+      before do
+        Puppet::Parser::Files.stubs(:find_manifests).returns ["modname", %w{file}]
+        parser_class.any_instance.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
+        parser_class.any_instance.stubs(:file=)
+      end
 
-    it "should fail if no files are found" do
-      Puppet::Parser::Files.expects(:find_manifests).returns [nil, []]
-      lambda { @loader.import("myfile") }.should raise_error(Puppet::ImportError)
-    end
+      it "should return immediately when imports are being ignored" do
+        Puppet::Parser::Files.expects(:find_manifests).never
+        Puppet[:ignoreimport] = true
+        @loader.import("foo").should be_nil
+      end
 
-    it "should parse each found file" do
-      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", [make_absolute("/one")]]
-      @loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
-      @loader.import("myfile")
-    end
+      it "should find all manifests matching the file or pattern" do
+        Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| pat == "myfile" }.returns ["modname", %w{one}]
+        @loader.import("myfile")
+      end
 
-    it "should make each file qualified before attempting to parse it" do
-      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
-      @loader.expects(:parse_file).with(make_absolute("/current/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
-      @loader.import("myfile", make_absolute("/current/file"))
-    end
+      it "should use the directory of the current file if one is set" do
+        Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:cwd] == make_absolute("/current") }.returns ["modname", %w{one}]
+        @loader.import("myfile", make_absolute("/current/file"))
+      end
 
-    it "should not attempt to import files that have already been imported" do
-      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
-      Puppet::Parser::Parser.any_instance.expects(:parse).once.returns(Puppet::Parser::AST::Hostclass.new(''))
-      @loader.import("myfile")
+      it "should pass the environment when looking for files" do
+        Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:environment] == @loader.environment }.returns ["modname", %w{one}]
+        @loader.import("myfile")
+      end
 
-      # This will fail if it tries to reimport the file.
-      @loader.import("myfile")
-    end
-  end
+      it "should fail if no files are found" do
+        Puppet::Parser::Files.expects(:find_manifests).returns [nil, []]
+        lambda { @loader.import("myfile") }.should raise_error(Puppet::ImportError)
+      end
 
-  describe "when importing all" do
-    before do
-      @base = tmpdir("base")
+      it "should parse each found file" do
+        Puppet::Parser::Files.expects(:find_manifests).returns ["modname", [make_absolute("/one")]]
+        @loader.expects(:parse_file).with(make_absolute("/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
+        @loader.import("myfile")
+      end
 
-      # Create two module path directories
-      @modulebase1 = File.join(@base, "first")
-      FileUtils.mkdir_p(@modulebase1)
-      @modulebase2 = File.join(@base, "second")
-      FileUtils.mkdir_p(@modulebase2)
+      it "should make each file qualified before attempting to parse it" do
+        Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
+        @loader.expects(:parse_file).with(make_absolute("/current/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
+        @loader.import("myfile", make_absolute("/current/file"))
+      end
 
-      Puppet[:modulepath] = "#{@modulebase1}#{File::PATH_SEPARATOR}#{@modulebase2}"
-    end
+      it "should not attempt to import files that have already been imported" do
+        @loader = Puppet::Parser::TypeLoader.new(:myenv)
 
-    def mk_module(basedir, name)
-      PuppetSpec::Modules.create(name, basedir)
+        Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
+        parser_class.any_instance.expects(:parse).once.returns(Puppet::Parser::AST::Hostclass.new(''))
+        other_parser_class.any_instance.expects(:parse).never.returns(Puppet::Parser::AST::Hostclass.new(''))
+        @loader.import("myfile")
+
+        # This will fail if it tries to reimport the file.
+        @loader.import("myfile")
+      end
     end
 
-    # We have to pass the base path so that we can
-    # write to modules that are in the second search path
-    def mk_manifests(base, mod, type, files)
-      exts = {"ruby" => ".rb", "puppet" => ".pp"}
-      files.collect do |file|
-        name = mod.name + "::" + file.gsub("/", "::")
-        path = File.join(base, mod.name, "manifests", file + exts[type])
-        FileUtils.mkdir_p(File.split(path)[0])
-
-        # write out the class
-        if type == "ruby"
-          File.open(path, "w") { |f| f.print "hostclass '#{name}' do\nend" }
-        else
-          File.open(path, "w") { |f| f.print "class #{name} {}" }
+    describe "when importing all" do
+      before do
+        @base = tmpdir("base")
+
+        # Create two module path directories
+        @modulebase1 = File.join(@base, "first")
+        FileUtils.mkdir_p(@modulebase1)
+        @modulebase2 = File.join(@base, "second")
+        FileUtils.mkdir_p(@modulebase2)
+
+        Puppet[:modulepath] = "#{@modulebase1}#{File::PATH_SEPARATOR}#{@modulebase2}"
+      end
+
+      def mk_module(basedir, name)
+        PuppetSpec::Modules.create(name, basedir)
+      end
+
+      # We have to pass the base path so that we can
+      # write to modules that are in the second search path
+      def mk_manifests(base, mod, type, files)
+        exts = {"ruby" => ".rb", "puppet" => ".pp"}
+        files.collect do |file|
+          name = mod.name + "::" + file.gsub("/", "::")
+          path = File.join(base, mod.name, "manifests", file + exts[type])
+          FileUtils.mkdir_p(File.split(path)[0])
+
+          # write out the class
+          if type == "ruby"
+            File.open(path, "w") { |f| f.print "hostclass '#{name}' do\nend" }
+          else
+            File.open(path, "w") { |f| f.print "class #{name} {}" }
+          end
+          name
         end
-        name
       end
-    end
 
-    it "should load all puppet manifests from all modules in the specified environment" do
-      @module1 = mk_module(@modulebase1, "one")
-      @module2 = mk_module(@modulebase2, "two")
+      it "should load all puppet manifests from all modules in the specified environment" do
+        @module1 = mk_module(@modulebase1, "one")
+        @module2 = mk_module(@modulebase2, "two")
 
-      mk_manifests(@modulebase1, @module1, "puppet", %w{a b})
-      mk_manifests(@modulebase2, @module2, "puppet", %w{c d})
+        mk_manifests(@modulebase1, @module1, "puppet", %w{a b})
+        mk_manifests(@modulebase2, @module2, "puppet", %w{c d})
 
-      @loader.import_all
+        @loader.import_all
 
-      @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
-      @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
-      @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
-      @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
-    end
+        @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
+      end
 
-    it "should load all ruby manifests from all modules in the specified environment" do
-      Puppet.expects(:deprecation_warning).at_least(1)
+      it "should load all ruby manifests from all modules in the specified environment" do
+        Puppet.expects(:deprecation_warning).at_least(1)
 
-      @module1 = mk_module(@modulebase1, "one")
-      @module2 = mk_module(@modulebase2, "two")
+        @module1 = mk_module(@modulebase1, "one")
+        @module2 = mk_module(@modulebase2, "two")
 
-      mk_manifests(@modulebase1, @module1, "ruby", %w{a b})
-      mk_manifests(@modulebase2, @module2, "ruby", %w{c d})
+        mk_manifests(@modulebase1, @module1, "ruby", %w{a b})
+        mk_manifests(@modulebase2, @module2, "ruby", %w{c d})
 
-      @loader.import_all
+        @loader.import_all
 
-      @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
-      @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
-      @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
-      @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
-    end
+        @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
+      end
 
-    it "should not load manifests from duplicate modules later in the module path" do
-      @module1 = mk_module(@modulebase1, "one")
+      it "should not load manifests from duplicate modules later in the module path" do
+        @module1 = mk_module(@modulebase1, "one")
 
-      # duplicate
-      @module2 = mk_module(@modulebase2, "one")
+        # duplicate
+        @module2 = mk_module(@modulebase2, "one")
 
-      mk_manifests(@modulebase1, @module1, "puppet", %w{a})
-      mk_manifests(@modulebase2, @module2, "puppet", %w{c})
+        mk_manifests(@modulebase1, @module1, "puppet", %w{a})
+        mk_manifests(@modulebase2, @module2, "puppet", %w{c})
 
-      @loader.import_all
+        @loader.import_all
 
-      @loader.environment.known_resource_types.hostclass("one::c").should be_nil
-    end
+        @loader.environment.known_resource_types.hostclass("one::c").should be_nil
+      end
 
-    it "should load manifests from subdirectories" do
-      @module1 = mk_module(@modulebase1, "one")
+      it "should load manifests from subdirectories" do
+        @module1 = mk_module(@modulebase1, "one")
 
-      mk_manifests(@modulebase1, @module1, "puppet", %w{a a/b a/b/c})
+        mk_manifests(@modulebase1, @module1, "puppet", %w{a a/b a/b/c})
 
-      @loader.import_all
+        @loader.import_all
 
-      @loader.environment.known_resource_types.hostclass("one::a::b").should be_instance_of(Puppet::Resource::Type)
-      @loader.environment.known_resource_types.hostclass("one::a::b::c").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("one::a::b").should be_instance_of(Puppet::Resource::Type)
+        @loader.environment.known_resource_types.hostclass("one::a::b::c").should be_instance_of(Puppet::Resource::Type)
+      end
     end
-  end
 
-  describe "when parsing a file" do
-    before do
-      @parser = Puppet::Parser::Parser.new(@loader.environment)
-      @parser.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
-      @parser.stubs(:file=)
-      Puppet::Parser::Parser.stubs(:new).with(@loader.environment).returns @parser
-    end
+    describe "when parsing a file" do
+      before do
+        @parser = Puppet::Parser::ParserFactory.parser(@loader.environment)
+        @parser.class.should == parser_class
+        @parser.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
+        @parser.stubs(:file=)
+        Puppet::Parser::ParserFactory.stubs(:parser).with(@loader.environment).returns @parser
+      end
 
-    it "should create a new parser instance for each file using the current environment" do
-      Puppet::Parser::Parser.expects(:new).with(@loader.environment).returns @parser
-      @loader.parse_file("/my/file")
-    end
+      it "should create a new parser instance for each file using the current environment" do
+        Puppet::Parser::ParserFactory.expects(:parser).with(@loader.environment).returns @parser
+        @loader.parse_file("/my/file")
+      end
 
-    it "should assign the parser its file and parse" do
-      @parser.expects(:file=).with("/my/file")
-      @parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
-      @loader.parse_file("/my/file")
+      it "should assign the parser its file and parse" do
+        @parser.expects(:file=).with("/my/file")
+        @parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
+        @loader.parse_file("/my/file")
+      end
     end
-  end
 
-  it "should be able to add classes to the current resource type collection" do
-    file = tmpfile("simple_file.pp")
-    File.open(file, "w") { |f| f.puts "class foo {}" }
-    @loader.import(file)
+    it "should be able to add classes to the current resource type collection" do
+      file = tmpfile("simple_file.pp")
+      File.open(file, "w") { |f| f.puts "class foo {}" }
+      @loader.import(file)
 
-    @loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
-  end
+      @loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
+    end
 
-  describe "when deciding where to look for files" do
-    { 'foo' => ['foo'],
-      'foo::bar' => ['foo/bar', 'foo'],
-      'foo::bar::baz' => ['foo/bar/baz', 'foo/bar', 'foo']
-    }.each do |fqname, expected_paths|
-      it "should look for #{fqname.inspect} in #{expected_paths.inspect}" do
-        @loader.instance_eval { name2files(fqname) }.should == expected_paths
+    describe "when deciding where to look for files" do
+      { 'foo' => ['foo'],
+        'foo::bar' => ['foo/bar', 'foo'],
+        'foo::bar::baz' => ['foo/bar/baz', 'foo/bar', 'foo']
+      }.each do |fqname, expected_paths|
+        it "should look for #{fqname.inspect} in #{expected_paths.inspect}" do
+          @loader.instance_eval { name2files(fqname) }.should == expected_paths
+        end
       end
     end
   end
+  describe 'when using the classic parser' do
+    before :each do
+      Puppet[:parser] = 'current'
+    end
+    it_should_behave_like 'the typeloader' do
+      let(:parser_class) { Puppet::Parser::Parser}
+      let(:other_parser_class) { Puppet::Parser::EParserAdapter}
+    end
+  end
+  describe 'when using the future parser' do
+    before :each do
+      Puppet[:parser] = 'future'
+    end
+    it_should_behave_like 'the typeloader' do
+      let(:parser_class) { Puppet::Parser::EParserAdapter}
+      let(:other_parser_class) { Puppet::Parser::Parser}
+    end
+  end
 end

data/spec/unit/pops/adaptable_spec.rb

@@ -0,0 +1,143 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+describe Puppet::Pops::Adaptable::Adapter do
+  class ValueAdapter < Puppet::Pops::Adaptable::Adapter
+    attr_accessor :value
+  end
+
+  class OtherAdapter < Puppet::Pops::Adaptable::Adapter
+    attr_accessor :value
+    def OtherAdapter.create_adapter(o)
+      x = new
+      x.value="I am calling you Daffy."
+      x
+    end
+  end
+
+  module Farm
+    class FarmAdapter < Puppet::Pops::Adaptable::Adapter
+      attr_accessor :value
+    end
+  end
+
+  class Duck
+    include Puppet::Pops::Adaptable
+  end
+
+  it "should create specialized adapter instance on call to adapt" do
+    d = Duck.new
+    a = ValueAdapter.adapt(d)
+    a.class.should == ValueAdapter
+  end
+
+  it "should produce the same instance on multiple adaptations" do
+    d = Duck.new
+    a = ValueAdapter.adapt(d)
+    a.value = 10
+    b = ValueAdapter.adapt(d)
+    b.value.should == 10
+  end
+
+  it "should return the correct adapter if there are several" do
+    d = Duck.new
+    other = OtherAdapter.adapt(d)
+    a = ValueAdapter.adapt(d)
+    a.value = 10
+    b = ValueAdapter.adapt(d)
+    b.value.should == 10
+  end
+
+  it "should allow specialization to override creating" do
+    d = Duck.new
+    a = OtherAdapter.adapt(d)
+    a.value.should == "I am calling you Daffy."
+  end
+
+  it "should create a new adapter overriding existing" do
+    d = Duck.new
+    a = OtherAdapter.adapt(d)
+    a.value.should == "I am calling you Daffy."
+    a.value = "Something different"
+    a.value.should == "Something different"
+    b = OtherAdapter.adapt(d)
+    b.value.should == "Something different"
+    b = OtherAdapter.adapt_new(d)
+    b.value.should == "I am calling you Daffy."
+  end
+
+  it "should not create adapter on get" do
+    d = Duck.new
+    a = OtherAdapter.get(d)
+    a.should == nil
+  end
+
+  it "should return same adapter from get after adapt" do
+    d = Duck.new
+    a = OtherAdapter.get(d)
+    a.should == nil
+    a = OtherAdapter.adapt(d)
+    a.value.should == "I am calling you Daffy."
+    b = OtherAdapter.get(d)
+    b.value.should == "I am calling you Daffy."
+    a.should == b
+  end
+
+  it "should handle adapters in nested namespaces" do
+    d = Duck.new
+    a = Farm::FarmAdapter.get(d)
+    a.should == nil
+    a = Farm::FarmAdapter.adapt(d)
+    a.value = 10
+    b = Farm::FarmAdapter.get(d)
+    b.value.should == 10
+    # Test implementation detail
+    d.instance_variables.include?(:@Farm_FarmAdapter).should == true
+  end
+
+  it "should be able to clear the adapter" do
+    d = Duck.new
+    a = OtherAdapter.adapt(d)
+    a.value.should == "I am calling you Daffy."
+    # The adapter cleared should be returned
+    OtherAdapter.clear(d).value.should == "I am calling you Daffy."
+    OtherAdapter.get(d).should == nil
+  end
+
+  context "When adapting with #adapt it" do
+    it "should be possible to pass a block to configure the adapter" do
+      d = Duck.new
+      a = OtherAdapter.adapt(d) do |x|
+        x.value = "Donald"
+      end
+      a.value.should == "Donald"
+    end
+
+    it "should be possible to pass a block to configure the adapter and get the adapted" do
+      d = Duck.new
+      a = OtherAdapter.adapt(d) do |x, o|
+        x.value = "Donald, the #{o.class.name}"
+      end
+      a.value.should == "Donald, the Duck"
+    end
+  end
+
+  context "When adapting with #adapt_new it" do
+    it "should be possible to pass a block to configure the adapter" do
+      d = Duck.new
+      a = OtherAdapter.adapt_new(d) do |x|
+        x.value = "Donald"
+      end
+      a.value.should == "Donald"
+    end
+
+    it "should be possible to pass a block to configure the adapter and get the adapted" do
+      d = Duck.new
+      a = OtherAdapter.adapt_new(d) do |x, o|
+        x.value = "Donald, the #{o.class.name}"
+      end
+      a.value.should == "Donald, the Duck"
+    end
+  end
+end