puppet-debugger 0.10.3 → 0.11.0

data/spec/fixtures/modules/extlib/Rakefile

@@ -0,0 +1,82 @@
+require 'puppetlabs_spec_helper/rake_tasks'
+
+# load optional tasks for releases
+# only available if gem group releases is installed
+begin
+  require 'voxpupuli/release/rake_tasks'
+rescue LoadError
+end
+
+PuppetLint.configuration.log_format = '%{path}:%{line}:%{check}:%{KIND}:%{message}'
+PuppetLint.configuration.absolute_classname_reverse = true
+
+exclude_paths = %w(
+  pkg/**/*
+  vendor/**/*
+  .vendor/**/*
+  spec/**/*
+)
+PuppetLint.configuration.ignore_paths = exclude_paths
+PuppetSyntax.exclude_paths = exclude_paths
+
+desc 'Auto-correct puppet-lint offenses'
+task 'lint:auto_correct' do
+  Rake::Task[:lint_fix].invoke
+end
+
+desc 'Run acceptance tests'
+RSpec::Core::RakeTask.new(:acceptance) do |t|
+  t.pattern = 'spec/acceptance'
+end
+
+desc 'Run tests'
+task test: [:release_checks]
+
+namespace :check do
+  desc 'Check for trailing whitespace'
+  task :trailing_whitespace do
+    Dir.glob('**/*.md', File::FNM_DOTMATCH).sort.each do |filename|
+      next if filename =~ %r{^((modules|acceptance|\.?vendor|spec/fixtures|pkg)/|REFERENCE.md)}
+      File.foreach(filename).each_with_index do |line, index|
+        if line =~ %r{\s\n$}
+          puts "#{filename} has trailing whitespace on line #{index + 1}"
+          exit 1
+        end
+      end
+    end
+  end
+end
+Rake::Task[:release_checks].enhance ['check:trailing_whitespace']
+
+desc "Run main 'test' task and report merged results to coveralls"
+task test_with_coveralls: [:test] do
+  if Dir.exist?(File.expand_path('../lib', __FILE__))
+    require 'coveralls/rake/task'
+    Coveralls::RakeTask.new
+    Rake::Task['coveralls:push'].invoke
+  else
+    puts 'Skipping reporting to coveralls.  Module has no lib dir'
+  end
+end
+
+desc 'Generate REFERENCE.md'
+task :reference, [:debug, :backtrace] do |t, args|
+  patterns = 'lib/puppet/functions/extlib/*.rb functions/*.pp'
+  Rake::Task['strings:generate:reference'].invoke(patterns, args[:debug], args[:backtrace])
+end
+
+begin
+  require 'github_changelog_generator/task'
+  GitHubChangelogGenerator::RakeTask.new :changelog do |config|
+    version = (Blacksmith::Modulefile.new).version
+    config.future_release = "v#{version}" if version =~ /^\d+\.\d+.\d+$/
+    config.header = "# Changelog\n\nAll notable changes to this project will be documented in this file.\nEach new release typically also includes the latest modulesync defaults.\nThese should not affect the functionality of the module."
+    config.exclude_labels = %w{duplicate question invalid wontfix wont-fix modulesync skip-changelog}
+    config.user = 'voxpupuli'
+    metadata_json = File.join(File.dirname(__FILE__), 'metadata.json')
+    metadata = JSON.load(File.read(metadata_json))
+    config.project = metadata['name']
+  end
+rescue LoadError
+end
+# vim: syntax=ruby

data/spec/fixtures/modules/extlib/functions/dir_split.pp

@@ -0,0 +1,25 @@
+# @summary Splits the given directory or directories into individual paths.
+#
+# Use this function when you need to split a absolute path into multiple absolute paths
+# that all descend from the given path.
+#
+# @param dirs [Variant[Stdlib::Absolutepath, Array[Stdlib::Absolutepath]]] - either an absolute path or a array of absolute paths.
+# @return [Array[String]] - an array of absolute paths after being cut into individual paths.
+# @example calling the function
+#  extlib::dir_split('/opt/puppetlabs') => ['/opt', '/opt/puppetlabs']
+function extlib::dir_split(Variant[Stdlib::Absolutepath, Array[Stdlib::Absolutepath]] $dirs) >> Array[String] {
+  $sep = extlib::file_separator()
+
+  $dirs_array = [$dirs].flatten.unique.map | Stdlib::Absolutepath $dir | {
+    $dir.split(shell_escape($sep)).reduce([]) |Array $acc, $value  | {
+        $counter = $acc.length - 1
+        $acc_value = ($acc[$counter] =~ Undef) ? { true => '', false => $acc[$counter] }
+        unless empty($value) {
+          $acc + extlib::path_join([$acc_value, $value])
+        } else {
+          $acc
+        }
+      }
+  }
+  $dirs_array.flatten.unique
+}

