puppet 0.24.9 → 0.25.0

data/lib/puppet/parser/ast.rb

@@ -105,6 +105,7 @@ require 'puppet/parser/ast/function'
 require 'puppet/parser/ast/hostclass'
 require 'puppet/parser/ast/ifstatement'
 require 'puppet/parser/ast/leaf'
+require 'puppet/parser/ast/match_operator'
 require 'puppet/parser/ast/minus'
 require 'puppet/parser/ast/node'
 require 'puppet/parser/ast/nop'

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

@@ -19,7 +19,7 @@ class Puppet::Parser::AST
             # 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 child.instance_of?(AST::ASTArray)
@@ -47,6 +47,10 @@ class Puppet::Parser::AST
 
             return self
         end
+
+        def to_s
+            "[" + @children.collect { |c| c.to_s }.join(', ') + "]"
+        end
     end
 
     # A simple container class, containing the parameters for an object.

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

@@ -16,7 +16,7 @@ class Puppet::Parser::AST
         def evaluate(scope)
             # evaluate the first operand, should return a boolean value
             lval = @lval.safeevaluate(scope)
-            
+
             # return result
             # lazy evaluate right operand
             case @operator
@@ -27,8 +27,8 @@ class Puppet::Parser::AST
                 else # false and false == false
                     false
                 end
-            when "or"; 
-                if Puppet::Parser::Scope.true?(lval) 
+            when "or";
+                if Puppet::Parser::Scope.true?(lval)
                     true
                 else
                     rval = @rval.safeevaluate(scope)

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

@@ -51,6 +51,16 @@ class Puppet::Parser::AST
             end
         end
 
+        def eachopt
+            if @value.is_a?(AST::ASTArray)
+                @value.each { |subval|
+                    yield subval
+                }
+            else
+                yield @value
+            end
+        end
+
         # Evaluate the actual statements; this only gets called if
         # our option matched.
         def evaluate(scope)

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

@@ -17,39 +17,24 @@ class Puppet::Parser::AST
 
             retvalue = nil
             found = false
-            
+
             # Iterate across the options looking for a match.
             default = nil
-            @options.each { |option|
-                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)
-                    break
+            @options.each do |option|
+                option.eachopt do |opt|
+                    return option.safeevaluate(scope) if opt.evaluate_match(value, scope, :file => file, :line => line, :sensitive => sensitive)
                 end
 
-                if option.default?
-                    default = option
-                end
-            }
+                default = option if option.default?
+            end
 
             # Unless we found something, look for the default.
-            unless found
-                if default
-                    retvalue = default.safeevaluate(scope)
-                else
-                    Puppet.debug "No true answers and no default"
-                    retvalue = nil
-                end
-            end
-            return retvalue
+            return default.safeevaluate(scope) if default
+
+            Puppet.debug "No true answers and no default"
+            return nil
+        ensure
+            scope.unset_ephemeral_var
         end
 
         def each

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

@@ -7,6 +7,7 @@ require 'puppet/parser/collector'
 class Puppet::Parser::AST
 class Collection < AST::Branch
     attr_accessor :type, :query, :form
+    attr_reader :override
 
     associates_doc
 
@@ -22,7 +23,37 @@ class Collection < AST::Branch
 
         scope.compiler.add_collection(newcoll)
 
+        # overrides if any
+        # Evaluate all of the specified params.
+        if @override
+            params = @override.collect do |param|
+                param.safeevaluate(scope)
+            end
+
+            newcoll.add_override(
+                :params => params,
+                :file => @file,
+                :line => @line,
+                :source => scope.source,
+                :scope => scope
+            )
+        end
+
         newcoll
     end
+
+    # Handle our parameter ourselves
+    def override=(override)
+        if override.is_a?(AST::ASTArray)
+            @override = override
+        else
+            @override = AST::ASTArray.new(
+                :line => override.line,
+                :file => override.file,
+                :children => [override]
+            )
+        end
+    end
+
 end
 end

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

@@ -28,15 +28,19 @@ class CollExpr < AST::Branch
         # case statements as doing an eval here.
         code = proc do |resource|
             case @oper
