puppet 0.18.4 → 0.22.4

data/lib/puppet/parser/ast.rb

@@ -1,156 +1,125 @@
 # the parent class for all of our syntactical objects
 
 require 'puppet'
+require 'puppet/util/autoload'
 
-module Puppet
-    module Parser
-        # The base class for all of the objects that make up the parse trees.
-        # Handles things like file name, line #, and also does the initialization
-        # for all of the parameters of all of the child objects.
-        class AST
-            # Do this so I don't have to type the full path in all of the subclasses
-            AST = Puppet::Parser::AST
-
-            Puppet.setdefaults("ast",
-                :typecheck => [true, "Whether to validate types during parsing."],
-                :paramcheck => [true, "Whether to validate parameters during parsing."]
-            )
-            attr_accessor :line, :file, :parent, :scope
-
-            # Just used for 'tree', which is only used in debugging.
-            @@pink = ""
-            @@green = ""
-            @@yellow = ""
-            @@slate = ""
-            @@reset = ""
-
-            # Just used for 'tree', which is only used in debugging.
-            @@indent = " " * 4
-            @@indline = @@pink + ("-" * 4) + @@reset
-            @@midline = @@slate + ("-" * 4) + @@reset
-
-            @@settypes = {}
-
-            # Just used for 'tree', which is only used in debugging.
-            def AST.indention
-                return @@indent * @@indention
-            end
-
-            # Just used for 'tree', which is only used in debugging.
-            def AST.midline
-                return @@midline
-            end
-
-            # Evaluate the current object.  Basically just iterates across all
-            # of the contained children and evaluates them in turn, returning a
-            # list of all of the collected values, rejecting nil values
-            def evaluate(args)
-                #Puppet.debug("Evaluating ast %s" % @name)
-                value = self.collect { |obj|
-                    obj.safeevaluate(args)
-                }.reject { |obj|
-                    obj.nil?
-                }
-            end
-
-            # The version of the evaluate method that should be called, because it
-            # correctly handles errors.  It is critical to use this method because
-            # it can enable you to catch the error where it happens, rather than
-            # much higher up the stack.
-            def safeevaluate(*args)
-                begin
-                    self.evaluate(*args)
-                rescue Puppet::DevError => except
-                    except.line ||= @line
-                    except.file ||= @file
-                    raise
-                rescue Puppet::ParseError => except
-                    except.line ||= @line
-                    except.file ||= @file
-                    raise
-                rescue => detail
-                    #if Puppet[:debug]
-                    #    puts detail.backtrace
-                    #end
-                    error = Puppet::DevError.new(
-                        "Child of type %s failed with error %s: %s" %
-                            [self.class, detail.class, detail.to_s]
-                    )
-                    error.line ||= @line
-                    error.file ||= @file
-                    error.backtrace = detail.backtrace
-                    if Puppet[:debug]
-                        puts detail.backtrace
-                    end
-                    raise error
-                end
-            end
-
-            # Again, just used for printing out the parse tree.
-            def typewrap(string)
-                #return self.class.to_s.sub(/.+::/,'') +
-                    #"(" + @@green + string.to_s + @@reset + ")"
-                return @@green + string.to_s + @@reset +
-                    "(" + self.class.to_s.sub(/.+::/,'') + ")"
-            end
-
-            # Initialize the object.  Requires a hash as the argument, and
-            # takes each of the parameters of the hash and calls the settor
-            # method for them.  This is probably pretty inefficient and should
-            # likely be changed at some point.
-            def initialize(args)
-                @file = nil
-                @line = nil
-                args.each { |param,value|
-                    method = param.to_s + "="
-                    unless self.respond_to?(method)
-                        error = Puppet::ParseError.new(
-                            "Invalid parameter %s to object class %s" %
-                                [param,self.class.to_s]
-                        )
-                        error.line = self.line
-                        error.file = self.file
-                        raise error
-                    end
-
-                    begin
-                        #Puppet.debug("sending %s to %s" % [method, self.class])
-                        self.send(method,value)
-                    rescue => detail
-                        error = Puppet::DevError.new(
-                            "Could not set parameter %s on class %s: %s" %
-                                [method,self.class.to_s,detail]
-                        )
-                        error.line ||= self.line
-                        error.file ||= self.file
-                        raise error
-                    end
-                }
-            end
-            #---------------------------------------------------------------
+# The base class for all of the objects that make up the parse trees.
+# Handles things like file name, line #, and also does the initialization
+# for all of the parameters of all of the child objects.
+class Puppet::Parser::AST
+    # Do this so I don't have to type the full path in all of the subclasses
+    AST = Puppet::Parser::AST
+
+    include Puppet::Util::Errors
+    include Puppet::Util::MethodHelper
+
+    Puppet.setdefaults("ast",
+        :typecheck => [true, "Whether to validate types during parsing."],
+        :paramcheck => [true, "Whether to validate parameters during parsing."]
+    )
+    attr_accessor :line, :file, :parent, :scope
+
+    # Just used for 'tree', which is only used in debugging.
+    @@pink = ""
+    @@green = ""
+    @@yellow = ""
+    @@slate = ""
+    @@reset = ""
+
+    # Just used for 'tree', which is only used in debugging.
+    @@indent = " " * 4
+    @@indline = @@pink + ("-" * 4) + @@reset
+    @@midline = @@slate + ("-" * 4) + @@reset
+
+    @@settypes = {}
+
+    # Just used for 'tree', which is only used in debugging.
+    def AST.indention
+        return @@indent * @@indention
+    end
+
+    # Just used for 'tree', which is only used in debugging.
+    def AST.midline
+        return @@midline
+    end
+
+    # Does this ast object set something?  If so, it gets evaluated first.
+    def self.settor?
+        if defined? @settor
+            @settor
+        else
+            false
         end
     end
