puppet 0.23.2 → 0.24.0

data/lib/puppet/parser/ast/else.rb

@@ -16,15 +16,5 @@ class Puppet::Parser::AST
             scope = hash[:scope]
             return @statements.safeevaluate(:scope => scope)
         end
-
-        def tree(indent = 0)
-            rettree = [
-                ((@@indline * indent) + self.typewrap(self.pin)),
-                @statements.tree(indent + 1)
-            ]
-            return rettree.flatten.join("\n")
-        end
     end
 end
-
-# $Id: else.rb 1835 2006-11-08 05:22:24Z luke $

data/lib/puppet/parser/ast/function.rb

@@ -53,5 +53,3 @@ class Puppet::Parser::AST
         end
     end
 end
-
-# $Id: function.rb 1835 2006-11-08 05:22:24Z luke $

data/lib/puppet/parser/ast/hostclass.rb

@@ -1,10 +1,10 @@
-require 'puppet/parser/ast/component'
+require 'puppet/parser/ast/definition'
 
 class Puppet::Parser::AST
-    # The code associated with a class.  This is different from components
+    # The code associated with a class.  This is different from definitions
     # in that each class is a singleton -- only one will exist for a given
     # node.
-    class HostClass < AST::Component
+    class HostClass < AST::Definition
         @name = :class
 
         # Are we a child of the passed class?  Do a recursive search up our
@@ -20,26 +20,30 @@ class Puppet::Parser::AST
         end
 
         # Evaluate the code associated with this class.
-        def evaluate(hash)
-            scope = hash[:scope]
-            args = hash[:arguments]
-
-            # Verify that we haven't already been evaluated
-            if scope.class_scope(self)
-                Puppet.debug "%s class already evaluated" % @type
+        def evaluate(options)
+            scope = options[:scope]
+            raise(ArgumentError, "Classes require resources") unless options[:resource]
+            # Verify that we haven't already been evaluated.  This is
+            # what provides the singleton aspect.
+            if existing_scope = scope.compile.class_scope(self)
+                Puppet.debug "Class '%s' already evaluated; not evaluating again" % (classname == "" ? "main" : classname)
                 return nil
             end
 
+            scope.compile.catalog.tag(self.classname)
+
             pnames = nil
             if pklass = self.parentobj
-                pklass.safeevaluate :scope => scope
+                pklass.safeevaluate :scope => scope, :resource => options[:resource]
 
                 scope = parent_scope(scope, pklass)
                 pnames = scope.namespaces
             end
 
-            unless hash[:nosubscope]
-                scope = subscope(scope)
+            # Don't create a subscope for the top-level class, since it already
+            # has its own scope.
+            unless options[:resource].title == :main
+                scope = subscope(scope, options[:resource])
             end
 
             if pnames
@@ -50,7 +54,7 @@ class Puppet::Parser::AST
 
             # Set the class before we do anything else, so that it's set
             # during the evaluation and can be inspected.
-            scope.setclass(self)
+            scope.compile.class_set(self.classname, scope)
 
             # Now evaluate our code, yo.
             if self.code
@@ -60,19 +64,17 @@ class Puppet::Parser::AST
             end
         end
 
-        def initialize(hash)
+        def initialize(options)
             @parentclass = nil
             super
         end
 
         def parent_scope(scope, klass)
-            if s = scope.class_scope(klass)
+            if s = scope.compile.class_scope(klass)
                 return s
             else
-                raise Puppet::DevError, "Could not find scope for %s" % klass.fqname
+                raise Puppet::DevError, "Could not find scope for %s" % klass.classname
             end
         end
     end
 end
-
-# $Id: hostclass.rb 2646 2007-07-04 21:06:26Z luke $

data/lib/puppet/parser/ast/ifstatement.rb

@@ -26,18 +26,5 @@ class Puppet::Parser::AST
                 end
             end
         end
-
-        def tree(indent = 0)
-            rettree = [
-                @test.tree(indent + 1),
-                ((@@indline * indent) + self.typewrap(self.pin)),
-                @statements.tree(indent + 1),
-                @else.tree(indent + 1)
-            ]
-
-            return rettree.flatten.join("\n")
-        end
     end
 end
-
-# $Id: ifstatement.rb 1780 2006-10-15 20:07:29Z luke $

data/lib/puppet/parser/ast/leaf.rb

@@ -10,11 +10,6 @@ class Puppet::Parser::AST
             return @value
         end
 
-        # Print the value in parse tree context.
-        def tree(indent = 0)
-            return ((@@indent * indent) + self.typewrap(self.value))
-        end
-
         def to_s
             return @value
         end
@@ -92,7 +87,4 @@ class Puppet::Parser::AST
             end
         end
     end
-
 end
-
-# $Id: leaf.rb 2522 2007-05-17 21:43:51Z luke $