-            when "and": code1.call(resource) and code2.call(resource)
-            when "or": code1.call(resource) or code2.call(resource)
-            when "==":
-                if resource[str1].is_a?(Array) && form != :exported
-                    resource[str1].include?(str2)
+            when "and"; code1.call(resource) and code2.call(resource)
+            when "or"; code1.call(resource) or code2.call(resource)
+            when "=="
+                if str1 == "tag"
+                    resource.tagged?(str2)
                 else
-                    resource[str1] == str2
+                    if resource[str1].is_a?(Array)
+                        resource[str1].include?(str2)
+                    else
+                        resource[str1] == str2
+                    end
                 end
-            when "!=": resource[str1] != str2
+            when "!="; resource[str1] != str2
             end
         end
 
@@ -46,20 +50,23 @@ class CollExpr < AST::Branch
         end
 
         case @oper
-        when "and", "or":
+        when "and", "or"
             if form == :exported
                 raise Puppet::ParseError, "Puppet does not currently support collecting exported resources with more than one condition"
             end
             oper = @oper.upcase
-        when "==": oper = "="
+        when "=="; oper = "="
         else
             oper = @oper
         end
 
         if oper == "=" or oper == "!="
             # Add the rails association info where necessary
-            if str1 == "title"
+            case str1
+            when "title"
                 str = "title #{oper} '#{str2}'"
+            when "tag"
+                str = "puppet_tags.name #{oper} '#{str2}'"
             else
                 str = "param_values.value #{oper} '#{str2}' and " +
                     "param_names.name = '#{str1}'"
@@ -67,7 +74,7 @@ class CollExpr < AST::Branch
         else
             str = "(%s) %s (%s)" % [str1, oper, str2]
         end
-        
+
         return str, code
     end
 

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

@@ -21,7 +21,7 @@ class Puppet::Parser::AST
             # convert to number if operands are number
             lval = Puppet::Parser::Scope.number?(lval) || lval
             rval = Puppet::Parser::Scope.number?(rval) || rval
-            
+
             # return result
             unless @operator == '!='
                 lval.send(@operator,rval)

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

@@ -24,9 +24,13 @@ class Puppet::Parser::AST::Definition < Puppet::Parser::AST::Branch
         false
     end
 
+    def get_classname(scope)
+        self.classname
+    end
+
     # Create a resource that knows how to evaluate our actual code.
     def evaluate(scope)
-        resource = Puppet::Parser::Resource.new(:type => self.class.name, :title => self.classname, :scope => scope, :source => scope.source)
+        resource = Puppet::Parser::Resource.new(:type => self.class.name, :title => get_classname(scope), :scope => scope, :source => scope.source)
 
         scope.catalog.tag(*resource.tags)
 
@@ -80,7 +84,7 @@ class Puppet::Parser::AST::Definition < Puppet::Parser::AST::Branch
     end
 
     def find_parentclass
-        @parser.findclass(namespace, parentclass)
+        @parser.find_hostclass(namespace, parentclass)
     end
 
     # Set our parent class, with a little check to avoid some potential

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

@@ -19,12 +19,12 @@ class Puppet::Parser::AST
 
             # Now check that it's been used correctly
             case @ftype
-            when :rvalue:
+            when :rvalue
                 unless Puppet::Parser::Functions.rvalue?(@name)
                     raise Puppet::ParseError, "Function '%s' does not return a value" %
                         @name
                 end
-            when :statement:
+            when :statement
                 if Puppet::Parser::Functions.rvalue?(@name)
                     raise Puppet::ParseError,
                         "Function '%s' must be the value of a statement" %
@@ -51,5 +51,10 @@ class Puppet::Parser::AST
              @fname = Puppet::Parser::Functions.function(@name)
             # Lastly, check the parity
         end
+
+        def to_s
+            args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
+            "#{name}(#{args})"
+        end
     end
 end

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

@@ -18,14 +18,19 @@ class Puppet::Parser::AST
         def evaluate(scope)
             value = @test.safeevaluate(scope)
 
-            if Puppet::Parser::Scope.true?(value)
-                return @statements.safeevaluate(scope)
-            else
-                if defined? @else
-                    return @else.safeevaluate(scope)
+            # let's emulate a new scope for each branches
+            begin
+                if Puppet::Parser::Scope.true?(value)
+                    return @statements.safeevaluate(scope)
                 else
-                    return nil
+                    if defined? @else
+                        return @else.safeevaluate(scope)
+                    else
+                        return nil
+                    end
                 end
