puppet 3.1.1 → 3.2.0.rc1

data/lib/puppet/parameter/package_options.rb

@@ -3,7 +3,7 @@ require 'puppet/parameter'
 # This specialized {Puppet::Parameter} handles munging of package options.
 # Package options are passed as an array of key value pairs. Special munging is
 # required as the keys and values needs to be quoted in a safe way.
-# 
+#
 class Puppet::Parameter::PackageOptions < Puppet::Parameter
   def unsafe_munge(values)
     values = [values] unless values.is_a? Array

data/lib/puppet/parameter/path.rb

@@ -21,7 +21,7 @@ class Puppet::Parameter::Path < Puppet::Parameter
   # @raise [Puppet::Error] if this property is configured for single paths and an array is given
   # @raise [Puppet::Error] if a path is not an absolute path
   # @return [Array<String>] the given paths
-  # 
+  #
   def validate_path(paths)
     if paths.is_a?(Array) and ! self.class.arrays? then
       fail "#{name} only accepts a single path, not an array of paths"

data/lib/puppet/parameter/value.rb

@@ -7,7 +7,7 @@ require 'puppet/parameter/value_collection'
 #
 class Puppet::Parameter::Value
   attr_reader :name, :options, :event
-  attr_accessor :block, :call, :method, :required_features
+  attr_accessor :block, :call, :method, :required_features, :invalidate_refreshes
 
   # Adds an alias for this value.
   # Makes the given _name_ be an alias for this acceptable value.

data/lib/puppet/parameter/value_collection.rb

@@ -2,7 +2,7 @@ require 'puppet/parameter/value'
 
 # A collection of values and regular expressions, used for specifying allowed values
 # in a given parameter.
-# @note This class is considered part of the internal implementation of {Puppet::Parameter}, and 
+# @note This class is considered part of the internal implementation of {Puppet::Parameter}, and
 #   {Puppet::Property} and the functionality provided by this class should be used via their interfaces.
 # @comment This class probably have several problems when trying to use it with a combination of
 #   regular expressions and aliases as it finds an acceptable value holder vi "name" which may be
@@ -88,7 +88,7 @@ class Puppet::Parameter::ValueCollection
   end
 
   # Munges the value if it is valid, else produces the same value.
-  # @param value [Object] the value to munge 
+  # @param value [Object] the value to munge
   # @return [Object] the munged value, or the given value
   # @todo This method does not seem to do any munging. It just returns the value if it matches the
   #   regexp, or the (most likely Symbolic) allowed value if it matches (which is more of a replacement
@@ -123,6 +123,10 @@ class Puppet::Parameter::ValueCollection
   #   was possible to specify a value of `:before` or `:after` for the purpose of calling
   #   both the block and the provider. Use of these deprecated options will now raise an exception later
   #   in the process when the _is_ value is set (see Puppet::Property#set).
+  # @option options [Symbol] :invalidate_refreshes True if a change on this property should invalidate and
+  #   remove any scheduled refreshes (from notify or subscribe) targeted at the same resource. For example, if
+  #   a change in this property takes into account any changes that a scheduled refresh would have performed,
+  #   then the scheduled refresh would be deleted.
   # @option options [Object] _any_ Any other option is treated as a call to a setter having the given
   #   option name (e.g. `:required_features` calls `required_features=` with the option's value as an
   #   argument).
@@ -187,7 +191,7 @@ class Puppet::Parameter::ValueCollection
   # Returns a valid value matcher (a literal or regular expression)
   # @todo This looks odd, asking for an instance that matches a symbol, or a instance that has
   #   a regexp. What is the intention here? Marking as api private...
-  # 
+  #
   # @return [Puppet::Parameter::Value] a valid valud matcher
   # @api private
   #

data/lib/puppet/parser/ast.rb

@@ -14,7 +14,7 @@ class Puppet::Parser::AST
   include Puppet::Util::MethodHelper
   include Puppet::Util::Docs
 
-  attr_accessor :parent, :scope, :file, :line
+  attr_accessor :parent, :scope, :file, :line, :pos
 
   def inspect
     "( #{self.class} #{self.to_s} #{@children.inspect} )"
@@ -110,8 +110,10 @@ require 'puppet/parser/ast/function'
 require 'puppet/parser/ast/hostclass'
 require 'puppet/parser/ast/ifstatement'
 require 'puppet/parser/ast/in_operator'
+require 'puppet/parser/ast/lambda'
 require 'puppet/parser/ast/leaf'
 require 'puppet/parser/ast/match_operator'
+require 'puppet/parser/ast/method_call'
 require 'puppet/parser/ast/minus'
 require 'puppet/parser/ast/node'
 require 'puppet/parser/ast/nop'

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

