puppet-retrospec 0.12.1 → 0.12.2

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/validate_ipv4_address.rb

@@ -1,48 +0,0 @@
-module Puppet::Parser::Functions
-
-  newfunction(:validate_ipv4_address, :doc => <<-ENDHEREDOC
-    Validate that all values passed are valid IPv4 addresses.
-    Fail compilation if any value fails this check.
-
-    The following values will pass:
-
-    $my_ip = "1.2.3.4"
-    validate_ipv4_address($my_ip)
-    validate_bool("8.8.8.8", "172.16.0.1", $my_ip)
-
-    The following values will fail, causing compilation to abort:
-
-    $some_array = [ 1, true, false, "garbage string", "3ffe:505:2" ]
-    validate_ipv4_address($some_array)
-
-    ENDHEREDOC
-  ) do |args|
-
-    require "ipaddr"
-    rescuable_exceptions = [ ArgumentError ]
-
-    if defined?(IPAddr::InvalidAddressError)
-      rescuable_exceptions << IPAddr::InvalidAddressError
-    end
-
-    unless args.length > 0 then
-      raise Puppet::ParseError, ("validate_ipv4_address(): wrong number of arguments (#{args.length}; must be > 0)")
-    end
-
-    args.each do |arg|
-      unless arg.is_a?(String)
-        raise Puppet::ParseError, "#{arg.inspect} is not a string."
-      end
-
-      begin
-        unless IPAddr.new(arg).ipv4?
-          raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv4 address."
-        end
-      rescue *rescuable_exceptions
-        raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv4 address."
-      end
-    end
-
-  end
-
-end

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/validate_ipv6_address.rb

@@ -1,49 +0,0 @@
-module Puppet::Parser::Functions
-
-  newfunction(:validate_ipv6_address, :doc => <<-ENDHEREDOC
-    Validate that all values passed are valid IPv6 addresses.
-    Fail compilation if any value fails this check.
-
-    The following values will pass:
-
-    $my_ip = "3ffe:505:2"
-    validate_ipv6_address(1)
-    validate_ipv6_address($my_ip)
-    validate_bool("fe80::baf6:b1ff:fe19:7507", $my_ip)
-
-    The following values will fail, causing compilation to abort:
-
-    $some_array = [ true, false, "garbage string", "1.2.3.4" ]
-    validate_ipv6_address($some_array)
-
-    ENDHEREDOC
-  ) do |args|
-
-    require "ipaddr"
-    rescuable_exceptions = [ ArgumentError ]
-
-    if defined?(IPAddr::InvalidAddressError)
-      rescuable_exceptions << IPAddr::InvalidAddressError
-    end
-
-    unless args.length > 0 then
-      raise Puppet::ParseError, ("validate_ipv6_address(): wrong number of arguments (#{args.length}; must be > 0)")
-    end
-
-    args.each do |arg|
-      unless arg.is_a?(String)
-        raise Puppet::ParseError, "#{arg.inspect} is not a string."
-      end
-
-      begin
-        unless IPAddr.new(arg).ipv6?
-          raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv6 address."
-        end
-      rescue *rescuable_exceptions
-        raise Puppet::ParseError, "#{arg.inspect} is not a valid IPv6 address."
-      end
-    end
-
-  end
-
-end

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/validate_numeric.rb

