bolt 0.10.0 → 0.11.0

data/vendored/puppet/lib/puppet/type/tidy.rb

@@ -260,8 +260,10 @@ Puppet::Type.newtype(:tidy) do
     end
     found_files = files.find_all { |path| tidy?(path) }.collect { |path| mkfile(path) }
     result = found_files.each { |file| debug "Tidying #{file.ref}" }.sort { |a,b| b[:path] <=> a[:path] }
-    #TRANSLATORS "Tidy" is a program name and should not be translated
-    notice _("Tidying %{count} files") % { count: found_files.size }
+    if found_files.size > 0
+      #TRANSLATORS "Tidy" is a program name and should not be translated
+      notice _("Tidying %{count} files") % { count: found_files.size }
+    end
 
     # No need to worry about relationships if we don't have rmdirs; there won't be
     # any directories.

data/vendored/puppet/lib/puppet/util/checksums.rb

@@ -10,7 +10,7 @@ module Puppet::Util::Checksums
   # It's not a good idea to use some of these in some contexts: for example, I
   # wouldn't try bucketing a file using the :none checksum type.
   def known_checksum_types
-    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite,
+    [:sha256, :sha256lite, :md5, :md5lite, :sha1, :sha1lite, :sha512, :sha384, :sha224, 
       :mtime, :ctime, :none]
   end
 
@@ -83,6 +83,87 @@ module Puppet::Util::Checksums
     sha256_hex_length
   end
 
+  # Calculate a checksum using Digest::SHA384.
+  def sha384(content)
+    require 'digest/sha2'
+    Digest::SHA384.hexdigest(content)
+  end
+
+  def sha384?(string)
+    string =~ /^\h{96}$/
+  end
+
+  def sha384_file(filename, lite = false)
+    require 'digest/sha2'
+
+    digest = Digest::SHA384.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha384_stream(lite = false, &block)
+    require 'digest/sha2'
+    digest = Digest::SHA384.new
+    checksum_stream(digest, block, lite)
+  end
+
+  def sha384_hex_length
+    96
+  end
+
+  # Calculate a checksum using Digest::SHA512.
+  def sha512(content)
+    require 'digest/sha2'
+    Digest::SHA512.hexdigest(content)
+  end
+
+  def sha512?(string)
+    string =~ /^\h{128}$/
+  end
+
+  def sha512_file(filename, lite = false)
+    require 'digest/sha2'
+
+    digest = Digest::SHA512.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha512_stream(lite = false, &block)
+    require 'digest/sha2'
+    digest = Digest::SHA512.new
+    checksum_stream(digest, block, lite)
+  end
+
+  def sha512_hex_length
+    128
+  end
+
+  # Calculate a checksum using Digest::SHA224.
+  def sha224(content)
+    require 'openssl'
+    OpenSSL::Digest::SHA224.new.hexdigest(content)
+  end
+
+  def sha224?(string)
+    string =~ /^\h{56}$/
+  end
+
+  def sha224_file(filename, lite = false)
+    require 'openssl'
+
+    digest = OpenSSL::Digest::SHA224.new
+    checksum_file(digest, filename,  lite)
+  end
+
+  def sha224_stream(lite = false, &block)
+    require 'openssl'
+    digest = OpenSSL::Digest::SHA224.new
+    checksum_stream(digest, block, lite)
+  end
+
+  def sha224_hex_length
+    56
+  end
+
   # Calculate a checksum using Digest::MD5.
   def md5(content)
     Digest::MD5.hexdigest(content)

data/vendored/puppet/lib/puppet/util/command_line.rb

@@ -14,6 +14,7 @@ require 'puppet/util'
 require "puppet/util/rubygems"
 require "puppet/util/limits"
 require 'puppet/util/colors'
+require 'puppet/gettext/module_translations'
 
 module Puppet
   module Util
@@ -122,6 +123,10 @@ module Puppet
                 $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
               end
 
+              Puppet::GettextConfig.reset_text_domain('cli')
+              Puppet::ModuleTranslations.load_from_modulepath(configured_environment.modules)
+              Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
+
               # Puppet requires Facter, which initializes its lookup paths. Reset Facter to
               # pickup the new $LOAD_PATH.
               Facter.reset

data/vendored/puppet/lib/puppet/vendor/semantic_puppet/lib/semantic_puppet.rb

@@ -1,5 +1,9 @@
 module SemanticPuppet