@@ -11,29 +11,73 @@ class Puppet::Parser::AST
       [@lval,@rval,@operator].each { |child| yield child }
     end
 
-    # Returns a boolean which is the result of the boolean operation
-    # of lval and rval operands
+    # Produces an object which is the result of the applying the operator to the of lval and rval operands.
+    # * Supports +, -, *, /, %, and <<, >> on numeric strings.
+    # * Supports + on arrays (concatenate), and hashes (merge)
+    # * Supports << on arrays (append)
+    #
     def evaluate(scope)
       # evaluate the operands, should return a boolean value
-      lval = @lval.safeevaluate(scope)
-      lval = Puppet::Parser::Scope.number?(lval)
-      if lval == nil
-        raise ArgumentError, "left operand of #{@operator} is not a number"
+      left = @lval.safeevaluate(scope)
+      right = @rval.safeevaluate(scope)
+
+      if left.is_a?(Array) || right.is_a?(Array)
+        eval_array(left, right)
+      elsif left.is_a?(Hash) || right.is_a?(Hash)
+        eval_hash(left, right)
+      else
+        eval_numeric(left, right)
       end
-      rval = @rval.safeevaluate(scope)
-      rval = Puppet::Parser::Scope.number?(rval)
-      if rval == nil
-        raise ArgumentError, "right operand of #{@operator} is not a number"
+    end
+
+    # Concatenates (+) two arrays, or appends (<<) any object to a newly created array.
+    #
+    def eval_array(left, right)
+      assert_concatenation_supported()
+
+      raise ArgumentError, "operator #{@operator} is not applicable when one of the operands is an Array." unless %w{+ <<}.include?(@operator)
+      raise ArgumentError, "left operand of #{@operator} must be an Array" unless left.is_a?(Array)
+      if @operator == '+'
+        raise ArgumentError, "right operand of #{@operator} must be an Array when left is an Array." unless right.is_a?(Array)
+        return left + right
       end
+      # only append case remains, left asserted to be an array, and right may be any object
+      # wrapping right in an array and adding it ensures a new copy (operator << mutates).
+      #
+      left + [right]
+    end
+
+    # Merges two hashes.
+    #
+    def eval_hash(left, right)
+      assert_concatenation_supported()
+
+      raise ArgumentError, "operator #{@operator} is not applicable when one of the operands is an Hash." unless @operator == '+'
+      raise ArgumentError, "left operand of #{@operator} must be an Hash" unless left.is_a?(Hash)
+      raise ArgumentError, "right operand of #{@operator} must be an Hash" unless right.is_a?(Hash)
+      # merge produces a merged copy
+      left.merge(right)
+    end
+
+    def eval_numeric(left, right)
+      left = Puppet::Parser::Scope.number?(left)
+      right = Puppet::Parser::Scope.number?(right)
+      raise ArgumentError, "left operand of #{@operator} is not a number" unless left != nil
+      raise ArgumentError, "right operand of #{@operator} is not a number" unless right != nil
 
       # compute result
-      lval.send(@operator, rval)
+      left.send(@operator, right)
+    end
+
+    def assert_concatenation_supported
+      return if Puppet[:parser] == 'future'
+      raise ParseError.new("Unsupported Operation: Array concatenation available with '--parser future' setting only.")
     end
 
     def initialize(hash)
       super
 
-      raise ArgumentError, "Invalid arithmetic operator #{@operator}" unless %w{+ - * / << >>}.include?(@operator)
+      raise ArgumentError, "Invalid arithmetic operator #{@operator}" unless %w{+ - * / % << >>}.include?(@operator)
     end
   end
 end

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

@@ -9,7 +9,7 @@ class Puppet::Parser::AST
   class ASTArray < Branch
     include Enumerable
 
-    # Return a child by index.  Probably never used.
+    # Return a child by index. Used (at least) by tests.
     def [](index)
       @children[index]
     end

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

@@ -0,0 +1,41 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class BlockExpression < Branch
+    include Enumerable
+
+    # Evaluate contained expressions, produce result of the last
+    def evaluate(scope)
+      result = nil
+      @children.each do |child|
+        # Skip things that respond to :instantiate (classes, nodes,
+        # and definitions), because they have already been
+        # instantiated.
+        if !child.respond_to?(:instantiate)
+          result = child.safeevaluate(scope)
+        end
+      end
+      result
+    end
+
+    # Return a child by index.
+    def [](index)
+      @children[index]
+    end
+
+    def push(*ary)
+      ary.each { |child|
+        #Puppet.debug "adding %s(%s) of type %s to %s" %
+        #    [child, child.object_id, child.class.to_s.sub(/.+::/,''),
+        #    self.object_id]
+        @children.push(child)
+      }
+
+      self
+    end
+
+    def to_s
+      "[" + @children.collect { |c| c.to_s }.join(', ') + "]"
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ class Puppet::Parser::AST
 
     associates_doc
 
