puppet 4.7.1-universal-darwin → 4.8.0-universal-darwin

data/lib/puppet/face/module/install.rb

@@ -21,7 +21,7 @@ Puppet::Face.define(:module, '1.0.0') do
 
       $ puppet module install puppetlabs-vcsrepo
       Preparing to install into /etc/puppetlabs/code/modules ...
-      Downloading from https://forgeapi.puppetlabs.com ...
+      Downloading from https://forgeapi.puppet.com ...
       Installing -- do not interrupt ...
       /etc/puppetlabs/code/modules
       └── puppetlabs-vcsrepo (v0.0.4)
@@ -30,7 +30,7 @@ Puppet::Face.define(:module, '1.0.0') do
 
       $ puppet module install puppetlabs-vcsrepo --environment development
       Preparing to install into /etc/puppetlabs/code/environments/development/modules ...
-      Downloading from https://forgeapi.puppetlabs.com ...
+      Downloading from https://forgeapi.puppet.com ...
       Installing -- do not interrupt ...
       /etc/puppetlabs/code/environments/development/modules
       └── puppetlabs-vcsrepo (v0.0.4)
@@ -39,7 +39,7 @@ Puppet::Face.define(:module, '1.0.0') do
 
       $ puppet module install puppetlabs-vcsrepo -v 0.0.4
       Preparing to install into /etc/puppetlabs/modules ...
-      Downloading from https://forgeapi.puppetlabs.com ...
+      Downloading from https://forgeapi.puppet.com ...
       Installing -- do not interrupt ...
       /etc/puppetlabs/code/modules
       └── puppetlabs-vcsrepo (v0.0.4)
@@ -48,7 +48,7 @@ Puppet::Face.define(:module, '1.0.0') do
 
       $ puppet module install puppetlabs-vcsrepo --target-dir=/opt/puppetlabs/puppet/modules
       Preparing to install into /opt/puppetlabs/puppet/modules ...
-      Downloading from https://forgeapi.puppetlabs.com ...
+      Downloading from https://forgeapi.puppet.com ...
       Installing -- do not interrupt ...
       /opt/puppetlabs/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
@@ -57,7 +57,7 @@ Puppet::Face.define(:module, '1.0.0') do
 
       $ puppet module install puppetlabs-vcsrepo --target-dir=/opt/puppetlabs/puppet/modules --modulepath /etc/puppetlabs/code/modules
       Preparing to install into /opt/puppetlabs/puppet/modules ...
-      Downloading from https://forgeapi.puppetlabs.com ...
+      Downloading from https://forgeapi.puppet.com ...
       Installing -- do not interrupt ...
       /opt/puppetlabs/puppet/modules
       └── puppetlabs-vcsrepo (v0.0.4)
@@ -66,7 +66,7 @@ Puppet::Face.define(:module, '1.0.0') do
 
       $ puppet module install puppetlabs-vcsrepo-0.0.4.tar.gz
       Preparing to install into /etc/puppetlabs/code/modules ...
-      Downloading from https://forgeapi.puppetlabs.com ...
+      Downloading from https://forgeapi.puppet.com ...
       Installing -- do not interrupt ...
       /etc/puppetlabs/code/modules
       └── puppetlabs-vcsrepo (v0.0.4)

data/lib/puppet/functions.rb

@@ -162,7 +162,7 @@ module Puppet::Functions
   end
 
   # Creates a function in, or in a local loader under the given loader.
-  # This method should only be used when manually creating functions 
+  # This method should only be used when manually creating functions
   # for the sake of testing. Functions that are autoloaded should
   # always use the `create_function` method and the autoloader will supply
   # the correct loader.
@@ -258,8 +258,8 @@ module Puppet::Functions
   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.any, from, to), names]
+    param_types = Puppet::Pops::Types::PTupleType.new([Puppet::Pops::Types::PAnyType::DEFAULT], Puppet::Pops::Types::PIntegerType.new(from, to))
+    [Puppet::Pops::Types::PCallableType.new(param_types), names]
   end
 
   # Function
@@ -272,8 +272,7 @@ module Puppet::Functions
 
     # @api private
     def self.builder
-      @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
-      DispatcherBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, @all_callables, loader)
+      DispatcherBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
     end
 
     # Dispatch any calls that match the signature to the provided method name.
@@ -310,7 +309,7 @@ module Puppet::Functions
         t = Puppet::Pops::Loader::TypeDefinitionInstantiator.create_from_model(type_alias_expr, aliases.loader)
 
         # Also define a method for convenient access to the defined type alias.
-        # Since initial capital letter in Ruby means a Constant these names use a prefix of 
+        # Since initial capital letter in Ruby means a Constant these names use a prefix of
         # `type`. As an example, the type 'MyType' is accessed by calling `type_MyType`.
         define_method("type_#{t.name}") { t }
       end
@@ -466,6 +465,15 @@ module Puppet::Functions
       @block_type = Puppet::Pops::Types::TypeFactory.optional(@block_type)
     end
 
