bolt 0.11.0 → 0.12.0

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

@@ -99,7 +99,6 @@ Puppet::Face.define(:parser, '0.0.1') do
           raise Puppet::Error, _("No input to parse given on command line or stdin")
         end
       else
-        missing_files = []
         files = args
         available_files = files.select do |file|
           Puppet::FileSystem.exist?(file)

data/vendored/puppet/lib/puppet/face/status.rb

@@ -13,6 +13,7 @@ Puppet::Indirector::Face.define(:status, '0.0.1') do
   find = get_action(:find)
   find.default = true
   find.summary _("Check status of puppet master server.")
+  #TRANSLATORS the string 'Puppet::Status' is a Puppet language object and should not be translated
   find.returns _(<<-'EOT')
     A "true" response or a low-level connection error. When used from the Ruby
     API: returns a Puppet::Status object.

data/vendored/puppet/lib/puppet/feature/base.rb

@@ -83,7 +83,7 @@ Puppet.features.add(:manages_symlinks) do
           attach_function :CreateSymbolicLinkW, [:lpwstr, :lpwstr, :dword], :boolean
 
           true
-        rescue LoadError => err
+        rescue LoadError
           Puppet.debug("CreateSymbolicLink is not available")
           false
         end

data/vendored/puppet/lib/puppet/file_bucket/dipper.rb

@@ -17,7 +17,6 @@ class Puppet::FileBucket::Dipper
     # Emulate the XMLRPC client
     server      = hash[:Server]
     port        = hash[:Port] || Puppet[:masterport]
-    environment = Puppet[:environment]
 
     if hash.include?(:Path)
       @local_path = hash[:Path]

data/vendored/puppet/lib/puppet/file_system/uniquefile.rb

@@ -144,7 +144,7 @@ class Puppet::FileSystem::Uniquefile < DelegateClass(File)
   def try_convert_to_hash(h)
     begin
       h.to_hash
-    rescue NoMethodError => e
+    rescue NoMethodError
       nil
     end
   end
@@ -154,7 +154,7 @@ class Puppet::FileSystem::Uniquefile < DelegateClass(File)
   def tmpdir
     tmp = '.'
     if $SAFE > 0
-      tmp = @@systmpdir
+      @@systmpdir
     else
       for dir in [ Puppet::Util.get_env('TMPDIR'), Puppet::Util.get_env('TMP'), Puppet::Util.get_env('TEMP'), @@systmpdir, '/tmp']
         if dir and stat = File.stat(dir) and stat.directory? and stat.writable?

data/vendored/puppet/lib/puppet/forge/errors.rb

@@ -32,12 +32,12 @@ module Puppet::Forge::Errors
     #
     # @return [String] the multiline version of the error message
     def multiline
-      _(<<-EOS).chomp % { uri: @uri }
-Could not connect via HTTPS to %{uri}
-  Unable to verify the SSL certificate
-    The certificate may not be signed by a valid CA
-    The CA bundle included with OpenSSL may not be valid or up to date
-      EOS
+      message = []
+      message << _('Could not connect via HTTPS to %{uri}') % { uri: @uri }
+      message << _('  Unable to verify the SSL certificate')
+      message << _('    The certificate may not be signed by a valid CA')
+      message << _('    The CA bundle included with OpenSSL may not be valid or up to date')
+      message.join("\n")
     end
   end
 
@@ -59,12 +59,12 @@ Could not connect via HTTPS to %{uri}
     #
     # @return [String] the multiline version of the error message
     def multiline
-      _(<<-EOS).chomp % { uri: @uri, detail: @detail }
-Could not connect to %{uri}
-  There was a network communications problem
-    The error we caught said '%{detail}'
-    Check your network connection and try again
-      EOS
+      message = []
+      message << _('Could not connect to %{uri}') % { uri: @uri }
+      message << _('  There was a network communications problem')
+      message << _("    The error we caught said '%{detail}'") % { detail: @detail }
+      message << _('    Check your network connection and try again')
+      message.join("\n")
     end
   end
 
@@ -90,10 +90,9 @@ Could not connect to %{uri}
       end
 
       message = if @message
-                  _("Request to Puppet Forge failed. Detail: %{error_message} / %{http_response}.") %
-                      { error_message: @message, http_response: @response }
+                  _("Request to Puppet Forge failed.") + ' ' + _("Detail: %{detail}.") % { detail: "#{@message} / #{@response}" }
                 else
