puppet 0.18.4 → 0.22.4

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

@@ -0,0 +1,222 @@
+require 'puppet/parser/ast/branch'
+
+# Any normal puppet object declaration.  Can result in a class or a 
+# component, in addition to builtin types.
+class Puppet::Parser::AST
+class ResourceDef < AST::Branch
+    attr_accessor :title, :type, :exported, :virtual
+    attr_reader :params
+
+    # probably not used at all
+    def []=(index,obj)
+        @params[index] = obj
+    end
+
+    # probably not used at all
+    def [](index)
+        return @params[index]
+    end
+
+    # Iterate across all of our children.
+    def each
+        [@type,@title,@params].flatten.each { |param|
+            #Puppet.debug("yielding param %s" % param)
+            yield param
+        }
+    end
+
+    # Does not actually return an object; instead sets an object
+    # in the current scope.
+    def evaluate(hash)
+        scope = hash[:scope]
+        @scope = scope
+        hash = {}
+
+        # Get our type and name.
+        objtype = @type
+
+        # Disable definition inheritance, for now.  8/27/06, luke
+        #if objtype == "super"
+        #    objtype = supertype()
+        #    @subtype = true
+        #else
+            @subtype = false
+        #end
+
+        # Evaluate all of the specified params.
+        paramobjects = @params.collect { |param|
+            param.safeevaluate(:scope => scope)
+        }
+
+        # Now collect info from our parent.
+        parentname = nil
+        if @subtype
+            parentname = supersetup(hash)
+        end
+
+        objtitles = nil
+        # Determine our name if we have one.
+        if self.title
+            objtitles = @title.safeevaluate(:scope => scope)
+            # it's easier to always use an array, even for only one name
+            unless objtitles.is_a?(Array)
+                objtitles = [objtitles]
+            end
+        else
+            if parentname
+                objtitles = [parentname]
+            else
+                # See if they specified the name as a parameter instead of
+                # as a normal name (i.e., before the colon).
+                unless object # we're a builtin
+                    if objclass = Puppet::Type.type(objtype)
+                        namevar = objclass.namevar
+
+                        tmp = hash["name"] || hash[namevar.to_s] 
+
+                        if tmp
+                            objtitles = [tmp]
+                        end
+                    else
+                        # This isn't grammatically legal.
+                        raise Puppet::ParseError, "Got a resource with no title"
+                    end
+                end
+            end
+        end
+
+        # This is where our implicit iteration takes place; if someone
+        # passed an array as the name, then we act just like the called us
+        # many times.
+        objtitles.collect { |objtitle|
+            exceptwrap :type => Puppet::ParseError do
+                exp = self.exported || scope.exported
+                # We want virtual to be true if exported is true.  We can't
+                # just set :virtual => self.virtual in the initialization,
+                # because sometimes the :virtual attribute is set *after*
+                # :exported, in which case it clobbers :exported if :exported
+                # is true.  Argh, this was a very tough one to track down.
+                virt = self.virtual || exported
+                obj = Puppet::Parser::Resource.new(
+                    :type => objtype,
+                    :title => objtitle,
+                    :params => paramobjects,
+                    :file => @file,
+                    :line => @line,
+                    :exported => exp,
+                    :virtual => virt,
+                    :source => scope.source,
+                    :scope => scope
+                )
+
+                # And then store the resource in the scope.
+                # XXX At some point, we need to switch all of this to return
+                # objects instead of storing them like this.
+                scope.setresource(obj)
+                obj
+            end
+        }.reject { |obj| obj.nil? }
+    end
+
+    # Create our ResourceDef.  Handles type checking for us.
+    def initialize(hash)
+        @checked = false
+        super
+
+        #self.typecheck(@type.value)
+    end
+
+    # Set the parameters for our object.
+    def params=(params)
+        if params.is_a?(AST::ASTArray)
+            @params = params
+        else
+            @params = AST::ASTArray.new(
+                :line => params.line,
+                :file => params.file,
+                :children => [params]
+            )
+        end
+    end
+
+    def supercomp
+        unless defined? @supercomp
+            if @scope and comp = @scope.inside
+                @supercomp = comp
+            else
+                error = Puppet::ParseError.new(
+                    "'super' is only valid within definitions"
+                )
+                error.line = self.line
+                error.file = self.file
+                raise error
+            end
+        end
+        @supercomp
+    end
+
+    # Take all of the arguments of our parent and add them into our own,
+    # without overriding anything.
+    def supersetup(hash)
+        comp = supercomp()
+
+        # Now check each of the arguments from the parent.
+        comp.arguments.each do |name, value|
+            unless hash.has_key? name
+                hash[name] = value
+            end
+        end
+
+        # Return the parent name, so it can be used if appropriate.
+        return comp.name
+    end
+
+    # Retrieve our supertype.
+    def supertype
+        unless defined? @supertype
+            if parent = supercomp.parentclass
+                @supertype = parent
+            else
+                error = Puppet::ParseError.new(
+                    "%s does not have a parent class" % comp.type
+                )
+                error.line = self.line
+                error.file = self.file
+                raise error
+            end
+        end
+        @supertype
+    end
+
+    # Print this object out.
+    def tree(indent = 0)
+        return [
+            @type.tree(indent + 1),
+            @title.tree(indent + 1),
+            ((@@indline * indent) + self.typewrap(self.pin)),
+            @params.collect { |param|
+                begin
+                    param.tree(indent + 1)
+                rescue NoMethodError => detail
+                    Puppet.err @params.inspect
+                    error = Puppet::DevError.new(
+                        "failed to tree a %s" % self.class
+                    )
+                    error.set_backtrace detail.backtrace
+                    raise error
+                end
+            }.join("\n")
+        ].join("\n")
+    end
+
+    def to_s
+        return "%s => { %s }" % [@title,
+            @params.collect { |param|
+                param.to_s
+            }.join("\n")
+        ]
+    end
+end
+end
+
+# $Id: resourcedef.rb 1922 2006-12-14 22:50:28Z luke $