+
+    # Evaluate the current object.  Basically just iterates across all
+    # of the contained children and evaluates them in turn, returning a
+    # list of all of the collected values, rejecting nil values
+    def evaluate(args)
+        #Puppet.debug("Evaluating ast %s" % @name)
+        value = self.collect { |obj|
+            obj.safeevaluate(args)
+        }.reject { |obj|
+            obj.nil?
+        }
+    end
+
+    # Throw a parse error.
+    def parsefail(message)
+        self.fail(Puppet::ParseError, message)
+    end
+
+    # Wrap a statemp in a reusable way so we always throw a parse error.
+    def parsewrap
+        exceptwrap :type => Puppet::ParseError do
+            yield
+        end
+    end
+
+    # The version of the evaluate method that should be called, because it
+    # correctly handles errors.  It is critical to use this method because
+    # it can enable you to catch the error where it happens, rather than
+    # much higher up the stack.
+    def safeevaluate(options)
+        # We duplicate code here, rather than using exceptwrap, because this
+        # is called so many times during parsing.
+        begin
+            return self.evaluate(options)
+        rescue Puppet::Error => detail
+            raise adderrorcontext(detail)
+        rescue => detail
+            error = Puppet::Error.new(detail.to_s)
+            # We can't use self.fail here because it always expects strings,
+            # not exceptions.
+            raise adderrorcontext(error)
+        end
+    end
+
+    # Again, just used for printing out the parse tree.
+    def typewrap(string)
+        #return self.class.to_s.sub(/.+::/,'') +
+            #"(" + @@green + string.to_s + @@reset + ")"
+        return @@green + string.to_s + @@reset +
+            "(" + self.class.to_s.sub(/.+::/,'') + ")"
+    end
+
+    # Initialize the object.  Requires a hash as the argument, and
+    # takes each of the parameters of the hash and calls the settor
+    # method for them.  This is probably pretty inefficient and should
+    # likely be changed at some point.
+    def initialize(args)
+        @file = nil
+        @line = nil
+        set_options(args)
+    end
+    #---------------------------------------------------------------
+    # Now autoload everything.
+    @autoloader = Puppet::Util::Autoload.new(self,
+        "puppet/parser/ast"
+    )
+    @autoloader.loadall
 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'
-require 'puppet/parser/ast/compdef'
-require 'puppet/parser/ast/component'
-require 'puppet/parser/ast/hostclass'
 require 'puppet/parser/ast/leaf'
-require 'puppet/parser/ast/node'
-require 'puppet/parser/ast/nodedef'
-require 'puppet/parser/ast/objectdef'
-require 'puppet/parser/ast/objectparam'
-require 'puppet/parser/ast/objectref'
-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 1250 2006-06-09 21:22:25Z luke $
+
+# $Id: ast.rb 2231 2007-02-27 21:31:02Z luke $

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

@@ -25,14 +25,6 @@ class Puppet::Parser::AST
                 # 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 = []
 
@@ -44,36 +36,30 @@ class Puppet::Parser::AST
                 @children.each { |child|
                     if child.instance_of?(AST::ASTArray)
                         child.each do |ac|
-                            items << ac
+                            if ac.class.settor?
+                                settors << ac
+                            else
+                                others << ac
+                            end
                         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 << child
+                        if child.class.settor?
+                            settors << child
+                        else
+                            others << child
+                        end
                     end
                 }