-                  _("Request to Puppet Forge failed. Detail: %{http_response}.") % { http_response: @response }
+                  _("Request to Puppet Forge failed.") + ' ' + _("Detail: %{detail}.") % { detail: @response }
                 end
       super(message, original)
     end
@@ -102,20 +101,13 @@ Could not connect to %{uri}
     #
     # @return [String] the multiline version of the error message
     def multiline
-      if @message
-        _(<<-EOS).chomp % { uri: @uri, response: @response, message: @message }
-Request to Puppet Forge failed.
-  The server being queried was %{uri}
-  The HTTP response we received was '%{response}'
-  The message we received said '%{message}'
-        EOS
-      else
-        _(<<-EOS).chomp % { uri: @uri, response: @response }
-Request to Puppet Forge failed.
-  The server being queried was %{uri}
-  The HTTP response we received was '%{response}'
-        EOS
-      end
+
+      message = []
+      message << _('Request to Puppet Forge failed.')
+      message << _('  The server being queried was %{uri}') % { uri: @uri }
+      message << _("  The HTTP response we received was '%{response}'") % { response: @response }
+      message << _("  The message we received said '%{message}'") % { message: @message } if @message
+      message.join("\n")
     end
   end
 

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

@@ -186,8 +186,12 @@ module Puppet::Functions
     # and it will fail unless protected with an if defined? if the local
     # variable does not exist in the block's binder.
     #
-    loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
-    create_loaded_function(func_name, loader, function_base, &block)
+    begin
+      loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
+      create_loaded_function(func_name, loader, function_base, &block)
+    rescue StandardError => e
+      raise ArgumentError, _("Function Load Error for function '%{function_name}': %{message}") % {function_name: func_name, message: e.message}
+    end
   end
 
   # Creates a function in, or in a local loader under the given loader.
@@ -573,14 +577,27 @@ module Puppet::Functions
     # @api private
     def create_callable(types, block_type, return_type, from, to)
       mapped_types = types.map do |t|
-        t.is_a?(Puppet::Pops::Types::PAnyType) ? t : Puppet::Pops::Types::TypeParser.singleton.parse(t, loader)
+        t.is_a?(Puppet::Pops::Types::PAnyType) ? t : internal_type_parse(t, loader)
       end
       param_types = Puppet::Pops::Types::PTupleType.new(mapped_types, from > 0 && from == to ? nil : Puppet::Pops::Types::PIntegerType.new(from, to))
-      return_type = Puppet::Pops::Types::TypeParser.singleton.parse(return_type, loader) unless return_type.nil? || return_type.is_a?(Puppet::Pops::Types::PAnyType)
+      return_type = internal_type_parse(return_type, loader) unless return_type.nil? || return_type.is_a?(Puppet::Pops::Types::PAnyType)
       Puppet::Pops::Types::PCallableType.new(param_types, block_type, return_type)
     end
+
+    def internal_type_parse(type_string, loader)
+      begin
+        Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
+      rescue StandardError => e
+        raise ArgumentError, _("Parsing of type string '\"%{type_string}\"' failed with message: <%{message}>.\n") % {
+            type_string: type_string,
+            message: e.message
+        }
+      end
+    end
+    private :internal_type_parse
   end
 
+
   # The LocalTypeAliasBuilder is used by the 'local_types' method to collect the individual
   # type aliases given by the function's author.
   #
@@ -603,9 +620,31 @@ module Puppet::Functions
     # @api public
     #
     def type(assignment_string)
-      result = parser.parse_string("type #{assignment_string}", nil) # no file source :-(
+      # Get location to use in case of error - this produces ruby filename and where call to 'type' occurred
+      # but strips off the rest of the internal "where" as it is not meaningful to user.
+      #
+      rb_location = caller[0]
+
+      begin
+        result = parser.parse_string("type #{assignment_string}", nil)
+      rescue StandardError => e
+        rb_location = rb_location.gsub(/:in.*$/, '')
+        # Create a meaningful location for parse errors - show both what went wrong with the parsing
+        # and in which ruby file it was found.
+        raise ArgumentError, _("Parsing of 'type \"%{assignment_string}\"' failed with message: <%{message}>.\n" +
+          "Called from <%{ruby_file_location}>") % {
+            assignment_string: assignment_string,
+            message: e.message,
+            ruby_file_location: rb_location
+        }
+      end
       unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
