Merge commit '2.6.3rc2' into next

Manually resolved conflicts:
	lib/puppet/parser/ast/resource.rb
	spec/unit/parser/ast/resource_spec.rb

4 files changed, 164 insertions, 117 deletions

diff --git a/spec/unit/parser/ast/resource_spec.rb b/spec/unit/parser/ast/resource_spec.rb
index a8e783256..3ed7b3e08 100755
--- a/spec/unit/parser/ast/resource_spec.rb
+++ b/spec/unit/parser/ast/resource_spec.rb
@@ -5,134 +5,180 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 describe Puppet::Parser::AST::Resource do
   ast = Puppet::Parser::AST
 
-  before :each do
-    @title = Puppet::Parser::AST::String.new(:value => "mytitle")
-    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-    @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
-    @scope.stubs(:resource).returns(stub_everything)
-    @instance = ast::ResourceInstance.new(:title => @title, :parameters => ast::ASTArray.new(:children => []))
-    @resource = ast::Resource.new(:type => "file", :instances => ast::ASTArray.new(:children => [@instance]))
-    @resource.stubs(:qualified_type).returns("Resource")
-  end
+  describe "for builtin types" do
+    before :each do
+      @title = Puppet::Parser::AST::String.new(:value => "mytitle")
+      @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
+      @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+      @scope.stubs(:resource).returns(stub_everything)
+      @instance = ast::ResourceInstance.new(:title => @title, :parameters => ast::ASTArray.new(:children => []))
+      @resource = ast::Resource.new(:type => "file", :instances => ast::ASTArray.new(:children => [@instance]))
+      @resource.stubs(:qualified_type).returns("Resource")
+    end
 
-  it "should evaluate all its parameters" do
-    param = stub 'param'
-    param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
-    @instance.stubs(:parameters).returns [param]
+    it "should evaluate all its parameters" do
+      param = stub 'param'
+      param.expects(:safeevaluate).with(@scope).returns Puppet::Parser::Resource::Param.new(:name => "myparam", :value => "myvalue", :source => stub("source"))
+      @instance.stubs(:parameters).returns [param]
 
-    @resource.evaluate(@scope)
-  end
+      @resource.evaluate(@scope)
+    end
 
-  it "should evaluate its title" do
-    @resource.evaluate(@scope)[0].title.should == "mytitle"
-  end
+    it "should evaluate its title" do
+      @resource.evaluate(@scope)[0].title.should == "mytitle"
+    end
+
+    it "should flatten the titles array" do
+      titles = []
+      %w{one two}.each do |title|
+        titles << Puppet::Parser::AST::String.new(:value => title)
+      end
 
-  it "should flatten the titles array" do
-    titles = []
-    %w{one two}.each do |title|
-      titles << Puppet::Parser::AST::String.new(:value => title)
+      array = Puppet::Parser::AST::ASTArray.new(:children => titles)
+
+      @instance.title = array
+      result = @resource.evaluate(@scope).collect { |r| r.title }
+      result.should be_include("one")
+      result.should be_include("two")
     end
 
-    array = Puppet::Parser::AST::ASTArray.new(:children => titles)
+    it "should create and return one resource objects per title" do
+      titles = []
+      %w{one two}.each do |title|
+        titles << Puppet::Parser::AST::String.new(:value => title)
+      end
 
-    @instance.title = array
-    result = @resource.evaluate(@scope).collect { |r| r.title }
-    result.should be_include("one")
-    result.should be_include("two")
-  end
+      array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-  it "should create and return one resource objects per title" do
-    titles = []
-    %w{one two}.each do |title|
-      titles << Puppet::Parser::AST::String.new(:value => title)
+      @instance.title = array
+      result = @resource.evaluate(@scope).collect { |r| r.title }
+      result.should be_include("one")
+      result.should be_include("two")
     end
 
-    array = Puppet::Parser::AST::ASTArray.new(:children => titles)
+    it "should implicitly iterate over instances" do
+      new_title = Puppet::Parser::AST::String.new(:value => "other_title")
+      new_instance = ast::ResourceInstance.new(:title => new_title, :parameters => ast::ASTArray.new(:children => []))
+      @resource.instances.push(new_instance)
+      @resource.evaluate(@scope).collect { |r| r.title }.should == ["mytitle", "other_title"]
+    end
 
-    @instance.title = array
-    result = @resource.evaluate(@scope).collect { |r| r.title }
-    result.should be_include("one")
-    result.should be_include("two")
-  end
+    it "should handover resources to the compiler" do
+      titles = []
+      %w{one two}.each do |title|
+        titles << Puppet::Parser::AST::String.new(:value => title)
+      end
 
