puppet 0.18.4 → 0.22.4

data/lib/puppet/parser/ast/collection.rb

@@ -1,91 +1,30 @@
-require 'puppet/rails'
+require 'puppet'
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/collector'
 
+# An object that collects stored objects from the central cache and returns
+# them to the current host, yo.
 class Puppet::Parser::AST
-    # An object that collects stored objects from the central cache and returns
-    # them to the current host, yo.
-    class Collection < AST::Branch
-        attr_accessor :type
+class Collection < AST::Branch
+    attr_accessor :type, :query, :form
 
-        # We cannot evaluate directly here; instead we need to store a 
-        # CollectType object, which will do the collection.  This is
-        # the only way to find certain exported types in the current
-        # configuration.
-        def evaluate(hash)
-            scope = hash[:scope]
+    # We return an object that does a late-binding evaluation.
+    def evaluate(hash)
+        scope = hash[:scope]
 
-            @convertedtype = @type.safeevaluate(:scope => scope)
-
-            scope.newcollection(self)
+        if self.query
+            str, code = self.query.safeevaluate :scope => scope
+        else
+            str = code = nil
         end
 
-        # Now perform the actual collection, yo.
-        def perform(scope)
-            # First get everything from the export table.
-            
-            # FIXME This will only find objects that are before us in the tree,
-            # which is a problem.
-            objects = scope.exported(@convertedtype)
-
-            # We want to return all of these objects, and then whichever objects
-            # we find in the db.
-            array = objects.values
-
-            # Mark all of these objects as collected, so that they also get
-            # returned to the client.  We don't store them in our scope
-            # or anything, which is a little odd, but eh.
-            array.each do |obj|
-                obj.collected = true
-            end
-
-            count = array.length
-
-            # Now we also have to see if there are any exported objects
-            # in our own scope.
-            scope.lookupexported(@convertedtype).each do |obj|
-                objects[obj.name] = obj
-                obj.collected = true
-            end
-
-            bucket = Puppet::TransBucket.new
-
-            Puppet::Rails::RailsObject.find_all_by_collectable(true).each do |obj|
-                # FIXME This should check that the source of the object is the
-                # host we're running on, else it's a bad conflict.
-                if objects.include?(obj.name)
-                    scope.debug("%s[%s] is already exported" % [@convertedtype, obj.name])
-                    next
-                end
-                count += 1
-                trans = obj.to_trans
-                bucket.push(trans)
+        newcoll = Puppet::Parser::Collector.new(scope, @type, str, code, self.form)
 
-                args = {
-                    :name => trans.name,
-                    :type => trans.type,
-                }
+        scope.newcollection(newcoll)
 
-                [:file, :line].each do |param|
-                    if val = trans.send(param)
-                        args[param] = val
-                    end
-                end
-
-                args[:arguments] = {}
-                trans.each do |p,v|  args[:arguments][p] = v end
-
-                
-                # XXX Because the scopes don't expect objects to return values,
-                # we have to manually add our objects to the scope.  This is
-                # uber-lame.
-                scope.setobject(args)
-            end
-
-            scope.debug("Collected %s objects of type %s" %
-                [count, @convertedtype])
-
-            return bucket
-        end
+        newcoll
     end
 end
+end
 
-# $Id: collection.rb 1193 2006-05-15 18:02:16Z luke $
+# $Id: collection.rb 1805 2006-10-18 00:22:45Z luke $

data/lib/puppet/parser/ast/collexpr.rb