data/lib/puppet/parser/ast/{typedefaults.rb → resourcedefaults.rb}

@@ -1,32 +1,24 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
-    # A statement syntactically similar to an ObjectDef, but uses a
+    # A statement syntactically similar to an ResourceDef, but uses a
     # capitalized object type and cannot have a name.  
-    class TypeDefaults < AST::Branch
+    class ResourceDefaults < AST::Branch
         attr_accessor :type, :params
 
         def each
             [@type,@params].each { |child| yield child }
         end
 
-        # As opposed to ObjectDef, this stores each default for the given
+        # As opposed to ResourceDef, this stores each default for the given
         # object type.
         def evaluate(hash)
             scope = hash[:scope]
-            type = @type.safeevaluate(:scope => scope)
+            type = @type.downcase
             params = @params.safeevaluate(:scope => scope)
 
-            begin
-                scope.setdefaults(type.downcase,params)
-            rescue Puppet::ParseError => except
-                except.line = self.line
-                except.file = self.file
-                raise except
-            rescue => detail
-                error = Puppet::ParseError.new(detail)
-                error.line = self.line
-                error.file = self.file
-                error.backtrace = detail.backtrace
-                raise error
+            parsewrap do
+                scope.setdefaults(type, params)
             end
         end
 
@@ -44,3 +36,5 @@ class Puppet::Parser::AST
     end
 
 end
+
+# $Id: resourcedefaults.rb 1835 2006-11-08 05:22:24Z luke $

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

@@ -0,0 +1,62 @@
+require 'puppet/parser/ast/resourcedef'
+
+class Puppet::Parser::AST
+    # Set a parameter on a resource specification created somewhere else in the
+    # configuration.  The object is responsible for verifying that this is allowed.
+    class ResourceOverride < ResourceDef
+        attr_accessor :object
+        attr_reader :params
+
+        # Iterate across all of our children.
+        def each
+            [@object,@params].flatten.each { |param|
+                #Puppet.debug("yielding param %s" % param)
+                yield param
+            }
+        end
+
+        # Does not actually return an object; instead sets an object
+        # in the current scope.
+        def evaluate(hash)
+            scope = hash[:scope]
+
+            # Get our object reference.
+            object = @object.safeevaluate(:scope => scope)
+
+            hash = {}
+
+            # Evaluate all of the specified params.
+            params = @params.collect { |param|
+                param.safeevaluate(:scope => scope)
+            }
+
+            # Now we just create a normal resource, but we call a very different
+            # method on the scope.
+            obj = Puppet::Parser::Resource.new(
+                :type => object.type,
+                :title => object.title,
+                :params => params,
+                :file => @file,
+                :line => @line,
+                :source => scope.source,
+                :scope => scope
+            )
+
+            # Now we tell the scope that it's an override, and it behaves as
+            # necessary.
+            scope.setoverride(obj)
+
+            obj
+        end
+
+        # Create our ResourceDef.  Handles type checking for us.
+        def initialize(hash)
+            @checked = false
+            super
+
+            #self.typecheck(@type.value)
+        end
+    end
+end
+
+# $Id: resourceoverride.rb 1726 2006-10-04 18:24:24Z luke $