-  it "should implicitly iterate over instances" do
-    new_title = Puppet::Parser::AST::String.new(:value => "other_title")
-    new_instance = ast::ResourceInstance.new(:title => new_title, :parameters => ast::ASTArray.new(:children => []))
-    @resource.instances.push(new_instance)
-    @resource.evaluate(@scope).collect { |r| r.title }.should == ["mytitle", "other_title"]
-  end
+      array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-  it "should handover resources to the compiler" do
-    titles = []
-    %w{one two}.each do |title|
-      titles << Puppet::Parser::AST::String.new(:value => title)
+      @instance.title = array
+      result = @resource.evaluate(@scope)
+
+      result.each do |res|
+        @compiler.catalog.resource(res.ref).should be_instance_of(Puppet::Parser::Resource)
+      end
     end
 
-    array = Puppet::Parser::AST::ASTArray.new(:children => titles)
+    it "should generate virtual resources if it is virtual" do
+      @resource.virtual = true
+
+      result = @resource.evaluate(@scope)
+      result[0].should be_virtual
+    end
 
-    @instance.title = array
-    result = @resource.evaluate(@scope)
+    it "should generate virtual and exported resources if it is exported" do
+      @resource.exported = true
 
-    result.each do |res|
-      @compiler.catalog.resource(res.ref).should be_instance_of(Puppet::Parser::Resource)
+      result = @resource.evaluate(@scope)
+      result[0].should be_virtual
+      result[0].should be_exported
     end
-  end
-  it "should generate virtual resources if it is virtual" do
-    @resource.virtual = true
 
-    result = @resource.evaluate(@scope)
-    result[0].should be_virtual
-  end
+    # Related to #806, make sure resources always look up the full path to the resource.
+    describe "when generating qualified resources" do
+      before do
+        @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
+        @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
+        ["one", "one::two", "three"].each do |name|
+          @parser.environment.known_resource_types.add(Puppet::Resource::Type.new(:definition, name, {}))
+        end
+        @twoscope = @scope.newscope(:namespace => "one")
+        @twoscope.resource = @scope.resource
+      end
 
-  it "should generate virtual and exported resources if it is exported" do
-    @resource.exported = true
+      def resource(type, params = nil)
+        params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
+        instance = Puppet::Parser::AST::ResourceInstance.new(
+                                                             :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
+        Puppet::Parser::AST::Resource.new(:type => type,
+                                          :instances => Puppet::Parser::AST::ASTArray.new(:children => [instance]))
+      end
 
-    result = @resource.evaluate(@scope)
-    result[0].should be_virtual
-    result[0].should be_exported
-  end
+      it "should be able to generate resources with fully qualified type information" do
+        resource("two").evaluate(@twoscope)[0].type.should == "One::Two"
+      end
 
-  # Related to #806, make sure resources always look up the full path to the resource.
-  describe "when generating qualified resources" do
-    before do
-      @scope = Puppet::Parser::Scope.new :compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-      @parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new)
-      ["one", "one::two", "three"].each do |name|
-        @parser.environment.known_resource_types.add(Puppet::Resource::Type.new(:definition, name, {}))
+      it "should be able to generate resources with unqualified type information" do
+        resource("one").evaluate(@twoscope)[0].type.should == "One"
       end
-      @twoscope = @scope.newscope(:namespace => "one")
-      @twoscope.resource = @scope.resource
-    end
 
