puppet 0.18.4 → 0.22.4

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

@@ -0,0 +1,30 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    # A separate ElseIf statement; can function as an 'else' if there's no
+    # test.
+    class Else < AST::Branch
+        attr_accessor :statements
+
+        def each
+            yield @statements
+        end
+
+        # Evaluate the actual statements; this only gets called if
+        # our test was true matched.
+        def evaluate(hash)
+            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

@@ -1,8 +1,12 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
     # An AST object to call a function.
     class Function < AST::Branch
         attr_accessor :name, :arguments
 
+        @settor = true
+
         def evaluate(hash)
             # We don't need to evaluate the name, because it's plaintext
 
@@ -11,7 +15,10 @@ class Puppet::Parser::AST
 
             args = @arguments.safeevaluate(:scope => scope)
 
-            return scope.send("function_" + @name, args)
+            #exceptwrap :message => "Failed to execute %s" % @name,
+            #        :type => Puppet::ParseError do
+                return scope.send("function_" + @name, args)
+            #end
         end
 
         def initialize(hash)
@@ -47,4 +54,4 @@ class Puppet::Parser::AST
     end
 end
 
-# $Id: function.rb 1190 2006-05-13 20:01:12Z luke $
+# $Id: function.rb 1835 2006-11-08 05:22:24Z luke $

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

@@ -1,158 +1,66 @@
+require 'puppet/parser/ast/component'
+
 class Puppet::Parser::AST
     # The code associated with a class.  This is different from components
     # in that each class is a singleton -- only one will exist for a given
     # node.
     class HostClass < AST::Component
         @name = :class
-        attr_accessor :parentclass
 
-        #def evaluate(scope,hash,objtype,objname)
+        # Are we a child of the passed class?  Do a recursive search up our
+        # parentage tree to figure it out.
+        def child_of?(klass)
+            return false unless self.parentclass
+
+            if klass == self.parentclass
+                return true
+            else
+                return self.parentclass.child_of?(klass)
+            end
+        end
+
+        # Evaluate the code associated with this class.
         def evaluate(hash)
             scope = hash[:scope]
-            objname = hash[:name]
             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 myscope = scope.lookupclass(self.object_id)
+            if scope.setclass?(self)
                 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
+            pnames = nil
+            if @parentclass
+                if pklass = self.parentclass
+                    pklass.safeevaluate :scope => scope
 
-            # 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"
+                    scope = parent_scope(scope, pklass)
+                    pnames = scope.namespaces
+                else
+                    parsefail "Could not find class %s" % @parentclass
                 end
-
-                # Override our scope binding with the parent scope
-                # 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.
-            result = super(
-                :scope => scope,
-                :arguments => args,
-                :type => @type,
-                :name => objname,               # might be nil
-                :newcontext => newcontext,
-                :asparent => hash[:asparent] || false    # might be nil
-            )
-
-            # 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
+            unless hash[:nosubscope]
+                scope = subscope(scope)
+            end
 
-            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
+            if pnames
+                pnames.each do |ns|
+                    scope.add_namespace(ns)
                 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
-        # exact same scope as the children.  This is maybe not a good idea
-        # but, eh.
-        #def evalparent(scope, args, name)
-        def evalparent(hash)
-            scope = hash[:scope]
-            args = hash[:arguments]
-            name = hash[:name]
-            if @parentclass
-                #scope.warning "parent class of %s is %s" %
-                #    [@type, @parentclass.inspect]
-                parentobj = nil
 
-                begin
-                    parentobj = scope.lookuptype(@parentclass)
-                rescue Puppet::ParseError => except
-                    except.line = self.line
-                    except.file = self.file
-                    raise except
-                rescue => detail
-                    error = Puppet::ParseError.new(detail)
-                    error.line = self.line
-                    error.file = self.file
-                    raise error
-                end
-                unless parentobj
-                    error = Puppet::ParseError.new( 
-                        "Could not find parent '%s' of '%s'" %
-                            [@parentclass,@name])
-                    error.line = self.line
-                    error.file = self.file
-                    raise error
-                end
+            # Set the class before we do anything else, so that it's set
+            # during the evaluation and can be inspected.
+            scope.setclass(self)
 
