puppet 0.24.9 → 0.25.0

data/lib/puppet/parser/files.rb

@@ -0,0 +1,92 @@
+require 'puppet/module'
+require 'puppet/parser/parser'
+
+# This is a silly central module for finding
+# different kinds of files while parsing.  This code
+# doesn't really belong in the Puppet::Module class,
+# but it doesn't really belong anywhere else, either.
+module Puppet::Parser::Files
+    module_function
+
+    # Return a list of manifests (as absolute filenames) that match +pat+
+    # with the current directory set to +cwd+. If the first component of
+    # +pat+ does not contain any wildcards and is an existing module, return
+    # a list of manifests in that module matching the rest of +pat+
+    # Otherwise, try to find manifests matching +pat+ relative to +cwd+
+    def find_manifests(start, options = {})
+        cwd = options[:cwd] || Dir.getwd
+        module_name, pattern = split_file_path(start)
+        begin
+            if mod = Puppet::Module.find(module_name, options[:environment])
+                return mod.match_manifests(pattern)
+            end
+        rescue Puppet::Module::InvalidName
+            # Than that would be a "no."
+        end
+        abspat = File::expand_path(start, cwd)
+        files = Dir.glob(abspat).reject { |f| FileTest.directory?(f) }
+        if files.size == 0
+            files = Dir.glob(abspat + ".pp").reject { |f| FileTest.directory?(f) }
+        end
+        return files
+    end
+
+    # Find the concrete file denoted by +file+. If +file+ is absolute,
+    # return it directly. Otherwise try to find it as a template in a
+    # module. If that fails, return it relative to the +templatedir+ config
+    # param.
+    # In all cases, an absolute path is returned, which does not
+    # necessarily refer to an existing file
+    def find_template(template, environment = nil)
+        if template =~ /^#{File::SEPARATOR}/
+            return template
+        end
+
+        if template_paths = templatepath(environment)
+            # If we can find the template in :templatedir, we return that.
+            template_paths.collect { |path|
+                File::join(path, template)
+            }.each do |f|
+                return f if FileTest.exist?(f)
+            end
+        end
+
+        # check in the default template dir, if there is one
+        if td_file = find_template_in_module(template, environment)
+            return td_file
+        end
+
+        return nil
+    end
+
+    def find_template_in_module(template, environment = nil)
+        path, file = split_file_path(template)
+
+        # Because templates don't have an assumed template name, like manifests do,
+        # we treat templates with no name as being templates in the main template
+        # directory.
+        return nil unless file
+
+        if mod = Puppet::Module.find(path, environment) and t = mod.template(file)
+            return t
+        end
+        nil
+    end
+
+    # Return an array of paths by splitting the +templatedir+ config
+    # parameter.
+    def templatepath(environment = nil)
+        dirs = Puppet.settings.value(:templatedir, environment).split(":")
+        dirs.select do |p|
+            File::directory?(p)
+        end
+    end
+
+    # Split the path into the module and the rest of the path, or return
+    # nil if the path is empty or absolute (starts with a /).
+    # This method can return nil & anyone calling it needs to handle that.
+    def split_file_path(path)
+        path.split(File::SEPARATOR, 2) unless path =~ /^(#{File::SEPARATOR}|$)/
+    end
+
+end

data/lib/puppet/parser/functions.rb

@@ -113,14 +113,14 @@ module Functions
 
         if @functions.include? name
             case @functions[name][:type]
-            when :statement: return false
-            when :rvalue: return true
+            when :statement; return false
+            when :rvalue; return true
             end
         else
             return false
         end
     end
-  
+
     # Runs a newfunction to create a function for each of the log levels
 
     Puppet::Util::Log.levels.each do |level|

data/lib/puppet/parser/functions/defined.rb

@@ -8,13 +8,13 @@ Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Dete
         result = false
         vals.each do |val|
             case val
-            when String:
+            when String
                 # For some reason, it doesn't want me to return from here.
-                if Puppet::Type.type(val) or finddefine(val) or findclass(val)
+                if Puppet::Type.type(val) or find_definition(val) or find_hostclass(val)
                     result = true
                     break
                 end
-            when Puppet::Parser::Resource::Reference:
+            when Puppet::Parser::Resource::Reference
                 if findresource(val.to_s)
                     result = true
                     break

data/lib/puppet/parser/functions/fqdn_rand.rb

@@ -1,6 +1,6 @@
-Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc => 
-    "Generates random numbers based on the node's fqdn. The first argument 
-    sets the range.  The second argument specifies a number to add to the 
+Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc =>
+    "Generates random numbers based on the node's fqdn. The first argument
+    sets the range.  The second argument specifies a number to add to the
     seed and is optional.") do |args|
         require 'md5'
         max = args[0]

data/lib/puppet/parser/functions/inline_template.rb

@@ -1,7 +1,7 @@
-Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :doc => 
-    "Evaluate a template string and return its value.  See `the templating docs 
-    </trac/puppet/wiki/PuppetTemplating>`_ for more information.  Note that 
-    if multiple template strings are specified, their output is all concatenated 
+Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :doc =>
+    "Evaluate a template string and return its value.  See `the templating docs
+    </trac/puppet/wiki/PuppetTemplating>`_ for more information.  Note that
+    if multiple template strings are specified, their output is all concatenated
     and returned as the output of the function.") do |vals|
         require 'erb'
 

data/lib/puppet/parser/functions/regsubst.rb

@@ -1,7 +1,9 @@
 module Puppet::Parser::Functions
     newfunction(:regsubst, :type => :rvalue,
-		:doc => "
-                Perform regexp replacement on a string. Parameters (in order):
+                :doc => "
+                Perform regexp replacement on a string.
+
+- **Parameters** (in order):
 
 :str:  The string to operate on.
 
@@ -17,13 +19,13 @@ module Puppet::Parser::Functions
     - **G**         Global replacement; all occurrences of the regexp in the string will be replaced.  Without this, only the first occurrence will be replaced.
 
 :lang:  Optional.  How to handle multibyte characters.  A single-character string with the following values:
-     
+
      - **N**         None
      - **E**         EUC
      - **S**         SJIS
      - **U**         UTF-8
 
-**Examples**
+- **Examples**
 
 Get the third octet from the node's IP address::
 
@@ -34,36 +36,36 @@ Put angle brackets around each octet in the node's IP address::
     $x = regsubst($ipaddress, '([0-9]+)', '<\\1>', 'G')
 ") \
         do |args|
-	flag_mapping = {
-	    "E" => Regexp::EXTENDED,
-	    "I" => Regexp::IGNORECASE,
-	    "M" => Regexp::MULTILINE,
-	}
-	if args.length < 3  or  args.length > 5
-	    raise Puppet::ParseError, ("regsub(): wrong number of arguments" +
-				       " (#{args.length}; min 3, max 5)")
-	end
-	str, regexp, replacement, flags, lang = args
-	reflags = 0
-	global = false
-	(flags or "").each_byte do |f|
-	    f = f.chr
-	    if f == "G"
-		global = true
-	    else
-		fvalue = flag_mapping[f]
-		if !fvalue
-		    raise Puppet::ParseError, "regsub(): bad flag `#{f}'"
-		end
-		reflags |= fvalue
-	    end
-	end
-	re = Regexp.compile(regexp, reflags, lang)
-	if global
-	    result = str.gsub(re, replacement)
-	else
-	    result = str.sub(re, replacement)
-	end
-	return result
+        flag_mapping = {
+            "E" => Regexp::EXTENDED,
+            "I" => Regexp::IGNORECASE,
+            "M" => Regexp::MULTILINE,
+        }
+        if args.length < 3  or  args.length > 5
+            raise Puppet::ParseError, ("regsub(): wrong number of arguments" +
+                                       " (#{args.length}; min 3, max 5)")
+        end
+        str, regexp, replacement, flags, lang = args
+        reflags = 0
+        global = false
+        (flags or "").each_byte do |f|
+            f = f.chr
+            if f == "G"
+                global = true
+            else
+                fvalue = flag_mapping[f]
+                if !fvalue
+                    raise Puppet::ParseError, "regsub(): bad flag `#{f}'"
+                end
+                reflags |= fvalue
+            end
+        end
+        re = Regexp.compile(regexp, reflags, lang)
+        if global
+            result = str.gsub(re, replacement)
+        else
+            result = str.sub(re, replacement)
+        end
+        return result
     end
 end

data/lib/puppet/parser/functions/require.rb

@@ -0,0 +1,34 @@
+# Requires the specified classes
+Puppet::Parser::Functions::newfunction(:require,
+        :doc =>"Evaluate one or more classes,  adding the required class as a dependency.
+
+The relationship metaparameters work well for specifying relationships
+between individual resources, but they can be clumsy for specifying 
+relationships between classes.  This function is a superset of the
+'include' function, adding a class relationship so that the requiring
+class depends on the required class.
+
+.. Warning::
+  using require in place of include can lead to unwanted dependency cycles.
+  For instance the following manifest, with 'require' instead of 'include'
+  would produce a nasty dependence cycle, because notify imposes a before
+  between File[/foo] and Service[foo]::
+
+    class myservice {
+       service { foo: ensure => running }
+    }
+
+    class otherstuff {
+       include myservice
+       file { '/foo': notify => Service[foo] }
+    }
+
+") do |vals|
+        send(:function_include, vals)
+        vals = [vals] unless vals.is_a?(Array)
+
+        # add a relation from ourselves to each required klass
+        vals.each do |klass|
+            compiler.catalog.add_edge(resource, findresource(:class, klass))
+        end
+end

data/lib/puppet/parser/functions/shellquote.rb

@@ -0,0 +1,41 @@
+module Puppet::Parser::Functions
+
+    Safe = 'a-zA-Z0-9@%_+=:,./-'    # Safe unquoted
+    Dangerous = '!"`$\\'            # Unsafe inside double quotes
+
+    newfunction(:shellquote, :type => :rvalue, :doc => "\
+        Quote and concatenate arguments for use in Bourne shell.
+
+        Each argument is quoted separately, and then all are concatenated
+        with spaces.  If an argument is an array, the elements of that
+        array is interpolated within the rest of the arguments; this makes
+        it possible to have an array of arguments and pass that array to
+        shellquote() instead of having to specify specify each argument
+        individually in the call.
+        ") \
+    do |args|
+
+        result = []
+        args.flatten.each do |word|
+            if word.length != 0 and word.count(Safe) == word.length
+                result << word
+            elsif word.count(Dangerous) == 0
+                result << ('"' + word + '"')
+            elsif word.count("'") == 0
+                result << ("'" + word + "'")
+            else
+                r = '"'
+                word.each_byte() do |c|
+                    if Dangerous.include?(c)
+                        r += "\\"
+                    end
+                    r += c.chr()
+                end
+                r += '"'
+                result << r
+            end
+        end
+
+        return result.join(" ")
+    end
+end

data/lib/puppet/parser/functions/split.rb

@@ -0,0 +1,29 @@
+module Puppet::Parser::Functions
+    newfunction(:split, :type => :rvalue,
+      :doc => "\
+Split a string variable into an array using the specified split regexp.
+
+  Usage::
+
+    $string     = 'v1.v2:v3.v4'
+    $array_var1 = split($string, ':')
+    $array_var2 = split($string, '[.]')
+    $array_var3 = split($string, '[.:]')
+
+$array_var1 now holds the result ['v1.v2', 'v3.v4'],
+while $array_var2 holds ['v1', 'v2:v3', 'v4'], and
+$array_var3 holds ['v1', 'v2', 'v3', 'v4'].
+
+Note that in the second example, we split on a string that contains
+a regexp meta-character (.), and that needs protection.  A simple
+way to do that for a single character is to enclose it in square
+brackets.") do |args|
+
+     if args.length != 2
+         raise Puppet::ParseError, ("split(): wrong number of arguments" +
+				   " (#{args.length}; must be 2)")
+     end
+
+     return args[0].split(Regexp.compile(args[1]))
+    end
+end

data/lib/puppet/parser/functions/sprintf.rb

@@ -1,12 +1,12 @@
 module Puppet::Parser::Functions
     newfunction(:sprintf, :type => :rvalue,
-		:doc => "Perform printf-style formatting of text.
+        :doc => "Perform printf-style formatting of text.
 
                          The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the ``Kernel::sprintf()`` function in Ruby for all the details.") do |args|
-	if args.length < 1
-	    raise Puppet::ParseError, 'sprintf() needs at least one argument'
-	end
-	fmt = args.shift()
-	return sprintf(fmt, *args)
+        if args.length < 1
+            raise Puppet::ParseError, 'sprintf() needs at least one argument'
+        end
+        fmt = args.shift()
+        return sprintf(fmt, *args)
     end
 end

data/lib/puppet/parser/functions/template.rb

@@ -1,7 +1,7 @@
-Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :doc => 
-    "Evaluate a template and return its value.  See `the templating docs 
-    </trac/puppet/wiki/PuppetTemplating>`_ for more information.  Note that 
-    if multiple templates are specified, their output is all concatenated 
+Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :doc =>
+    "Evaluate a template and return its value.  See `the templating docs
+    </trac/puppet/wiki/PuppetTemplating>`_ for more information.  Note that
+    if multiple templates are specified, their output is all concatenated
     and returned as the output of the function.") do |vals|
         require 'erb'
 

data/lib/puppet/parser/functions/versioncmp.rb

@@ -1,6 +1,27 @@
 require 'puppet/util/package'
 
-Puppet::Parser::Functions::newfunction(:versioncmp,  :doc => "Compares two versions.") do |args|
+Puppet::Parser::Functions::newfunction(:versioncmp, :type => :rvalue, 
+    :doc => "Compares two versions
+
+Prototype::
+
+    \$result = versioncmp(a, b)
+
+    where a and b are arbitrary version strings
+
+This functions returns a number::
+
+    * > 0 if version a is greater than version b
+    * == 0 if both version are equals
+    * < 0 if version a is less than version b
+
+Example::
+
+    if versioncmp('2.6-1', '2.4.5') > 0 {
+        notify('2.6-1 is > than 2.4.5')
+    }
+
+") do |args|
 
     unless args.length == 2
         raise Puppet::ParseError, "versioncmp should have 2 arguments"

data/lib/puppet/parser/grammar.ra

@@ -0,0 +1,812 @@
+# vim: syntax=ruby
+
+# the parser
+
+class Puppet::Parser::Parser
+
+token LBRACK DQTEXT SQTEXT RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
+token FALSE EQUALS APPENDS LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
+token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
+token IF ELSE IMPORT DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
+token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSNAME CLASSREF
+token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
+token MATCH NOMATCH REGEX
+
+prechigh
+    right NOT
+    nonassoc UMINUS
+    left  MATCH NOMATCH
+    left  TIMES DIV
+    left  MINUS PLUS
+    left  LSHIFT RSHIFT
+    left  NOTEQUAL ISEQUAL
+    left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
+    left  AND
+    left  OR
+preclow
+
+rule
+program:    statements {
+    if val[0]
+        # Make sure we always return an array.
+        if val[0].is_a?(AST::ASTArray)
+            if val[0].children.empty?
+                result = nil
+            else
+                result = val[0]
+            end
+        else
+            result = aryfy(val[0])
+        end
+    else
+        result = nil
+    end
+}
+            | nil
+
+statements:   statement
+            | statements statement {
+    if val[0] and val[1]
+        if val[0].instance_of?(AST::ASTArray)
+            val[0].push(val[1])
+            result = val[0]
+        else
+            result = ast AST::ASTArray, :children => [val[0],val[1]]
+        end
+    elsif obj = (val[0] || val[1])
+        result = obj
+    else result = nil
+    end
+}
+
+# The main list of valid statements
+statement:    resource
+            | virtualresource
+            | collection
+            | assignment
+            | casestatement
+            | ifstatement
+            | import
+            | fstatement
+            | definition
+            | hostclass
+            | nodedef
+            | resourceoverride
+            | append
+
+fstatement:   NAME LPAREN funcvalues RPAREN {
+    args = aryfy(val[2])
+    result = ast AST::Function,
+        :name => val[0][:value],
+        :line => val[0][:line],
+        :arguments => args,
+        :ftype => :statement
+}
+ | NAME LPAREN funcvalues COMMA RPAREN {
+    args = aryfy(val[2])
+    result = ast AST::Function,
+        :name => val[0][:value],
+        :line => val[0][:line],
+        :arguments => args,
+        :ftype => :statement
+}            | NAME LPAREN RPAREN {
+    result = ast AST::Function,
+        :name => val[0][:value],
+        :line => val[0][:line],
+        :arguments => AST::ASTArray.new({}),
+        :ftype => :statement
+}
+            | NAME funcvalues {
+    args = aryfy(val[1])
+    result = ast AST::Function,
+        :name => val[0][:value],
+        :line => val[0][:line],
+        :arguments => args,
+        :ftype => :statement
+}
+
+funcvalues:       namestring
+                | resourceref
+                | funcvalues COMMA namestring {
+    result = aryfy(val[0], val[2])
+    result.line = @lexer.line
+    result.file = @lexer.file
+}
+                | funcvalues COMMA resourceref {
+    unless val[0].is_a?(AST::ASTArray)
+        val[0] = aryfy(val[0])
+    end
+
+    val[0].push(val[2])
+
+    result = val[0]
+}
+
+# This is *almost* an rvalue, but I couldn't get a full
+# rvalue to work without scads of shift/reduce conflicts.
+namestring:       name
+                | variable
+                | type
+                | boolean
+                | funcrvalue
+                | selector
+                | quotedtext
+                | CLASSNAME {
+                    result = ast AST::Name, :value => val[0][:value]
+                }
+
+resource:       classname LBRACE resourceinstances endsemi RBRACE {
+    @lexer.commentpop
+    array = val[2]
+    if array.instance_of?(AST::ResourceInstance)
+        array = [array]
+    end
+    result = ast AST::ASTArray
+
+    # this iterates across each specified resourceinstance
+    array.each { |instance|
+        unless instance.instance_of?(AST::ResourceInstance)
+            raise Puppet::Dev, "Got something that isn't an instance"
+        end
+        # now, i need to somehow differentiate between those things with
+        # arrays in their names, and normal things
+        result.push ast(AST::Resource,
+            :type => val[0],
+            :title => instance[0],
+            :params => instance[1])
+    }
+}           | classname LBRACE params endcomma RBRACE {
+    # This is a deprecated syntax.
+    error "All resource specifications require names"
+}           | classref LBRACE params endcomma RBRACE {
+    # a defaults setting for a type
+    result = ast(AST::ResourceDefaults, :type => val[0], :params => val[2])
+}
+
+# Override a value set elsewhere in the configuration.
+resourceoverride:     resourceref LBRACE anyparams endcomma RBRACE {
+    @lexer.commentpop
+    result = ast AST::ResourceOverride, :object => val[0], :params => val[2]
+}
+
+# Exported and virtual resources; these don't get sent to the client
+# unless they get collected elsewhere in the db.
+virtualresource:  at resource {
+    type = val[0]
+
+    if (type == :exported and ! Puppet[:storeconfigs]) and ! Puppet[:parseonly]
+        Puppet.warning addcontext("You cannot collect without storeconfigs being set")
+    end
+
+    if val[1].is_a? AST::ResourceDefaults
+        error "Defaults are not virtualizable"
+    end
+
+    method = type.to_s + "="
+
+    # Just mark our resources as exported and pass them through.
+    if val[1].instance_of?(AST::ASTArray)
+        val[1].each do |obj|
+            obj.send(method, true)
+        end
+    else
+        val[1].send(method, true)
+    end
+
+    result = val[1]
+}
+
+at:   AT { result = :virtual }
+    | AT AT { result = :exported }
+
+# A collection statement.  Currently supports no arguments at all, but eventually
+# will, I assume.
+collection:     classref collectrhand LBRACE anyparams endcomma RBRACE {
+    if val[0] =~ /^[a-z]/
+        Puppet.warning addcontext("Collection names must now be capitalized")
+    end
+    type = val[0].downcase
+    args = {:type => type}
+
+    if val[1].is_a?(AST::CollExpr)
+        args[:query] = val[1]
+        args[:query].type = type
+        args[:form] = args[:query].form
+    else
+        args[:form] = val[1]
+    end
+    if args[:form] == :exported and ! Puppet[:storeconfigs] and ! Puppet[:parseonly]
+        Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
+    end
+    args[:override] = val[3]
+    result = ast AST::Collection, args
+}
+                | classref collectrhand {
+    if val[0] =~ /^[a-z]/
+        Puppet.warning addcontext("Collection names must now be capitalized")
+    end
+    type = val[0].downcase
+    args = {:type => type }
+
+    if val[1].is_a?(AST::CollExpr)
+        args[:query] = val[1]
+        args[:query].type = type
+        args[:form] = args[:query].form
+    else
+        args[:form] = val[1]
+    end
+    if args[:form] == :exported and ! Puppet[:storeconfigs] and ! Puppet[:parseonly]
+        Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
+    end
+    result = ast AST::Collection, args
+}
+
+
+collectrhand:     LCOLLECT collstatements RCOLLECT {
+    if val[1]
+        result = val[1]
+        result.form = :virtual
+    else
+        result = :virtual
+    end
+}
+                | LLCOLLECT collstatements RRCOLLECT {
+    if val[1]
+        result = val[1]
+        result.form = :exported
+    else
+        result = :exported
+    end
+}
+
+# A mini-language for handling collection comparisons.  This is organized
+# to avoid the need for precedence indications.
+collstatements:           nil
+                        | collstatement
+                        | collstatements colljoin collstatement {
+    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
+}
+
+collstatement:            collexpr
+                        | LPAREN collstatements RPAREN {
+    result = val[1]
+    result.parens = true
+}
+
+colljoin:                 AND { result=val[0][:value] }
+                        | OR  { result=val[0][:value] }
+
+collexpr:                 colllval ISEQUAL simplervalue {
+    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
+    #result = ast AST::CollExpr
+    #result.push *val
+}
+                        | colllval NOTEQUAL simplervalue {
+    result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
+    #result = ast AST::CollExpr
+    #result.push *val
+}
+
+colllval:                 variable
+                        | name
+
+resourceinst:   resourcename COLON params endcomma {
+    result = ast AST::ResourceInstance, :children => [val[0],val[2]]
+}
+
+resourceinstances:   resourceinst
+                 | resourceinstances SEMIC resourceinst {
+    if val[0].instance_of?(AST::ResourceInstance)
+        result = ast AST::ASTArray, :children => [val[0],val[2]]
+    else
+        val[0].push val[2]
+        result = val[0]
+    end
+}
+
+endsemi:      # nothing
+            | SEMIC
+
+undef:         UNDEF {
+    result = ast AST::Undef, :value => :undef
+}
+
+name:         NAME {
+    result = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+}
+
+type:         CLASSREF {
+    result = ast AST::Type, :value => val[0][:value], :line => val[0][:line]
+}
+
+resourcename:   quotedtext
+            | name
+            | type
+            | selector
+            | variable
+            | array
+
+assignment:     VARIABLE EQUALS expression {
+    if val[0][:value] =~ /::/
+        raise Puppet::ParseError, "Cannot assign to variables in other namespaces"
+    end
+    # this is distinct from referencing a variable
+    variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+    result = ast AST::VarDef, :name => variable, :value => val[2], :line => val[0][:line]
+}
+
+append:     VARIABLE APPENDS expression {
+    variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
+    result = ast AST::VarDef, :name => variable, :value => val[2], :append => true, :line => val[0][:line]
+}
+
+params:   # nothing
+{
+    result = ast AST::ASTArray
+}
+        | param { result = val[0] }
+        | params COMMA param {
+    if val[0].instance_of?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = ast AST::ASTArray, :children => [val[0],val[2]]
+    end
+}
+
+param:        NAME FARROW rvalue {
+    result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2]
+}
+
+addparam:     NAME PARROW rvalue {
+    result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2],
+                                     :add => true
+}
+
+anyparam:     param
+            | addparam
+
+anyparams:   # nothing
+{
+    result = ast AST::ASTArray
+}
+        | anyparam { result = val[0] }
+        | anyparams COMMA anyparam {
+    if val[0].instance_of?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = ast AST::ASTArray, :children => [val[0],val[2]]
+    end
+}
+
+rvalues:      rvalue
+            | rvalues comma rvalue {
+    if val[0].instance_of?(AST::ASTArray)
+        result = val[0].push(val[2])
+    else
+        result = ast AST::ASTArray, :children => [val[0],val[2]]
+    end
+}
+
+simplervalue:       quotedtext
+            | name
+            | type
+            | boolean
+            | selector
+            | variable
+
+rvalue:       quotedtext
+            | name
+            | type
+            | boolean
+            | selector
+            | variable
+            | array
+            | resourceref
+            | funcrvalue
+            | undef
+
+# We currently require arguments in these functions.
+funcrvalue:   NAME LPAREN funcvalues RPAREN {
+    args = aryfy(val[2])
+    result = ast AST::Function,
+        :name => val[0][:value], :line => val[0][:line],
+        :arguments => args,
+        :ftype => :rvalue
+}           | NAME LPAREN RPAREN {
+    result = ast AST::Function,
+        :name => val[0][:value], :line => val[0][:line],
+        :arguments => AST::ASTArray.new({}),
+        :ftype => :rvalue
+}
+
+quotedtext: DQTEXT {
+    result = ast AST::String, :value => val[0][:value], :line => val[0][:line]
+}           | SQTEXT {
+    result = ast AST::FlatString, :value => val[0][:value], :line => val[0][:line]
+}
+
+boolean:    BOOLEAN {
+    result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line]
+}
+
+resourceref: NAME LBRACK rvalues RBRACK {
+    Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
+    result = ast AST::ResourceReference, :type => val[0][:value], :line => val[0][:line], :title => val[2]
+}               | classref LBRACK rvalues RBRACK {
+    result = ast AST::ResourceReference, :type => val[0], :title => val[2]
+}
+
+ifstatement:      IF expression LBRACE statements RBRACE else {
+    @lexer.commentpop
+    args = {
+        :test => val[1],
+        :statements => val[3]
+    }
+
+    if val[5]
+        args[:else] = val[5]
+    end
+
+    result = ast AST::IfStatement, args
+}
+                | IF expression LBRACE RBRACE else {
+    @lexer.commentpop
+    args = {
+        :test => val[1],
+        :statements => ast(AST::Nop)
+    }
+
+    if val[4]
+        args[:else] = val[4]
+    end
+
+    result = ast AST::IfStatement, args
+}
+
+else:             # nothing
+                | ELSE LBRACE statements RBRACE {
+    @lexer.commentpop
+    result = ast AST::Else, :statements => val[2]
+}
+                | ELSE LBRACE RBRACE {
+    @lexer.commentpop
+    result = ast AST::Else, :statements => ast(AST::Nop)
+}
+
+# Unlike yacc/bison, it seems racc
+# gives tons of shift/reduce warnings
+# with the following syntax:
+#
+# expression: ...
+#            | expression arithop expressio { ... }
+#
+# arithop: PLUS | MINUS | DIVIDE | TIMES ...
+#
+# So I had to develop the expression by adding one rule
+# per operator :-(
+
+expression:   rvalue
+            | expression MATCH regex {
+    result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression NOMATCH regex {
+    result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression PLUS expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression MINUS expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression DIV expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression TIMES expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression LSHIFT expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression RSHIFT expression {
+    result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | MINUS expression =UMINUS {
+    result = ast AST::Minus, :value => val[1]
+}
+            | expression NOTEQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression ISEQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression GREATERTHAN expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression GREATEREQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression LESSTHAN expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression LESSEQUAL expression {
+    result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | NOT expression {
+    result = ast AST::Not, :value => val[1]
+}
+            | expression AND expression {
+    result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | expression OR expression {
+    result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
+}
+            | LPAREN expression RPAREN {
+    result = val[1]
+}
+
+casestatement:  CASE rvalue LBRACE caseopts RBRACE {
+    @lexer.commentpop
+    options = val[3]
+    unless options.instance_of?(AST::ASTArray)
+        options = ast AST::ASTArray, :children => [val[3]]
+    end
+    result = ast AST::CaseStatement, :test => val[1], :options => options
+}
+
+caseopts:     caseopt
+            | caseopts caseopt {
+    if val[0].instance_of?(AST::ASTArray)
+        val[0].push val[1]
+        result = val[0]
+    else
+        result = ast AST::ASTArray, :children => [val[0], val[1]]
+    end
+}
+
+caseopt:        casevalues COLON LBRACE statements RBRACE {
+    @lexer.commentpop
+    result = ast AST::CaseOpt, :value => val[0], :statements => val[3]
+}               | casevalues COLON LBRACE RBRACE {
+    @lexer.commentpop
+    result = ast(AST::CaseOpt,
+        :value => val[0],
+        :statements => ast(AST::ASTArray)
+    )
+}
+
+casevalues:       selectlhand
+                | casevalues COMMA selectlhand {
+    if val[0].instance_of?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = ast AST::ASTArray, :children => [val[0],val[2]]
+    end
+}
+
+selector:     selectlhand QMARK svalues {
+    result = ast AST::Selector, :param => val[0], :values => val[2]
+}
+
+svalues:      selectval
+            | LBRACE sintvalues endcomma RBRACE {
+    @lexer.commentpop
+    result = val[1]
+}
+
+sintvalues:   selectval
+            | sintvalues comma selectval {
+    if val[0].instance_of?(AST::ASTArray)
+        val[0].push(val[2])
+        result = val[0]
+    else
+        result = ast AST::ASTArray, :children => [val[0],val[2]]
+    end
+}
+
+selectval:        selectlhand FARROW rvalue {
+    result = ast AST::ResourceParam, :param => val[0], :value => val[2]
+}
+
+selectlhand:  name
+            | type
+            | quotedtext
+            | variable
+            | funcrvalue
+            | boolean
+            | undef
+            | DEFAULT {
+    result = ast AST::Default, :value => val[0][:value], :line => val[0][:line]
+}
+            | regex
+
+# These are only used for importing, and we don't interpolate there.
+qtexts:       quotedtext { result = [val[0].value] }
+            | qtexts COMMA quotedtext {
+    results = val[0] << val[2].value
+}
+
+import: IMPORT qtexts {
+    val[1].each do |file|
+        import(file)
+    end
+
+    result = AST::ASTArray.new(:children => [])
+}
+
+# Disable definition inheritance for now. 8/27/06, luke
+#definition: DEFINE NAME argumentlist parent LBRACE statements RBRACE {
+definition: DEFINE classname argumentlist LBRACE statements RBRACE {
+    @lexer.commentpop
+    newdefine classname(val[1]), :arguments => val[2], :code => val[4], :line => val[0][:line]
+    @lexer.indefine = false
+    result = nil
+
+#}           | DEFINE NAME argumentlist parent LBRACE RBRACE {
+}           | DEFINE classname argumentlist LBRACE RBRACE {
+    @lexer.commentpop
+    newdefine classname(val[1]), :arguments => val[2], :line => val[0][:line]
+    @lexer.indefine = false
+    result = nil
+}
+
+#hostclass: CLASS NAME argumentlist parent LBRACE statements RBRACE {
+hostclass: CLASS classname classparent LBRACE statements RBRACE {
+    @lexer.commentpop
+    # Our class gets defined in the parent namespace, not our own.
+    @lexer.namepop
+    newclass classname(val[1]), :code => val[4], :parent => val[2], :line => val[0][:line]
+    result = nil
+}           | CLASS classname classparent LBRACE RBRACE {
+    @lexer.commentpop
+    # Our class gets defined in the parent namespace, not our own.
+    @lexer.namepop
+    newclass classname(val[1]), :parent => val[2], :line => val[0][:line]
+    result = nil
+}
+
+nodedef: NODE hostnames nodeparent LBRACE statements RBRACE {
+    @lexer.commentpop
+    newnode val[1], :parent => val[2], :code => val[4], :line => val[0][:line]
+    result = nil
+}       |  NODE hostnames nodeparent LBRACE RBRACE {
+    @lexer.commentpop
+    newnode val[1], :parent => val[2], :line => val[0][:line]
+    result = nil
+}
+
+classref:       CLASSREF { result = val[0][:value] }
+
+classname:       NAME { result = val[0][:value] }
+            | CLASSNAME { result = val[0][:value] }
+
+# Multiple hostnames, as used for node names.  These are all literal
+# strings, not AST objects.
+hostnames:    nodename
+  | hostnames COMMA nodename {
+    result = val[0]
+    result = [result] unless result.is_a?(Array)
+    result << val[2]
+}
+
+nodename: hostname {
+    result = ast AST::HostName, :value => val[0]
+}
+
+hostname: NAME { result = val[0][:value] }
+        | SQTEXT { result = val[0][:value] }
+        | DQTEXT { result = val[0][:value] }
+        | DEFAULT { result = val[0][:value] }
+        | regex
+
+nil:    {
+    result = nil
+}
+
+nothing:    {
+    result = ast AST::ASTArray, :children => []
+}
+
+argumentlist: nil
+            | LPAREN nothing RPAREN {
+    result = nil
+}
+            | LPAREN arguments RPAREN {
+    result = val[1]
+    result = [result] unless result[0].is_a?(Array)
+}
+
+arguments:    argument
+            | arguments COMMA argument {
+    result = val[0]
+    result = [result] unless result[0].is_a?(Array)
+    result << val[2]
+}
+
+argument:     NAME EQUALS rvalue {
+    Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
+    result = [val[0][:value], val[2]]
+}
+            | NAME {
+    Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
+    result = [val[0][:value]]
+}           | VARIABLE EQUALS rvalue {
+    result = [val[0][:value], val[2]]
+}           | VARIABLE {
+    result = [val[0][:value]]
+}
+
+nodeparent:       nil
+            | INHERITS hostname {
+    result = val[1]
+}
+
+classparent:       nil
+            | INHERITS classnameordefault {
+    result = val[1]
+}
+
+classnameordefault: classname | DEFAULT
+
+variable:     VARIABLE {
+    result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line]
+}
+
+array:        LBRACK rvalues RBRACK {
+    if val[1].instance_of?(AST::ASTArray)
+        result = val[1]
+    else
+        result = ast AST::ASTArray, :children => [val[1]]
+    end
+}
+            | LBRACK rvalues COMMA RBRACK {
+    if val[1].instance_of?(AST::ASTArray)
+        result = val[1]
+    else
+        result = ast AST::ASTArray, :children => [val[1]]
+    end
+}           | LBRACK RBRACK {
+    result = ast AST::ASTArray
+}
+
+comma:        FARROW
+            | COMMA
+
+endcomma:     # nothing
+            | COMMA { result = nil }
+
+regex:        REGEX {
+    result = ast AST::Regex, :value => val[0][:value]
+}
+
+end
+---- header ----
+require 'puppet'
+require 'puppet/util/loadedfile'
+require 'puppet/parser/lexer'
+require 'puppet/parser/ast'
+#require 'puppet/parser/interpreter'
+
+module Puppet
+    class ParseError < Puppet::Error; end
+    class ImportError < Racc::ParseError; end
+    class AlreadyImportedError < ImportError; end
+end
+
+Puppet[:typecheck] = true
+Puppet[:paramcheck] = true
+
+---- inner ----
+
+# It got too annoying having code in a file that needs to be compiled.
+require 'puppet/parser/parser_support'
+
+# Make emacs happy
+# Local Variables:
+# mode: ruby
+# End:
+
+# $Id$
+