data/lib/puppet/parser/ast/node.rb

@@ -7,11 +7,10 @@ class Puppet::Parser::AST
         @name = :node
         attr_accessor :name
 
-        #def evaluate(scope, facts = {})
-        def evaluate(hash)
-            scope = hash[:scope]
+        def evaluate(options)
+            scope = options[:scope]
 
-            #pscope = if ! Puppet[:lexical] or hash[:asparent]
+            #pscope = if ! Puppet[:lexical] or options[:asparent]
             #    @scope
             #else
             #    origscope
@@ -20,11 +19,11 @@ class Puppet::Parser::AST
             # We don't have to worry about the declarativeness of node parentage,
             # because the entry point is always a single node definition.
             if parent = self.parentobj
-                scope = parent.safeevaluate :scope => scope
+                scope = parent.safeevaluate :scope => scope, :resource => options[:resource]
             end
 
             scope = scope.newscope(
-                :type => self.name,
+                :resource => options[:resource],
                 :keyword => @keyword,
                 :source => self,
                 :namespace => "" # nodes are always in ""
@@ -33,7 +32,7 @@ class Puppet::Parser::AST
             # Mark our node name as a class, too, but strip it of the domain
             # name.  Make the mark before we evaluate the code, so that it is
             # marked within the code itself.
-            scope.setclass(self)
+            scope.compile.class_set(self.classname, scope)
 
             # And then evaluate our code if we have any
             if self.code
@@ -43,7 +42,7 @@ class Puppet::Parser::AST
             return scope
         end
 
-        def initialize(hash)
+        def initialize(options)
             @parentclass = nil
             super
 
@@ -53,6 +52,12 @@ class Puppet::Parser::AST
             end
         end
 
+        # Make sure node scopes are marked as such.
+        def subscope(*args)
+            scope = super
+            scope.nodescope = true
+        end
+
         private
         # Search for the object matching our parent class.
         def find_parentclass
@@ -60,5 +65,3 @@ class Puppet::Parser::AST
         end
     end
 end
-
-# $Id: node.rb 2742 2007-08-03 23:49:53Z luke $

data/lib/puppet/parser/ast/resource.rb

@@ -0,0 +1,75 @@
+require 'puppet/parser/ast/resource_reference'
+
+# Any normal puppet resource declaration.  Can point to a definition or a
+# builtin type.
+class Puppet::Parser::AST
+class Resource < AST::ResourceReference
+    attr_accessor :title, :type, :exported, :virtual
+    attr_reader :params
+
+    # Does not actually return an object; instead sets an object
+    # in the current scope.
+    def evaluate(options)
+        scope = options[:scope]
+
+        # Evaluate all of the specified params.
+        paramobjects = @params.collect { |param|
+            param.safeevaluate(:scope => scope)
+        }
+
+        objtitles = @title.safeevaluate(:scope => scope)
+
+        # it's easier to always use an array, even for only one name
+        unless objtitles.is_a?(Array)
+            objtitles = [objtitles]
+        end
+
+        objtype = qualified_type(scope)
+
+        # This is where our implicit iteration takes place; if someone
+        # passed an array as the name, then we act just like the called us
+        # many times.
+        objtitles.collect { |objtitle|
+            exceptwrap :type => Puppet::ParseError do
+                exp = self.exported || scope.resource.exported?
+                # We want virtual to be true if exported is true.  We can't
+                # just set :virtual => self.virtual in the initialization,
+                # because sometimes the :virtual attribute is set *after*
+                # :exported, in which case it clobbers :exported if :exported
+                # is true.  Argh, this was a very tough one to track down.
+                virt = self.virtual || scope.resource.virtual? || exp
+                obj = Puppet::Parser::Resource.new(
+                    :type => objtype,
+                    :title => objtitle,
+                    :params => paramobjects,
+                    :file => self.file,
+                    :line => self.line,
+                    :exported => exp,
+                    :virtual => virt,
+                    :source => scope.source,
+                    :scope => scope
+                )
+
+                # And then store the resource in the compile.
+                # At some point, we need to switch all of this to return
+                # objects instead of storing them like this.
+                scope.compile.store_resource(scope, obj)
+                obj
+            end
+        }.reject { |obj| obj.nil? }
+    end
+
+    # Set the parameters for our object.
+    def params=(params)
+        if params.is_a?(AST::ASTArray)
+            @params = params
+        else
+            @params = AST::ASTArray.new(
+                :line => params.line,
+                :file => params.file,
+                :children => [params]
+            )
+        end
+    end
+end
+end

data/lib/puppet/parser/ast/{resourcedefaults.rb → resource_defaults.rb}

@@ -6,35 +6,19 @@ class Puppet::Parser::AST
     class ResourceDefaults < AST::Branch
         attr_accessor :type, :params
 
-        def each
-            [@type,@params].each { |child| yield child }
-        end
-
         # As opposed to ResourceDef, this stores each default for the given
         # object type.
         def evaluate(hash)
             scope = hash[:scope]
-            type = @type.downcase
+
+            # Use a resource reference to canonize the type
+            ref = Puppet::ResourceReference.new(@type, "whatever")
+            type = ref.type
             params = @params.safeevaluate(:scope => scope)
 
             parsewrap do
                 scope.setdefaults(type, params)
             end
         end
-
-        def tree(indent = 0)
-            return [
-                @type.tree(indent + 1),
-                ((@@indline * 4 * indent) + self.typewrap(self.pin)),
-                @params.tree(indent + 1)
-            ].join("\n")
-        end
-
-        def to_s
-            return "%s { %s }" % [@type,@params]
-        end
     end
-
 end
-
-# $Id: resourcedefaults.rb 1835 2006-11-08 05:22:24Z luke $

data/lib/puppet/parser/ast/{resourceoverride.rb → resource_override.rb}

@@ -1,9 +1,9 @@
-require 'puppet/parser/ast/resourcedef'
+require 'puppet/parser/ast/resource'
 
 class Puppet::Parser::AST
     # Set a parameter on a resource specification created somewhere else in the
     # configuration.  The object is responsible for verifying that this is allowed.
-    class ResourceOverride < ResourceDef
+    class ResourceOverride < Resource
         attr_accessor :object
         attr_reader :params
 
@@ -44,7 +44,7 @@ class Puppet::Parser::AST
 
             # Now we tell the scope that it's an override, and it behaves as
             # necessary.
-            scope.setoverride(obj)
+            scope.compile.store_override(obj)
 
             obj
         end
@@ -58,5 +58,3 @@ class Puppet::Parser::AST
         end
     end
 end
-
-# $Id: resourceoverride.rb 1726 2006-10-04 18:24:24Z luke $

data/lib/puppet/parser/ast/resource_reference.rb

@@ -0,0 +1,66 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    # A reference to an object.  Only valid as an rvalue.
+    class ResourceReference < AST::Branch
+        attr_accessor :title, :type
+        # Is the type a builtin type?
+        def builtintype?(type)
+            if typeklass = Puppet::Type.type(type)
+                return typeklass
+            else
+                return false
+            end
+        end
+
+        def each
+            [@type,@title].flatten.each { |param|
+                #Puppet.debug("yielding param %s" % param)
+                yield param
+            }
+        end
+
+        # Evaluate our object, but just return a simple array of the type
+        # and name.
+        def evaluate(hash)
+            scope = hash[:scope]
+
+            title = @title.safeevaluate(:scope => scope)
+            if @type.to_s.downcase == "class"
+                objtype = "class"
+                title = qualified_class(scope, title)
+            else
+                objtype = qualified_type(scope)
+            end
+
+            return Puppet::Parser::Resource::Reference.new(
+                :type => objtype, :title => title
+            )
+        end
+
+        # Look up a fully qualified class name.
+        def qualified_class(scope, title)
+            # Look up the full path to the class
+            if classobj = scope.findclass(title)
+                title = classobj.classname
+            else
+                raise Puppet::ParseError, "Could not find class %s" % title
+            end
+        end
+
+        # Look up a fully-qualified type.  This method is
+        # also used in AST::Resource.
+        def qualified_type(scope, title = nil)
+            # We want a lower-case type.  For some reason.
+            objtype = @type.downcase
+            unless builtintype?(objtype)
+                if dtype = scope.finddefine(objtype)
+                    objtype = dtype.classname
+                else
+                    raise Puppet::ParseError, "Could not find resource type %s" % objtype
+                end
+            end
+            return objtype
+        end
+    end
+end

data/lib/puppet/parser/ast/resourceparam.rb

@@ -20,19 +20,5 @@ class Puppet::Parser::AST
                 :add => self.add
             )
         end
-
-        def tree(indent = 0)
-            return [
-                @param.tree(indent + 1),
-                ((@@indline * indent) + self.typewrap(self.pin)),
-                @value.tree(indent + 1)
-            ].join("\n")
-        end
-
-        def to_s
-            return "%s => %s" % [@param,@value]
-        end
     end
 end
-
-# $Id: resourceparam.rb 2670 2007-07-10 15:31:19Z luke $

data/lib/puppet/parser/ast/selector.rb

@@ -60,15 +60,5 @@ class Puppet::Parser::AST
 
             return retvalue
         end
-
-        def tree(indent = 0)
-            return [
-                @param.tree(indent + 1),
-                ((@@indline * indent) + self.typewrap(self.pin)),
-                @values.tree(indent + 1)
-            ].join("\n")
-        end
     end
 end
-
-# $Id: selector.rb 2145 2007-02-01 01:29:48Z luke $