puppet 0.23.2 → 0.24.0

data/lib/puppet/parser/resource/param.rb

@@ -51,7 +51,7 @@ class Puppet::Parser::Resource::Param
         #dev_warn if db_values.nil? || db_values.empty? 
 
         values_to_remove(db_values).each { |remove_me|
-            Puppet::Rails::ParamValue.delete(remove_me)
+            Puppet::Rails::ParamValue.delete(remove_me.id)
         }
         line_number = line_to_i()
         values_to_add(db_values).each { |add_me| 
@@ -88,4 +88,3 @@ class Puppet::Parser::Resource::Param
     end
 end
 
-# $Id: param.rb 2742 2007-08-03 23:49:53Z luke $

data/lib/puppet/parser/resource/reference.rb

@@ -1,9 +1,11 @@
+require 'puppet/resource_reference'
+
 # A reference to a resource.  Mostly just the type and title.
-class Puppet::Parser::Resource::Reference
+class Puppet::Parser::Resource::Reference < Puppet::ResourceReference
     include Puppet::Util::MethodHelper
     include Puppet::Util::Errors
 
-    attr_accessor :type, :title, :builtin, :file, :line, :scope
+    attr_accessor :builtin, :file, :line, :scope
 
     # Are we a builtin type?
     def builtin?
@@ -15,24 +17,39 @@ class Puppet::Parser::Resource::Reference
             end
         end
 
-        self.builtin
+        @builtin
     end
 
     def builtintype
-        if t = Puppet::Type.type(self.type) and t.name != :component
+        if t = Puppet::Type.type(self.type.downcase) and t.name != :component
             t
         else
             nil
         end
     end
 
-    # Return the defined type for our obj.
+    # Return the defined type for our obj.  This can return classes,
+    # definitions or nodes.
     def definedtype
         unless defined? @definedtype
-            if tmp = @scope.finddefine(self.type)
+            case self.type
+            when "Class": # look for host classes
+                if self.title == :main
+                    tmp = @scope.findclass("")
+                else
+                    tmp = @scope.findclass(self.title)
+                end
+            when "Node": # look for node definitions
+                tmp = @scope.parser.nodes[self.title]
+            else # normal definitions
+                # We have to swap these variables around so the errors are right.
+                tmp = @scope.finddefine(self.type)
+            end
+
+            if tmp
                 @definedtype = tmp
             else
-                fail Puppet::ParseError, "Could not find resource type '%s'" % self.type
+                fail Puppet::ParseError, "Could not find resource '%s'" % self
             end
         end
 
@@ -48,13 +65,6 @@ class Puppet::Parser::Resource::Reference
         return [type.to_s,title.to_s]
     end
 
-    def to_s
-        unless defined? @namestring
-            @namestring = "%s[%s]" % [type.capitalize, title]
-        end
-        @namestring
-    end
-
     def typeclass
         unless defined? @typeclass
             if tmp = builtintype || definedtype
@@ -67,5 +77,3 @@ class Puppet::Parser::Resource::Reference
         @typeclass
     end
 end
-
-# $Id: reference.rb 2664 2007-07-09 20:54:35Z luke $

data/lib/puppet/parser/scope.rb

@@ -15,36 +15,19 @@ class Puppet::Parser::Scope
 
     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, :virtual
+    attr_accessor :parent, :level, :parser, :source, :resource
+    attr_accessor :base, :keyword, :nodescope
+    attr_accessor :top, :translated, :compile
 
-    # Whether we behave declaratively.  Note that it's a class variable,
-    # so all scopes behave the same.
-    @@declarative = true
-
-    # Retrieve and set the declarative setting.
-    def self.declarative
-        return @@declarative
-    end
-
-    def self.declarative=(val)
-        @@declarative = val
+    # Proxy accessors
+    def host
+        @compile.node.name
     end
 
-    # 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
+    def interpreter
+        @compile.interpreter
     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.
-    sharedtable :classtable, :definedtable, :exportable, :overridetable, :collecttable
-
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
     def self.true?(value)
@@ -65,146 +48,14 @@ class Puppet::Parser::Scope
         end
     end
 
-    # Is the type a builtin type?
-    def builtintype?(type)
-        if typeklass = Puppet::Type.type(type)
-            return typeklass
-        else
-            return false
-        end
-    end
-
-    # Create a new child scope.
-    def child=(scope)
-        @children.push(scope)
-
-        # 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(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
-
-                if exobj.file and exobj.line
-                    msg << " in file %s at line %s" %
-                        [exobj.file, exobj.line]
-                end
-
-                if obj.line or obj.file
-                    msg << "; cannot redefine"
-                end
-
-                raise Puppet::ParseError.new(msg)
-            end
-        end
-
-        return true
-    end
-
-    # 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)
-        scope = if klass.respond_to?(:classname)
-            @classtable[klass.classname]
-        else
-            @classtable[klass]
-        end
-
-        return nil unless scope
-
-        if scope.nodescope? and ! klass.is_a?(AST::Node)
-            raise Puppet::ParseError, "Node %s has already been evaluated; cannot evaluate class with same name" % [klass.classname]
-        end
-
-        scope
-    end
-
-    # Return the list of collections.
-    def collections
-        @collecttable
-    end
-
-    def declarative=(val)
-        self.class.declarative = val
-    end
-
-    def declarative
-        self.class.declarative
-    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
-
-    # Remove a specific child.
-    def delete(child)
-        @children.delete(child)
-    end
-
-    # 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
-
-        if @children.include?(resource)
-            @children.delete(resource)
-        end
-    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.keys.reject { |k| k == "" }
-    end
-
-    # Yield each child scope in turn
-    def each
-        @children.each { |child|
-            yield child
-        }
-    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
-
-    def exported?
-        self.exported
-    end
-
     def findclass(name)
         @namespaces.each do |namespace|
-            if r = interp.findclass(namespace, name)
+            if r = parser.findclass(namespace, name)
                 return r
             end
         end
@@ -213,7 +64,7 @@ class Puppet::Parser::Scope
 
     def finddefine(name)
         @namespaces.each do |namespace|
-            if r = interp.finddefine(namespace, name)
+            if r = parser.finddefine(namespace, name)
                 return r
             end
         end
@@ -221,28 +72,11 @@ class Puppet::Parser::Scope
     end
 
     def findresource(string, name = nil)
-        if name
-            string = "%s[%s]" % [string.capitalize, name]
-        end
-
-        @definedtable[string]
-    end
-
-    # Recursively complete the whole tree, in preparation for
-    # translation or storage.
-    def finish
-        self.each do |obj|
-            obj.finish
-        end
+        compile.findresource(string, name)
     end
 
-    # Initialize our new scope.  Defaults to having no parent and to
-    # being declarative.
+    # Initialize our new scope.  Defaults to having no parent.
     def initialize(hash = {})
-        @parent = nil
-        @type = nil
-        @name = nil
-        @finished = false
         if hash.include?(:namespace)
             if n = hash[:namespace]
                 @namespaces = [n]
@@ -262,94 +96,15 @@ class Puppet::Parser::Scope
 
         @tags = []
 
-        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
-
-            @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
-
-        # Our child scopes and objects
-        @children = []
-
         # The symbol table for this scope.  This is where we store variables.
         @symtable = {}
 
         # 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|
+        @defaults = Hash.new { |dhash,type|
             dhash[type] = {}
         }
-
-        unless @interp
-            raise Puppet::DevError, "Scopes require an interpreter"
-        end
-    end
-
-    # 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
-
-    # 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 table for storing class singletons.  This will only actually
-        # be used by top scopes and node scopes.
-        @classtable = {}
-
-        self.class.declarative = declarative
-
-        # The table for all defined objects.
-        @definedtable = {}
-
-        # The list of objects that will available for export.
-        @exportable = {}
-
-        # 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
-
-        # 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
-
-        @namespaces = [""]
-
-        # 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 = []
-
-        @topscope = self
-        @type = "puppet"
-        @name = "top"
     end
 
     # Collect all of the defaults set at any higher scopes.
@@ -360,16 +115,16 @@ class Puppet::Parser::Scope
         values = {}
 
         # first collect the values from the parents
-        unless @parent.nil?
-            @parent.lookupdefaults(type).each { |var,value|
+        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|
+        if @defaults.include?(type)
+            @defaults[type].each { |var,value|
                 values[var] = value
             }
         end
@@ -379,17 +134,6 @@ class Puppet::Parser::Scope
         return values
     end
 
-    # Look up all of the exported objects of a given type.
-    def lookupexported(type)
-        @definedtable.find_all do |name, r|
-            r.type == type and r.exported?
-        end
-    end
-
-    def lookupoverrides(obj)
-        @overridetable[obj.ref]
-    end
-
     # Look up a defined type.
     def lookuptype(name)
         finddefine(name) || findclass(name)
@@ -403,7 +147,7 @@ class Puppet::Parser::Scope
         unless klass
             raise Puppet::ParseError, "Could not find class %s" % klassname
         end
-        unless kscope = class_scope(klass)
+        unless kscope = compile.class_scope(klass)
             raise Puppet::ParseError, "Class %s has not been evaluated so its variables cannot be referenced" % klass.classname
         end
         return kscope.lookupvar(shortname, usestring)
@@ -426,7 +170,7 @@ class Puppet::Parser::Scope
                 return @symtable[name]
             end
         elsif self.parent 
-            return @parent.lookupvar(name, usestring)
+            return parent.lookupvar(name, usestring)
         elsif usestring
             return ""
         else
@@ -438,16 +182,9 @@ class Puppet::Parser::Scope
         @namespaces.dup
     end
 
-    # Add a collection to the global list.
-    def newcollection(coll)
-        @collecttable << coll
-    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)
+    # Create a new scope and set these options.
+    def newscope(options = {})
+        compile.newscope(self, options)
     end
 
     # Is this class for a node?  This is used to make sure that
@@ -455,75 +192,25 @@ class Puppet::Parser::Scope
     # is required because of how often the names are used throughout
     # the system, including on the client.
     def nodescope?
-        defined?(@nodescope) and @nodescope
+        self.nodescope
     end
 
-    # Return the list of remaining overrides.
-    def overrides
-        #@overridetable.collect { |name, overs| overs }.flatten
-        @overridetable.values.flatten
-    end
-
-    def resources
-        @definedtable.values
-    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(obj)
-        if obj.is_a?(AST::HostClass)
-            unless obj.classname
-                raise Puppet::DevError, "Got a %s with no fully qualified name" %
-                    obj.class
-            end
-            @classtable[obj.classname] = self
-        else
-            raise Puppet::DevError, "Invalid class %s" % obj.inspect
-        end
-        if obj.is_a?(AST::Node)
-            @nodescope = true
-        end
-        nil
-    end
-
-    # Set all of our facts in the top-level scope.
-    def setfacts(facts)
-        facts.each { |var, value|
-            self.setvar(var, value)
-        }
-    end
-
-    # Add a new object to our object table and the global list, and do any necessary
-    # checks.
-    def setresource(obj)
-        self.chkobjectclosure(obj)
-
-        @children << obj
-
-        # Mark the resource as virtual or exported, as necessary.
-        if self.exported?
-            obj.exported = true
-        elsif self.virtual?
-            obj.virtual = true
+    # We probably shouldn't cache this value...  But it's a lot faster
+    # than doing lots of queries.
+    def parent
+        unless defined?(@parent)
+            @parent = compile.parent(self)
         end
-
-        # The global table
-        @definedtable[obj.ref] = obj
-
-        return obj
+        @parent
     end
 
-    # 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)
+    # Return the list of scopes up to the top scope, ordered with our own first.
+    # This is used for looking up variables and defaults.
+    def scope_path
+        if parent
+            [self, parent.scope_path].flatten.compact
         else
-            @overridetable[resource.ref] << resource
+            [self]
         end
     end
 
@@ -531,7 +218,7 @@ class Puppet::Parser::Scope
     # 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]
+        table = @defaults[type]
 
         # if we got a single param, it'll be in its own array
         params = [params] unless params.is_a?(Array)
@@ -539,17 +226,8 @@ class Puppet::Parser::Scope
         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
-                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
+            if table.include?(param.name)
+                raise Puppet::ParseError.new("Default already defined for %s { %s }; cannot redefine" % [type, param.name], param.line, param.file)
             end
             table[param.name] = param
         }
