puppet 0.18.4 → 0.22.4

data/lib/puppet/parser/scope.rb

@@ -2,1152 +2,725 @@
 # such.
 
 require 'puppet/parser/parser'
+require 'puppet/parser/templatewrapper'
 require 'puppet/transportable'
+require 'strscan'
 
-module Puppet::Parser
-    class Scope
-        class ScopeObj < Hash
-            attr_accessor :file, :line, :type, :name
-        end
-
-        # A simple wrapper for templates, so they don't have full access to
-        # the scope objects.
-        class TemplateWrapper
-            attr_accessor :scope, :file
-            include Puppet::Util
-            Puppet::Util.logmethods(self)
-
-            def initialize(scope, file)
-                @scope = scope
-                if file =~ /^#{File::SEPARATOR}/
-                    @file = file
-                else
-                    @file = File.join(Puppet[:templatedir], file)
-                end
-
-                unless FileTest.exists?(@file)
-                    raise Puppet::ParseError,
-                        "Could not find template %s" % file
-                end
-
-                # We'll only ever not have an interpreter in testing, but, eh.
-                if @scope.interp
-                    @scope.interp.newfile(@file)
-                end
-            end
+class Puppet::Parser::Scope
+    require 'puppet/parser/resource'
 
-            def method_missing(name, *args)
-                if value = @scope.lookupvar(name.to_s) and value != :undefined and value != ""
-                    return value
-                else
-                    # Just throw an error immediately, instead of searching for
-                    # other missingmethod things or whatever.
-                    raise Puppet::ParseError,
-                        "Could not find value for '%s'" % name
-                end
-            end
+    AST = Puppet::Parser::AST
 
-            def result
-                result = nil
-                benchmark(:info, "Interpolated template #{@file}") do
-                    template = ERB.new(File.read(@file))
-                    result = template.result(binding)
-                end
+    # This doesn't actually work right now.
+    Puppet.config.setdefaults(:puppet,
+        :lexical => [false, "Whether to use lexical scoping (vs. dynamic)."],
+        :templatedir => ["$vardir/templates",
+            "Where Puppet looks for template files."
+        ]
+    )
 
-                result
-            end
+    Puppet::Util.logmethods(self)
 
-            def to_s
-                "template[%s]" % @file
-            end
-        end
+    include Enumerable
+    include Puppet::Util::Errors
+    attr_accessor :parent, :level, :interp, :source, :host
+    attr_accessor :name, :type, :topscope, :base, :keyword
+    attr_accessor :top, :translated, :exported
 
-        # This doesn't actually work right now.
-        Puppet.config.setdefaults(:puppet,
-            :lexical => [false, "Whether to use lexical scoping (vs. dynamic)."],
-            :templatedir => ["$vardir/templates",
-                "Where Puppet looks for template files."
-            ]
-        )
+    # Whether we behave declaratively.  Note that it's a class variable,
+    # so all scopes behave the same.
+    @@declarative = true
 
-        Puppet::Util.logmethods(self)
-
-        include Enumerable
-        attr_accessor :parent, :level, :interp
-        attr_accessor :name, :type, :topscope, :base, :keyword
+    # Retrieve and set the declarative setting.
+    def self.declarative
+        return @@declarative
+    end
 
-        attr_accessor :top, :context, :translated, :collectable
+    def self.declarative=(val)
+        @@declarative = val
+    end
 
-        # This is probably not all that good of an idea, but...
-        # This way a parent can share its tables with all of its children.
-        attr_writer :nodetable, :classtable, :definedtable, :exportable
+    # This handles the shared tables that all scopes have.  They're effectively
+    # global tables, except that they're only global for a single scope tree,
+    # which is why I can't use class variables for them.
+    def self.sharedtable(*names)
+        attr_accessor(*names)
+        @@sharedtables ||= []
+        @@sharedtables += names
+    end
 
-        # Whether we behave declaratively.  Note that it's a class variable,
-        # so all scopes behave the same.
-        @@declarative = true
+    # This is probably not all that good of an idea, but...
+    # This way a parent can share its tables with all of its children.
+    sharedtable :classtable, :definedtable, :exportable, :overridetable, :collecttable
 
-        # Retrieve and set the declarative setting.
-        def self.declarative
-            return @@declarative
+    # Is the value true?  This allows us to control the definition of truth
+    # in one place.
+    def self.true?(value)
+        if value == false or value == ""
+            return false
+        else
+            return true
         end
+    end
 
-        def self.declarative=(val)
-            @@declarative = val
+    # Add to our list of namespaces.
+    def add_namespace(ns)
+        return false if @namespaces.include?(ns)
+        if @namespaces == [""]
+            @namespaces = [ns]
+        else
+            @namespaces << ns
         end
+    end
 
-        # Add all of the defaults for a given object to that object.
-        def adddefaults(obj)
-            defaults = lookupdefaults(obj.type)
-
-            defaults.each do |var, value|
-                unless obj[var]
-                    self.debug "Adding default %s for %s" %
-                        [var, obj.type]
-
-                    obj[var] = value
-                end
-            end
+    # Is the type a builtin type?
+    def builtintype?(type)
+        if typeklass = Puppet::Type.type(type)
+            return typeklass
+        else
+            return false
         end
+    end
 
-        # Add a single object's tags to the global list of tags for
-        # that object.
-        def addtags(obj)
-            unless defined? @tagtable
-                raise Puppet::DevError, "Told to add tags, but no tag table"
-            end
-            list = @tagtable[obj.type][obj.name]
-
-            obj.tags.each { |tag|
-                unless list.include?(tag)
-                    if tag.nil? or tag == ""
-                        Puppet.debug "Got tag %s from %s(%s)" %
-                            [tag.inspect, obj.type, obj.name]
-                    else
-                        list << tag
-                    end
-                end
-            }
-        end
+    # Create a new child scope.
+    def child=(scope)
+        @children.push(scope)
 
-        # Is the type a builtin type?
-        def builtintype?(type)
-            if typeklass = Puppet::Type.type(type)
-                return typeklass
-            else
-                return false
-            end
+        # Copy all of the shared tables over to the child.
+        @@sharedtables.each do |name|
+            scope.send(name.to_s + "=", self.send(name))
         end
+    end
 