+            ensure
+                scope.unset_ephemeral_var
             end
         end
     end

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

@@ -10,8 +10,21 @@ class Puppet::Parser::AST
             return @value
         end
 
+        # evaluate ourselves, and match
+        def evaluate_match(value, scope, options = {})
+            obj = self.safeevaluate(scope)
+            if ! options[:sensitive] && obj.respond_to?(:downcase)
+                obj = obj.downcase
+            end
+            obj == value
+        end
+
+        def match(value)
+            @value == value
+        end
+
         def to_s
-            return @value
+            return @value.to_s unless @value.nil?
         end
     end
 
@@ -29,6 +42,10 @@ class Puppet::Parser::AST
             end
             @value
         end
+
+        def to_s
+            @value ? "true" : "false"
+        end
     end
 
     # The base string class.
@@ -38,6 +55,10 @@ class Puppet::Parser::AST
         def evaluate(scope)
             return scope.strinterp(@value, file, line)
         end
+
+        def to_s
+            "\"#{@value}\""
+        end
     end
 
     # An uninterpreted string.
@@ -45,6 +66,10 @@ class Puppet::Parser::AST
         def evaluate(scope)
             return @value
         end
+
+        def to_s
+            "\"#{@value}\""
+        end
     end
 
     # The 'default' option on case statements and selectors.
@@ -64,16 +89,57 @@ class Puppet::Parser::AST
     # undef values; equiv to nil
     class Undef < AST::Leaf; end
 
-    # Host names, either fully qualified or just the short name
+    # Host names, either fully qualified or just the short name, or even a regex
     class HostName < AST::Leaf
         def initialize(hash)
             super
 
-            unless @value =~ %r{^[0-9a-zA-Z\-]+(\.[0-9a-zA-Z\-]+)*$}
+            @value = @value.to_s.downcase unless @value.is_a?(Regex)
+            if @value =~ /[^-\w.]/
                 raise Puppet::DevError,
                     "'%s' is not a valid hostname" % @value
             end
         end
+
+        def to_classname
+            classname = @value.to_s.downcase
+            classname.gsub!(/[^-a-zA-Z0-9:.]/,'') if regex?
+            classname
+        end
+
+        # implementing eql? and hash so that when an HostName is stored
+        # in a hash it has the same hashing properties as the underlying value
+        def eql?(value)
+            value = value.value if value.is_a?(HostName)
+            return @value.eql?(value)
+        end
+
+        def hash
+            return @value.hash
+        end
+
+        def match(value)
+            return @value.match(value) unless value.is_a?(HostName)
+
+            if value.regex? and self.regex?
+                # Wow this is some sweet design; maybe a touch of refactoring
+                # in order here.
+                return value.value.value == self.value.value
+            elsif value.regex? # we know if the existing name is not a regex, it won't match a regex
+                return false
+            else
+                # else, we could be either a regex or normal and it doesn't matter
+                return @value.match(value.value)
+            end
+        end
+
+        def regex?
+            @value.is_a?(Regex)
+        end
+
+        def to_s
+            @value.to_s
+        end
     end
 
     # A simple variable.  This object is only used during interpolation;
@@ -87,4 +153,41 @@ class Puppet::Parser::AST
             end
         end
     end
+
+    class Regex < AST::Leaf
+        def initialize(hash)
+            super
+            @value = Regexp.new(@value) unless @value.is_a?(Regexp)
+        end
+
+        # we're returning self here to wrap the regexp and to be used in places
+        # where a string would have been used, without modifying any client code.
+        # For instance, in many places we have the following code snippet:
+        #  val = @val.safeevaluate(@scope)
+        #  if val.match(otherval)
+        #      ...
+        #  end
+        # this way, we don't have to modify this test specifically for handling
+        # regexes.
+        def evaluate(scope)
+            return self
+        end
+
+        def evaluate_match(value, scope, options = {})
+            value = value.is_a?(String) ? value : value.to_s
+
+            if matched = @value.match(value)
+                scope.ephemeral_from(matched, options[:file], options[:line])
+            end
+            matched
+        end
+
+        def match(value)
+            @value.match(value)
+        end
+
+        def to_s
+            return "/#{@value.source}/"
+        end
+    end
 end