puppet 0.25.5 → 2.6.0

data/lib/puppet/parameter/value.rb

@@ -0,0 +1,63 @@
+require 'puppet/parameter/value_collection'
+
+# An individual Value class.
+class Puppet::Parameter::Value
+  attr_reader :name, :options, :event
+  attr_accessor :block, :call, :method, :required_features
+
+  # Add an alias for this value.
+  def alias(name)
+    @aliases << convert(name)
+  end
+
+  # Return all aliases.
+  def aliases
+    @aliases.dup
+  end
+
+  # Store the event that our value generates, if it does so.
+  def event=(value)
+    @event = convert(value)
+  end
+
+  def initialize(name)
+    if name.is_a?(Regexp)
+      @name = name
+    else
+      # Convert to a string and then a symbol, so things like true/false
+      # still show up as symbols.
+      @name = convert(name)
+    end
+
+    @aliases = []
+
+    @call = :instead
+  end
+
+  # Does a provided value match our value?
+  def match?(value)
+    if regex?
+      return true if name =~ value.to_s
+    else
+      return(name == convert(value) ? true : @aliases.include?(convert(value)))
+    end
+  end
+
+  # Is our value a regex?
+  def regex?
+    @name.is_a?(Regexp)
+  end
+
+  private
+
+  # A standard way of converting all of our values, so we're always
+  # comparing apples to apples.
+  def convert(value)
+    if value == ''
+      # We can't intern an empty string, yay.
+      value
+    else
+      value.to_s.to_sym
+    end
+  end
+end

data/lib/puppet/parameter/value_collection.rb

@@ -0,0 +1,143 @@
+require 'puppet/parameter/value'
+
+# A collection of values and regexes, used for specifying
+# what values are allowed in a given parameter.
+class Puppet::Parameter::ValueCollection
+
+  def aliasvalue(name, other)
+    other = other.to_sym
+    unless value = match?(other)
+      raise Puppet::DevError, "Cannot alias nonexistent value #{other}"
+    end
+
+    value.alias(name)
+  end
+
+  # Return a doc string for all of the values in this parameter/property.
+  def doc
+    unless defined?(@doc)
+      @doc = ""
+      unless values.empty?
+        @doc += "  Valid values are "
+        @doc += @strings.collect do |value|
+          if aliases = value.aliases and ! aliases.empty?
+            "``#{value.name}`` (also called ``#{aliases.join(", ")}``)"
+          else
+            "``#{value.name}``"
+          end
+        end.join(", ") + "."
+      end
+
+      @doc += "  Values can match ``" + regexes.join("``, ``") + "``." unless regexes.empty?
+    end
+
+    @doc
+  end
+
+  # Does this collection contain any value definitions?
+  def empty?
+    @values.empty?
+  end
+
+  def initialize
+    # We often look values up by name, so a hash makes more sense.
+    @values = {}
+
+    # However, we want to retain the ability to match values in order,
+    # but we always prefer directly equality (i.e., strings) over regex matches.
+    @regexes = []
+    @strings = []
+  end
+
+  # Can we match a given value?
+  def match?(test_value)
+    # First look for normal values
+    if value = @strings.find { |v| v.match?(test_value) }
+      return value
+    end
+
+    # Then look for a regex match
+    @regexes.find { |v| v.match?(test_value) }
+  end
+
+  # If the specified value is allowed, then munge appropriately.
+  def munge(value)
+    return value if empty?
+
+    if instance = match?(value)
+      if instance.regex?
+        return value
+      else
+        return instance.name
+      end
+    else
+      return value
+    end
+  end
+
+  # Define a new valid value for a property.  You must provide the value itself,
+  # usually as a symbol, or a regex to match the value.
+  #
+  # The first argument to the method is either the value itself or a regex.
+  # The second argument is an option hash; valid options are:
+  # * <tt>:event</tt>: The event that should be returned when this value is set.
+  # * <tt>:call</tt>: When to call any associated block.  The default value
+  #   is ``instead``, which means to call the value instead of calling the
+  #   provider.  You can also specify ``before`` or ``after``, which will
+  #   call both the block and the provider, according to the order you specify
+  #   (the ``first`` refers to when the block is called, not the provider).
+  def newvalue(name, options = {}, &block)
+    value = Puppet::Parameter::Value.new(name)
+    @values[value.name] = value
+    if value.regex?
+      @regexes << value
+    else
+      @strings << value
+    end
+
+    options.each { |opt, arg| value.send(opt.to_s + "=", arg) }
+    if block_given?
+      value.block = block
+    else
+      value.call = options[:call] || :none
+    end
+
+    value.method ||= "set_#{value.name}" if block_given? and ! value.regex?
+
+    value
+  end
+
+  # Define one or more new values for our parameter.
+  def newvalues(*names)
+    names.each { |name| newvalue(name) }
+  end
+
+  def regexes
+    @regexes.collect { |r| r.name.inspect }
+  end
+
+  # Verify that the passed value is valid.
+  def validate(value)
+    return if empty?
+
+    unless @values.detect { |name, v| v.match?(value) }
+      str = "Invalid value #{value.inspect}. "
+
+      str += "Valid values are #{values.join(", ")}. " unless values.empty?
+
+      str += "Valid values match #{regexes.join(", ")}." unless regexes.empty?
+
+      raise ArgumentError, str
+    end
+  end
+
+  # Return a single value instance.
+  def value(name)
+    @values[name]
+  end
+
+  # Return the list of valid values.
+  def values
+    @strings.collect { |s| s.name }
+  end
+end