@@ -1,93 +0,0 @@
-module Puppet::Parser::Functions
-
-  newfunction(:validate_numeric, :doc => <<-'ENDHEREDOC') do |args|
-    Validate that the first argument is a numeric value (or an array of numeric values). Abort catalog compilation if any of the checks fail.
-    
-    The second argument is optional and passes a maximum. (All elements of) the first argument has to be less or equal to this max.
-
-    The third argument is optional and passes a minimum.  (All elements of) the first argument has to be greater or equal to this min.
-    If, and only if, a minimum is given, the second argument may be an empty string or undef, which will be handled to just check
-    if (all elements of) the first argument are greater or equal to the given minimum.
-
-    It will fail if the first argument is not a numeric (Integer or Float) or array of numerics, and if arg 2 and arg 3 are not convertable to a numeric.
-
-    For passing and failing usage, see `validate_integer()`. It is all the same for validate_numeric, yet now floating point values are allowed, too.
-
-    ENDHEREDOC
-
-    # tell the user we need at least one, and optionally up to two other parameters
-    raise Puppet::ParseError, "validate_numeric(): Wrong number of arguments; must be 1, 2 or 3, got #{args.length}" unless args.length > 0 and args.length < 4
-
-    input, max, min = *args
-
-    # check maximum parameter
-    if args.length > 1
-      max = max.to_s
-      # allow max to be empty (or undefined) if we have a minimum set
-      if args.length > 2 and max == ''
-        max = nil
-      else
-        begin
-          max = Float(max)
-        rescue TypeError, ArgumentError
-          raise Puppet::ParseError, "validate_numeric(): Expected second argument to be unset or a Numeric, got #{max}:#{max.class}"
-        end
-      end
-    else
-      max = nil
-    end
-
-    # check minimum parameter
-    if args.length > 2
-      begin
-        min = Float(min.to_s)
-      rescue TypeError, ArgumentError
-        raise Puppet::ParseError, "validate_numeric(): Expected third argument to be unset or a Numeric, got #{min}:#{min.class}"
-      end
-    else
-      min = nil
-    end
-
-    # ensure that min < max
-    if min and max and min > max
-      raise Puppet::ParseError, "validate_numeric(): Expected second argument to be larger than third argument, got #{max} < #{min}"
-    end
-
-    # create lamba validator function
-    validator = lambda do |num|
-      # check input < max
-      if max and num > max
-        raise Puppet::ParseError, "validate_numeric(): Expected #{input.inspect} to be smaller or equal to #{max}, got #{input.inspect}."
-      end
-      # check input > min (this will only be checked if no exception has been raised before)
-      if min and num < min
-        raise Puppet::ParseError, "validate_numeric(): Expected #{input.inspect} to be greater or equal to #{min}, got #{input.inspect}."
-      end
-    end
-
-    # if this is an array, handle it.
-    case input
-    when Array
-      # check every element of the array
-      input.each_with_index do |arg, pos|
-        begin
-          arg = Float(arg.to_s)
-          validator.call(arg)
-        rescue TypeError, ArgumentError
-          raise Puppet::ParseError, "validate_numeric(): Expected element at array position #{pos} to be a Numeric, got #{arg.class}"
-        end
-      end
-    # for the sake of compatibility with ruby 1.8, we need extra handling of hashes
-    when Hash
-      raise Puppet::ParseError, "validate_integer(): Expected first argument to be a Numeric or Array, got #{input.class}"
-    # check the input. this will also fail any stuff other than pure, shiny integers
-    else
-      begin
-        input = Float(input.to_s)
-        validator.call(input)
-      rescue TypeError, ArgumentError
-        raise Puppet::ParseError, "validate_numeric(): Expected first argument to be a Numeric or Array, got #{input.class}"
-      end
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/validate_re.rb