-    attr_accessor :name, :arguments
+    attr_accessor :name, :arguments, :pblock
 
     def evaluate(scope)
       # Make sure it's a defined function
@@ -16,8 +16,16 @@ class Puppet::Parser::AST
       case @ftype
       when :rvalue
         raise Puppet::ParseError, "Function '#{@name}' does not return a value" unless Puppet::Parser::Functions.rvalue?(@name)
+
       when :statement
-        if Puppet::Parser::Functions.rvalue?(@name)
+        # It is harmless to produce an ignored rvalue, the alternative is to mark functions
+        # as appropriate for both rvalue and statements
+        # Keeping the old behavior when a pblock is not present. This since it is not known
+        # if the lambda contains a statement or not (at least not without a costly search).
+        # The purpose of the check is to protect a user for producing a meaningless rvalue where the
+        # operation has no side effects.
+        #
+        if !pblock && Puppet::Parser::Functions.rvalue?(@name)
           raise Puppet::ParseError,
             "Function '#{@name}' must be the value of a statement"
         end
@@ -28,6 +36,9 @@ class Puppet::Parser::AST
       # We don't need to evaluate the name, because it's plaintext
       args = @arguments.safeevaluate(scope).map { |x| x == :undef ? '' : x }
 
+      # append a puppet lambda (unevaluated) if it is defined
+      args << pblock if pblock
+
       scope.send("function_#{@name}", args)
     end
 

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

@@ -0,0 +1,107 @@
+require 'puppet/parser/ast/block_expression'
+
+class Puppet::Parser::AST
+  # A block of statements/expressions with additional parameters
+  # Requires scope to contain the values for the defined parameters when evaluated
+  # If evaluated without a prepared scope, the lambda will behave like its super class.
+  #
+  class Lambda < AST::BlockExpression
+
+    # The lambda parameters.
+    # These are encoded as an array where each entry is an array of one or two object. The first
+    # is the parameter name, and the optional second object is the value expression (that will
+    # be evaluated when bound to a scope).
+    # The value expression is the default value for the parameter. All default values must be
+    # at the end of the parameter list.
+    #
+    # @return [Array<Array<String,String>>] list of parameter names with optional value expression
+    attr_accessor :parameters
+    # Evaluates each expression/statement and produce the last expression evaluation result
+    # @return [Object] what the last expression evaluated to
+    def evaluate(scope)
+      if @children.is_a? Puppet::Parser::AST::ASTArray
+        result = nil
+        @children.each {|expr| result = expr.evaluate(scope) }
+        result
+      else
+        @children.evaluate(scope)
+      end
+    end
+
+    # Calls the lambda.
+    # Assigns argument values in a nested local scope that should be used to evaluate the lambda
+    # and then evaluates the lambda.
+    # @param scope [Puppet::Scope] the calling scope
+    # @return [Object] the result of evaluating the expression(s) in the lambda
+    #
+    def call(scope, *args)
+      raise Puppet::ParseError, "Too many arguments: #{args.size} for #{parameters.size}" unless args.size <= parameters.size
+      merged = parameters.zip(args)
+      missing = merged.select { |e| !e[1] && e[0].size == 1 }
+      unless missing.empty?
+        optional = parameters.count { |p| p.size == 2 }
+        raise Puppet::ParseError, "Too few arguments; #{args.size} for #{optional > 0 ? ' min ' : ''}#{parameters.size - optional}"
+      end
+
+      evaluated = merged.collect do |m|
+        # Ruby 1.8.7 zip seems to produce a different result than Ruby 1.9.3 in some situations
+        n = m[0].is_a?(Array) ? m[0][0] : m[0]
+        v = m[1] || (m[0][1]).safeevaluate(scope) # given value or default expression value
+        [n, v]
+      end
+
+      # Store the evaluated name => value associations in a new inner/local/ephemeral scope
+      # (This is made complicated due to the fact that the implementation of scope is overloaded with
+      # functionality and an inner ephemeral scope must be used (as opposed to just pushing a local scope
+      # on a scope "stack").
+      begin
+        elevel = scope.ephemeral_level
+        scope.ephemeral_from(Hash[evaluated], file, line)
+        result = safeevaluate(scope)
+      ensure
+        scope.unset_ephemeral_var(elevel)
+        result ||= nil
+      end
+      result
+    end
+
+    # Validates the lambda.
+    # Validation checks if parameters with default values are at the end of the list. (It is illegal
+    # to have a parameter with default value followed by one without).
+    #
+    # @raise [Puppet::ParseError] if a parameter with a default comes before a parameter without default value
+    #
+    def validate
+      params = parameters || []
+      defaults = params.drop_while {|p| p.size < 2 }
+      trailing = defaults.drop_while {|p| p.size == 2 }
+      raise Puppet::ParseError, "Lambda parameters with default values must be placed last" unless trailing.empty?
+    end
+
+    # Returns the number of parameters (required and optional)
+    # @return [Integer] the total number of accepted parameters
+    def parameter_count
+      @parameters.size
+    end
+
+    # Returns the number of optional parameters.
+    # @return [Integer] the number of optional accepted parameters
+    def optional_parameter_count
+      @parameters.count {|p| p.size == 2 }
+    end
+
+    def initialize(options)
+      super(options)
+      # ensure there is an empty parameters structure if not given by creator
+      @parameters = [] unless options[:parameters]
+      validate
+    end
+
+    def to_s
+      result = ["{|"]
+      result += @parameters.collect {|p| "#{p[0]}" + (p.size == 2 && p[1]) ? p[1].to_s() : '' }.join(', ')
+      result << "| ... }"
+      result.join('')
+    end
+  end
+end

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

