From 0d2e0672eb516a1b1f2ced6b8c74bd2064dd205e Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Wed, 8 Jun 2011 07:03:54 -0700
Subject: Adding []/[]= support to Scope

The interface to scope is much clearer this way anyway,
but this is needed to integrate Puppet with Hiera[1].
It just provides hash-like behavior to Scope, which Hiera
and others can now easily rely on.

I also went through all of the code that used Scope#lookupvar
and Scope#setvar and changed it if possible, and at the same
time cleaned up a lot of tests that were unnecessarily stubbing
(and thus making it difficult to tell if I had actually broken
anything).

1 - https://github.com/ripienaar/hiera

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/ast/leaf.rb            |  4 +--
 lib/puppet/parser/compiler.rb            |  4 +--
 lib/puppet/parser/functions/extlookup.rb | 12 +++----
 lib/puppet/parser/functions/fqdn_rand.rb |  2 +-
 lib/puppet/parser/resource.rb            |  2 +-
 lib/puppet/parser/scope.rb               | 57 +++++++++++++++++++-------------
 lib/puppet/parser/templatewrapper.rb     |  4 +--
 lib/puppet/resource/type.rb              | 16 ++++-----
 8 files changed, 56 insertions(+), 45 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/ast/leaf.rb b/lib/puppet/parser/ast/leaf.rb
index c8ebc9483..64a197492 100644
--- a/lib/puppet/parser/ast/leaf.rb
+++ b/lib/puppet/parser/ast/leaf.rb
@@ -124,7 +124,7 @@ class Puppet::Parser::AST
     # not include syntactical constructs, like '$' and '{}').
     def evaluate(scope)
       parsewrap do
-        if (var = scope.lookupvar(@value, :file => file, :line => line)) == :undefined
+        if (var = scope[@value, {:file => file, :line => line}]) == :undefined
           var = :undef
         end
         var
@@ -141,7 +141,7 @@ class Puppet::Parser::AST
 
     def evaluate_container(scope)
       container = variable.respond_to?(:evaluate) ? variable.safeevaluate(scope) : variable