+    # Defines the return type. Defaults to 'Any'
+    # @param [String] type a reference to a Puppet Data Type
+    #
+    # @api public
+    def return_type(type)
+      raise ArgumentError, "Argument to 'return_type' must be a String reference to a Puppet Data Type. Got #{type.class}" unless type.is_a?(String)
+      @return_type = type
+    end
+
     private
 
     # @api private
@@ -505,8 +513,9 @@ module Puppet::Functions
       @max = 0
       @block_type = nil
       @block_name = nil
+      @return_type = nil
       self.instance_eval &block
-      callable_t = create_callable(@types, @block_type, @min, @max)
+      callable_t = create_callable(@types, @block_type, @return_type, @min, @max)
       @dispatcher.add_dispatch(callable_t, meth_name, @names, @block_name, @injections, @weaving, @max == :default)
     end
 
@@ -516,28 +525,19 @@ module Puppet::Functions
     # Optional[Callable], Callable, or nil.
     #
     # @api private
-    def create_callable(types, block_type, from, to)
+    def create_callable(types, block_type, return_type, from, to)
       mapped_types = types.map do |t|
         @type_parser.parse(t, loader)
       end
-
-      if from == 0 || from != to
-        # :optional and/or :repeated parameters are present.
-        mapped_types << from
-        mapped_types << to
-      end
-
-      if block_type
-        mapped_types << block_type
-      end
-
-      Puppet::Pops::Types::TypeFactory.callable(*mapped_types)
+      param_types = Puppet::Pops::Types::PTupleType.new(mapped_types, from > 0 && from == to ? nil : Puppet::Pops::Types::PIntegerType.new(from, to))
+      return_type = @type_parser.parse(return_type, loader) unless return_type.nil?
+      Puppet::Pops::Types::PCallableType.new(param_types, block_type, return_type)
     end
   end
 
   # The LocalTypeAliasBuilder is used by the 'local_types' method to collect the individual
   # type aliases given by the function's author.
-  # 
+  #
   class LocalTypeAliasesBuilder
     attr_reader :local_types, :parser, :loader
 
@@ -552,7 +552,7 @@ module Puppet::Functions
     # in string form without the leading 'type' keyword.
     # Calls to local_type must be made before the first parameter definition or an error will
     # be raised.
-    # 
+    #
     # @param assignment_string [String] a string on the form 'AliasType = ExistingType'
     # @api public
     #
@@ -601,8 +601,7 @@ module Puppet::Functions
   class InternalFunction < Function
     # @api private
     def self.builder