@@ -140,7 +140,7 @@ class Puppet::Parser::AST
 
     def array_index_or_key(object, key)
       if object.is_a?(Array)
-        raise Puppet::ParserError, "#{key} is not an integer, but is used as an index of an array" unless key = Puppet::Parser::Scope.number?(key)
+        raise Puppet::ParseError, "#{key} is not an integer, but is used as an index of an array" unless key = Puppet::Parser::Scope.number?(key)
       end
       key
     end
@@ -148,7 +148,6 @@ class Puppet::Parser::AST
     def evaluate(scope)
       object = evaluate_container(scope)
       accesskey = evaluate_key(scope)
-
       raise Puppet::ParseError, "#{variable} is not an hash or array when accessing it with #{accesskey}" unless object.is_a?(Hash) or object.is_a?(Array)
 
       object[array_index_or_key(object, accesskey)] || :undef

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

@@ -0,0 +1,77 @@
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/methods'
+
+class Puppet::Parser::AST
+  # An AST object to call a method
+  class MethodCall < AST::Branch
+
+    associates_doc
+
+    # An AST that evaluates to the object the method is applied to
+    # @return [Puppet::Parser::AST]
+    attr_accessor :receiver
+
+    # The name of the method
+    # @return [String]
+    attr_accessor :name
+
+    # The arguments to evaluate as arguments to the method.
+    # @return [Array<Puppet::Parser::AST>]
+    attr_accessor :arguments
+
+    # An optional lambda/block that will be yielded to by the called method (if it supports this)
+    # @return [Puppet::Parser::AST::Lambda]
+    attr_accessor :lambda
+
+    # Evaluates the method call and returns what the called method/function returns.
+    # The evaluation evaluates all arguments in the calling scope and then delegates
+    # to a "method" instance produced by Puppet::Parser::Methods for this method call.
+    # @see Puppet::Parser::Methods
+    # @return [Object] what the called method/function returns
+    def evaluate(scope)
+      # Make sure it's a defined method for the receiver
+      r = @receiver.evaluate(scope)
+      raise Puppet::ParseError, "No object to apply method #{@name} to" unless r
+      m = Puppet::Parser::Methods.find_method(scope, r, @name)
+      raise Puppet::ParseError, "Unknown method #{@name} for #{r}" unless m
+
+      # Now check if rvalue is required (in expressions)
+      case @ftype
+      when :rvalue
+        raise Puppet::ParseError, "Method '#{@name}' does not return a value" unless m.is_rvalue?
+      when :statement
+        # When used as a statement, ignore if it produces a rvalue (it is simply not used)
+      else
+        raise Puppet::DevError, "Invalid method type #{@ftype.inspect}"
+      end
+
+      # Evaluate arguments
+      args = @arguments ? @arguments.safeevaluate(scope).map { |x| x == :undef ? '' : x } : []
+
+      # There is no need to evaluate the name, since it is a literal ruby string
+
+      # call the method (it is already bound to the receiver and name)
+      m.invoke(scope, args, @lambda)
+    end
+
+    def initialize(hash)
+      @ftype = hash[:ftype] || :rvalue
+      hash.delete(:ftype) if hash.include? :ftype
+
+      super(hash)
+
+      # Lastly, check the parity
+    end
+
+    # Sets this method call in statement mode where a produced rvalue is ignored.
+    # @return [void]
+    def ignore_rvalue
+      @ftype = :statement
+    end
+
+    def to_s
+      args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
+      "#{@receiver.to_s}.#{name} (#{args})" + (@lambda ? " #{@lambda.to_s}" : '')
+    end
+  end
+end