More AST refactoring -- each of the code wrapping classes

just returns a resource from its evaluate() method, and
all of the work is done in the evaluate_code method.  This
makes the code cleaner, because it means 1) evaluate() has
the same prototype as all of the other AST classes,
2) evaluate() is no longer called indirectly through
the Parser Resource class, and 3) the classes themselves
are responsible for creating the resources, rather than
it being done in the Compile class.

1 files changed, 148 insertions, 156 deletions

diff --git a/lib/puppet/parser/ast/definition.rb b/lib/puppet/parser/ast/definition.rb
index 2e39e7332..bf57942d7 100644
--- a/lib/puppet/parser/ast/definition.rb
+++ b/lib/puppet/parser/ast/definition.rb
@@ -1,152 +1,145 @@
 require 'puppet/parser/ast/branch'
 
-class Puppet::Parser::AST
-    # Evaluate the stored parse tree for a given component.  This will
-    # receive the arguments passed to the component and also the type and
-    # name of the component.
-    class Definition < AST::Branch
-        include Puppet::Util
-        include Puppet::Util::Warnings
-        include Puppet::Util::MethodHelper
-        class << self
-            attr_accessor :name
-        end
+require 'puppet/util/warnings'
 
-        # The class name
-        @name = :definition
+# The AST class for defined types, which is also the base class
+# nodes and classes.
+class Puppet::Parser::AST::Definition < Puppet::Parser::AST::Branch
+    include Puppet::Util::Warnings
+    class << self
+        attr_accessor :name
+    end
 
-        attr_accessor :classname, :arguments, :code, :scope, :keyword
-        attr_accessor :exported, :namespace, :parser, :virtual
+    # The class name
+    @name = :definition
 
-        # These are retrieved when looking up the superclass
-        attr_accessor :name
+    attr_accessor :classname, :arguments, :code, :scope, :keyword
+    attr_accessor :exported, :namespace, :parser, :virtual, :name
 
-        attr_reader :parentclass
+    attr_reader :parentclass
 
-        def child_of?(klass)
-            false
-        end
+    def child_of?(klass)
+        false
+    end
 
-        def evaluate(origscope, resource)
-            # Create a new scope.
-            scope = subscope(origscope, resource)
+    # Create a resource that knows how to evaluate our actual code.
+    def evaluate(scope)
+        resource = Puppet::Parser::Resource.new(:type => "class", :title => klass.classname, :scope => scope, :source => scope.source)
 
-            # Additionally, add a tag for whatever kind of class
-            # we are
-            if @classname != "" and ! @classname.nil?
-                @classname.split(/::/).each { |tag| scope.resource.tag(tag) }
-            end
+        scope.compile.store_resource(scope, resource)
 
-            [resource.name, resource.title].each do |str|
-                unless str.nil? or str =~ /[^\w]/ or str == ""
-                    scope.resource.tag(str)
-                end
-            end
+        return resource
+    end
 
-            set_resource_parameters(scope, resource)
+    # Now evaluate the code associated with this class or definition.
+    def evaluate_code(resource)
+        # Create a new scope.
+        scope = subscope(resource.scope, resource)
 
-            if self.code
-                return self.code.safeevaluate(scope)
-            else
-                return nil
-            end
+        set_resource_parameters(scope, resource)
+
+        if self.code
+            return self.code.safeevaluate(scope)
+        else
+            return nil
         end
+    end
 
-        def initialize(hash = {})
-            @arguments = nil
-            @parentclass = nil
-            super
+    def initialize(hash = {})
+        @arguments = nil
+        @parentclass = nil
+        super
 
-            # Convert the arguments to a hash for ease of later use.
-            if @arguments
-                unless @arguments.is_a? Array
-                    @arguments = [@arguments]
-                end
-                oldargs = @arguments
-                @arguments = {}
-                oldargs.each do |arg, val|
-                    @arguments[arg] = val
-                end
-            else
-                @arguments = {}
+        # Convert the arguments to a hash for ease of later use.
+        if @arguments
+            unless @arguments.is_a? Array
+                @arguments = [@arguments]
             end
-
-            # Deal with metaparams in the argument list.
-            @arguments.each do |arg, defvalue|
-                next unless Puppet::Type.metaparamclass(arg)
-                if defvalue
-                    warnonce "%s is a metaparam; this value will inherit to all contained resources" % arg
-                else
-                    raise Puppet::ParseError, "%s is a metaparameter; please choose another parameter name in the %s definition" % [arg, self.classname]
-                end
+            oldargs = @arguments
+            @arguments = {}
+            oldargs.each do |arg, val|
+                @arguments[arg] = val
             end
+        else
+            @arguments = {}
         end
 
-        def find_parentclass
-            @parser.findclass(namespace, parentclass)
+        # Deal with metaparams in the argument list.
+        @arguments.each do |arg, defvalue|
+            next unless Puppet::Type.metaparamclass(arg)
+            if defvalue
+                warnonce "%s is a metaparam; this value will inherit to all contained resources" % arg
+            else
+                raise Puppet::ParseError, "%s is a metaparameter; please choose another parameter name in the %s definition" % [arg, self.classname]
+            end
         end
+    end
 
-        # Set our parent class, with a little check to avoid some potential
-        # weirdness.
-        def parentclass=(name)
-            if name == self.classname
-                parsefail "Parent classes must have dissimilar names"
-            end
+    def find_parentclass
+        @parser.findclass(namespace, parentclass)
+    end
 