data/lib/puppet/parser/ast/{objectparam.rb → resourceparam.rb}

@@ -1,6 +1,8 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
-    # The AST object for the parameters inside ObjectDefs and Selectors.
-    class ObjectParam < AST::Branch
+    # The AST object for the parameters inside ResourceDefs and Selectors.
+    class ResourceParam < AST::Branch
         attr_accessor :value, :param
 
         def each
@@ -10,9 +12,12 @@ class Puppet::Parser::AST
         # Return the parameter and the value.
         def evaluate(hash)
             scope = hash[:scope]
-            param = @param.safeevaluate(:scope => scope)
-            value = @value.safeevaluate(:scope => scope)
-            return [param, value]
+
+            return Puppet::Parser::Resource::Param.new(
+                :name => @param,
+                :value => @value.safeevaluate(:scope => scope),
+                :source => scope.source, :line => self.line, :file => self.file
+            )
         end
 
         def tree(indent = 0)
@@ -27,5 +32,6 @@ class Puppet::Parser::AST
             return "%s => %s" % [@param,@value]
         end
     end
-
 end
+
+# $Id: resourceparam.rb 1739 2006-10-06 03:13:15Z luke $

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

@@ -0,0 +1,44 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    # A reference to an object.  Only valid as an rvalue.
+    class ResourceRef < AST::Branch
+        attr_accessor :title, :type
+
+        def each
+            [@type,@title].flatten.each { |param|
+                #Puppet.debug("yielding param %s" % param)
+                yield param
+            }
+        end
+
+        # Evaluate our object, but just return a simple array of the type
+        # and name.
+        def evaluate(hash)
+            scope = hash[:scope]
+
+            # We want a lower-case type.
+            objtype = @type.downcase
+
+            title = @title.safeevaluate(:scope => scope)
+
+            return Puppet::Parser::Resource::Reference.new(
+                :type => objtype, :title => title
+            )
+        end
+
+        def tree(indent = 0)
+            return [
+                @type.tree(indent + 1),
+                @title.tree(indent + 1),
+                ((@@indline * indent) + self.typewrap(self.pin))
+            ].join("\n")
+        end
+
+        def to_s
+            return "%s[%s]" % [@type,@title]
+        end
+    end
+end
+
+# $Id: resourceref.rb 1726 2006-10-04 18:24:24Z luke $

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

@@ -1,3 +1,5 @@
+require 'puppet/parser/ast/branch'
+
 class Puppet::Parser::AST
     # The inline conditional operator.  Unlike CaseStatement, which executes
     # code, we just return a value.
@@ -16,10 +18,15 @@ class Puppet::Parser::AST
 
             # Get our parameter.
             paramvalue = @param.safeevaluate(:scope => scope)
+            
+            sensitive = Puppet[:casesensitive]
+            
+            if ! sensitive and paramvalue.respond_to?(:downcase)
+                paramvalue = paramvalue.downcase
+            end
 
             default = nil
 
-            #@values = [@values] unless @values.instance_of? AST::ASTArray
             unless @values.instance_of? AST::ASTArray or @values.instance_of? Array
                 @values = [@values]
             end
@@ -27,12 +34,16 @@ class Puppet::Parser::AST
             # Then look for a match in the options.
             @values.each { |obj|
                 param = obj.param.safeevaluate(:scope => scope)
+                if ! sensitive && param.respond_to?(:downcase)
+                    param = param.downcase
+                end
                 if param == paramvalue
                     # we found a matching option
                     retvalue = obj.value.safeevaluate(:scope => scope)
                     found = true
                     break
                 elsif obj.param.is_a?(Default)
+                    # Store the default, in case it's necessary.
                     default = obj
                 end
             }
@@ -42,12 +53,8 @@ class Puppet::Parser::AST
                 if default
                     retvalue = default.value.safeevaluate(:scope => scope)
                 else
-                    error = Puppet::ParseError.new(
-                        "No value for selector param '%s'" % paramvalue
-                    )
-                    error.line = self.line
-                    error.file = self.file
-                    raise error
+                    self.fail Puppet::ParseError,
+                        "No matching value for selector param '%s'" % paramvalue
                 end
             end
 
@@ -62,5 +69,6 @@ class Puppet::Parser::AST
             ].join("\n")
         end
     end
-
 end
+
+# $Id: selector.rb 2145 2007-02-01 01:29:48Z luke $