data/spec/fixtures/modules/extlib/functions/file_separator.pp

@@ -0,0 +1,7 @@
+# @summary Returns the os specific file path separator.
+# @return [String] - The os specific path separator.
+# @example Example of how to use
+#  extlib::file_separator() => '/'
+function extlib::file_separator() >> String {
+  ($::facts['kernel'] == 'windows' ) ? { true => "\\", false => '/' }
+}

data/spec/fixtures/modules/extlib/functions/mkdir_p.pp

@@ -0,0 +1,20 @@
+# @summary Like the unix command mkdir_p except with puppet code.
+# This creates file resources for all directories and utilizes the dir_split() function
+# to get a list of all the descendant directories.  You will have no control over any other parameters
+# for the file resource.  If you wish to control the file resources you can use the dir_split() function
+# and get an array of directories for use in your own code.  Please note this does not use an exec resource.
+#
+# @param dirs [Variant[Stdlib::Absolutepath, Array[Stdlib::Absolutepath]]] - the path(s) to create
+# @return [Array[Stdlib::Absolutepath]]
+# @example How to use
+#  extlib::mkdir_p('/opt/puppetlabs/bin') => ['/opt', '/opt/puppetlabs', '/opt/puppetlabs/bin']
+# @note splits the given directories into paths that are then created using file resources
+# @note if you wish to create the directories manually you can use the extlib::dir_split() function in the same manner
+function extlib::mkdir_p(Variant[Stdlib::Absolutepath, Array[Stdlib::Absolutepath]] $dirs) >> Array[Stdlib::Absolutepath] {
+  $dirs_array = extlib::dir_split($dirs)
+  @file{$dirs_array:
+    ensure => directory,
+  }
+  realize(File[$dirs_array])
+  $dirs_array
+}

data/spec/fixtures/modules/extlib/functions/path_join.pp

@@ -0,0 +1,29 @@
+# @summary Take one or more paths and join them together using the os specific separator.
+# Because in how windows uses a different separator this function
+# will format a windows path into a equilivent unix like path.  This type of unix like
+# path will work on windows.
+#
+# @param dirs Joins two or more directories by file separator.
+# @return [Stdlib::Absolutepath] The joined path
+# @example Joining Unix paths to return `/tmp/test/libs`
+#   extlib::path_join('/tmp', 'test', 'libs')
+# @example Joining Windows paths to return `/c/test/libs`
+#   extlib::path_join('c:', 'test', 'libs')
+function extlib::path_join(Array[String] $dirs) >> Stdlib::Absolutepath {
+  $unix_sep = '/'
+  $sep_regex = /\/|\\/
+  $first_value = $dirs[0]
+  # when first value is absolute path, append all other elements
+  # by breaking the path into pieces first, then joining
+  if $first_value =~ Stdlib::Absolutepath {
+    $fixed_dirs = $first_value.split($sep_regex) + $dirs.delete($first_value)
+  } else {
+    $fixed_dirs = $dirs
+  }
+  $no_empty_dirs = $fixed_dirs.filter |$dir| { !empty($dir) }
+  $dirs_without_sep = $no_empty_dirs.map |String $dir | {
+    # remove : and file separator
+    $dir.regsubst($sep_regex, '').regsubst(':', '')
+  }
+  join([$unix_sep,$dirs_without_sep.join($unix_sep)])
+}

data/spec/fixtures/modules/extlib/lib/puppet/functions/cache_data.rb

@@ -0,0 +1,11 @@
+# @summary DEPRECATED.  Use the namespaced function [`extlib::cache_data`](#extlibcache_data) instead.
+# DEPRECATED.  Use the namespaced function [`extlib::cache_data`](#extlibcache_data) instead.
+Puppet::Functions.create_function(:cache_data) do
+  dispatch :deprecation_gen do
+    repeated_param 'Any', :args
+  end
+  def deprecation_gen(*args)
+    call_function('deprecation', 'cache_data', 'This method is deprecated, please use extlib::cache_data instead.')
+    call_function('extlib::cache_data', *args)
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/default_content.rb

