bolt 0.11.0 → 0.12.0

data/vendored/puppet/lib/puppet/module_tool/errors/uninstaller.rb

@@ -11,22 +11,13 @@ module Puppet::ModuleTool::Errors
     end
 
     def multiline
-      module_versions_list = @modules.map do |mod|
+      message = []
+      message << _("Could not uninstall module '%{module_name}' (%{version})") % { module_name: @module_name, version: v(@version) }
+      message << _("  No installed version of '%{module_name}' matches (%{version})") % { module_name: @module_name, version: v(@version) }
+      message += @modules.map do |mod|
         _("    '%{module_name}' (%{version}) is installed in %{path}") % { module_name: mod[:name], version: v(mod[:version]), path: mod[:path] }
-      end.join("\n")
-
-      if module_versions_list.empty?
-        _(<<-MSG).chomp  % { module_name: @module_name, version: v(@version)}
-Could not uninstall module '%{module_name}' (%{version})
-  No installed version of '%{module_name}' matches (%{version})
-        MSG
-      else
-        _(<<-MSG).chomp  % { module_name: @module_name, version: v(@version), module_versions_list: module_versions_list }
-Could not uninstall module '%{module_name}' (%{version})
-  No installed version of '%{module_name}' matches (%{version})
-%{module_versions_list}
-        MSG
       end
+      message.join("\n")
     end
   end
 
@@ -41,32 +32,19 @@ Could not uninstall module '%{module_name}' (%{version})
     end
 
     def multiline
-
-      module_requirements_list = @required_by.map do |mod|
-        msg_variables = { module_name: mod['name'], version: v(mod['version']), module_dependency: @module_name,
-                          dependency_version: v(mod['version_requirement']) }
-        _("    '%{module_name}' (%{version}) requires '%{module_dependency}' (%{dependency_version})") % msg_variables
-      end.join("\n")
-
+      message = []
       if @requested_version
-        msg_variables = { module_name: @module_name, requested_version: @requested_version, version: v(@installed_version),
-                          module_requirements_list: module_requirements_list }
-        #TRANSLATORS `puppet module uninstall --force` is a command line option that should not be translated
-        _(<<-EOF).chomp % msg_variables
-Could not uninstall module '%{module_name}' (v%{requested_version})
-  Other installed modules have dependencies on '%{module_name}' (%{version})
-%{module_requirements_list}
-    Use `puppet module uninstall --force` to uninstall this module anyway
-        EOF
+        message << _("Could not uninstall module '%{module_name}' (v%{requested_version})") % { module_name: @module_name, requested_version: @requested_version }
       else
-        #TRANSLATORS `puppet module uninstall --force` is a command line option that should not be translated
-        _(<<-EOF) % { module_name: @module_name, version: v(@installed_version), module_requirements_list: module_requirements_list }
-Could not uninstall module '%{module_name}'
-  Other installed modules have dependencies on '%{module_name}' (%{version})
-%{module_requirements_list}
-    Use `puppet module uninstall --force` to uninstall this module anyway
-        EOF
+        message << _("Could not uninstall module '%{module_name}'") % { module_name: @module_name }
+      end
+      message << _("  Other installed modules have dependencies on '%{module_name}' (%{version})") % { module_name: @module_name, version: v(@installed_version) }
+      message += @required_by.map do |mod|
+        _("    '%{module_name}' (%{version}) requires '%{module_dep}' (%{dep_version})") % { module_name: mod['name'], version: v(mod['version']), module_dep: @module_name, dep_version: v(mod['version_requirement']) }
       end
+      #TRANSLATORS `puppet module uninstall --force` is a command line option that should not be translated
+      message << _("    Use `puppet module uninstall --force` to uninstall this module anyway")
+      message.join("\n")
     end
   end
 end

data/vendored/puppet/lib/puppet/module_tool/errors/upgrader.rb

@@ -21,36 +21,24 @@ module Puppet::ModuleTool::Errors
     end
 
     def multiline