-      @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
-      InternalDispatchBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, @all_callables, loader)
+      InternalDispatchBuilder.new(dispatcher, Puppet::Pops::Types::TypeParser.singleton, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
     end
 
     # Defines class level injected attribute with reader method

data/lib/puppet/functions/alert.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level alert.
+Puppet::Functions.create_function(:alert, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :alert do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def alert(scope, *values)
+    Puppet::Util::Log.log_func(scope, :alert, values)
+  end
+end

data/lib/puppet/functions/binary_file.rb

@@ -0,0 +1,25 @@
+# Loads a binary file from a module or file system and returns its contents as a Binary.
+# (Documented in 3.x stub)
+#
+# @since 4.8.0
+#
+Puppet::Functions.create_function(:binary_file, Puppet::Functions::InternalFunction) do
+  dispatch :binary_file do
+    scope_param
+    param 'String', :path
+  end
+
+  def binary_file(scope, unresolved_path)
+    path = nil
+    found = Puppet::Parser::Files.find_file(unresolved_path, scope.compiler.environment)
+    if found && Puppet::FileSystem.exist?(found)
+      path = found
+    end
+
+    if path
+      Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(Puppet::FileSystem.binread(path))
+    else
+      raise Puppet::ParseError, "binary_file(): The given file '#{path}' does not exist"
+    end
+  end
+end

data/lib/puppet/functions/break.rb

@@ -0,0 +1,22 @@
+# Make iteration break as if there were no more values to process
+#
+# @since 4.7.0
+#
+Puppet::Functions.create_function(:break) do
+  dispatch :break_impl do
+  end
+
+  def break_impl()
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+    # PuppetStopIteration contains file and line and is a StopIteration exception
+    # so it can break a Ruby Kernel#loop or enumeration
+    #
+    raise Puppet::Pops::Evaluator::PuppetStopIteration.new(file, line)
+  end
+end

data/lib/puppet/functions/contain.rb

@@ -0,0 +1,33 @@
+# Called within a class definition, establishes a containment
+# relationship with another class
+# For documentation, see the 3.x stub
+#
+Puppet::Functions.create_function(:contain, Puppet::Functions::InternalFunction) do
+  dispatch :contain do
+    scope_param
+    # The function supports what the type system sees as Ruby runtime objects, and
+    # they cannot be parameterized to find what is actually valid instances.
+    # The validation is instead done in the function body itself via a call to
+    # `transform_and_assert_classnames` on the calling scope.
+    required_repeated_param 'Any', :names
+  end
+
+  def contain(scope, *classes)
+    # Make call patterns uniform and protected against nested arrays, also make
+    # names absolute if so desired.
+    classes = scope.transform_and_assert_classnames(classes.flatten)
+
+    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+    containing_resource = scope.resource
+
+    # This is the same as calling the include function but faster and does not rely on the include
+    # function.
+    (scope.compiler.evaluate_classes(classes, scope, false) || []).each do |resource|
+      if ! scope.catalog.edge?(containing_resource, resource)
+        scope.catalog.add_edge(containing_resource, resource)
+      end
+    end
+    # Result is an Array[Class, 1, n] which allows chaining other operations
+    result
+  end
+end

data/lib/puppet/functions/crit.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level crit.
+Puppet::Functions.create_function(:crit, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :crit do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def crit(scope, *values)
+    Puppet::Util::Log.log_func(scope, :crit, values)
+  end
+end

data/lib/puppet/functions/debug.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level debug.
+Puppet::Functions.create_function(:debug, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :debug do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def debug(scope, *values)
+    Puppet::Util::Log.log_func(scope, :debug, values)
+  end
+end

data/lib/puppet/functions/emerg.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level emerg.
+Puppet::Functions.create_function(:emerg, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :emerg do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def emerg(scope, *values)
+    Puppet::Util::Log.log_func(scope, :emerg, values)
+  end
+end

data/lib/puppet/functions/epp.rb

@@ -18,7 +18,7 @@
 # template and pass the `docroot` and `virtual_docroot` parameters, call the `epp`
 # function like this:
 #
-# `epp('apache/templates/vhost/_docroot.epp', { 'docroot' => '/var/www/html',
+# `epp('apache/vhost/_docroot.epp', { 'docroot' => '/var/www/html',
 # 'virtual_docroot' => '/var/www/example' })`
 #
 # Puppet produces a syntax error if you pass more parameters than are declared in

data/lib/puppet/functions/err.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level err.
+Puppet::Functions.create_function(:err, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :err do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def err(scope, *values)
+    Puppet::Util::Log.log_func(scope, :err, values)
+  end
+end

data/lib/puppet/functions/find_file.rb

@@ -0,0 +1,31 @@
+# Finds an existing file from a module and returns its path.
+# (Documented in 3.x stub)
+#
+# @since 4.8.0
+#
+Puppet::Functions.create_function(:find_file, Puppet::Functions::InternalFunction) do
+  dispatch :find_file do
+    scope_param
+    repeated_param 'String', :paths
+  end
+
+  dispatch :find_file_array do
+    scope_param
+    repeated_param 'Array[String]', :paths_array
+  end
+
+  def find_file_array(scope, array)
+    find_file(scope, *array)
+  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)
+        return found
+      end
+    end
+    nil
+  end
+end

data/lib/puppet/functions/include.rb

@@ -0,0 +1,21 @@
+# Include the specified classes
+# For documentation see the 3.x stub
+Puppet::Functions.create_function(:include, Puppet::Functions::InternalFunction) do
+  dispatch :include do
+    scope_param
+    # The function supports what the type system sees as Ruby runtime objects, and
+    # they cannot be parameterized to find what is actually valid instances.
+    # The validation is instead done in the function body itself via a call to
+    # `transform_and_assert_classnames` on the calling scope.
+    required_repeated_param 'Any', :names
+  end
+
+  def include(scope, *classes)
+    classes = scope.transform_and_assert_classnames(classes.flatten)
+    result = classes.map {|name| Puppet::Pops::Types::TypeFactory.host_class(name) }
+    scope.compiler.evaluate_classes(classes, scope, false)
+
+    # Result is an Array[Class, 1, n] which allows chaining other operations
+    result
+  end
+end

data/lib/puppet/functions/info.rb

@@ -0,0 +1,14 @@
+# Log a message on the server at level info.
+Puppet::Functions.create_function(:info, Puppet::Functions::InternalFunction) do
+  # @param values The values to log.
+  # @return [Undef]
+  dispatch :info do
+    scope_param
+    repeated_param 'Any', :values
+    return_type 'Undef'
+  end
+
+  def info(scope, *values)
+    Puppet::Util::Log.log_func(scope, :info, values)
+  end
+end

data/lib/puppet/functions/new.rb

@@ -26,6 +26,6 @@ Puppet::Functions.create_function(:new, Puppet::Functions::InternalFunction) do
   end
 
   def assert_type(type, value)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of('new():', type, value)
+    Puppet::Pops::Types::TypeAsserter.assert_instance_of(['Converted value from %s.new()', type], type, value)
   end
 end

data/lib/puppet/functions/next.rb

@@ -0,0 +1,23 @@
+# Make iteration continue with the next value optionally given a value for this iteration.
+# If a value is not given it defaults to `undef`
+#
+# @since 4.7.0
+#
+Puppet::Functions.create_function(:next) do
+  dispatch :next_impl do
+    optional_param 'Any', :value
+  end
+
+  def next_impl(value = nil)
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+
+    exc = Puppet::Pops::Evaluator::Next.new(value, file, line)
+    raise exc
+  end
+end