puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/parameter.rb

@@ -0,0 +1,316 @@
+require 'puppet/util/methodhelper'
+require 'puppet/util/log_paths'
+require 'puppet/util/logging'
+require 'puppet/util/docs'
+
+class Puppet::Parameter
+  include Puppet::Util
+  include Puppet::Util::Errors
+  include Puppet::Util::LogPaths
+  include Puppet::Util::Logging
+  include Puppet::Util::MethodHelper
+
+  require 'puppet/parameter/value_collection'
+
+  class << self
+    include Puppet::Util
+    include Puppet::Util::Docs
+    attr_reader :validater, :munger, :name, :default, :required_features, :value_collection
+    attr_accessor :metaparam
+
+    # Define the default value for a given parameter or parameter.  This
+    # means that 'nil' is an invalid default value.  This defines
+    # the 'default' instance method.
+    def defaultto(value = nil, &block)
+      if block
+        define_method(:default, &block)
+      else
+        if value.nil?
+          raise Puppet::DevError,
+            "Either a default value or block must be provided"
+        end
+        define_method(:default) do value end
+      end
+    end
+
+    # Return a documentation string.  If there are valid values,
+    # then tack them onto the string.
+    def doc
+      @doc ||= ""
+
+      unless defined?(@addeddocvals)
+        @doc += value_collection.doc
+
+        if f = self.required_features
+          @doc += "  Requires features #{f.flatten.collect { |f| f.to_s }.join(" ")}."
+        end
+        @addeddocvals = true
+      end
+
+      @doc
+    end
+
+    def nodefault
+      undef_method :default if public_method_defined? :default
+    end
+
+    # Store documentation for this parameter.
+    def desc(str)
+      @doc = str
+    end
+
+    def initvars
+      @value_collection = ValueCollection.new
+    end
+
+    # This is how we munge the value.  Basically, this is our
+    # opportunity to convert the value from one form into another.
+    def munge(&block)
+      # I need to wrap the unsafe version in begin/rescue parameterments,
+      # but if I directly call the block then it gets bound to the
+      # class's context, not the instance's, thus the two methods,
+      # instead of just one.
+      define_method(:unsafe_munge, &block)
+    end
+
+    # Does the parameter support reverse munging?
+    # This will be called when something wants to access the parameter
+    # in a canonical form different to what the storage form is.
+    def unmunge(&block)
+      define_method(:unmunge, &block)
+    end
+
+    # Mark whether we're the namevar.
+    def isnamevar
+      @isnamevar = true
+      @required = true
+    end
+
+    # Is this parameter the namevar?  Defaults to false.
+    def isnamevar?
+      @isnamevar
+    end
+
+    # This parameter is required.
+    def isrequired
+      @required = true
+    end
+
+    # Specify features that are required for this parameter to work.
+    def required_features=(*args)
+      @required_features = args.flatten.collect { |a| a.to_s.downcase.intern }
+    end
+
+    # Is this parameter required?  Defaults to false.
+    def required?
+      @required
+    end
+
+    # Verify that we got a good value
+    def validate(&block)
+      define_method(:unsafe_validate, &block)
+    end
+
+    # Define a new value for our parameter.
+    def newvalues(*names)
+      @value_collection.newvalues(*names)
+    end
+
+    def aliasvalue(name, other)
+      @value_collection.aliasvalue(name, other)
+    end
+  end
+
+  # Just a simple method to proxy instance methods to class methods
+  def self.proxymethods(*values)
+    values.each { |val|
+      define_method(val) do
+        self.class.send(val)
+      end
+    }
+  end
+
+  # And then define one of these proxies for each method in our
+  # ParamHandler class.
+  proxymethods("required?", "isnamevar?")
+
+  attr_accessor :resource
+  # LAK 2007-05-09: Keep the @parent around for backward compatibility.
+  attr_accessor :parent
+
+  [:line, :file, :version].each do |param|
+    define_method(param) do
+      resource.send(param)
+    end
+  end
+
+  def devfail(msg)
+    self.fail(Puppet::DevError, msg)
+  end
+
+  def fail(*args)
+    type = nil
+    if args[0].is_a?(Class)
+      type = args.shift
+    else
+      type = Puppet::Error
+    end
+
+    error = type.new(args.join(" "))
+
+    error.line = @resource.line if @resource and @resource.line
+
+    error.file = @resource.file if @resource and @resource.file
+
+    raise error
+  end
+
+  # Basic parameter initialization.
+  def initialize(options = {})
+    options = symbolize_options(options)
+    if resource = options[:resource]
+      self.resource = resource
+      options.delete(:resource)
+    else
+      raise Puppet::DevError, "No resource set for #{self.class.name}"
+    end
+
+    set_options(options)
+  end
+
+  def log(msg)
+    send_log(resource[:loglevel], msg)
+  end
+
+  # Is this parameter a metaparam?
+  def metaparam?
+    self.class.metaparam
+  end
+
+  # each parameter class must define the name method, and parameter
+  # instances do not change that name this implicitly means that a given
+  # object can only have one parameter instance of a given parameter
+  # class
+  def name
+    self.class.name
+  end
+
+  # for testing whether we should actually do anything
+  def noop
+    @noop ||= false
+    tmp = @noop || self.resource.noop || Puppet[:noop] || false
+    #debug "noop is #{tmp}"
+    tmp
+  end
+
+  # return the full path to us, for logging and rollback; not currently
+  # used
+  def pathbuilder
+    if @resource
+      return [@resource.pathbuilder, self.name]
+    else
+      return [self.name]
+    end
+  end
+
+  # If the specified value is allowed, then munge appropriately.
+  # If the developer uses a 'munge' hook, this method will get overridden.
+  def unsafe_munge(value)
+    self.class.value_collection.munge(value)
+  end
+
+  # no unmunge by default
+  def unmunge(value)
+    value
+  end
+
+  # A wrapper around our munging that makes sure we raise useful exceptions.
+  def munge(value)
+    begin
+      ret = unsafe_munge(value)
+    rescue Puppet::Error => detail
+      Puppet.debug "Reraising #{detail}"
+      raise
+    rescue => detail
+      raise Puppet::DevError, "Munging failed for value #{value.inspect} in class #{self.name}: #{detail}", detail.backtrace
+    end
+    ret
+  end
+
+  # Verify that the passed value is valid.
+  # If the developer uses a 'validate' hook, this method will get overridden.
+  def unsafe_validate(value)
+    self.class.value_collection.validate(value)
+  end
+
+  # A protected validation method that only ever raises useful exceptions.
+  def validate(value)
+    begin
+      unsafe_validate(value)
+    rescue ArgumentError => detail
+      fail detail.to_s
+    rescue Puppet::Error, TypeError
+      raise
+    rescue => detail
+      raise Puppet::DevError, "Validate method failed for class #{self.name}: #{detail}", detail.backtrace
+    end
+  end
+
+  def remove
+    @resource = nil
+  end
+
+  def value
+    unmunge(@value) unless @value.nil?
+  end
+
+  # Store the value provided.  All of the checking should possibly be
+  # late-binding (e.g., users might not exist when the value is assigned
+  # but might when it is asked for).
+  def value=(value)
+    validate(value)
+
+    @value = munge(value)
+  end
+
+  # Retrieve the resource's provider.  Some types don't have providers, in which
+  # case we return the resource object itself.
+  def provider
+    @resource.provider
+  end
+
+  # The properties need to return tags so that logs correctly collect them.
+  def tags
+    unless defined?(@tags)
+      @tags = []
+      # This might not be true in testing
+      @tags = @resource.tags if @resource.respond_to? :tags
+      @tags << self.name.to_s
+    end
+    @tags
+  end
+
+  def to_s
+    name.to_s
+  end
+
+  def self.format_value_for_display(value)
+    if value.is_a? Array
+      formatted_values = value.collect {|value| format_value_for_display(value)}.join(', ')
+      "[#{formatted_values}]"
+    elsif value.is_a? Hash
+      # Sorting the hash keys for display is largely for having stable
+      # output to test against, but also helps when scanning for hash
+      # keys, since they will be in ASCIIbetical order.
+      hash = value.keys.sort {|a,b| a.to_s <=> b.to_s}.collect do |k|
+        "'#{k}' => #{format_value_for_display(value[k])}"
+      end.join(', ')
+
+      "{#{hash}}"
+    else
+      "'#{value}'"
+    end
+  end
+end
+
+require 'puppet/parameter/path'

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

