puppet 0.16.0 → 0.18.4

data/lib/puppet/parser/ast.rb

@@ -79,6 +79,9 @@ module Puppet
                     error.line ||= @line
                     error.file ||= @file
                     error.backtrace = detail.backtrace
+                    if Puppet[:debug]
+                        puts detail.backtrace
+                    end
                     raise error
                 end
             end
@@ -131,6 +134,7 @@ end
 
 require 'puppet/parser/ast/astarray'
 require 'puppet/parser/ast/branch'
+require 'puppet/parser/ast/collection'
 require 'puppet/parser/ast/caseopt'
 require 'puppet/parser/ast/casestatement'
 require 'puppet/parser/ast/classdef'
@@ -147,5 +151,6 @@ require 'puppet/parser/ast/selector'
 require 'puppet/parser/ast/typedefaults'
 require 'puppet/parser/ast/vardef'
 require 'puppet/parser/ast/tag'
+require 'puppet/parser/ast/function'
 
-# $Id: ast.rb 1106 2006-04-11 22:32:51Z luke $
+# $Id: ast.rb 1250 2006-06-09 21:22:25Z luke $

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

@@ -22,20 +22,46 @@ class Puppet::Parser::AST
             # do we need to evaluate the settor-like statements first.  This
             # is basically variable and type-default declarations.
             if scope.declarative?
