[4638] Cleanup of plurals and inheritance relationships in AST

Changed the grammar so that the following "plural" constructs always
parse as an ASTArray:

- funcvalues
- rvalues
- resourceinstances
- anyparams
- params
- caseopts
- casevalues

And the following "singluar" construct never parses as an ASTArray:

- statement

The previous behavior was for these constructs to parse as a scalar
when they represented a single item and an ASTArray when they
contained zero or multiple items.  ("Statement" could sometimes
represent a single item because a single resource declaration could
represent multiple resources).  This complicated other grammar rules
and caused ambiguous handling of nested arrays.

Also made these changes to the AST class hierarchy:

- ResourceInstance no longer derives from ASTArray.  This relationship
  was not meaningful because a ResourceInstance is a (title,
  parameters) pair, not an array, and it produced complications when
  we wanted to represent an array of ResourceInstance objects.

- Resource no longer derives from ResourceReference.  No significant
  functionality was being inherited and the relationship doesn't make
  sense in an AST context.

- ResourceOverride no longer derives from Resource.  No significant
  functionality was being inherited and the relationship doesn't make
  sense in an AST context.

- Resource can now represent a compound resource instance such as
  "notify { foo: ; bar: }".  This saves the parser from having to
  use represent a statement as an array of objects.

- ASTArray's evaluate method never flattens out arrays of arrays.

2 files changed, 33 insertions, 39 deletions

diff --git a/spec/unit/parser/ast/astarray_spec.rb b/spec/unit/parser/ast/astarray_spec.rb
index f79d6c533..8794848b6 100755
--- a/spec/unit/parser/ast/astarray_spec.rb
+++ b/spec/unit/parser/ast/astarray_spec.rb
@@ -23,43 +23,26 @@ describe Puppet::Parser::AST::ASTArray do
     operator.evaluate(@scope)
   end
 
-  it "should evaluate childrens of type ASTArray" do
-    item1 = stub "item1", :is_a? => true
-    item2 = stub "item2"
-    item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
-    item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
-    item2.stubs(:each).yields(item1)
-
-    item1.expects(:safeevaluate).with(@scope).returns(123)
-
-    operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
-    operator.evaluate(@scope).should == [123]
-  end
-
-  it "should flatten children coming from children ASTArray" do
-    item1 = stub "item1", :is_a? => true
-    item2 = stub "item2"
-    item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
-    item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
-    item2.stubs(:each).yields([item1])
-
-    item1.expects(:safeevaluate).with(@scope).returns(123)
-
-    operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
-    operator.evaluate(@scope).should == [123]
+  it "should not flatten children coming from children ASTArray" do
+    item = Puppet::Parser::AST::String.new :value => 'foo'
+    inner_array = Puppet::Parser::AST::ASTArray.new :children => [item, item]
+    operator = Puppet::Parser::AST::ASTArray.new :children => [inner_array, inner_array]
+    operator.evaluate(@scope).should == [['foo', 'foo'], ['foo', 'foo']]
   end
 
   it "should not flatten the results of children evaluation" do
-    item1 = stub "item1", :is_a? => true
-    item2 = stub "item2"
-    item2.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
-    item2.stubs(:instance_of?).with(Puppet::Parser::AST::ASTArray).returns(true)
-    item2.stubs(:each).yields([item1])
-
-    item1.expects(:safeevaluate).with(@scope).returns([123])
+    item = Puppet::Parser::AST::String.new :value => 'foo'
+    item.stubs(:evaluate).returns(['foo'])
+    operator = Puppet::Parser::AST::ASTArray.new :children => [item, item]
+    operator.evaluate(@scope).should == [['foo'], ['foo']]
+  end
 
-    operator = Puppet::Parser::AST::ASTArray.new :children => [item2]
-    operator.evaluate(@scope).should == [[123]]
+  it "should discard nil results from children evaluation" do
+    item1 = Puppet::Parser::AST::String.new :value => 'foo'
+    item2 = Puppet::Parser::AST::String.new :value => 'foo'
+    item2.stubs(:evaluate).returns(nil)
+    operator = Puppet::Parser::AST::ASTArray.new :children => [item1, item2]
+    operator.evaluate(@scope).should == ['foo']
   end
 
   it "should return a valid string with to_s" do
diff --git a/spec/unit/parser/ast/resource_spec.rb b/spec/unit/parser/ast/resource_spec.rb
index 6dbfc1f04..a8e783256 100755
--- a/spec/unit/parser/ast/resource_spec.rb
+++ b/spec/unit/parser/ast/resource_spec.rb
@@ -10,14 +10,15 @@ describe Puppet::Parser::AST::Resource do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
     @scope.stubs(:resource).returns(stub_everything)
-    @resource = ast::Resource.new(:title => @title, :type => "file", :parameters => ast::ASTArray.new(:children => []) )
+    @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"))
-    @resource.stubs(:parameters).returns [param]
+    @instance.stubs(:parameters).returns [param]
 
     @resource.evaluate(@scope)
   end
@@ -34,7 +35,7 @@ describe Puppet::Parser::AST::Resource do
 
     array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-    @resource.title = array
+    @instance.title = array
     result = @resource.evaluate(@scope).collect { |r| r.title }
     result.should be_include("one")
     result.should be_include("two")
@@ -48,12 +49,19 @@ describe Puppet::Parser::AST::Resource do
 
     array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-    @resource.title = array
+    @instance.title = array
     result = @resource.evaluate(@scope).collect { |r| r.title }
     result.should be_include("one")
     result.should be_include("two")
   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
+
   it "should handover resources to the compiler" do
     titles = []
     %w{one two}.each do |title|
@@ -62,7 +70,7 @@ describe Puppet::Parser::AST::Resource do
 
     array = Puppet::Parser::AST::ASTArray.new(:children => titles)
 
-    @resource.title = array
+    @instance.title = array
     result = @resource.evaluate(@scope)
 
     result.each do |res|
@@ -98,7 +106,10 @@ describe Puppet::Parser::AST::Resource do
 
     def resource(type, params = nil)
       params ||= Puppet::Parser::AST::ASTArray.new(:children => [])
-      Puppet::Parser::AST::Resource.new(:type => type, :title => Puppet::Parser::AST::String.new(:value => "myresource"), :parameters => params)
+      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 be able to generate resources with fully qualified type information" do