-                # Verify that the parent and child are of the same type
-                unless parentobj.class == self.class
-                    error = Puppet::ParseError.new(
-                        "Class %s has incompatible parent type, %s vs %s" %
-                        [@type, parentobj.class, self.class]
-                    )
-                    error.file = self.file
-                    error.line = self.line
-                    raise error
-                end
-                # We don't need to pass the type, because the parent will just
-                # 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,
-                    :asparent => true,
-                    :collectable => self.collectable
-                )
+            # Now evaluate our code, yo.
+            if self.code
+                return self.code.evaluate(:scope => scope)
             else
-                return false
+                return nil
             end
         end
 
@@ -161,6 +69,14 @@ class Puppet::Parser::AST
             super
         end
 
+        def parent_scope(scope, klass)
+            if s = scope.class_scope(klass)
+                return s
+            else
+                raise Puppet::DevError, "Could not find scope for %s" % klass.fqname
+            end
+        end
     end
-
 end
+
+# $Id: hostclass.rb 2226 2007-02-27 16:30:09Z luke $

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

@@ -0,0 +1,43 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    # A basic 'if/elsif/else' statement.
+    class IfStatement < AST::Branch
+        attr_accessor :test, :else, :statements
+
+        def each
+            [@test,@else,@statements].each { |child| yield child }
+        end
+
+        # Short-curcuit evaluation.  If we're true, evaluate our statements,
+        # else if there's an 'else' setting, evaluate it.
+        # the first option that matches.
+        def evaluate(hash)
+            scope = hash[:scope]
+            value = @test.safeevaluate(:scope => scope)
+
+            if Puppet::Parser::Scope.true?(value)
+                return @statements.safeevaluate(:scope => scope)
+            else
+                if defined? @else
+                    return @else.safeevaluate(:scope => scope)
+                else
+                    return nil
+                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

@@ -28,15 +28,11 @@ class Puppet::Parser::AST
         def initialize(hash)
             super
 
-            unless @value == 'true' or @value == 'false'
+            unless @value == true or @value == false
                 raise Puppet::DevError,
                     "'%s' is not a boolean" % @value
             end
-            if @value == 'true'
-                @value = true
-            else
-                @value = false
-            end
+            @value
         end
     end
 
@@ -45,14 +41,12 @@ class Puppet::Parser::AST
         # Interpolate the string looking for variables, and then return
         # the result.
         def evaluate(hash)
-            return hash[:scope].strinterp(@value)
+            return hash[:scope].strinterp(@value, @file, @line)
         end
     end
 
-    # The base string class.
+    # An uninterpreted string.
     class FlatString < AST::Leaf
-        # Interpolate the string looking for variables, and then return
-        # the result.
         def evaluate(hash)
             return @value
         end
@@ -69,6 +63,9 @@ class Puppet::Parser::AST
     # Lower-case words.
     class Name < AST::Leaf; end
 
+    # double-colon separated class names
+    class ClassName < AST::Leaf; end
+
     # Host names, either fully qualified or just the short name
     class HostName < AST::Leaf
         def initialize(hash)
@@ -87,20 +84,12 @@ class Puppet::Parser::AST
         # Looks up the value of the object in the scope tree (does
         # not include syntactical constructs, like '$' and '{}').
         def evaluate(hash)
-            begin
+            parsewrap do
                 return hash[:scope].lookupvar(@value)
-            rescue Puppet::ParseError => except
-                except.line = self.line
-                except.file = self.file
-                raise except
-            rescue => detail
-                error = Puppet::DevError.new(detail)
-                error.line = self.line
-                error.file = self.file
-                error.backtrace = detail.backtrace
-                raise error
             end
         end
     end
 
 end