-        # Verify that the given object isn't defined elsewhere.
-        def chkobjectclosure(hash)
-            type = hash[:type]
-            name = hash[:name]
-            unless name
-                return true
-            end
-            if @definedtable[type].include?(name)
-                typeklass = Puppet::Type.type(type)
-                if typeklass and ! typeklass.isomorphic?
-                    Puppet.info "Allowing duplicate %s" % type
-                else
-                    exobj = @definedtable[type][name]
-
-                    # Either it's a defined type, which are never
-                    # isomorphic, or it's a non-isomorphic type.
-                    msg = "Duplicate definition: %s[%s] is already defined" %
-                        [type, name]
-
-                    if exobj.file and exobj.line
-                        msg << " in file %s at line %s" %
-                            [exobj.file, exobj.line]
-                    end
-
-                    if hash[:line] or hash[:file]
-                        msg << "; cannot redefine"
-                    end
+    # Verify that the given object isn't defined elsewhere.
+    def chkobjectclosure(obj)
+        if exobj = @definedtable[obj.ref]
+            typeklass = Puppet::Type.type(obj.type)
+            if typeklass and ! typeklass.isomorphic?
+                Puppet.info "Allowing duplicate %s" % type
+            else
+                # Either it's a defined type, which are never
+                # isomorphic, or it's a non-isomorphic type.
+                msg = "Duplicate definition: %s is already defined" % obj.ref
 
-                    error = Puppet::ParseError.new(msg)
-                    raise error
+                if exobj.file and exobj.line
+                    msg << " in file %s at line %s" %
+                        [exobj.file, exobj.line]
                 end
-            end
 
-            return true
-        end
+                if obj.line or obj.file
+                    msg << "; cannot redefine"
+                end
 
-        def declarative=(val)
-            self.class.declarative = val
+                raise Puppet::ParseError.new(msg)
+            end
         end
 
-        def declarative
-            self.class.declarative
-        end
+        return true
+    end
 
-        # Log the existing tags.  At some point this should be in a better
-        # place, but eh.
-        def logtags
-            @tagtable.sort { |a, b|
-                a[0] <=> b[0]
-            }.each { |type, names|
-                names.sort { |a, b|
-                    a[0] <=> b[0]
-                }.each { |name, tags|
-                    Puppet.info "%s(%s): '%s'" % [type, name, tags.join("' '")]
-                }
-            }
+    # Return the scope associated with a class.  This is just here so
+    # that subclasses can set their parent scopes to be the scope of
+    # their parent class.
+    def class_scope(klass)
+        if klass.respond_to?(:fqname)
+            @classtable[klass.fqname]
+        else
+            @classtable[klass]
         end
+    end
 
-        # Create a new child scope.
-        def child=(scope)
-            @children.push(scope)
+    # Return the list of collections.
+    def collections
+        @collecttable
+    end
 
-            if defined? @nodetable
-                scope.nodetable = @nodetable
-            else
-                raise Puppet::DevError, "No nodetable has been defined"
-            end
+    def declarative=(val)
+        self.class.declarative = val
+    end
 
-            if defined? @classtable
-                scope.classtable = @classtable
-            else
-                raise Puppet::DevError, "No classtable has been defined"
-            end
+    def declarative
+        self.class.declarative
+    end
 
-            if defined? @exportable
-                scope.exportable = @exportable
-            else
-                raise Puppet::DevError, "No exportable has been defined"
-            end
+    # Test whether a given scope is declarative.  Even though it's
+    # a global value, the calling objects don't need to know that.
+    def declarative?
+        @@declarative
+    end
 
-            if defined? @definedtable
-                scope.definedtable = @definedtable
-            else
-                raise Puppet::DevError, "No definedtable has been defined"
-            end
-        end
+    # Remove a specific child.
+    def delete(child)
+        @children.delete(child)
+    end
 
-        # Test whether a given scope is declarative.  Even though it's
-        # a global value, the calling objects don't need to know that.
-        def declarative?
-            @@declarative
+    # Remove a resource from the various tables.  This is only used when
+    # a resource maps to a definition and gets evaluated.
+    def deleteresource(resource)
+        if @definedtable[resource.ref]
+            @definedtable.delete(resource.ref)
         end
 
-        # Remove a specific child.
-        def delete(child)
-            @children.delete(child)
+        if @children.include?(resource)
+            @children.delete(resource)
         end
+    end
 
-        # Are we the top scope?
-        def topscope?
-            @level == 1
-        end
+    # Are we the top scope?
+    def topscope?
+        @level == 1
+    end
 
-        # Return a list of all of the defined classes.
-        def classlist
-            unless defined? @classtable
-                raise Puppet::DevError, "Scope did not receive class table"
-            end
-            return @classtable.collect { |id, klass|
-                # The class table can contain scopes or strings as its values
-                # so support them accordingly.
-                if klass.is_a? Scope
-                    klass.type
-                else
-                    klass
-                end
-            }
+    # Return a list of all of the defined classes.
+    def classlist
+        unless defined? @classtable
+            raise Puppet::DevError, "Scope did not receive class table"
         end
+        return @classtable.keys.reject { |k| k == "" }
+    end
 
-        # Yield each child scope in turn
-        def each
-            @children.each { |child|
-                yield child
-            }
-        end
+    # Yield each child scope in turn
+    def each
+        @children.each { |child|
+            yield child
+        }
+    end
 
-        # Evaluate a list of classes.
-        def evalclasses(classes)
-            return unless classes
-            classes.each do |klass|
-                if code = lookuptype(klass)
-                    # Just reuse the 'include' function, since that's the equivalent
-                    # of what we're doing here.
-                    function_include(klass)
-                end
+    # Evaluate a list of classes.
+    def evalclasses(*classes)
+        retval = []
+        classes.each do |klass|
+            if obj = findclass(klass)
+                obj.safeevaluate :scope => self
+                retval << klass
             end
         end
+        retval
+    end
 
-        # Evaluate a specific node's code.  This method will normally be called
-        # on the top-level scope, but it actually evaluates the node at the
-        # appropriate scope.
-        def evalnode(hash)
-            objects = hash[:ast]
-            names = hash[:names]  or
-                raise Puppet::DevError, "Node names must be provided to evalnode"
-            facts = hash[:facts]
-            classes = hash[:classes]
-            parent = hash[:parent]
-
-            # Always add "default" to our name list, so we're always searching
-            # for a default node.
-            names << "default"
-
-            scope = code = nil
-            # Find a node that matches one of our names
-            names.each { |node|
-                if nodehash = @nodetable[node]
-                    code = nodehash[:node]
-                    scope = nodehash[:scope]
-
-                    if node == "default"
-                        Puppet.info "Using default node"
-                    end
-                    break
-                end
-            }
+    def exported?
+        self.exported
+    end
 
