puppet 3.2.4 → 3.3.0.rc2

data/lib/puppet/parser/files.rb

@@ -1,10 +1,5 @@
 require 'puppet/module'
-#require 'puppet/parser/parser'
 
-# This is a silly central module for finding
-# different kinds of files while parsing.  This code
-# doesn't really belong in the Puppet::Module class,
-# but it doesn't really belong anywhere else, either.
 module Puppet; module Parser; module Files
 
   module_function

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

@@ -45,52 +45,29 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
   ENDHEREDOC
   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
-    if resource = Puppet::Type.type(type_name.to_sym)
-      type_of_resource = :type
-    elsif resource = find_definition(type_name.downcase)
-      type_of_resource = :define
-    else
-      raise ArgumentError, "could not create resource of unknown type #{type_name}"
-    end
+  type, instances, defaults = args
+  defaults ||= {}
+
+  resource = Puppet::Parser::AST::Resource.new(:type => type.sub(/^@{1,2}/, '').downcase, :instances =>
+    instances.collect do |title, params|
+      Puppet::Parser::AST::ResourceInstance.new(
+        :title => Puppet::Parser::AST::Leaf.new(:value => title),
+        :parameters => defaults.merge(params).collect do |name, value|
+          Puppet::Parser::AST::ResourceParam.new(
+            :param => name,
+            :value => Puppet::Parser::AST::Leaf.new(:value => value))
+        end)
+    end)
+
+  if type.start_with? '@@'
+    resource.exported = true
+  elsif type.start_with? '@'
+    resource.virtual = true
   end
-  # iterate through the resources to create
-  defaults = args[2] || {}
-  args[1].each do |title, params|
-    params = Puppet::Util.symbolizehash(defaults.merge(params))
-    raise ArgumentError, 'params should not contain title' if(params[:title])
-    case type_of_resource
-    # JJM The only difference between a type and a define is the call to instantiate_resource
-    # 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
-      if type_of_resource == :define then
-        resource.instantiate_resource(self, p_resource)
-      end
-      compiler.add_resource(self, p_resource)
-    when :class
-      klass = find_hostclass(title)
-      raise ArgumentError, "could not find hostclass #{title}" unless klass
-      klass.ensure_in_catalog(self, params)
-      compiler.catalog.add_class(title)
-    end
+
+  begin
+    resource.safeevaluate(self)
+  rescue Puppet::ParseError => internal_error
+    raise internal_error.original
   end
 end

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