@@ -0,0 +1,11 @@
+# @summary DEPRECATED.  Use the namespaced function [`extlib::default_content`](#extlibdefault_content) instead.
+# DEPRECATED.  Use the namespaced function [`extlib::default_content`](#extlibdefault_content) instead.
+Puppet::Functions.create_function(:default_content) do
+  dispatch :deprecation_gen do
+    repeated_param 'Any', :args
+  end
+  def deprecation_gen(*args)
+    call_function('deprecation', 'default_content', 'This method is deprecated, please use extlib::default_content instead.')
+    call_function('extlib::default_content', *args)
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/dump_args.rb

@@ -0,0 +1,11 @@
+# @summary DEPRECATED.  Use the namespaced function [`extlib::dump_args`](#extlibdump_args) instead.
+# DEPRECATED.  Use the namespaced function [`extlib::dump_args`](#extlibdump_args) instead.
+Puppet::Functions.create_function(:dump_args) do
+  dispatch :deprecation_gen do
+    repeated_param 'Any', :args
+  end
+  def deprecation_gen(*args)
+    call_function('deprecation', 'dump_args', 'This method is deprecated, please use extlib::dump_args instead.')
+    call_function('extlib::dump_args', *args)
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/echo.rb

@@ -0,0 +1,11 @@
+# @summary DEPRECATED.  Use the namespaced function [`extlib::echo`](#extlibecho) instead.
+# DEPRECATED.  Use the namespaced function [`extlib::echo`](#extlibecho) instead.
+Puppet::Functions.create_function(:echo) do
+  dispatch :deprecation_gen do
+    repeated_param 'Any', :args
+  end
+  def deprecation_gen(*args)
+    call_function('deprecation', 'echo', 'This method is deprecated, please use extlib::echo instead.')
+    call_function('extlib::echo', *args)
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/cache_data.rb

@@ -0,0 +1,48 @@
+require 'fileutils'
+require 'yaml'
+require 'etc'
+
+# @summary Retrieves data from a cache file, or creates it with supplied data if the file doesn't exist
+#
+# Retrieves data from a cache file, or creates it with supplied data if the
+# file doesn't exist
+#
+# Useful for having data that's randomly generated once on the master side
+# (e.g. a password), but then stays the same on subsequent runs. Because it's
+# stored on the master on disk, it doesn't work when you use mulitple Puppet
+# masters that don't share their vardir.
+#
+# @example Calling the function
+#   $password = cache_data('mysql', 'mysql_password', 'this_is_my_password')
+#
+# @example With a random password
+#   $password = cache_data('mysql', 'mysql_password', random_password())
+Puppet::Functions.create_function(:'extlib::cache_data') do
+  # @param namespace Namespace for the cache
+  # @param name Cache key within the namespace
+  # @param initial_data The data for when there is no cache yet
+  # @return The cached value when it exists. The initial data when no cache exists
+  dispatch :cache_data do
+    param 'String[1]', :namespace
+    param 'String[1]', :name
+    param 'Any', :initial_data
+    return_type 'Any'
+  end
+
+  def cache_data(namespace, name, initial_data)
+    cache_dir = File.join(Puppet[:vardir], namespace)
+    cache = File.join(cache_dir, name)
+
+    if File.exist? cache
+      YAML.load(File.read(cache))
+    else
+      FileUtils.mkdir_p(cache_dir)
+      File.open(cache, 'w', 0o600) do |c|
+        c.write(YAML.dump(initial_data))
+      end
+      File.chown(File.stat(Puppet[:vardir]).uid, nil, cache)
+      File.chown(File.stat(Puppet[:vardir]).uid, nil, cache_dir)
+      initial_data
+    end
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/default_content.rb

