puppet-retrospec 0.12.1 → 0.12.2

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

@@ -1,49 +0,0 @@
-#
-# delete.rb
-#
-
-# TODO(Krzysztof Wilczynski): We need to add support for regular expression ...
-
-module Puppet::Parser::Functions
-  newfunction(:delete, :type => :rvalue, :doc => <<-EOS
-Deletes all instances of a given element from an array, substring from a
-string, or key from a hash.
-
-*Examples:*
-
-    delete(['a','b','c','b'], 'b')
-    Would return: ['a','c']
-
-    delete({'a'=>1,'b'=>2,'c'=>3}, 'b')
-    Would return: {'a'=>1,'c'=>3}
-
-    delete({'a'=>1,'b'=>2,'c'=>3}, ['b','c'])
-    Would return: {'a'=>1}
-
-    delete('abracadabra', 'bra')
-    Would return: 'acada'
-  EOS
-  ) do |arguments|
-
-    if (arguments.size != 2) then
-      raise(Puppet::ParseError, "delete(): Wrong number of arguments "+
-                                  "given #{arguments.size} for 2.")
-    end
-
-    collection = arguments[0].dup
-    Array(arguments[1]).each do |item|
-      case collection
-        when Array, Hash
-          collection.delete item
-        when String
-          collection.gsub! item, ''
-        else
-          raise(TypeError, "delete(): First argument must be an Array, " +
-                             "String, or Hash. Given an argument of class #{collection.class}.")
-      end
-    end
-    collection
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,49 +0,0 @@
-#
-# delete_at.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:delete_at, :type => :rvalue, :doc => <<-EOS
-Deletes a determined indexed value from an array.
-
-*Examples:*
-
-    delete_at(['a','b','c'], 1)
-
-Would return: ['a','c']
-    EOS
-  ) do |arguments|
-
-    raise(Puppet::ParseError, "delete_at(): Wrong number of arguments " +
-      "given (#{arguments.size} for 2)") if arguments.size < 2
-
-    array = arguments[0]
-
-    unless array.is_a?(Array)
-      raise(Puppet::ParseError, 'delete_at(): Requires array to work with')
-    end
-
-    index = arguments[1]
-
-    if index.is_a?(String) and not index.match(/^\d+$/)
-      raise(Puppet::ParseError, 'delete_at(): You must provide ' +
-        'non-negative numeric index')
-    end
-
-    result = array.clone
-
-    # Numbers in Puppet are often string-encoded which is troublesome ...
-    index = index.to_i
-
-    if index > result.size - 1 # First element is at index 0 is it not?
-      raise(Puppet::ParseError, 'delete_at(): Given index ' +
-        'exceeds size of array given')
-    end
-
-    result.delete_at(index) # We ignore the element that got deleted ...
-
-    return result
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,34 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:delete_undef_values, :type => :rvalue, :doc => <<-EOS
-Returns a copy of input hash or array with all undefs deleted.
-
-*Examples:*
-
-    $hash = delete_undef_values({a=>'A', b=>'', c=>undef, d => false})
-
-Would return: {a => 'A', b => '', d => false}
-
-    $array = delete_undef_values(['A','',undef,false])
-
-Would return: ['A','',false]
-
-      EOS
-    ) do |args|
-
-    raise(Puppet::ParseError,
-          "delete_undef_values(): Wrong number of arguments given " +
-          "(#{args.size})") if args.size < 1
-
-    unless args[0].is_a? Array or args[0].is_a? Hash
-      raise(Puppet::ParseError,
-            "delete_undef_values(): expected an array or hash, got #{args[0]} type  #{args[0].class} ")
-    end
-    result = args[0].dup
-    if result.is_a?(Hash)
-      result.delete_if {|key, val| val.equal? :undef}
-    elsif result.is_a?(Array)
-      result.delete :undef
-    end
-    result
-  end
-end

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

@@ -1,26 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:delete_values, :type => :rvalue, :doc => <<-EOS
-Deletes all instances of a given value from a hash.
-
-*Examples:*
-
-    delete_values({'a'=>'A','b'=>'B','c'=>'C','B'=>'D'}, 'B')
-
-Would return: {'a'=>'A','c'=>'C','B'=>'D'}
-
-      EOS
-    ) do |arguments|
-
-    raise(Puppet::ParseError,
-          "delete_values(): Wrong number of arguments given " +
-          "(#{arguments.size} of 2)") if arguments.size != 2
-
-    hash, item = arguments
-
-    if not hash.is_a?(Hash)
-      raise(TypeError, "delete_values(): First argument must be a Hash. " + \
-                       "Given an argument of class #{hash.class}.")
-    end
-    hash.dup.delete_if { |key, val| item == val }
-  end
-end

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