+      message = []
+      message << _("Could not upgrade module '%{module_name}' (%{version})") % { module_name: @module_name, version: vstring }
       if @newer_versions.empty?
-        # TRANSLATORS `puppet module upgrade --force` is a command line option that should not be translated
-        _(<<-MSG).chomp % { module_name: @module_name, version: vstring }
-Could not upgrade module '%{module_name}' (%{version})
-  The installed version is already the latest version matching %{version}
-    Use `puppet module upgrade --force` to upgrade only this module
-        MSG
+        message << _("  The installed version is already the latest version matching %{version}") % { version: vstring }
       else
-        if @possible_culprits.empty?
-          # TRANSLATORS `puppet module upgrade --force` is a command line option that should not be translated
-          _(<<-MSG).chomp % { module_name: @module_name, version: vstring, count: @newer_versions.length }
-Could not upgrade module '%{module_name}' (%{version})
-  There are %{count} newer versions
-    No combination of dependency upgrades would satisfy all dependencies
-    Use `puppet module upgrade --force` to upgrade only this module
-          MSG
-        else
-          module_dependency_list = @possible_culprits.map {|name| "    - #{name}"}.join("\n")
-          # TRANSLATORS `puppet module upgrade --force` is a command line option that should not be translated
-          _(<<-MSG).chomp % { module_name: @module_name, version: vstring, count: @newer_versions.length, module_dependency_list: module_dependency_list }
-Could not upgrade module '%{module_name}' (%{version})
-  There are %{count} newer versions
-    No combination of dependency upgrades would satisfy all dependencies
-    Dependencies will not be automatically upgraded across major versions
-    Upgrading one or more of these modules may permit the upgrade to succeed:
-%{module_dependency_list}
-    Use `puppet module upgrade --force` to upgrade only this module
-          MSG
+        message << _("  There are %{count} newer versions") % { count: @newer_versions.length }
+        message << _("    No combination of dependency upgrades would satisfy all dependencies")
+        unless @possible_culprits.empty?
+          message << _("    Dependencies will not be automatically upgraded across major versions")
+          message << _("    Upgrading one or more of these modules may permit the upgrade to succeed:")
+          @possible_culprits.each do |name|
+            message << "    - #{name}"
+          end
         end
       end
+      #TRANSLATORS `puppet module upgrade --force` is a command line option that should not be translated
+      message << _("    Use `puppet module upgrade --force` to upgrade only this module")
+      message.join("\n")
     end
   end
 
@@ -66,10 +54,10 @@ Could not upgrade module '%{module_name}' (%{version})
     end
 
     def multiline
-      _(<<-MSG).chomp % { action: @action, module_name: @module_name, version: vstring }
-Could not %{action} module '%{module_name}' (%{version})
-  Downgrading is not allowed.
-      MSG
+      message = []
+      message << _("Could not %{action} module '%{module_name}' (%{version})") % { action: @action, module_name: @module_name, version: vstring }
+      message << _("  Downgrading is not allowed.")
+      message.join("\n")
     end
   end
 end

data/vendored/puppet/lib/puppet/module_tool/installed_modules.rb

@@ -60,7 +60,7 @@ module Puppet::ModuleTool
         name = mod.forge_name.tr('/', '-')
         begin
           version = SemanticPuppet::Version.parse(mod.version)
-        rescue SemanticPuppet::Version::ValidationFailure => e
+        rescue SemanticPuppet::Version::ValidationFailure
           Puppet.warning _("%{module_name} (%{path}) has an invalid version number (%{version}). The version has been set to 0.0.0. If you are the maintainer for this module, please update the metadata.json with a valid Semantic Version (http://semver.org).") % { module_name: mod.name, path: mod.path, version: mod.version }
           version = SemanticPuppet::Version.parse("0.0.0")
         end

data/vendored/puppet/lib/puppet/module_tool/metadata.rb

@@ -200,7 +200,6 @@ module Puppet::ModuleTool
     #
     # @param value [Object] The value to be tested
     def validate_data_provider(value)