@@ -1,40 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:validate_re, :doc => <<-'ENDHEREDOC') do |args|
-    Perform simple validation of a string against one or more regular
-    expressions. The first argument of this function should be a string to
-    test, and the second argument should be a stringified regular expression
-    (without the // delimiters) or an array of regular expressions.  If none
-    of the regular expressions match the string passed in, compilation will
-    abort with a parse error.
-
-    If a third argument is specified, this will be the error message raised and
-    seen by the user.
-
-    The following strings will validate against the regular expressions:
-
-        validate_re('one', '^one$')
-        validate_re('one', [ '^one', '^two' ])
-
-    The following strings will fail to validate, causing compilation to abort:
-
-        validate_re('one', [ '^two', '^three' ])
-
-    A helpful error message can be returned like this:
-
-        validate_re($::puppetversion, '^2.7', 'The $puppetversion fact value does not match 2.7')
-
-    ENDHEREDOC
-    if (args.length < 2) or (args.length > 3) then
-      raise Puppet::ParseError, ("validate_re(): wrong number of arguments (#{args.length}; must be 2 or 3)")
-    end
-
-    msg = args[2] || "validate_re(): #{args[0].inspect} does not match #{args[1].inspect}"
-
-    # We're using a flattened array here because we can't call String#any? in
-    # Ruby 1.9 like we can in Ruby 1.8
-    raise Puppet::ParseError, (msg) unless [args[1]].flatten.any? do |re_str|
-      args[0] =~ Regexp.compile(re_str)
-    end
-
-  end
-end

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/validate_slength.rb

@@ -1,71 +0,0 @@
-module Puppet::Parser::Functions
-
-  newfunction(:validate_slength, :doc => <<-'ENDHEREDOC') do |args|
-    Validate that the first argument is a string (or an array of strings), and
-    less/equal to than the length of the second argument. An optional third
-    parameter can be given a the minimum length. It fails if the first
-    argument is not a string or array of strings, and if arg 2 and arg 3 are
-    not convertable to a number.
-
-    The following values will pass:
-
-      validate_slength("discombobulate",17)
-      validate_slength(["discombobulate","moo"],17)
-      validate_slength(["discombobulate","moo"],17,3)
-
-    The following valueis will not:
-
-      validate_slength("discombobulate",1)
-      validate_slength(["discombobulate","thermometer"],5)
-      validate_slength(["discombobulate","moo"],17,10)
-
-    ENDHEREDOC
-
-    raise Puppet::ParseError, "validate_slength(): Wrong number of arguments (#{args.length}; must be 2 or 3)" unless args.length == 2 or args.length == 3
-
-    input, max_length, min_length = *args
-
-    begin
-      max_length = Integer(max_length)
-      raise ArgumentError if max_length <= 0
-    rescue ArgumentError, TypeError
-      raise Puppet::ParseError, "validate_slength(): Expected second argument to be a positive Numeric, got #{max_length}:#{max_length.class}"
-    end
-
-    if min_length
-      begin
-        min_length = Integer(min_length)
-        raise ArgumentError if min_length < 0
-    rescue ArgumentError, TypeError
-        raise Puppet::ParseError, "validate_slength(): Expected third argument to be unset or a positive Numeric, got #{min_length}:#{min_length.class}"
-      end
-    else
-      min_length = 0
-    end
-
-    if min_length > max_length
-      raise Puppet::ParseError, "validate_slength(): Expected second argument to be larger than third argument"
-    end
-
-    validator = lambda do |str|
-      unless str.length <= max_length and str.length >= min_length
-        raise Puppet::ParseError, "validate_slength(): Expected length of #{input.inspect} to be between #{min_length} and #{max_length}, was #{input.length}"
-      end
-    end
-
-    case input
-    when String
-      validator.call(input)
-    when Array
-      input.each_with_index do |arg, pos|
-        if arg.is_a? String
-          validator.call(arg)
-        else
-          raise Puppet::ParseError, "validate_slength(): Expected element at array position #{pos} to be a String, got #{arg.class}"
-        end
-      end
-    else
-      raise Puppet::ParseError, "validate_slength(): Expected first argument to be a String or Array, got #{input.class}"
-    end
-  end
-end

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/validate_string.rb

@@ -1,38 +0,0 @@
-module Puppet::Parser::Functions
-
-  newfunction(:validate_string, :doc => <<-'ENDHEREDOC') do |args|
-    Validate that all passed values are string data structures. Abort catalog
-    compilation if any value fails this check.
-
-    The following values will pass:
-
-        $my_string = "one two"
-        validate_string($my_string, 'three')
-
-    The following values will fail, causing compilation to abort:
-
-        validate_string(true)
-        validate_string([ 'some', 'array' ])
-        
-    Note: validate_string(undef) will not fail in this version of the
-    functions API (incl. current and future parser). Instead, use:
-    
-        if $var == undef {
-          fail('...')
-        }
-    
-    ENDHEREDOC
-
-    unless args.length > 0 then
-      raise Puppet::ParseError, ("validate_string(): wrong number of arguments (#{args.length}; must be > 0)")
-    end
-
-    args.each do |arg|
-      unless arg.is_a?(String)
-        raise Puppet::ParseError, ("#{arg.inspect} is not a string.  It looks to be a #{arg.class}")
-      end
-    end
-
-  end
-
-end

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/values.rb

@@ -1,39 +0,0 @@
-#
-# values.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:values, :type => :rvalue, :doc => <<-EOS
-When given a hash this function will return the values of that hash.
-
-*Examples:*
-
-    $hash = {
-      'a' => 1,
-      'b' => 2,
-      'c' => 3,
-    }
-    values($hash)
-
-This example would return:
-
-    [1,2,3]
-    EOS
-  ) do |arguments|
-
-    raise(Puppet::ParseError, "values(): Wrong number of arguments " +
-      "given (#{arguments.size} for 1)") if arguments.size < 1
-
-    hash = arguments[0]
-
-    unless hash.is_a?(Hash)
-      raise(Puppet::ParseError, 'values(): Requires hash to work with')
-    end
-
-    result = hash.values
-
-    return result
-  end
-end
-
-# vim: set ts=2 sw=2 et :

