puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/util/provider_features.rb

@@ -0,0 +1,168 @@
+# Provides feature definitions.
+require 'puppet/util/methodhelper'
+require 'puppet/util/docs'
+require 'puppet/util'
+module Puppet::Util::ProviderFeatures
+  include Puppet::Util::Docs
+  # The class that models the features and handles checking whether the features
+  # are present.
+  class ProviderFeature
+    include Puppet::Util
+    include Puppet::Util::MethodHelper
+    include Puppet::Util::Docs
+    attr_accessor :name, :docs, :methods
+
+    # Are all of the requirements met?
+    def available?(obj)
+      if self.methods
+        return !!methods_available?(obj)
+      else
+        # In this case, the provider has to declare support for this
+        # feature, and that's been checked before we ever get to the
+        # method checks.
+        return false
+      end
+    end
+
+    def initialize(name, docs, hash)
+      self.name = name.intern
+      self.docs = docs
+      hash = symbolize_options(hash)
+      set_options(hash)
+    end
+
+    private
+
+    # Are all of the required methods available?
+    def methods_available?(obj)
+      methods.each do |m|
+        if obj.is_a?(Class)
+          return false unless obj.public_method_defined?(m)
+        else
+          return false unless obj.respond_to?(m)
+        end
+      end
+      true
+    end
+  end
+
+  # Define one or more features.  At a minimum, features require a name
+  # and docs, and at this point they should also specify a list of methods
+  # required to determine if the feature is present.
+  def feature(name, docs, hash = {})
+    @features ||= {}
+    raise(Puppet::DevError, "Feature #{name} is already defined") if @features.include?(name)
+    begin
+      obj = ProviderFeature.new(name, docs, hash)
+      @features[obj.name] = obj
+    rescue ArgumentError => detail
+      error = ArgumentError.new(
+        "Could not create feature #{name}: #{detail}"
+      )
+      error.set_backtrace(detail.backtrace)
+      raise error
+    end
+  end
+
+  # Return a hash of all feature documentation.
+  def featuredocs
+    str = ""
+    @features ||= {}
+    return nil if @features.empty?
+    names = @features.keys.sort { |a,b| a.to_s <=> b.to_s }
+    names.each do |name|
+      doc = @features[name].docs.gsub(/\n\s+/, " ")
+      str += "- *#{name}*: #{doc}\n"
+    end
+
+    if providers.length > 0
+      headers = ["Provider", names].flatten
+      data = {}
+      providers.each do |provname|
+        data[provname] = []
+        prov = provider(provname)
+        names.each do |name|
+          if prov.feature?(name)
+            data[provname] << "*X*"
+          else
+            data[provname] << ""
+          end
+        end
+      end
+      str += doctable(headers, data)
+    end
+    str
+  end
+
+  # Return a list of features.
+  def features
+    @features ||= {}
+    @features.keys
+  end
+
+  # Generate a module that sets up the boolean methods to test for given
+  # features.
+  def feature_module
+    unless defined?(@feature_module)
+      @features ||= {}
+      @feature_module = ::Module.new
+      const_set("FeatureModule", @feature_module)
+      features = @features
+      # Create a feature? method that can be passed a feature name and
+      # determine if the feature is present.
+      @feature_module.send(:define_method, :feature?) do |name|
+        method = name.to_s + "?"
+        return !!(respond_to?(method) and send(method))
+      end
+
+      # Create a method that will list all functional features.
+      @feature_module.send(:define_method, :features) do
+        return false unless defined?(features)
+        features.keys.find_all { |n| feature?(n) }.sort { |a,b|
+          a.to_s <=> b.to_s
+        }
+      end
+
+      # Create a method that will determine if a provided list of
+      # features are satisfied by the curred provider.
+      @feature_module.send(:define_method, :satisfies?) do |*needed|
+        ret = true
+        needed.flatten.each do |feature|
+          unless feature?(feature)
+            ret = false
+            break
+          end
+        end
+        ret
+      end
+
+      # Create a boolean method for each feature so you can test them
+      # individually as you might need.
+      @features.each do |name, feature|
+        method = name.to_s + "?"
+        @feature_module.send(:define_method, method) do
+          (is_a?(Class) ?  declared_feature?(name) : self.class.declared_feature?(name)) or feature.available?(self)
+        end
+      end
+
+      # Allow the provider to declare that it has a given feature.
+      @feature_module.send(:define_method, :has_features) do |*names|
+        @declared_features ||= []
+        names.each do |name|
+          @declared_features << name.intern
+        end
+      end
+      # Aaah, grammatical correctness
+      @feature_module.send(:alias_method, :has_feature, :has_features)
+    end
+    @feature_module
+  end
+
+  # Return the actual provider feature instance.  Really only used for testing.
+  def provider_feature(name)
+    return nil unless defined?(@features)
+
+    @features[name]
+  end
+end
+