-  Puppet::GettextConfig.load_translations('semantic_puppet', File.absolute_path('../locales', File.dirname(__FILE__)), :po)
+  locales_path = File.absolute_path('../locales', File.dirname(__FILE__))
+  # Only create a translation repository of the relevant translations exist
+  if Puppet::FileSystem.exist?(File.join(locales_path, Puppet::GettextConfig.current_locale))
+    Puppet::GettextConfig.load_translations('semantic_puppet', locales_path, :po)
+  end
 
   autoload :Version, 'semantic_puppet/version'
   autoload :VersionRange, 'semantic_puppet/version_range'

data/vendored/puppet/lib/puppet_pal.rb

@@ -26,8 +26,9 @@ require 'puppet/parser/script_compiler'
 module Puppet
 module Pal
 
-  # @param compiler [Puppet::Pal::Compiler] a configured compiler as obtained in the callback from `with_script_compiler`
-
+  # A configured compiler as obtained in the callback from `with_script_compiler`.
+  # (Later, there may also be a catalog compiler available.)
+  #
   class Compiler
     attr_reader :internal_compiler
     protected :internal_compiler
@@ -53,17 +54,51 @@ module Pal
       internal_evaluator.evaluator.external_call_function(function_name, args, topscope, &block)
     end
 
-    # Returns an Array[Puppet::Pops::Types::PCallableType] describing the given function's signatures, or empty array if function not found.
+    # Returns a Puppet::Pal::FunctionSignature object or nil if function is not found
+    # The returned FunctionSignature has information about all overloaded signatures of the function
+    #
+    # @example using function_signature
+    #   # returns true if 'myfunc' is callable with three integer arguments 1, 2, 3
+    #   compiler.function_signature('myfunc').callable_with?([1,2,3])
+    #
     # @param function_name [String] the name of the function to get a signature for
-    # @return [Array<Puppet::Pops::Types::PCallableType>] an array of callable signatures, or an empty array if function not found
-    def function_signatures(function_name)
+    # @return [Puppet::Pal::FunctionSignature] a function signature, or nil if function not found
+    #
+    def function_signature(function_name)
       loader = internal_compiler.loaders.private_environment_loader
       if func = loader.load(:function, function_name)
-        t = func.class.dispatcher.to_type
-        return t.is_a?(Puppet::Pops::Types::PVariantType) ? t.types : [t]
+        return FunctionSignature.new(func.class)
       end
       # Could not find function
-      Puppet::Pops::EMPTY_ARRAY
+      nil
+    end
+
+    # Returns an array of TypedName objects for all functions, optionally filtered by a regular expression.
+    # The returned array has more information than just the leaf name - the typical thing is to just get
+    # the name as showing the following example.
+    #
+    # @example getting the names of all functions
+    #   compiler.list_functions.map {|tn| tn.name }
+    #
+    # @param filter_regex [Regexp] an optional regexp that filters based on name (matching names are included in the result)
+    # @return [Array<Puppet::Pops::Loader::TypedName>] an array of typed names
+    #
+    def list_functions(filter_regex = nil)
+      list_loadable_kind(:function, filter_regex)
+    end
+
+    # Returns an array of TypedName objects for all functions, optionally filtered by a regular expression.
+    # The returned array has more information than just the leaf name - the typical thing is to just get
+    # the name as showing the following example.
+    #
+    # @example getting the names of all functions
+    #   compiler.list_functions.map {|tn| tn.name }
+    #
+    # @param filter_regex [Regexp] an optional regexp that filters based on name (matching names are included in the result)
+    # @return [Array<Puppet::Pops::Loader::TypedName>] an array of typed names
+    #
+    def list_functions(filter_regex = nil)
+      list_loadable_kind(:function, filter_regex)
     end
 
     # Evaluates a string of puppet language code in top scope.
@@ -191,6 +226,17 @@ module Pal
       call_function('new', t, *arguments)
     end
 
+    protected
+
+    def list_loadable_kind(kind, filter_regex = nil)
+      loader = internal_compiler.loaders.private_environment_loader
+      if filter_regex.nil?
+        loader.discover(kind)
+      else
+        loader.discover(kind) {|f| f.name =~ filter_regex }
+      end
+    end
+
     private
 
     def topscope
@@ -199,18 +245,230 @@ module Pal
   end
 
   class ScriptCompiler < Compiler
-    # Returns the signature callable of the given plan (the arguments it accepts, and the data type it returns)
+    # Returns the signature of the given plan name
     # @param plan_name [String] the name of the plan to get the signature of
-    # @return [Puppet::Pops::Types::PCallableType, nil] returns a callable data type, or nil if plan is not found
+    # @return [Puppet::Pal::PlanSignature, nil] returns a PlanSignature, or nil if plan is not found
     #
     def plan_signature(plan_name)
       loader = internal_compiler.loaders.private_environment_loader
       if func = loader.load(:plan, plan_name)
