puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/forge.rb

@@ -54,6 +54,9 @@ class Puppet::Forge < Semantic::Dependency::Source
   def search(term)
     matches = []
     uri = "/v3/modules?query=#{URI.escape(term)}"
+    if Puppet[:module_groups]
+      uri += "&module_groups=#{Puppet[:module_groups]}"
+    end
 
     while uri
       response = make_http_request(uri)
@@ -63,7 +66,7 @@ class Puppet::Forge < Semantic::Dependency::Source
         uri = result['pagination']['next']
         matches.concat result['results']
       else
-        raise ResponseError.new(:uri => URI.parse(@host).merge(uri) , :input => term, :response => response)
+        raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :response => response)
       end
     end
 
@@ -86,6 +89,9 @@ class Puppet::Forge < Semantic::Dependency::Source
   def fetch(input)
     name = input.tr('/', '-')
     uri = "/v3/releases?module=#{name}"
+    if Puppet[:module_groups]
+      uri += "&module_groups=#{Puppet[:module_groups]}"
+    end
     releases = []
 
     while uri
@@ -94,7 +100,7 @@ class Puppet::Forge < Semantic::Dependency::Source
       if response.code == '200'
         response = JSON.parse(response.body)
       else
-        raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :input => input, :response => response)
+        raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :response => response)
       end
 
       releases.concat(process(response['results']))
@@ -119,9 +125,17 @@ class Puppet::Forge < Semantic::Dependency::Source
       version = Semantic::Version.parse(meta['version'])
       release = "#{name}@#{version}"
 
-      dependencies = (meta['dependencies'] || [])
-      dependencies.map! do |dep|
-        Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
+      if meta['dependencies']
+        dependencies = meta['dependencies'].collect do |dep|
+          begin
+            Puppet::ModuleTool::Metadata.new.add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
+            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
+          rescue ArgumentError => e
+            raise ArgumentError, "Malformed dependency: #{dep['name']}. Exception was: #{e}"
+          end
+        end
+      else
+        dependencies = []
       end
 
       super(source, name, version, Hash[dependencies])
@@ -172,8 +186,11 @@ class Puppet::Forge < Semantic::Dependency::Source
     end
 
     def download(uri, destination)
-      @source.make_http_request(uri, destination)
+      response = @source.make_http_request(uri, destination)
       destination.flush and destination.close
+      unless response.code == '200'
+        raise Puppet::Forge::Errors::ResponseError.new(:uri => uri, :response => response)
+      end
     end
 
     def validate_checksum(file, checksum)
@@ -194,6 +211,16 @@ class Puppet::Forge < Semantic::Dependency::Source
   private
 
   def process(list)
-    list.map { |release| ModuleRelease.new(self, release) }
+    l = list.map do |release|
+      metadata = release['metadata']
+      begin
+        ModuleRelease.new(self, release)
+      rescue ArgumentError => e
+        Puppet.warning "Cannot consider release #{metadata['name']}-#{metadata['version']}: #{e}"
+        false
+      end
+    end
+
+    l.select { |r| r }
   end
 end

data/lib/puppet/forge/errors.rb

@@ -77,7 +77,6 @@ Could not connect to #{@uri}
     # @option options [Net::HTTPResponse] :response The original HTTP response
     def initialize(options)
       @uri     = options[:uri]
-      @input   = options[:input]
       @message = options[:message]
       response = options[:response]
       @response = "#{response.code} #{response.message.strip}"
@@ -90,7 +89,7 @@ Could not connect to #{@uri}
       rescue JSON::ParserError
       end
 
-      message = "Could not execute operation for '#{@input}'. Detail: "
+      message = "Request to Puppet Forge failed. Detail: "
       message << @message << " / " if @message
       message << @response << "."
       super(message, original)
@@ -100,13 +99,13 @@ Could not connect to #{@uri}
     #
     # @return [String] the multiline version of the error message
     def multiline
-      message = <<-EOS
-Could not execute operation for '#{@input}'
+      message = <<-EOS.chomp
+Request to Puppet Forge failed.
   The server being queried was #{@uri}
   The HTTP response we received was '#{@response}'
       EOS