data/lib/vendor/puppet/util/pson.rb

@@ -0,0 +1,13 @@
+# A simple module to provide consistency between how we use PSON and how
+# ruby expects it to be used.  Basically, we don't want to require
+# that the sender specify a class.
+#  Ruby wants everyone to provide a 'type' field, and the PSON support
+# requires such a field to track the class down.  Because we use our URL to
+# figure out what class we're working on, we don't need that, and we don't want
+# our consumers and producers to need to know anything about our internals.
+module Puppet::Util::Pson
+  def pson_create(pson)
+    raise ArgumentError, "No data provided in pson data" unless pson['data']
+    from_pson(pson['data'])
+  end
+end

data/lib/vendor/puppet/util/queue/stomp.rb

@@ -0,0 +1,60 @@
+require 'puppet/util/queue'
+require 'stomp'
+require 'uri'
+
+# Implements the Ruby Stomp client as a queue type within the
+# Puppet::Indirector::Queue::Client registry, for use with the <tt>:queue</tt>
+# indirection terminus type.
+#
+# Looks to <tt>Puppet[:queue_source]</tt> for the sole argument to the
+# underlying Stomp::Client constructor; consequently, for this client to work,
+# <tt>Puppet[:queue_source]</tt> must use the Stomp::Client URL-like syntax
+# for identifying the Stomp message broker: <em>login:pass@host.port</em>
+class Puppet::Util::Queue::Stomp
+  attr_accessor :stomp_client
+
+  def initialize
+    begin
+      uri = URI.parse(Puppet[:queue_source])
+    rescue => detail
+      raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is invalid: #{detail}"
+    end
+    unless uri.scheme == "stomp"
+      raise ArgumentError, "Could not create Stomp client instance - queue source #{Puppet[:queue_source]} is not a Stomp URL: #{detail}"
+    end
+
+    begin
+      self.stomp_client = Stomp::Client.new(uri.user, uri.password, uri.host, uri.port, true)
+    rescue => detail
+      raise ArgumentError, "Could not create Stomp client instance with queue source #{Puppet[:queue_source]}: got internal Stomp client error #{detail}"
+    end
+
+    # Identify the supported method for sending messages.
+    @method =
+      case
+      when stomp_client.respond_to?(:publish)
+        :publish
+      when stomp_client.respond_to?(:send)
+        :send
+      else
+        raise ArgumentError, "STOMP client does not respond to either publish or send"
+      end
+  end
+
+  def publish_message(target, msg)
+    stomp_client.__send__(@method, stompify_target(target), msg, :persistent => true)
+  end
+
+  def subscribe(target)
+    stomp_client.subscribe(stompify_target(target), :ack => :client) do |stomp_message|
+      yield(stomp_message.body)
+      stomp_client.acknowledge(stomp_message)
+    end
+  end
+
+  def stompify_target(target)
+    '/queue/' + target.to_s
+  end
+
+  Puppet::Util::Queue.register_queue_type(self, :stomp)
+end

data/lib/vendor/puppet/util/queue.rb