-      err = nil
       if value.is_a?(String)
         unless value =~ /^[a-zA-Z][a-zA-Z0-9_]*$/
           if value =~ /^[a-zA-Z]/

data/vendored/puppet/lib/puppet/network/http/api/indirected_routes.rb

@@ -191,7 +191,7 @@ class Puppet::Network::HTTP::API::IndirectedRoutes
       begin
         yield format
         true
-      rescue Puppet::Network::FormatHandler::FormatError => e
+      rescue Puppet::Network::FormatHandler::FormatError
         false
       end
     end

data/vendored/puppet/lib/puppet/network/rights.rb

@@ -34,7 +34,7 @@ class Rights
 
   def is_forbidden_and_why?(name, args = {})
     res = :nomatch
-    right = @rights.find do |acl|
+    @rights.find do |acl|
       found = false
       # an acl can return :dunno, which means "I'm not qualified to answer your question,
       # please ask someone else". This is used when for instance an acl matches, but not for the

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

@@ -30,7 +30,7 @@ class Puppet::Node
     env_name = data['environment']
     env_name = env_name.intern unless env_name.nil?
     @environment_name = env_name
-    environment = env_name
+    environment = env_name # rubocop:disable Lint/UselessAssignment
   end
 
   def self.from_data_hash(data)

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

@@ -295,7 +295,7 @@ class Puppet::Node::Environment
   # @param forge_name [String] The module name
   # @return [Puppet::Module, nil] The module if found, else nil
   def module_by_forge_name(forge_name)
-    author, modname = forge_name.split('/')
+    _, modname = forge_name.split('/')
     found_mod = self.module(modname)
     found_mod and found_mod.forge_name == forge_name ?
       found_mod :

data/vendored/puppet/lib/puppet/parameter/value_collection.rb

@@ -180,23 +180,10 @@ class Puppet::Parameter::ValueCollection
   def validate(value)
     return if empty?
 
-    unless @values.detect { |name, v| v.match?(value) }
-      str = if values.empty?
-              if regexes.empty?
-                _("Invalid value %{value}.") % { value: value.inspect }
-              else
-                _("Invalid value %{value}. Valid values match %{patterns_list}.") %
-                    { value: value.inspect, patterns_list: regexes.join(", ") }
-              end
-            else
-              if regexes.empty?
-                _("Invalid value %{value}. Valid values are %{values_list}.") %
-                    { value: value.inspect, values_list: values.join(", ") }
-              else
-                _("Invalid value %{value}. Valid values are %{values_list}. Valid values match %{patterns_list}.") %
-                    { value: value.inspect, values_list: values.join(", "), patterns_list: regexes.join(", ") }
-              end
-            end
+    unless @values.detect {|name, v| v.match?(value)}
+      str = _("Invalid value %{value}.") % { value: value.inspect }
+      str += " " + _("Valid values are %{value_list}.") % { value_list: values.join(", ") } unless values.empty?
+      str += " " + _("Valid values match %{pattern}.") % { pattern: regexes.join(", ") } unless regexes.empty?
       raise ArgumentError, str
     end
   end

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

@@ -720,6 +720,7 @@ class Puppet::Parser::Compiler
     Puppet.override( @context_overrides , _("For initializing compiler")) do
       # THE MAGIC STARTS HERE ! This triggers parsing, loading etc.
       @catalog.version = environment.known_resource_types.version
+      @loaders.pre_load
     end
 
     @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @topscope))

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

@@ -198,7 +198,6 @@ module Puppet::Parser::Functions
   def self.function(name, environment = Puppet.lookup(:current_environment))
     name = name.intern
 
-    func = nil
     unless func = get_function(name, environment)
       autoloader.load(name, environment)
       func = get_function(name, environment)

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

@@ -34,5 +34,5 @@ DOC
 ) do |args|
   data = args[0]
   format = args[1]
-  result = data.scanf(format)
+  data.scanf(format)
 end

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