data/spec/fixtures/modules/stdlib/lib/puppet/parser/functions/values_at.rb

@@ -1,99 +0,0 @@
-#
-# values_at.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:values_at, :type => :rvalue, :doc => <<-EOS
-Finds value inside an array based on location.
-
-The first argument is the array you want to analyze, and the second element can
-be a combination of:
-
-* A single numeric index
-* A range in the form of 'start-stop' (eg. 4-9)
-* An array combining the above
-
-*Examples*:
-
-    values_at(['a','b','c'], 2)
-
-Would return ['c'].
-
-    values_at(['a','b','c'], ["0-1"])
-
-Would return ['a','b'].
-
-    values_at(['a','b','c','d','e'], [0, "2-3"])
-
-Would return ['a','c','d'].
-    EOS
-  ) do |arguments|
-
-    raise(Puppet::ParseError, "values_at(): Wrong number of " +
-      "arguments given (#{arguments.size} for 2)") if arguments.size < 2
-
-    array = arguments.shift
-
-    unless array.is_a?(Array)
-      raise(Puppet::ParseError, 'values_at(): Requires array to work with')
-    end
-
-    indices = [arguments.shift].flatten() # Get them all ... Pokemon ...
-
-    if not indices or indices.empty?
-      raise(Puppet::ParseError, 'values_at(): You must provide ' +
-        'at least one positive index to collect')
-    end
-
-    result       = []
-    indices_list = []
-
-    indices.each do |i|
-      i = i.to_s
-      if m = i.match(/^(\d+)(\.\.\.?|\-)(\d+)$/)
-        start = m[1].to_i
-        stop  = m[3].to_i
-
-        type = m[2]
-
-        if start > stop
-          raise(Puppet::ParseError, 'values_at(): Stop index in ' +
-            'given indices range is smaller than the start index')
-        elsif stop > array.size - 1 # First element is at index 0 is it not?
-          raise(Puppet::ParseError, 'values_at(): Stop index in ' +
-            'given indices range exceeds array size')
-        end
-
-        range = case type
-          when /^(\.\.|\-)$/ then (start .. stop)
-          when /^(\.\.\.)$/  then (start ... stop) # Exclusive of last element ...
-        end
-
-        range.each { |i| indices_list << i.to_i }
-      else
-        # Only positive numbers allowed in this case ...
-        if not i.match(/^\d+$/)
-          raise(Puppet::ParseError, 'values_at(): Unknown format ' +
-            'of given index')
-        end
-
-        # In Puppet numbers are often string-encoded ...
-        i = i.to_i
-
-        if i > array.size - 1 # Same story.  First element is at index 0 ...
-          raise(Puppet::ParseError, 'values_at(): Given index ' +
-            'exceeds array size')
-        end
-
-        indices_list << i
-      end
-    end
-
-    # We remove nil values as they make no sense in Puppet DSL ...
-    result = indices_list.collect { |i| array[i] }.compact
-
-    return result
-  end
-end
-
-# vim: set ts=2 sw=2 et :