-      message << "  The message we received said '#{@message}'\n" if @message
-      message << "    Check the author and module names are correct."
+      message << "\n  The message we received said '#{@message}'" if @message
+      message
     end
   end
 

data/lib/puppet/forge/repository.rb

@@ -52,6 +52,14 @@ class Puppet::Forge
       return read_response(request, io)
     end
 
+    def forge_authorization
+      if Puppet[:forge_authorization]
+        Puppet[:forge_authorization]
+      elsif Puppet.features.pe_license?
+        PELicense.load_license_key.authorization_token
+      end
+    end
+
     def get_request_object(path)
       headers = {
         "User-Agent" => user_agent,
@@ -63,9 +71,13 @@ class Puppet::Forge
         })
       end
 
+      if forge_authorization
+        headers = headers.merge({"Authorization" => forge_authorization})
+      end
+
       request = Net::HTTP::Get.new(URI.escape(path), headers)
 
-      unless @uri.user.nil? || @uri.password.nil?
+      unless @uri.user.nil? || @uri.password.nil? || forge_authorization
         request.basic_auth(@uri.user, @uri.password)
       end
 
@@ -121,7 +133,7 @@ class Puppet::Forge
     #
     # @return [Net::HTTP::Proxy] object constructed from repo settings
     def get_http_object
-      proxy_class = Net::HTTP::Proxy(Puppet::Util::HttpProxy.http_proxy_host, Puppet::Util::HttpProxy.http_proxy_port)
+      proxy_class = Net::HTTP::Proxy(Puppet::Util::HttpProxy.http_proxy_host, Puppet::Util::HttpProxy.http_proxy_port, Puppet::Util::HttpProxy.http_proxy_user, Puppet::Util::HttpProxy.http_proxy_password)
       proxy = proxy_class.new(@uri.host, @uri.port)
 
       if @uri.scheme == 'https'

data/lib/puppet/functions.rb

@@ -80,7 +80,7 @@
 #
 # If nothing is specified, the number of arguments given to the function must
 # be the same as the number of parameters, and all of the parameters are of
-# type 'Object'.
+# type 'Any'.
 #
 # To express that the last parameter captures the rest, the method
 # `last_captures_rest` can be called. This indicates that the last parameter is
@@ -179,7 +179,7 @@ module Puppet::Functions
     unless the_class.method_defined?(func_name)
       raise ArgumentError, "Function Creation Error, cannot create a default dispatcher for function '#{func_name}', no method with this name found"
     end
-    object_signature(*min_max_param(the_class.instance_method(func_name)))
+    any_signature(*min_max_param(the_class.instance_method(func_name)))
   end
 
   # @api private
@@ -208,14 +208,14 @@ module Puppet::Functions
   end
 
   # Construct a signature consisting of Object type, with min, and max, and given names.
-  # (there is only one type entry). Note that this signature is Object, not Optional[Object].
+  # (there is only one type entry).
   #
   # @api private
-  def self.object_signature(from, to, names)
+  def self.any_signature(from, to, names)
     # Construct the type for the signature
     # Tuple[Object, from, to]
     factory = Puppet::Pops::Types::TypeFactory
-    [factory.callable(factory.object, from, to), names]
+    [factory.callable(factory.any, from, to), names]
   end
 
   # Function
@@ -288,10 +288,12 @@ module Puppet::Functions
     def required_block_param(*type_and_name)
       case type_and_name.size
       when 0
-        type = @all_callables
+        # the type must be an independent instance since it will be contained in another type
+        type = @all_callables.copy
         name = 'block'
       when 1
-        type = @all_callables
+        # the type must be an independent instance since it will be contained in another type
+        type = @all_callables.copy
         name = type_and_name[0]
       when 2
         type_string, name = type_and_name
@@ -300,12 +302,12 @@ module Puppet::Functions
         raise ArgumentError, "block_param accepts max 2 arguments (type, name), got #{type_and_name.size}."
       end
 
