bolt 0.10.0 → 0.11.0

data/vendored/puppet/lib/puppet/gettext/module_translations.rb

@@ -0,0 +1,42 @@
+require 'puppet/gettext/config'
+
+module Puppet::ModuleTranslations
+
+  # @api private
+  # Loads translation files for each of the specified modules,
+  # if present. Requires the modules to have `forge_name` specified.
+  # @param [[Module]] modules a list of modules for which to
+  #        load translations
+  def self.load_from_modulepath(modules)
+    modules.each do |mod|
+      next unless mod.forge_name && mod.has_translations?(Puppet::GettextConfig.current_locale)
+
+      module_name = mod.forge_name.gsub('/', '-')
+      if Puppet::GettextConfig.load_translations(module_name, mod.locale_directory, :po)
+        Puppet.debug "Loaded translations for #{module_name}."
+      elsif Puppet::GettextConfig.gettext_loaded?
+        Puppet.debug "Could not find translation files for #{module_name} at #{mod.locale_directory}. Skipping translation initialization."
+      else
+        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
+      end
+    end
+  end
+
+  # @api private
+  # Loads translation files that have been pluginsync'd for modules
+  # from the $vardir.
+  # @param [String] vardir the path to Puppet's vardir
+  def self.load_from_vardir(vardir)
+    locale = Puppet::GettextConfig.current_locale
+    Dir.glob("#{vardir}/locales/#{locale}/*.po") do |f|
+      module_name = File.basename(f, ".po")
+      if Puppet::GettextConfig.load_translations(module_name, File.join(vardir, "locales"), :po)
+        Puppet.debug "Loaded translations for #{module_name}."
+      elsif Puppet::GettextConfig.gettext_loaded?
+        Puppet.debug "Could not load translations for #{module_name}."
+      else
+        Puppet.warn_once("gettext_unavailable", "gettext_unavailable", "No gettext library found, skipping translation initialization.")
+      end
+    end
+  end
+end

data/vendored/puppet/lib/puppet/indirector/catalog/compiler.rb

@@ -49,6 +49,8 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     node = node_from_request(facts, request)
     node.trusted_data = Puppet.lookup(:trusted_information) { Puppet::Context::TrustedInformation.local(node) }.to_h
 
+    node.environment.use_text_domain if node.environment
+
     if catalog = compile(node, request.options)
       return catalog
     else

data/vendored/puppet/lib/puppet/module.rb

@@ -97,9 +97,6 @@ class Puppet::Module
     load_metadata
 
     @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
-
-    # i18n initialization for modules
-    initialize_i18n unless Puppet[:disable_i18n]
   end
 
   # @deprecated The puppetversion module metadata field is no longer used.
@@ -308,6 +305,16 @@ class Puppet::Module
     subpath("locales")
   end
 
+  # Returns true if the module has translation files for the
+  # given locale.
+  # @param [String] locale the two-letter language code to check
+  #        for translations
+  # @return true if the module has a directory for the locale, false
+  #         false otherwise
+  def has_translations?(locale)
+    return Puppet::FileSystem.exist?(File.join(locale_directory, locale))
+  end
+
   def has_external_facts?
     File.directory?(plugin_fact_directory)
   end
@@ -428,21 +435,6 @@ class Puppet::Module
     @strict_semver
   end
 
-  def initialize_i18n
-    # this name takes the form "namespace-module", and should match the name of
-    # the PO file containing the translations.
-    module_name = @forge_name ? @forge_name.gsub("/", "-") : name
-    return if Puppet::GettextConfig.translations_loaded?(module_name)
-
-    if Puppet::GettextConfig.load_translations(module_name, locale_directory, :po)
-      Puppet.debug "i18n initialized for #{module_name}"
-    elsif Puppet::GettextConfig.gettext_loaded?
-      Puppet.debug "Could not find translation files for #{module_name} at #{locale_directory}. Skipping i18n initialization."
-    else
-      Puppet.debug "No gettext library found, skipping i18n initialization."
-    end
-  end
-
   private
 
   def wanted_manifests_from(pattern)

data/vendored/puppet/lib/puppet/network/http/factory.rb

@@ -38,6 +38,15 @@ class Puppet::Network::HTTP::Factory
     http.read_timeout = Puppet[:http_read_timeout]
     http.open_timeout = Puppet[:http_connect_timeout]
 
+    if Puppet[:sourceaddress]
+      if http.respond_to?(:local_host)
+        Puppet.debug("Using source IP #{Puppet[:sourceaddress]}")
+        http.local_host = Puppet[:sourceaddress]
+      else
+        raise ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP."
+      end
+    end
+
     if Puppet[:http_debug]
       http.set_debug_output($stderr)
     end