@@ -42,7 +42,6 @@ Puppet::Parser::Functions::newfunction(
     end
     enumerator = o.each
     index = 0
-    result = nil
     if serving_size == 1
       (o.size).times do
         pblock.call(scope, enumerator.next)
@@ -68,7 +67,6 @@ Puppet::Parser::Functions::newfunction(
       raise ArgumentError, "Block must define at most two parameters (for hash entry key and value)."
     end
     enumerator = o.each_pair
-    result = nil
     if serving_size == 1
       (o.size).times do
         pblock.call(scope, enumerator.next)

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

@@ -9,7 +9,7 @@ uses CSV files but the concept can easily be adjust for databases, yaml
 or any other queryable data source.
 
 The object of this is to make it obvious when it's being used, rather than
-magically loading data in when an module is loaded I prefer to look at the code
+magically loading data in when a module is loaded I prefer to look at the code
 and see statements like:
 
     $snmp_contact = extlookup(\"snmp_contact\")
@@ -26,7 +26,7 @@ Over time there will be a lot of this kind of thing spread all over your manifes
 and adding an additional client involves grepping through manifests to find all the
 places where you have constructs like this.
 
-This is a data problem and shouldn't be handled in code, a using this function you
+This is a data problem and shouldn't be handled in code, and using this function you
 can do just that.
 
 First you configure it in site.pp:

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

@@ -42,7 +42,6 @@ Puppet::Parser::Functions::newfunction(
     end
     enumerator = o.each
     index = 0
-    result = nil
     if serving_size == 1
       (o.size).times do
         pblock.call(scope, enumerator.next)
@@ -68,7 +67,6 @@ Puppet::Parser::Functions::newfunction(
       raise ArgumentError, "Block must define at most two parameters (for hash entry key and value)."
     end
     enumerator = o.each_pair
-    result = nil
     if serving_size == 1
       (o.size).times do
         pblock.call(scope, enumerator.next)

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

@@ -35,7 +35,7 @@ module Puppet::Parser::Functions
     key, default, override = HieraPuppet.parse_args(args)
     if answer = HieraPuppet.lookup(key, default, self, override, :array)
       method = Puppet::Parser::Functions.function(:include)
-      send(method, answer)
+      send(method, [answer])
     else
       raise Puppet::ParseError, "Could not find data item #{key}"
     end

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

@@ -0,0 +1,44 @@
+Puppet::Parser::Functions.newfunction(:lookup, :type => :rvalue, :arity => -2, :doc => <<-'ENDHEREDOC') do |args|
+Looks up data defined using Puppet Bindings.
+The function is callable with one or two arguments and optionally with a lambda to process the result.
+The second argument can be a type specification; a String that describes the type of the produced result.
+If a value is found, an assert is made that the value is compliant with the specified type.
+
+When called with one argument; the name:
+
+    lookup('the_name')
+
+When called with two arguments; the name, and the expected type:
+
+    lookup('the_name', 'String')
+
+Using a lambda to process the looked up result.
+
+    lookup('the_name') |$result| { if $result == undef { 'Jane Doe' } else { $result }}
+
+The type specification is one of:
+
+* the basic types; 'Integer', 'String', 'Float', 'Boolean', or 'Pattern' (regular expression)
+* an Array with an optional element type given in '[]', that when not given defaults to '[Data]'
+* a Hash with optional key and value types given in '[]', where key type defaults to 'Literal' and value to 'Data', if
+  only one type is given, the key defaults to 'Literal'
+* the abstract type 'Literal' which is one of the basic types
+* the abstract type 'Data' which is 'Literal', or type compatible with Array[Data], or Hash[Literal, Data]
+* the abstract type 'Collection' which is Array or Hash of any element type.
+* the abstract type 'Object' which is any kind of type
+
+ENDHEREDOC
+
+  unless Puppet[:binder] || Puppet[:parser] == 'future'
+    raise Puppet::ParseError, "The lookup function is only available with settings --binder true, or --parser future" 
+  end
+  type_parser = Puppet::Pops::Types::TypeParser.new
+  pblock    = args[-1] if args[-1].is_a?(Puppet::Parser::AST::Lambda)
+  type_name = args[1] unless args[1].is_a?(Puppet::Parser::AST::Lambda)
+  type = type_parser.parse( type_name || "Data")
+  result = compiler.injector.lookup(self, type, args[0])
+  if pblock
+    result = pblock.call(self, result.nil? ? :undef : result)
+  end
+  result.nil? ? :undef : result
+end

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

@@ -79,7 +79,7 @@ Puppet::Parser::Functions::newfunction(
     end
   end
   raise ArgumentError, ("slice(): wrong argument type (#{args[1]}; must be number.") unless slice_size
-  raise ArgumentError, ("slice(): wrong argument value: #{slice_size}; is not an positive integer number > 0") unless slice_size.is_a?(Fixnum) && slice_size > 0
+  raise ArgumentError, ("slice(): wrong argument value: #{slice_size}; is not a positive integer number > 0") unless slice_size.is_a?(Fixnum) && slice_size > 0
   receiver = args[0]
 
   # the block is optional, ok if nil, function then produces an array

data/lib/puppet/parser/grammar.ra

@@ -783,7 +783,6 @@ hasharrayaccesses:    hasharrayaccess
 end
 ---- header ----
 require 'puppet'
-require 'puppet/util/loadedfile'
 require 'puppet/parser/lexer'
 require 'puppet/parser/ast'
 

data/lib/puppet/parser/lexer.rb

@@ -460,7 +460,6 @@ class Puppet::Parser::Lexer
     skip
 
     until token_queue.empty? and @scanner.eos? do
-      yielded = false
       matched_token, value = find_token
 
       # error out if we didn't match anything at all

data/lib/puppet/parser/parser.rb

@@ -7,7 +7,6 @@
 require 'racc/parser.rb'
 
 require 'puppet'
-require 'puppet/util/loadedfile'
 require 'puppet/parser/lexer'
 require 'puppet/parser/ast'
 

data/lib/puppet/parser/parser_factory.rb

@@ -29,7 +29,8 @@ module Puppet::Parser
     def self.eparser(environment)
       # Since RGen is optional, test that it is installed
       @@asserted ||= false
-      assert_rgen_installed() unless @asserted
+      assert_rgen_installed() unless @@asserted
+      @@asserted = true
       require 'puppet/parser'
       require 'puppet/parser/e_parser_adapter'
       EParserAdapter.new(Puppet::Parser::Parser.new(environment))
@@ -53,7 +54,7 @@ module Puppet::Parser
         container.left_expr = litstring
         raise "no eContainer" if litstring.eContainer() != container
         raise "no eContainingFeature" if litstring.eContainingFeature() != :left_expr
-      rescue =>e
+      rescue
         raise Puppet::DevError.new("The gem 'rgen' version >= 0.6.1 is required when using '--parser future'. An older version is installed, please update.")
       end
     end

data/lib/puppet/parser/parser_support.rb

@@ -69,7 +69,7 @@ class Puppet::Parser::Parser
 
   # Raise a Parse error.
   def error(message, options = {})
-    if brace = @lexer.expected
+    if @lexer.expected
       message += "; expected '%s'"
     end
     except = Puppet::ParseError.new(message)

data/lib/puppet/parser/relationship.rb

@@ -50,7 +50,7 @@ class Puppet::Parser::Relationship
     unless source_resource = catalog.resource(source)
       raise ArgumentError, "Could not find resource '#{source}' for relationship on '#{target}'"
     end
-    unless target_resource = catalog.resource(target)
+    unless catalog.resource(target)
       raise ArgumentError, "Could not find resource '#{target}' for relationship from '#{source}'"
     end
     Puppet.debug "Adding relationship from #{source} to #{target} with '#{param_name}'"

data/lib/puppet/parser/scope.rb

@@ -74,6 +74,22 @@ class Puppet::Parser::Scope
     def parent
       @parent
     end
+
+    def add_entries_to(target = {})
+      @parent.add_entries_to(target) unless @parent.nil?
+      # do not return pure ephemeral ($0-$n)
+      if is_local_scope?
+        @symbols.each do |k, v|
+          if v == :undef
+            target.delete(k)
+          else
+            target[ k ] = v
+          end
+        end
+      end
+      target
+    end
+
   end
 
   # Initialize a new scope suitable for parser function testing.  This method
@@ -182,7 +198,7 @@ class Puppet::Parser::Scope
     @tags = []
 
     # The symbol table for this scope.  This is where we store variables.
-    @symtable = Ephemeral.new
+    @symtable = Ephemeral.new(nil, true)
 
     @ephemeral = [ Ephemeral.new(@symtable) ]
 
@@ -267,7 +283,7 @@ class Puppet::Parser::Scope
   # @api public
   def lookupvar(name, options = {})
     unless name.is_a? String
-      raise Puppet::DevError, "Scope variable name is a #{name.class}, not a string"
+      raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
     end
 
     table = @ephemeral.last
@@ -305,7 +321,7 @@ class Puppet::Parser::Scope
   # The scope of the inherited thing of this scope's resource. This could
   # either be a node that was inherited or the class.
   #
-  # @returns [Puppet::Parser::Scope] The scope or nil if there is not an inherited scope
+  # @return [Puppet::Parser::Scope] The scope or nil if there is not an inherited scope
   def inherited_scope
     if has_inherited_class?
       qualified_scope(resource.resource_type.parent)
@@ -320,7 +336,7 @@ class Puppet::Parser::Scope
   # scope in which it was included. The chain of parent scopes is followed
   # until a node scope or the topscope is found
   #
-  # @returns [Puppet::Parser::Scope] The scope or nil if there is no enclosing scope
+  # @return [Puppet::Parser::Scope] The scope or nil if there is no enclosing scope
   def enclosing_scope
     if has_enclosing_scope?
       if parent.is_topscope? or parent.is_nodescope?
@@ -347,7 +363,11 @@ class Puppet::Parser::Scope
 
   def lookup_qualified_variable(class_name, variable_name, position)
     begin
-      qualified_scope(class_name).lookupvar(variable_name, position)
+      if lookup_as_local_name?(class_name, variable_name)
+        self[variable_name]
+      else
+        qualified_scope(class_name).lookupvar(variable_name, position)
+      end
     rescue RuntimeError => e
       location = if position[:lineproc]
                    " at #{position[:lineproc].call}"
@@ -361,6 +381,21 @@ class Puppet::Parser::Scope
     end
   end
 
+  # Handles the special case of looking up fully qualified variable in not yet evaluated top scope
+  # This is ok if the lookup request originated in topscope (this happens when evaluating
+  # bindings; using the top scope to provide the values for facts.
+  # @param class_name [String] the classname part of a variable name, may be special ""
+  # @param variable_name [String] the variable name without the absolute leading '::'
+  # @return [Boolean] true if the given variable name should be looked up directly in this scope
+  #
+  def lookup_as_local_name?(class_name, variable_name)
+    # not a local if name has more than one segment
+    return nil if variable_name =~ /::/
+    # partial only if the class for "" cannot be found
+    return nil unless class_name == "" && klass = find_hostclass(class_name) && class_scope(klass).nil?
+    is_topscope?
+  end
+
   def has_inherited_class?
     is_classscope? and resource.resource_type.parent
   end
@@ -378,9 +413,10 @@ class Puppet::Parser::Scope
   end
   private :qualified_scope
 
-  # Return a hash containing our variables and their values, optionally (and
-  # by default) including the values defined in our parent.  Local values
-  # shadow parent values.
+  # Returns a Hash containing all variables and their values, optionally (and
+  # by default) including the values defined in parent. Local values
+  # shadow parent values. Ephemeral scopes for match results ($0 - $n) are not included.
+  #
   def to_hash(recursive = true)
     if recursive and parent
       target = parent.to_hash(recursive)
@@ -388,14 +424,8 @@ class Puppet::Parser::Scope
       target = Hash.new
     end
 
-    @symtable.each do |name, value|
-      if value == :undef
-        target.delete(name)
-      else
-        target[name] = value
-      end
-    end
-
+    # add all local scopes
+    @ephemeral.last.add_entries_to(target)
     target
   end
 
@@ -441,7 +471,7 @@ class Puppet::Parser::Scope
       raise Puppet::ParseError.new("Cannot assign to a numeric match result variable '$#{name}'") unless options[:ephemeral]
     end
     unless name.is_a? String
-      raise Puppet::DevError, "Scope variable name is a #{name.class}, not a string"
+      raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
     end
 
     table = effective_symtable options[:ephemeral]
@@ -469,7 +499,7 @@ class Puppet::Parser::Scope
   # scope's symtable. If the parameter `use_ephemeral` is true, the "top most" ephemeral "table"
   # will be returned (irrespective of it being a match scope or a local scope).
   #
-  # @param [Boolean] whether the top most ephemeral (of any kind) should be used or not
+  # @param use_ephemeral [Boolean] whether the top most ephemeral (of any kind) should be used or not
   def effective_symtable use_ephemeral
     s = @ephemeral.last
     return s if use_ephemeral
@@ -523,12 +553,7 @@ class Puppet::Parser::Scope
     if level == :all
       @ephemeral = [ Ephemeral.new(@symtable)]
     else
-      # If we ever drop 1.8.6 and lower, this should be replaced by a single
-      # pop-with-a-count - or if someone more ambitious wants to monkey-patch
-      # that feature into older rubies. --daniel 2012-07-16
-      (@ephemeral.size - level).times do
-        @ephemeral.pop
-      end
+      @ephemeral.pop(@ephemeral.size - level)
     end
   end
 

data/lib/puppet/parser/type_loader.rb

@@ -95,15 +95,7 @@ class Puppet::Parser::TypeLoader
     # behavior) only load files from the first module of a given name.  E.g.,
     # given first/foo and second/foo, only files from first/foo will be loaded.
     environment.modules.each do |mod|
-      manifest_files = []
-      if File.exists?(mod.manifests)
-        Find.find(mod.manifests) do |path|
-          if path.end_with?(".pp") || path.end_with?(".rb")
-            manifest_files << path
-          end
-        end
-      end
-      load_files(mod.name, manifest_files)
+      load_files(mod.name, mod.all_manifests)
     end
   end
 
@@ -117,7 +109,7 @@ class Puppet::Parser::TypeLoader
   # Try to load the object with the given fully qualified name.
   def try_load_fqname(type, fqname)
     return nil if fqname == "" # special-case main.
-    name2files(fqname).each do |filename|
+    files_to_try_for(fqname).each do |filename|
       begin
         imported_types = import_from_modules(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
@@ -125,7 +117,6 @@ class Puppet::Parser::TypeLoader
           return result
         end
       rescue Puppet::ImportError => detail
-        # We couldn't load the item
         # I'm not convienced we should just drop these errors, but this
         # preserves existing behaviours.
       end
@@ -171,13 +162,17 @@ class Puppet::Parser::TypeLoader
 
   # Return a list of all file basenames that should be tried in order
   # to load the object with the given fully qualified name.
-  def name2files(fqname)
-    result = []
-    ary = fqname.split("::")
-    while ary.length > 0
-      result << ary.join(File::SEPARATOR)
-      ary.pop
+  def files_to_try_for(qualified_name)
+    qualified_name.split('::').inject([]) do |paths, name|
+      add_path_for_name(paths, name)
+    end
+  end
+
+  def add_path_for_name(paths, name)
+    if paths.empty?
+      [name]
+    else
+      paths.unshift(File.join(paths.first, name))
     end
-    return result
   end
 end