@@ -0,0 +1,37 @@
+# Takes an optional content and an optional template name and returns the contents of a file.
+Puppet::Functions.create_function(:'extlib::default_content') do
+  # @param content
+  # @param template_name
+  #   The path to an .erb or .epp template file or `undef`.
+  # @return
+  #   Returns the value of the content parameter if it's a non empty string.
+  #   Otherwise returns the rendered output from `template_name`.
+  #   Returns `undef` if both `content` and `template_name` are `undef`.
+  #
+  # @example Using the function with a file resource.
+  #   $config_file_content = default_content($file_content, $template_location)
+  #   file { '/tmp/x':
+  #     ensure  => 'file',
+  #     content => $config_file_content,
+  #   }
+  dispatch :default_content do
+    param 'Optional[String]', :content
+    param 'Optional[String]', :template_name
+    return_type 'Optional[String]'
+  end
+
+  def emptyish(x)
+    x.nil? || x.empty? || x == :undef
+  end
+
+  def default_content(content = :undef, template_name = :undef)
+    return content unless emptyish(content)
+
+    unless emptyish(template_name)
+      return call_function('template', template_name) unless template_name.end_with?('.epp')
+      return call_function('epp', template_name)
+    end
+
+    :undef
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/dump_args.rb

@@ -0,0 +1,20 @@
+require 'json'
+
+# @summary Prints the args to STDOUT in Pretty JSON format.
+#
+# Prints the args to STDOUT in Pretty JSON format.
+#
+# Useful for debugging purposes only. Ideally you would use this in
+# conjunction with a rspec-puppet unit test.  Otherwise the output will
+# be shown during a puppet run when verbose/debug options are enabled.
+Puppet::Functions.create_function(:'extlib::dump_args') do
+  # @param args The data you want to dump as pretty JSON.
+  # @return [Undef] Returns nothing.
+  dispatch :dump_args do
+    param 'Any', :args
+  end
+
+  def dump_args(args)
+    puts JSON.pretty_generate(args)
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/echo.rb

@@ -0,0 +1,45 @@
+# This function outputs the variable content and its type to the
+# debug log. It's similiar to the `notice` function but provides
+# a better output format useful to trace variable types and values
+# in the manifests.
+#
+# ```
+# $v1 = 'test'
+# $v2 = ["1", "2", "3"]
+# $v3 = {"a"=>"1", "b"=>"2"}
+# $v4 = true
+# # $v5 is not defined
+# $v6 = { "b" => { "b" => [1,2,3], "c" => true, "d" => { 'x' => 'y' }}, 'x' => 'y', 'z' => [1,2,3,4,5,6]}
+# $v7 = 12345
+#
+# echo($v1, 'My string')
+# echo($v2, 'My array')
+# echo($v3, 'My hash')
+# echo($v4, 'My boolean')
+# echo($v5, 'My undef')
+# echo($v6, 'My structure')
+# echo($v7) # no comment here
+# debug log output
+# My string (String) "test"
+# My array (Array) ["1", "2", "3"]
+# My hash (Hash) {"a"=>"1", "b"=>"2"}
+# My boolean (TrueClass) true
+# My undef (String) ""
+# My structure (Hash) {"b"=>{"b"=>["1", "2", "3"], "c"=>true, "d"=>{"x"=>"y"}}, "x"=>"y", "z"=>["1", "2", "3", "4", "5", "6"]}
+# (String) "12345"
+# ```
+Puppet::Functions.create_function(:'extlib::echo') do
+  # @param value The value you want to inspect.
+  # @param comment An optional comment to prepend to the debug output.
+  # @return [Undef] Returns nothing.
+  dispatch :echo do
+    param 'Any', :value
+    optional_param 'String', :comment
+  end
+
+  def echo(value, comment = nil)
+    message = "(#{value.class}) #{value.inspect}"
+    message = "#{comment} #{message}" if comment
+    Puppet.debug message
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/has_module.rb

@@ -0,0 +1,33 @@
+require 'json'
+
+# A function that lets you know whether a specific module is on your modulepath.
+Puppet::Functions.create_function(:'extlib::has_module') do
+  # @param module_name The full name of the module you want to know exists or not.
+  #   Namespace and modulename can be separated with either `-` or `/`.
+  # @return Returns `true` or `false`.
+  # @example Calling the function
+  #   extlib::has_module('camptocamp/systemd')
+  dispatch :has_module do
+    param 'Pattern[/\A\w+[-\/]\w+\z/]', :module_name
+    return_type 'Boolean'
+  end
+
+  def has_module(module_name) # rubocop:disable Style/PredicateName
+    full_module_name = module_name.gsub(%r{/}, '-')
+    module_name = full_module_name[%r{(?<=-).+}]
+    begin
+      module_path = call_function('get_module_path', module_name)
+    rescue Puppet::ParseError
+      # stdlib function get_module_path raises Puppet::ParseError if module isn't in your environment
+      return false
+    end
+
+    metadata_json = File.join(module_path, 'metadata.json')
+
+    return false unless File.exist?(metadata_json)
+
+    metadata = JSON.parse(File.read(metadata_json))
+    return true if metadata['name'] == full_module_name
+    false
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/ip_to_cron.rb