@@ -0,0 +1,39 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class ArithmeticOperator < 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)
+      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
+
+    def initialize(hash)
+      super
+
+      raise ArgumentError, "Invalid arithmetic operator #{@operator}" unless %w{+ - * / << >>}.include?(@operator)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+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)
+      result = []
+      @children.each do |child|
+        # Skip things that respond to :instantiate (classes, nodes,
+        # and definitions), because they have already been
+        # instantiated.
+        if !child.respond_to?(:instantiate)
+          item = child.safeevaluate(scope)
+          if !item.nil?
+            # nil values are implicitly removed.
+            result.push(item)
+          end
+        end
+      end
+      result
+    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)
+      }
+
+      self
+    end
+
+    def to_s
+      "[" + @children.collect { |c| c.to_s }.join(', ') + "]"
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/asthash.rb

@@ -0,0 +1,37 @@
+require 'puppet/parser/ast/leaf'
+
+class Puppet::Parser::AST
+  class ASTHash < Leaf
+    include Enumerable
+
+    # Evaluate our children.
+    def evaluate(scope)
+      items = {}
+
+      @value.each_pair do |k,v|
+        key = k.respond_to?(:safeevaluate) ? k.safeevaluate(scope) : k
+        items.merge!({ key => v.safeevaluate(scope) })
+      end
+
+      items
+    end
+
+    def merge(hash)
+      case hash
+      when ASTHash
+        @value = @value.merge(hash.value)
+      when Hash
+        @value = @value.merge(hash)
+      end
+    end
+
+    def to_s
+      "{" + @value.collect { |v| v.collect { |a| a.to_s }.join(' => ') }.join(', ') + "}"
+    end
+
+    def initialize(args)
+      super(args)
+      @value ||= {}
+    end
+  end
+end