data/lib/puppet/parser.rb

@@ -0,0 +1,4 @@
+require 'puppet/parser/parser'
+require 'puppet/parser/compiler'
+require 'puppet/resource/type_collection'
+

data/lib/puppet/parser/ast.rb

@@ -8,90 +8,105 @@ require 'puppet/file_collection/lookup'
 # Handles things like file name, line #, and also does the initialization
 # for all of the parameters of all of the child objects.
 class Puppet::Parser::AST
-    # Do this so I don't have to type the full path in all of the subclasses
-    AST = Puppet::Parser::AST
+  # Do this so I don't have to type the full path in all of the subclasses
+  AST = Puppet::Parser::AST
 
-    include Puppet::FileCollection::Lookup
+  include Puppet::FileCollection::Lookup
 
-    include Puppet::Util::Errors
-    include Puppet::Util::MethodHelper
-    include Puppet::Util::Docs
+  include Puppet::Util::Errors
+  include Puppet::Util::MethodHelper
+  include Puppet::Util::Docs
 
-    attr_accessor :parent, :scope
+  attr_accessor :parent, :scope
 
-    # don't fetch lexer comment by default
-    def use_docs
-        self.class.use_docs
-    end
+  # don't fetch lexer comment by default
+  def use_docs
+    self.class.use_docs
+  end
 
-    # allow our subclass to specify they want documentation
-    class << self
-       attr_accessor :use_docs
-       def associates_doc
-         self.use_docs = true
-       end
+  # allow our subclass to specify they want documentation
+  class << self
+    attr_accessor :use_docs
+    def associates_doc
+    self.use_docs = true
     end
+  end
 
-    # Does this ast object set something?  If so, it gets evaluated first.
-    def self.settor?
-        if defined? @settor
-            @settor
-        else
-            false
-        end
+  # Does this ast object set something?  If so, it gets evaluated first.
+  def self.settor?
+    if defined?(@settor)
+      @settor
+    else
+      false
     end
+  end
 
-    # Evaluate the current object.  Just a stub method, since the subclass
-    # should override this method.
-    # of the contained children and evaluates them in turn, returning a
-    # list of all of the collected values, rejecting nil values
-    def evaluate(*options)
-        raise Puppet::DevError, "Did not override #evaluate in %s" % self.class
-    end
+  # Evaluate the current object.  Just a stub method, since the subclass
+  # should override this method.
+  # of the contained children and evaluates them in turn, returning a
+  # list of all of the collected values, rejecting nil values
+  def evaluate(*options)
+    raise Puppet::DevError, "Did not override #evaluate in #{self.class}"
+  end
 
-    # Throw a parse error.
-    def parsefail(message)
-        self.fail(Puppet::ParseError, message)
-    end
+  # Throw a parse error.
+  def parsefail(message)
+    self.fail(Puppet::ParseError, message)
+  end
 
-    # Wrap a statemp in a reusable way so we always throw a parse error.
-    def parsewrap
-        exceptwrap :type => Puppet::ParseError do
-            yield
-        end
+  # Wrap a statemp in a reusable way so we always throw a parse error.
+  def parsewrap
+    exceptwrap :type => Puppet::ParseError do
+      yield
     end
+  end
 
-    # The version of the evaluate method that should be called, because it
-    # correctly handles errors.  It is critical to use this method because
-    # it can enable you to catch the error where it happens, rather than
-    # much higher up the stack.
-    def safeevaluate(*options)
-        # We duplicate code here, rather than using exceptwrap, because this
-        # is called so many times during parsing.
-        begin
-            return self.evaluate(*options)
-        rescue Puppet::Error => detail
-            raise adderrorcontext(detail)
-        rescue => detail
-            error = Puppet::Error.new(detail.to_s)
-            # We can't use self.fail here because it always expects strings,
-            # not exceptions.
-            raise adderrorcontext(error, detail)
-        end
+  # The version of the evaluate method that should be called, because it
+  # correctly handles errors.  It is critical to use this method because
+  # it can enable you to catch the error where it happens, rather than
+  # much higher up the stack.
+  def safeevaluate(*options)
+    # We duplicate code here, rather than using exceptwrap, because this
+    # is called so many times during parsing.
+    begin
+      return self.evaluate(*options)
+    rescue Puppet::Error => detail
+      raise adderrorcontext(detail)
+    rescue => detail
+      error = Puppet::Error.new(detail.to_s)
+      # We can't use self.fail here because it always expects strings,
+      # not exceptions.
+      raise adderrorcontext(error, detail)
     end
