puppet 3.0.2 → 3.1.0.rc1

data/lib/puppet/parser/functions/create_resources.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC') do |args|
+Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc => <<-'ENDHEREDOC') do |args|
     Converts a hash into a set of resources and adds them to the catalog.
 
     This function takes two mandatory arguments: a resource type, and a hash describing
@@ -31,12 +31,31 @@ Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC
 
     This function can be used to create defined resources and classes, as well
     as native resources.
+
+    Virtual and Exported resources may be created by prefixing the type name
+    with @ or @@ respectively.  For example, the $myusers hash may be exported
+    in the following manner:
+
+        create_resources("@@user", $myusers)
+
+    The $myusers may be declared as virtual resources using:
+
+        create_resources("@user", $myusers)
+
   ENDHEREDOC
-  raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length < 2 || args.length > 3
+  raise ArgumentError, ("create_resources(): wrong number of arguments (#{args.length}; must be 2 or 3)") if args.length > 3
 
   # figure out what kind of resource we are
   type_of_resource = nil
   type_name = args[0].downcase
+  type_exported, type_virtual = false
+  if type_name.start_with? '@@'
+    type_name = type_name[2..-1]
+    type_exported = true
+  elsif type_name.start_with? '@'
+    type_name = type_name[1..-1]
+    type_virtual = true
+  end
   if type_name == 'class'
     type_of_resource = :class
   else
