puppet 0.9.2 → 0.13.0

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

@@ -0,0 +1,88 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+    # The basic container class.  This object behaves almost identically
+    # to a normal array except at initialization time.  Note that its name
+    # is 'AST::ASTArray', rather than plain 'AST::Array'; I had too many
+    # bugs when it was just 'AST::Array', because things like
+    # 'object.is_a?(Array)' never behaved as I expected.
+    class ASTArray < Branch
+        include Enumerable
+
+        # Return a child by index.  Probably never used.
+        def [](index)
+            @children[index]
+        end
+
+        # Evaluate our children.
+        def evaluate(scope)
+            rets = nil
+            # We basically always operate declaratively, and when we
+            # do we need to evaluate the settor-like statements first.  This
+            # is basically variable and type-default declarations.
+            if scope.declarative?
+                test = [
+                    AST::VarDef, AST::TypeDefaults
+                ]
+
+                settors = []
+                others = []
+                @children.each { |child|
+                    if test.include?(child.class)
+                        settors.push child
+                    else
+                        others.push child
+                    end
+                }
+                rets = [settors,others].flatten.collect { |child|
+                    child.safeevaluate(scope)
+                }
+            else
+                # If we're not declarative, just do everything in order.
+                rets = @children.collect { |item|
+                    item.safeevaluate(scope)
+                }
+            end
+
+            rets = rets.reject { |obj| obj.nil? }
+
+            return rets
+        end
+
+        def push(*ary)
+            ary.each { |child|
+                #Puppet.debug "adding %s(%s) of type %s to %s" %
+                #    [child, child.object_id, child.class.to_s.sub(/.+::/,''),
+                #    self.object_id]
+                @children.push(child)
+            }
+
+            return self
+        end
+
+        # Convert to a string.  Only used for printing the parse tree.
+        def to_s
+            return "[" + @children.collect { |child|
+                child.to_s
+            }.join(", ") + "]"
+        end
+
+        # Print the parse tree.
+        def tree(indent = 0)
+            #puts((AST.indent * indent) + self.pin)
+            self.collect { |child|
+                child.tree(indent)
+            }.join("\n" + (AST.midline * (indent+1)) + "\n")
+        end
+    end
+
+    # A simple container class, containing the parameters for an object.
+    # Used for abstracting the grammar declarations.  Basically unnecessary
+    # except that I kept finding bugs because I had too many arrays that
+    # meant completely different things.
+    class ObjectInst < ASTArray; end
+
+    # Another simple container class to make sure we can correctly arrayfy
+    # things.
+    class CompArgument < ASTArray; end
+end

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

@@ -0,0 +1,47 @@
+class Puppet::Parser::AST
+    # The parent class of all AST objects that contain other AST objects.
+    # Everything but the really simple objects descend from this.  It is
+    # important to note that Branch objects contain other AST objects only --
+    # if you want to contain values, use a descendent of the AST::Leaf class.
+    class Branch < AST
+        include Enumerable
+        attr_accessor :pin, :children
+
+        # Yield each contained AST node in turn.  Used mostly by 'evaluate'.
+        # This definition means that I don't have to override 'evaluate'
+        # every time, but each child of Branch will likely need to override
+        # this method.
+        def each
+            @children.each { |child|
+                yield child
+            }
+        end
+
+        # Initialize our object.  Largely relies on the method from the base
+        # class, but also does some verification.
+        def initialize(arghash)
+            super(arghash)
+
+            # Create the hash, if it was not set at initialization time.
+            unless defined? @children
+                @children = []
+            end
+
+            # Verify that we only got valid AST nodes.
+            @children.each { |child|
+                unless child.is_a?(AST)
+                    raise Puppet::DevError,
+                        "child %s is a %s instead of ast" % [child, child.class]
+                end
+            }
+        end
+
+        # Pretty-print the parse tree.
+        def tree(indent = 0)
+            return ((@@indline * indent) +
+                self.typewrap(self.pin)) + "\n" + self.collect { |child|
+                    child.tree(indent + 1)
+            }.join("\n")
+        end
+    end
+end

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