-      unless type.is_a?(Puppet::Pops::Types::PCallableType)
-        raise ArgumentError, "Expected PCallableType, got #{type.class}"
+      unless Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(type, false)
+        raise ArgumentError, "Expected PCallableType or PVariantType thereof, got #{type.class}"
       end
 
-      unless name.is_a?(String)
-        raise ArgumentError, "Expected block_param name to be a String, got #{name.class}"
+      unless name.is_a?(String) || name.is_a?(Symbol)
+        raise ArgumentError, "Expected block_param name to be a String or Symbol, got #{name.class}"
       end
 
       if @block_type.nil?
@@ -329,7 +331,7 @@ module Puppet::Functions
 
     # Specifies the min and max occurance of arguments (of the specified types)
     # if something other than the exact count from the number of specified
-    # types). The max value may be specified as -1 if an infinite number of
+    # types). The max value may be specified as :default if an infinite number of
     # arguments are supported. When max is > than the number of specified
     # types, the last specified type repeats.
     #
@@ -527,6 +529,11 @@ module Puppet::Functions
   #
   # @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]
+    end
     # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
     #
     # @api private

data/lib/puppet/functions/assert_type.rb

@@ -1,39 +1,56 @@
 # Returns the given value if it is an instance of the given type, and raises an error otherwise.
+# Optionally, if a block is given (accepting two parameters), it will be called instead of raising
+# an error. This to enable giving the user richer feedback, or to supply a default value.
 #
 # @example how to assert type
 #   # assert that `$b` is a non empty `String` and assign to `$a`
 #   $a = assert_type(String[1], $b)
 #
+# @example using custom error message
+#   $a = assert_type(String[1], $b) |$expected, $actual| { fail("The name cannot be empty") }
+#
+# @example using a warning and a default
+#   $a = assert_type(String[1], $b) |$expected, $actual| { warning("Name is empty, using default") 'anonymous' }
+#
 # See the documentation for "The Puppet Type System" for more information about types.
 #
 Puppet::Functions.create_function(:assert_type) do
   dispatch :assert_type do
     param 'Type', 'type'
-    param 'Optional[Object]', 'value'
+    param 'Any', 'value'
+    optional_block_param 'Callable[Type, Type]', 'block'
   end
 
   dispatch :assert_type_s do
     param 'String', 'type_string'
-    param 'Optional[Object]', 'value'
+    param 'Any', 'value'
+    optional_block_param 'Callable[Type, Type]', 'block'
   end
 
   # @param type [Type] the type the value must be an instance of
-  # @param value [Optional[Object]] the value to assert
+  # @param value [Object] the value to assert
   #
-  def assert_type(type, value)
+  def assert_type(type, value, block=nil)
     unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
       inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value)
-      # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
-      # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
-      #
-      actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
-      raise Puppet::ParseError, "assert_type(): Expected type #{type} does not match actual: #{actual}"
+      if block
+        # Give the inferred type to allow richer comparisson in the given block (if generalized
+        # information is lost).
+        #
+        value = block.call(nil, type, inferred_type)
+      else
+        # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
+        # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
+        #
+        actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
+        raise Puppet::ParseError, "assert_type(): Expected type #{type} does not match actual: #{actual}"
+      end
     end
     value
   end
 
   # @param type_string [String] the type the value must be an instance of given in String form
-  # @param value [Optional[Object]] the value to assert
+  # @param value [Object] the value to assert
   #
   def assert_type_s(type_string, value)
     t = Puppet::Pops::Types::TypeParser.new.parse(type_string)

data/lib/puppet/functions/each.rb

