puppet 0.25.5 → 2.6.0

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

@@ -2,30 +2,27 @@ require 'puppet'
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    class MatchOperator < AST::Branch
+  class MatchOperator < AST::Branch
 
-        attr_accessor :lval, :rval, :operator
+    attr_accessor :lval, :rval, :operator
 
-        # Iterate across all of our children.
-        def each
-            [@lval,@rval].each { |child| yield child }
-        end
+    # Iterate across all of our children.
+    def each
+      [@lval,@rval].each { |child| yield child }
+    end
 
-        # Returns a boolean which is the result of the boolean operation
-        # of lval and rval operands
-        def evaluate(scope)
-            lval = @lval.safeevaluate(scope)
+    # Returns a boolean which is the result of the boolean operation
+    # of lval and rval operands
+    def evaluate(scope)
+      lval = @lval.safeevaluate(scope)
 
-            return @operator == "=~" if rval.evaluate_match(lval, scope)
-            return @operator == "!~"
-        end
+      return(rval.evaluate_match(lval, scope) ? @operator == "=~" : @operator == "!~")
+    end
 
-        def initialize(hash)
-            super
+    def initialize(hash)
+      super
 
-            unless %w{!~ =~}.include?(@operator)
-                raise ArgumentError, "Invalid regexp operator %s" % @operator
-            end
-        end
+      raise ArgumentError, "Invalid regexp operator #{@operator}" unless %w{!~ =~}.include?(@operator)
     end
+  end
 end

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

@@ -4,20 +4,20 @@ require 'puppet/parser/ast/branch'
 # An object that returns a boolean which is the boolean not
 # of the given value.
 class Puppet::Parser::AST
-    class Minus < AST::Branch
-        attr_accessor :value
+  class Minus < AST::Branch
+    attr_accessor :value
 
-        def each
-            yield @value
-        end
+    def each
+      yield @value
+    end
 
-        def evaluate(scope)
-            val = @value.safeevaluate(scope)
-            val = Puppet::Parser::Scope.number?(val)
-            if val == nil
-                raise ArgumentError, "minus operand %s is not a number" % val
-            end
-            return -val
-        end
+    def evaluate(scope)
+      val = @value.safeevaluate(scope)
+      val = Puppet::Parser::Scope.number?(val)
+      if val == nil
+        raise ArgumentError, "minus operand #{val} is not a number"
+      end
+      -val
     end
+  end
 end

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

@@ -1,11 +1,11 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # This class is a no-op, it doesn't produce anything
-    # when evaluated, hence it's name :-)
-    class Nop < AST::Leaf
-        def evaluate(scope)
-            # nothing to do
-        end
+  # This class is a no-op, it doesn't produce anything
+  # when evaluated, hence it's name :-)
+  class Nop < AST::Leaf
+    def evaluate(scope)
+      # nothing to do
     end
+  end
 end

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

@@ -4,16 +4,16 @@ require 'puppet/parser/ast/branch'
 # An object that returns a boolean which is the boolean not
 # of the given value.
 class Puppet::Parser::AST
-    class Not < AST::Branch
-        attr_accessor :value
+  class Not < AST::Branch
+    attr_accessor :value
 
-        def each
-            yield @value
-        end
+    def each
+      yield @value
+    end
 
-        def evaluate(scope)
-            val = @value.safeevaluate(scope)
-            return ! Puppet::Parser::Scope.true?(val)
-        end
+    def evaluate(scope)
+      val = @value.safeevaluate(scope)
+      ! Puppet::Parser::Scope.true?(val)
     end
+  end
 end

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