-        return func.class.dispatcher.to_type
+        return PlanSignature.new(func)
       end
       # Could not find plan
       nil
     end
+
+    # Returns an array of TypedName objects for all plans, optionally filtered by a regular expression.
+    # The returned array has more information than just the leaf name - the typical thing is to just get
+    # the name as showing the following example.
+    #
+    # @example getting the names of all plans
+    #   compiler.list_plans.map {|tn| tn.name }
+    #
+    # @param filter_regex [Regexp] an optional regexp that filters based on name (matching names are included in the result)
+    # @return [Array<Puppet::Pops::Loader::TypedName>] an array of typed names
+    #
+    def list_plans(filter_regex = nil)
+      list_loadable_kind(:plan, filter_regex)
+    end
+
+    # Returns the signature callable of the given task (the arguments it accepts, and the data type it returns)
+    # @param task_name [String] the name of the task to get the signature of
+    # @return [Puppet::Pal::TaskSignature, nil] returns a TaskSignature, or nil if task is not found
+    #
+    def task_signature(task_name)
+      loader = internal_compiler.loaders.private_environment_loader
+      if task = loader.load(:task, task_name)
+        return TaskSignature.new(task)
+      end
+      # Could not find task
+      nil
+    end
+
+    # Returns an array of TypedName objects for all tasks, optionally filtered by a regular expression.
+    # The returned array has more information than just the leaf name - the typical thing is to just get
+    # the name as showing the following example.
+    #
+    # @example getting the names of all tasks
+    #   compiler.list_tasks.map {|tn| tn.name }
+    #
+    # @param filter_regex [Regexp] an optional regexp that filters based on name (matching names are included in the result)
+    # @return [Array<Puppet::Pops::Loader::TypedName>] an array of typed names
+    #
+    def list_tasks(filter_regex = nil)
+      list_loadable_kind(:task, filter_regex)
+    end
+  end
+
+  # A FunctionSignature is returned from `function_signature`. Its purpose is to answer questions about the function's parameters
+  # and if it can be called with a set of parameters.
+  #
+  # It is also possible to get an array of puppet Callable data type where each callable describes one possible way
+  # the function can be called.
+  #
+  # @api public
+  #
+  class FunctionSignature
+    # @api private
+    def initialize(function_class)
+      @func = function_class
+    end
+
+    # Returns true if the function can be called with the given arguments and false otherwise.
+    # If the function is not callable, and a code block is given, it is given a formatted error message that describes
+    # the type mismatch. That error message can be quite complex if the function has multiple dispatch depending on
+    # given types.
+    #
+    # @param args [Array] The arguments as given to the function call
+    # @param callable [Proc, nil] An optional ruby Proc or puppet lambda given to the function
+    # @yield [String] a formatted error message describing a type mismatch if the function is not callable with given args + block
+    # @return [Boolean] true if the function can be called with given args + block, and false otherwise
+    # @api public
+    #
+    def callable_with?(args, callable=nil)
+      signatures = @func.dispatcher.to_type
+      callables = signatures.is_a?(Puppet::Pops::Types::PVariantType) ? signatures.types : [signatures]
+
+      return true if callables.any? {|t| t.callable_with?(args) }
+      return false unless block_given?
+      args_type = Puppet::Pops::Types::TypeCalculator.singleton.infer_set(callable.nil? ? args : args + [callable])
+      error_message = Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(@func.name, @func.signatures, args_type)
+      yield error_message
+      false
+    end
+
+    # Returns an array of Callable puppet data type
+    # @return [Array<Puppet::Pops::Types::PCallableType] one callable per way the function can be called
+    #
+    # @api public
+    #
+    def callables
+      signatures = @func.dispatcher.to_type
+      signatures.is_a?(Puppet::Pops::Types::PVariantType) ? signatures.types : [signatures]
+    end
+  end
+
+  # A TaskSignature is returned from `task_signature`. Its purpose is to answer questions about the task's parameters
+  # and if it can be run/called with a hash of named parameters.
+  #
+  class TaskSignature
+    def initialize(task)
+      @task = task
+    end
+
+    # Returns whether or not the given arguments are acceptable when running the task.
+    # In addition to returning the boolean outcome, if a block is given, it is called with a string of formatted
+    # error messages that describes the difference between what was given and what is expected. The error message may
+    # have multiple lines of text, and each line is indented one space.
+    #
+    # @param args_hash [Hash] a hash mapping parameter names to argument values
+    # @yieldparam [String] a formatted error message if a type mismatch occurs that explains the mismatch
+    # @return [Boolean] if the given arguments are acceptable when running the task
+    #
+    def runnable_with?(args_hash)
+      params = @task.parameters
+      params_type = if params.nil?
+        T_GENERIC_TASK_HASH
+      else
+        key_to_type = {}
+        @task.parameters.each_pair { |k, v| key_to_type[k] = v['type'] }
+        Puppet::Pops::Types::TypeFactory.struct(key_to_type)
+      end
+      return true if params_type.instance?(args_hash)
+
+      if block_given?
+        tm = Puppet::Pops::Types::TypeMismatchDescriber.singleton
+        error = if params.nil?
+          tm.describe_mismatch('', params_type, Puppet::Pops::Types::TypeCalculator.infer_set(args_hash))
+        else
+          tm.describe_struct_signature(params_type, args_hash).flatten.map {|e| e.format }.join("\n")
+        end
+        yield "Task #{@task.name}:\n#{error}"
+      end
+      false
+    end
+
+    # Returns the Task instance as a hash
+    #
+    # @return [Hash{String=>Object}] the hash representation of the task
+    def task_hash
+      @task._pcore_init_hash
+    end
+
+    # Returns the Task instance which can be further explored. It contains all meta-data defined for
+    # the task such as the description, parameters, output, etc.
+    #
+    # @return [Puppet::Pops::Types::PuppetObject] An instance of a dynamically created Task class
+    def task
+      @task
+    end
+  end
+
+  # A PlanSignature is returned from `plan_signature`. Its purpose is to answer questions about the plans's parameters
+  # and if it can be called with a hash of named parameters.
+  #
+  # @api public
+  #
+  class PlanSignature
+    def initialize(plan_function)
+      @plan_func = plan_function
+    end
+
+    # Returns true or false depending on if the given PlanSignature is callable with a set of named arguments or not
+    # In addition to returning the boolean outcome, if a block is given, it is called with a string of formatted
+    # error messages that describes the difference between what was given and what is expected. The error message may
+    # have multiple lines of text, and each line is indented one space.
+    #
+    # @example Checking if signature is acceptable
+    #
+    #   signature = pal.plan_signature('myplan')
+    #   signature.callable_with?({x => 10}) { |errors| raise ArgumentError("Ooops: given arguments does not match\n#{errors}") }
+    #
+    # @api public
+    #
+    def callable_with?(args_hash)
+      dispatcher = @plan_func.class.dispatcher.dispatchers[0]
+
+      param_scope = {}
+      # Assign all non-nil values, even those that represent non-existent parameters.
+      args_hash.each { |k, v| param_scope[k] = v unless v.nil? }
+      dispatcher.parameters.each do |p|
+        name = p.name
+        arg = args_hash[name]
+        if arg.nil?
+          # Arg either wasn't given, or it was undef
+          if p.value.nil?
+            # No default. Assign nil if the args_hash included it
+            param_scope[name] = nil if args_hash.include?(name)
+          else
+            # parameter does not have a default value, it will be assigned its default when being called
+            # we assume that the default value is of the correct type and therefore simply skip
+            # checking this
+            # param_scope[name] = param_scope.evaluate(name, p.value, closure_scope, @evaluator)
+          end
+        end
+      end
+
+      errors = Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_struct_signature(dispatcher.params_struct, param_scope).flatten
+      return true if errors.empty?
+      if block_given?
+        yield errors.map {|e| e.format }.join("\n")
+      end
+      false
+    end
+
+    # Returns a PStructType describing the parameters as a puppet Struct data type
+    # Note that a `to_s` on the returned structure will result in a human readable Struct datatype as a
+    # description of what a plan expects.
+    #
+    # @return [Puppet::Pops::Types::PStructType] a struct data type describing the parameters and their types
+    #
+    # @api public
+    #
+    def params_type
+      dispatcher = @plan_func.class.dispatcher.dispatchers[0]
+      dispatcher.params_struct
+    end
   end
 
   # Defines a context in which multiple operations in an env with a script compiler can be performed in a given block.
@@ -571,6 +829,9 @@ module Pal
   T_ANY_ARRAY = Puppet::Pops::Types::TypeFactory.array_of_any
   T_BOOLEAN = Puppet::Pops::Types::PBooleanType::DEFAULT
 
+  T_GENERIC_TASK_HASH = Puppet::Pops::Types::TypeFactory.hash_kv(
+    Puppet::Pops::Types::TypeFactory.pattern(/\A[a-z][a-z0-9_]*\z/), Puppet::Pops::Types::TypeFactory.data)
+
   def self.assert_type(type, value, what, allow_nil=false)
     Puppet::Pops::Types::TypeAsserter.assert_instance_of(nil, type, value, allow_nil) { _('Puppet Pal: %{what}') % {what: what} }
   end