@@ -0,0 +1,81 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/collector'
+
+# An object that collects stored objects from the central cache and returns
+# them to the current host, yo.
+class Puppet::Parser::AST
+class CollExpr < AST::Branch
+    attr_accessor :test1, :test2, :oper, :form, :type, :parens
+
+    # We return an object that does a late-binding evaluation.
+    def evaluate(hash)
+        scope = hash[:scope]
+
+        # Make sure our contained expressions have all the info they need.
+        [@test1, @test2].each do |t|
+            if t.is_a?(self.class)
+                t.form ||= self.form
+                t.type ||= self.type
+            end
+        end
+
+        # The code is only used for virtual lookups
+        str1, code1 = @test1.safeevaluate :scope => scope
+        str2, code2 = @test2.safeevaluate :scope => scope
+
+        # First build up the virtual code.
+        # If we're a conjunction operator, then we're calling code.  I did
+        # some speed comparisons, and it's at least twice as fast doing these
+        # case statements as doing an eval here.
+        code = proc do |resource|
+            case @oper
+            when "and": code1.call(resource) and code2.call(resource)
+            when "or": code1.call(resource) or code2.call(resource)
+            when "==": resource[str1] == str2
+            when "!=": resource[str1] != str2
+            end
+        end
+
+        # Now build up the rails conditions code
+        if self.parens and self.form == :exported
+            Puppet.warning "Parentheses are ignored in Rails searches"
+        end
+
+        case @oper
+        when "and", "or": oper = @oper.upcase
+        when "==": oper = "="
+        else
+            oper = @oper
+        end
+
+        if oper == "=" or oper == "!="
+            # Add the rails association info where necessary
+            if str1 == "title"
+                str = "title #{oper} '#{str2}'"
+            else
+                unless self.form == :virtual or str1 == "title"
+                    parsefail "Collection from the database only supports " +
+                        "title matching currently"
+                end
+                str = "rails_parameters.name = '#{str1}' and " +
+                    "rails_parameters.value #{oper} '#{str2}'"
+            end
+        else
+            str = [str1, oper, str2].join(" ")
+        end
+
+        return str, code
+    end
+
+    def initialize(hash = {})
+        super
+
+        unless %w{== != and or}.include?(@oper)
+            raise ArgumentError, "Invalid operator %s" % @oper
+        end
+    end
+end
+end
+
+# $Id: collexpr.rb 1726 2006-10-04 18:24:24Z luke $

data/lib/puppet/parser/ast/component.rb

@@ -1,77 +1,74 @@
+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 Component < AST::Branch
+        include Puppet::Util
+        include Puppet::Util::Warnings
+        include Puppet::Util::MethodHelper
         class << self
             attr_accessor :name
         end
 
         # The class name
-        @name = :component
+        @name = :definition
+
+        attr_accessor :type, :arguments, :code, :scope, :keyword
+        attr_accessor :exported, :namespace, :fqname, :interp
 
-        attr_accessor :type, :args, :code, :scope, :keyword, :collectable
+        # These are retrieved when looking up the superclass
+        attr_accessor :name
+
+        def child_of?(klass)
+            false
+        end
 
-        #def evaluate(scope,hash,objtype,objname)
         def evaluate(hash)
             origscope = hash[:scope]
             objtype = hash[:type]
-            objname = hash[:name]
-            arguments = hash[:arguments] || {}
+            title = hash[:title]
+            args = symbolize_options(hash[:arguments] || {})
 
-            @collectable = hash[:collectable]
+            name = args[:name] || title
 
-            pscope = origscope
-            #pscope = if ! Puppet[:lexical] or hash[:asparent] == false
-            #    origscope
-            #else
-            #    @scope
-            #end
-            scope = pscope.newscope(
-                :type => @type,
-                :name => objname,
-                :keyword => self.keyword
-            )
-            newcontext = hash[:newcontext]
+            exported = hash[:exported]
 
-            if @collectable or origscope.collectable
-                scope.collectable = true
-            end
+            pscope = origscope
+            scope = subscope(pscope, title)
 
-            unless self.is_a? AST::HostClass and ! newcontext
-                #scope.warning "Setting context to %s" % self.object_id
-                scope.context = self.object_id
+            if exported or origscope.exported?
+                scope.exported = true
             end
-            @scope = scope
 
             # Additionally, add a tag for whatever kind of class
             # we are
-            scope.tag(@type)
+            if @type != "" and ! @type.nil?
+                scope.tag(@type)
+            end
 
-            unless objname.nil?
-                scope.tag(objname)
+            [name, title].each do |str|
+                unless str.nil? or str =~ /[^\w]/ or str == ""
+                    scope.tag(str)
+                end
             end
 
             # define all of the arguments in our local scope
-            if self.args
+            if self.arguments
                 # Verify that all required arguments are either present or
                 # have been provided with defaults.
