puppet 0.25.5 → 2.6.0

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

@@ -6,54 +6,60 @@ require 'puppet/parser/collector'
 # them to the current host, yo.
 class Puppet::Parser::AST
 class Collection < AST::Branch
-    attr_accessor :type, :query, :form
-    attr_reader :override
+  attr_accessor :type, :query, :form
+  attr_reader :override
 
-    associates_doc
+  associates_doc
 
-    # We return an object that does a late-binding evaluation.
-    def evaluate(scope)
-        if self.query
-            str, code = self.query.safeevaluate scope
-        else
-            str = code = nil
-        end
+  # We return an object that does a late-binding evaluation.
+  def evaluate(scope)
+    if self.query
+      str, code = self.query.safeevaluate scope
+    else
+      str = code = nil
+    end
+
+    newcoll = Puppet::Parser::Collector.new(scope, @type, str, code, self.form)
 
-        newcoll = Puppet::Parser::Collector.new(scope, @type, str, code, self.form)
+    scope.compiler.add_collection(newcoll)
 
-        scope.compiler.add_collection(newcoll)
+    # overrides if any
+    # Evaluate all of the specified params.
+    if @override
+      params = @override.collect do |param|
+        param.safeevaluate(scope)
+      end
 
-        # overrides if any
-        # Evaluate all of the specified params.
-        if @override
-            params = @override.collect do |param|
-                param.safeevaluate(scope)
-            end
 
             newcoll.add_override(
-                :params => params,
-                :file => @file,
-                :line => @line,
-                :source => scope.source,
-                :scope => scope
-            )
-        end
-
-        newcoll
+                
+        :parameters => params,
+        :file => @file,
+        :line => @line,
+        :source => scope.source,
+        
+        :scope => scope
+      )
     end
 
-    # Handle our parameter ourselves
-    def override=(override)
-        if override.is_a?(AST::ASTArray)
-            @override = override
-        else
+    newcoll
+  end
+
+  # Handle our parameter ourselves
+  def override=(override)
+    if override.is_a?(AST::ASTArray)
+      @override = override
+    else
+
             @override = AST::ASTArray.new(
-                :line => override.line,
-                :file => override.file,
-                :children => [override]
-            )
-        end
+                
+        :line => override.line,
+        :file => override.file,
+        
+        :children => [override]
+      )
     end
+  end
 
 end
 end

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

@@ -6,84 +6,81 @@ require 'puppet/parser/collector'
 # them to the current host, yo.
 class Puppet::Parser::AST
 class CollExpr < AST::Branch
-    attr_accessor :test1, :test2, :oper, :form, :type, :parens
+  attr_accessor :test1, :test2, :oper, :form, :type, :parens
 