@@ -884,11 +884,12 @@ class Puppet::Parser::Scope
     path = detail[0]
     env_path = nil
     env_path = environment.configuration.path_to_env unless (environment.nil? || environment.configuration.nil?)
-    if env_path && path && path.start_with?(env_path)
+    # check module paths first since they may be in the environment (i.e. they are longer)
+    if module_path = environment.full_modulepath.detect {|m_path| path.start_with?(m_path) }
+      path = "<module>" + path[module_path.length..-1]
+    elsif env_path && path && path.start_with?(env_path)
       path = "<env>" + path[env_path.length..-1]
     end
-    # TODO: also shorten module paths to <module>/name/...
-
     # Make the output appear as "Scope(path, line)"
     "Scope(#{[path, detail[1]].join(', ')})" 
   end

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

@@ -111,6 +111,7 @@ class Puppet::Parser::ScriptCompiler
 
   # Find and evaluate the top level code.
   def evaluate_main
+    @loaders.pre_load
     program = @loaders.load_main_manifest
     return program.nil? ? nil : Puppet::Pops::Parser::EvaluatingParser.singleton.evaluator.evaluate(program, @topscope)
   end

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

@@ -78,7 +78,8 @@ class Puppet::Parser::TemplateWrapper
     # Expose all the variables in our scope as instance variables of the
     # current object, making it possible to access them without conflict
     # to the regular methods.