@@ -557,23 +235,19 @@ class Puppet::Parser::Scope
 
     # Set a variable in the current scope.  This will override settings
     # in scopes above, but will not allow variables in the current scope
-    # to be reassigned if we're declarative (which is the default).
+    # to be reassigned.
     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
-                Puppet.warning "Reassigning %s to %s" % [name,value]
+            error = Puppet::ParseError.new("Cannot reassign variable %s" % name)
+            if file
+                error.file = file
             end
+            if line
+                error.line = line
+            end
+            raise error
         end
         @symtable[name] = value
     end
@@ -637,82 +311,16 @@ class Puppet::Parser::Scope
         return out
     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 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 "parent returned tag %s" % tag.inspect
-                    next
-                end
-                unless tmp.include?(tag)
-                    tmp << tag
-                end
-            }
-        end
-        return tmp.sort.uniq
+        resource.tags
     end
 
     # Used mainly for logging
     def to_s
-        if self.name
-            return "%s[%s]" % [@type, @name]
-        else
-            return self.type.to_s
-        end
-    end
-
-    # 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
-                devfail "Got %s for translation" % child.class
-            end
-        end.reject { |o| o.nil? }
-        bucket = Puppet::TransBucket.new ret
-
-        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
+        "Scope(%s)" % @resource.to_s
     end
 
     # Undefine a variable; only used for testing.
@@ -721,23 +329,4 @@ class Puppet::Parser::Scope
             @symtable.delete(var)
         end
     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 ary.empty?
-            return nil
-        else
-            return ary
-        end
-    end
-
-    def virtual?
-        self.virtual || self.exported?
-    end
 end
-
-# $Id: scope.rb 2646 2007-07-04 21:06:26Z luke $