puppet-parse 0.0.1 → 0.0.2

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

@@ -0,0 +1,74 @@
+require 'puppet/parser/ast/resource_reference'
+
+# Any normal puppet resource declaration.  Can point to a definition or a
+# builtin type.
+class Puppet::Parser::AST
+class Resource < AST::Branch
+
+  associates_doc
+
+  attr_accessor :type, :instances, :exported, :virtual
+
+  # Does not actually return an object; instead sets an object
+  # in the current scope.
+  def evaluate(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
+
+    # First level of implicit iteration: build a resource for each
+    # instance.  This handles things like:
+    # file { '/foo': owner => blah; '/bar': owner => blah }
+    @instances.collect { |instance|
+
+      # Evaluate all of the specified params.
+      paramobjects = instance.parameters.collect { |param|
+        param.safeevaluate(scope)
+      }
+
+      resource_titles = instance.title.safeevaluate(scope)
+
+      # it's easier to always use an array, even for only one name
+      resource_titles = [resource_titles].flatten.collect do |title|
+        case title
+        when ::String, ::Numeric, ::Symbol, true, false
+          title.to_s
+        else
+          raise Puppet::ParseError, "Resource title must be a String, not #{title.class}"
+        end
+      end
+
+      fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type, resource_titles)
+
+      # Second level of implicit iteration; build a resource for each
+      # title.  This handles things like:
+      # file { ['/foo', '/bar']: owner => blah }
+      resource_titles.collect { |resource_title|
+        exceptwrap :type => Puppet::ParseError do
+          resource = Puppet::Parser::Resource.new(
+            fully_qualified_type, resource_title,
+            :parameters => paramobjects,
+            :file => self.file,
+            :line => self.line,
+            :exported => self.exported,
+            :virtual => virt,
+            :source => scope.source,
+            :scope => scope,
+            :strict => true
+          )
+
+          if resource.resource_type.is_a? Puppet::Resource::Type
+            resource.resource_type.instantiate_resource(scope, resource)
+          end
+          scope.compiler.add_resource(scope, resource)
+          scope.compiler.evaluate_classes([resource_title],scope,false) if fully_qualified_type == 'class'
+          resource
+        end
+      }
+    }.flatten.reject { |resource| resource.nil? }
+  end
+end
+end

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

@@ -0,0 +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, :parameters
+
+    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.new(@type, "whatever")
+      type = ref.type
+      params = @parameters.safeevaluate(scope)
+
+      parsewrap do
+        scope.setdefaults(type, params)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  class ResourceInstance < Branch
+    # A simple container for a parameter for an object.  Consists of a
+    # title and a set of parameters.
+    attr_accessor :title, :parameters
+  end
+end

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