data/vendored/puppet/lib/puppet/node/environment.rb

@@ -433,6 +433,20 @@ class Puppet::Node::Environment
     deps
   end
 
+  # Loads module translations for the current environment once for
+  # the lifetime of the environment.
+  def use_text_domain
+    return if Puppet[:disable_i18n]
+
+    if @text_domain.nil?
+      @text_domain = @name
+      Puppet::GettextConfig.reset_text_domain(@text_domain)
+      Puppet::ModuleTranslations.load_from_modulepath(modules)
+    else
+      Puppet::GettextConfig.use_text_domain(@text_domain)
+    end
+  end
+
   # Checks if a reparse is required (cache of files is stale).
   #
   def check_for_reparse

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

@@ -29,8 +29,22 @@ Puppet::Parser::Functions::newfunction(
   :arity => -2,
   :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."
+  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|
-  fmt = args.shift
-  return sprintf(fmt, *args)
+  fmt = args[0]
+  args = args[1..-1]
+  begin
+    return sprintf(fmt, *args)
+  rescue KeyError => e
+    if args.size == 1 && args[0].is_a?(Hash)
+      # map the single hash argument such that all top level string keys are symbols
+      # as that allows named arguments to be used in the format string.
+      #
+      result = {}
+      args[0].each_pair { |k,v| result[k.is_a?(String) ? k.to_sym : k] = v }
+      return sprintf(fmt, result)
+    end
+    raise e
+  end
 end

data/vendored/puppet/lib/puppet/parser/scope.rb

@@ -611,6 +611,7 @@ class Puppet::Parser::Scope
       begin
         qs = qualified_scope(class_name)
         unless qs.nil?
+          return qs.get_local_variable(leaf_name) if qs.has_local_variable?(leaf_name)
           iscope = qs.inherited_scope
           return lookup_qualified_variable("#{iscope.source.name}::#{leaf_name}", options) unless iscope.nil?
         end
@@ -623,6 +624,16 @@ class Puppet::Parser::Scope
     return handle_not_found('', fqn, options)
   end
 
+  # @api private
+  def has_local_variable?(name)
+    @ephemeral.last.include?(name)
+  end
+
+  # @api private
+  def get_local_variable(name)
+    @ephemeral.last[name]
+  end
+
   def handle_not_found(class_name, variable_name, position, reason = nil)
     unless Puppet[:strict_variables]
       # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found

data/vendored/puppet/lib/puppet/pops.rb

@@ -113,7 +113,6 @@ module Puppet
   end
 
   require 'puppet/parser/ast/pops_bridge'
-  require 'puppet/bindings'
   require 'puppet/functions'
 
   Puppet::Pops::Model.register_pcore_types

data/vendored/puppet/lib/puppet/pops/evaluator/epp_evaluator.rb

@@ -71,6 +71,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
       enforce_parameters = true
     end
 
+    # filter out all qualified names and set them in qualified_variables
+    # only pass unqualified (filtered) variable names to the the template
+    filtered_args = {}
+    template_args.each_pair do |k, v|
+      if k =~ /::/
+        k = k[2..-1] if k.start_with?('::')
+        scope[k] = v
+      else
+        filtered_args[k] = v
+      end
+    end
+    template_args = filtered_args
+
     # inline_epp() logic sees all local variables, epp() all global
     if use_global_scope_only
       scope.with_global_scope do |global_scope|

data/vendored/puppet/lib/puppet/pops/loader/loader_paths.rb

@@ -28,9 +28,10 @@ module LoaderPaths
         # When wanted also add FunctionPath3x to load 3x functions
     when :plan
       result << PlanPathPP.new(loader)
+    when :task
+      result << TaskPath.new(loader) if Puppet[:tasks] && loader.loadables.include?(:task)
     when :type
       result << TypePathPP.new(loader) if loader.loadables.include?(:type_pp)
-      result << TaskPath.new(loader) if Puppet[:tasks] && loader.loadables.include?(:task)
     when :resource_type_pp
       result << ResourceTypeImplPP.new(loader) if loader.loadables.include?(:resource_type_pp)
     else
@@ -73,6 +74,10 @@ module LoaderPaths
       @loader.path
     end
 
+    def lib_root?
+      @loader.lib_root?
+    end
+
     # Effective path is the generic path + the name part(s) + extension.
     #
     def effective_path(typed_name, start_index_in_name)
@@ -93,6 +98,10 @@ module LoaderPaths
       TypedName.new(type, n, name_authority)
     end
 
+    def valid_path?(path)
+      path.end_with?(extension) && path.start_with?(generic_path)
+    end
+
     def valid_name?(typed_name)
       true
     end
@@ -157,10 +166,11 @@ module LoaderPaths
   end
 
   class FunctionPath4x < RubySmartPath
-    FUNCTION_PATH_4X = File.join('lib', 'puppet', 'functions').freeze
+    SYSTEM_FUNCTION_PATH_4X = File.join('puppet', 'functions').freeze
+    FUNCTION_PATH_4X = File.join('lib', SYSTEM_FUNCTION_PATH_4X).freeze
 
     def relative_path
-      FUNCTION_PATH_4X
+      lib_root? ? SYSTEM_FUNCTION_PATH_4X : FUNCTION_PATH_4X
     end
 
     def instantiator
@@ -169,10 +179,11 @@ module LoaderPaths
   end
 
   class FunctionPath3x < RubySmartPath
-    FUNCTION_PATH_3X = File.join('lib', 'puppet', 'parser', 'functions').freeze
+    SYSTEM_FUNCTION_PATH_3X = File.join('puppet', 'parser', 'functions').freeze
+    FUNCTION_PATH_3X = File.join('lib', SYSTEM_FUNCTION_PATH_3X).freeze
 
     def relative_path
-      FUNCTION_PATH_3X
+      lib_root? ? SYSTEM_FUNCTION_PATH_3X : FUNCTION_PATH_3X
     end
 
     def instantiator
@@ -208,6 +219,7 @@ module LoaderPaths
   # match more than one path with one name
   class TaskPath < PuppetSmartPath
     TASKS_PATH = 'tasks'.freeze
+    FORBIDDEN_EXTENSIONS = %w{.conf .md}.freeze
 
     def extension
       EMPTY_STRING
@@ -221,6 +233,20 @@ module LoaderPaths
       TASKS_PATH
     end
 
+    def typed_name(type, name_authority, relative_path, module_name)
+      n = ''
+      n << module_name unless module_name.nil?
+
+      # Remove extension regardless of what it is. A task name cannot contain dots
+      relative_path = relative_path.sub(/\.[^\/]*\z/, '')
+
+      relative_path.split('/').each do |segment|
+        n << '::' if n.size > 0
+        n << segment
+      end
+      TypedName.new(type, n, name_authority)
+    end
+
     def instantiator
       require_relative 'task_instantiator'
       TaskInstantiator
@@ -230,6 +256,14 @@ module LoaderPaths
       # TODO: Remove when PE has proper namespace handling
       typed_name.name_parts.size <= 2
     end
+
+    def valid_path?(path)
+      path.start_with?(generic_path) && is_task_name?(File.basename(path, '.*')) && !FORBIDDEN_EXTENSIONS.any? { |ext| path.end_with?(ext) }
+    end
+
+    def is_task_name?(name)
+      !!(name =~ /^[a-z][a-z0-9_]*$/)
+    end
   end
 
   class ResourceTypeImplPP < PuppetSmartPath

data/vendored/puppet/lib/puppet/pops/loader/module_loaders.rb

@@ -27,8 +27,8 @@ module ModuleLoaders
     # to search up the path from this source file's __FILE__ location until it finds the base of
     # puppet.
     #
-    puppet_lib = File.join(File.dirname(__FILE__), '../../../..')
-    ModuleLoaders::FileBased.new(parent_loader,
+    puppet_lib = File.realpath(File.join(File.dirname(__FILE__), '../../..'))
+    LibRootedFileBased.new(parent_loader,
                                                        loaders,
                                                        nil,
                                                        puppet_lib,   # may or may not have a 'lib' above 'puppet'
@@ -38,12 +38,16 @@ module ModuleLoaders
   end
 
   def self.environment_loader_from(parent_loader, loaders, env_path)
-    ModuleLoaders::FileBased.new(parent_loader,
-      loaders,
-      ENVIRONMENT,
-      env_path,
-      ENVIRONMENT
-    )
+    if env_path.nil? || env_path.empty?
+      EmptyLoader.new(parent_loader, ENVIRONMENT)
+    else
+      FileBased.new(parent_loader,
+        loaders,
+        ENVIRONMENT,
+        env_path,
+        ENVIRONMENT
+      )
+    end
   end
 
   def self.module_loader_from(parent_loader, loaders, module_name, module_path)
@@ -64,6 +68,20 @@ module ModuleLoaders
     )
   end
 
+  class EmptyLoader < BaseLoader
+    def find(typed_name)
+      return nil
+    end
+
+    def private_loader
+      @private_loader ||= self
+    end
+
+    def private_loader=(loader)
+      @private_loader = loader
+    end
+  end
+
   class AbstractPathBasedModuleLoader < BaseLoader
 
     # The name of the module, or nil, if this is a global "component"
@@ -92,6 +110,8 @@ module ModuleLoaders
     def initialize(parent_loader, loaders, module_name, path, loader_name, loadables)
       super parent_loader, loader_name
 
+      raise ArgumentError, 'path based loader cannot be instantiated without a path' if path.nil? || path.empty?
+
       @module_name = module_name
       @path = path
       @smart_paths = LoaderPaths::SmartPaths.new(self)
@@ -158,6 +178,16 @@ module ModuleLoaders
             return smart_path.nil? ? nil : instantiate(smart_path, typed_name, origin)
           end
 
+        when :task
+          if !global?
+            # Global name must be the name of the module
+            return nil unless name_parts[0] == module_name
+
+            # Look for the special 'init' Task
+            origin, smart_path = find_existing_path(init_task_name)
+            return smart_path.nil? ? nil : instantiate(smart_path, typed_name, origin)
+          end
+
         when :type
           if !global?
             # Global name must be the name of the module
@@ -165,16 +195,7 @@ module ModuleLoaders
 
             # Look for the special 'init_typeset' TypeSet
             origin, smart_path = find_existing_path(init_typeset_name)
-
-            # The init_typeset has no special meaning unless found under the 'types' folder
-            unless smart_path.is_a?(LoaderPaths::TypePathPP)
-
-              # Look for the special 'init' Task
-              origin, smart_path = find_existing_path(init_type_name)
-
-              # The init has no special meaning unless found under the 'tasks' folder
-              return smart_path.is_a?(LoaderPaths::TaskPath) ? instantiate(smart_path, typed_name, origin) : nil
-            end
+            return nil if smart_path.nil?
 
             value = smart_path.instantiator.create(self, typed_name, origin, get_contents(origin))
             if value.is_a?(Types::PTypeSetType)
@@ -290,6 +311,16 @@ module ModuleLoaders
       module_name.nil? || module_name == ENVIRONMENT
     end
 
+    # Answers `true` if the loader used by this instance is rooted beneath 'lib'. This is
+    # typically true for the the system_loader. It will have a path relative to the parent
+    # of 'puppet' instead of the parent of 'lib/puppet' since the 'lib' directory of puppet
+    # is renamed during install. This is significant for loaders that load ruby code.
+    #
+    # @return [Boolean] a boolean answering if the loader is rooted beneath 'lib'.
+    def lib_root?
+      false
+    end
+
     # Produces the private loader for the module. If this module is not already resolved, this will trigger resolution
     #
     def private_loader
@@ -316,8 +347,8 @@ module ModuleLoaders
 
     # @return [TypedName] the fake typed name that maps to the path of an init[arbitrary extension]
     #   file that represents a task named after the module
-    def init_type_name
-      @init_type_name ||= TypedName.new(:type, "#{module_name}::init")
+    def init_task_name
+      @init_task_name ||= TypedName.new(:task, "#{module_name}::init")
     end
 
     # @return [TypedName] the fake typed name that maps to the path of an init.pp file that represents
@@ -413,17 +444,26 @@ module ModuleLoaders
     # @return [Array<String>] found paths
     def relative_paths(smart_path)
       root = smart_path.generic_path
-      ext = smart_path.extension
-      ext = nil if ext.empty?
       found = []
       @path_index.each do |path|
-        next unless (ext.nil? || path.end_with?(ext)) && path.start_with?(root)
-        found << Pathname(path).relative_path_from(Pathname(root)).to_s
+        found << Pathname(path).relative_path_from(Pathname(root)).to_s if smart_path.valid_path?(path)
       end
       found
     end
   end
 
+  # Specialization used by the system_loader which is limited to see what's beneath 'lib' and hence
+  # cannot be rooted in its parent. The 'lib' directory is renamed during install so any attempt
+  # to traverse into it from above would fail.
+  #
+  # @api private
+  #
+  class LibRootedFileBased < FileBased
+    def lib_root?
+      true
+    end
+  end
+
   # Loads from a gem specified as a URI, gem://gemname/optional/path/in/gem, or just a String gemname.
   # The source reference (shown in errors etc.) is the expanded path of the gem as this is believed to be more
   # helpful - given the location it should be quite obvious which gem it is, without the location, the user would