-            # And fail if we don't find one.
-            unless scope and code
-                raise Puppet::Error, "Could not find configuration for %s" %
-                    names.join(" or ")
+    def findclass(name)
+        @namespaces.each do |namespace|
+            if r = interp.findclass(namespace, name)
+                return r
             end
-
-            # We need to do a little skullduggery here.  We want a
-            # temporary scope, because we don't want this scope to
-            # show up permanently in the scope tree -- otherwise we could
-            # not evaluate the node multiple times.  We could conceivably
-            # cache the results, but it's not worth it at this stage.
-
-            # Note that we evaluate the node code with its containing
-            # scope, not with the top scope.  We also retrieve the created
-            # scope so that we can get any classes set within it
-            nodescope = code.safeevaluate(:scope => scope, :facts => facts)
-
-            scope.evalclasses(classes)
         end
+        return nil
+    end
 
-        # The top-level evaluate, used to evaluate a whole AST tree.  This is
-        # a strange method, in that it turns around and calls evaluate() on its
-        # :ast argument.
-        def evaluate(hash)
-            objects = hash[:ast]
-            facts = hash[:facts] || {}
-
-            @@done = []
-
-            unless objects
-                raise Puppet::DevError, "Evaluation requires an AST tree"
-            end
-
-            # Set all of our facts in the top-level scope.
-            facts.each { |var, value|
-                self.setvar(var, value)
-            }
-
-            # Evaluate all of our configuration.  This does not evaluate any
-            # node definitions.
-            result = objects.safeevaluate(:scope => self)
-
-            # If they've provided a name or a parent, we assume they're looking
-            # for nodes.
-            if hash[:searched]
-                # Specifying a parent node takes precedence, because it is assumed
-                # that this node was found in a remote repository like ldap.
-                gennode(hash)
-            elsif hash.include? :names # else, look for it in the config
-                evalnode(hash)
-            else
-                # Else we're not using nodes at all, so just evaluate any passed-in
-                # classes.
-                classes = hash[:classes] || []
-                evalclasses(classes)
-
-                # These classes would be passed in manually, via something like
-                # a cfengine module
+    def finddefine(name)
+        @namespaces.each do |namespace|
+            if r = interp.finddefine(namespace, name)
+                return r
             end
+        end
+        return nil
+    end
 
-            bucket = self.to_trans
-
-            # Add our class list
-            unless self.classlist.empty?
-                bucket.classes = self.classlist
-            end
+    def findresource(string, name = nil)
+        if name
+            string = "%s[%s]" % [string.capitalize, name]
+        end
 
-            # Now clean up after ourselves
-            [@@done].each do |table|
-                table.clear
-            end
+        @definedtable[string]
+    end
 
-            return bucket
+    # Recursively complete the whole tree, in preparation for
+    # translation or storage.
+    def finish
+        self.each do |obj|
+            obj.finish
         end
+    end
 
-        # Return the hash of objects that we specifically exported.  We return
-        # a hash to make it easy for the caller to deduplicate based on name.
-        def exported(type)
-            if @exportable.include?(type)
-                return @exportable[type].dup
+    # Initialize our new scope.  Defaults to having no parent and to
+    # being declarative.
+    def initialize(hash = {})
+        @parent = nil
+        @type = nil
+        @name = nil
+        @finished = false
+        if hash.include?(:namespace)
+            if n = hash[:namespace]
+                @namespaces = [n]
+            end
+            hash.delete(:namespace)
+        else
+            @namespaces = [""]
+        end
+        hash.each { |name, val|
+            method = name.to_s + "="
+            if self.respond_to? method
+                self.send(method, val)
             else
-                return {}
-            end
-        end
-
-        # Store our object in the central export table.
-        def exportobject(obj)
-            if @exportable.include?(obj.type) and
-                @exportable[obj.type].include?(obj.name)
-                    raise Puppet::ParseError, "Object %s[%s] is already exported" %
-                        [obj.type, obj.name]
+                raise Puppet::DevError, "Invalid scope argument %s" % name
             end
+        }
 
-            debug "Exporting %s[%s]" % [obj.type, obj.name]
+        @tags = []
 
-            @exportable[obj.type][obj.name] = obj
+        if @parent.nil?
+            unless hash.include?(:declarative)
+                hash[:declarative] = true
+            end
+            self.istop(hash[:declarative])
+            @inside = nil
+        else
+            # This is here, rather than in newchild(), so that all
+            # of the later variable initialization works.
+            @parent.child = self
 
-            return obj
+            @level = @parent.level + 1
+            @interp = @parent.interp
+            @source = hash[:source] || @parent.source
+            @topscope = @parent.topscope
+            #@inside = @parent.inside # Used for definition inheritance
+            @host = @parent.host
+            @type ||= @parent.type
         end
 
-        # Pull in all of the appropriate classes and evaluate them.  It'd
-        # be nice if this didn't know quite so much about how AST::Node
-        # operated internally.  This is used when a list of classes is passed in,
-        # instead of a node definition, such as from the cfengine module.
-        def gennode(hash)
-            names = hash[:names] or
-                raise Puppet::DevError, "Node names must be provided to gennode"
-            facts = hash[:facts]
-            classes = hash[:classes]
-            parent = hash[:parentnode]
-            name = names.shift
-            arghash = {
-                :type => name,
-                :code => AST::ASTArray.new(:pin => "[]")
-            }
-
-            #Puppet.notice "hash is %s" %
-            #    hash.inspect
-            #Puppet.notice "Classes are %s, parent is %s" %
-            #    [classes.inspect, parent.inspect]
+        # Our child scopes and objects
+        @children = []
 
-            if parent
-                arghash[:parentclass] = parent
-            end
+        # The symbol table for this scope.  This is where we store variables.
+        @symtable = {}
 
-            # Create the node
-            node = AST::Node.new(arghash)
-            node.keyword = "node"
+        # All of the defaults set for types.  It's a hash of hashes,
+        # with the first key being the type, then the second key being
+        # the parameter.
+        @defaultstable = Hash.new { |dhash,type|
+            dhash[type] = {}
+        }
 