-    def resource(type, params = nil)
-      params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
-      instance = Puppet::Parser::AST::ResourceInstance.new(
-          :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
-      Puppet::Parser::AST::Resource.new(:type => type,
-                                        :instances => Puppet::Parser::AST::ASTArray.new(:children => [instance]))
-    end
+      it "should correctly generate resources that can look up builtin types" do
+        resource("file").evaluate(@twoscope)[0].type.should == "File"
+      end
 
-    it "should be able to generate resources with fully qualified type information" do
-      resource("two").evaluate(@twoscope)[0].type.should == "One::Two"
-    end
+      it "should correctly generate resources that can look up defined classes by title" do
+        @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
+        @scope.compiler.stubs(:evaluate_classes)
+        res = resource("class").evaluate(@twoscope)[0]
+        res.type.should == "Class"
+        res.title.should == "Myresource"
+      end
 
-    it "should be able to generate resources with unqualified type information" do
-      resource("one").evaluate(@twoscope)[0].type.should == "One"
+      it "should evaluate parameterized classes when they are instantiated" do
+        @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
+        @scope.compiler.expects(:evaluate_classes).with(['myresource'],@twoscope,false)
+        resource("class").evaluate(@twoscope)[0]
+      end
+
+      it "should fail for resource types that do not exist" do
+        lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
+      end
     end
+  end
 
-    it "should correctly generate resources that can look up builtin types" do
-      resource("file").evaluate(@twoscope)[0].type.should == "File"
+  describe "for class resources" do
+    before do
+      @title = Puppet::Parser::AST::String.new(:value => "classname")
+      @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
+      @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
+      @scope.stubs(:resource).returns(stub_everything)
+      @instance = ast::ResourceInstance.new(:title => @title, :parameters => ast::ASTArray.new(:children => []))
+      @resource = ast::Resource.new(:type => "Class", :instances => ast::ASTArray.new(:children => [@instance]))
+      @resource.stubs(:qualified_type).returns("Resource")
+      @type = Puppet::Resource::Type.new(:hostclass, "classname")
+      @compiler.known_resource_types.add(@type)
     end
 
-    it "should correctly generate resources that can look up defined classes by title" do
-      @scope.known_resource_types.add_hostclass Puppet::Resource::Type.new(:hostclass, "Myresource", {})
-      res = resource("class").evaluate(@twoscope)[0]
-      res.type.should == "Class"
-      res.title.should == "Myresource"
+    it "should instantiate the class" do
+      @compiler.stubs(:evaluate_classes)
+      result = @resource.evaluate(@scope)
+      result.length.should == 1
+      result.first.ref.should == "Class[Classname]"
+      @compiler.catalog.resource("Class[Classname]").should equal result.first
     end
 
-    it "should fail for resource types that do not exist" do
-      lambda { resource("nosuchtype").evaluate(@twoscope) }.should raise_error(Puppet::ParseError)
+    it "should cause its parent to be evaluated" do
+      parent_type = Puppet::Resource::Type.new(:hostclass, "parentname")
+      @compiler.stubs(:evaluate_classes)
+      @compiler.known_resource_types.add(parent_type)
+      @type.parent = "parentname"
+      result = @resource.evaluate(@scope)
+      result.length.should == 1
+      result.first.ref.should == "Class[Classname]"
+      @compiler.catalog.resource("Class[Classname]").should equal result.first
+      @compiler.catalog.resource("Class[Parentname]").should be_instance_of(Puppet::Parser::Resource)
     end
+
   end
+
 end
diff --git a/spec/unit/parser/compiler_spec.rb b/spec/unit/parser/compiler_spec.rb
index 22d52f257..95f3853e2 100755
--- a/spec/unit/parser/compiler_spec.rb
+++ b/spec/unit/parser/compiler_spec.rb
@@ -580,7 +580,7 @@ describe Puppet::Parser::Compiler do
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
-      @class.expects(:mk_plain_resource).with(@scope)
+      @class.expects(:ensure_in_catalog).with(@scope)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
@@ -591,7 +591,7 @@ describe Puppet::Parser::Compiler do
 
       @resource.expects(:evaluate).never
 
-      @class.expects(:mk_plain_resource).returns(@resource)
+      @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope)
@@ -601,7 +601,7 @@ describe Puppet::Parser::Compiler do
       @compiler.catalog.stubs(:tag)
 
       @resource.expects(:evaluate)
-      @class.expects(:mk_plain_resource).returns(@resource)
+      @class.expects(:ensure_in_catalog).returns(@resource)
       @scope.stubs(:class_scope).with(@class)
 
       @compiler.evaluate_classes(%w{myclass}, @scope, false)
@@ -638,7 +638,7 @@ describe Puppet::Parser::Compiler do
       @scope.stubs(:class_scope).with(@class)
 
       Puppet::Parser::Resource.stubs(:new).returns(@resource)
-      @class.stubs :mk_plain_resource
+      @class.stubs :ensure_in_catalog
       @compiler.evaluate_classes(%w{myclass notfound}, @scope).should == %w{myclass}
     end
   end
@@ -678,7 +678,7 @@ describe Puppet::Parser::Compiler do
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
-      node_class.expects(:mk_plain_resource).returns(node_resource)
+      node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
@@ -688,7 +688,7 @@ describe Puppet::Parser::Compiler do
       @compiler.known_resource_types.stubs(:node).with("default").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[default]", :evaluate => nil, :type => "node"
-      node_class.expects(:mk_plain_resource).returns(node_resource)
+      node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       @compiler.compile
     end
@@ -698,7 +698,7 @@ describe Puppet::Parser::Compiler do
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
       node_resource = stub 'node resource', :ref => "Node[c]", :type => "node"