+  end
 
-    # Initialize the object.  Requires a hash as the argument, and
-    # takes each of the parameters of the hash and calls the settor
-    # method for them.  This is probably pretty inefficient and should
-    # likely be changed at some point.
-    def initialize(args)
-        set_options(args)
-    end
+  # Initialize the object.  Requires a hash as the argument, and
+  # takes each of the parameters of the hash and calls the settor
+  # method for them.  This is probably pretty inefficient and should
+  # likely be changed at some point.
+  def initialize(args)
+    set_options(args)
+  end
+
+  # evaluate ourselves, and match
+  def evaluate_match(value, scope)
+    obj = self.safeevaluate(scope)
+
+    obj   = obj.downcase   if obj.respond_to?(:downcase)
+    value = value.downcase if value.respond_to?(:downcase)
+
+    obj   = Puppet::Parser::Scope.number?(obj)   || obj
+    value = Puppet::Parser::Scope.number?(value) || value
+
+    # "" == undef for case/selector/if
+    obj == value or (obj == "" and value == :undef)
+  end
 end
 
 # And include all of the AST subclasses.
 require 'puppet/parser/ast/arithmetic_operator'
 require 'puppet/parser/ast/astarray'
+require 'puppet/parser/ast/asthash'
 require 'puppet/parser/ast/branch'
 require 'puppet/parser/ast/boolean_operator'
 require 'puppet/parser/ast/caseopt'
@@ -99,15 +114,13 @@ require 'puppet/parser/ast/casestatement'
 require 'puppet/parser/ast/collection'
 require 'puppet/parser/ast/collexpr'
 require 'puppet/parser/ast/comparison_operator'
-require 'puppet/parser/ast/definition'
 require 'puppet/parser/ast/else'
 require 'puppet/parser/ast/function'
-require 'puppet/parser/ast/hostclass'
 require 'puppet/parser/ast/ifstatement'
+require 'puppet/parser/ast/in_operator'
 require 'puppet/parser/ast/leaf'
 require 'puppet/parser/ast/match_operator'
 require 'puppet/parser/ast/minus'
-require 'puppet/parser/ast/node'
 require 'puppet/parser/ast/nop'
 require 'puppet/parser/ast/not'
 require 'puppet/parser/ast/resource'
@@ -118,3 +131,4 @@ require 'puppet/parser/ast/resourceparam'
 require 'puppet/parser/ast/selector'
 require 'puppet/parser/ast/tag'
 require 'puppet/parser/ast/vardef'
+require 'puppet/parser/ast/relationship'

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

@@ -2,40 +2,38 @@ require 'puppet'
 require 'puppet/parser/ast/branch'
 
 class Puppet::Parser::AST
-    class ArithmeticOperator < AST::Branch
+  class ArithmeticOperator < AST::Branch
 
-        attr_accessor :operator, :lval, :rval
+    attr_accessor :operator, :lval, :rval
 
-        # Iterate across all of our children.
-        def each
-            [@lval,@rval,@operator].each { |child| yield child }
-        end
+    # 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)
-            lval = Puppet::Parser::Scope.number?(lval)
-            if lval == nil
-                raise ArgumentError, "left operand of %s is not a number" % @operator
-            end
-            rval = @rval.safeevaluate(scope)
-            rval = Puppet::Parser::Scope.number?(rval)
-            if rval == nil
-                raise ArgumentError, "right operand of %s is not a number" % @operator
-            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)
+      lval = Puppet::Parser::Scope.number?(lval)
+      if lval == nil
+        raise ArgumentError, "left operand of #{@operator} is not a number"
+      end
+      rval = @rval.safeevaluate(scope)
+      rval = Puppet::Parser::Scope.number?(rval)
+      if rval == nil
+        raise ArgumentError, "right operand of #{@operator} is not a number"
+      end
 
-            # compute result
-            lval.send(@operator, rval)
-        end
+      # compute result
+      lval.send(@operator, rval)
+    end
 
-        def initialize(hash)
-            super
+    def initialize(hash)
+      super
 
-            unless %w{+ - * / << >>}.include?(@operator)
-                raise ArgumentError, "Invalid arithmetic operator %s" % @operator
-            end
-        end
+      raise ArgumentError, "Invalid arithmetic operator #{@operator}" unless %w{+ - * / << >>}.include?(@operator)
     end
+  end
 end