@@ -0,0 +1,60 @@
+require 'puppet/parser/ast'
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/relationship'
+
+class Puppet::Parser::AST::Relationship < Puppet::Parser::AST::Branch
+  RELATIONSHIP_TYPES = %w{-> <- ~> <~}
+
+  attr_accessor :left, :right, :arrow, :type
+
+  def actual_left
+    chained? ? left.right : left
+  end
+
+  # Evaluate our object, but just return a simple array of the type
+  # and name.
+  def evaluate(scope)
+    if chained?
+      real_left = left.safeevaluate(scope)
+      left_dep = left_dep.shift if left_dep.is_a?(Array)
+    else
+      real_left = left.safeevaluate(scope)
+    end
+    real_right = right.safeevaluate(scope)
+
+    source, target = sides2edge(real_left, real_right)
+    result = Puppet::Parser::Relationship.new(source, target, type)
+    scope.compiler.add_relationship(result)
+    real_right
+  end
+
+  def initialize(left, right, arrow, args = {})
+    super(args)
+    unless RELATIONSHIP_TYPES.include?(arrow)
+      raise ArgumentError, "Invalid relationship type #{arrow.inspect}; valid types are #{RELATIONSHIP_TYPES.collect { |r| r.to_s }.join(", ")}"
+    end
+    @left, @right, @arrow = left, right, arrow
+  end
+
+  def type
+    subscription? ? :subscription : :relationship
+  end
+
+  def sides2edge(left, right)
+    out_edge? ? [left, right] : [right, left]
+  end
+
+  private
+
+  def chained?
+    left.is_a?(self.class)
+  end
+
+  def out_edge?
+    ["->", "~>"].include?(arrow)
+  end
+
+  def subscription?
+    ["~>", "<~"].include?(arrow)
+  end
+end

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

@@ -5,72 +5,73 @@ require 'puppet/parser/ast/resource_reference'
 class Puppet::Parser::AST
 class Resource < AST::ResourceReference
 
-    associates_doc
+  associates_doc
 
-    attr_accessor :title, :type, :exported, :virtual
-    attr_reader :params
+  attr_accessor :title, :type, :exported, :virtual
+  attr_reader :parameters
 
-    # Does not actually return an object; instead sets an object
-    # in the current scope.
-    def evaluate(scope)
-        # Evaluate all of the specified params.
-        paramobjects = @params.collect { |param|
-            param.safeevaluate(scope)
-        }
+  # Does not actually return an object; instead sets an object
+  # in the current scope.
+  def evaluate(scope)
+    # Evaluate all of the specified params.
+    paramobjects = parameters.collect { |param|
+      param.safeevaluate(scope)
+    }
 
-        resource_titles = @title.safeevaluate(scope)
+    resource_titles = @title.safeevaluate(scope)
 
-        # it's easier to always use an array, even for only one name
-        unless resource_titles.is_a?(Array)
-            resource_titles = [resource_titles]
-        end
+    # it's easier to always use an array, even for only one name
+    resource_titles = [resource_titles] unless resource_titles.is_a?(Array)
 
-        resource_type = qualified_type(scope)
+    # 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 || self.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 || self.exported
+    # 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.
+    resource_titles.flatten.collect { |resource_title|
+      exceptwrap :type => Puppet::ParseError do
 
-        # 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.
-        resource_titles.flatten.collect { |resource_title|
-            exceptwrap :type => Puppet::ParseError do
-                resource = Puppet::Parser::Resource.new(
-                    :type => resource_type,
-                    :title => resource_title,
-                    :params => paramobjects,
-                    :file => self.file,
-                    :line => self.line,
-                    :exported => self.exported,
-                    :virtual => virt,
-                    :source => scope.source,
-                    :scope => scope
-                )
+              resource = Puppet::Parser::Resource.new(
+        type, resource_title,
+          :parameters => paramobjects,
+          :file => self.file,
+          :line => self.line,
+          :exported => self.exported,
+          :virtual => virt,
+          :source => scope.source,
+          :scope => scope,
+        
+          :strict => true
+        )
 
-                # And then store the resource in the compiler.
-                # At some point, we need to switch all of this to return
-                # resources instead of storing them like this.
-                scope.compiler.add_resource(scope, resource)
-                resource
-            end
-        }.reject { |resource| resource.nil? }
-    end
+        # And then store the resource in the compiler.
+        # At some point, we need to switch all of this to return
+        # resources instead of storing them like this.
+        scope.compiler.add_resource(scope, resource)
+        resource
+      end
+    }.reject { |resource| resource.nil? }
+  end
+
+  # Set the parameters for our object.
+  def parameters=(params)
+    if params.is_a?(AST::ASTArray)
+      @parameters = params
+    else
 