@@ -0,0 +1,111 @@
+#  Applies a parameterized block to each element in a sequence of selected entries from the first
+#  argument and returns the first argument.
+#
+# This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
+# of enumerable type (integer, Integer range, or String), and the second
+# a parameterized block as produced by the puppet syntax:
+#
+#       $a.each |$x| { ... }
+#       each($a) |$x| { ... }
+#
+# When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
+# should define one or two block parameters.
+# For each application of the block, the next element from the array is selected, and it is passed to
+# the block if the block has one parameter. If the block has two parameters, the first is the elements
+# index, and the second the value. The index starts from 0.
+#
+#       $a.each |$index, $value| { ... }
+#       each($a) |$index, $value| { ... }
+#
+# When the first argument is a Hash, the parameterized block should define one or two parameters.
+# When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
+# and when two parameters are defined the iteration is performed with key and value.
+#
+#       $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
+#       $a.each |$key, $value| { ..."key ${key}, value ${value}" }
+#
+# @example using each
+#
+#       [1,2,3].each |$val| { ... }                       # 1, 2, 3
+#       [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
+#       {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
+#       {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
+#       Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
+#       "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
+#       3.each |$number| { ... }                          # 0, 1, 2
+#
+# @since 3.2 for Array and Hash
+# @since 3.5 for other enumerables
+# @note requires `parser = future`
+#
+Puppet::Functions.create_function(:each) do
+  dispatch :foreach_Hash_2 do
+    param 'Hash[Any, Any]', :hash
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :foreach_Hash_1 do
+    param 'Hash[Any, Any]', :hash
+    required_block_param 'Callable[1,1]', :block
+  end
+
+  dispatch :foreach_Enumerable_2 do
+    param 'Any', :enumerable
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :foreach_Enumerable_1 do
+    param 'Any', :enumerable
+    required_block_param 'Callable[1,1]', :block
+  end
+
+  def foreach_Hash_1(hash, pblock)
+    enumerator = hash.each_pair
+    hash.size.times do
+      pblock.call(nil, enumerator.next)
+    end
+    # produces the receiver
+    hash
+  end
+
+  def foreach_Hash_2(hash, pblock)
+    enumerator = hash.each_pair
+    hash.size.times do
+      pblock.call(nil, *enumerator.next)
+    end
+    # produces the receiver
+    hash
+  end
+
+  def foreach_Enumerable_1(enumerable, pblock)
+    enum = asserted_enumerable(enumerable)
+      begin
+        loop { pblock.call(nil, enum.next) }
+      rescue StopIteration
+      end
+    # produces the receiver
+    enumerable
+  end
+
+  def foreach_Enumerable_2(enumerable, pblock)
+    enum = asserted_enumerable(enumerable)
+    index = 0
+    begin
+      loop do
+        pblock.call(nil, index, enum.next)
+        index += 1
+      end
+    rescue StopIteration
+    end
+    # produces the receiver
+    enumerable
+  end
+
+  def asserted_enumerable(obj)
+    unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
+      raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
+    end
+    enum
+  end
+
+end

data/lib/puppet/functions/epp.rb

@@ -0,0 +1,54 @@
+# Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
+#
+# The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
+# reference, which will load `<TEMPLATE FILE>` from a module's `templates`
+# directory. (For example, the reference `apache/vhost.conf.epp` will load the
+# file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
+#
+# The second argument is optional; if present, it should be a hash containing parameters for the
+# template. (See below.)
+#
+# EPP supports the following tags:
+#
+# * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
+# * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
+# * `<%# comment %>` - The tag and its content renders nothing.
+# * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
+# * `<%-` - Same as `<%` but suppresses any leading whitespace.
+# * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
+# * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
+#
+# File based EPP supports the following visibilities of variables in scope:
+#
+# * Global scope (i.e. top + node scopes) - global scope is always visible
+# * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
+# * Global + declared parameters - if the EPP declares parameters, given argument names must match
+#
+# EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
+# `<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
+# given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
+# defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
+# Note that `<%-` must be used or any leading whitespace will be interpreted as text
+#
+# Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
+# are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
+# (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
+# Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
+# scope where the `epp` function is called from.
+#
+# @see function inline_epp for examples of EPP
+# @since 3.5
+# @note Requires Future Parser
+Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do
+
+  dispatch :epp do
+    scope_param()
+    param 'String', 'path'
+    param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
+    arg_count(1, 2)
+  end
+
+  def epp(scope, path, parameters = nil)
+    Puppet::Pops::Evaluator::EppEvaluator.epp(scope, path, scope.compiler.environment, parameters)
+  end
+end