@@ -0,0 +1,39 @@
+# Provides a "random" value to cron based on the last bit of the machine IP address.
+# used to avoid starting a certain cron job at the same time on all servers.
+# Takes the runinterval in seconds as parameter and returns an array of [hour, minute]
+#
+# example usage
+# ```
+# ip_to_cron(3600) - returns [ '*', one value between 0..59 ]
+# ip_to_cron(1800) - returns [ '*', an array of two values between 0..59 ]
+# ip_to_cron(7200) - returns [ an array of twelve values between 0..23, one value between 0..59 ]
+# ```
+Puppet::Functions.create_function(:'extlib::ip_to_cron') do
+  # @param runinterval The number of seconds to use as the run interval
+  # return [Array] Returns an array of the form `[hour, minute]`
+  dispatch :ip_to_cron do
+    optional_param 'Integer[1]', :runinterval
+    return_type 'Array'
+  end
+
+  def ip_to_cron(runinterval = 1800)
+    facts = closure_scope['facts']
+    ip = facts['networking']['ip']
+    ip_last_octet = ip.to_s.split('.')[3].to_i
+
+    if runinterval <= 3600
+      occurances = 3600 / runinterval
+      scope = 60
+      base = ip_last_octet % scope
+      hour = '*'
+      minute = (1..occurances).map { |i| (base - (scope / occurances * i)) % scope }.sort
+    else
+      occurances = 86_400 / runinterval
+      scope = 24
+      base = ip_last_octet % scope
+      hour = (1..occurances).map { |i| (base - (scope / occurances * i)) % scope }.sort
+      minute = ip_last_octet % 60
+    end
+    [hour, minute]
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/random_password.rb

@@ -0,0 +1,63 @@
+# vim: set ts=2 sw=2 et :
+# encoding: utf-8
+
+# random_password.rb
+#
+# Copyright 2012 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# For example:
+# ```
+# Given the following statements:
+#
+#   $a = 4
+#   $b = 8
+#   $c = 16
+#
+#   notice random_password($a)
+#   notice random_password($b)
+#   notice random_password($c)
+#
+# The result will be as follows:
+#
+#   notice: Scope(Class[main]): fNDC
+#   notice: Scope(Class[main]): KcKDLrjR
+#   notice: Scope(Class[main]): FtvfvkS9j9wXLsd6
+# ```
+
+# A function to return a string of arbitrary length that contains randomly selected characters.
+Puppet::Functions.create_function(:'extlib::random_password') do
+  # @param length The length of random password you want generated.
+  # @return [String] The random string returned consists of alphanumeric characters excluding 'look-alike' characters.
+  # @example Calling the function
+  #   random_password(42)
+  dispatch :random_password do
+    param 'Integer[1]', :length
+    return_type 'String'
+  end
+
+  def random_password(length)
+    # These are quite often confusing ...
+    ambiguous_characters = %w[0 1 O I l]
+
+    # Get allowed characters set ...
+    set = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a
+    set -= ambiguous_characters
+
+    # Shuffle characters in the set at random and return desired number of them ...
+    Array.new(length) do |_i|
+      set[rand(set.length)]
+    end.join
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/resources_deep_merge.rb