@@ -0,0 +1,66 @@
+class Puppet::Parser::AST
+    # Each individual option in a case statement.
+    class CaseOpt < AST::Branch
+        attr_accessor :value, :statements
+
+        # CaseOpt is a bit special -- we just want the value first,
+        # so that CaseStatement can compare, and then it will selectively
+        # decide whether to fully evaluate this option
+
+        def each
+            [@value,@statements].each { |child| yield child }
+        end
+
+        # Are we the default option?
+        def default?
+            if defined? @default
+                return @default
+            end
+
+            if @value.is_a?(AST::ASTArray)
+                @value.each { |subval|
+                    if subval.is_a?(AST::Default)
+                        @default = true
+                        break
+                    end
+                }
+            else
+                if @value.is_a?(AST::Default)
+                    @default = true
+                end
+            end
+
+            unless defined? @default
+                @default = false
+            end
+
+            return @default
+        end
+
+        # You can specify a list of values; return each in turn.
+        def eachvalue
+            if @value.is_a?(AST::ASTArray)
+                @value.each { |subval|
+                    yield subval.value
+                }
+            else
+                yield @value.value
+            end
+        end
+
+        # Evaluate the actual statements; this only gets called if
+        # our option matched.
+        def evaluate(scope)
+            return @statements.safeevaluate(scope.newscope)
+        end
+
+        def tree(indent = 0)
+            rettree = [
+                @value.tree(indent + 1),
+                ((@@indline * indent) + self.typewrap(self.pin)),
+                @statements.tree(indent + 1)
+            ]
+            return rettree.flatten.join("\n")
+        end
+    end
+end

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

@@ -0,0 +1,78 @@
+class Puppet::Parser::AST
+    # The basic logical structure in Puppet.  Supports a list of
+    # tests and statement arrays.
+    class CaseStatement < AST::Branch
+        attr_accessor :test, :options, :default
+
+        # Short-curcuit evaluation.  Return the value of the statements for
+        # the first option that matches.
+        def evaluate(scope)
+            value = @test.safeevaluate(scope)
+
+            retvalue = nil
+            found = false
+            
+            # Iterate across the options looking for a match.
+            @options.each { |option|
+                if option.eachvalue { |opval| break true if opval == value }
+                    # we found a matching option
+                    retvalue = option.safeevaluate(scope)
+                    found = true
+                    break
+                end
+            }
+
+            # Unless we found something, look for the default.
+            unless found
+                if defined? @default
+                    retvalue = @default.safeevaluate(scope)
+                else
+                    Puppet.debug "No true answers and no default"
+                end
+            end
+            return retvalue
+        end
+
+        # Do some input validation on our options.
+        def initialize(hash)
+            values = {}
+
+            super
+
+            # This won't work if we move away from only allowing
+            # constants here, but for now, it's fine and useful.
+            @options.each { |option|
+                unless option.is_a?(CaseOpt)
+                    raise Puppet::DevError, "Option is not a CaseOpt"
+                end
+                if option.default?
+                    @default = option
+                end
+                option.eachvalue { |val|
+                    if values.include?(val)
+                        raise Puppet::ParseError,
+                            "Value %s appears twice in case statement" %
+                                val
+                    else
+                        values[val] = true
+                    end
+                }
+            }
+        end
+
+        def tree(indent = 0)
+            rettree = [
+                @test.tree(indent + 1),
+                ((@@indline * indent) + self.typewrap(self.pin)),
+                @options.tree(indent + 1)
+            ]
+
+            return rettree.flatten.join("\n")
+        end
+
+        def each
+            [@test,@options].each { |child| yield child }
+        end
+    end
+
+end

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

