diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 7e1231844..c8450380f 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,572 +1,580 @@
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/util/pson'
 require 'puppet/parameter'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 #
 # @api public
 class Puppet::Resource
   # This stub class is only needed for serialization compatibility with 0.25.x.
   # Specifically, it exists to provide a compatibility API when using YAML
   # serialized objects loaded from StoreConfigs.
   Reference = Puppet::Resource
 
   include Puppet::Util::Tagging
 
   extend Puppet::Util::Pson
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
   attr_reader :type, :title
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
   ATTRIBUTES = [:file, :line, :exported]
 
   def self.from_data_hash(data)
     raise ArgumentError, "No resource type provided in serialized data" unless type = data['type']
     raise ArgumentError, "No resource title provided in serialized data" unless title = data['title']
 
     resource = new(type, title)
 
     if params = data['parameters']
       params.each { |param, value| resource[param] = value }
     end
 
     if tags = data['tags']
       tags.each { |tag| resource.tag(tag) }
     end
 
     ATTRIBUTES.each do |a|
       if value = data[a.to_s]
         resource.send(a.to_s + "=", value)
       end
     end
 
     resource
   end
 
   def self.from_pson(pson)
     Puppet.deprecation_warning("from_pson is being removed in favour of from_data_hash.")
     self.from_data_hash(pson)
   end
 
   def inspect
     "#{@type}[#{@title}]#{to_hash.inspect}"
   end
 
   def to_data_hash
     data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
       next hash unless value = self.send(param)
       hash[param.to_s] = value
       hash
     end
 
     data["exported"] ||= false
 
     params = self.to_hash.inject({}) do |hash, ary|
       param, value = ary
 
       # Don't duplicate the title as the namevar
       next hash if param == namevar and value == title
 
       hash[param] = Puppet::Resource.value_to_pson_data(value)
       hash
     end
 
     data["parameters"] = params unless params.empty?
 
     data
   end
 
   # This doesn't include document type as it is part of a catalog
   def to_pson_data_hash
     to_data_hash
   end
 
   def self.value_to_pson_data(value)
     if value.is_a? Array
       value.map{|v| value_to_pson_data(v) }
     elsif value.is_a? Puppet::Resource
       value.to_s
     else
       value
     end
   end
 
   def yaml_property_munge(x)
     case x
     when Hash
       x.inject({}) { |h,kv|
         k,v = kv
         h[k] = self.class.value_to_pson_data(v)
         h
       }
     else self.class.value_to_pson_data(x)
     end
   end
 
   YAML_ATTRIBUTES = [:@file, :@line, :@exported, :@type, :@title, :@tags, :@parameters]
 
   # Explicitly list the instance variables that should be serialized when
   # converting to YAML.
   #
   # @api private
   # @return [Array<Symbol>] The intersection of our explicit variable list and
   #   all of the instance variables defined on this class.
   def to_yaml_properties
     YAML_ATTRIBUTES & super
   end
 
   def to_pson(*args)
     to_data_hash.to_pson(*args)
   end
 
   # Proxy these methods to the parameters hash.  It's likely they'll
   # be overridden at some point, but this works for now.
   %w{has_key? keys length delete empty? <<}.each do |method|
     define_method(method) do |*args|
       parameters.send(method, *args)
     end
   end
 
   # Set a given parameter.  Converts all passed names
   # to lower-case symbols.
   def []=(param, value)
     validate_parameter(param) if validate_parameters
     parameters[parameter_name(param)] = value
   end
 
   # Return a given parameter's value.  Converts all passed names
   # to lower-case symbols.
   def [](param)
     parameters[parameter_name(param)]
   end
 
   def ==(other)
     return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
 
     return false unless to_hash == other.to_hash
     true
   end
 
   # Compatibility method.
   def builtin?
     builtin_type?
   end
 
   # Is this a builtin resource type?
   def builtin_type?
     resource_type.is_a?(Class)
   end
 
   # Iterate over each param/value pair, as required for Enumerable.
   def each
     parameters.each { |p,v| yield p, v }
   end
 
   def include?(parameter)
     super || parameters.keys.include?( parameter_name(parameter) )
   end
 
   %w{exported virtual strict}.each do |m|
     define_method(m+"?") do
       self.send(m)
     end
   end
 
   def class?
     @is_class ||= @type == "Class"
   end
 
   def stage?
     @is_stage ||= @type.to_s.downcase == "stage"
   end
 
   # Cache to reduce respond_to? lookups
   @@nondeprecating_type = {}
 
   # Create our resource.
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
 
     # Set things like strictness first.
     attributes.each do |attr, value|
       next if attr == :parameters
       send(attr.to_s + "=", value)
     end
 
     @type, @title = extract_type_and_title(type, title)
 
     @type = munge_type_name(@type)
 
     if self.class?
       @title = :main if @title == ""
       @title = munge_type_name(@title)
     end
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
     if resource_type and ! @@nondeprecating_type[resource_type]
       if resource_type.respond_to?(:deprecate_params)
         resource_type.deprecate_params(title, attributes[:parameters])
       else
         @@nondeprecating_type[resource_type] = true
       end
     end
 
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
     @reference = self # for serialization compatibility with 0.25.x
     if strict? and ! resource_type
       if self.class?
         raise ArgumentError, "Could not find declared class #{title}"
       else
         raise ArgumentError, "Invalid resource type #{type}"
       end
     end
   end
 
   def ref
     to_s
   end
 
   # Find our resource.
   def resolve
     catalog ? catalog.resource(to_s) : nil
   end
 
   # The resource's type implementation
   # @return [Puppet::Type, Puppet::Resource::Type]
   # @api private
   def resource_type
     @rstype ||= case type
     when "Class"; environment.known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; environment.known_resource_types.node(title)
     else
       Puppet::Type.type(type) || environment.known_resource_types.definition(type)
     end
   end
 
   # Set the resource's type implementation
   # @param type [Puppet::Type, Puppet::Resource::Type]
   # @api private
   def resource_type=(type)
     @rstype = type
   end
 
   def environment
     @environment ||= if catalog
                        catalog.environment_instance
                      else
                        Puppet::Node::Environment::NONE
                      end
   end
 
   def environment=(environment)
     @environment = environment
   end
 
   # Produce a simple hash of our parameters.
   def to_hash
     parse_title.merge parameters
   end
 
   def to_s
     "#{type}[#{title}]"
   end
 
   def uniqueness_key
     # Temporary kludge to deal with inconsistant use patters
     h = self.to_hash
     h[namevar] ||= h[:name]
     h[:name]   ||= h[namevar]
     h.values_at(*key_attributes.sort_by { |k| k.to_s })
   end
 
   def key_attributes
     resource_type.respond_to?(:key_attributes) ? resource_type.key_attributes : [:name]
   end
 
   # Convert our resource to Puppet code.
   def to_manifest
     # Collect list of attributes to align => and move ensure first
     attr = parameters.keys
     attr_max = attr.inject(0) { |max,k| k.to_s.length > max ? k.to_s.length : max }
 
     attr.sort!
     if attr.first != :ensure  && attr.include?(:ensure)
       attr.delete(:ensure)
       attr.unshift(:ensure)
     end
 
     attributes = attr.collect { |k|
       v = parameters[k]
       "  %-#{attr_max}s => %s,\n" % [k, Puppet::Parameter.format_value_for_display(v)]
     }.join
 
     "%s { '%s':\n%s}" % [self.type.to_s.downcase, self.title, attributes]
   end
 
   def to_ref
     ref
   end
 
   # Convert our resource to a RAL resource instance.  Creates component
   # instances for resource types that don't exist.
   def to_ral
     typeklass = Puppet::Type.type(self.type) || Puppet::Type.type(:component)
     typeklass.new(self)
   end
 
   def name
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
     [ type, title ].join('/')
   end
 
   def missing_arguments
     resource_type.arguments.select do |param, default|
       param = param.to_sym
       parameters[param].nil? || parameters[param].value == :undef
     end
   end
   private :missing_arguments
 
   # Consult external data bindings for class parameter values which must be
   # namespaced in the backend.
   #
   # Example:
   #
   #   class foo($port=0){ ... }
   #
   # We make a request to the backend for the key 'foo::port' not 'foo'
   #
   def lookup_external_default_for(param, scope)
     # Only lookup parameters for host classes
     return nil unless resource_type.type == :hostclass
 
     name = "#{resource_type.name}::#{param}"
     lookup_with_databinding(name, scope)
   end
 
   private :lookup_external_default_for
 
   def lookup_with_databinding(name, scope)
     begin
       Puppet::DataBinding.indirection.find(
         name,
         :environment => scope.environment.to_s,
         :variables => scope)
     rescue Puppet::DataBinding::LookupError => e
       raise Puppet::Error.new("Error from DataBinding '#{Puppet[:data_binding_terminus]}' while looking up '#{name}': #{e.message}", e)
     end
   end
 
   private :lookup_with_databinding
 
   def set_default_parameters(scope)
     return [] unless resource_type and resource_type.respond_to?(:arguments)
 
     unless is_a?(Puppet::Parser::Resource)
       fail Puppet::DevError, "Cannot evaluate default parameters for #{self} - not a parser resource"
     end
 
     missing_arguments.collect do |param, default|
       external_value = lookup_external_default_for(param, scope)
 
       if external_value.nil? && default.nil?
         next
       elsif external_value.nil?
         value = default.safeevaluate(scope)
       else
         value = external_value
       end
 
       self[param.to_sym] = value
       param
     end.compact
   end
 
   def copy_as_resource
     result = Puppet::Resource.new(type, title)
 
     result.file = self.file
     result.line = self.line
     result.exported = self.exported
     result.virtual = self.virtual
     result.tag(*self.tags)
     result.environment = environment
     result.instance_variable_set(:@rstype, resource_type)
 
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = Puppet::Resource.new(v.type, v.title)
       elsif v.is_a?(Array)
         # flatten resource references arrays
         v = v.flatten if v.flatten.find { |av| av.is_a?(Puppet::Resource) }
         v = v.collect do |av|
           av = Puppet::Resource.new(av.type, av.title) if av.is_a?(Puppet::Resource)
           av
         end
       end
 