-    benchmark(:debug, _("Bound template variables for %{template_source}") % { template_source: template_source }) do
+    escaped_template_source = template_source.gsub(/%/, '%%')
+    benchmark(:debug, _("Bound template variables for %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
       scope.to_hash.each do |name, value|
         realname = name.gsub(/[^\w]/, "_")
         instance_variable_set("@#{realname}", value)
@@ -86,7 +87,7 @@ class Puppet::Parser::TemplateWrapper
     end
 
     result = nil
-    benchmark(:debug, _("Interpolated template %{template_source}") % { template_source: template_source }) do
+    benchmark(:debug, _("Interpolated template %{template_source} in %%{seconds} seconds") % { template_source: escaped_template_source }) do
       template = ERB.new(string, 0, "-")
       template.filename = @__file__
       result = template.result(binding)

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

@@ -70,7 +70,7 @@ class Puppet::Parser::TypeLoader
           Puppet.debug {"Automatically imported #{fqname} from #{filename} into #{environment}"}
           return result
         end
-      rescue TypeLoaderError => detail
+      rescue TypeLoaderError
         # I'm not convinced we should just drop these errors, but this
         # preserves existing behaviours.
       end

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

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

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

@@ -27,8 +27,9 @@ class AccessOperator
   protected
 
   def access_Object(o, scope, keys)
-    if o.is_a?(Puppet::Pops::Types::PuppetObject)
-      access_func = o._pcore_type.functions(true)['[]']
+    type = Puppet::Pops::Types::TypeCalculator.infer(o)
+    if type.is_a?(Puppet::Pops::Types::TypeWithMembers)
+      access_func = type['[]']
       return access_func.invoke(o, scope, keys) unless access_func.nil?
     end
     fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)

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

@@ -318,7 +318,7 @@ class Closure < CallableSignature
     closure_scope = enclosing_scope
 
     parameters.each do |param|
-      arg_type, param_range = create_param_type(param, closure_scope)
+      arg_type, _ = create_param_type(param, closure_scope)
       key_type = type_factory.string(param.name.to_s)
       key_type = type_factory.optional(key_type) unless param.value.nil?
       members[key_type] = arg_type

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

@@ -442,9 +442,9 @@ class EvaluatorImpl
           end
         end
         result = left.send(operator, right)
-      rescue NoMethodError => e
+      rescue NoMethodError
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
-      rescue ZeroDivisionError => e
+      rescue ZeroDivisionError
         fail(Issues::DIV_BY_ZERO, bin_expr.right_expr)
       end
       case result

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

@@ -72,14 +72,15 @@ class Dispatch < Evaluator::CallableSignature
       new_args = []
       @weaving.each do |knit|
         if knit.is_a?(Array)
-          injection_data = @injections[knit[0]]
+          injection_name = @injections[knit[0]]
           new_args <<
-            case injection_data[3]
-            when :dispatcher_internal
-              # currently only supports :scope injection
+            case injection_name
+            when :scope
               scope
+            when :pal_script_compiler
+              Puppet.lookup(:pal_script_compiler)
             else
-              raise_error ArgumentError, "Unknown injection #{injection_data[3]}"
+              raise ArgumentError, "Unknown injection #{injection_name}"
             end
         else
           # Careful so no new nil arguments are added since they would override default

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

@@ -49,13 +49,13 @@ class Puppet::Pops::Functions::Function
     rescue Puppet::Pops::Evaluator::Next => jumper
       begin
         throw :next, jumper.value
-      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
         raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
       end
     rescue Puppet::Pops::Evaluator::Return => jumper
       begin
         throw :return, jumper
-      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
+      rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
         raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
       end
     end

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

@@ -29,7 +29,7 @@ class Loader
   attr_reader :loader_name
 
   # Describes the kinds of things that loaders can load
-  LOADABLE_KINDS = [:func_4x, :func_4xpp, :type_pp, :resource_type_pp, :plan, :task].freeze
+  LOADABLE_KINDS = [:func_4x, :func_4xpp, :datatype, :type_pp, :resource_type_pp, :plan, :task].freeze
 
   # @param [String] name the name of the loader. Must be unique among all loaders maintained by a {Loader} instance
   def initialize(loader_name)

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

@@ -31,6 +31,7 @@ module LoaderPaths
     when :task
       result << TaskPath.new(loader) if Puppet[:tasks] && loader.loadables.include?(:task)
     when :type
+      result << DataTypePath.new(loader) if loader.loadables.include?(:datatype)
       result << TypePathPP.new(loader) if loader.loadables.include?(:type_pp)
     when :resource_type_pp
       result << ResourceTypeImplPP.new(loader) if loader.loadables.include?(:resource_type_pp)
@@ -203,6 +204,19 @@ module LoaderPaths
     end
   end
 
+  class DataTypePath < RubySmartPath
+    SYSTEM_TYPE_PATH = File.join('puppet', 'datatypes').freeze
+    TYPE_PATH = File.join('lib', SYSTEM_TYPE_PATH).freeze
+
+    def relative_path
+      lib_root? ? SYSTEM_TYPE_PATH : TYPE_PATH
+    end
+
+    def instantiator
+      RubyDataTypeInstantiator
+    end
+  end
+
   class TypePathPP < PuppetSmartPath
     TYPE_PATH_PP = 'types'.freeze
 
@@ -240,11 +254,15 @@ module LoaderPaths
       # 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
+      if relative_path == 'init' && !(module_name.nil? || module_name.empty?)
+        TypedName.new(type, module_name, name_authority)
+      else
+        relative_path.split('/').each do |segment|
+          n << '::' if n.size > 0
+          n << segment
+        end
+        TypedName.new(type, n, name_authority)
       end
-      TypedName.new(type, n, name_authority)
     end
 
     def instantiator
@@ -302,6 +320,24 @@ module LoaderPaths
     def instantiator()
       Puppet::Pops::Loader::PuppetPlanInstantiator
     end
+
+    def typed_name(type, name_authority, relative_path, module_name)
+      if relative_path == 'init.pp' && !(module_name.nil? || module_name.empty?)
+        TypedName.new(type, module_name, name_authority)
+      else
+        n = ''
+        n << module_name unless module_name.nil?
+        unless extension.empty?
+          # Remove extension
+          relative_path = relative_path[0..-(extension.length+1)]
+        end
+        relative_path.split('/').each do |segment|
+          n << '::' if n.size > 0
+          n << segment
+        end
+        TypedName.new(type, n, name_authority)
+      end
+    end
   end
 
   # SmartPaths