puppet 2.7.19 → 2.7.20.rc1

data/lib/puppet/parser/files.rb

@@ -82,7 +82,7 @@ module Puppet::Parser::Files
   # 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 == "" or path == File.expand_path(path)
+    path.split(File::SEPARATOR, 2) unless path == "" or Puppet::Util.absolute_path?(path)
   end
 
 end

data/lib/puppet/parser/functions.rb

@@ -6,14 +6,25 @@ require 'monitor'
 # is added to a central module that then gets included into the Scope
 # class.
 module Puppet::Parser::Functions
-
-  (@functions = Hash.new { |h,k| h[k] = {} }).extend(MonitorMixin)
-  (@modules   = {}                          ).extend(MonitorMixin)
+  Environment = Puppet::Node::Environment
 
   class << self
     include Puppet::Util
   end
 
+  # This is used by tests
+  def self.reset
+    @functions = Hash.new { |h,k| h[k] = {} }.extend(MonitorMixin)
+    @modules = Hash.new.extend(MonitorMixin)
+
+    # Runs a newfunction to create a function for each of the log levels
+    Puppet::Util::Log.levels.each do |level|
+      newfunction(level, :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
+        send(level, vals.join(" "))
+      end
+    end
+  end
+
   def self.autoloader
     unless defined?(@autoloader)
       @autoloader = Puppet::Util::Autoload.new(
@@ -26,8 +37,6 @@ module Puppet::Parser::Functions
     @autoloader
   end
 
-  Environment = Puppet::Node::Environment
-
   def self.environment_module(env = nil)
     @modules.synchronize {
       @modules[ env || Environment.current || Environment.root ] ||= Module.new
@@ -36,9 +45,9 @@ module Puppet::Parser::Functions
 
   # Create a new function type.
   def self.newfunction(name, options = {}, &block)
-    name = symbolize(name)
+    name = name.intern
 
-    raise Puppet::DevError, "Function #{name} already defined" if functions.include?(name)
+    raise Puppet::DevError, "Function #{name} already defined" if get_function(name)
 
     ftype = options[:type] || :statement
 
@@ -51,33 +60,50 @@ module Puppet::Parser::Functions
 
     # Someday we'll support specifying an arity, but for now, nope
     #functions[name] = {:arity => arity, :type => ftype}
-    functions[name] = {:type => ftype, :name => fname}
-    functions[name][:doc] = options[:doc] if options[:doc]
+    func = {:type => ftype, :name => fname}
+    func[:doc] = options[:doc] if options[:doc]
+
+    add_function(name, func)
+    func
   end
 
   # Remove a function added by newfunction
   def self.rmfunction(name)
-    name = symbolize(name)
+    Puppet.deprecation_warning "Puppet::Parser::Functions.rmfunction is deprecated and will be removed in 3.0"
+    name = name.intern
 
-    raise Puppet::DevError, "Function #{name} is not defined" unless functions.include? name
+    raise Puppet::DevError, "Function #{name} is not defined" unless get_function(name)
 
-    functions.delete name
+    @functions.synchronize {
+      @functions[Environment.current].delete(name)
+      # This seems wrong because it won't delete a function defined on root if
+      # the current environment is different
+      #@functions[Environment.root].delete(name)
+    }
 
     fname = "function_#{name}"
+    # This also only deletes from the module associated with
+    # Environment.current
     environment_module.send(:remove_method, fname)
   end
 
   # Determine if a given name is a function
   def self.function(name)
-    name = symbolize(name)
+    name = name.intern
 
+    func = nil
     @functions.synchronize do
-      unless functions.include?(name) or functions(Puppet::Node::Environment.root).include?(name)
-        autoloader.load(name,Environment.current || Environment.root)
+      unless func = get_function(name)
+        autoloader.load(name, Environment.current)
+        func = get_function(name)
       end
     end
 
-    ( functions(Environment.root)[name] || functions[name] || {:name => false} )[:name]
+    if func
+      func[:name]
+    else
+      false
+    end
   end
 
   def self.functiondocs
@@ -85,7 +111,7 @@ module Puppet::Parser::Functions
 
     ret = ""
 
-    functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
+    merged_functions.sort { |a,b| a[0].to_s <=> b[0].to_s }.each do |name, hash|
       ret += "#{name}\n#{"-" * name.to_s.length}\n"
       if hash[:doc]
         ret += Puppet::Util::Docs.scrub(hash[:doc])
@@ -100,6 +126,7 @@ module Puppet::Parser::Functions
   end
 
   def self.functions(env = nil)
+    Puppet.deprecation_warning "Puppet::Parser::Functions.functions is deprecated and will be removed in 3.0"
     @functions.synchronize {
       @functions[ env || Environment.current || Environment.root ]
     }
@@ -107,13 +134,32 @@ module Puppet::Parser::Functions
 
   # Determine if a given function returns a value or not.
   def self.rvalue?(name)
-    (functions[symbolize(name)] || {})[:type] == :rvalue
+    func = get_function(name)
+    func ? func[:type] == :rvalue : false
   end
 
-  # Runs a newfunction to create a function for each of the log levels
-  Puppet::Util::Log.levels.each do |level|
-    newfunction(level, :doc => "Log a message on the server at level #{level.to_s}.") do |vals|
-      send(level, vals.join(" "))
+
+  class << self
+    private
+
+    def merged_functions
+      @functions.synchronize {
+        @functions[Environment.root].merge(@functions[Environment.current])
+      }
+    end
+
+    def get_function(name)
+      name = name.intern
+      merged_functions[name]
+    end
+
+    def add_function(name, func)
+      name = name.intern
+      @functions.synchronize {
+        @functions[Environment.current][name] = func
+      }
     end
   end
+
+  reset  # initialize the class instance variables
 end

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

@@ -18,7 +18,7 @@ Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC
 
     A third, optional parameter may be given, also as a hash:
 
-        $defaults => {
+        $defaults = {
           'ensure'   => present,
           'provider' => 'ldap',
         }
@@ -51,8 +51,7 @@ Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC
   # iterate through the resources to create
   defaults = args[2] || {}
   args[1].each do |title, params|
-    params = defaults.merge(params)
-    Puppet::Util.symbolizehash!(params)
+    params = Puppet::Util.symbolizehash(defaults.merge(params))
     raise ArgumentError, 'params should not contain title' if(params[:title])
     case type_of_resource
     # JJM The only difference between a type and a define is the call to instantiate_resource

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

@@ -24,12 +24,7 @@
 # other dealings in this Software without prior written authorization
 # from Thomas Bellman.
 
-module Puppet::Parser::Functions
-
-  Safe = 'a-zA-Z0-9@%_+=:,./-'    # Safe unquoted
-  Dangerous = '!"`$\\'            # Unsafe inside double quotes
-
-  newfunction(:shellquote, :type => :rvalue, :doc => "\
+Puppet::Parser::Functions.newfunction(:shellquote, :type => :rvalue, :doc => "\
     Quote and concatenate arguments for use in Bourne shell.
 
     Each argument is quoted separately, and then all are concatenated
@@ -39,27 +34,28 @@ module Puppet::Parser::Functions
     shellquote instead of having to specify each argument
     individually in the call.
     ") \
-  do |args|
+do |args|
+  safe = 'a-zA-Z0-9@%_+=:,./-'    # Safe unquoted
+  dangerous = '!"`$\\'            # Unsafe inside double quotes
 
-    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
-        end
-        r += '"'
-        result << r
+  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
       end
+      r += '"'
+      result << r
     end
-
-    return result.join(" ")
   end
+
+  return result.join(" ")
 end

data/lib/puppet/parser/lexer.rb

@@ -105,6 +105,11 @@ 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
@@ -240,10 +245,30 @@ 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={})
@@ -333,7 +358,6 @@ class Puppet::Parser::Lexer
 
   # Find the next token that matches a regex.  We look for these first.
   def find_regex_token
-    @regex += 1
     best_token = nil
     best_length = 0
 
@@ -354,7 +378,6 @@ class Puppet::Parser::Lexer
 
   # Find the next token, returning the string and the token.
   def find_token
-    @find += 1
     shift_token || find_regex_token || find_string_token
   end
 
@@ -367,8 +390,6 @@ class Puppet::Parser::Lexer
   end
 
   def initialize
-    @find = 0
-    @regex = 0
     initvars
   end
 
@@ -521,7 +542,7 @@ class Puppet::Parser::Lexer
 
   # we've encountered the start of a string...
   # slurp in the rest of the string and return it
-  def slurpstring(terminators,escapes=%w{ \\  $ ' " n t s }+["\n"],ignore_invalid_escapes=false)
+  def slurpstring(terminators,escapes=%w{ \\  $ ' " r 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}'"
@@ -530,6 +551,7 @@ class Puppet::Parser::Lexer
       ch = $1
       if escapes.include? ch
         case ch
+        when 'r'; "\r"
         when 'n'; "\n"
         when 't'; "\t"
         when 's'; " "
@@ -547,9 +569,15 @@ 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(TOKENS[:VARIABLE].regex)
+    elsif var_name = @scanner.scan(variable_regex)
+      warn_if_variable_has_hyphen(var_name)
       token_queue << [TOKENS[:VARIABLE],var_name]
       tokenize_interpolated_string(DQ_continuation_token_types)
     else
@@ -580,4 +608,10 @@ 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

data/lib/puppet/parser/relationship.rb

@@ -54,7 +54,9 @@ class Puppet::Parser::Relationship
       raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
     end
     Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"
-    source_resource[param_name] ||= []
+    if source_resource[param_name].class != Array
+      source_resource[param_name] = [source_resource[param_name]].compact
+    end
     source_resource[param_name] << target
   end
 end

data/lib/puppet/parser/resource.rb

@@ -6,11 +6,9 @@ require 'puppet/resource'
 class Puppet::Parser::Resource < Puppet::Resource
   require 'puppet/parser/resource/param'
   require 'puppet/util/tagging'
-  require 'puppet/file_collection/lookup'
   require 'puppet/parser/yaml_trimmer'
   require 'puppet/resource/type_collection_helper'
 
-  include Puppet::FileCollection::Lookup
   include Puppet::Resource::TypeCollectionHelper
 
   include Puppet::Util
@@ -22,6 +20,7 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   attr_accessor :source, :scope, :collector_id
   attr_accessor :virtual, :override, :translated, :catalog, :evaluated
+  attr_accessor :file, :line
 
   attr_reader :exported, :parameters
 
@@ -37,7 +36,7 @@ class Puppet::Parser::Resource < Puppet::Resource
   def evaluated?;  !!@evaluated;  end
 
   def [](param)
-    param = symbolize(param)
+    param = param.intern
     if param == :title
       return self.title
     end

data/lib/puppet/parser/resource/param.rb

@@ -1,20 +1,18 @@
-require 'puppet/file_collection/lookup'
 require 'puppet/parser/yaml_trimmer'
 
 # The parameters we stick in Resources.
 class Puppet::Parser::Resource::Param
-  attr_accessor :name, :value, :source, :add
   include Puppet::Util
   include Puppet::Util::Errors
   include Puppet::Util::MethodHelper
-
-  include Puppet::FileCollection::Lookup
   include Puppet::Parser::YamlTrimmer
 
+  attr_accessor :name, :value, :source, :add, :file, :line
+
   def initialize(hash)
     set_options(hash)
     requiredopts(:name, :value)
-    @name = symbolize(@name)
+    @name = @name.intern
   end
 
   def line_to_i

data/lib/puppet/parser/scope.rb

@@ -458,10 +458,13 @@ class Puppet::Parser::Scope
     method.to_s =~ /^function_(.*)$/
     super unless $1
     super unless Puppet::Parser::Functions.function($1)
-
-    # Calling .function(name) adds "function_#{name}" as a callable method on
-    # self if it's found, so now we can just send it
-    send(method, *args)
+    # In odd circumstances, this might not end up defined by the previous
+    # method, so we might as well be certain.
+    if respond_to? method
+      send(method, *args)
+    else
+      raise Puppet::DevError, "Function #{$1} not defined despite being loaded!"
+    end
   end
 
   def resolve_type_and_titles(type, titles)

data/lib/puppet/property.rb

@@ -68,9 +68,11 @@ class Puppet::Property < Puppet::Parameter
 
   # Call the provider method.
   def call_provider(value)
-      provider.send(self.class.name.to_s + "=", value)
-  rescue NoMethodError
-      self.fail "The #{provider.class.name} provider can not handle attribute #{self.class.name}"
+      method = self.class.name.to_s + "="
+      unless provider.respond_to? method
+        self.fail "The #{provider.class.name} provider can not handle attribute #{self.class.name}"
+      end
+      provider.send(method, value)
   end
 
   # Call the dynamically-created method associated with our value, if