-                rets = [definers, settors, others].flatten.collect { |child|
+                rets = [settors, others].flatten.collect { |child|
                     child.safeevaluate(:scope => scope)
                 }
+                return rets.reject { |o| o.nil? }
             else
                 # If we're not declarative, just do everything in order.
-                rets = @children.collect { |item|
+                return @children.collect { |item|
                     item.safeevaluate(:scope => scope)
-                }
+                }.reject { |o| o.nil? }
             end
-
-            rets = rets.reject { |obj| obj.nil? }
-
-            return rets
         end
 
         def push(*ary)
@@ -107,9 +93,7 @@ class Puppet::Parser::AST
     # Used for abstracting the grammar declarations.  Basically unnecessary
     # except that I kept finding bugs because I had too many arrays that
     # meant completely different things.
-    class ObjectInst < ASTArray; end
-
-    # Another simple container class to make sure we can correctly arrayfy
-    # things.
-    class CompArgument < ASTArray; end
+    class ResourceInst < ASTArray; end
 end
+
+# $Id: astarray.rb 1739 2006-10-06 03:13:15Z luke $

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

@@ -45,3 +45,5 @@ class Puppet::Parser::AST
         end
     end
 end
+
+# $Id: branch.rb 1484 2006-08-22 23:34:40Z luke $

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

@@ -1,3 +1,5 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
     # Each individual option in a case statement.
     class CaseOpt < AST::Branch
@@ -42,26 +44,17 @@ class Puppet::Parser::AST
         def eachvalue(scope)
             if @value.is_a?(AST::ASTArray)
                 @value.each { |subval|
-                    if scope
-                        yield subval.evaluate(:scope => scope)
-                    elsif subval.is_a? AST::Leaf
-                        yield subval.value
-                    end
+                    yield subval.evaluate(:scope => scope)
                 }
             else
-                if scope
-                    yield @value.evaluate(:scope => scope)
-                elsif @value.is_a? AST::Leaf
-                    yield @value.value
-                end
+                yield @value.evaluate(:scope => scope)
             end
         end
 
         # Evaluate the actual statements; this only gets called if
         # our option matched.
         def evaluate(hash)
-            scope = hash[:scope]
-            return @statements.safeevaluate(:scope => scope)
+            return @statements.safeevaluate(hash)
         end
 
         def tree(indent = 0)
@@ -74,3 +67,5 @@ class Puppet::Parser::AST
         end
     end
 end
+
+# $Id: caseopt.rb 2259 2007-03-06 19:03:05Z luke $

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

@@ -1,3 +1,5 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
     # The basic logical structure in Puppet.  Supports a list of
     # tests and statement arrays.
@@ -9,58 +11,46 @@ class Puppet::Parser::AST
         def evaluate(hash)
             scope = hash[:scope]
             value = @test.safeevaluate(:scope => scope)
+            sensitive = Puppet[:casesensitive]
+            value = value.downcase if ! sensitive and value.respond_to?(:downcase)
 
             retvalue = nil
             found = false
             
             # Iterate across the options looking for a match.
+            default = nil
             @options.each { |option|
-                if option.eachvalue(scope) { |opval| break true if opval == value }
+                option.eachvalue(scope) { |opval|
+                    opval = opval.downcase if ! sensitive and opval.respond_to?(:downcase)
+                    if opval == value
+                        found = true
+                        break
+                    end
+                }
+
+                if found
                     # we found a matching option
                     retvalue = option.safeevaluate(:scope => scope)
-                    found = true
                     break
                 end
+
+                if option.default?
+                    default = option
+                end
             }
 
             # Unless we found something, look for the default.
             unless found
-                if defined? @default
-                    retvalue = @default.safeevaluate(:scope => scope)
+                if default
+                    retvalue = default.safeevaluate(:scope => scope)
                 else
                     Puppet.debug "No true answers and no default"
+                    retvalue = nil
                 end
             end
             return retvalue
         end
 
-        # Do some input validation on our options.
-        def initialize(hash)
-            values = {}
-
-            super
-
-            # This won't work if we move away from only allowing
-            # constants here, but for now, it's fine and useful.
-            @options.each { |option|
-                unless option.is_a?(CaseOpt)
-                    raise Puppet::DevError, "Option is not a CaseOpt"
-                end
-                if option.default?
-                    @default = option
-                end
-                option.eachvalue(nil) { |val|
-                    if values.include?(val)
-                        raise Puppet::ParseError,
-                            "Value %s appears twice in case statement" %
-                                val
-                    else
-                        values[val] = true
-                    end
-                }
-            }
-        end
-
         def tree(indent = 0)
             rettree = [
                 @test.tree(indent + 1),
@@ -75,5 +65,6 @@ class Puppet::Parser::AST
             [@test,@options].each { |child| yield child }
         end
     end
-
 end
+
+# $Id: casestatement.rb 2259 2007-03-06 19:03:05Z luke $