@@ -0,0 +1,96 @@
+
+require 'puppet/indirector'
+require 'puppet/util/instance_loader'
+
+# Implements a message queue client type plugin registry for use by the indirector facility.
+# Client modules for speaking a particular protocol (e.g. Stomp::Client for Stomp message
+# brokers, Memcached for Starling and Sparrow, etc.) register themselves with this module.
+#
+# Client classes are expected to live under the Puppet::Util::Queue namespace and corresponding
+# directory; the attempted use of a client via its typename (see below) will cause Puppet::Util::Queue
+# to attempt to load the corresponding plugin if it is not yet loaded.  The client class registers itself
+# with Puppet::Util::Queue and should use the same type name as the autloader expects for the plugin file.
+#   class Puppet::Util::Queue::SpecialMagicalClient < Messaging::SpecialMagic
+#       ...
+#       Puppet::Util::Queue.register_queue_type_class(self)
+#   end
+#
+# This module reduces the rightmost segment of the class name into a pretty symbol that will
+# serve as the queuing client's name.  Which means that the "SpecialMagicalClient" above will
+# be named <em>:special_magical_client</em> within the registry.
+#
+# Another class/module may mix-in this module, and may then make use of the registered clients.
+#   class Queue::Fue
+#       # mix it in at the class object level rather than instance level
+#       extend ::Puppet::Util::Queue
+#   end
+#
+# Queue::Fue instances can get a message queue client through the registry through the mixed-in method
+# +client+, which will return a class-wide singleton client instance, determined by +client_class+.
+#
+# The client plugins are expected to implement an interface similar to that of Stomp::Client:
+# * <tt>new</tt> should return a connected, ready-to-go client instance.  Note that no arguments are passed in.
+# * <tt>publish_message(queue, message)</tt> should publish the _message_ to the specified _queue_.
+# * <tt>subscribe(queue)</tt> _block_ subscribes to _queue_ and executes _block_ upon receiving a message.
+# * _queue_ names are simple names independent of the message broker or client library.  No "/queue/" prefixes like in Stomp::Client.
+module Puppet::Util::Queue
+  extend Puppet::Util::InstanceLoader
+  instance_load :queue_clients, 'puppet/util/queue'
+
+  # Adds a new class/queue-type pair to the registry.  The _type_ argument is optional; if not provided,
+  # _type_ defaults to a lowercased, underscored symbol programmatically derived from the rightmost
+  # namespace of <em>klass.name</em>.
+  #
+  #   # register with default name +:you+
+  #   register_queue_type(Foo::You)
+  #
+  #   # register with explicit queue type name +:myself+
+  #   register_queue_type(Foo::Me, :myself)
+  #
+  # If the type is already registered, an exception is thrown.  No checking is performed of _klass_,
+  # however; a given class could be registered any number of times, as long as the _type_ differs with
+  # each registration.
+  def self.register_queue_type(klass, type = nil)
+    type ||= queue_type_from_class(klass)
+    raise Puppet::Error, "Queue type #{type} is already registered" if instance_hash(:queue_clients).include?(type)
+    instance_hash(:queue_clients)[type] = klass
+  end
+
+  # Given a queue type symbol, returns the associated +Class+ object.  If the queue type is unknown
+  # (meaning it hasn't been registered with this module), an exception is thrown.
+  def self.queue_type_to_class(type)
+    c = loaded_instance :queue_clients, type
+    raise Puppet::Error, "Queue type #{type} is unknown." unless c
+    c
+  end
+
+  # Given a class object _klass_, returns the programmatic default queue type name symbol for _klass_.
+  # The algorithm is as shown in earlier examples; the last namespace segment of _klass.name_ is taken
+  # and converted from mixed case to underscore-separated lowercase, and interned.
+  #   queue_type_from_class(Foo) -> :foo
+  #   queue_type_from_class(Foo::Too) -> :too
+  #   queue_type_from_class(Foo::ForYouTwo) -> :for_you_too
+  #
+  # The implicit assumption here, consistent with Puppet's approach to plugins in general,
+  # is that all your client modules live in the same namespace, such that reduction to
+  # a flat namespace of symbols is reasonably safe.
+  def self.queue_type_from_class(klass)
+    # convert last segment of classname from studly caps to lower case with underscores, and symbolize
+    klass.name.split('::').pop.sub(/^[A-Z]/) {|c| c.downcase}.gsub(/[A-Z]/) {|c| '_' + c.downcase }.intern
+  end
+
+  # The class object for the client to be used, determined by queue configuration
+  # settings.
+  # Looks to the <tt>:queue_type</tt> configuration entry in the running application for
+  # the default queue type to use.
+  def client_class
+    Puppet::Util::Queue.queue_type_to_class(Puppet[:queue_type])
+  end
+
+  # Returns (instantiating as necessary) the singleton queue client instance, according to the
+  # client_class.  No arguments go to the client class constructor, meaning its up to the client class
+  # to know how to determine its queue message source (presumably through Puppet configuration data).
+  def client
+    @client ||= client_class.new
+  end
+end

data/lib/vendor/puppet/util/rails/cache_accumulator.rb