@@ -58,6 +77,8 @@ Puppet::Parser::Functions::newfunction(:create_resources, :doc => <<-'ENDHEREDOC
     # for a defined type.
     when :type, :define
       p_resource = Puppet::Parser::Resource.new(type_name, title, :scope => self, :source => resource)
+      p_resource.virtual = type_virtual
+      p_resource.exported = type_exported
       {:name => title}.merge(params).each do |k,v|
         p_resource.set_parameter(k,v)
       end

data/lib/puppet/parser/functions/defined.rb

@@ -1,5 +1,5 @@
 # Test whether a given class or definition is defined
-Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :doc => "Determine whether
+Puppet::Parser::Functions::newfunction(:defined, :type => :rvalue, :arity => -2, :doc => "Determine whether
   a given class or resource type is defined. This function can also determine whether a
   specific resource has been declared. Returns true or false. Accepts class names,
   type names, and resource references.

data/lib/puppet/parser/functions/extlookup.rb

@@ -3,6 +3,7 @@ require 'csv'
 module Puppet::Parser::Functions
   newfunction(:extlookup,
   :type => :rvalue,
+  :arity => -2,
   :doc => "This is a parser function to read data from external files, this version
 uses CSV files but the concept can easily be adjust for databases, yaml
 or any other queryable data source.
@@ -89,7 +90,7 @@ This is for back compatibility to interpolate variables with %. % interpolation
   default  = args[1]
   datafile = args[2]
 
-  raise Puppet::ParseError, ("extlookup(): wrong number of arguments (#{args.length}; must be <= 3)") if args.length > 3
+  raise ArgumentError, ("extlookup(): wrong number of arguments (#{args.length}; must be <= 3)") if args.length > 3
 
   extlookup_datadir = undef_as('',self['::extlookup_datadir'])
 

data/lib/puppet/parser/functions/fail.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions::newfunction(:fail, :doc => "Fail with a parse error.") do |vals|
+Puppet::Parser::Functions::newfunction(:fail, :arity => -1, :doc => "Fail with a parse error.") do |vals|
     vals = vals.collect { |s| s.to_s }.join(" ") if vals.is_a? Array
     raise Puppet::ParseError, vals.to_s
 end

data/lib/puppet/parser/functions/file.rb

@@ -1,7 +1,7 @@
 # Returns the contents of a file
 
 Puppet::Parser::Functions::newfunction(
-  :file, :type => :rvalue,
+  :file, :arity => -2, :type => :rvalue,
   :doc => "Return the contents of a file.  Multiple files
   can be passed, and the first file that exists will be read in."
 ) do |vals|

data/lib/puppet/parser/functions/fqdn_rand.rb

@@ -1,6 +1,6 @@
 require 'digest/md5'
 
-Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc =>
+Puppet::Parser::Functions::newfunction(:fqdn_rand, :arity => -2, :type => :rvalue, :doc =>
   "Generates random numbers based on the node's fqdn. Generated random values
   will be a range from 0 up to and excluding n, where n is the first parameter.
   The second argument specifies a number to add to the seed and is optional, for example:

data/lib/puppet/parser/functions/generate.rb

@@ -1,5 +1,5 @@
 # Runs an external command and returns the results
-Puppet::Parser::Functions::newfunction(:generate, :type => :rvalue,
+Puppet::Parser::Functions::newfunction(:generate, :arity => -2, :type => :rvalue,
     :doc => "Calls an external command on the Puppet master and returns
     the results of the command.  Any arguments are passed to the external command as
     arguments.  If the generator does not exit with return code of 0,

data/lib/puppet/parser/functions/hiera.rb

@@ -1,5 +1,5 @@
 module Puppet::Parser::Functions
-  newfunction(:hiera, :type => :rvalue) do |*args|
+  newfunction(:hiera, :type => :rvalue, :arity => -2) do |*args|
     require 'hiera_puppet'
     key, default, override = HieraPuppet.parse_args(args)
     HieraPuppet.lookup(key, default, self, override, :priority)

data/lib/puppet/parser/functions/hiera_array.rb

@@ -1,5 +1,5 @@
 module Puppet::Parser::Functions
-  newfunction(:hiera_array, :type => :rvalue) do |*args|
+  newfunction(:hiera_array, :type => :rvalue, :arity => -2) do |*args|
     require 'hiera_puppet'
     key, default, override = HieraPuppet.parse_args(args)
     HieraPuppet.lookup(key, default, self, override, :array)

data/lib/puppet/parser/functions/hiera_hash.rb

@@ -1,5 +1,5 @@
 module Puppet::Parser::Functions
-  newfunction(:hiera_hash, :type => :rvalue) do |*args|
+  newfunction(:hiera_hash, :type => :rvalue, :arity => -2) do |*args|
     require 'hiera_puppet'
     key, default, override = HieraPuppet.parse_args(args)
     HieraPuppet.lookup(key, default, self, override, :hash)

data/lib/puppet/parser/functions/hiera_include.rb

@@ -1,5 +1,5 @@
 module Puppet::Parser::Functions
-  newfunction(:hiera_include) do |*args|
+  newfunction(:hiera_include, :arity => -2) do |*args|
     require 'hiera_puppet'
     key, default, override = HieraPuppet.parse_args(args)
     if answer = HieraPuppet.lookup(key, default, self, override, :array)

data/lib/puppet/parser/functions/include.rb

@@ -1,5 +1,5 @@
 # Include the specified classes
-Puppet::Parser::Functions::newfunction(:include, :doc => "Evaluate one or more classes.") do |vals|
+Puppet::Parser::Functions::newfunction(:include, :arity => -2, :doc => "Evaluate one or more classes.") do |vals|
     if vals.is_a?(Array)
       # Protect against array inside array
       vals = vals.flatten

data/lib/puppet/parser/functions/inline_template.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :doc =>
+Puppet::Parser::Functions::newfunction(:inline_template, :type => :rvalue, :arity => -2, :doc =>
   "Evaluate a template string and return its value.  See 
   [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for 
   more information.  Note that if multiple template strings are specified, their 

data/lib/puppet/parser/functions/md5.rb

@@ -1,5 +1,5 @@
 require 'digest/md5'
 
-Puppet::Parser::Functions::newfunction(:md5, :type => :rvalue, :doc => "Returns a MD5 hash value from a provided string.") do |args|
+Puppet::Parser::Functions::newfunction(:md5, :type => :rvalue, :arity => 1, :doc => "Returns a MD5 hash value from a provided string.") do |args|
       Digest::MD5.hexdigest(args[0])
 end

data/lib/puppet/parser/functions/realize.rb

@@ -1,7 +1,7 @@
 # This is just syntactic sugar for a collection, although it will generally
 # be a good bit faster.
 
-Puppet::Parser::Functions::newfunction(:realize, :doc => "Make a virtual object real.  This is useful
+Puppet::Parser::Functions::newfunction(:realize, :arity => -2, :doc => "Make a virtual object real.  This is useful
     when you want to know the name of the virtual object and don't want to
     bother with a full collection.  It is slightly faster than a collection,
     and, of course, is a bit shorter.  You must pass the object using a

data/lib/puppet/parser/functions/regsubst.rb

@@ -24,10 +24,9 @@
 # other dealings in this Software without prior written authorization
 # from Thomas Bellman.
 
-module Puppet::Parser::Functions
-
-  newfunction(
+Puppet::Parser::Functions::newfunction(
   :regsubst, :type => :rvalue,
+  :arity => -4,
 
   :doc => "
 Perform regexp replacement on a string or array of strings.
@@ -56,64 +55,62 @@ Get the third octet from the node's IP address:
 Put angle brackets around each octet in the node's IP address:
 
     $x = regsubst($ipaddress, '([0-9]+)', '<\\1>', 'G')
-") \
-  do |args|
-    unless args.length.between?(3, 5)
+") do |args|
+  unless args.length.between?(3, 5)
 
-      raise(
-        Puppet::ParseError,
+    raise(
+      ArgumentError,
 
-          "regsubst(): got #{args.length} arguments, expected 3 to 5")
-    end
-    target, regexp, replacement, flags, lang = args
-    reflags = 0
-    operation = :sub
-    if flags == nil
-      flags = []
-    elsif flags.respond_to?(:split)
-      flags = flags.split('')
-    else
-
-      raise(
-        Puppet::ParseError,
-
-          "regsubst(): bad flags parameter #{flags.class}:`#{flags}'")
-    end
-    flags.each do |f|
-      case f
-      when 'G' then operation = :gsub
-      when 'E' then reflags |= Regexp::EXTENDED
-      when 'I' then reflags |= Regexp::IGNORECASE
-      when 'M' then reflags |= Regexp::MULTILINE
-      else raise(Puppet::ParseError, "regsubst(): bad flag `#{f}'")
-      end
+        "regsubst(): got #{args.length} arguments, expected 3 to 5")
+  end
+  target, regexp, replacement, flags, lang = args
+  reflags = 0
+  operation = :sub
+  if flags == nil
+    flags = []
+  elsif flags.respond_to?(:split)
+    flags = flags.split('')
+  else
+
+    raise(
+      Puppet::ParseError,
+
+        "regsubst(): bad flags parameter #{flags.class}:`#{flags}'")
+  end
+  flags.each do |f|
+    case f
+    when 'G' then operation = :gsub
+    when 'E' then reflags |= Regexp::EXTENDED
+    when 'I' then reflags |= Regexp::IGNORECASE
+    when 'M' then reflags |= Regexp::MULTILINE
+    else raise(Puppet::ParseError, "regsubst(): bad flag `#{f}'")
     end
-    begin
-      re = Regexp.compile(regexp, reflags, lang)
-    rescue RegexpError, TypeError
+  end
+  begin
+    re = Regexp.compile(regexp, reflags, lang)
+  rescue RegexpError, TypeError
 
-      raise(
-        Puppet::ParseError,
+    raise(
+      Puppet::ParseError,
 
-          "regsubst(): Bad regular expression `#{regexp}'")
-    end
-    if target.respond_to?(operation)
-      # String parameter -> string result
-      result = target.send(operation, re, replacement)
-    elsif target.respond_to?(:collect) and
-      target.respond_to?(:all?) and
-      target.all? { |e| e.respond_to?(operation) }
-      # Array parameter -> array result
-      result = target.collect { |e|
-        e.send(operation, re, replacement)
-      }
-    else
-
-      raise(
-        Puppet::ParseError,
-
-          "regsubst(): bad target #{target.class}:`#{target}'")
-    end
-    return result
+        "regsubst(): Bad regular expression `#{regexp}'")
+  end
+  if target.respond_to?(operation)
+    # String parameter -> string result
+    result = target.send(operation, re, replacement)
+  elsif target.respond_to?(:collect) and
+    target.respond_to?(:all?) and
+    target.all? { |e| e.respond_to?(operation) }
+    # Array parameter -> array result
+    result = target.collect { |e|
+      e.send(operation, re, replacement)
+    }
+  else
+
+    raise(
+      Puppet::ParseError,
+
+        "regsubst(): bad target #{target.class}:`#{target}'")
   end
+  return result
 end

data/lib/puppet/parser/functions/require.rb

@@ -2,6 +2,7 @@
 
   Puppet::Parser::Functions::newfunction(
     :require,
+    :arity => -2,
     :doc =>"Evaluate one or more classes,  adding the required class as a dependency.
 
 The relationship metaparameters work well for specifying relationships

data/lib/puppet/parser/functions/search.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions::newfunction(:search, :doc => "Add another namespace for this class to search.
+Puppet::Parser::Functions::newfunction(:search, :arity => -2, :doc => "Add another namespace for this class to search.
     This allows you to create classes with sets of definitions and add
     those classes to another class's search path.") do |vals|
     vals.each do |val|

data/lib/puppet/parser/functions/sha1.rb

@@ -1,5 +1,5 @@
 require 'digest/sha1'
 
-Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
+Puppet::Parser::Functions::newfunction(:sha1, :type => :rvalue, :arity => 1, :doc => "Returns a SHA1 hash value from a provided string.") do |args|
       Digest::SHA1.hexdigest(args[0])
 end

data/lib/puppet/parser/functions/shellquote.rb

@@ -24,7 +24,7 @@
 # other dealings in this Software without prior written authorization
 # from Thomas Bellman.
 
-Puppet::Parser::Functions.newfunction(:shellquote, :type => :rvalue, :doc => "\
+Puppet::Parser::Functions.newfunction(:shellquote, :type => :rvalue, :arity => -1, :doc => "\
     Quote and concatenate arguments for use in Bourne shell.
 
     Each argument is quoted separately, and then all are concatenated

data/lib/puppet/parser/functions/split.rb

@@ -2,6 +2,7 @@ module Puppet::Parser::Functions
 
   newfunction(
   :split, :type => :rvalue,
+  :arity => 2,
 
     :doc => "\
 Split a string variable into an array using the specified split regexp.
@@ -22,8 +23,6 @@ a regexp meta-character (.), which must be escaped.  A simple
 way to do that for a single character is to enclose it in square
 brackets; a backslash will also escape a single character.") do |args|
 
-  raise Puppet::ParseError, ("split(): wrong number of arguments (#{args.length}; must be 2)") if args.length != 2
-
   return args[0].split(Regexp.compile(args[1]))
   end
 end

data/lib/puppet/parser/functions/sprintf.rb

@@ -24,16 +24,13 @@
 # other dealings in this Software without prior written authorization
 # from Thomas Bellman.
 
-module Puppet::Parser::Functions
-
-  newfunction(
+Puppet::Parser::Functions::newfunction(
   :sprintf, :type => :rvalue,
+  :arity => -2,
+  :doc => "Perform printf-style formatting of text.
 
-    :doc => "Perform printf-style formatting of text.
-
-      The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the `Kernel::sprintf` function in Ruby for all the details.") do |args|
-    raise Puppet::ParseError, 'sprintf() needs at least one argument' if args.length < 1
-    fmt = args.shift
-    return sprintf(fmt, *args)
-  end
+      The first parameter is format string describing how the rest of the parameters should be formatted.  See the documentation for the `Kernel::sprintf` function in Ruby for all the details."
+) do |args|
+  fmt = args.shift
+  return sprintf(fmt, *args)
 end

data/lib/puppet/parser/functions/tag.rb

@@ -1,5 +1,5 @@
 # Tag the current scope with each passed name
-Puppet::Parser::Functions::newfunction(:tag, :doc => "Add the specified tags to the containing class
+Puppet::Parser::Functions::newfunction(:tag, :arity => -2, :doc => "Add the specified tags to the containing class
   or definition.  All contained objects will then acquire that tag, also.
   ") do |vals|
     self.resource.tag(*vals)

data/lib/puppet/parser/functions/tagged.rb

@@ -1,5 +1,5 @@
 # Test whether a given tag is set.  This functions as a big OR -- if any of the specified tags are unset, we return false.
-Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :doc => "A boolean function that
+Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2, :doc => "A boolean function that
   tells you whether the current container is tagged with the specified tags.
   The tags are ANDed, so that all of the specified tags must be included for
   the function to return true.") do |vals|

data/lib/puppet/parser/functions/template.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :doc =>
+Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2, :doc =>
   "Evaluate a template and return its value.  See
   [the templating docs](http://docs.puppetlabs.com/guides/templating.html) for 
   more information.

data/lib/puppet/parser/functions/versioncmp.rb

@@ -1,6 +1,6 @@
 require 'puppet/util/package'
 
-Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue, :doc =>
+Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue, :arity => 2, :doc =>
 "Compares two version numbers.
 
 Prototype:
@@ -26,9 +26,5 @@ This function uses the same version comparison algorithm used by Puppet's
 
 ") do |args|
 
-  unless args.length == 2
-    raise Puppet::ParseError, "versioncmp should have 2 arguments"
-  end
-
   return Puppet::Util::Package.versioncmp(args[0], args[1])
 end

data/lib/puppet/parser/parser_support.rb

@@ -136,34 +136,18 @@ class Puppet::Parser::Parser
 
   # how should I do error handling here?
   def parse(string = nil)
-    if self.file =~ /\.rb$/
-      main = parse_ruby_file
-    else
-      self.string = string if string
-      begin
-        @yydebug = false
-        main = yyparse(@lexer,:scan)
-      rescue Puppet::ParseError => except
-        except.line ||= @lexer.line
-        except.file ||= @lexer.file
-        raise except
-      rescue => except
-        raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, except)
-      end
-    end
-    # Store the results as the top-level class.
-    return Puppet::Parser::AST::Hostclass.new('', :code => main)
+    self.string = string if string
+
+    @yydebug = false
+    code = yyparse(@lexer, :scan)
+    Puppet::Parser::AST::Hostclass.new('', :code => code)
+  rescue Puppet::ParseError => except
+    except.line ||= @lexer.line
+    except.file ||= @lexer.file
+    raise except
+  rescue => except
+    raise Puppet::ParseError.new(except.message, @lexer.file, @lexer.line, except)
   ensure
     @lexer.clear
   end
-
-  def parse_ruby_file
-    # Execute the contents of the file inside its own "main" object so
-    # that it can call methods in the resource type API.
-    main_object = Puppet::DSL::ResourceTypeAPI.new
-    main_object.instance_eval(File.read(self.file))
-
-    # Then extract any types that were created.
-    Puppet::Parser::AST::ASTArray.new :children => main_object.instance_eval { @__created_ast_objects__ }
-  end
 end