From 6dbd4771265173a9d4c3e7756c35c9ca371ca394 Mon Sep 17 00:00:00 2001
From: Jesse Wolfe <jes5199@gmail.com>
Date: Wed, 28 Jul 2010 14:54:23 -0700
Subject: [#4397]+[#4344] Move type-name resolution out of Puppet::Resource
 into the AST resources.

Move type-name resolution out of Puppet::Resource into the AST resources.
Move find_resource_type out of Puppet::Resource into Scope
Thus, never pass unqualified type names to Puppet::Resource objects.
Thus, Puppet::Resource objects don't need the namespace property,
and Puppet::Resource objects never consult the harddrive to look for
.pp files that might contain their type definitions,
Thus, performance is improved.

Also removes the temporary fix for #4257 that caused #4397
(The code was too eager to look for a class in the topscope)

Paired-With: Paul Berry <paul@puppetlabs.com>
Signed-off-by: Jesse Wolfe <jes5199@gmail.com>
---
 spec/unit/parser/ast/resource_reference_spec.rb |  5 -----
 spec/unit/parser/functions/require_spec.rb      |  2 +-
 spec/unit/parser/functions/tag_spec.rb          |  1 +
 spec/unit/parser/resource_spec.rb               | 12 +++---------
 4 files changed, 5 insertions(+), 15 deletions(-)

(limited to 'spec/unit/parser')

diff --git a/spec/unit/parser/ast/resource_reference_spec.rb b/spec/unit/parser/ast/resource_reference_spec.rb
index 7b48119f4..93419d963 100755
--- a/spec/unit/parser/ast/resource_reference_spec.rb
+++ b/spec/unit/parser/ast/resource_reference_spec.rb
@@ -32,11 +32,6 @@ describe Puppet::Parser::AST::ResourceReference do
     ]
   end
 
-  it "should pass its scope's namespaces to all created resource references" do
-    @scope.add_namespace "foo"
-    newref("File", "/tmp/yay").evaluate(@scope).namespaces.should == ["foo"]
-  end
-
   it "should return a correct representation when converting to string" do
     type = stub 'type', :is_a? => true, :to_s => "file"
     title = stub 'title', :is_a? => true, :to_s => "[/tmp/a, /tmp/b]"
diff --git a/spec/unit/parser/functions/require_spec.rb b/spec/unit/parser/functions/require_spec.rb
index bd42fa579..49c4bbf74 100755
--- a/spec/unit/parser/functions/require_spec.rb
+++ b/spec/unit/parser/functions/require_spec.rb
@@ -6,7 +6,7 @@ describe "the require function" do
 
   before :each do
     @catalog = stub 'catalog'
-    @compiler = stub 'compiler', :catalog => @catalog
+    @compiler = stub 'compiler', :catalog => @catalog, :environment => nil
 
     @scope = Puppet::Parser::Scope.new
     @scope.stubs(:findresource)
diff --git a/spec/unit/parser/functions/tag_spec.rb b/spec/unit/parser/functions/tag_spec.rb
index ff37badbb..dac134134 100755
--- a/spec/unit/parser/functions/tag_spec.rb
+++ b/spec/unit/parser/functions/tag_spec.rb
@@ -6,6 +6,7 @@ describe "the 'tag' function" do
 
   before :each do
     @scope = Puppet::Parser::Scope.new
+    @scope.stubs(:environment).returns(nil)
   end
 
   it "should exist" do
diff --git a/spec/unit/parser/resource_spec.rb b/spec/unit/parser/resource_spec.rb
index da49940b0..dae22fcaa 100755
--- a/spec/unit/parser/resource_spec.rb
+++ b/spec/unit/parser/resource_spec.rb
@@ -58,23 +58,17 @@ describe Puppet::Parser::Resource do
   end
 
   it "should get its environment from its scope" do