@@ -0,0 +1,87 @@
+# @summary Deeply merge a "defaults" hash into a "resources" hash like the ones expected by `create_resources()`.
+#
+# Deeply merge a "defaults" hash into a "resources" hash like the ones expected by `create_resources()`.
+#
+# Internally calls the puppetlabs-stdlib function `deep_merge()`. In case of
+# duplicate keys the `resources` hash keys win over the `defaults` hash keys.
+#
+# Example
+# ```puppet
+# $defaults_hash = {
+#   'one'   => '1',
+#   'two'   => '2',
+#   'three' => '3',
+#   'four'  => {
+#     'five'  => '5',
+#     'six'   => '6',
+#     'seven' => '7',
+#   }
+# }
+#
+# $numbers_hash = {
+#   'german' => {
+#     'one'   => 'eins',
+#     'three' => 'drei',
+#     'four'  => {
+#       'six' => 'sechs',
+#     },
+#   },
+#   'french' => {
+#     'one' => 'un',
+#     'two' => 'deux',
+#     'four' => {
+#       'five'  => 'cinq',
+#       'seven' => 'sept',
+#     },
+#   }
+# }
+#
+# $result_hash = resources_deep_merge($numbers_hash, $defaults_hash)
+# ```
+#
+# The $result_hash then looks like this:
+#
+# ```puppet
+# $result_hash = {
+#   'german' => {
+#     'one'   => 'eins',
+#     'two'   => '2',
+#     'three' => 'drei',
+#     'four'  => {
+#       'five'  => '5',
+#       'six'   => 'sechs',
+#       'seven' => '7',
+#     }
+#   },
+#   'french' => {
+#     'one'   => 'un',
+#     'two'   => 'deux',
+#     'three' => '3',
+#     'four'  => {
+#       'five'  => 'cinq',
+#       'six'   => '6',
+#       'seven' => 'sept',
+#     }
+#   }
+# }
+# ```
+Puppet::Functions.create_function(:'extlib::resources_deep_merge') do
+  # Deep-merges defaults into a resources hash
+  # @param resources The hash of resources.
+  # @param defaults The hash of defaults to merge.
+  # @return Returns the merged hash.
+  dispatch :resources_deep_merge do
+    param 'Hash', :resources
+    param 'Hash', :defaults
+    return_type 'Hash'
+  end
+
+  def resources_deep_merge(resources, defaults)
+    deep_merged_resources = {}
+    resources.each do |title, params|
+      deep_merged_resources[title] = call_function('deep_merge', defaults, params)
+    end
+
+    deep_merged_resources
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/extlib/sort_by_version.rb

@@ -0,0 +1,15 @@
+# A function that sorts an array of version numbers.
+Puppet::Functions.create_function(:'extlib::sort_by_version') do
+  # @param versions An array of version strings you want sorted.
+  # @return Returns the sorted array.
+  # @example Calling the function
+  #   extlib::sort_by_version(['10.0.0b12', '10.0.0b3', '10.0.0a2', '9.0.10', '9.0.3'])
+  dispatch :sort_by_version do
+    param 'Array[String]', :versions
+    return_type 'Array[String]'
+  end
+
+  def sort_by_version(versions)
+    versions.sort_by { |v| Gem::Version.new(v) }
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/ip_to_cron.rb

@@ -0,0 +1,11 @@
+# @summary DEPRECATED.  Use the namespaced function [`extlib::ip_to_cron`](#extlibip_to_cron) instead.
+# DEPRECATED.  Use the namespaced function [`extlib::ip_to_cron`](#extlibip_to_cron) instead.
+Puppet::Functions.create_function(:ip_to_cron) do
+  dispatch :deprecation_gen do
+    repeated_param 'Any', :args
+  end
+  def deprecation_gen(*args)
+    call_function('deprecation', 'ip_to_cron', 'This method is deprecated, please use extlib::ip_to_cron instead.')
+    call_function('extlib::ip_to_cron', *args)
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/random_password.rb

@@ -0,0 +1,11 @@
+# @summary DEPRECATED.  Use the namespaced function [`extlib::random_password`](#extlibrandom_password) instead.
+# DEPRECATED.  Use the namespaced function [`extlib::random_password`](#extlibrandom_password) instead.
+Puppet::Functions.create_function(:random_password) do
+  dispatch :deprecation_gen do
+    repeated_param 'Any', :args
+  end
+  def deprecation_gen(*args)
+    call_function('deprecation', 'random_password', 'This method is deprecated, please use extlib::random_password instead.')
+    call_function('extlib::random_password', *args)
+  end
+end

data/spec/fixtures/modules/extlib/lib/puppet/functions/resources_deep_merge.rb

@@ -0,0 +1,11 @@
+# @summary DEPRECATED.  Use the namespaced function [`extlib::resources_deep_merge`](#extlibresources_deep_merge) instead.
+# DEPRECATED.  Use the namespaced function [`extlib::resources_deep_merge`](#extlibresources_deep_merge) instead.
+Puppet::Functions.create_function(:resources_deep_merge) do
+  dispatch :deprecation_gen do
+    repeated_param 'Any', :args
+  end
+  def deprecation_gen(*args)
+    call_function('deprecation', 'resources_deep_merge', 'This method is deprecated, please use extlib::resources_deep_merge instead.')
+    call_function('extlib::resources_deep_merge', *args)
+  end
+end