-                test = [
-                    AST::VarDef, AST::TypeDefaults
+                # This is such a stupid hack.  I've no real idea how to make a
+                # "real" declarative language, so I hack it so it looks like
+                # one, yay.
+                definelist = [
+                    AST::CompDef, AST::NodeDef, AST::ClassDef
+                ]
+                setlist = [
+                    AST::VarDef, AST::TypeDefaults, AST::Function
                 ]
 
+                definers = []
                 settors = []
                 others = []
+
+                # Make a new array, so we don't have to deal with the details of
+                # flattening and such
+                items = []
+                
+                # First clean out any AST::ASTArrays
                 @children.each { |child|
-                    if test.include?(child.class)
-                        settors.push child
+                    if child.instance_of?(AST::ASTArray)
+                        child.each do |ac|
+                            items << ac
+                        end
+                    else
+                        items << child
+                    end
+                }
+
+                # Now sort them all according to the type of action
+                items.each { |child|
+                    if definelist.include?(child.class)
+                        definers << child
+                    elsif setlist.include?(child.class)
+                        settors << child
                     else
-                        others.push child
+                        others << child
                     end
                 }
-                rets = [settors,others].flatten.collect { |child|
+                rets = [definers, settors, others].flatten.collect { |child|
                     child.safeevaluate(:scope => scope)
                 }
             else

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

@@ -0,0 +1,91 @@
+require 'puppet/rails'
+
+class Puppet::Parser::AST
+    # An object that collects stored objects from the central cache and returns
+    # them to the current host, yo.
+    class Collection < AST::Branch
+        attr_accessor :type
+
+        # We cannot evaluate directly here; instead we need to store a 
+        # CollectType object, which will do the collection.  This is
+        # the only way to find certain exported types in the current
+        # configuration.
+        def evaluate(hash)
+            scope = hash[:scope]
+
+            @convertedtype = @type.safeevaluate(:scope => scope)
+
+            scope.newcollection(self)
+        end
+
+        # Now perform the actual collection, yo.
+        def perform(scope)
+            # First get everything from the export table.
+            
+            # FIXME This will only find objects that are before us in the tree,
+            # which is a problem.
+            objects = scope.exported(@convertedtype)
+
+            # We want to return all of these objects, and then whichever objects
+            # we find in the db.
+            array = objects.values
+
+            # Mark all of these objects as collected, so that they also get
+            # returned to the client.  We don't store them in our scope
+            # or anything, which is a little odd, but eh.
+            array.each do |obj|
+                obj.collected = true
+            end
+
+            count = array.length
+
+            # Now we also have to see if there are any exported objects
+            # in our own scope.
+            scope.lookupexported(@convertedtype).each do |obj|
+                objects[obj.name] = obj
+                obj.collected = true
+            end
+
+            bucket = Puppet::TransBucket.new
+
+            Puppet::Rails::RailsObject.find_all_by_collectable(true).each do |obj|
+                # FIXME This should check that the source of the object is the
+                # host we're running on, else it's a bad conflict.
+                if objects.include?(obj.name)
+                    scope.debug("%s[%s] is already exported" % [@convertedtype, obj.name])
+                    next
+                end
+                count += 1
+                trans = obj.to_trans
+                bucket.push(trans)
+
+                args = {
+                    :name => trans.name,
+                    :type => trans.type,
+                }
+
+                [:file, :line].each do |param|
+                    if val = trans.send(param)
+                        args[param] = val
+                    end
+                end
+
+                args[:arguments] = {}
+                trans.each do |p,v|  args[:arguments][p] = v end
+
+                
+                # XXX Because the scopes don't expect objects to return values,
+                # we have to manually add our objects to the scope.  This is
+                # uber-lame.
+                scope.setobject(args)
+            end
+
+            scope.debug("Collected %s objects of type %s" %
+                [count, @convertedtype])
+
+            return bucket
+        end
+    end
+end
+
+# $Id: collection.rb 1193 2006-05-15 18:02:16Z luke $

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

@@ -9,7 +9,7 @@ class Puppet::Parser::AST
     # encounter an error if the component is instantiated more than
     # once.
     class CompDef < AST::Branch
-        attr_accessor :type, :args, :code, :keyword
+        attr_accessor :type, :args, :code, :keyword, :scope
 
         def each
             [@type,@args,@code].each { |child| yield child }
@@ -72,4 +72,4 @@ class Puppet::Parser::AST
     end
 end
 
-# $Id: compdef.rb 952 2006-02-27 22:21:44Z luke $
+# $Id: compdef.rb 1186 2006-05-13 02:14:35Z luke $

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

@@ -10,39 +10,47 @@ class Puppet::Parser::AST
         # The class name
         @name = :component
 
-        attr_accessor :type, :args, :code, :scope, :keyword
+        attr_accessor :type, :args, :code, :scope, :keyword, :collectable
 
         #def evaluate(scope,hash,objtype,objname)
         def evaluate(hash)
-            scope = hash[:scope]
+            origscope = hash[:scope]
             objtype = hash[:type]
             objname = hash[:name]
             arguments = hash[:arguments] || {}
 
-            scope = scope.newscope(
+            @collectable = hash[:collectable]
+
+            pscope = origscope
+            #pscope = if ! Puppet[:lexical] or hash[:asparent] == false
+            #    origscope
+            #else
+            #    @scope
+            #end
+            scope = pscope.newscope(
                 :type => @type,
                 :name => objname,
                 :keyword => self.keyword
             )
             newcontext = hash[:newcontext]
 
+            if @collectable or origscope.collectable
+                scope.collectable = true
+            end
+
             unless self.is_a? AST::HostClass and ! newcontext
                 #scope.warning "Setting context to %s" % self.object_id
                 scope.context = self.object_id
             end
             @scope = scope
 
-
             # Additionally, add a tag for whatever kind of class
             # we are
             scope.tag(@type)
 
             unless objname.nil?
-                #Puppet.info "tagging with %s" % objname.inspect
                 scope.tag(objname)
             end
-            #scope.base = self.class.name
-
 
             # define all of the arguments in our local scope
             if self.args
@@ -95,9 +103,14 @@ class Puppet::Parser::AST
             # Now just evaluate the code with our new bindings.
             self.code.safeevaluate(:scope => scope)
 
-            # We return the scope, so that our children can make their scopes
-            # under ours.  This allows them to find our definitions.
-            return scope
+            # If we're being evaluated as a parent class, we want to return the
+            # scope, so it can be overridden and such, but if not, we want to 
+            # return a TransBucket of our objects.
+            if hash.include?(:asparent)
+                return scope
+            else
+                return scope.to_trans
+            end
         end
 
         # Check whether a given argument is valid.  Searches up through
@@ -136,4 +149,4 @@ class Puppet::Parser::AST
     end
 end
 
-# $Id: component.rb 972 2006-03-03 18:23:53Z luke $
+# $Id: component.rb 1192 2006-05-14 02:42:21Z luke $

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

@@ -0,0 +1,50 @@
+class Puppet::Parser::AST
+    # An AST object to call a function.
+    class Function < AST::Branch
+        attr_accessor :name, :arguments
+
+        def evaluate(hash)
+            # We don't need to evaluate the name, because it's plaintext
+
+            # Just evaluate the arguments
+            scope = hash[:scope]
+
+            args = @arguments.safeevaluate(:scope => scope)
+
+            return scope.send("function_" + @name, args)
+        end
+
+        def initialize(hash)
+            @ftype = hash[:ftype] || :rvalue
+            hash.delete(:ftype) if hash.include? :ftype
+
+            super(hash)
+
+            # Make sure it's a defined function
+            unless @fname = Puppet::Parser::Functions.function(@name)
+                raise Puppet::ParseError, "Unknown function %s" % @name
+            end
+
+            # Now check that it's been used correctly
+            case @ftype
+            when :rvalue:
+                unless Puppet::Parser::Functions.rvalue?(@name)
+                    raise Puppet::ParseError, "Function '%s' does not return a value" %
+                        @name
+                end
+            when :statement:
+                if Puppet::Parser::Functions.rvalue?(@name)
+                    raise Puppet::ParseError,
+                        "Function '%s' must be the value of a statement" %
+                        @name
+                end
+            else
+                raise Puppet::DevError, "Invalid function type %s" % @ftype.inspect
+            end
+
+            # Lastly, check the arity
+        end
+    end
+end
+
+# $Id: function.rb 1190 2006-05-13 20:01:12Z luke $

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

@@ -9,47 +9,92 @@ class Puppet::Parser::AST
         #def evaluate(scope,hash,objtype,objname)
         def evaluate(hash)
             scope = hash[:scope]
-            objtype = hash[:type]
             objname = hash[:name]
-            hash = hash[:arguments]
+            args = hash[:arguments]
             # Verify that we haven't already been evaluated
             # FIXME The second subclass won't evaluate the parent class
             # code at all, and any overrides will throw an error.
-            if scope.lookupclass(self.object_id)
+            if myscope = scope.lookupclass(self.object_id)
                 Puppet.debug "%s class already evaluated" % @type
+
+                # Not used, but will eventually be used to fix #140.
+                if myscope.is_a? Puppet::Parser::Scope
+                    unless scope.object_id == myscope.object_id
+                        #scope.parent = myscope
+                    end
+                end
                 return nil
             end
 
+            # Set the class before we do anything else, so that it's set
+            # during the evaluation and can be inspected.
+            scope.setclass(self.object_id, @type)
+
+            origscope = scope
+
             # Default to creating a new context
             newcontext = true
-            if parentscope = self.evalparent(
-                :scope => scope, :arguments => hash, :name => objname
+
+            # If we've got a parent, then we pass it the original scope we
+            # received.  It will get passed all the way up to the top class,
+            # which will create a subscope and pass that subscope to its
+            # subclass.
+            if @parentscope = self.evalparent(
+                :scope => scope, :arguments => args, :name => objname
             )
+                if @parentscope.is_a? Puppet::TransBucket
+                    raise Puppet::DevError, "Got a bucket instead of a scope"
+                end
+
                 # Override our scope binding with the parent scope
-                # binding. This is quite hackish, but I can't think
-                # of another way to make sure our scopes end up under
-                # our parent scopes.
-                scope = parentscope
+                # binding.
+                scope = @parentscope
 
                 # But don't create a new context if our parent created one
                 newcontext = false
             end
 
-            # just use the Component evaluate method, but change the type
-            # to our own type
-            #retval = super(scope,hash,@name,objname)
-            retval = super(
+            # Just use the Component evaluate method, but change the type
+            # to our own type.
+            result = super(
                 :scope => scope,
-                :arguments => hash,
+                :arguments => args,
                 :type => @type,
-                :name => objname,
-                :newcontext => newcontext
+                :name => objname,               # might be nil
+                :newcontext => newcontext,
+                :asparent => hash[:asparent] || false    # might be nil
             )
 
-            # Set the mark after we evaluate, so we don't record it but
-            # then encounter an error
-            scope.setclass(self.object_id, @type)
-            return retval
+            # Now set the class again, this time using the scope.  This way
+            # we can look up the parent scope of this class later, so we
+            # can hook the children together.
+            scope.setscope(self.object_id, result)
+
+            # This is important but painfully difficult.  If we're the top-level
+            # class, that is, we have no parent classes, then the transscope
+            # is our own scope, but if there are parent classes, then the topmost
+            # parent's scope is the transscope, since it contains its code and
+            # all of the subclass's code.
+            transscope ||= result
+
+            if hash[:asparent]
+                # If we're a parent class, then return the scope object itself.
+                return result
+            else
+                transscope = nil
+                if @parentscope
+                    transscope = @parentscope
+                    until transscope.parent.object_id == origscope.object_id
+                        transscope = transscope.parent
+                    end
+                else
+                    transscope = result
+                end
+
+                # But if we're the final subclass, translate the whole scope tree
+                # into TransObjects and TransBuckets.
+                return transscope.to_trans
+            end
         end
 
         # Evaluate our parent class.  Parent classes are evaluated in the
@@ -97,11 +142,14 @@ class Puppet::Parser::AST
                     raise error
                 end
                 # We don't need to pass the type, because the parent will just
-                # use its own type
+                # use its own type.  Specify that it's being evaluated as a parent,
+                # so that it returns the scope, not a transbucket.
                 return parentobj.safeevaluate(
                     :scope => scope,
                     :arguments => args,
-                    :name => name
+                    :name => name,
+                    :asparent => true,
+                    :collectable => self.collectable
                 )
             else
                 return false

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

@@ -7,13 +7,21 @@ class Puppet::Parser::AST
 
         #def evaluate(scope, facts = {})
         def evaluate(hash)
-            scope = hash[:scope]
+            origscope = hash[:scope]
             facts = hash[:facts] || {}
-            #scope.info "name is %s, type is %s" % [self.name, self.type]
+
             # nodes are never instantiated like a normal object,
             # but we need the type to be the name users would use for
             # instantiation, otherwise tags don't work out
-            scope = scope.newscope(
+
+            pscope = origscope
+            #pscope = if ! Puppet[:lexical] or hash[:asparent]
+            #    @scope
+            #else
+            #    origscope
+            #end
+
+            scope = pscope.newscope(
                 :type => self.type,
                 :keyword => @keyword
             )
@@ -36,13 +44,14 @@ class Puppet::Parser::AST
             # already been defined at this top-level scope.
             #super(scope, facts, @name, @name)
 
-            # And then evaluate our code.
-            @code.safeevaluate(:scope => scope)
-
             # Mark our node name as a class, too, but strip it of the domain
-            # name.
+            # name.  Make the mark before we evaluate the code, so that it is
+            # marked within the code itself.
             scope.setclass(self.object_id, @type.sub(/\..+/, ''))
 
+            # And then evaluate our code.
+            @code.safeevaluate(:scope => scope)
+
             return scope
         end
 
@@ -77,7 +86,7 @@ class Puppet::Parser::AST
 
                 begin
                     code = node.code
-                    code.safeevaluate(:scope => scope)
+                    code.safeevaluate(:scope => scope, :asparent => true)
                 rescue Puppet::ParseError => except
                     except.line = self.line
                     except.file = self.file