data/lib/vendor/puppet/parser/ast/boolean_operator.rb

@@ -0,0 +1,46 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class BooleanOperator < 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 first operand, should return a boolean value
+      lval = @lval.safeevaluate(scope)
+
+      # return result
+      # lazy evaluate right operand
+      case @operator
+      when "and"
+        if Puppet::Parser::Scope.true?(lval)
+          rval = @rval.safeevaluate(scope)
+          Puppet::Parser::Scope.true?(rval)
+        else # false and false == false
+          false
+        end
+      when "or"
+        if Puppet::Parser::Scope.true?(lval)
+          true
+        else
+          rval = @rval.safeevaluate(scope)
+          Puppet::Parser::Scope.true?(rval)
+        end
+      end
+    end
+
+    def initialize(hash)
+      super
+
+      raise ArgumentError, "Invalid boolean operator #{@operator}" unless %w{and or}.include?(@operator)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+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.
+      @children ||= []
+
+      # Verify that we only got valid AST nodes.
+      @children.each { |child|
+        unless child.is_a?(AST)
+          raise Puppet::DevError,
+            "child #{child} is a #{child.class} instead of ast"
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'puppet/parser/ast/branch'
+
+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?
+      # Cache the @default value.
+      return @default if defined?(@default)
+
+      @value.each { |subval|
+        if subval.is_a?(AST::Default)
+          @default = true
+          break
+        end
+      }
+
+      @default ||= false
+
+      @default
+    end
+
+    # You can specify a list of values; return each in turn.
+    def eachvalue(scope)
+      @value.each { |subval|
+        yield subval.safeevaluate(scope)
+      }
+    end
+
+    def eachopt
+      @value.each { |subval|
+        yield subval
+      }
+    end
+
+    # Evaluate the actual statements; this only gets called if
+    # our option matched.
+    def evaluate(scope)
+      @statements.safeevaluate(scope)
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'puppet/parser/ast/branch'
+
+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
+
+    associates_doc
+
+    # Short-curcuit evaluation.  Return the value of the statements for
+    # the first option that matches.
+    def evaluate(scope)
+      level = scope.ephemeral_level
+
+      value = @test.safeevaluate(scope)
+
+      retvalue = nil
+      found = false
+
+      # Iterate across the options looking for a match.
+      default = nil
+      @options.each do |option|
+        option.eachopt do |opt|
+          return option.safeevaluate(scope) if opt.evaluate_match(value, scope)
+        end
+
+        default = option if option.default?
+      end
+
+      # Unless we found something, look for the default.
+      return default.safeevaluate(scope) if default
+
+      Puppet.debug "No true answers and no default"
+      return nil
+    ensure
+      scope.unset_ephemeral_var(level)
+    end
+
+    def each
+      [@test,@options].each { |child| yield child }
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'puppet'
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/collector'
+
+# An object that collects stored objects from the central cache and returns
+# them to the current host, yo.
+class Puppet::Parser::AST
+  class Collection < AST::Branch
+    attr_accessor :type, :query, :form
+    attr_reader :override
+
+    associates_doc
+
+    # We return an object that does a late-binding evaluation.
+    def evaluate(scope)
+      match, code = query && query.safeevaluate(scope)
+
+      resource_type = scope.find_resource_type(@type)
+      fail "Resource type #{@type} doesn't exist" unless resource_type
+      newcoll = Puppet::Parser::Collector.new(scope, resource_type.name, match, code, self.form)
+
+      scope.compiler.add_collection(newcoll)
+
+      # overrides if any
+      # Evaluate all of the specified params.
+      if @override
+        params = @override.collect { |param| param.safeevaluate(scope) }
+        newcoll.add_override(
+          :parameters => params,
+          :file       => @file,
+          :line       => @line,
+          :source     => scope.source,
+          :scope      => scope
+        )
+      end
+
+      newcoll
+    end
+
+    # Handle our parameter ourselves
+    def override=(override)
+      @override = if override.is_a?(AST::ASTArray)
+        override
+      else
+        AST::ASTArray.new(:line => override.line,:file => override.file,:children => [override])
+      end
+    end
+  end
+end