-      (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope.lookupvar(container, :file => file, :line => line)
+      (container.is_a?(Hash) or container.is_a?(Array)) ? container : scope[container, {:file => file, :line => line}]
     end
 
     def evaluate_key(scope)
diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index c1daade4c..f43a31285 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -450,7 +450,7 @@ class Puppet::Parser::Compiler
   # Set the node's parameters into the top-scope as variables.
   def set_node_parameters
     node.parameters.each do |param, value|
-      @topscope.setvar(param, value)
+      @topscope[param] = value
     end
 
     # These might be nil.
@@ -473,7 +473,7 @@ class Puppet::Parser::Compiler
 
     Puppet.settings.each do |name, setting|
       next if name.to_s == "name"
-      scope.setvar name.to_s, environment[name]
+      scope[name.to_s] = environment[name]
     end
   end
 
diff --git a/lib/puppet/parser/functions/extlookup.rb b/lib/puppet/parser/functions/extlookup.rb
index 5fbf26cec..9ffca59a7 100644
--- a/lib/puppet/parser/functions/extlookup.rb
+++ b/lib/puppet/parser/functions/extlookup.rb
@@ -91,9 +91,9 @@ This is for back compatibility to interpolate variables with %. % interpolation
 
   raise Puppet::ParseError, ("extlookup(): wrong number of arguments (#{args.length}; must be <= 3)") if args.length > 3
 
-  extlookup_datadir = undef_as('',lookupvar('::extlookup_datadir'))
+  extlookup_datadir = undef_as('',self['::extlookup_datadir'])
 
-  extlookup_precedence = undef_as([],lookupvar('::extlookup_precedence')).collect { |var| var.gsub(/%\{(.+?)\}/) { lookupvar("::#{$1}") } }
+  extlookup_precedence = undef_as([],self['::extlookup_precedence']).collect { |var| var.gsub(/%\{(.+?)\}/) { self["::#{$1}"] } }
 
   datafiles = Array.new
 
@@ -121,9 +121,9 @@ This is for back compatibility to interpolate variables with %. % interpolation
           if result[0].length == 2
             val = result[0][1].to_s
 
-            # parse %{}'s in the CSV into local variables using lookupvar()
+            # parse %{}'s in the CSV into local variables using the current scope
             while val =~ /%\{(.+?)\}/
-              val.gsub!(/%\{#{$1}\}/, lookupvar($1))
+              val.gsub!(/%\{#{$1}\}/, self[$1])
             end
 
             desired = val
@@ -134,9 +134,9 @@ This is for back compatibility to interpolate variables with %. % interpolation
             # Individual cells in a CSV result are a weird data type and throws
             # puppets yaml parsing, so just map it all to plain old strings
             desired = cells.map do |c|
-              # parse %{}'s in the CSV into local variables using lookupvar()
+              # parse %{}'s in the CSV into local variables using the current scope
               while c =~ /%\{(.+?)\}/
-                c.gsub!(/%\{#{$1}\}/, lookupvar($1))
+                c.gsub!(/%\{#{$1}\}/, self[$1])
               end
 
               c.to_s
diff --git a/lib/puppet/parser/functions/fqdn_rand.rb b/lib/puppet/parser/functions/fqdn_rand.rb
index 93ab98bcd..668802e73 100644
--- a/lib/puppet/parser/functions/fqdn_rand.rb
+++ b/lib/puppet/parser/functions/fqdn_rand.rb
@@ -7,6 +7,6 @@ Puppet::Parser::Functions::newfunction(:fqdn_rand, :type => :rvalue, :doc =>
       $random_number_seed = fqdn_rand(30,30)") do |args|
     require 'digest/md5'
     max = args.shift
-    srand(Digest::MD5.hexdigest([lookupvar('::fqdn'),args].join(':')).hex)
+    srand(Digest::MD5.hexdigest([self['::fqdn'],args].join(':')).hex)
     rand(max).to_s
 end
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 3bb5f8601..305ba81e8 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -258,7 +258,7 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   def add_backward_compatible_relationship_param(name)
     # Skip metaparams for which we get no value.
-    return unless val = scope.lookupvar(name.to_s) and val != :undefined
+    return unless val = scope[name.to_s] and val != :undefined
 
     # The default case: just set the value
     set_parameter(name, val) and return unless @parameters[name]
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index ed67cd141..67dcb1cb0 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -48,6 +48,35 @@ class Puppet::Parser::Scope
     end
   end
 
+  def [](name, options = {})
+    table = ephemeral?(name) ? @ephemeral.last : @symtable
+    # If the variable is qualified, then find the specified scope and look the variable up there instead.
+    if name =~ /^(.*)::(.+)$/
+      begin
+        qualified_scope($1)[$2,options]
+      rescue RuntimeError => e
+        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
+        warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
+        :undefined
+      end
+    elsif ephemeral_include?(name) or table.include?(name)
+      # We can't use "if table[name]" here because the value might be false
+      if options[:dynamic] and self != compiler.topscope
+        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
+        Puppet.deprecation_warning "Dynamic lookup of $#{name}#{location} is deprecated.  Support will be removed in Puppet 2.8.  Use a fully-qualified variable name (e.g., $classname::variable) or parameterized classes."
+      end
+      table[name]
+    elsif parent
+      parent[name,options.merge(:dynamic => (dynamic || options[:dynamic]))]
+    else
+      :undefined
+    end
+  end
+
+  def []=(var, value)
+    setvar(var, value)
+  end
+
   # A demeterific shortcut to the catalog.
   def catalog
     compiler.catalog
@@ -223,29 +252,9 @@ class Puppet::Parser::Scope
   private :qualified_scope
 
   # Look up a variable.  The simplest value search we do.
+  # This method is effectively deprecated - use self[] instead.
   def lookupvar(name, options = {})
-    table = ephemeral?(name) ? @ephemeral.last : @symtable
-    # If the variable is qualified, then find the specified scope and look the variable up there instead.
-    if name =~ /^(.*)::(.+)$/
-      begin
-        qualified_scope($1).lookupvar($2,options)
-      rescue RuntimeError => e
-        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
-        warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
-        :undefined
-      end
-    elsif ephemeral_include?(name) or table.include?(name)
-      # We can't use "if table[name]" here because the value might be false
-      if options[:dynamic] and self != compiler.topscope
-        location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
-        Puppet.deprecation_warning "Dynamic lookup of $#{name}#{location} is deprecated.  Support will be removed in Puppet 2.8.  Use a fully-qualified variable name (e.g., $classname::variable) or parameterized classes."
-      end
-      table[name]
-    elsif parent
-      parent.lookupvar(name,options.merge(:dynamic => (dynamic || options[:dynamic])))
-    else
-      :undefined
-    end
+    self[name, options]
   end
 
   # Return a hash containing our variables and their values, optionally (and
@@ -312,6 +321,8 @@ class Puppet::Parser::Scope
   # Set a variable in the current scope.  This will override settings
   # in scopes above, but will not allow variables in the current scope
   # to be reassigned.
+  #   It's preferred that you use self[]= instead of this; only use this
+  # when you need to set options.
   def setvar(name,value, options = {})
     table = options[:ephemeral] ? @ephemeral.last : @symtable
     if table.include?(name)
@@ -329,7 +340,7 @@ class Puppet::Parser::Scope
       table[name] = value
     else # append case
       # lookup the value in the scope if it exists and insert the var
-      table[name] = undef_as('',lookupvar(name))
+      table[name] = undef_as('',self[name])
       # concatenate if string, append if array, nothing for other types
       case value
       when Array
diff --git a/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb
index 27d75bf92..83d18cc3f 100644
--- a/lib/puppet/parser/templatewrapper.rb
+++ b/lib/puppet/parser/templatewrapper.rb
@@ -25,7 +25,7 @@ class Puppet::Parser::TemplateWrapper
 
   # Should return true if a variable is defined, false if it is not
   def has_variable?(name)
-    scope.lookupvar(name.to_s, :file => file, :line => script_line) != :undefined
+    scope[name.to_s, {:file => file, :line => script_line}] != :undefined
   end
 
   # Allow templates to access the defined classes
@@ -56,7 +56,7 @@ class Puppet::Parser::TemplateWrapper
   # the missing_method definition here until we declare the syntax finally
   # dead.
   def method_missing(name, *args)
-    value = scope.lookupvar(name.to_s,:file => file,:line => script_line)
+    value = scope[name.to_s, {:file => file,:line => script_line}]
     if value != :undefined
       return value
     else
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index f8d820b77..7b251e8c7 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -225,22 +225,22 @@ class Puppet::Resource::Type
       param = param.to_sym
       fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
 
-      exceptwrap { scope.setvar(param.to_s, value) }
+      exceptwrap { scope[param.to_s] = value }
 
       set[param] = true
     end
 
     if @type == :hostclass
-      scope.setvar("title", resource.title.to_s.downcase) unless set.include? :title
-      scope.setvar("name",  resource.name.to_s.downcase ) unless set.include? :name
+      scope["title"] = resource.title.to_s.downcase unless set.include? :title
+      scope["name"] =  resource.name.to_s.downcase  unless set.include? :name
     else
-      scope.setvar("title", resource.title              ) unless set.include? :title
-      scope.setvar("name",  resource.name               ) unless set.include? :name
+      scope["title"] = resource.title               unless set.include? :title
+      scope["name"] =  resource.name                unless set.include? :name
     end
-    scope.setvar("module_name", module_name) if module_name and ! set.include? :module_name
+    scope["module_name"] = module_name if module_name and ! set.include? :module_name
 
     if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
-      scope.setvar("caller_module_name", caller_name)
+      scope["caller_module_name"] = caller_name
     end
     scope.class_set(self.name,scope) if hostclass? or node?
     # Verify that all required arguments are either present or
@@ -253,7 +253,7 @@ class Puppet::Resource::Type
       fail Puppet::ParseError, "Must pass #{param} to #{resource.ref}" unless default
 
       value = default.safeevaluate(scope)
-      scope.setvar(param.to_s, value)
+      scope[param.to_s] = value
 
       # Set it in the resource, too, so the value makes it to the client.
       resource[param] = value
-- 
cgit 


From 06e86e40bbb173fa24a7d1c2ecf4e54e1748de67 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Wed, 8 Jun 2011 18:55:10 -0700
Subject: Adding default environment to Scope

We were previously not defaulting to an environment,
which is silly given that there's always a default.  It
just made setup code harder.  We now default to the default
environment.

This makes further testing involving scopes much easier.

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/scope.rb | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 67dcb1cb0..711655e44 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -82,10 +82,6 @@ class Puppet::Parser::Scope
     compiler.catalog
   end
 
-  def environment
-    compiler.environment
-  end
-
   # Proxy accessors
   def host
     @compiler.node.name
@@ -130,7 +126,7 @@ class Puppet::Parser::Scope
 
   # Remove this when rebasing
   def environment
-    compiler ? compiler.environment : nil
+    compiler ? compiler.environment : Puppet::Node::Environment.new
   end
 
   def find_hostclass(name)
@@ -454,6 +450,6 @@ class Puppet::Parser::Scope
 
   def extend_with_functions_module
     extend Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.root)
-    extend Puppet::Parser::Functions.environment_module(environment)
+    extend Puppet::Parser::Functions.environment_module(environment) if environment != Puppet::Node::Environment.root
   end
 end
-- 
cgit 


From 9d608ea176224f38c6af349883065d9363dd1bb1 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Wed, 8 Jun 2011 22:36:25 -0700
Subject: Resource type defaults cleanup

This is again done to make support for hiera easier.
The way we were handling lookup of resource defaults
was over-complicated.

This does a decent bit of cleanup overall, but primarily
focused on resource type defaults and how they get
set during compilation.

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/compiler.rb | 10 ++++++----
 lib/puppet/resource.rb        | 33 +++++++++++++++++++++++++++++++++
 lib/puppet/resource/type.rb   | 34 +++++++++++++++-------------------
 3 files changed, 54 insertions(+), 23 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/compiler.rb b/lib/puppet/parser/compiler.rb
index f43a31285..06cd80a1e 100644
--- a/lib/puppet/parser/compiler.rb
+++ b/lib/puppet/parser/compiler.rb
@@ -139,19 +139,21 @@ class Puppet::Parser::Compiler
   # evaluated later in the process.
   def evaluate_classes(classes, scope, lazy_evaluate = true)
     raise Puppet::DevError, "No source for scope passed to evaluate_classes" unless scope.source
-    param_classes = nil
+    class_parameters = nil
     # if we are a param class, save the classes hash
     # and transform classes to be the keys
     if classes.class == Hash
-      param_classes = classes
+      class_parameters = classes
       classes = classes.keys
     end
     classes.each do |name|
       # If we can find the class, then make a resource that will evaluate it.
       if klass = scope.find_hostclass(name)
 
-        if param_classes
-          resource = klass.ensure_in_catalog(scope, param_classes[name] || {})
+        # If parameters are passed, then attempt to create a duplicate resource
+        # so the appropriate error is thrown.
+        if class_parameters
+          resource = klass.ensure_in_catalog(scope, class_parameters[name] || {})
         else
           next if scope.class_scope(klass)
           resource = klass.ensure_in_catalog(scope)
diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 59e387d00..217eb11c8 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -343,6 +343,26 @@ class Puppet::Resource
     [ type, title ].join('/')
   end
 
+  def set_default_parameters(scope)
+    return [] unless resource_type and resource_type.respond_to?(:arguments)
+
+    result = []
+
+    resource_type.arguments.each do |param, default|
+      param = param.to_sym
+      next if parameters.include?(param)
+      unless is_a?(Puppet::Parser::Resource)
+        fail Puppet::DevError, "Cannot evaluate default parameters for #{self} - not a parser resource"
+      end
+
+      next if default.nil?
+
+      self[param] = default.safeevaluate(scope)
+      result << param
+    end
+    result
+  end
+
   def to_resource
     self
   end
@@ -351,6 +371,19 @@ class Puppet::Resource
     resource_type.valid_parameter?(name)
   end
 
+  # Verify that all required arguments are either present or
+  # have been provided with defaults.
+  # Must be called after 'set_default_parameters'.  We can't join the methods
+  # because Type#set_parameters needs specifically ordered behavior.
+  def validate_complete
+    return unless resource_type and resource_type.respond_to?(:arguments)
+
+    resource_type.arguments.each do |param, default|
+      param = param.to_sym
+      fail Puppet::ParseError, "Must pass #{param} to #{self}" unless parameters.include?(param)
+    end
+  end
+
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index 7b251e8c7..ca6e8b53b 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -158,11 +158,7 @@ class Puppet::Resource::Type
       return resource
     end
     resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
-    if parameters
-      parameters.each do |k,v|
-        resource.set_parameter(k,v)
-      end
-    end
+    assign_parameter_values(parameters, resource)
     instantiate_resource(scope, resource)
     scope.compiler.add_resource(scope, resource)
     resource
@@ -188,6 +184,14 @@ class Puppet::Resource::Type
     @name.is_a?(Regexp)
   end
 
+  def assign_parameter_values(parameters, resource)
+    return unless parameters
+    scope = resource.scope || {}
+    arguments.merge(parameters).each do |name, default|
+      resource.set_parameter name, default
+    end
+  end
+
   # MQR TODO:
   #
   # The change(s) introduced by the fix for #4270 are mostly silly & should be 
@@ -243,22 +247,14 @@ class Puppet::Resource::Type
       scope["caller_module_name"] = caller_name
     end
     scope.class_set(self.name,scope) if hostclass? or node?
-    # Verify that all required arguments are either present or
-    # have been provided with defaults.
-    arguments.each do |param, default|
-      param = param.to_sym
-      next if set.include?(param)
-
-      # Even if 'default' is a false value, it's an AST value, so this works fine
-      fail Puppet::ParseError, "Must pass #{param} to #{resource.ref}" unless default
 
-      value = default.safeevaluate(scope)
-      scope[param.to_s] = value
-
-      # Set it in the resource, too, so the value makes it to the client.
-      resource[param] = value
-    end
+    # Evaluate the default parameters, now that all other variables are set
+    default_params = resource.set_default_parameters(scope)
+    default_params.each { |param| scope[param.to_s] = resource[param] }
 
+    # This has to come after the above parameters so that default values
+    # can use their values
+    resource.validate_complete
   end
 
   # Check whether a given argument is valid.
-- 
cgit 


From b3c155430965280ab59b1dd70c020c6da3396fc9 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Thu, 16 Jun 2011 18:37:04 -0700
Subject: Adding Scope#include? method

This is primarily for Hiera/DataLibrary support,
but is a decent idea regardless.

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/scope.rb | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 711655e44..7b75ca86b 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -87,6 +87,10 @@ class Puppet::Parser::Scope
     @compiler.node.name
   end
 
+  def include?(name)
+    self[name] != :undefined
+  end
+
   # Is the value true?  This allows us to control the definition of truth
   # in one place.
   def self.true?(value)
-- 
cgit 


From 3b2a24602d11d4ca2f7e761fb831f126ecf2de62 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Thu, 16 Jun 2011 18:41:19 -0700
Subject: Adding Scope#each method

The capability was already there via to_hash, and
Enumerable was already included, but this method was
missing.  Given the kind of hacking RI is doing,
this seemed appropriate.

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/scope.rb | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 7b75ca86b..3a87f964b 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -82,6 +82,10 @@ class Puppet::Parser::Scope
     compiler.catalog
   end
 
+  def each
+    to_hash.each { |name, value| yield(name, value) }
+  end
+
   # Proxy accessors
   def host
     @compiler.node.name
-- 
cgit 


From 784d54c20bbc6272d408de1aee831a883298c5cd Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Tue, 5 Jul 2011 11:57:53 -0700
Subject: Improving an error message

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/resource.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 305ba81e8..6b072bd90 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -173,7 +173,7 @@ class Puppet::Parser::Resource < Puppet::Resource
         :name => param, :value => value, :source => self.source
       )
     elsif ! param.is_a?(Puppet::Parser::Resource::Param)
-      raise ArgumentError, "Must pass a parameter or all necessary values"
+      raise ArgumentError, "Received incomplete information - no value provided for parameter #{param}"
     end
 
     tag(*param.value) if param.name == :tag
-- 
cgit 


From 79c8023d45d8c86f0f21cf6c4c27e0e5389c7528 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Tue, 5 Jul 2011 11:58:34 -0700
Subject: Fixing default parameter value assignment

The method for adding class resources to the
catalog was only working in cases where the default
values weren't AST objects.  This commit fixes
this, along with the tests that were failing
and drew out the problem.

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/resource/type.rb | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index ca6e8b53b..8b154ce95 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -187,8 +187,12 @@ class Puppet::Resource::Type
   def assign_parameter_values(parameters, resource)
     return unless parameters
     scope = resource.scope || {}
-    arguments.merge(parameters).each do |name, default|
-      resource.set_parameter name, default
+
+    # It'd be nice to assign default parameter values here,
+    # but we can't because they often rely on local variables
+    # created during set_resource_parameters.
+    parameters.each do |name, value|
+      resource.set_parameter name, value
     end
   end
 
-- 
cgit 


From 2431bb3fc8fba238cb2cf1bb71f316c62ba384b7 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Tue, 5 Jul 2011 12:03:40 -0700
Subject: Cleaning up indentation in versoncmp function

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/functions/versioncmp.rb | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/functions/versioncmp.rb b/lib/puppet/parser/functions/versioncmp.rb
index 6091e0923..e4edb151e 100644
--- a/lib/puppet/parser/functions/versioncmp.rb
+++ b/lib/puppet/parser/functions/versioncmp.rb
@@ -1,10 +1,8 @@
 require 'puppet/util/package'
 
 
-      Puppet::Parser::Functions::newfunction(
-        :versioncmp, :type => :rvalue,
-
-  :doc => "Compares two versions
+Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue,
+:doc => "Compares two versions
 
 Prototype:
 
-- 
cgit 


From baf32de1dcda02f7da8b2926abee7f46d0d47fe1 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Tue, 5 Jul 2011 12:25:54 -0700
Subject: Making the Functions module more resilient

We were previously storing the module name with
the environment instances as the key, which meant
if the environment instances were removed, we could
never get those modules again.  Given that the
functions weren't reloaded, this meant the functions
were gone if we ever reloaded the environment.

This makes the Functions environment module resilient across
environment reloads, and it also makes the method work correctly
when handed either an environment or a string.

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/functions.rb | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/functions.rb b/lib/puppet/parser/functions.rb
index e19ac127f..22eee70d7 100644
--- a/lib/puppet/parser/functions.rb
+++ b/lib/puppet/parser/functions.rb
@@ -29,8 +29,11 @@ module Puppet::Parser::Functions
   Environment = Puppet::Node::Environment
 
   def self.environment_module(env = nil)
+    if env and ! env.is_a?(Puppet::Node::Environment)
+      env = Puppet::Node::Environment.new(env)
+    end
     @modules.synchronize {
-      @modules[ env || Environment.current || Environment.root ] ||= Module.new
+      @modules[ (env || Environment.current || Environment.root).name ] ||= Module.new
     }
   end
 
-- 
cgit 


From bdc0f8716ae8ccb2b2657dfab591afe9589d8902 Mon Sep 17 00:00:00 2001
From: Luke Kanies <luke@puppetlabs.com>
Date: Tue, 5 Jul 2011 16:32:03 -0700
Subject: Scope[] now returns nil for undefined variables

Given that we have the 'include?' method, this feature
is unnecessary, and it makes sense to convert to more
ruby-like behavior.

Any code that previously checked whether lookupvar
(or the new []) returned :undefined should now check
whether 'scope.include?(var)'.  Thus, you can have
the same behavior, but it takes a bit different code
to get it.

Signed-off-by: Luke Kanies <luke@puppetlabs.com>
Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 lib/puppet/parser/ast/leaf.rb        |  7 ++++---
 lib/puppet/parser/resource.rb        |  3 ++-
 lib/puppet/parser/scope.rb           | 12 ++++++++----
 lib/puppet/parser/templatewrapper.rb |  7 +++----
 4 files changed, 17 insertions(+), 12 deletions(-)

(limited to 'lib/puppet')

diff --git a/lib/puppet/parser/ast/leaf.rb b/lib/puppet/parser/ast/leaf.rb
index 64a197492..3efb52f63 100644
--- a/lib/puppet/parser/ast/leaf.rb
+++ b/lib/puppet/parser/ast/leaf.rb
@@ -124,10 +124,11 @@ class Puppet::Parser::AST
     # not include syntactical constructs, like '$' and '{}').
     def evaluate(scope)
       parsewrap do
-        if (var = scope[@value, {:file => file, :line => line}]) == :undefined
-          var = :undef
+        if ! scope.include?(@value)
+          :undef
+        else
+          scope[@value, {:file => file, :line => line}]
         end
-        var
       end
     end
 
diff --git a/lib/puppet/parser/resource.rb b/lib/puppet/parser/resource.rb
index 6b072bd90..56887c357 100644
--- a/lib/puppet/parser/resource.rb
+++ b/lib/puppet/parser/resource.rb
@@ -258,7 +258,8 @@ class Puppet::Parser::Resource < Puppet::Resource
 
   def add_backward_compatible_relationship_param(name)
     # Skip metaparams for which we get no value.
-    return unless val = scope[name.to_s] and val != :undefined
+    return unless scope.include?(name.to_s)
+    val = scope[name.to_s]
 
     # The default case: just set the value
     set_parameter(name, val) and return unless @parameters[name]
diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index 3a87f964b..9d84c7e65 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -57,7 +57,7 @@ class Puppet::Parser::Scope
       rescue RuntimeError => e
         location = (options[:file] && options[:line]) ? " at #{options[:file]}:#{options[:line]}" : ''
         warning "Could not look up qualified variable '#{name}'; #{e.message}#{location}"
-        :undefined
+        nil
       end
     elsif ephemeral_include?(name) or table.include?(name)
       # We can't use "if table[name]" here because the value might be false
@@ -69,7 +69,7 @@ class Puppet::Parser::Scope
     elsif parent
       parent[name,options.merge(:dynamic => (dynamic || options[:dynamic]))]
     else
-      :undefined
+      nil
     end
   end
 
@@ -92,7 +92,7 @@ class Puppet::Parser::Scope
   end
 
   def include?(name)
-    self[name] != :undefined
+    ! self[name].nil?
   end
 
   # Is the value true?  This allows us to control the definition of truth
@@ -244,7 +244,11 @@ class Puppet::Parser::Scope
   end
 
   def undef_as(x,v)
-    (v == :undefined) ? x : (v == :undef) ? x : v
+    if v.nil? or v == :undef
+      x
+    else
+      v
+    end
   end
 
   def qualified_scope(classname)
diff --git a/lib/puppet/parser/templatewrapper.rb b/lib/puppet/parser/templatewrapper.rb
index 83d18cc3f..9336e704d 100644
--- a/lib/puppet/parser/templatewrapper.rb
+++ b/lib/puppet/parser/templatewrapper.rb
@@ -25,7 +25,7 @@ class Puppet::Parser::TemplateWrapper
 
   # Should return true if a variable is defined, false if it is not
   def has_variable?(name)
-    scope[name.to_s, {:file => file, :line => script_line}] != :undefined
+    scope.include?(name.to_s)
   end
 
   # Allow templates to access the defined classes
@@ -56,9 +56,8 @@ class Puppet::Parser::TemplateWrapper
   # the missing_method definition here until we declare the syntax finally
   # dead.
   def method_missing(name, *args)
-    value = scope[name.to_s, {:file => file,:line => script_line}]
-    if value != :undefined
-      return value
+    if scope.include?(name.to_s)
+      return scope[name.to_s, {:file => file,:line => script_line}]
     else
       # Just throw an error immediately, instead of searching for
       # other missingmethod things or whatever.
-- 
cgit