@@ -1,36 +0,0 @@
-#
-# difference.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:difference, :type => :rvalue, :doc => <<-EOS
-This function returns the difference between two arrays.
-The returned array is a copy of the original array, removing any items that
-also appear in the second array.
-
-*Examples:*
-
-    difference(["a","b","c"],["b","c","d"])
-
-Would return: ["a"]
-    EOS
-  ) do |arguments|
-
-    # Two arguments are required
-    raise(Puppet::ParseError, "difference(): Wrong number of arguments " +
-      "given (#{arguments.size} for 2)") if arguments.size != 2
-
-    first = arguments[0]
-    second = arguments[1]
-
-    unless first.is_a?(Array) && second.is_a?(Array)
-      raise(Puppet::ParseError, 'difference(): Requires 2 arrays')
-    end
-
-    result = first - second
-
-    return result
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,21 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:dirname, :type => :rvalue, :doc => <<-EOS
-    Returns the dirname of a path.
-    EOS
-  ) do |arguments|
-
-    if arguments.size < 1 then
-      raise(Puppet::ParseError, "dirname(): No arguments given")
-    end
-    if arguments.size > 1 then
-      raise(Puppet::ParseError, "dirname(): Too many arguments given (#{arguments.size})")
-    end
-    unless arguments[0].is_a?(String)
-      raise(Puppet::ParseError, 'dirname(): Requires string as argument')
-    end
-
-    return File.dirname(arguments[0])
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,32 +0,0 @@
-#
-#  downcase.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:downcase, :type => :rvalue, :doc => <<-EOS
-Converts the case of a string or all strings in an array to lower case.
-    EOS
-  ) do |arguments|
-
-    raise(Puppet::ParseError, "downcase(): Wrong number of arguments " +
-      "given (#{arguments.size} for 1)") if arguments.size < 1
-
-    value = arguments[0]
-
-    unless value.is_a?(Array) || value.is_a?(String)
-      raise(Puppet::ParseError, 'downcase(): Requires either ' +
-        'array or string to work with')
-    end
-
-    if value.is_a?(Array)
-      # Numbers in Puppet are often string-encoded which is troublesome ...
-      result = value.collect { |i| i.is_a?(String) ? i.downcase : i }
-    else
-      result = value.downcase
-    end
-
-    return result
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,27 +0,0 @@
-#
-# empty.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:empty, :type => :rvalue, :doc => <<-EOS
-Returns true if the variable is empty.
-    EOS
-  ) do |arguments|
-
-    raise(Puppet::ParseError, "empty(): Wrong number of arguments " +
-      "given (#{arguments.size} for 1)") if arguments.size < 1
-
-    value = arguments[0]
-
-    unless value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(String)
-      raise(Puppet::ParseError, 'empty(): Requires either ' +
-        'array, hash or string to work with')
-    end
-
-    result = value.empty?
-
-    return result
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,35 +0,0 @@
-#
-# ensure_packages.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:ensure_packages, :type => :statement, :doc => <<-EOS
-Takes a list of packages and only installs them if they don't already exist.
-It optionally takes a hash as a second parameter that will be passed as the
-third argument to the ensure_resource() function.
-    EOS
-  ) do |arguments|
-
-    if arguments.size > 2 or arguments.size == 0
-      raise(Puppet::ParseError, "ensure_packages(): Wrong number of arguments " +
-        "given (#{arguments.size} for 1 or 2)")
-    elsif arguments.size == 2 and !arguments[1].is_a?(Hash) 
-      raise(Puppet::ParseError, 'ensure_packages(): Requires second argument to be a Hash')
-    end
-
-    packages = Array(arguments[0])
-
-    if arguments[1]
-      defaults = { 'ensure' => 'present' }.merge(arguments[1])
-    else
-      defaults = { 'ensure' => 'present' }
-    end
-
-    Puppet::Parser::Functions.function(:ensure_resource)
-    packages.each { |package_name|
-      function_ensure_resource(['package', package_name, defaults ])
-    }
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,46 +0,0 @@
-# Test whether a given class or definition is defined
-require 'puppet/parser/functions'
-
-Puppet::Parser::Functions.newfunction(:ensure_resource,
-                                      :type => :statement,
-                                      :doc => <<-'ENDOFDOC'
-Takes a resource type, title, and a list of attributes that describe a
-resource.
-
-    user { 'dan':
-      ensure => present,
-    }
-
-This example only creates the resource if it does not already exist:
-
-    ensure_resource('user', 'dan', {'ensure' => 'present' })
-
-If the resource already exists but does not match the specified parameters,
-this function will attempt to recreate the resource leading to a duplicate
-resource definition error.
-
-An array of resources can also be passed in and each will be created with
-the type and parameters specified if it doesn't already exist.
-
-    ensure_resource('user', ['dan','alex'], {'ensure' => 'present'})
-
-ENDOFDOC
-) do |vals|
-  type, title, params = vals
-  raise(ArgumentError, 'Must specify a type') unless type
-  raise(ArgumentError, 'Must specify a title') unless title
-  params ||= {}
-
-  items = [title].flatten
-
-  items.each do |item|
-    Puppet::Parser::Functions.function(:defined_with_params)
-    if function_defined_with_params(["#{type}[#{item}]", params])
-      Puppet.debug("Resource #{type}[#{item}] with params #{params} not created because it already exists")
-    else
-      Puppet.debug("Create new resource #{type}[#{item}] with params #{params}")
-      Puppet::Parser::Functions.function(:create_resources)
-      function_create_resources([type.capitalize, { item => params }])
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-#
-# flatten.rb
-#
-
-module Puppet::Parser::Functions
-  newfunction(:flatten, :type => :rvalue, :doc => <<-EOS
-This function flattens any deeply nested arrays and returns a single flat array
-as a result.
-
-*Examples:*
-
-    flatten(['a', ['b', ['c']]])
-
-Would return: ['a','b','c']
-    EOS
-  ) do |arguments|
-
-    raise(Puppet::ParseError, "flatten(): Wrong number of arguments " +
-      "given (#{arguments.size} for 1)") if arguments.size != 1
-
-    array = arguments[0]
-
-    unless array.is_a?(Array)
-      raise(Puppet::ParseError, 'flatten(): Requires array to work with')
-    end
-
-    result = array.flatten
-
-    return result
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,25 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:floor, :type => :rvalue, :doc => <<-EOS
-    Returns the largest integer less or equal to the argument.
-    Takes a single numeric value as an argument.
-    EOS
-  ) do |arguments|
-
-    raise(Puppet::ParseError, "floor(): Wrong number of arguments " +
-          "given (#{arguments.size} for 1)") if arguments.size != 1
-
-    begin
-      arg = Float(arguments[0])
-    rescue TypeError, ArgumentError => e
-      raise(Puppet::ParseError, "floor(): Wrong argument type " +
-            "given (#{arguments[0]} for Numeric)")
-    end
-
-    raise(Puppet::ParseError, "floor(): Wrong argument type " +
-          "given (#{arg.class} for Numeric)") if arg.is_a?(Numeric) == false
-
-    arg.floor
-  end
-end
-
-# vim: set ts=2 sw=2 et :

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