-      # If the value is an array with only one value, then
-      # convert it to a single value.  This is largely so that
-      # the database interaction doesn't have to worry about
-      # whether it returns an array or a string.
-      result[p] = if v.is_a?(Array) and v.length == 1
-                    v[0]
-                  else
-                    v
-                  end
+      if Puppet[:parser] == 'current'
+        # If the value is an array with only one value, then
+        # convert it to a single value.  This is largely so that
+        # the database interaction doesn't have to worry about
+        # whether it returns an array or a string.
+        #
+        # This behavior is not done in the future parser, but we can't issue a
+        # deprecation warning either since there isn't anything that a user can
+        # do about it.
+        result[p] = if v.is_a?(Array) and v.length == 1
+                      v[0]
+                    else
+                      v
+                    end
+      else
+        result[p] = v
+      end
     end
 
     result
   end
 
   def valid_parameter?(name)
     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
 
     # Perform optional type checking
     if Puppet[:parser] == 'future'
       # Perform type checking
       arg_types = resource_type.argument_types
       # Parameters is a map from name, to parameter, and the parameter again has name and value
       parameters.each do |name, value|
         next unless t = arg_types[name.to_s]  # untyped, and parameters are symbols here (aargh, strings in the type)
         unless Puppet::Pops::Types::TypeCalculator.instance?(t, value.value)
           inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value.value)
           actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
           fail Puppet::ParseError, "Expected parameter '#{name}' of '#{self}' to have type #{t.to_s}, got #{actual.to_s}"
         end
       end
     end
   end
 
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
 
   def prune_parameters(options = {})
     properties = resource_type.properties.map(&:name)
 
     dup.collect do |attribute, value|
       if value.to_s.empty? or Array(value).empty?
         delete(attribute)
       elsif value.to_s == "absent" and attribute.to_s != "ensure"
         delete(attribute)
       end
 
       parameters_to_include = options[:parameters_to_include] || []
       delete(attribute) unless properties.include?(attribute) || parameters_to_include.include?(attribute)
     end
     self
   end
 
   private
 
   # Produce a canonical method name.
   def parameter_name(param)
     param = param.to_s.downcase.to_sym
     if param == :name and namevar
       param = namevar
     end
     param
   end
 
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
     if builtin_type? and t = resource_type and t.key_attributes.length == 1
       t.key_attributes.first
     else
       :name
     end
   end
 
   def extract_parameters(params)
     params.each do |param, value|
       validate_parameter(param) if strict?
       self[param] = value
     end
   end
 
   def extract_type_and_title(argtype, argtitle)
     if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
     elsif argtitle                                         then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
     elsif argtype.is_a?(Hash)                              then
       raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
         "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
     else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
     end
   end
 
   def munge_type_name(value)
     return :main if value == :main
     return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
 
     value.to_s.split("::").collect { |s| s.capitalize }.join("::")
   end
 
   def parse_title
     h = {}
     type = resource_type
     if type.respond_to? :title_patterns
       type.title_patterns.each { |regexp, symbols_and_lambdas|
         if captures = regexp.match(title.to_s)
           symbols_and_lambdas.zip(captures[1..-1]).each do |symbol_and_lambda,capture|
             symbol, proc = symbol_and_lambda
             # Many types pass "identity" as the proc; we might as well give
             # them a shortcut to delivering that without the extra cost.
             #
             # Especially because the global type defines title_patterns and
             # uses the identity patterns.
             #
             # This was worth about 8MB of memory allocation saved in my
             # testing, so is worth the complexity for the API.
             if proc then
               h[symbol] = proc.call(capture)
             else
               h[symbol] = capture
             end
           end
           return h
         end
       }
       # If we've gotten this far, then none of the provided title patterns
       # matched. Since there's no way to determine the title then the
       # resource should fail here.
       raise Puppet::Error, "No set of title patterns matched the title \"#{title}\"."
     else
       return { :name => title.to_s }
     end
   end
 
   def parameters
     # @parameters could have been loaded from YAML, causing it to be nil (by
     # bypassing initialize).
     @parameters ||= {}
   end
 end