-      node_class.expects(:mk_plain_resource).returns(node_resource)
+      node_class.expects(:ensure_in_catalog).returns(node_resource)
 
       node_resource.expects(:evaluate)
 
@@ -707,7 +707,7 @@ describe Puppet::Parser::Compiler do
 
     it "should set the node's scope as the top scope" do
       node_resource = stub 'node resource', :ref => "Node[c]", :evaluate => nil, :type => "node"
-      node_class = stub 'node', :name => "c", :mk_plain_resource => node_resource
+      node_class = stub 'node', :name => "c", :ensure_in_catalog => node_resource
 
       @compiler.known_resource_types.stubs(:node).with("c").returns(node_class)
 
diff --git a/spec/unit/parser/lexer_spec.rb b/spec/unit/parser/lexer_spec.rb
index 2d67bf357..d52add399 100755
--- a/spec/unit/parser/lexer_spec.rb
+++ b/spec/unit/parser/lexer_spec.rb
@@ -424,6 +424,7 @@ describe Puppet::Parser::Lexer,"when lexing strings" do
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],
     %q{"string with an escaped '\\$'"}                              => [[:STRING,"string with an escaped '$'"]],
+    %Q{"string with a line ending with a backslash: \\\nfoo"}       => [[:STRING,"string with a line ending with a backslash: foo"]],
     %q{"string with $v (but no braces)"}                            => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']],
     %q["string with ${v} in braces"]                                => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' in braces']],
     %q["string with ${qualified::var} in braces"]                   => [[:DQPRE,"string with "],[:VARIABLE,'qualified::var'],[:DQPOST,' in braces']],
diff --git a/spec/unit/resource/type_spec.rb b/spec/unit/resource/type_spec.rb
index 7701e55d5..ef45712e6 100755
--- a/spec/unit/resource/type_spec.rb
+++ b/spec/unit/resource/type_spec.rb
@@ -579,29 +579,29 @@ describe Puppet::Resource::Type do
     end
 
     it "should create a resource instance" do
-      @top.mk_plain_resource(@scope).should be_instance_of(Puppet::Parser::Resource)
+      @top.ensure_in_catalog(@scope).should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should set its resource type to 'class' when it is a hostclass" do
-      Puppet::Resource::Type.new(:hostclass, "top").mk_plain_resource(@scope).type.should == "Class"
+      Puppet::Resource::Type.new(:hostclass, "top").ensure_in_catalog(@scope).type.should == "Class"
     end
 
     it "should set its resource type to 'node' when it is a node" do
-      Puppet::Resource::Type.new(:node, "top").mk_plain_resource(@scope).type.should == "Node"
+      Puppet::Resource::Type.new(:node, "top").ensure_in_catalog(@scope).type.should == "Node"
     end
 
     it "should fail when it is a definition" do
-      lambda { Puppet::Resource::Type.new(:definition, "top").mk_plain_resource(@scope) }.should raise_error(ArgumentError)
+      lambda { Puppet::Resource::Type.new(:definition, "top").ensure_in_catalog(@scope) }.should raise_error(ArgumentError)
     end
 
     it "should add the created resource to the scope's catalog" do
-      @top.mk_plain_resource(@scope)
+      @top.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should evaluate the parent class if one exists" do
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
@@ -609,40 +609,40 @@ describe Puppet::Resource::Type do
     it "should fail to evaluate if a parent class is defined but cannot be found" do
       othertop = Puppet::Resource::Type.new :hostclass, "something", :parent => "yay"
       @code.add othertop
-      lambda { othertop.mk_plain_resource(@scope) }.should raise_error(Puppet::ParseError)
+      lambda { othertop.ensure_in_catalog(@scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should not create a new resource if one already exists" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
-      @top.mk_plain_resource(@scope)
+      @top.ensure_in_catalog(@scope)
     end
 
     it "should return the existing resource when not creating a new one" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
-      @top.mk_plain_resource(@scope).should == "something"
+      @top.ensure_in_catalog(@scope).should == "something"
     end
 
     it "should not create a new parent resource if one already exists and it has a parent class" do
-      @top.mk_plain_resource(@scope)
+      @top.ensure_in_catalog(@scope)
 
       top_resource = @compiler.catalog.resource(:class, "top")
 
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should equal(top_resource)
     end
 
     # #795 - tag before evaluation.
     it "should tag the catalog with the resource tags when it is evaluated" do
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("middle")
     end
 
     it "should tag the catalog with the parent class tags when it is evaluated" do
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("top")
     end