-        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'") % { assignment_string: assignment_string }
+        rb_location = rb_location.gsub(/:in.*$/, '')
+        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'.\n"+
+        "Called from <%{ruby_file_location}>") % {
+          assignment_string: assignment_string,
+          ruby_file_location: rb_location
+        }
       end
       @local_types << result.body
     end
@@ -618,30 +657,7 @@ module Puppet::Functions
   #
   # This is a private, internal, system for creating functions. It supports
   # everything that the public function definition system supports as well as a
-  # few extra features.
-  #
-  # Injection Support
-  # ===
-  # The Function API supports injection of data and services. It is possible to
-  # make injection that takes effect when the function is loaded (for services
-  # and runtime configuration that does not change depending on how/from where
-  # in what context the function is called. It is also possible to inject and
-  # weave argument values into a call.
-  #
-  # Injection of attributes
-  # ---
-  # Injection of attributes is performed by one of the methods `attr_injected`,
-  # and `attr_injected_producer`.  The injected attributes are available via
-  # accessor method calls.
-  #
-  # @example using injected attributes
-  #   Puppet::Functions.create_function('test') do
-  #     attr_injected String, :larger, 'message_larger'
-  #     attr_injected String, :smaller, 'message_smaller'
-  #     def test(a, b)
-  #       a > b ? larger() : smaller()
-  #     end
-  #   end
+  # few extra features such as injection of well known parameters.
   #
   # @api private
   class InternalFunction < Function
@@ -665,26 +681,22 @@ module Puppet::Functions
     end
   end
 
-  # @note WARNING: This style of creating functions is not public. It is a system
-  #   under development that will be used for creating "system" functions.
-  #
   # Injection and Weaving of parameters
   # ---
-  # It is possible to inject and weave parameters into a call. These extra
-  # parameters are not part of the parameters passed from the Puppet logic, and
-  # they can not be overridden by parameters given as arguments in the call.
-  # They are invisible to the Puppet Language.
+  # It is possible to inject and weave a set of well known parameters into a call.
+  # These extra parameters are not part of the parameters passed from the Puppet
+  # logic, and  they can not be overridden by parameters given as arguments in the
+  # call. They are invisible to the Puppet Language.
   #
   # @example using injected parameters
   #   Puppet::Functions.create_function('test') do
   #     dispatch :test do
   #       param 'Scalar', 'a'
   #       param 'Scalar', 'b'
-  #       injected_param 'String', 'larger', 'message_larger'
-  #       injected_param 'String', 'smaller', 'message_smaller'
+  #       scope_param
   #     end
-  #     def test(a, b, larger, smaller)
-  #       a > b ? larger : smaller
+  #     def test(a, b, scope)
+  #       a > b ? scope['a'] : scope['b']
   #     end
   #   end
   #
@@ -692,54 +704,22 @@ module Puppet::Functions
   #
   #     test(10, 20)
   #
-  # Using injected value as default
-  # ---
-  # Default value assignment is handled by using the regular Ruby mechanism (a
-  # value is assigned to the variable).  The dispatch simply indicates that the
-  # value is optional. If the default value should be injected, it can be
-  # handled different ways depending on what is desired:
-  #
-  # * by calling the accessor method for an injected Function class attribute.
-  #   This is suitable if the value is constant across all instantiations of the
-  #   function, and across all calls.
-  # * by injecting a parameter into the call
-  #   to the left of the parameter, and then assigning that as the default value.
-  # * One of the above forms, but using an injected producer instead of a
-  #   directly injected value.
-  #
-  # @example method with injected default values
-  #   Puppet::Functions.create_function('test') do
-  #     dispatch :test do
-  #       injected_param String, 'b_default', 'b_default_value_key'
-  #       param 'Scalar', 'a'
-  #       param 'Scalar', 'b'
-  #     end
-  #     def test(b_default, a, b = b_default)
-  #       # ...
-  #     end
-  #   end
-  #
   # @api private
   class InternalDispatchBuilder < DispatcherBuilder
-    def scope_param()
-      @injections << [:scope, 'scope', '', :dispatcher_internal]
-      # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size()-1]
+    # Inject parameter for `Puppet::Parser::Scope`
+    def scope_param
+      inject(:scope)
     end