diff --git a/spec/integration/parser/scope_spec.rb b/spec/integration/parser/scope_spec.rb
index 1fd84f421..b89edeeb6 100644
--- a/spec/integration/parser/scope_spec.rb
+++ b/spec/integration/parser/scope_spec.rb
@@ -1,798 +1,807 @@
 require 'spec_helper'
 require 'puppet_spec/compiler'
 
 describe "Two step scoping for variables" do
   include PuppetSpec::Compiler
 
   def expect_the_message_to_be(message, node = Puppet::Node.new('the node'))
     catalog = compile_to_catalog(yield, node)
     catalog.resource('Notify', 'something')[:message].should == message
   end
 
   before :each do
     Puppet.expects(:deprecation_warning).never
   end
 
   context 'using current parser' do
     describe "using plussignment to change in a new scope" do
       it "does not change a string in the parent scope" do
         # Expects to be able to concatenate string using +=
         expect_the_message_to_be('top_msg') do <<-MANIFEST
             $var = "top_msg"
             class override {
               $var += "override"
               include foo
             }
             class foo {
               notify { 'something': message => $var, }
             }
 
             include override
           MANIFEST
         end
       end
     end
   end
 
   context 'using future parser' do
     before(:each) do
       Puppet[:parser] = 'future'
     end
 
     describe "using plussignment to change in a new scope" do
       it "does not change a string in the parent scope" do
         # Expects to be able to concatenate string using +=
         expect do
           catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new('the node'))
               $var = "top_msg"
               class override {
                 $var += "override"
                 include foo
               }
               class foo {
                 notify { 'something': message => $var, }
               }
 
               include override
             MANIFEST
         end.to raise_error(/The value 'top_msg' cannot be converted to Numeric/)
       end
     end
 
     it "when using a template ignores the dynamic value of the var when using the @varname syntax" do
       expect_the_message_to_be('node_msg') do <<-MANIFEST
           node default {
             $var = "node_msg"
             include foo
           }
           class foo {
             $var = "foo_msg"
             include bar
           }
           class bar {
             notify { 'something': message => inline_template("<%= @var %>"), }
           }
         MANIFEST
       end
     end
 
     it "when using a template gets the var from an inherited class when using the @varname syntax" do
       expect_the_message_to_be('Barbamama') do <<-MANIFEST
           node default {
             $var = "node_msg"
             include bar_bamama
             include foo
           }
           class bar_bamama {
             $var = "Barbamama"
           }
           class foo {
             $var = "foo_msg"
             include bar
           }
           class bar inherits bar_bamama {
             notify { 'something': message => inline_template("<%= @var %>"), }
           }
         MANIFEST
       end
     end
 
     it "when using a template ignores the dynamic var when it is not present in an inherited class" do
       expect_the_message_to_be('node_msg') do <<-MANIFEST
           node default {
             $var = "node_msg"
             include bar_bamama
             include foo
           }
           class bar_bamama {
           }
           class foo {
             $var = "foo_msg"
             include bar
           }
           class bar inherits bar_bamama {
             notify { 'something': message => inline_template("<%= @var %>"), }
           }
         MANIFEST
       end
     end
   end
 
   shared_examples_for "the scope" do
 
     describe "fully qualified variable names" do
       it "keeps nodescope separate from topscope" do
         expect_the_message_to_be('topscope') do <<-MANIFEST
             $c = "topscope"
             node default {
               $c = "nodescope"
               notify { 'something': message => $::c }
             }
           MANIFEST
         end
       end
     end
 
     describe "when colliding class and variable names" do
       it "finds a topscope variable with the same name as a class" do
         expect_the_message_to_be('topscope') do <<-MANIFEST
             $c = "topscope"
             class c { }
             node default {
               include c
               notify { 'something': message => $c }
             }
           MANIFEST
         end
       end
 
       it "finds a node scope variable with the same name as a class" do
         expect_the_message_to_be('nodescope') do <<-MANIFEST
             class c { }
             node default {
               $c = "nodescope"
               include c
               notify { 'something': message => $c }
             }
           MANIFEST
         end
       end
 
       it "finds a class variable when the class collides with a nodescope variable" do
         expect_the_message_to_be('class') do <<-MANIFEST
             class c { $b = "class" }
             node default {
               $c = "nodescope"
               include c
               notify { 'something': message => $c::b }
             }
           MANIFEST
         end
       end
 
       it "finds a class variable when the class collides with a topscope variable" do
         expect_the_message_to_be('class') do <<-MANIFEST
             $c = "topscope"
             class c { $b = "class" }
             node default {
               include c
               notify { 'something': message => $::c::b }
             }
           MANIFEST
         end
       end
     end
 
     describe "when using shadowing and inheritance" do
       it "finds value define in the inherited node" do
         expect_the_message_to_be('parent_msg') do <<-MANIFEST
             $var = "top_msg"
             node parent {
               $var = "parent_msg"
             }
             node default inherits parent {
               include foo
             }
             class foo {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds top scope when the class is included before the node defines the var" do
         expect_the_message_to_be('top_msg') do <<-MANIFEST
             $var = "top_msg"
             node parent {
               include foo
             }
             node default inherits parent {
               $var = "default_msg"
             }
             class foo {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds top scope when the class is included before the node defines the var" do
         expect_the_message_to_be('top_msg') do <<-MANIFEST
             $var = "top_msg"
             node parent {
               include foo
             }
             node default inherits parent {
               $var = "default_msg"
             }
             class foo {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds values in its local scope" do
         expect_the_message_to_be('local_msg') do <<-MANIFEST
             node default {
               include baz
             }
             class foo {
             }
             class bar inherits foo {
               $var = "local_msg"
               notify { 'something': message => $var, }
             }
             class baz {
               include bar
             }
           MANIFEST
         end
       end
 
       it "finds values in its inherited scope" do
         expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {
               include baz
             }
             class foo {
               $var = "foo_msg"
             }
             class bar inherits foo {
               notify { 'something': message => $var, }
             }
             class baz {
               include bar
             }
           MANIFEST
         end
       end
 
       it "prefers values in its local scope over values in the inherited scope" do
         expect_the_message_to_be('local_msg') do <<-MANIFEST
             include bar
 
             class foo {
               $var = "inherited"
             }
 
             class bar inherits foo {
               $var = "local_msg"
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds a qualified variable by following parent scopes of the specified scope" do
         expect_the_message_to_be("from node") do <<-MANIFEST
             class c {
               notify { 'something': message => "$a::b" }
             }
 
             class a { }
 
             node default {
               $b = "from node"
               include a
               include c
             }
           MANIFEST
         end
       end
 
       it "finds values in its inherited scope when the inherited class is qualified to the top" do
         expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {
               include baz
             }
             class foo {
               $var = "foo_msg"
             }
             class bar inherits ::foo {
               notify { 'something': message => $var, }
             }
             class baz {
               include bar
             }
           MANIFEST
         end
       end
 
       it "prefers values in its local scope over values in the inherited scope when the inherited class is fully qualified" do
         expect_the_message_to_be('local_msg') do <<-MANIFEST
             include bar
 
             class foo {
               $var = "inherited"
             }
 
             class bar inherits ::foo {
               $var = "local_msg"
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds values in top scope when the inherited class is qualified to the top" do
         expect_the_message_to_be('top msg') do <<-MANIFEST
             $var = "top msg"
             class foo {
             }
 
             class bar inherits ::foo {
               notify { 'something': message => $var, }
             }
 
             include bar
           MANIFEST
         end
       end
 
       it "finds values in its inherited scope when the inherited class is a nested class that shadows another class at the top" do
         expect_the_message_to_be('inner baz') do <<-MANIFEST
             node default {
               include foo::bar
             }
             class baz {
               $var = "top baz"
             }
             class foo {
               class baz {
                 $var = "inner baz"
               }
 
               class bar inherits baz {
                 notify { 'something': message => $var, }
               }
             }
           MANIFEST
         end
       end
 
       it "finds values in its inherited scope when the inherited class is qualified to a nested class and qualified to the top" do
         expect_the_message_to_be('top baz') do <<-MANIFEST
             node default {
               include foo::bar
             }
             class baz {
               $var = "top baz"
             }
             class foo {
               class baz {
                 $var = "inner baz"
               }
 
               class bar inherits ::baz {
                 notify { 'something': message => $var, }
               }
             }
           MANIFEST
         end
       end
 
       it "finds values in its inherited scope when the inherited class is qualified" do
         expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {
               include bar
             }
             class foo {
               class baz {
                 $var = "foo_msg"
               }
             }
             class bar inherits foo::baz {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "prefers values in its inherited scope over those in the node (with intermediate inclusion)" do
         expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include baz
             }
             class foo {
               $var = "foo_msg"
             }
             class bar inherits foo {
               notify { 'something': message => $var, }
             }
             class baz {
               include bar
             }
           MANIFEST
         end
       end
 
       it "prefers values in its inherited scope over those in the node (without intermediate inclusion)" do
         expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include bar
             }
             class foo {
               $var = "foo_msg"
             }
             class bar inherits foo {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "prefers values in its inherited scope over those from where it is included" do
         expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {
               include baz
             }
             class foo {
               $var = "foo_msg"
             }
             class bar inherits foo {
               notify { 'something': message => $var, }
             }
             class baz {
               $var = "baz_msg"
               include bar
             }
           MANIFEST
         end
       end
 
       it "does not used variables from classes included in the inherited scope" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include bar
             }
             class quux {
               $var = "quux_msg"
             }
             class foo inherits quux {
             }
             class baz {
               include foo
             }
             class bar inherits baz {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "does not use a variable from a scope lexically enclosing it" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include other::bar
             }
             class other {
               $var = "other_msg"
               class bar {
                 notify { 'something': message => $var, }
               }
             }
           MANIFEST
         end
       end
 
       it "finds values in its node scope" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include baz
             }
             class foo {
             }
             class bar inherits foo {
               notify { 'something': message => $var, }
             }
             class baz {
               include bar
             }
           MANIFEST
         end
       end
 
       it "finds values in its top scope" do
         expect_the_message_to_be('top_msg') do <<-MANIFEST
             $var = "top_msg"
             node default {
               include baz
             }
             class foo {
             }
             class bar inherits foo {
               notify { 'something': message => $var, }
             }
             class baz {
               include bar
             }
           MANIFEST
         end
       end
 
       it "prefers variables from the node over those in the top scope" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             $var = "top_msg"
             node default {
               $var = "node_msg"
               include foo
             }
             class foo {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds top scope variables referenced inside a defined type" do
         expect_the_message_to_be('top_msg') do <<-MANIFEST
             $var = "top_msg"
             node default {
               foo { "testing": }
             }
             define foo() {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds node scope variables referenced inside a defined type" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             $var = "top_msg"
             node default {
               $var = "node_msg"
               foo { "testing": }
             }
             define foo() {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
     end
 
     describe "in situations that used to have dynamic lookup" do
       it "ignores the dynamic value of the var" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include foo
             }
             class baz {
               $var = "baz_msg"
               include bar
             }
             class foo inherits baz {
             }
             class bar {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "finds nil when the only set variable is in the dynamic scope" do
         expect_the_message_to_be(nil) do <<-MANIFEST
             node default {
               include baz
             }
             class foo {
             }
             class bar inherits foo {
               notify { 'something': message => $var, }
             }
             class baz {
               $var = "baz_msg"
               include bar
             }
           MANIFEST
         end
       end
 
       it "ignores the value in the dynamic scope for a defined type" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include foo
             }
             class foo {
               $var = "foo_msg"
               bar { "testing": }
             }
             define bar() {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "when using a template ignores the dynamic value of the var when using scope.lookupvar" do
         expect_the_message_to_be('node_msg') do <<-MANIFEST
             node default {
               $var = "node_msg"
               include foo
             }
             class foo {
               $var = "foo_msg"
               include bar
             }
             class bar {
               notify { 'something': message => inline_template("<%= scope.lookupvar('var') %>"), }
             }
           MANIFEST
         end
       end
     end
 
     describe "using plussignment to change in a new scope" do
 
       it "does not change an array in the parent scope" do
-        expect_the_message_to_be('top_msg') do <<-MANIFEST
+        # Under the future parser single element arrays are no longer converted
+        # into the first element of the array. This causes the message to be
+        # different in the two versions.
+        if Puppet[:parser] == 'future'
+          expected = ['top_msg']
+        else
+          expected = 'top_msg'
+        end
+
+        expect_the_message_to_be(expected) do <<-MANIFEST
             $var = ["top_msg"]
             class override {
               $var += ["override"]
               include foo
             }
             class foo {
               notify { 'something': message => $var, }
             }
 
             include override
           MANIFEST
         end
       end
 
       it "concatenates two arrays" do
         expect_the_message_to_be(['top_msg', 'override']) do <<-MANIFEST
             $var = ["top_msg"]
             class override {
               $var += ["override"]
               notify { 'something': message => $var, }
             }
 
             include override
           MANIFEST
         end
       end
 
       it "leaves an array of arrays unflattened" do
         expect_the_message_to_be([['top_msg'], ['override']]) do <<-MANIFEST
             $var = [["top_msg"]]
             class override {
               $var += [["override"]]
               notify { 'something': message => $var, }
             }
 
             include override
           MANIFEST
         end
       end
 
       it "does not change a hash in the parent scope" do
         expect_the_message_to_be({"key"=>"top_msg"}) do <<-MANIFEST
             $var = { "key" => "top_msg" }
             class override {
               $var += { "other" => "override" }
               include foo
             }
             class foo {
               notify { 'something': message => $var, }
             }
 
             include override
           MANIFEST
         end
       end
 
       it "replaces a value of a key in the hash instead of merging the values" do
         expect_the_message_to_be({"key"=>"override"}) do <<-MANIFEST
             $var = { "key" => "top_msg" }
             class override {
               $var += { "key" => "override" }
               notify { 'something': message => $var, }
             }
 
             include override
           MANIFEST
         end
       end
     end
 
     describe "when using an enc" do
       it "places enc parameters in top scope" do
         enc_node = Puppet::Node.new("the node", { :parameters => { "var" => 'from_enc' } })
 
         expect_the_message_to_be('from_enc', enc_node) do <<-MANIFEST
             notify { 'something': message => $var, }
           MANIFEST
         end
       end
 
       it "does not allow the enc to specify an existing top scope var" do
         enc_node = Puppet::Node.new("the_node", { :parameters => { "var" => 'from_enc' } })
 
         expect {
           compile_to_catalog("$var = 'top scope'", enc_node)
         }.to raise_error(
           Puppet::Error,
           /Cannot reassign variable var at line 1(\:6)? on node the_node/
         )
       end
 
       it "evaluates enc classes in top scope when there is no node" do
         enc_node = Puppet::Node.new("the node", { :classes => ['foo'], :parameters => { "var" => 'from_enc' } })
 
         expect_the_message_to_be('from_enc', enc_node) do <<-MANIFEST
             class foo {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
 
       it "evaluates enc classes in the node scope when there is a matching node" do
         enc_node = Puppet::Node.new("the_node", { :classes => ['foo'] })
 
         expect_the_message_to_be('from matching node', enc_node) do <<-MANIFEST
             node inherited {
               $var = "from inherited"
             }
 
             node the_node inherits inherited {
               $var = "from matching node"
             }
 
             class foo {
               notify { 'something': message => $var, }
             }
           MANIFEST
         end
       end
     end
   end
 
   describe 'using classic parser' do
     before :each do
       Puppet[:parser] = 'current'
     end
     it_behaves_like 'the scope' do
     end
   end
 
   describe 'using future parser' do
     before :each do
       Puppet[:parser] = 'future'
     end
     it_behaves_like 'the scope' do
     end
   end
 
 end