-            # Now evaluate it, which evaluates the parent and nothing else
-            # but does return the nodescope.
-            scope = node.safeevaluate(:scope => self)
-
-            # Finally evaluate our list of classes in this new scope.
-            scope.evalclasses(classes)
+        unless @interp
+            raise Puppet::DevError, "Scopes require an interpreter"
         end
+    end
 
-        # Initialize our new scope.  Defaults to having no parent and to
-        # being declarative.
-        def initialize(hash = {})
-            @parent = nil
-            @type = nil
-            @name = nil
-            @finished = false
-            hash.each { |name, val|
-                method = name.to_s + "="
-                if self.respond_to? method
-                    self.send(method, val)
-                else
-                    raise Puppet::DevError, "Invalid scope argument %s" % name
-                end
-            }
-
-            @tags = []
-
-            if @parent.nil?
-                unless hash.include?(:declarative)
-                    hash[:declarative] = true
-                end
-                self.istop(hash[:declarative])
-            else
-                # This is here, rather than in newchild(), so that all
-                # of the later variable initialization works.
-                @parent.child = self
-
-                @level = @parent.level + 1
-                @interp = @parent.interp
-                @topscope = @parent.topscope
-                @context = @parent.context
-            end
-
-            # Our child scopes and objects
-            @children = []
+    # Associate the object directly with the scope, so that contained objects
+    # can look up what container they're running within.
+    def inside(arg = nil)
+        return @inside unless arg
+
+        old = @inside
+        @inside = arg
+        yield
+    ensure
+        #Puppet.warning "exiting %s" % @inside.name
+        @inside = old
+    end
 
-            # The symbol table for this scope
-            @symtable = Hash.new(nil)
+    # Mark that we're the top scope, and set some hard-coded info.
+    def istop(declarative = true)
+        # the level is mostly used for debugging
+        @level = 1
 
-            # The type table for this scope
-            @typetable = Hash.new(nil)
+        # The table for storing class singletons.  This will only actually
+        # be used by top scopes and node scopes.
+        @classtable = {}
 
-            # All of the defaults set for types.  It's a hash of hashes,
-            # with the first key being the type, then the second key being
-            # the parameter.
-            @defaultstable = Hash.new { |dhash,type|
-                dhash[type] = Hash.new(nil)
-            }
+        self.class.declarative = declarative
 
-            # The object table is similar, but it is actually a hash of hashes
-            # where the innermost objects are TransObject instances.
-            @objectable = Hash.new { |typehash,typekey|
-                # See #newobject for how to create the actual objects
-                typehash[typekey] = Hash.new(nil)
-            }
+        # The table for all defined objects.
+        @definedtable = {}
 
-            # This is just for collecting statements locally, so we can
-            # verify that there is no overlap within this specific scope
-            @localobjectable = Hash.new { |typehash,typekey|
-                typehash[typekey] = Hash.new(nil)
-            }
+        # The list of objects that will available for export.
+        @exportable = {}
 
-            # Map the names to the tables.
-            @map = {
-                "variable" => @symtable,
-                "type" => @typetable,
-                "node" => @nodetable,
-                "object" => @objectable,
-                "defaults" => @defaultstable
-            }
+        # The list of overrides.  This is used to cache overrides on objects
+        # that don't exist yet.  We store an array of each override.
+        @overridetable = Hash.new do |overs, ref|
+            overs[ref] = []
         end
 
-        # Mark that we're the top scope, and set some hard-coded info.
-        def istop(declarative = true)
-            # the level is mostly used for debugging
-            @level = 1
+        # Eventually, if we support sites, this will allow definitions
+        # of nodes with the same name in different sites.  For now
+        # the top-level scope is always the only site scope.
+        @sitescope = true
 
-            # The table for storing class singletons.  This will only actually
-            # be used by top scopes and node scopes.
-            @classtable = Hash.new(nil)
+        @namespaces = [""]
 
-            self.class.declarative = declarative
+        # The list of collections that have been created.  This is a global list,
+        # but they each refer back to the scope that created them.
+        @collecttable = []
 
-            # The table for all defined objects.
-            @definedtable = Hash.new { |types, type|
-                types[type] = {}
-            }
-
-            # A table for storing nodes.
-            @nodetable = Hash.new(nil)
-
-            # The list of objects that will available for export.
-            @exportable = Hash.new { |types, type|
-                types[type] = {}
-            }
+        @topscope = self
+        @type = "puppet"
+        @name = "top"
+    end
 