-    # 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
+            @parameters = AST::ASTArray.new(
+                
+        :line => params.line,
+        :file => params.file,
+        
+        :children => [params]
+      )
     end
+  end
 end
 end

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

@@ -1,24 +1,24 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # A statement syntactically similar to an ResourceDef, but uses a
-    # capitalized object type and cannot have a name.
-    class ResourceDefaults < AST::Branch
-        attr_accessor :type, :params
+  # A statement syntactically similar to an ResourceDef, but uses a
+  # capitalized object type and cannot have a name.
+  class ResourceDefaults < AST::Branch
+    attr_accessor :type, :parameters
 
-        associates_doc
+    associates_doc
 
-        # As opposed to ResourceDef, this stores each default for the given
-        # object type.
-        def evaluate(scope)
-            # Use a resource reference to canonize the type
-            ref = Puppet::Resource::Reference.new(@type, "whatever")
-            type = ref.type
-            params = @params.safeevaluate(scope)
+    # As opposed to ResourceDef, this stores each default for the given
+    # object type.
+    def evaluate(scope)
+      # Use a resource reference to canonize the type
+      ref = Puppet::Resource.new(@type, "whatever")
+      type = ref.type
+      params = @parameters.safeevaluate(scope)
 
-            parsewrap do
-                scope.setdefaults(type, params)
-            end
-        end
+      parsewrap do
+        scope.setdefaults(type, params)
+      end
     end
+  end
 end

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

@@ -1,68 +1,68 @@
 require 'puppet/parser/ast/resource'
 
 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 < Resource
+  # 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 < Resource
 
-        associates_doc
+    associates_doc
 
-        attr_accessor :object
-        attr_reader :params
+    attr_accessor :object
+    attr_reader :parameters
 
-        # Iterate across all of our children.
-        def each
-            [@object,@params].flatten.each { |param|
-                #Puppet.debug("yielding param %s" % param)
-                yield param
-            }
-        end
+    # Iterate across all of our children.
+    def each
+      [@object,@parameters].flatten.each { |param|
+        #Puppet.debug("yielding param #{param}")
+        yield param
+      }
+    end
+
+    # Does not actually return an object; instead sets an object
+    # in the current scope.
+    def evaluate(scope)
+      # Get our object reference.
+      resource = @object.safeevaluate(scope)
 
-        # Does not actually return an object; instead sets an object
-        # in the current scope.
-        def evaluate(scope)
-            # Get our object reference.
-            resource = @object.safeevaluate(scope)
+      hash = {}
 
-            hash = {}
+      # Evaluate all of the specified params.
+      params = @parameters.collect { |param|
+        param.safeevaluate(scope)
+      }
 
-            # Evaluate all of the specified params.
-            params = @params.collect { |param|
-                param.safeevaluate(scope)
-            }
+      # Now we just create a normal resource, but we call a very different
+      # method on the scope.
+      resource = [resource] unless resource.is_a?(Array)
 
-            # Now we just create a normal resource, but we call a very different
-            # method on the scope.
-            resource = [resource] unless resource.is_a?(Array)
+      resource = resource.collect do |r|
 
-            resource = resource.collect do |r|
-                res = Puppet::Parser::Resource.new(
-                    :type => r.type,
-                    :title => r.title,
-                    :params => params,
-                    :file => file,
-                    :line => line,
-                    :source => scope.source,
-                    :scope => scope
-                )
+              res = Puppet::Parser::Resource.new(
+        r.type, r.title,
+          :parameters => 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.compiler.add_override(res)
+        # Now we tell the scope that it's an override, and it behaves as
+        # necessary.
+        scope.compiler.add_override(res)
 
-                res
-            end
-            # decapsulate array in case of only one item
-            return resource.pop if resource.length == 1
-            return resource
-        end
+        res
+      end
+      # decapsulate array in case of only one item
+      return(resource.length == 1 ? resource.pop : resource)
+    end
 
-        # Create our ResourceDef.  Handles type checking for us.
-        def initialize(hash)
-            @checked = false
-            super
+    # Create our ResourceDef.  Handles type checking for us.
+    def initialize(hash)
+      @checked = false
+      super
 
-            #self.typecheck(@type.value)
-        end
+      #self.typecheck(@type.value)
     end
+  end
 end