-    scope = stub 'scope', :source => stub("source")
-    scope.expects(:environment).returns "foo"
+    scope = stub 'scope', :source => stub("source"), :namespaces => nil
+    scope.expects(:environment).returns("foo").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment.should == "foo"
   end
 
-  it "should get its namespaces from its scope" do
-    scope = stub 'scope', :source => stub("source")
-    scope.expects(:namespaces).returns %w{one two}
-    Puppet::Parser::Resource.new("file", "whatever", :scope => scope).namespaces.should == %w{one two}
-  end
-
   it "should use the resource type collection helper module" do
     Puppet::Parser::Resource.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should use the scope's environment as its environment" do
-    @scope.expects(:environment).returns "myenv"
+    @scope.expects(:environment).returns("myenv").at_least_once
     Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment.should == "myenv"
   end
 
-- 
cgit 


From 6b1dd81799a44288287d9ab0cdf46afa3aaf090a Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Thu, 5 Aug 2010 10:34:35 -0700
Subject: [#4472]+[#4483] Moved type-name resolution out of
 Puppet::Parser::TypeLoader.

Moved type-name resolution out of Puppet::Parser::TypeLoader, and into
its primary client, Puppet::Resource::TypeCollection.  TypeCollection
now always passes fully qualified type names to TypeLoader.

This avoids duplicate type-name resolution logic between TypeLoader
and TypeCollection.  That in turn fixes bug 4472, which resulted
from flaws in the type-name resolution logic in TypeLoader.

In addition, it fixes bug 4483, which resulted from improper
interleaving between looking up names using the TypeCollection and the
TypeLoader.
---
 spec/unit/parser/type_loader_spec.rb | 83 ++++++++----------------------------
 1 file changed, 18 insertions(+), 65 deletions(-)

(limited to 'spec/unit/parser')

diff --git a/spec/unit/parser/type_loader_spec.rb b/spec/unit/parser/type_loader_spec.rb
index 8f005d551..b7e174753 100644
--- a/spec/unit/parser/type_loader_spec.rb
+++ b/spec/unit/parser/type_loader_spec.rb
@@ -28,86 +28,28 @@ describe Puppet::Parser::TypeLoader do
   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.load_until(["foo"], "") { |f| false }.should be_nil
-    end
-
-    it "should turn the provided namespaces and name into a list of files" do
-      @loader.expects(:name2files).with(["foo"], "bar").returns []
-      @loader.load_until(["foo"], "bar") { |f| false }
+      @loader.try_load_fqname("") { |filename, modname| raise :should_not_occur }.should be_nil
     end
 
     it "should attempt to import each generated name" do
-      @loader.expects(:name2files).returns %w{foo bar}
+      @loader.expects(:import).with("foo/bar",nil)
       @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.load_until(["foo"], "bar") { |f| false }
+      @loader.try_load_fqname("foo::bar") { |f| false }
     end
 
     it "should yield after each import" do
       yielded = []
-      @loader.expects(:name2files).returns %w{foo bar}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.load_until(["foo"], "bar") { |f| yielded << f; false }
-      yielded.should == %w{foo bar}
-    end
-
-    it "should stop importing when the yielded block returns true" do
-      yielded = []
-      @loader.expects(:name2files).returns %w{foo bar baz}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.expects(:import).with("baz",nil).never
-      @loader.load_until(["foo"], "bar") { |f| true if f == "bar" }
-    end
-
-    it "should return the result of the block" do
-      yielded = []
-      @loader.expects(:name2files).returns %w{foo bar baz}
+      @loader.expects(:import).with("foo/bar",nil)
       @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.expects(:import).with("baz",nil).never
-      @loader.load_until(["foo"], "bar") { |f| 10 if f == "bar" }.should == 10
-    end
-
-    it "should return nil if the block never returns true" do
-      @loader.expects(:name2files).returns %w{foo bar}
-      @loader.expects(:import).with("foo",nil)
-      @loader.expects(:import).with("bar",nil)
-      @loader.load_until(["foo"], "bar") { |f| false }.should be_nil
+      @loader.try_load_fqname("foo::bar") { |filename, modname| yielded << [filename, modname]; false }
+      yielded.should == [["foo/bar", nil], ["foo", nil]]
     end
 
     it "should know when a given name has been loaded" do
-      @loader.expects(:name2files).returns %w{file}
       @loader.expects(:import).with("file",nil)
-      @loader.load_until(["foo"], "bar") { |f| true }
+      @loader.try_load_fqname("file") { |f| true }
       @loader.should be_loaded("file")
     end
-
-    it "should set the module name on any created resource types" do
-      type = Puppet::Resource::Type.new(:hostclass, "mytype")
-
-      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
-      @loader.stubs(:parse_file)
-      @loader.load_until(["foo"], "one") { |f| type }
-
-      type.module_name.should == "modname"
-    end
-  end
-
-  describe "when mapping names to files" do
-    {
-      [["foo"], "::bar::baz"] => %w{bar/baz},
-      [[""], "foo::bar"]      => %w{foo foo/bar},
-      [%w{foo}, "bar"]        => %w{foo foo/bar bar},
-      [%w{a b}, "bar"]        => %w{a a/bar b b/bar bar},
-      [%w{a::b::c}, "bar"]    => %w{a a/b/c/bar bar},
-      [%w{a::b}, "foo::bar"]  => %w{a a/b/foo/bar foo/bar}
-    }.each do |inputs, outputs|
-      it "should produce #{outputs.inspect} from the #{inputs[0].inspect} namespace and #{inputs[1]} name" do
-        @loader.name2files(*inputs).should == outputs
-      end
-    end
   end
 
   describe "when importing" do
@@ -198,4 +140,15 @@ describe Puppet::Parser::TypeLoader do
 
     @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
+      end
+    end
+  end
 end
-- 
cgit 


From 4da88fb4cd57871f16649d50572240ac3f7420f0 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Fri, 13 Aug 2010 15:43:34 -0700
Subject: [#4496]+[#4521]+[#4522] Add structures to the AST to represent type
 definitions (classes, definitions, and nodes).

Previously, type definitions were not represented directly in the AST.
Instead, the parser would instantiate types and insert them into
known_resource_types as soon as they were parsed.  This made it
difficult to distinguish which types had come from the file that was
just parsed and which types had been loaded previously, which led to
bug 4496.

A side-effect of this change is that the user is no longer allowed to
define types inside of conditional constructs (such as if/else).  This
was allowed before but had unexpected semantics (bugs 4521 and 4522).

It is still possible, however, to place an "include" statement inside
a conditional construct, and have that "include" statement trigger the
autoloading of a file that instantiates types.
---
 spec/unit/parser/ast/definition_spec.rb | 17 ++++++
 spec/unit/parser/ast/hostclass_spec.rb  | 73 +++++++++++++++++++++++++
 spec/unit/parser/ast/node_spec.rb       | 30 +++++++++++
 spec/unit/parser/ast/resource_spec.rb   |  6 +--
 spec/unit/parser/parser_spec.rb         | 96 ++++++++++++++++++---------------
 spec/unit/parser/scope_spec.rb          |  3 +-
 spec/unit/parser/type_loader_spec.rb    | 32 +++++------
 7 files changed, 189 insertions(+), 68 deletions(-)
 create mode 100644 spec/unit/parser/ast/definition_spec.rb
 create mode 100644 spec/unit/parser/ast/hostclass_spec.rb
 create mode 100644 spec/unit/parser/ast/node_spec.rb

(limited to 'spec/unit/parser')

diff --git a/spec/unit/parser/ast/definition_spec.rb b/spec/unit/parser/ast/definition_spec.rb
new file mode 100644
index 000000000..01ca068ad
--- /dev/null
+++ b/spec/unit/parser/ast/definition_spec.rb
@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Definition do
+  describe "when instantiated" do
+    it "should create a definition with the proper type, name, context, and module name" do
+      definition = Puppet::Parser::AST::Definition.new('foo', :line => 5)
+      instantiated_definitions = definition.instantiate('modname')
+      instantiated_definitions.length.should == 1
+      instantiated_definitions[0].type.should == :definition
+      instantiated_definitions[0].name.should == 'foo'
+      instantiated_definitions[0].line.should == 5
+      instantiated_definitions[0].module_name.should == 'modname'
+    end
+  end
+end
diff --git a/spec/unit/parser/ast/hostclass_spec.rb b/spec/unit/parser/ast/hostclass_spec.rb
new file mode 100644
index 000000000..b22eba98b
--- /dev/null
+++ b/spec/unit/parser/ast/hostclass_spec.rb
@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Hostclass do
+  def ast
+    Puppet::Parser::AST
+  end
+
+  def newarray(*elems)
+    ast::ASTArray.new({}).push(*elems)
+  end
+
+  it "should make its name and context available through accessors" do
+    hostclass = ast::Hostclass.new('foo', :line => 5)
+    hostclass.name.should == 'foo'
+    hostclass.context.should == {:line => 5}
+  end
+
+  it "should make its code available through an accessor" do
+    code = newarray
+    hostclass = ast::Hostclass.new('foo', :code => code)
+    hostclass.code.should be_equal(code)
+  end
+
+  describe "when instantiated" do
+    it "should create a class with the proper type, code, name, context, and module name" do
+      code = newarray
+      hostclass = ast::Hostclass.new('foo', :code => code, :line => 5)
+      instantiated_class = hostclass.instantiate('modname')[0]
+      instantiated_class.type.should == :hostclass
+      instantiated_class.name.should == 'foo'
+      instantiated_class.code.should be_equal(code)
+      instantiated_class.line.should == 5
+      instantiated_class.module_name.should == 'modname'
+    end
+
+    it "should instantiate all nested classes, defines, and nodes with the same module name." do
+      nested_objects = newarray(ast::Hostclass.new('foo::child1'),
+                                ast::Definition.new('foo::child2'),
+                                ast::Definition.new('child3'))
+      hostclass = ast::Hostclass.new('foo', :code => nested_objects)
+      instantiated_classes = hostclass.instantiate('modname')
+      instantiated_classes.length.should == 4
+      instantiated_classes[0].name.should == 'foo'
+      instantiated_classes[1].name.should == 'foo::child1'
+      instantiated_classes[2].name.should == 'foo::child2'
+      instantiated_classes[3].name.should == 'child3'
+      instantiated_classes.each { |cls| cls.module_name.should == 'modname' }
+    end
+
+    it "should handle a nested class that contains its own nested classes." do
+      foo_bar_baz = ast::Hostclass.new('foo::bar::baz')
+      foo_bar = ast::Hostclass.new('foo::bar', :code => newarray(foo_bar_baz))
+      foo = ast::Hostclass.new('foo', :code => newarray(foo_bar))
+      instantiated_classes = foo.instantiate('')
+      instantiated_classes.length.should == 3
+      instantiated_classes[0].name.should == 'foo'
+      instantiated_classes[1].name.should == 'foo::bar'
+      instantiated_classes[2].name.should == 'foo::bar::baz'
+    end
+
+    it "should skip nested elements that are not classes, definitions, or nodes." do
+      func = ast::Function.new(:name => 'biz', :arguments => newarray(ast::Name.new(:value => 'baz')))
+      foo = ast::Hostclass.new('foo', :code => newarray(func))
+      instantiated_classes = foo.instantiate('')
+      instantiated_classes.length.should == 1
+      instantiated_classes[0].should be_a(Puppet::Resource::Type)
+      instantiated_classes[0].name.should == 'foo'
+    end
+  end
+end
+
diff --git a/spec/unit/parser/ast/node_spec.rb b/spec/unit/parser/ast/node_spec.rb
new file mode 100644
index 000000000..409e877f9
--- /dev/null
+++ b/spec/unit/parser/ast/node_spec.rb
@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Puppet::Parser::AST::Node do
+  describe "when instantiated" do
+    it "should make its names available through an accessor" do
+      node = Puppet::Parser::AST::Node.new(['foo', 'bar'])
+      node.names.should == ['foo', 'bar']
+    end
+
+    it "should create a node with the proper type, name, context, and module name" do
+      node = Puppet::Parser::AST::Node.new(['foo'], :line => 5)
+      instantiated_nodes = node.instantiate('modname')
+      instantiated_nodes.length.should == 1
+      instantiated_nodes[0].type.should == :node
+      instantiated_nodes[0].name.should == 'foo'
+      instantiated_nodes[0].line.should == 5
+      instantiated_nodes[0].module_name.should == 'modname'
+    end
+
+    it "should handle multiple names" do
+      node = Puppet::Parser::AST::Node.new(['foo', 'bar'])
+      instantiated_nodes = node.instantiate('modname')
+      instantiated_nodes.length.should == 2
+      instantiated_nodes[0].name.should == 'foo'
+      instantiated_nodes[1].name.should == 'bar'
+    end
+  end
+end
diff --git a/spec/unit/parser/ast/resource_spec.rb b/spec/unit/parser/ast/resource_spec.rb
index 58ffae925..4e5549b96 100755
--- a/spec/unit/parser/ast/resource_spec.rb
+++ b/spec/unit/parser/ast/resource_spec.rb
@@ -89,9 +89,9 @@ describe Puppet::Parser::AST::Resource 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)
-      @parser.newdefine "one"
-      @parser.newdefine "one::two"
-      @parser.newdefine "three"
+      ["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
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 0657ab37a..0a61e73de 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -73,14 +73,16 @@ describe Puppet::Parser do
       lambda { @parser.parse("$var += ") }.should raise_error
     end
 
-    it "should call ast::VarDef with append=true" do
-      ast::VarDef.expects(:new).with { |h| h[:append] == true }
-      @parser.parse("$var += 2")
+    it "should create ast::VarDef with append=true" do
+      vardef = @parser.parse("$var += 2").code[0]
+      vardef.should be_a(Puppet::Parser::AST::VarDef)
+      vardef.append.should == true
     end
 
     it "should work with arrays too" do
-      ast::VarDef.expects(:new).with { |h| h[:append] == true }
-      @parser.parse("$var += ['test']")
+      vardef = @parser.parse("$var += ['test']").code[0]
+      vardef.should be_a(Puppet::Parser::AST::VarDef)
+      vardef.append.should == true
     end
 
   end
@@ -160,10 +162,14 @@ describe Puppet::Parser do
     end
 
     it "should create an ast::ResourceOverride" do
-      ast::ResourceOverride.expects(:new).with { |arg|
-        arg[:line]==1 and arg[:object].is_a?(ast::ResourceReference) and arg[:parameters].is_a?(ast::ResourceParam)
-      }
-      @parser.parse('Resource["title1","title2"] { param => value }')
+      #ast::ResourceOverride.expects(:new).with { |arg|
+      #  arg[:line]==1 and arg[:object].is_a?(ast::ResourceReference) and arg[:parameters].is_a?(ast::ResourceParam)
+      #}
+      ro = @parser.parse('Resource["title1","title2"] { param => value }').code[0]
+      ro.should be_a(ast::ResourceOverride)
+      ro.line.should == 1
+      ro.object.should be_a(ast::ResourceReference)
+      ro.parameters[0].should be_a(ast::ResourceParam)
     end
 
   end
@@ -290,24 +296,6 @@ describe Puppet::Parser do
     end
   end
 
-  describe "when creating a node" do
-    before :each do
-      @lexer = stub 'lexer'
-      @lexer.stubs(:getcomment)
-      @parser.stubs(:lexer).returns(@lexer)
-      @node = stub_everything 'node'
-      @parser.stubs(:ast_context).returns({})
-      @parser.stubs(:node).returns(nil)
-
-      @nodename = stub 'nodename', :is_a? => false, :value => "foo"
-      @nodename.stubs(:is_a?).with(Puppet::Parser::AST::HostName).returns(true)
-    end
-
-    it "should return an array of nodes" do
-      @parser.newnode(@nodename).should be_instance_of(Array)
-    end
-  end
-
   describe "when retrieving a specific node" do
     it "should delegate to the known_resource_types node" do
       @known_resource_types.expects(:node).with("node")
@@ -360,30 +348,28 @@ describe Puppet::Parser do
       @parser.stubs(:known_resource_types).returns @krt
     end
 
-    it "should create new classes" do
-      @parser.parse("class foobar {}")
-      @krt.hostclass("foobar").should be_instance_of(Puppet::Resource::Type)
+    it "should not create new classes" do
+      @parser.parse("class foobar {}").code[0].should be_a(Puppet::Parser::AST::Hostclass)
+      @krt.hostclass("foobar").should be_nil
     end
 
     it "should correctly set the parent class when one is provided" do
-      @parser.parse("class foobar inherits yayness {}")
-      @krt.hostclass("foobar").parent.should == "yayness"
+      @parser.parse("class foobar inherits yayness {}").code[0].instantiate('')[0].parent.should == "yayness"
     end
 
     it "should correctly set the parent class for multiple classes at a time" do
-      @parser.parse("class foobar inherits yayness {}\nclass boo inherits bar {}")
-      @krt.hostclass("foobar").parent.should == "yayness"
-      @krt.hostclass("boo").parent.should == "bar"
+      statements = @parser.parse("class foobar inherits yayness {}\nclass boo inherits bar {}").code
+      statements[0].instantiate('')[0].parent.should == "yayness"
+      statements[1].instantiate('')[0].parent.should == "bar"
     end
 
     it "should define the code when some is provided" do
-      @parser.parse("class foobar { $var = val }")
-      @krt.hostclass("foobar").code.should_not be_nil
+      @parser.parse("class foobar { $var = val }").code[0].code.should_not be_nil
     end
 
     it "should define parameters when provided" do
-      @parser.parse("class foobar($biz,$baz) {}")
-      @krt.hostclass("foobar").arguments.should == {"biz" => nil, "baz" => nil}
+      foobar = @parser.parse("class foobar($biz,$baz) {}").code[0].instantiate('')[0]
+      foobar.arguments.should == {"biz" => nil, "baz" => nil}
     end
   end
 
@@ -400,13 +386,37 @@ describe Puppet::Parser do
     end
 
     it "should correctly mark exported resources as exported" do
-      @parser.parse("@@file { '/file': }")
-      @krt.hostclass("").code[0].exported.should be_true
+      @parser.parse("@@file { '/file': }").code[0][0].exported.should be_true
     end
 
     it "should correctly mark virtual resources as virtual" do
-      @parser.parse("@file { '/file': }")
-      @krt.hostclass("").code[0].virtual.should be_true
+      @parser.parse("@file { '/file': }").code[0][0].virtual.should be_true
+    end
+  end
+
+  describe "when parsing nodes" do
+    it "should be able to parse a node with a single name" do
+      node = @parser.parse("node foo { }").code[0]
+      node.should be_a Puppet::Parser::AST::Node
+      node.names.length.should == 1
+      node.names[0].value.should == "foo"
+    end
+
+    it "should be able to parse a node with two names" do
+      node = @parser.parse("node foo, bar { }").code[0]
+      node.should be_a Puppet::Parser::AST::Node
+      node.names.length.should == 2
+      node.names[0].value.should == "foo"
+      node.names[1].value.should == "bar"
+    end
+
+    it "should be able to parse a node with three names" do
+      node = @parser.parse("node foo, bar, baz { }").code[0]
+      node.should be_a Puppet::Parser::AST::Node
+      node.names.length.should == 3
+      node.names[0].value.should == "foo"
+      node.names[1].value.should == "bar"
+      node.names[2].value.should == "baz"
     end
   end
 end
diff --git a/spec/unit/parser/scope_spec.rb b/spec/unit/parser/scope_spec.rb
index 9895f446b..2e390a53b 100755
--- a/spec/unit/parser/scope_spec.rb
+++ b/spec/unit/parser/scope_spec.rb
@@ -29,8 +29,7 @@ describe Puppet::Parser::Scope do
   end
 
   it "should be able to retrieve its parent module name from the source of its parent type" do
-    @topscope.source = Puppet::Resource::Type.new(:hostclass, :foo)
-    @topscope.source.module_name = "foo"
+    @topscope.source = Puppet::Resource::Type.new(:hostclass, :foo, :module_name => "foo")
 
     @scope.parent_module_name.should == "foo"
   end
diff --git a/spec/unit/parser/type_loader_spec.rb b/spec/unit/parser/type_loader_spec.rb
index b7e174753..b06251681 100644
--- a/spec/unit/parser/type_loader_spec.rb
+++ b/spec/unit/parser/type_loader_spec.rb
@@ -28,26 +28,18 @@ describe Puppet::Parser::TypeLoader do
   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("") { |filename, modname| raise :should_not_occur }.should be_nil
+      @loader.try_load_fqname(:hostclass, "") { |filename, modname| raise :should_not_occur }.should be_nil
     end
 
     it "should attempt to import each generated name" do
-      @loader.expects(:import).with("foo/bar",nil)
-      @loader.expects(:import).with("foo",nil)
-      @loader.try_load_fqname("foo::bar") { |f| false }
-    end
-
-    it "should yield after each import" do
-      yielded = []
-      @loader.expects(:import).with("foo/bar",nil)
-      @loader.expects(:import).with("foo",nil)
-      @loader.try_load_fqname("foo::bar") { |filename, modname| yielded << [filename, modname]; false }
-      yielded.should == [["foo/bar", nil], ["foo", nil]]
+      @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
 
     it "should know when a given name has been loaded" do
-      @loader.expects(:import).with("file",nil)
-      @loader.try_load_fqname("file") { |f| true }
+      @loader.expects(:import).with("file",nil).returns([])
+      @loader.try_load_fqname(:hostclass, "file") { |f| true }
       @loader.should be_loaded("file")
     end
   end
@@ -55,7 +47,7 @@ describe Puppet::Parser::TypeLoader do
   describe "when importing" do
     before do
       Puppet::Parser::Files.stubs(:find_manifests).returns ["modname", %w{file}]
-      @loader.stubs(:parse_file)
+      @loader.stubs(:parse_file).returns(Puppet::Parser::AST::Hostclass.new(''))
     end
 
     it "should return immediately when imports are being ignored" do
@@ -86,13 +78,13 @@ describe Puppet::Parser::TypeLoader do
 
     it "should parse each found file" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
-      @loader.expects(:parse_file).with("/one")
+      @loader.expects(:parse_file).with("/one").returns(Puppet::Parser::AST::Hostclass.new(''))
       @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("/current/one")
+      @loader.expects(:parse_file).with("/current/one").returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile", "/current/file")
     end
 
@@ -105,7 +97,7 @@ describe Puppet::Parser::TypeLoader do
 
     it "should not attempt to import files that have already been imported" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
-      @loader.expects(:parse_file).once
+      @loader.expects(:parse_file).once.returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile")
 
       # This will fail if it tries to reimport the file.
@@ -116,7 +108,7 @@ describe Puppet::Parser::TypeLoader do
   describe "when parsing a file" do
     before do
       @parser = Puppet::Parser::Parser.new(@loader.environment)
-      @parser.stubs(:parse)
+      @parser.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       @parser.stubs(:file=)
       Puppet::Parser::Parser.stubs(:new).with(@loader.environment).returns @parser
     end
@@ -128,7 +120,7 @@ describe Puppet::Parser::TypeLoader do
 
     it "should assign the parser its file and parse" do
       @parser.expects(:file=).with("/my/file")
-      @parser.expects(:parse)
+      @parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.parse_file("/my/file")
     end
   end
-- 
cgit 


From df088c9ba16dce50c17a79920c1ac186db67b9e9 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Wed, 25 Aug 2010 11:29:23 -0700
Subject: [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.
---
 spec/unit/parser/ast/astarray_spec.rb | 49 ++++++++++++-----------------------
 spec/unit/parser/ast/resource_spec.rb | 23 +++++++++++-----
 spec/unit/parser/parser_spec.rb       |  5 ++--
 3 files changed, 35 insertions(+), 42 deletions(-)

(limited to 'spec/unit/parser')

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
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 0a61e73de..bf4ef0cf1 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -143,7 +143,6 @@ describe Puppet::Parser do
     end
 
     it "should create an ast::ResourceReference" do
-      ast::Resource.stubs(:new)
       ast::ResourceReference.expects(:new).with { |arg|
         arg[:line]==1 and arg[:type]=="File" and arg[:title].is_a?(ast::ASTArray)
       }
@@ -386,11 +385,11 @@ describe Puppet::Parser do
     end
 
     it "should correctly mark exported resources as exported" do
-      @parser.parse("@@file { '/file': }").code[0][0].exported.should be_true
+      @parser.parse("@@file { '/file': }").code[0].exported.should be_true
     end
 
     it "should correctly mark virtual resources as virtual" do
-      @parser.parse("@file { '/file': }").code[0][0].virtual.should be_true
+      @parser.parse("@file { '/file': }").code[0].virtual.should be_true
     end
   end
 
-- 
cgit 


From ce9bf1edcaac4901de6e0a7da413d1742d216eb0 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Tue, 7 Sep 2010 18:01:42 -0700
Subject: Modified the error message that is generated when a class,
 definition, or node occurs in a conditional construct so that it contains the
 proper line number.

---
 spec/unit/parser/ast/definition_spec.rb | 5 +++++
 spec/unit/parser/ast/node_spec.rb       | 5 +++--
 2 files changed, 8 insertions(+), 2 deletions(-)

(limited to 'spec/unit/parser')

diff --git a/spec/unit/parser/ast/definition_spec.rb b/spec/unit/parser/ast/definition_spec.rb
index 01ca068ad..b7b2c851c 100644
--- a/spec/unit/parser/ast/definition_spec.rb
+++ b/spec/unit/parser/ast/definition_spec.rb
@@ -3,6 +3,11 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Definition do
+  it "should make its context available through an accessor" do
+    definition = Puppet::Parser::AST::Definition.new('foo', :line => 5)
+    definition.context.should == {:line => 5}
+  end
+
   describe "when instantiated" do
     it "should create a definition with the proper type, name, context, and module name" do
       definition = Puppet::Parser::AST::Definition.new('foo', :line => 5)
diff --git a/spec/unit/parser/ast/node_spec.rb b/spec/unit/parser/ast/node_spec.rb
index 409e877f9..3e8017de0 100644
--- a/spec/unit/parser/ast/node_spec.rb
+++ b/spec/unit/parser/ast/node_spec.rb
@@ -4,9 +4,10 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Node do
   describe "when instantiated" do
-    it "should make its names available through an accessor" do
-      node = Puppet::Parser::AST::Node.new(['foo', 'bar'])
+    it "should make its names and context available through accessors" do
+      node = Puppet::Parser::AST::Node.new(['foo', 'bar'], :line => 5)
       node.names.should == ['foo', 'bar']
+      node.context.should == {:line => 5}
     end
 
     it "should create a node with the proper type, name, context, and module name" do
-- 
cgit