+
+# $Id: leaf.rb 2239 2007-02-28 01:21:58Z luke $

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

@@ -1,113 +1,66 @@
+require 'puppet/parser/ast/hostclass'
+
 class Puppet::Parser::AST
     # The specific code associated with a host.  Nodes are annoyingly unlike
     # other objects.  That's just the way it is, at least for now.
     class Node < AST::HostClass
         @name = :node
-        attr_accessor :type, :args, :code, :parentclass
+        attr_accessor :name
 
         #def evaluate(scope, facts = {})
         def evaluate(hash)
-            origscope = hash[:scope]
-            facts = hash[:facts] || {}
-
-            # 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 = hash[:scope]
 
-            pscope = origscope
             #pscope = if ! Puppet[:lexical] or hash[:asparent]
             #    @scope
             #else
             #    origscope
             #end
 
-            scope = pscope.newscope(
-                :type => self.type,
-                :keyword => @keyword
-            )
-            scope.context = self.object_id
-
-            # Now set all of the facts inside this scope
-            facts.each { |var, value|
-                scope.setvar(var, value)
-            }
-
-            if tmp = self.evalparent(scope)
-                # Again, override our scope with the parent scope, if
-                # there is one.
-                scope = tmp
+            # 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.parentclass
+                scope = parent.safeevaluate :scope => scope
             end
 
-            #scope.tag(@name)
-
-            # We never pass the facts to the parent class, because they've
-            # already been defined at this top-level scope.
-            #super(scope, facts, @name, @name)
+            scope = scope.newscope(
+                :type => self.name,
+                :keyword => @keyword,
+                :source => self,
+                :namespace => "" # nodes are always in ""
+            )
 
             # 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.object_id, @type.sub(/\..+/, ''))
+            scope.setclass(self)
 
-            # And then evaluate our code.
-            @code.safeevaluate(:scope => scope)
+            # And then evaluate our code if we have any
+            if self.code
+                @code.safeevaluate(:scope => scope)
+            end
 
             return scope
         end
 
-        # Evaluate our parent class.
-        def evalparent(scope)
-            if @parentclass
-                # This is pretty messed up.  I don't know if this will
-                # work in the long term, but we need to evaluate the node
-                # in our own scope, even though our parent node has
-                # a scope associated with it, because otherwise we 1) won't
-                # get our facts defined, and 2) we won't actually get the
-                # objects returned, based on how nodes work.
-
-                # We also can't just evaluate the node itself, because
-                # it would create a node scope within this scope,
-                # and that would cause mass havoc.
-                node = nil
-
-                # The 'node' method just returns a hash of the node
-                # code and name.  It's used here, and in 'evalnode'.
-                unless hash = scope.node(@parentclass)
-                    raise Puppet::ParseError,
-                        "Could not find parent node %s" %
-                        @parentclass
-                end
-
-                node = hash[:node]
-                type = nil
-                if type = node.type
-                    scope.tag(node.type)
-                end
-
-                begin
-                    code = node.code
-                    code.safeevaluate(:scope => scope, :asparent => true)
-                rescue Puppet::ParseError => except
-                    except.line = self.line
-                    except.file = self.file
-                    raise except
-                rescue => detail
-                    error = Puppet::ParseError.new(detail)
-                    error.line = self.line
-                    error.file = self.file
-                    raise error
-                end
+        def initialize(hash)
+            @parentclass = nil
+            super
 
-                if node.parentclass
-                    node.evalparent(scope)
-                end
+            # Do some validation on the node name
+            if @name =~ /[^-\w.]/
+                raise Puppet::ParseError, "Invalid node name %s" % @name
             end
         end
 
-        def initialize(hash)
-            @parentclass = nil
-            super
+        def parentclass
+            parentobj do |name|
+                @interp.nodesearch(name)
+            end
 
+            @parentclass
         end
     end
 end
+
+# $Id: node.rb 1727 2006-10-04 18:44:26Z luke $