@@ -1,34 +0,0 @@
-Puppet::Parser::Functions::newfunction(
-  :fqdn_rand_string,
-  :arity => -2,
-  :type => :rvalue,
-  :doc => "Usage: `fqdn_rand_string(LENGTH, [CHARSET], [SEED])`. LENGTH is
-  required and must be a positive integer. CHARSET is optional and may be
-  `undef` or a string. SEED is optional and may be any number or string.
-
-  Generates a random string LENGTH characters long using the character set
-  provided by CHARSET, combining the `$fqdn` fact and the value of SEED for
-  repeatable randomness. (That is, each node will get a different random
-  string from this function, but a given node's result will be the same every
-  time unless its hostname changes.) Adding a SEED can be useful if you need
-  more than one unrelated string. CHARSET will default to alphanumeric if
-  `undef` or an empty string.") do |args|
-    raise(ArgumentError, "fqdn_rand_string(): wrong number of arguments (0 for 1)") if args.size == 0
-    Puppet::Parser::Functions.function('is_integer')
-    raise(ArgumentError, "fqdn_rand_base64(): first argument must be a positive integer") unless function_is_integer([args[0]]) and args[0].to_i > 0
-    raise(ArgumentError, "fqdn_rand_base64(): second argument must be undef or a string") unless args[1].nil? or args[1].is_a? String
-
-    Puppet::Parser::Functions.function('fqdn_rand')
-
-    length = args.shift.to_i
-    charset = args.shift.to_s.chars.to_a
-
-    charset = (0..9).map { |i| i.to_s } + ('A'..'Z').to_a + ('a'..'z').to_a if charset.empty?
-
-    rand_string = ''
-    for current in 1..length
-      rand_string << charset[function_fqdn_rand([charset.size, (args + [current.to_s]).join(':')]).to_i]
-    end
-
-    rand_string
-end