@@ -0,0 +1,67 @@
+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 < AST::Branch
+
+    associates_doc
+
+    attr_accessor :object, :parameters
+
+    # 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)
+
+      hash = {}
+
+      # Evaluate all of the specified params.
+      params = @parameters.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)
+
+      resource = resource.collect do |r|
+
+              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)
+
+        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
+
+      #self.typecheck(@type.value)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'puppet/parser/ast'
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST::ResourceReference < Puppet::Parser::AST::Branch
+  attr_accessor :title, :type
+
+  # Evaluate our object, but just return a simple array of the type
+  # and name.
+  def evaluate(scope)
+    titles = Array(title.safeevaluate(scope)).flatten
+
+    a_type, titles = scope.resolve_type_and_titles(type, titles)
+
+    resources = titles.collect{ |a_title|
+      Puppet::Resource.new(a_type, a_title)
+    }
+
+    return(resources.length == 1 ? resources.pop : resources)
+  end
+
+  def to_s
+    if title.is_a?(Puppet::Parser::AST::ASTArray)
+      "#{type.to_s.capitalize}#{title}"
+    else
+      "#{type.to_s.capitalize}[#{title}]"
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # The AST object for the parameters inside ResourceDefs and Selectors.
+  class ResourceParam < AST::Branch
+    attr_accessor :value, :param, :add
+
+    def each
+      [@param,@value].each { |child| yield child }
+    end
+
+    # Return the parameter and the value.
+    def evaluate(scope)
+
+            return Puppet::Parser::Resource::Param.new(
+                
+        :name => @param,
+        :value => @value.safeevaluate(scope),
+        
+        :source => scope.source, :line => self.line, :file => self.file,
+        :add => self.add
+      )
+    end
+
+    def to_s
+      "#{@param} => #{@value.to_s}"
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # The inline conditional operator.  Unlike CaseStatement, which executes
+  # code, we just return a value.
+  class Selector < AST::Branch
+    attr_accessor :param, :values
+
+    def each
+      [@param,@values].each { |child| yield child }
+    end
+
+    # Find the value that corresponds with the test.
+    def evaluate(scope)
+      level = scope.ephemeral_level
+      # Get our parameter.
+      paramvalue = @param.safeevaluate(scope)
+
+      default = nil
+
+      @values = [@values] unless @values.instance_of? AST::ASTArray or @values.instance_of? Array
+
+      # Then look for a match in the options.
+      @values.each do |obj|
+        # short circuit asap if we have a match
+        return obj.value.safeevaluate(scope) if obj.param.evaluate_match(paramvalue, scope)
+
+        # Store the default, in case it's necessary.
+        default = obj if obj.param.is_a?(Default)
+      end
+
+      # Unless we found something, look for the default.
+      return default.value.safeevaluate(scope) if default
+
+      self.fail Puppet::ParseError, "No matching value for selector param '#{paramvalue}'"
+    ensure
+      scope.unset_ephemeral_var(level)
+    end
+
+    def to_s
+      param.to_s + " ? { " + values.collect { |v| v.to_s }.join(', ') + " }"
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # The code associated with a class.  This is different from components
+  # in that each class is a singleton -- only one will exist for a given
+  # node.
+  class Tag < AST::Branch
+    @name = :class
+    attr_accessor :type
+
+    def evaluate(scope)
+      types = @type.safeevaluate(scope)
+
+      types = [types] unless types.is_a? Array
+
+      types.each do |type|
+        # Now set our class.  We don't have to worry about checking
+        # whether we've been evaluated because we're not evaluating
+        # any code.
+        scope.setclass(self.object_id, type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+# The base class for AST nodes representing top level things:
+# hostclasses, definitions, and nodes.
+class Puppet::Parser::AST::TopLevelConstruct < Puppet::Parser::AST
+end

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

@@ -0,0 +1,33 @@
+require 'puppet/parser/ast/branch'
+
+class Puppet::Parser::AST
+  # Define a variable.  Stores the value in the current scope.
+  class VarDef < AST::Branch
+
+    associates_doc
+
+    attr_accessor :name, :value, :append
+
+    @settor = true
+
+    # Look up our name and value, and store them appropriately.  The
+    # lexer strips off the syntax stuff like '$'.
+    def evaluate(scope)
+      value = @value.safeevaluate(scope)
+      if name.is_a?(HashOrArrayAccess)
+        name.assign(scope, value)
+      else
+        name = @name.safeevaluate(scope)
+
+        parsewrap do
+          scope.setvar(name,value, :file => file, :line => line, :append => @append)
+        end
+      end
+    end
+
+    def each
+      [@name,@value].each { |child| yield child }
+    end
+  end
+
+end

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

@@ -0,0 +1,139 @@
+# the parent class for all of our syntactical objects
+
+require 'puppet'
+require 'puppet/util/autoload'
+
+# The base class for all of the objects that make up the parse trees.
+# 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
+
+  include Puppet::Util::Errors
+  include Puppet::Util::MethodHelper
+  include Puppet::Util::Docs
+
+  attr_accessor :parent, :scope, :file, :line
+
+  def inspect
+    "( #{self.class} #{self.to_s} #{@children.inspect} )"
+  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
+  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 #{self.class}"
+  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
+  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
+
+  # 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) or (obj == :undef and value == "")
+  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/boolean_operator'
+require 'puppet/parser/ast/branch'
+require 'puppet/parser/ast/caseopt'
+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/relationship'
+require 'puppet/parser/ast/resource'
+require 'puppet/parser/ast/resource_defaults'
+require 'puppet/parser/ast/resource_instance'
+require 'puppet/parser/ast/resource_override'
+require 'puppet/parser/ast/resource_reference'
+require 'puppet/parser/ast/resourceparam'
+require 'puppet/parser/ast/selector'
+require 'puppet/parser/ast/tag'
+require 'puppet/parser/ast/vardef'

data/lib/vendor/puppet/parser/collector.rb

@@ -0,0 +1,176 @@
+# An object that collects stored objects from the central cache and returns
+# them to the current host, yo.
+class Puppet::Parser::Collector
+  attr_accessor :type, :scope, :vquery, :equery, :form, :resources, :overrides, :collected
+
+  # Call the collection method, mark all of the returned objects as
+  # non-virtual, optionally applying parameter overrides. The collector can
+  # also delete himself from the compiler if there is no more resources to
+  # collect (valid only for resource fixed-set collector which get their
+  # resources from +collect_resources+ and not from the catalog)
+  def evaluate
+    # Shortcut if we're not using storeconfigs and they're trying to collect
+    # exported resources.
+    if form == :exported and Puppet[:storeconfigs] != true
+      Puppet.warning "Not collecting exported resources without storeconfigs"
+      return false
+    end
+
+    if self.resources
+      unless objects = collect_resources and ! objects.empty?
+        return false
+      end
+    else
+      method = "collect_#{@form.to_s}"
+      objects = send(method).each do |obj|
+        obj.virtual = false
+      end
+      return false if objects.empty?
+    end
+
+    # we have an override for the collected resources
+    if @overrides and !objects.empty?
+      # force the resource to be always child of any other resource
+      overrides[:source].meta_def(:child_of?) do
+        true
+      end
+
+      # tell the compiler we have some override for him unless we already
+      # overrided those resources
+      objects.each do |res|
+        unless @collected.include?(res.ref)
+          newres = Puppet::Parser::Resource.
+            new(res.type, res.title,
+                :parameters => overrides[:parameters],
+                :file       => overrides[:file],
+                :line       => overrides[:line],
+                :source     => overrides[:source],
+                :scope      => overrides[:scope])
+
+          scope.compiler.add_override(newres)
+        end
+      end
+    end
+
+    # filter out object that this collector has previously found.
+    objects.reject! { |o| @collected.include?(o.ref) }
+
+    return false if objects.empty?
+
+    # keep an eye on the resources we have collected
+    objects.inject(@collected) { |c,o| c[o.ref]=o; c }
+
+    # return our newly collected resources
+    objects
+  end
+
+  def initialize(scope, type, equery, vquery, form)
+    @scope  = scope
+    @vquery = vquery
+    @equery = equery
+
+    # initialisation
+    @collected = {}
+
+    # Canonize the type
+    @type = Puppet::Resource.new(type, "whatever").type
+
+    unless [:exported, :virtual].include?(form)
+      raise ArgumentError, "Invalid query form #{form}"
+    end
+    @form = form
+  end
+
+  # add a resource override to the soon to be exported/realized resources
+  def add_override(hash)
+    raise ArgumentError, "Exported resource try to override without parameters" unless hash[:parameters]
+
+    # schedule an override for an upcoming collection
+    @overrides = hash
+  end
+
+  private
+
+  # Collect exported objects.
+  def collect_exported
+    resources = []
+
+    time = Puppet::Util.thinmark do
+      # First get everything from the export table.  Just reuse our
+      # collect_virtual method but tell it to use 'exported? for the test.
+      resources = collect_virtual(true).reject { |r| ! r.virtual? }
+
+      # key is '#{type}/#{name}', and host and filter.
+      found = Puppet::Resource.indirection.
+        search(@type, :host => @scope.host, :filter => @equery, :scope => @scope)
+
+      found_resources = found.map {|x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope)}
+
+      found_resources.each do |item|
+        if existing = @scope.findresource(item.type, item.title)
+          unless existing.collector_id == item.collector_id
+            # unless this is the one we've already collected
+            raise Puppet::ParseError,
+              "Another local or imported resource exists with the type and title #{item.ref}"
+          end
+        else
+          item.exported = false
+          @scope.compiler.add_resource(@scope, item)
+          resources << item
+        end
+      end
+    end
+
+    scope.debug("Collected %s %s resource%s in %.2f seconds" %
+                [resources.length, @type, resources.length == 1 ? "" : "s", time])
+
+    resources
+  end
+
+  def collect_resources
+    @resources = [@resources] unless @resources.is_a?(Array)
+    method = "collect_#{form.to_s}_resources"
+    send(method)
+  end
+
+  def collect_exported_resources
+    raise Puppet::ParseError, "realize() is not yet implemented for exported resources"
+  end
+
+  # Collect resources directly; this is the result of using 'realize',
+  # which specifies resources, rather than using a normal collection.
+  def collect_virtual_resources
+    return [] unless defined?(@resources) and ! @resources.empty?
+    result = @resources.dup.collect do |ref|
+      if res = @scope.findresource(ref.to_s)
+        @resources.delete(ref)
+        res
+      end
+    end.reject { |r| r.nil? }.each do |res|
+      res.virtual = false
+    end
+
+    # If there are no more resources to find, delete this from the list
+    # of collections.
+    @scope.compiler.delete_collection(self) if @resources.empty?
+
+    result
+  end
+
+  # Collect just virtual objects, from our local compiler.
+  def collect_virtual(exported = false)
+    scope.compiler.resources.find_all do |resource|
+      resource.type == @type and (exported ? resource.exported? : true) and match?(resource)
+    end
+  end
+
+  # Does the resource match our tests?  We don't yet support tests,
+  # so it's always true at the moment.
+  def match?(resource)
+    if self.vquery
+      return self.vquery.call(resource)
+    else
+      return true
+    end
+  end
+end