-                # FIXME This should probably also require each parent
-                # class's arguments...
-                self.args.each { |arg, default|
-                    unless arguments.include?(arg)
+                self.arguments.each { |arg, default|
+                    arg = symbolize(arg)
+                    unless args.include?(arg)
                         if defined? default and ! default.nil?
-                            arguments[arg] = default
+                            default = default.safeevaluate :scope => scope
+                            args[arg] = default
                             #Puppet.debug "Got default %s for %s in %s" %
-                            #    [default.inspect, arg.inspect, objname.inspect]
+                            #    [default.inspect, arg.inspect, @name.inspect]
                         else
-                            error = Puppet::ParseError.new(
-                                "Must pass %s to %s of type %s" %
-                                    [arg.inspect,objname,@type]
-                            )
-                            error.line = self.line
-                            error.file = self.file
-                            raise error
+                            parsefail "Must pass %s to %s of type %s" %
+                                    [arg,title,@type]
                         end
                     end
                 }
@@ -79,68 +76,142 @@ class Puppet::Parser::AST
 
             # Set each of the provided arguments as variables in the
             # component's scope.
-            arguments["name"] = objname
-            arguments.each { |arg,value|
-                begin
-                    scope.setvar(arg,arguments[arg])
-                rescue Puppet::ParseError => except
-                    except.line = self.line
-                    except.file = self.file
-                    raise except
-                rescue Puppet::ParseError => except
-                    except.line = self.line
-                    except.file = self.file
-                    raise except
-                rescue => except
-                    error = Puppet::ParseError.new(except.message)
-                    error.line = self.line
-                    error.file = self.file
-                    error.backtrace = except.backtrace
-                    raise error
+            args.each { |arg,value|
+                unless validattr?(arg)
+                    parsefail "%s does not accept attribute %s" % [@type, arg]
+                end
+
+                exceptwrap do
+                    scope.setvar(arg.to_s,args[arg])
                 end
             }
 
-            # Now just evaluate the code with our new bindings.
-            self.code.safeevaluate(:scope => scope)
+            unless args.include? :title
+                scope.setvar("title",title)
+            end
 
-            # If we're being evaluated as a parent class, we want to return the
-            # scope, so it can be overridden and such, but if not, we want to 
-            # return a TransBucket of our objects.
-            if hash.include?(:asparent)
-                return scope
+            unless args.include? :name
+                scope.setvar("name",name)
+            end
+
+            if self.code
+                return self.code.safeevaluate(:scope => scope)
             else
-                return scope.to_trans
+                return nil
             end
         end
 
-        # Check whether a given argument is valid.  Searches up through
-        # any parent classes that might exist.
-        def validarg?(param)
-            found = false
-            unless @args.is_a? Array
-                @args = [@args]
+        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 = {}
             end
 
-            found = @args.detect { |arg|
-                if arg.is_a? Array
-                    arg[0] == param
+            # 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 elements" % arg
                 else
-                    arg == param
+                    raise Puppet::ParseError,
+                        "%s is a metaparameter; please choose another name" %
+                        name
                 end
+            end
+        end
+
+        def parentclass
+            parentobj do |name|
+                @interp.findclass(namespace, name)
+            end
+        end
+
+        # Set our parent class, with a little check to avoid some potential
+        # weirdness.
+        def parentclass=(name)
+            if name == self.type
+                parsefail "Parent classes must have dissimilar names"
+            end
+
+            @parentclass = name
+        end
+
+        # Hunt down our class object.
+        def parentobj
+            if @parentclass
+                # Cache our result, since it should never change.
+                unless @parentclass.is_a?(AST::HostClass)
+                    unless tmp = yield(@parentclass)
+                        parsefail "Could not find %s %s" % [self.class.name, @parentclass]
+                    end
+
+                    if tmp == self
+                        parsefail "Parent classes must have dissimilar names"
+                    end
+
+                    @parentclass = tmp
+                end
+                @parentclass
+            else
+                nil
+            end
+        end
+
+        # Create a new subscope in which to evaluate our code.
+        def subscope(scope, name = nil)
+            args = {
+                :type => @type,
+                :keyword => self.keyword,
+                :namespace => self.namespace
             }
 
-            if found
+            args[:name] = name if name
+            args[:type] = self.type if self.type
+            scope = scope.newscope(args)
+            scope.source = self
+
+            return scope
+        end
+
+        def to_s
+            fqname
+        end
+
+        # 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 defined? @parentclass and @parentclass
-                # Else, check any existing parent
-                parent = @scope.lookuptype(@parentclass)
-                if parent and parent != []
-                    return parent.validarg?(param)
-                else
-                    raise Puppet::Error, "Could not find parent class %s" %
-                        @parentclass
-                end
+            elsif param == "name"
+                return true
+#            elsif defined? @parentclass and @parentclass
+#                # Else, check any existing parent
+#                if parent = @scope.lookuptype(@parentclass) and parent != []
+#                    return parent.validarg?(param)
+#                elsif builtin = Puppet::Type.type(@parentclass)
+#                    return builtin.validattr?(param)
+#                else
+#                    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
@@ -149,4 +220,4 @@ class Puppet::Parser::AST
     end
 end
 
-# $Id: component.rb 1192 2006-05-14 02:42:21Z luke $
+# $Id: component.rb 2393 2007-04-19 18:34:03Z luke $