-            @parentclass = name
+    # Set our parent class, with a little check to avoid some potential
+    # weirdness.
+    def parentclass=(name)
+        if name == self.classname
+            parsefail "Parent classes must have dissimilar names"
         end
 
-        # Hunt down our class object.
-        def parentobj
-            if @parentclass
-                # Cache our result, since it should never change.
-                unless defined?(@parentobj)
-                    unless tmp = find_parentclass
-                        parsefail "Could not find %s %s" % [self.class.name, @parentclass]
-                    end
+        @parentclass = name
+    end
 
-                    if tmp == self
-                        parsefail "Parent classes must have dissimilar names"
-                    end
+    # Hunt down our class object.
+    def parentobj
+        if @parentclass
+            # Cache our result, since it should never change.
+            unless defined?(@parentobj)
+                unless tmp = find_parentclass
+                    parsefail "Could not find %s %s" % [self.class.name, @parentclass]
+                end
 
-                    @parentobj = tmp
+                if tmp == self
+                    parsefail "Parent classes must have dissimilar names"
                 end
-                @parentobj
-            else
-                nil
+
+                @parentobj = tmp
             end
+            @parentobj
+        else
+            nil
         end
+    end
 
-        # Create a new subscope in which to evaluate our code.
-        def subscope(scope, resource)
-            args = {
-                :resource => resource,
-                :keyword => self.keyword,
-                :namespace => self.namespace,
-                :source => self
-            }
+    # Create a new subscope in which to evaluate our code.
+    def subscope(scope, resource)
+        args = {
+            :resource => resource,
+            :keyword => self.keyword,
+            :namespace => self.namespace,
+            :source => self
+        }
 
-            oldscope = scope
-            scope = scope.newscope(args)
-            scope.source = self
+        oldscope = scope
+        scope = scope.newscope(args)
+        scope.source = self
 
-            return scope
-        end
+        return scope
+    end
 
-        def to_s
-            classname
-        end
+    def to_s
+        classname
+    end
 
-        # Check whether a given argument is valid.  Searches up through
-        # any parent classes that might exist.
-        def validattr?(param)
-            param = param.to_s
+    # Check whether a given argument is valid.  Searches up through
+    # any parent classes that might exist.
+    def validattr?(param)
+        param = param.to_s
 
-            if @arguments.include?(param)
-                # It's a valid arg for us
-                return true
-            elsif param == "name"
-                return true
+        if @arguments.include?(param)
+            # It's a valid arg for us
+            return true
+        elsif param == "name"
+            return true
 #            elsif defined? @parentclass and @parentclass
 #                # Else, check any existing parent
 #                if parent = @scope.lookuptype(@parentclass) and parent != []
@@ -157,53 +150,52 @@ class Puppet::Parser::AST
 #                    raise Puppet::Error, "Could not find parent class %s" %
 #                        @parentclass
 #                end
-            elsif Puppet::Type.metaparam?(param)
-                return true
-            else
-                # Or just return false
-                return false
-            end
+        elsif Puppet::Type.metaparam?(param)
+            return true
+        else
+            # Or just return false
+            return false
         end
+    end
 
-        private
-
-        # Set any arguments passed by the resource as variables in the scope.
-        def set_resource_parameters(scope, resource)
-            args = symbolize_options(resource.to_hash || {})
-
-            # Verify that all required arguments are either present or
-            # have been provided with defaults.
-            if self.arguments
-                self.arguments.each { |arg, default|
-                    arg = symbolize(arg)
-                    unless args.include?(arg)
-                        if defined? default and ! default.nil?
-                            default = default.safeevaluate scope
-                            args[arg] = default
-                            #Puppet.debug "Got default %s for %s in %s" %
-                            #    [default.inspect, arg.inspect, @name.inspect]
-                        else
-                            parsefail "Must pass %s to %s of type %s" %
-                                    [arg, resource.title, @classname]
-                        end
+    private
+
+    # Set any arguments passed by the resource as variables in the scope.
+    def set_resource_parameters(scope, resource)
+        args = symbolize_options(resource.to_hash || {})
+
+        # Verify that all required arguments are either present or
+        # have been provided with defaults.
+        if self.arguments
+            self.arguments.each { |arg, default|
+                arg = arg.to_sym
+                unless args.include?(arg)
+                    if defined? default and ! default.nil?
+                        default = default.safeevaluate scope
+                        args[arg] = default
+                        #Puppet.debug "Got default %s for %s in %s" %
+                        #    [default.inspect, arg.inspect, @name.inspect]
+                    else
+                        parsefail "Must pass %s to %s of type %s" %
+                                [arg, resource.title, @classname]
                     end
-                }
-            end
-
-            # Set each of the provided arguments as variables in the
-            # definition's scope.
-            args.each { |arg,value|
-                unless validattr?(arg)
-                    parsefail "%s does not accept attribute %s" % [@classname, arg]
-                end
-
-                exceptwrap do
-                    scope.setvar(arg.to_s, args[arg])
                 end
             }
-
-            scope.setvar("title", resource.title) unless args.include? :title
-            scope.setvar("name", resource.name) unless args.include? :name
         end
+
+        # Set each of the provided arguments as variables in the
+        # definition's scope.
+        args.each { |arg,value|
+            unless validattr?(arg)
+                parsefail "%s does not accept attribute %s" % [@classname, arg]
+            end
+
+            exceptwrap do
+                scope.setvar(arg.to_s, args[arg])
+            end
+        }
+
+        scope.setvar("title", resource.title) unless args.include? :title
+        scope.setvar("name", resource.name) unless args.include? :name
     end
 end