@@ -0,0 +1,78 @@
+require 'puppet/parser/ast/compdef'
+
+class Puppet::Parser::AST
+    # Define a new class.  Syntactically similar to component definitions,
+    # but classes are always singletons -- only one can exist on a given
+    # host.
+    class ClassDef < AST::CompDef
+        attr_accessor :parentclass
+
+        def each
+            if @parentclass
+                #[@name,@args,@parentclass,@code].each { |child| yield child }
+                [@name,@parentclass,@code].each { |child| yield child }
+            else
+                #[@name,@args,@code].each { |child| yield child }
+                [@name,@code].each { |child| yield child }
+            end
+        end
+
+        # Store our parse tree according to name.
+        def evaluate(scope)
+            name = @name.safeevaluate(scope)
+            #args = @args.safeevaluate(scope)
+
+                #:args => args,
+            arghash = {
+                :name => name,
+                :code => @code
+            }
+
+            if @parentclass
+                arghash[:parentclass] = @parentclass.safeevaluate(scope)
+            end
+
+            #Puppet.debug("defining hostclass '%s' with arguments [%s]" %
+            #    [name,args])
+
+            begin
+                hclass = HostClass.new(arghash)
+                hclass.keyword = self.keyword
+                scope.settype(name, hclass)
+            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
+            end
+        end
+
+        def initialize(hash)
+            @parentclass = nil
+            @keyword = "class"
+            super
+        end
+
+        def tree(indent = 0)
+                #@args.tree(indent + 1),
+            return [
+                @name.tree(indent + 1),
+                ((@@indline * 4 * indent) + self.typewrap("class")),
+                @parentclass ? @parentclass.tree(indent + 1) : "",
+                @code.tree(indent + 1),
+            ].join("\n")
+        end
+
+        def to_s
+            return "class %s(%s) inherits %s {\n%s }" %
+                [@name, @parentclass, @code]
+                #[@name, @args, @parentclass, @code]
+        end
+    end
+
+end

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

@@ -0,0 +1,111 @@
+class Puppet::Parser::AST
+    # Define a new component.  This basically just stores the
+    # associated parse tree by name in our current scope.  Note that
+    # there is currently a mismatch in how we look up components -- it
+    # usually uses scopes, but sometimes uses '@@settypes'.
+    # FIXME This class should verify that each of its direct children
+    # has an abstractable name -- i.e., if a file does not include a
+    # variable in its name, then the user is essentially guaranteed to
+    # encounter an error if the component is instantiated more than
+    # once.
+    class CompDef < AST::Branch
+        attr_accessor :name, :args, :code, :keyword
+
+        def each
+            [@name,@args,@code].each { |child| yield child }
+        end
+
+        # Store the parse tree.
+        def evaluate(scope)
+            name = @name.safeevaluate(scope)
+            args = @args.safeevaluate(scope)
+
+            begin
+                comp = AST::Component.new(
+                    :name => name,
+                    :args => args,
+                    :code => @code
+                )
+                comp.keyword = self.keyword
+                scope.settype(name, comp)
+            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
+            end
+        end
+
+        def initialize(hash)
+            @parentclass = nil
+
+            # Set a default keyword
+            @keyword = "define"
+            super
+
+            #Puppet.debug "Defining type %s" % @name.value
+
+            # we need to both mark that a given argument is valid,
+            # and we need to also store any provided default arguments
+            # FIXME This creates a global list of types and their
+            # acceptable arguments.  This should really be scoped
+            # instead.
+            @@settypes[@name.value] = self
+        end
+
+        def tree(indent = 0)
+            return [
+                @name.tree(indent + 1),
+                ((@@indline * 4 * indent) + self.typewrap("define")),
+                @args.tree(indent + 1),
+                @code.tree(indent + 1),
+            ].join("\n")
+        end
+
+        def to_s
+            return "define %s(%s) {\n%s }" % [@name, @args, @code]
+        end
+
+        # Check whether a given argument is valid.  Searches up through
+        # any parent classes that might exist.
+        def validarg?(param)
+            found = false
+            if @args.is_a?(AST::ASTArray)
+                found = @args.detect { |arg|
+                    if arg.is_a?(AST::ASTArray)
+                        arg[0].value == param
+                    else
+                        arg.value == param
+                    end
+                }
+            else
+                found = @args.value == param
+                #Puppet.warning "got arg %s" % @args.inspect
+                #hash[@args.value] += 1
+            end
+
+            if found
+                return true
+            # a nil parentclass is an empty astarray
+            # stupid but true
+            elsif @parentclass
+                parent = @@settypes[@parentclass.value]
+                if parent and parent != []
+                    return parent.validarg?(param)
+                else
+                    raise Puppet::Error, "Could not find parent class %s" %
+                        @parentclass.value
+                end
+            else
+                return false
+            end
+
+        end
+    end
+
+end