-    # We return an object that does a late-binding evaluation.
-    def evaluate(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
-        str2, code2 = @test2.safeevaluate 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 "=="
-                if str1 == "tag"
-                    resource.tagged?(str2)
-                else
-                    if resource[str1].is_a?(Array)
-                        resource[str1].include?(str2)
-                    else
-                        resource[str1] == str2
-                    end
-                end
-            when "!="; resource[str1] != str2
-            end
-        end
+  # We return an object that does a late-binding evaluation.
+  def evaluate(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
 
-        # Now build up the rails conditions code
-        if self.parens and self.form == :exported
-            Puppet.warning "Parentheses are ignored in Rails searches"
-        end
+    # The code is only used for virtual lookups
+    str1, code1 = @test1.safeevaluate scope
+    str2, code2 = @test2.safeevaluate scope
 
-        case @oper
-        when "and", "or"
-            if form == :exported
-                raise Puppet::ParseError, "Puppet does not currently support collecting exported resources with more than one condition"
-            end
-            oper = @oper.upcase
-        when "=="; oper = "="
+    # 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 "=="
+        if str1 == "tag"
+          resource.tagged?(str2)
         else
-            oper = @oper
-        end
-
-        if oper == "=" or oper == "!="
-            # Add the rails association info where necessary
-            case str1
-            when "title"
-                str = "title #{oper} '#{str2}'"
-            when "tag"
-                str = "puppet_tags.name #{oper} '#{str2}'"
-            else
-                str = "param_values.value #{oper} '#{str2}' and " +
-                    "param_names.name = '#{str1}'"
-            end
-        else
-            str = "(%s) %s (%s)" % [str1, oper, str2]
+          if resource[str1].is_a?(Array)
+            resource[str1].include?(str2)
+          else
+            resource[str1] == str2
+          end
         end
+      when "!="; resource[str1] != str2
+      end
+    end
 
-        return str, code
+    # Now build up the rails conditions code
+    if self.parens and self.form == :exported
+      Puppet.warning "Parentheses are ignored in Rails searches"
     end
 
-    def initialize(hash = {})
-        super
+    case @oper
+    when "and", "or"
+      if form == :exported
+        raise Puppet::ParseError, "Puppet does not currently support collecting exported resources with more than one condition"
+      end
+      oper = @oper.upcase
+    when "=="; oper = "="
+    else
+      oper = @oper
+    end
 
-        unless %w{== != and or}.include?(@oper)
-            raise ArgumentError, "Invalid operator %s" % @oper
-        end
+    if oper == "=" or oper == "!="
+      # Add the rails association info where necessary
+      case str1
+      when "title"
+        str = "title #{oper} '#{str2}'"
+      when "tag"
+        str = "puppet_tags.name #{oper} '#{str2}'"
+      else
+        str = "param_values.value #{oper} '#{str2}' and param_names.name = '#{str1}'"
+      end
+    else
+      str = "(#{str1}) #{oper} (#{str2})"
     end
+
+    return str, code
+  end
+
+  def initialize(hash = {})
+    super
+
+    raise ArgumentError, "Invalid operator #{@oper}" unless %w{== != and or}.include?(@oper)
+  end
 end
 end

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

@@ -2,40 +2,37 @@ require 'puppet'
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    class ComparisonOperator < AST::Branch
-
-        attr_accessor :operator, :lval, :rval
-
-        # Iterate across all of our children.
-        def each
-            [@lval,@rval,@operator].each { |child| yield child }
-        end
-
-        # Returns a boolean which is the result of the boolean operation
-        # of lval and rval operands
-        def evaluate(scope)
-            # evaluate the operands, should return a boolean value
-            lval = @lval.safeevaluate(scope)
-            rval = @rval.safeevaluate(scope)
-
-            # convert to number if operands are number
-            lval = Puppet::Parser::Scope.number?(lval) || lval
-            rval = Puppet::Parser::Scope.number?(rval) || rval
-
-            # return result
-            unless @operator == '!='
-                lval.send(@operator,rval)
-            else
-                lval != rval
-            end
-        end
-
-        def initialize(hash)
-            super
-
-            unless %w{== != < > <= >=}.include?(@operator)
-                raise ArgumentError, "Invalid comparison operator %s" % @operator
-            end
-        end
+  class ComparisonOperator < AST::Branch
+
+    attr_accessor :operator, :lval, :rval
+
+    # Iterate across all of our children.
+    def each
+      [@lval,@rval,@operator].each { |child| yield child }
+    end
+
+    # Returns a boolean which is the result of the boolean operation
+    # of lval and rval operands
+    def evaluate(scope)
+      # evaluate the operands, should return a boolean value
+      lval = @lval.safeevaluate(scope)
+
+      case @operator
+      when "==","!="
+        @rval.evaluate_match(lval, scope) ? @operator == '==' : @operator == '!='
+      else
+        rval = @rval.safeevaluate(scope)
+        rval = Puppet::Parser::Scope.number?(rval) || rval
+        lval = Puppet::Parser::Scope.number?(lval) || lval
+
+        lval.send(@operator,rval)
+      end
+    end
+
+    def initialize(hash)
+      super
+
+      raise ArgumentError, "Invalid comparison operator #{@operator}" unless %w{== != < > <= >=}.include?(@operator)
     end
+  end
 end

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

@@ -1,22 +1,22 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # A separate ElseIf statement; can function as an 'else' if there's no
-    # test.
-    class Else < AST::Branch
+  # A separate ElseIf statement; can function as an 'else' if there's no
+  # test.
+  class Else < AST::Branch
 
-        associates_doc
+    associates_doc
 
-        attr_accessor :statements
+    attr_accessor :statements
 
-        def each
-            yield @statements
-        end
+    def each
+      yield @statements
+    end
 
-        # Evaluate the actual statements; this only gets called if
-        # our test was true matched.
-        def evaluate(scope)
-            return @statements.safeevaluate(scope)
-        end
+    # Evaluate the actual statements; this only gets called if
+    # our test was true matched.
+    def evaluate(scope)
+      @statements.safeevaluate(scope)
     end
+  end
 end

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

@@ -1,60 +1,51 @@
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    # An AST object to call a function.
-    class Function < AST::Branch
+  # An AST object to call a function.
+  class Function < AST::Branch
 
-        associates_doc
+    associates_doc
 
-        attr_accessor :name, :arguments
+    attr_accessor :name, :arguments
 
-        @settor = true
+    @settor = true
 
-        def evaluate(scope)
-
-            # Make sure it's a defined function
-            unless @fname
-                raise Puppet::ParseError, "Unknown function %s" % @name
-            end
-
-            # Now check that it's been used correctly
-            case @ftype
-            when :rvalue
-                unless Puppet::Parser::Functions.rvalue?(@name)
-                    raise Puppet::ParseError, "Function '%s' does not return a value" %
-                        @name
-                end
-            when :statement
-                if Puppet::Parser::Functions.rvalue?(@name)
-                    raise Puppet::ParseError,
-                        "Function '%s' must be the value of a statement" %
-                        @name
-                end
-            else
-                raise Puppet::DevError, "Invalid function type %s" % @ftype.inspect
-            end
+    def evaluate(scope)
 
+      # Make sure it's a defined function
+      raise Puppet::ParseError, "Unknown function #{@name}" unless Puppet::Parser::Functions.function(@name)
 
+      # Now check that it's been used correctly
+      case @ftype
+      when :rvalue
+        raise Puppet::ParseError, "Function '#{@name}' does not return a value" unless Puppet::Parser::Functions.rvalue?(@name)
+      when :statement
+        if Puppet::Parser::Functions.rvalue?(@name)
+          raise Puppet::ParseError,
+            "Function '#{@name}' must be the value of a statement"
+        end
+      else
+        raise Puppet::DevError, "Invalid function type #{@ftype.inspect}"
+      end
 
-            # We don't need to evaluate the name, because it's plaintext
-            args = @arguments.safeevaluate(scope)
+      # We don't need to evaluate the name, because it's plaintext
+      args = @arguments.safeevaluate(scope)
 
-            return scope.send("function_" + @name, args)
-        end
+      scope.send("function_#{@name}", args)
+    end
 
-        def initialize(hash)
-            @ftype = hash[:ftype] || :rvalue
-            hash.delete(:ftype) if hash.include? :ftype
+    def initialize(hash)
+      @ftype = hash[:ftype] || :rvalue
+      hash.delete(:ftype) if hash.include? :ftype
 
-            super(hash)
+      super(hash)
 
-             @fname = Puppet::Parser::Functions.function(@name)
-            # Lastly, check the parity
-        end
+      # Lastly, check the parity
+    end
 
-        def to_s
-            args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
-            "#{name}(#{args})"
-        end
+    def to_s
+      args = arguments.is_a?(ASTArray) ? arguments.to_s.gsub(/\[(.*)\]/,'\1') : arguments
+      "#{name}(#{args})"
     end
+  end
 end