-            # Eventually, if we support sites, this will allow definitions
-            # of nodes with the same name in different sites.  For now
-            # the top-level scope is always the only site scope.
-            @sitescope = true
-
-            # And create a tag table, so we can collect all of the tags
-            # associated with any objects created in this scope tree
-            @tagtable = Hash.new { |types, type|
-                types[type] = Hash.new { |names, name|
-                    names[name] = []
-                }
+    # Collect all of the defaults set at any higher scopes.
+    # This is a different type of lookup because it's additive --
+    # it collects all of the defaults, with defaults in closer scopes
+    # overriding those in later scopes.
+    def lookupdefaults(type)
+        values = {}
+
+        # first collect the values from the parents
+        unless @parent.nil?
+            @parent.lookupdefaults(type).each { |var,value|
+                values[var] = value
             }
-
-            @context = nil
-            @topscope = self
-            @type = "puppet"
-            @name = "top"
-        end
-
-        # Look up a given class.  This enables us to make sure classes are
-        # singletons
-        def lookupclass(klassid)
-            unless defined? @classtable
-                raise Puppet::DevError, "Scope did not receive class table"
-            end
-            return @classtable[klassid]
         end
 
-        # Collect all of the defaults set at any higher scopes.
-        # This is a different type of lookup because it's additive --
-        # it collects all of the defaults, with defaults in closer scopes
-        # overriding those in later scopes.
-        def lookupdefaults(type)
-            values = {}
-
-            # first collect the values from the parents
-            unless @parent.nil?
-                @parent.lookupdefaults(type).each { |var,value|
-                    values[var] = value
-                }
-            end
-
-            # then override them with any current values
-            # this should probably be done differently
-            if @defaultstable.include?(type)
-                @defaultstable[type].each { |var,value|
-                    values[var] = value
-                }
-            end
-            #Puppet.debug "Got defaults for %s: %s" %
-            #    [type,values.inspect]
-            return values
-        end
-
-        # Look up all of the exported objects of a given type.  Just like
-        # lookupobject, this only searches up through parent classes, not
-        # the whole scope tree.
-        def lookupexported(type)
-            found = []
-            sub = proc { |table|
-                # We always return nil so that it will search all the way
-                # up the scope tree.
-                if table.has_key?(type)
-                    table[type].each do |name, obj|
-                        found << obj
-                    end
-                    nil
-                else
-                    info table.keys.inspect
-                    nil
-                end
+        # then override them with any current values
+        # this should probably be done differently
+        if @defaultstable.include?(type)
+            @defaultstable[type].each { |var,value|
+                values[var] = value
             }
+        end
 
-            value = lookup("object",sub, false)
+        #Puppet.debug "Got defaults for %s: %s" %
+        #    [type,values.inspect]
+        return values
+    end
 
-            return found
+    # Look up all of the exported objects of a given type.  Just like
+    # lookupobject, this only searches up through parent classes, not
+    # the whole scope tree.
+    def lookupexported(type)
+        @definedtable.find_all do |name, r|
+            r.type == type and r.exported?
         end
+    end
 
-        # Look up a node by name
-        def lookupnode(name)
-            #Puppet.debug "Looking up type %s" % name
-            value = lookup("type",name)
-            if value == :undefined
-                return nil
-            else
-                #Puppet.debug "Found node %s" % name
-                return value
-            end
-        end
+    def lookupoverrides(obj)
+        @overridetable[obj.ref]
+    end
 
-        # Look up a defined type.
-        def lookuptype(name)
-            #Puppet.debug "Looking up type %s" % name
-            value = lookup("type",name)
-            if value == :undefined
-                return nil
-            else
-                #Puppet.debug "Found type %s" % name
-                return value
-            end
-        end
+    # Look up a defined type.
+    def lookuptype(name)
+        finddefine(name) || findclass(name)
+    end
 
-        # Look up an object by name and type.  This should only look up objects
-        # within a class structure, not within the entire scope structure.
-        def lookupobject(hash)
-            type = hash[:type]
-            name = hash[:name]
-            #Puppet.debug "Looking up object %s of type %s in level %s" %
-            #    [name, type, @level]
-            sub = proc { |table|
-                if table.include?(type)
-                    if table[type].include?(name)
-                        table[type][name]
-                    end
-                else
-                    nil
-                end
-            }
-            value = lookup("object",sub, true)
-            if value == :undefined
-                return nil
-            else
-                return value
-            end
+    def lookup_qualified_var(name, usestring)
+        parts = name.split(/::/)
+        shortname = parts.pop
+        klassname = parts.join("::")
+        klass = findclass(klassname)
+        unless klass
+            raise Puppet::ParseError, "Could not find class %s" % klassname
         end
-
-        # Look up a variable.  The simplest value search we do.
-        def lookupvar(name)
-            value = lookup("variable", name)
-            if value == :undefined
-                return ""
-            else
-                return value
-            end
+        unless kscope = class_scope(klass)
+            raise Puppet::ParseError, "Class %s has not been evaluated so its variables cannot be referenced" % klass.fqname
         end
+        return kscope.lookupvar(shortname, usestring)
+    end
 
-        def newcollection(coll)
-            @children << coll
+    private :lookup_qualified_var
+
+    # Look up a variable.  The simplest value search we do.  Default to returning
+    # an empty string for missing values, but support returning a constant.
+    def lookupvar(name, usestring = true)
+        # If the variable is qualified, then find the specified scope and look the variable up there instead.
+        if name =~ /::/
+            return lookup_qualified_var(name, usestring)
+        end
+        # We can't use "if @symtable[name]" here because the value might be false
+        if @symtable.include?(name)
+            return @symtable[name]
+        elsif self.parent 
+            return @parent.lookupvar(name, usestring)
+        elsif usestring
+            return ""
+        else
+            return :undefined
         end
+    end
 
-        # Add a new object to our object table.
-        def newobject(hash)
-            if @objectable[hash[:type]].include?(hash[:name])
-                raise Puppet::DevError, "Object %s[%s] is already defined" %
-                    [hash[:type], hash[:name]]
-            end
-
-            self.chkobjectclosure(hash)
-
-            obj = nil
-
-            obj = Puppet::TransObject.new(hash[:name], hash[:type])
+    def namespaces
+        @namespaces.dup
+    end
 
-            @children << obj
+    # Add a collection to the global list.
+    def newcollection(coll)
+        @collecttable << coll
+    end
 
-            @objectable[hash[:type]][hash[:name]] = obj
+    # Create a new scope.
+    def newscope(hash = {})
+        hash[:parent] = self
+        #debug "Creating new scope, level %s" % [self.level + 1]
+        return Puppet::Parser::Scope.new(hash)
+    end
 
-            @definedtable[hash[:type]][hash[:name]] = obj
+    # Return the list of remaining overrides.
+    def overrides
+        #@overridetable.collect { |name, overs| overs }.flatten
+        @overridetable.values.flatten
+    end
 
-            return obj
-        end
+    def resources
+        @definedtable.values
+    end
 
-        # Create a new scope.
-        def newscope(hash = {})
-            hash[:parent] = self
-            #debug "Creating new scope, level %s" % [self.level + 1]
-            return Puppet::Parser::Scope.new(hash)
+    def setclass?(obj)
+        if obj.respond_to?(:fqname)
+            @classtable.has_key?(obj.fqname)
+        else
+            @classtable[obj]
         end
+    end
 
-        # Retrieve a specific node.  This is used in ast.rb to find a
-        # parent node and in findnode to retrieve and evaluate a node.
-        def node(name)
-            @nodetable[name]
+    # Store the fact that we've evaluated a given class.  We use a hash
+    # that gets inherited from the top scope down, rather than a global
+    # hash.  We store the object ID, not class name, so that we
+    # can support multiple unrelated classes with the same name.
+    def setclass(obj)
+        if obj.is_a?(AST::HostClass)
+            unless obj.fqname
+                raise Puppet::DevError, "Got a %s with no fully qualified name" %
+                    obj.class
+            end
+            @classtable[obj.fqname] = self
+        else
+            raise Puppet::DevError, "Invalid class %s" % obj.inspect
         end
+    end
 
-        # Store the fact that we've evaluated a given class.  We use a hash
-        # that gets inherited from the top scope down, rather than a global
-        # hash.  We store the object ID, not class name, so that we
-        # can support multiple unrelated classes with the same name.
-        def setclass(id, name)
-            unless name =~ /^[a-z][\w-]*$/
-                raise Puppet::ParseError, "Invalid class name '%s'" % name
-            end
+    # Set all of our facts in the top-level scope.
+    def setfacts(facts)
+        facts.each { |var, value|
+            self.setvar(var, value)
+        }
+    end
 
-            @classtable[id] = name
-        end
+    # Add a new object to our object table and the global list, and do any necessary
+    # checks.
+    def setresource(obj)
+        self.chkobjectclosure(obj)
 
-        # Store the scope for each class, so that other subclasses can look
-        # them up.
-        def setscope(id, scope)
-            @classtable[id] = scope
-        end
+        @children << obj
 
-        # Set defaults for a type.  The typename should already be downcased,
-        # so that the syntax is isolated.
-        def setdefaults(type,params)
-            table = @defaultstable[type]
+        # The global table
+        @definedtable[obj.ref] = obj
 
-            # if we got a single param, it'll be in its own array
-            unless params[0].is_a?(Array)
-                params = [params]
-            end
+        return obj
+    end
 
-            params.each { |ary|
-                #Puppet.debug "Default for %s is %s => %s" %
-                #    [type,ary[0].inspect,ary[1].inspect]
-                if @@declarative
-                    if table.include?(ary[0])
-                        error = Puppet::ParseError.new(
-                            "Default already defined for %s { %s }" %
-                                [type,ary[0]]
-                        )
-                        raise error
-                    end
-                else
-                    if table.include?(ary[0])
-                        # we should maybe allow this warning to be turned off...
-                        Puppet.warning "Replacing default for %s { %s }" %
-                            [type,ary[0]]
-                    end
-                end
-                table[ary[0]] = ary[1]
-            }
+    # Override a parameter in an existing object.  If the object does not yet
+    # exist, then cache the override in a global table, so it can be flushed
+    # at the end.
+    def setoverride(resource)
+        resource.override = true
+        if obj = @definedtable[resource.ref]
+            obj.merge(resource)
+        else
+            @overridetable[resource.ref] << resource
         end
+    end
 
-        # Store a host in the site node table.
-        def setnode(name,code)
-            unless defined? @nodetable
-                raise Puppet::DevError, "No node table defined"
-            end
-            if @nodetable.include?(name)
-                raise Puppet::ParseError, "Host %s is already defined" % name
+    # Set defaults for a type.  The typename should already be downcased,
+    # so that the syntax is isolated.  We don't do any kind of type-checking
+    # here; instead we let the resource do it when the defaults are used.
+    def setdefaults(type, params)
+        table = @defaultstable[type]
+
+        # if we got a single param, it'll be in its own array
+        params = [params] unless params.is_a?(Array)
+
+        params.each { |param|
+            #Puppet.debug "Default for %s is %s => %s" %
+            #    [type,ary[0].inspect,ary[1].inspect]
+            if @@declarative
+                if table.include?(param.name)
+                    self.fail "Default already defined for %s { %s }" %
+                            [type,param.name]
+                end
             else
-                #Puppet.warning "Setting node %s at level %s" % [name, @level]
-
-                # We have to store both the scope that's setting the node and
-                # the node itself, so that the node gets evaluated in the correct
-                # scope.
-                code.scope = self
-                @nodetable[name] = {
-                    :scope => self,
-                    :node => code
-                }
+                if table.include?(param.name)
+                    # we should maybe allow this warning to be turned off...
+                    Puppet.warning "Replacing default for %s { %s }" %
+                        [type,param.name]
+                end
             end
-        end
+            table[param.name] = param
+        }
+    end
 
-        # Define our type.
-        def settype(name,ltype)
-            # Don't let them redefine the class in this scope.
-            if @typetable.include?(name)
-                raise Puppet::ParseError,
-                    "%s is already defined" % name
+    # 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 if we're declarative (which is the default).
+    def setvar(name,value, file = nil, line = nil)
+        #Puppet.debug "Setting %s to '%s' at level %s" %
+        #    [name.inspect,value,self.level]
+        if @symtable.include?(name)
+            if @@declarative
+                error = Puppet::ParseError.new("Cannot reassign variable %s" % name)
+                if file
+                    error.file = file
+                end
+                if line
+                    error.line = line
+                end
+                raise error
             else
-                ltype.scope = self
-                @typetable[name] = ltype
+                Puppet.warning "Reassigning %s to %s" % [name,value]
             end
         end
+        @symtable[name] = value
+    end
 
-        # This method will fail if the named object is already defined anywhere
-        # in the scope tree, which is what provides some minimal closure-like
-        # behaviour.
-        def setobject(hash)
-            # FIXME This objectlookup stuff should be looking up using both
-            # the name and the namevar.
-
-            # First see if we can look the object up using normal scope
-            # rules, i.e., one of our parent classes has defined the
-            # object or something
-
-            name = hash[:name]
-            type = hash[:type]
-            params = hash[:arguments]
-            file = hash[:file]
-            line = hash[:line]
-
-            collectable = hash[:collectable] || self.collectable
-
-            # Verify that we're not overriding any already-set parameters.
-            if localobj = @localobjectable[type][name]
-                params.each { |var, value|
-                    if localobj.include?(var)
-                        msg = "Cannot reassign attribute %s on %s[%s]" %
-                            [var, type, name]
-
-                        error = Puppet::ParseError.new(msg)
-                        error.line = line
-                        error.file = file
-                        raise error
+    # Return an interpolated string.
+    def strinterp(string, file = nil, line = nil)
+        # Most strings won't have variables in them.
+        ss = StringScanner.new(string)
+        out = ""
+        while not ss.eos?
+            if ss.scan(/^\$\{((\w*::)*\w+)\}|^\$((\w*::)*\w+)/) 
+                # If it matches the backslash, then just retun the dollar sign.
+                if ss.matched == '\\$'
+                    out << '$'
+                else # look the variable up
+                    out << lookupvar(ss[1] || ss[3]).to_s || ""
+                end
+            elsif ss.scan(/^\\(.)/)
+                # Puppet.debug("Got escape: pos:%d; m:%s" % [ss.pos, ss.matched])
+                case ss[1]
+                when 'n'
+                    out << "\n"
+                when 't'
+                    out << "\t"
+                when 's'
+                    out << " "
+                when '\\'
+                    out << '\\'
+                when '$'
+                    out << '$'
+                else
+                    str = "Unrecognised escape sequence '#{ss.matched}'"
+                    if file
+                        str += " in file %s" % file
                     end
-                }
-            end
-
-            # First look for it in a parent scope
-            obj = lookupobject(:name => name, :type => type)
-
-            if obj
-                unless collectable == obj.collectable
-                    msg = nil
-                    if collectable
-                        msg = "Exported %s[%s] cannot override local objects"
-                            [type, name]
-                    else
-                        msg = "Local %s[%s] cannot override exported objects"
-                            [type, name]
+                    if line
+                        str += " at line %s" % line
                     end
-
-                    error = Puppet::ParseError.new(msg)
-                    error.line = line
-                    error.file = file
-                    raise error
+                    Puppet.warning str
+                    out << ss.matched
                 end
-            end
-
-            unless obj and obj != :undefined
-                unless obj = @objectable[type][name]
-                    obj = self.newobject(
-                        :type => type,
-                        :name => name,
-                        :line => line,
-                        :file => file
-                    )
-
-                    obj.collectable = collectable
-
-                    # only set these if we've created the object,
-                    # which is the most common case
-                    # FIXME we eventually need to store the file
-                    # and line with each param, not the object
-                    # itself.
-                    obj.file = file
-                    obj.line = line
+            elsif ss.scan(/^\$/)
+                out << '$'
+            elsif ss.scan(/^\\\n/) # an escaped carriage return
+                next
+            else 
+                tmp = ss.scan(/[^\\$]+/)
+                # Puppet.debug("Got other: pos:%d; m:%s" % [ss.pos, tmp])
+                unless tmp
+                    error = Puppet::ParseError.new("Could not parse string %s" %
+                        string.inspect)
+                    {:file= => file, :line= => line}.each do |m,v|
+                        error.send(m, v) if v
+                    end
+                    raise error
                 end
+                out << tmp
             end
-
-            # Now add our parameters.  This has the function of overriding
-            # existing values, which might have been defined in a higher
-            # scope.
-            params.each { |var,value|
-                # Add it to our found object
-                obj[var] = value
-            }
-
-            # This is only used for override verification -- the local object
-            # table does not have transobjects or whatever in it, it just has
-            # simple hashes.  This is necessary because setobject can modify
-            # our object table or a parent class's object table, and we
-            # still need to make sure param settings cannot be duplicated
-            # within our scope.
-            @localobjectable[type][name] ||= {}
-            params.each { |var,value|
-                # And add it to the local table; mmm, hack
-                @localobjectable[type][name][var] = value
-            }
-
-            return obj
         end
 
-        # 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 if we're declarative (which is the default).
-        def setvar(name,value)
-            #Puppet.debug "Setting %s to '%s' at level %s" %
-            #    [name.inspect,value,self.level]
-            if @@declarative and @symtable.include?(name)
-                raise Puppet::ParseError, "Cannot reassign variable %s" % name
-            else
-                if @symtable.include?(name)
-                    Puppet.warning "Reassigning %s to %s" % [name,value]
-                end
-                @symtable[name] = value
-            end
-        end
+        return out
+    end
 
-        # Return an interpolated string.
-        def strinterp(string)
-            newstring = string.gsub(/\\\$|\$\{(\w+)\}|\$(\w+)/) do |value|
-                # If it matches the backslash, then just retun the dollar sign.
-                if value == '\\$'
-                    '$'
-                else # look the variable up
-                    var = $1 || $2
-                    lookupvar($1 || $2)
-                end
+    # Add a tag to our current list.  These tags will be added to all
+    # of the objects contained in this scope.
+    def tag(*ary)
+        ary.each { |tag|
+            if tag.nil? or tag == ""
+                puts caller
+                Puppet.debug "got told to tag with %s" % tag.inspect
+                next
             end
+            unless tag =~ /^\w[-\w]+$/
+                fail Puppet::ParseError, "Invalid tag %s" % tag.inspect
+            end
+            tag = tag.to_s
+            unless @tags.include?(tag)
+                #Puppet.info "Tagging scope %s with %s" % [self.object_id, tag]
+                @tags << tag
+            end
+        }
+    end
 
-            return newstring.gsub(/\\t/, "\t").gsub(/\\n/, "\n").gsub(/\\s/, "\s")
-        end
-
-        # Add a tag to our current list.  These tags will be added to all
-        # of the objects contained in this scope.
-        def tag(*ary)
-            ary.each { |tag|
+    # Return the tags associated with this scope.  It's basically
+    # just our parents' tags, plus our type.  We don't cache this value
+    # because our parent tags might change between calls.
+    def tags
+        tmp = [] + @tags
+        unless ! defined? @type or @type.nil? or @type == ""
+            tmp << @type.to_s
+        end
+        if @parent
+            #info "Looking for tags in %s" % @parent.type
+            @parent.tags.each { |tag|
                 if tag.nil? or tag == ""
-                    Puppet.debug "got told to tag with %s" % tag.inspect
+                    Puppet.debug "parent returned tag %s" % tag.inspect
                     next
                 end
-                unless @tags.include?(tag)
-                    #Puppet.info "Tagging scope %s with %s" % [self.object_id, tag]
-                    @tags << tag.to_s
+                unless tmp.include?(tag)
+                    tmp << tag
                 end
             }
         end
+        return tmp.sort.uniq
+    end
 
-        # Return the tags associated with this scope.  It's basically
-        # just our parents' tags, plus our type.
-        def tags
-            tmp = [] + @tags
-            unless ! defined? @type or @type.nil? or @type == ""
-                tmp << @type.to_s
-            end
-            if @parent
-                #info "Looking for tags in %s" % @parent.type
-                @parent.tags.each { |tag|
-                    if tag.nil? or tag == ""
-                        Puppet.debug "parent returned tag %s" % tag.inspect
-                        next
-                    end
-                    unless tmp.include?(tag)
-                        tmp << tag
-                    end
-                }
-            end
-            return tmp
+    # Used mainly for logging
+    def to_s
+        if self.name
+            return "%s[%s]" % [@type, @name]
+        else
+            return self.type.to_s
         end
+    end
 
-        # Used mainly for logging
-        def to_s
-            if @name
-                return "%s[%s]" % [@type, @name]
+    # Convert all of our objects as necessary.
+    def translate
+        ret = @children.collect do |child|
+            case child
+            when Puppet::Parser::Resource
+                child.to_trans
+            when self.class
+                child.translate
             else
-                return @type.to_s
+                devfail "Got %s for translation" % child.class
             end
-        end
-
-        # Convert our scope to a TransBucket.  Everything in our @localobjecttable
-        # gets converted to either an evaluated definition, or a TransObject
-        def to_trans
-            results = []
-
-            # Set this on entry, just in case someone tries to get all weird
-            @translated = true
-
-            @children.dup.each do |child|
-                if @@done.include?(child)
-                    raise Puppet::DevError, "Already translated %s" %
-                        child.object_id
-                else
-                    @@done << child
-                end
-                #warning "Working on %s of type %s with id %s" %
-                #    [child.type, child.class, child.object_id]
-
-                # If it's a scope, then it can only be a subclass's scope, so
-                # convert it to a transbucket and store it in our results list
-                result = nil
-                case child
-                when Scope
-                    result = child.to_trans
-                when Puppet::TransObject
-                    # These objects can map to defined types or builtin types.
-                    # Builtin types should be passed out as they are, but defined
-                    # types need to be evaluated.  We have to wait until this
-                    # point so that subclass overrides can happen.
-
-                    # Wait until the last minute to set tags, although this
-                    # probably should not matter
-                    child.tags = self.tags
-
-                    # Add any defaults.
-                    self.adddefaults(child)
-
-                    # Then make sure this child's tags are stored in the
-                    # central table.  This should maybe be in the evaluate
-                    # methods, but, eh.
-                    @topscope.addtags(child)
-
-                    # Now that all that is done, check to see what kind of object
-                    # it is.
-                    if objecttype = lookuptype(child.type)
-                        # It's a defined type, so evaluate it.  Retain whether
-                        # the object is collectable.  If the object is collectable,
-                        # then it will store all of its contents into the
-                        # @exportable table, rather than returning them.
-                        result = objecttype.safeevaluate(
-                            :name => child.name,
-                            :type => child.type,
-                            :arguments => child.to_hash,
-                            :scope => self,
-                            :collectable => child.collectable
-                        )
-                    else
-                        # If it's collectable, then store it.  It will be
-                        # stripped out in the interpreter using the collectstrip
-                        # method.  If we don't do this, then these objects
-                        # don't get stored in the DB.
-                        if child.collectable
-                            exportobject(child)
-                        end
-                        result = child
-                    end
-                # This is pretty hackish, but the collection has to actually
-                # be performed after all of the classes and definitions are
-                # evaluated, otherwise we won't catch objects that are exported
-                # in them.  I think this will still be pretty limited in some
-                # cases, especially those where you are both exporting and
-                # collecting, but it's the best I can do for now.
-                when Puppet::Parser::AST::Collection
-                    child.perform(self).each do |obj|
-                        results << obj
-                    end
-                else
-                    raise Puppet::DevError,
-                        "Puppet::Parse::Scope cannot handle objects of type %s" %
-                            child.class
-                end
-
-                # Skip nil objects or empty transbuckets
-                if result
-                    unless result.is_a? Puppet::TransBucket and result.empty?
-                        results << result
-                    end
-                end
-            end
-
-            # Get rid of any nil objects.
-            results.reject! { |child|
-                child.nil?
-            }
-
-            # If we have a name and type, then make a TransBucket, which
-            # becomes a component.
-            # Else, just stack all of the objects into the current bucket.
-            if @type
-                bucket = Puppet::TransBucket.new
+        end.reject { |o| o.nil? }
+        bucket = Puppet::TransBucket.new ret
 
-                if defined? @name and @name
-                    bucket.name = @name
-                end
-                # it'd be nice not to have to do this...
-                results.each { |result|
-                    #Puppet.warning "Result type is %s" % result.class
-                    bucket.push(result)
-                }
-                bucket.type = @type
-
-                if defined? @keyword
-                    bucket.keyword = @keyword
-                end
-                #Puppet.debug(
-                #    "TransBucket with name %s and type %s in scope %s" %
-                #    [@name,@type,self.object_id]
-                #)
-
-                # now find metaparams
-                @symtable.each { |var,value|
-                    if Puppet::Type.metaparam?(var.intern)
-                        #Puppet.debug("Adding metaparam %s" % var)
-                        bucket.param(var,value)
-                    else
-                        #Puppet.debug("%s is not a metaparam" % var)
-                    end
-                }
-                #Puppet.debug "Returning bucket %s from scope %s" %
-                #    [bucket.name,self.object_id]
-                return bucket
-            else
-                Puppet.debug "typeless scope; just returning a list"
-                return results
-            end
+        case self.type
+        when "": bucket.type = "main"
+        when nil: devfail "A Scope with no type"
+        else
+            bucket.type = @type
         end
+        if self.name
+            bucket.name = self.name
+        end
+        return bucket
+    end
 
-        # Undefine a variable; only used for testing.
-        def unsetvar(var)
-            if @symtable.include?(var)
-                @symtable.delete(var)
-            end
+    # Undefine a variable; only used for testing.
+    def unsetvar(var)
+        if @symtable.include?(var)
+            @symtable.delete(var)
         end
+    end
 
-        protected
-
-        # This method abstracts recursive searching.  It accepts the type
-        # of search being done and then either a literal key to search for or
-        # a Proc instance to do the searching.
-        def lookup(type,sub, usecontext = false)
-            table = @map[type]
-            if table.nil?
-                error = Puppet::ParseError.new(
-                    "Could not retrieve %s table at level %s" %
-                        [type,self.level]
-                )
-                raise error
-            end
+    # Return an array of all of the unevaluated objects
+    def unevaluated
+        ary = @definedtable.find_all do |name, object|
+            ! object.builtin? and ! object.evaluated?
+        end.collect { |name, object| object }
 
-            if sub.is_a?(Proc) and obj = sub.call(table)
-                return obj
-            elsif table.include?(sub)
-                return table[sub]
-            elsif ! @parent.nil?
-                # Context is used for retricting overrides.
-                if usecontext and self.context != @parent.context
-                    return :undefined
-                else
-                    return @parent.lookup(type,sub, usecontext)
-                end
-            else
-                return :undefined
-            end
+        if ary.empty?
+            return nil
+        else
+            return ary
         end
     end
 end
 
-# $Id: scope.rb 1401 2006-07-18 14:00:33Z luke $
+# $Id: scope.rb 2418 2007-04-26 19:09:24Z luke $