-    # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
-    #
-    # @api private
-    def injected_param(type, name, injection_name = '')
-      @injections << [type, name, injection_name]
-      # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size() -1]
+
+    # Inject parameter for `Puppet::Pal::ScriptCompiler`
+    def script_compiler_param
+      inject(:pal_script_compiler)
     end
 
-    # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
-    #
-    # @api private
-    def injected_producer_param(type, name, injection_name = '')
-      @injections << [type, name, injection_name, :producer]
+    private
+
+    def inject(injection_name)
+      @injections << injection_name
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size()-1]
     end

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

@@ -105,7 +105,6 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
   end
 
   def is_defined(scope, *vals)
-    env = scope.environment
     vals.any? do |val|
       case val
       when String
@@ -120,7 +119,6 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
             Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_main_class(scope)
           else
             # Find a resource type, definition or class definition
-            krt = scope.environment.known_resource_types
             Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type_or_class(scope, val)
           end
         end
@@ -150,7 +148,6 @@ Puppet::Functions.create_function(:'defined', Puppet::Functions::InternalFunctio
           #
           raise  ArgumentError, _('The given class type is a reference to all classes') if val.type.class_name.nil?
           Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_hostclass(scope, val.type.class_name)
-          #scope.environment.known_resource_types.find_hostclass(val.type.class_name)
         end
       else
         raise ArgumentError, _("Invalid argument of type '%{value_class}' to 'defined'") % { value_class: val.class }

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

@@ -19,7 +19,6 @@ Puppet::Functions.create_function(:find_file, Puppet::Functions::InternalFunctio
   end
 
   def find_file(scope, *args)
-    path = nil
     args.each do |file|
       found = Puppet::Parser::Files.find_file(file, scope.compiler.environment)
       if found && Puppet::FileSystem.exist?(found)

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

@@ -107,7 +107,6 @@ Puppet::Functions.create_function(:map) do
 
   def map_Enumerable_1(enumerable)
     result = []
-    index = 0
     enum = Puppet::Pops::Types::Iterable.asserted_iterable(self, enumerable)
     begin
       loop { result << yield(enum.next) }

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

@@ -66,7 +66,7 @@ Puppet::Functions.create_function(:regsubst) do
 
   def regsubst_regexp(target, pattern, replacement, flags = nil)
     pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
-    inner_regsubst(target, pattern, replacement, operation = flags == 'G' ? :gsub : :sub)
+    inner_regsubst(target, pattern, replacement, flags == 'G' ? :gsub : :sub)
   end
 
   def inner_regsubst(target, re, replacement, op)

data/vendored/puppet/lib/puppet/graph/simple_graph.rb

@@ -228,23 +228,19 @@ class Puppet::Graph::SimpleGraph
     number_of_cycles = cycles.length
     return if number_of_cycles == 0
 
-    cycle_path_list = ''
+    message = n_("Found %{num} dependency cycle:\n", "Found %{num} dependency cycles:\n", number_of_cycles) % { num: number_of_cycles }
+
     cycles.each do |cycle|
       paths = paths_in_cycle(cycle)
-      cycle_path_list += paths.map{ |path| '(' + path.join(' => ') + ')'}.join('\n')
+      message += paths.map{ |path| '(' + path.join(' => ') + ')'}.join('\n') + '\n'
     end
 
     if Puppet[:graph] then
       filename = write_cycles_to_graph(cycles)
-      message  = n_("Found %{number_of_cycles} dependency cycle:\n%{cycle_path_list}\nCycle graph written to %{filename}.",
-                    "Found %{number_of_cycles} dependency cycles:\n%{cycle_path_list}\nCycle graph written to %{filename}.", number_of_cycles) %
-          { number_of_cycles: number_of_cycles, cycle_path_list: cycle_path_list, filename: filename }
+      message += _("Cycle graph written to %{filename}.") % { filename: filename }
     else
-      #TRANSLATORS '--graph' refers to a command line option and should not be translated
-      #TRANSLATORS OmniGraffle and GraphViz and program names and should not be translated
-      message = n_("Found %{number_of_cycles} dependency cycle:\n%{cycle_path_list}\nTry the '--graph' option and opening the resulting '.dot' file in OmniGraffle or GraphViz",
-                   "Found %{number_of_cycles} dependency cycles:\n%{cycle_path_list}\nTry the '--graph' option and opening the resulting '.dot' file in OmniGraffle or GraphViz", number_of_cycles) %
-          { number_of_cycles: number_of_cycles, cycle_path_list: cycle_path_list }
+      #TRANSLATORS '--graph' refers to a command line option and OmniGraffle and GraphViz are program names and should not be translated
+      message += _("Try the '--graph' option and opening the resulting '.dot' file in OmniGraffle or GraphViz")
     end
     Puppet.err(message)
     cycles

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

@@ -178,7 +178,6 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     # TODO: get property/parameter defaults if entries are nil in the resource
     # For now they're hard-coded to match the File type.
 
-    file_metadata = {}
     list_of_resources.each do |resource|
       sources = [resource[:source]].flatten.compact
       next unless inlineable?(resource, sources)
@@ -277,24 +276,31 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       raise Puppet::Error, _("Unable to find a common checksum type between agent '%{agent_type}' and master '%{master_type}'.") % { agent_type: options[:checksum_type], master_type: known_checksum_types } unless checksum_type
     end
 
-    str = if checksum_type
-            if node.environment
-              _("Compiled static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
-            else
-              _("Compiled static catalog for %{node}") % { node: node.name }
-            end
-          else
-            if node.environment
-              _("Compiled catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
-            else
-              _("Compiled catalog for %{node}") % { node: node.name }
-            end
-          end
+    escaped_node_name = node.name.gsub(/%/, '%%')
+    if checksum_type
+      if node.environment
+        escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+        benchmark_str = _("Compiled static catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+        profile_str   = _("Compiled static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+      else
+        benchmark_str = _("Compiled static catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+        profile_str   = _("Compiled static catalog for %{node}") % { node: node.name }
+      end
+    else
+      if node.environment
+        escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+        benchmark_str = _("Compiled catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+        profile_str   = _("Compiled catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+      else
+        benchmark_str = _("Compiled catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+        profile_str   = _("Compiled catalog for %{node}") % { node: node.name }
+      end
+    end
     config = nil
 
-    benchmark(:notice, str) do
+    benchmark(:notice, benchmark_str) do
       compile_type = checksum_type ? :static_compile : :compile
-      Puppet::Util::Profiler.profile(str, [:compiler, compile_type, node.environment, node.name]) do
+      Puppet::Util::Profiler.profile(profile_str, [:compiler, compile_type, node.environment, node.name]) do
         begin
           config = Puppet::Parser::Compiler.compile(node, options[:code_id])
         rescue Puppet::Error => detail
@@ -305,15 +311,21 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
         end
 
         if checksum_type && config.is_a?(model)
-          str = if node.environment
-                  #TRANSLATORS Inlined refers to adding additional metadata
-                  _("Inlined resource metadata into static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
-                else
-                  #TRANSLATORS Inlined refers to adding additional metadata
-                  _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
-                end
-          benchmark(:notice, str) do
-            Puppet::Util::Profiler.profile(str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
+          escaped_node_name = node.name.gsub(/%/, '%%')
+          if node.environment
+            escaped_node_environment = node.environment.to_s.gsub(/%/, '%%')
+            #TRANSLATORS Inlined refers to adding additional metadata
+            benchmark_str = _("Inlined resource metadata into static catalog for %{node} in environment %{environment} in %%{seconds} seconds") % { node: escaped_node_name, environment: escaped_node_environment }
+            #TRANSLATORS Inlined refers to adding additional metadata
+            profile_str   = _("Inlined resource metadata into static catalog for %{node} in environment %{environment}") % { node: node.name, environment: node.environment }
+          else
+            #TRANSLATORS Inlined refers to adding additional metadata
+            benchmark_str = _("Inlined resource metadata into static catalog for %{node} in %%{seconds} seconds") % { node: escaped_node_name }
+            #TRANSLATORS Inlined refers to adding additional metadata
+            profile_str   = _("Inlined resource metadata into static catalog for %{node}") % { node: node.name }
+          end
+          benchmark(:notice, benchmark_str) do
+            Puppet::Util::Profiler.profile(profile_str, [:compiler, :static_compile_postprocessing, node.environment, node.name]) do
               inline_metadata(config, checksum_type)
             end
           end