puppet 2.7.26 → 3.0.0.rc4

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

@@ -7,7 +7,7 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc =>
 
       $random_number = fqdn_rand(30)
       $random_number_seed = fqdn_rand(30,30)") do |args|
-    max = args.shift
-    srand(Digest::MD5.hexdigest([lookupvar('::fqdn'),args].join(':')).hex)
+    max = args.shift.to_i
+    srand(Digest::MD5.hexdigest([self['::fqdn'],args].join(':')).hex)
     rand(max).to_s
 end

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

@@ -14,9 +14,9 @@ Puppet::Parser::Functions::newfunction(:generate, :type => :rvalue,
       raise Puppet::ParseError, "Generators must be fully qualified" unless Puppet::Util.absolute_path?(args[0])
 
       if Puppet.features.microsoft_windows?
-        valid = args[0] =~ /^[a-z]:(?:[\/\\][\w.-]+)+$/i
+        valid = args[0] =~ /^[a-z]:(?:[\/\\][-.~\w]+)+$/i
       else
-        valid = args[0] =~ /^[-\/\w.]+$/
+        valid = args[0] =~ /^[-\/\w.+]+$/
       end
 
       unless valid
@@ -30,7 +30,7 @@ Puppet::Parser::Functions::newfunction(:generate, :type => :rvalue,
       end
 
       begin
-        Dir.chdir(File.dirname(args[0])) { Puppet::Util.execute(args) }
+        Dir.chdir(File.dirname(args[0])) { Puppet::Util::Execution.execute(args) }
       rescue Puppet::ExecutionFailure => detail
         raise Puppet::ParseError, "Failed to execute generator #{args[0]}: #{detail}"
       end

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

@@ -1,6 +1,11 @@
 # Include the specified classes
 Puppet::Parser::Functions::newfunction(:include, :doc => "Evaluate one or more classes.") do |vals|
-    vals = [vals] unless vals.is_a?(Array)
+    if vals.is_a?(Array)
+      # Protect against array inside array
+      vals = vals.flatten
+    else
+      vals = [vals]
+    end
 
     # The 'false' disables lazy evaluation.
     klasses = compiler.evaluate_classes(vals, self, false)

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

@@ -2,7 +2,6 @@
 
   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
@@ -32,26 +31,22 @@ fail if used with earlier clients.
   method = Puppet::Parser::Functions.function(:include)
 
   send(method, vals)
-  if resource.metaparam_compatibility_mode?
-    warning "The 'require' function is only compatible with clients at 0.25 and above; including class but not adding dependency"
-  else
-    vals = [vals] unless vals.is_a?(Array)
-
-    vals.each do |klass|
-      # lookup the class in the scopes
-      if classobj = find_hostclass(klass)
-        klass = classobj.name
-      else
-        raise Puppet::ParseError, "Could not find class #{klass}"
-      end
-
-      # This is a bit hackish, in some ways, but it's the only way
-      # to configure a dependency that will make it to the client.
-      # The 'obvious' way is just to add an edge in the catalog,
-      # but that is considered a containment edge, not a dependency
-      # edge, so it usually gets lost on the client.
-      ref = Puppet::Resource.new(:class, klass)
-      resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
+  vals = [vals] unless vals.is_a?(Array)
+
+  vals.each do |klass|
+    # lookup the class in the scopes
+    if classobj = find_hostclass(klass)
+      klass = classobj.name
+    else
+      raise Puppet::ParseError, "Could not find class #{klass}"
     end
+
+    # This is a bit hackish, in some ways, but it's the only way
+    # to configure a dependency that will make it to the client.
+    # The 'obvious' way is just to add an edge in the catalog,
+    # but that is considered a containment edge, not a dependency
+    # edge, so it usually gets lost on the client.
+    ref = Puppet::Resource.new(:class, klass)
+    resource.set_parameter(:require, [resource[:require]].flatten.compact << ref)
   end
 end

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

@@ -24,7 +24,12 @@
 # other dealings in this Software without prior written authorization
 # from Thomas Bellman.
 
-Puppet::Parser::Functions.newfunction(:shellquote, :type => :rvalue, :doc => "\
+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
@@ -34,28 +39,31 @@ Puppet::Parser::Functions.newfunction(:shellquote, :type => :rvalue, :doc => "\
     shellquote instead of having to specify each argument
     individually in the call.
     ") \
-do |args|
-  safe = 'a-zA-Z0-9@%_+=:,./-'    # Safe unquoted
-  dangerous = '!"`$\\'            # Unsafe inside double quotes
+  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|
-        r += "\\" if dangerous.include?(c)
-        r += c.chr
+    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 = '"'
+        # We want each byte, because that is how sh will process it in enough
+        # cases; Ruby 1.8.5 ends up making this the way that gets expressed,
+        # because it requires a block to the `each_byte` method.
+        word.each_byte do |c|
+          c = c.chr
+          r += "\\" if Dangerous.include?(c)
+          r += c
+        end
+        r += '"'
+        result << r
       end
-      r += '"'
-      result << r
     end
-  end
 
-  return result.join(" ")
+    return result.join(" ")
+  end
 end

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

@@ -1,10 +1,7 @@
 require 'puppet/util/package'
 
-
-      Puppet::Parser::Functions::newfunction(
-        :versioncmp, :type => :rvalue,
-
-  :doc => "Compares two version numbers.
+Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue, :doc =>
+"Compares two version numbers.
 
 Prototype:
 

data/lib/puppet/parser/grammar.ra

@@ -12,7 +12,7 @@ token IF ELSE IMPORT DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
 token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSREF
 token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
 token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
-token IN
+token IN UNLESS
 
 prechigh
   right NOT
@@ -60,6 +60,7 @@ statement_or_declaration:    resource
   | assignment
   | casestatement
   | ifstatement_begin
+  | unlessstatement
   | import
   | fstatement
   | definition
@@ -69,6 +70,22 @@ statement_or_declaration:    resource
   | append
   | relationship
 
+keyword: AND
+ | CASE
+ | CLASS
+ | DEFAULT
+ | DEFINE
+ | ELSE
+ | ELSIF
+ | IF
+ | IN
+ | IMPORT
+ | INHERITS
+ | NODE
+ | OR
+ | UNDEF
+ | UNLESS
+
 relationship: relationship_side edge relationship_side {
   result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
 }
@@ -321,7 +338,11 @@ params:   # nothing
     result = val[0]
 }
 
-param:        NAME FARROW expression {
+param_name: NAME 
+  | keyword 
+  | BOOLEAN
+
+param:        param_name FARROW expression {
   result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2]
 }
 
@@ -375,6 +396,24 @@ resourceref: NAME LBRACK expressions RBRACK {
   result = ast AST::ResourceReference, :type => val[0].value, :title => val[2]
 }
 
+unlessstatement: UNLESS expression LBRACE statements RBRACE {
+  @lexer.commentpop
+  args = {
+    :test => ast(AST::Not, :value => val[1]),
+    :statements => val[3]
+  }
+
+  result = ast AST::IfStatement, args
+}
+  | UNLESS expression LBRACE RBRACE {
+    @lexer.commentpop
+    args = {
+      :test => ast(AST::Not, :value => val[1]), 
+      :statements => ast(AST::Nop)
+    }
+    result = ast AST::IfStatement, args
+}
+
 ifstatement_begin: IF ifstatement {
   result = val[1]
 }
@@ -661,18 +700,9 @@ arguments:    argument
     result << val[2]
 }
 
-argument:     NAME EQUALS expression {
-  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 expression {
-  result = [val[0][:value], val[2]]
-}           | VARIABLE {
-  result = [val[0][:value]]
-}
+argument:
+ VARIABLE EQUALS expression { result = [val[0][:value], val[2]] }
+| VARIABLE { result = [val[0][:value]] }
 
 nodeparent:       nil
   | INHERITS hostname {

data/lib/puppet/parser/lexer.rb

@@ -1,7 +1,9 @@
 # the scanner/lexer
 
+require 'forwardable'
 require 'strscan'
 require 'puppet'
+require 'puppet/util/methodhelper'
 
 
 module Puppet
@@ -11,39 +13,37 @@ end
 module Puppet::Parser; end
 
 class Puppet::Parser::Lexer
+  extend Forwardable
+
   attr_reader :last, :file, :lexing_context, :token_queue
 
   attr_accessor :line, :indefine
+  alias :indefine? :indefine
 
   def lex_error msg
     raise Puppet::LexError.new(msg)
   end
 
   class Token
+    include Puppet::Util::MethodHelper
+
     attr_accessor :regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate
+    alias skip? skip
+    alias accumulate? accumulate
 
-    def initialize(regex, name)
-      if regex.is_a?(String)
-        @name, @string = name, regex
-        @regex = Regexp.new(Regexp.escape(@string))
+    def initialize(string_or_regex, name, options = {})
+      if string_or_regex.is_a?(String)
+        @name, @string = name, string_or_regex
+        @regex = Regexp.new(Regexp.escape(string_or_regex))
       else
-        @name, @regex = name, regex
+        @name, @regex = name, string_or_regex
       end
-    end
 
-    # MQR: Why not just alias?
-    %w{skip accumulate}.each do |method|
-      define_method(method+"?") do
-        self.send(method)
-      end
+      set_options(options)
     end
 
     def to_s
-      if self.string
-        @string
-      else
-        @name.to_s
-      end
+      string or @name.to_s
     end
 
     def acceptable?(context={})
@@ -54,16 +54,15 @@ class Puppet::Parser::Lexer
 
   # Maintain a list of tokens.
   class TokenList
-    attr_reader :regex_tokens, :string_tokens
+    extend Forwardable
 
-    def [](name)
-      @tokens[name]
-    end
+    attr_reader :regex_tokens, :string_tokens
+    def_delegator :@tokens, :[]
 
     # Create a new token.
     def add_token(name, regex, options = {}, &block)
-      token = Token.new(regex, name)
       raise(ArgumentError, "Token #{name} already exists") if @tokens.include?(name)
+      token = Token.new(regex, name, options)
       @tokens[token.name] = token
       if token.string
         @string_tokens << token
@@ -72,10 +71,6 @@ class Puppet::Parser::Lexer
         @regex_tokens << token
       end
 
-      options.each do |name, option|
-        token.send(name.to_s + "=", option)
-      end
-
       token.meta_def(:convert, &block) if block_given?
 
       token
@@ -105,65 +100,57 @@ class Puppet::Parser::Lexer
     def sort_tokens
       @string_tokens.sort! { |a, b| b.string.length <=> a.string.length }
     end
-
-    # Yield each token name and value in turn.
-    def each
-      @tokens.each {|name, value| yield name, value }
-    end
   end
 
   TOKENS = TokenList.new
-
-    TOKENS.add_tokens(
-
-      '[' => :LBRACK,
-      ']' => :RBRACK,
-      '{' => :LBRACE,
-      '}' => :RBRACE,
-      '(' => :LPAREN,
-
-      ')' => :RPAREN,
-      '=' => :EQUALS,
-      '+=' => :APPENDS,
-      '==' => :ISEQUAL,
-      '>=' => :GREATEREQUAL,
-      '>' => :GREATERTHAN,
-      '<' => :LESSTHAN,
-      '<=' => :LESSEQUAL,
-      '!=' => :NOTEQUAL,
-      '!' => :NOT,
-      ',' => :COMMA,
-      '.' => :DOT,
-      ':' => :COLON,
-      '@' => :AT,
-      '<<|' => :LLCOLLECT,
-      '->' => :IN_EDGE,
-      '<-' => :OUT_EDGE,
-      '~>' => :IN_EDGE_SUB,
-      '<~' => :OUT_EDGE_SUB,
-      '|>>' => :RRCOLLECT,
-      '<|' => :LCOLLECT,
-      '|>' => :RCOLLECT,
-      ';' => :SEMIC,
-      '?' => :QMARK,
-      '\\' => :BACKSLASH,
-      '=>' => :FARROW,
-      '+>' => :PARROW,
-      '+' => :PLUS,
-      '-' => :MINUS,
-      '/' => :DIV,
-      '*' => :TIMES,
-      '<<' => :LSHIFT,
-      '>>' => :RSHIFT,
-      '=~' => :MATCH,
-      '!~' => :NOMATCH,
-      %r{((::){0,1}[A-Z][-\w]*)+} => :CLASSREF,
-      "<string>" => :STRING,
-      "<dqstring up to first interpolation>" => :DQPRE,
-      "<dqstring between two interpolations>" => :DQMID,
-      "<dqstring after final interpolation>" => :DQPOST,
-      "<boolean>" => :BOOLEAN
-      )
+  TOKENS.add_tokens(
+    '['   => :LBRACK,
+    ']'   => :RBRACK,
+    '{'   => :LBRACE,
+    '}'   => :RBRACE,
+    '('   => :LPAREN,
+    ')'   => :RPAREN,
+    '='   => :EQUALS,
+    '+='  => :APPENDS,
+    '=='  => :ISEQUAL,
+    '>='  => :GREATEREQUAL,
+    '>'   => :GREATERTHAN,
+    '<'   => :LESSTHAN,
+    '<='  => :LESSEQUAL,
+    '!='  => :NOTEQUAL,
+    '!'   => :NOT,
+    ','   => :COMMA,
+    '.'   => :DOT,
+    ':'   => :COLON,
+    '@'   => :AT,
+    '<<|' => :LLCOLLECT,
+    '|>>' => :RRCOLLECT,
+    '->'  => :IN_EDGE,
+    '<-'  => :OUT_EDGE,
+    '~>'  => :IN_EDGE_SUB,
+    '<~'  => :OUT_EDGE_SUB,
+    '<|'  => :LCOLLECT,
+    '|>'  => :RCOLLECT,
+    ';'   => :SEMIC,
+    '?'   => :QMARK,
+    '\\'  => :BACKSLASH,
+    '=>'  => :FARROW,
+    '+>'  => :PARROW,
+    '+'   => :PLUS,
+    '-'   => :MINUS,
+    '/'   => :DIV,
+    '*'   => :TIMES,
+    '<<'  => :LSHIFT,
+    '>>'  => :RSHIFT,
+    '=~'  => :MATCH,
+    '!~'  => :NOMATCH,
+    %r{((::){0,1}[A-Z][-\w]*)+} => :CLASSREF,
+    "<string>" => :STRING,
+    "<dqstring up to first interpolation>" => :DQPRE,
+    "<dqstring between two interpolations>" => :DQMID,
+    "<dqstring after final interpolation>" => :DQPOST,
+    "<boolean>" => :BOOLEAN
+  )
 
   # Numbers are treated separately from names, so that they may contain dots.
   TOKENS.add_token :NUMBER, %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b} do |lexer, value|
@@ -245,30 +232,10 @@ class Puppet::Parser::Lexer
   end
   #:startdoc:
 
-  TOKENS.add_token :DOLLAR_VAR_WITH_DASH, %r{\$(?:::)?(?:[-\w]+::)*[-\w]+} do |lexer, value|
-    lexer.warn_if_variable_has_hyphen(value)
-
-    [TOKENS[:VARIABLE], value[1..-1]]
-  end
-  def (TOKENS[:DOLLAR_VAR_WITH_DASH]).acceptable?(context = {})
-    Puppet[:allow_variables_with_dashes]
-  end
-
   TOKENS.add_token :DOLLAR_VAR, %r{\$(::)?(\w+::)*\w+} do |lexer, value|
     [TOKENS[:VARIABLE],value[1..-1]]
   end
 
-  TOKENS.add_token :VARIABLE_WITH_DASH, %r{(?:::)?(?:[-\w]+::)*[-\w]+} do |lexer, value|
-    lexer.warn_if_variable_has_hyphen(value)
-
-    [TOKENS[:VARIABLE], value]
-  end
-  #:stopdoc: # Issue #4161
-  def (TOKENS[:VARIABLE_WITH_DASH]).acceptable?(context={})
-    Puppet[:allow_variables_with_dashes] and TOKENS[:VARIABLE].acceptable?(context)
-  end
-  #:startdoc:
-
   TOKENS.add_token :VARIABLE, %r{(::)?(\w+::)*\w+}
   #:stopdoc: # Issue #4161
   def (TOKENS[:VARIABLE]).acceptable?(context={})
@@ -280,35 +247,32 @@ class Puppet::Parser::Lexer
   TOKENS.sort_tokens
 
   @@pairs = {
-    "{" => "}",
-    "(" => ")",
-    "[" => "]",
-    "<|" => "|>",
+    "{"   => "}",
+    "("   => ")",
+    "["   => "]",
+    "<|"  => "|>",
     "<<|" => "|>>"
   }
 
   KEYWORDS = TokenList.new
-
-
-    KEYWORDS.add_tokens(
-
-      "case" => :CASE,
-      "class" => :CLASS,
-      "default" => :DEFAULT,
-      "define" => :DEFINE,
-      "import" => :IMPORT,
-      "if" => :IF,
-      "elsif" => :ELSIF,
-      "else" => :ELSE,
-      "inherits" => :INHERITS,
-      "node" => :NODE,
-      "and"  => :AND,
-      "or"   => :OR,
-      "undef"   => :UNDEF,
-      "false" => :FALSE,
-      "true" => :TRUE,
-
-      "in" => :IN
+  KEYWORDS.add_tokens(
+    "case"     => :CASE,
+    "class"    => :CLASS,
+    "default"  => :DEFAULT,
+    "define"   => :DEFINE,
+    "import"   => :IMPORT,
+    "if"       => :IF,
+    "elsif"    => :ELSIF,
+    "else"     => :ELSE,
+    "inherits" => :INHERITS,
+    "node"     => :NODE,
+    "and"      => :AND,
+    "or"       => :OR,
+    "undef"    => :UNDEF,
+    "false"    => :FALSE,
+    "true"     => :TRUE,
+    "in"       => :IN,
+    "unless"   => :UNLESS
   )
 
   def clear
@@ -341,9 +305,7 @@ class Puppet::Parser::Lexer
     @scanner = StringScanner.new(contents)
   end
 
-  def shift_token
-    @token_queue.shift
-  end
+  def_delegator :@token_queue, :shift, :shift_token
 
   def find_string_token
     # We know our longest string token is three chars, so try each size in turn
@@ -381,14 +343,6 @@ class Puppet::Parser::Lexer
     shift_token || find_regex_token || find_string_token
   end
 
-  def indefine?
-    if defined?(@indefine)
-      @indefine
-    else
-      false
-    end
-  end
-
   def initialize
     initvars
   end
@@ -437,26 +391,19 @@ class Puppet::Parser::Lexer
     return token, { :value => value, :line => @line }
   end
 
-  # Go up one in the namespace.
-  def namepop
-    @namestack.pop
-  end
+  # Handling the namespace stack
+  def_delegator :@namestack, :pop, :namepop
+  # This value might have :: in it, but we don't care -- it'll be handled
+  # normally when joining, and when popping we want to pop this full value,
+  # however long the namespace is.
+  def_delegator :@namestack, :<<, :namestack
 
   # Collect the current namespace.
   def namespace
     @namestack.join("::")
   end
 
-  # This value might have :: in it, but we don't care -- it'll be
-  # handled normally when joining, and when popping we want to pop
-  # this full value, however long the namespace is.
-  def namestack(value)
-    @namestack << value
-  end
-
-  def rest
-    @scanner.rest
-  end
+  def_delegator :@scanner, :rest
 
   # this is the heart of the lexer
   def scan
@@ -536,13 +483,11 @@ class Puppet::Parser::Lexer
 
   # Provide some limited access to the scanner, for those
   # tokens that need it.
-  def scan_until(regex)
-    @scanner.scan_until(regex)
-  end
+  def_delegator :@scanner, :scan_until
 
   # we've encountered the start of a string...
   # slurp in the rest of the string and return it
-  def slurpstring(terminators,escapes=%w{ \\  $ ' " r n t s }+["\n"],ignore_invalid_escapes=false)
+  def slurpstring(terminators,escapes=%w{ \\  $ ' " n t s }+["\n"],ignore_invalid_escapes=false)
     # we search for the next quote that isn't preceded by a
     # backslash; the caret is there to match empty strings
     str = @scanner.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]/) or lex_error "Unclosed quote after '#{last}' in '#{rest}'"
@@ -551,7 +496,6 @@ class Puppet::Parser::Lexer
       ch = $1
       if escapes.include? ch
         case ch
-        when 'r'; "\r"
         when 'n'; "\n"
         when 't'; "\t"
         when 's'; " "
@@ -569,15 +513,9 @@ class Puppet::Parser::Lexer
   def tokenize_interpolated_string(token_type,preamble='')
     value,terminator = slurpstring('"$')
     token_queue << [TOKENS[token_type[terminator]],preamble+value]
-    variable_regex = if Puppet[:allow_variables_with_dashes]
-                       TOKENS[:VARIABLE_WITH_DASH].regex
-                     else
-                       TOKENS[:VARIABLE].regex
-                     end
     if terminator != '$' or @scanner.scan(/\{/)
       token_queue.shift
-    elsif var_name = @scanner.scan(variable_regex)
-      warn_if_variable_has_hyphen(var_name)
+    elsif var_name = @scanner.scan(TOKENS[:VARIABLE].regex)
       token_queue << [TOKENS[:VARIABLE],var_name]
       tokenize_interpolated_string(DQ_continuation_token_types)
     else
@@ -608,10 +546,4 @@ class Puppet::Parser::Lexer
   def commentpush
     @commentstack.push(['', @line])
   end
-
-  def warn_if_variable_has_hyphen(var_name)
-    if var_name.include?('-')
-      Puppet.deprecation_warning("Using `-` in variable names is deprecated at #{file || '<string>'}:#{line}. See http://links.puppetlabs.com/puppet-hyphenated-variable-deprecation")
-    end
-  end
 end