Merge remote branch 'paul/ticket/next/4657' into next

This patch conflicts with a backport of itself. This merge resolution
favors the original patch for the code changes, and the 2.6.2 patch for
the specs.

Manually Resolved Conflicts:
	lib/puppet/dsl/resource_type_api.rb
	lib/puppet/parser/ast/definition.rb
	lib/puppet/parser/parser_support.rb
	spec/integration/parser/ruby_manifest_spec.rb
	spec/unit/dsl/resource_type_api_spec.rb

1 files changed, 22 insertions, 34 deletions

diff --git a/spec/unit/dsl/resource_type_api_spec.rb b/spec/unit/dsl/resource_type_api_spec.rb
index 4f4eb7e01..c9a5d272f 100755
--- a/spec/unit/dsl/resource_type_api_spec.rb
+++ b/spec/unit/dsl/resource_type_api_spec.rb
@@ -5,62 +5,50 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/dsl/resource_type_api'
 
 describe Puppet::DSL::ResourceTypeAPI do
-  # Run the given block in the context of a new ResourceTypeAPI
-  # object.
+  # Verify that the block creates a single AST node through the API,
+  # instantiate that AST node into a types, and return that type.
   def test_api_call(&block)
-    Thread.current[:known_resource_types] = Puppet::Resource::TypeCollection.new(:env)
-    Puppet::DSL::ResourceTypeAPI.new.instance_eval(&block)
+    main_object = Puppet::DSL::ResourceTypeAPI.new
+    main_object.instance_eval(&block)
+    created_ast_objects = main_object.instance_eval { @__created_ast_objects__ }
+    created_ast_objects.length.should == 1
+    new_types = created_ast_objects[0].instantiate('')
+    new_types.length.should == 1
+    new_types[0]
   ensure
-    Thread.current[:known_resource_types] = nil
+    Thread.current[:ruby_file_parse_result] = nil
   end
 
   [:definition, :node, :hostclass].each do |type|
     method = type == :definition ? "define" : type
     it "should be able to create a #{type}" do
-      newtype = Puppet::Resource::Type.new(:hostclass, "foo")
-      Puppet::Resource::Type.expects(:new).with { |t, n, args| t == type }.returns newtype
-      test_api_call { send(method, "myname") }
+      newtype = test_api_call { send(method, "myname").should == nil }
+      newtype.should be_a(Puppet::Resource::Type)
+      newtype.type.should == type
     end
 
     it "should use the provided name when creating a #{type}" do
-      type = Puppet::Resource::Type.new(:hostclass, "foo")
-      Puppet::Resource::Type.expects(:new).with { |t, n, args| n == "myname" }.returns type
-      test_api_call { send(method, "myname") }
+      newtype = test_api_call { send(method, "myname") }
+      newtype.name.should == "myname"
     end
 
     unless type == :definition
-      it "should pass in any provided options" do
-        type = Puppet::Resource::Type.new(:hostclass, "foo")
-        Puppet::Resource::Type.expects(:new).with { |t, n, args| args == {:myarg => :myvalue} }.returns type
-        test_api_call { send(method, "myname", :myarg => :myvalue) }
+      it "should pass in any provided options when creating a #{type}" do
+        newtype = test_api_call { send(method, "myname", :line => 200) }
+        newtype.line.should == 200
       end
     end
 
     it "should set any provided block as the type's ruby code" do
-      Puppet::Resource::Type.any_instance.expects(:ruby_code=).with { |blk| blk.call == 'foo' }
-      test_api_call { send(method, "myname") { 'foo' } }
-    end
-
-    it "should add the type to the current environment's known resource types" do
-      begin
-        newtype = Puppet::Resource::Type.new(:hostclass, "foo")
-        Puppet::Resource::Type.expects(:new).returns newtype
-        known_resource_types = Puppet::Resource::TypeCollection.new(:env)
-        Thread.current[:known_resource_types] = known_resource_types
-        known_resource_types.expects(:add).with(newtype)
-        Puppet::DSL::ResourceTypeAPI.new.instance_eval { hostclass "myname" }
-      ensure
-        Thread.current[:known_resource_types] = nil
-      end
+      newtype = test_api_call { send(method, "myname") { 'method_result' } }
+      newtype.ruby_code.call.should == 'method_result'
     end
   end
 
   describe "when creating a definition" do
     it "should use the provided options to define valid arguments for the resource type" do
-      newtype = Puppet::Resource::Type.new(:definition, "foo")
-      Puppet::Resource::Type.expects(:new).returns newtype
-      test_api_call { define("myname", :arg1, :arg2) }
-      newtype.instance_eval { @arguments }.should == { 'arg1' => nil, 'arg2' => nil }
+      newtype = test_api_call { define("myname", :arg1, :arg2) }
+      newtype.arguments.should == { 'arg1' => nil, 'arg2' => nil }
     end
   end
 end