@@ -0,0 +1,65 @@
+require 'puppet/util'
+
+module Puppet::Util::CacheAccumulator
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  class Base
+    attr_reader :klass, :attribute
+
+    def initialize(klass, attribute)
+      @klass = klass
+      @attribute = attribute
+      @find_or_create = "find_or_create_by_#{@attribute.to_s}".intern
+    end
+
+    def store
+      @store || reset
+    end
+
+    def reset
+      @store = {}
+    end
+
+    def find(*keys)
+      result = nil
+      if keys.length == 1
+        result = store[keys[0]] ||= @klass.send(@find_or_create, *keys)
+      else
+        found, missing = keys.partition {|k| store.include? k}
+        result = found.length
+        result += do_multi_find(missing) if missing.length > 0
+      end
+      result
+    end
+
+    def do_multi_find(keys)
+      result = 0
+      @klass.find(:all, :conditions => {@attribute => keys}).each do |obj|
+        store[obj.send(@attribute)] = obj
+        result += 1
+      end
+      result
+    end
+  end
+
+  module ClassMethods
+    def accumulates(*attributes)
+      attributes.each {|attrib| install_accumulator(attrib)}
+    end
+
+    def accumulators
+      @accumulators ||= {}
+    end
+
+    def install_accumulator(attribute)
+      self.accumulators[attribute] = Base.new(self, attribute)
+      module_eval %{
+        def self.accumulate_by_#{attribute.to_s}(*keys)
+          accumulators[:#{attribute.to_s}].find(*keys)
+        end
+      }
+    end
+  end
+end

data/lib/vendor/puppet/util/rails/collection_merger.rb

@@ -0,0 +1,17 @@
+module Puppet::Util::CollectionMerger
+  def ar_hash_merge(db_hash, mem_hash, args)
+    (db_hash.keys | mem_hash.keys).each do |key|
+      if (db_hash[key] && mem_hash[key])
+        # in both, update value
+        args[:modify].call(db_hash[key], mem_hash[key])
+      elsif (db_hash[key])
+        # in db, not memory, delete from database
+        args[:delete].call(db_hash[key])
+      else
+        # in mem, not in db, insert into the database
+        args[:create].call(key, mem_hash[key])
+      end
+    end
+  end
+end
+

data/lib/vendor/puppet/util/rails/reference_serializer.rb

@@ -0,0 +1,32 @@
+
+module Puppet::Util::ReferenceSerializer
+  def unserialize_value(val)
+    case val
+    when /^--- /
+      YAML.load(val)
+    when "true"
+      true
+    when "false"
+      false
+    else
+      val
+    end
+  end
+
+  def serialize_value(val)
+    case val
+    when Puppet::Resource
+      YAML.dump(val)
+    when true, false
+      # The database does this for us, but I prefer the
+      # methods be their exact inverses.
+      # Note that this means quoted booleans get returned
+      # as actual booleans, but there doesn't appear to be
+      # a way to fix that while keeping the ability to
+      # search for parameters set to true.
+      val.to_s
+    else
+      val
+    end
+  end
+end

data/lib/vendor/puppet/util/rdoc.rb

@@ -0,0 +1,87 @@
+
+module Puppet::Util::RDoc
+
+  module_function
+
+  # launch a rdoc documenation process
+  # with the files/dir passed in +files+
+  def rdoc(outputdir, files, charset = nil)
+      Puppet[:ignoreimport] = true
+
+      # then rdoc
+      require 'rdoc/rdoc'
+      require 'rdoc/options'
+
+      # load our parser
+      require 'puppet/util/rdoc/parser'
+
+      r = RDoc::RDoc.new
+
+      RDoc::RDoc::GENERATORS["puppet"] = RDoc::RDoc::Generator.new(
+          "puppet/util/rdoc/generators/puppet_generator.rb",
+          "PuppetGenerator".intern,
+          "puppet")
+
+      # specify our own format & where to output
+      options = [ "--fmt", "puppet",
+                  "--quiet",
+                  "--exclude", "/modules/[^/]*/files/.*$",
+                  "--exclude", "/modules/[^/]*/templates/.*$",
+                  "--op", outputdir ]
+
+      options << "--force-update" if Options::OptionList.options.any? { |o| o[0] == "--force-update" }
+      options += [ "--charset", charset] if charset
+      options += files
+      #TODO dedup file paths (not strict duplication sense, parents, children, etc
+
+      # launch the documentation process
+      r.document(options)
+  rescue RDoc::RDocError => e
+      raise Puppet::ParseError.new("RDoc error #{e}")
+  end
+
+  # launch a output to console manifest doc
+  def manifestdoc(files)
+    Puppet[:ignoreimport] = true
+    files.select { |f| FileTest.file?(f) }.each do |f|
+      parser = Puppet::Parser::Parser.new(Puppet::Node::Environment.new(Puppet[:environment]))
+      parser.file = f
+      ast = parser.parse
+      output(f, ast)
+    end
+  end
+
+  # Ouputs to the console the documentation
+  # of a manifest
+  def output(file, ast)
+    astobj = []
+    ast.instantiate('').each do |resource_type|
+      astobj << resource_type if resource_type.file == file
+    end
+
+    astobj.sort! {|a,b| a.line <=> b.line }.each do |k|
+      output_astnode_doc(k)
+    end
+  end
+
+  def output_astnode_doc(ast)
+    puts ast.doc if !ast.doc.nil? and !ast.doc.empty?
+    if Puppet.settings[:document_all]
+      # scan each underlying resources to produce documentation
+      code = ast.code.children if ast.code.is_a?(Puppet::Parser::AST::ASTArray)
+      code ||= ast.code
+      output_resource_doc(code) unless code.nil?
+    end
+  end
+
+  def output_resource_doc(code)
+    code.sort { |a,b| a.line <=> b.line }.each do |stmt|
+      output_resource_doc(stmt.children) if stmt.is_a?(Puppet::Parser::AST::ASTArray)
+
+      if stmt.is_a?(Puppet::Parser::AST::Resource)
+        puts stmt.doc if !stmt.doc.nil? and !stmt.doc.empty?
+      end
+    end
+  end
+
+end

data/lib/vendor/puppet/util/reference.rb

@@ -0,0 +1,124 @@
+require 'puppet/util/instance_loader'
+require 'fileutils'
+
+# Manage Reference Documentation.
+class Puppet::Util::Reference
+  include Puppet::Util
+  include Puppet::Util::Docs
+
+  extend Puppet::Util::InstanceLoader
+
+  instance_load(:reference, 'puppet/reference')
+
+  def self.footer
+    "\n\n----------------\n\n*This page autogenerated on #{Time.now}*\n"
+  end
+
+  def self.modes
+    %w{pdf text}
+  end
+
+  def self.newreference(name, options = {}, &block)
+    ref = self.new(name, options, &block)
+    instance_hash(:reference)[name.intern] = ref
+
+    ref
+  end
+
+  def self.page(*sections)
+    depth = 4
+    # Use the minimum depth
+    sections.each do |name|
+      section = reference(name) or raise "Could not find section #{name}"
+      depth = section.depth if section.depth < depth
+    end
+  end
+
+  def self.pdf(text)
+    puts "creating pdf"
+    rst2latex = which('rst2latex') || which('rst2latex.py') ||
+      raise("Could not find rst2latex")
+
+    cmd = %{#{rst2latex} /tmp/puppetdoc.txt > /tmp/puppetdoc.tex}
+    Puppet::Util.replace_file("/tmp/puppetdoc.txt") {|f| f.puts text }
+    # There used to be an attempt to use secure_open / replace_file to secure
+    # the target, too, but that did nothing: the race was still here.  We can
+    # get exactly the same benefit from running this effort:
+    File.unlink('/tmp/puppetdoc.tex') rescue nil
+    output = %x{#{cmd}}
+    unless $CHILD_STATUS == 0
+      $stderr.puts "rst2latex failed"
+      $stderr.puts output
+      exit(1)
+    end
+    $stderr.puts output
+
+    # Now convert to pdf
+    Dir.chdir("/tmp") do
+      %x{texi2pdf puppetdoc.tex >/dev/null 2>/dev/null}
+    end
+
+  end
+
+  def self.references
+    instance_loader(:reference).loadall
+    loaded_instances(:reference).sort { |a,b| a.to_s <=> b.to_s }
+  end
+
+  attr_accessor :page, :depth, :header, :title, :dynamic
+  attr_writer :doc
+
+  def doc
+    if defined?(@doc)
+      return "#{@name} - #{@doc}"
+    else
+      return @title
+    end
+  end
+
+  def dynamic?
+    self.dynamic
+  end
+
+  def initialize(name, options = {}, &block)
+    @name = name
+    options.each do |option, value|
+      send(option.to_s + "=", value)
+    end
+
+    meta_def(:generate, &block)
+
+    # Now handle the defaults
+    @title ||= "#{@name.to_s.capitalize} Reference"
+    @page ||= @title.gsub(/\s+/, '')
+    @depth ||= 2
+    @header ||= ""
+  end
+
+  # Indent every line in the chunk except those which begin with '..'.
+  def indent(text, tab)
+    text.gsub(/(^|\A)/, tab).gsub(/^ +\.\./, "..")
+  end
+
+  def option(name, value)
+    ":#{name.to_s.capitalize}: #{value}\n"
+  end
+
+  def text
+    puts output
+  end
+
+  def to_markdown(withcontents = true)
+    # First the header
+    text = markdown_header(@title, 1)
+    text << "\n\n**This page is autogenerated; any changes will get overwritten** *(last generated on #{Time.now.to_s})*\n\n"
+
+    text << @header
+
+    text << generate
+
+    text << self.class.footer if withcontents
+
+    text
+  end
+end