snappycode-shadow_puppet 0.3.2

data/LICENSE

@@ -0,0 +1,165 @@
+       GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.rdoc

@@ -0,0 +1,11 @@
+= ShadowPuppet
+
+ShadowPuppet is a Ruby DSL for Puppet, extracted out of the work we at Rails
+Machine are doing on Moonshine[http://blog.railsmachine.com/articles/2009/01/16/moonshine-configuration-management-and-deployment/].
+
+ShadowPuppet provides a DSL for creating collections ("manifests") of Puppet
+Resources in Ruby. For documentation on writing these manifests, please see
+ShadowPuppet::Manifest.
+
+A binary[http://railsmachine.github.com/shadow_puppet/files/bin/shadow_puppet.html] is provided to parse and execute a
+ShadowPuppet::Manifest.

data/bin/shadow_puppet

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+#== Sample manifest:
+#
+#  $ cat examples/foo.rb
+#  class Foo < ShadowPuppet::Manifest
+#   recipe :demo, :text => 'foo'
+#   recipe :some_gems
+#
+#   def some_gems
+#     package 'rails', :ensure => :updated, :provider => :gem
+#     package 'railsmachine', :ensure => '1.0.5', :provider => :gem, :require => package('capistrano')
+#     package 'capistrano', :ensure => :updated, :provider => :gem
+#   end
+#
+#   def demo(options = {})
+#     exec 'sample', :command => "echo '#{options[:text]}' > /tmp/sample.txt"
+#     file '/tmp/sample2.txt', :ensure => :present, :content => Facter.to_hash.inspect
+#   end
+# end
+#
+#== Executing this manifest:
+#
+#  $ shadow_puppet examples/foo.rb
+#  notice: /shadow_puppet:19861340/Exec[foo]/returns: executed successfully
+#  $
+#
+#The shadow_puppet binary parses the given ruby code, which is
+#expected to contain a class named Foo that inherits from
+#ShadowPuppet::Manifest. An instance of this class is created, and the
+#<tt>execute</tt> method is called. All output is printed to the console.
+
+begin
+
+  require 'optparse'
+  opts = OptionParser.new do |opts|
+    opts.banner = <<-EOF
+    NAME
+      Shadow Puppet
+
+    AUTHOR
+      Jesse Newland
+      jesse@railsmachine.com
+
+    DESCRIPTION
+      A Ruby DSL for puppet
+
+    EXAMPLES
+      Sample manifest:
+
+        #foo.rb
+        class Foo < ShadowPuppet::Manifest
+          recipe :foo
+
+          def foo
+            exec :foo, :command => 'echo "foo" > /tmp/foo.txt'
+            file '/tmp/example.txt', :ensure => :present, :content => Facter.to_hash.inspect
+          end
+        end
+
+      Executing this manifest:
+
+        $ shadow_puppet foo.rb
+        notice: /shadow_puppet:19861340/Exec[foo]/returns: executed successfully
+        $
+
+      The shadow_puppet binary parses the given ruby code, which is
+      expected to contain a class named Foo that inherits from
+      ShadowPuppet::Manifest. An instance of this class is created, and the
+      execute method is called. All output is printed to the console.
+  EOF
+
+  end
+
+  opts.parse!
+
+  require 'rubygems'
+  require 'shadow_puppet'
+  require 'active_support/inflector'
+  require 'active_support/core_ext/string/inflections'
+  unless String.included_modules.include?(ActiveSupport::CoreExtensions::String::Inflections)
+    String.send :include, ActiveSupport::CoreExtensions::String::Inflections
+  end
+  require 'fileutils'
+
+  filename = ARGV[0]
+  raise ArgumentError unless filename
+
+  klass = File.basename(filename, ".rb")
+  require filename
+  manifest = klass.classify.constantize.new
+  manifest.execute! && exit(0)
+rescue Errno::EACCES
+  puts "Please run shadow_puppet as root"
+rescue Exception => e
+  if e.instance_of?(SystemExit)
+    raise
+  else
+    puts 'Uncaught exception'
+    puts e.class
+    puts e.message
+    puts e.backtrace.join("\n")
+    exit(1)
+  end
+end

data/examples/foo.rb

@@ -0,0 +1,15 @@
+class Foo < ShadowPuppet::Manifest
+  recipe :demo, :text => 'foo'
+  recipe :some_gems
+
+  def some_gems
+    package 'rails', :ensure => :updated, :provider => :gem
+    package 'railsmachine', :ensure => '1.0.5', :provider => :gem, :require => package('capistrano')
+    package 'capistrano', :ensure => :updated, :provider => :gem
+  end
+
+  def demo(options = {})
+    exec 'sample', :command => "echo '#{options[:text]}' > /tmp/sample.txt"
+    file '/tmp/sample2.txt', :ensure => :present, :content => Facter.to_hash.inspect
+  end
+end

data/lib/shadow_puppet.rb

@@ -0,0 +1,30 @@
+require 'puppet'
+require 'erb'
+require File.join(File.dirname(__FILE__) + '/shadow_puppet', 'core_ext.rb')
+require File.join(File.dirname(__FILE__) + '/shadow_puppet', 'manifest.rb')
+
+class ShadowPuppet::Manifest::Setup < ShadowPuppet::Manifest
+  recipe :setup_directories
+
+  def setup_directories()
+    if Process.uid == 0
+      file "/var/shadow_puppet",
+        :ensure => "directory",
+        :backup => false
+      file "/etc/shadow_puppet",
+        :ensure => "directory",
+        :backup => false
+    else
+      file ENV["HOME"] + "/.shadow_puppet",
+        :ensure => "directory",
+        :backup => false
+      file ENV["HOME"] + "/.shadow_puppet/var",
+        :ensure   => "directory",
+        :backup   => false,
+        :require  => file(ENV["HOME"] + "/.shadow_puppet")
+    end
+  end
+end
+
+setup = ShadowPuppet::Manifest::Setup.new
+setup.execute

data/lib/shadow_puppet/core_ext.rb

@@ -0,0 +1,24 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/array'
+require 'active_support/inflector'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/object/duplicable'
+class Hash #:nodoc:
+  def deep_merge(other_hash)
+    self.merge(other_hash) do |key, oldval, newval|
+      oldval = oldval.to_hash if oldval.respond_to?(:to_hash)
+      newval = newval.to_hash if newval.respond_to?(:to_hash)
+      oldval.is_a?(Hash) && newval.is_a?(Hash) ? oldval.deep_merge(newval) : newval
+    end
+  end
+  def deep_merge!(other_hash)
+    replace(deep_merge(other_hash))
+  end
+  def deep_symbolize_keys
+    self.inject({}) { |result, (key, value)|
+      value = value.deep_symbolize_keys if value.is_a?(Hash)
+      result[(key.to_sym rescue key) || key] = value
+      result
+    }
+  end
+end

data/lib/shadow_puppet/manifest.rb

@@ -0,0 +1,372 @@
+module ShadowPuppet
+  # A Manifest is an executable collection of Puppet Resources[http://reductivelabs.com/trac/puppet/wiki/TypeReference].
+  #
+  # ===Example
+  #
+  #   class ManifestExample < ShadowPuppet::Manifest
+  #     recipe :sample
+  #     recipe :lamp, :ruby               # queue calls to self.lamp and
+  #                                       # self.ruby when executing
+  #
+  #     recipe :mysql, {                  # queue a call to self.mysql
+  #       :root_password => 'OMGSEKRET'   # passing the provided hash
+  #     }                                 # as an option
+  #
+  #     def sample
+  #       exec :foo, :command => 'echo "foo" > /tmp/foo.txt'
+  #
+  #       package :foo, :ensure => :installed
+  #
+  #       file '/tmp/example.txt',
+  #         :ensure   => :present,
+  #         :contents => Facter.to_hash_inspect,
+  #         :require  => package(:foo)
+  #     end
+  #
+  #     def lamp
+  #       #install a basic LAMP stack
+  #     end
+  #
+  #     def ruby
+  #       #install a ruby interpreter and tools
+  #     end
+  #
+  #     def mysql(options)
+  #        #install a mysql server and set the root password to options[:root_password]
+  #     end
+  #
+  #   end
+  #
+  # To execute the above manifest, instantiate it and call execute on it:
+  #
+  #   m = ManifestExample.new
+  #   m.execute
+  #
+  # As shown in the +sample+ method in ManifestExample above, instance
+  # methods are created for each Puppet::Type available on your system. These
+  # methods behave identally to the Puppet Resources methods. See here[http://reductivelabs.com/trac/puppet/wiki/TypeReference]
+  # for documentation on these methods.
+  #
+  # To view a list of all defined methods on your system, run:
+  #
+  #    ruby -rubygems -e 'require "shadow_puppet";puts ShadowPuppet::Manifest.puppet_type_methods'
+  #
+  # The use of methods (+sample+, +lamp+, +ruby+, and +mysql+ above) as a
+  # container for resources facilitates recipie re-use through the use of Ruby
+  # Modules. For example:
+  #
+  #   module ApachePuppet
+  #     # Required options:
+  #     #   domain
+  #     #   path
+  #     def php_vhost(options)
+  #       #...
+  #     end
+  #    end
+  #
+  #   class MyWebMainfest < ShadowPuppet::Manifest
+  #     include ApachePuppet
+  #     recipe :php_vhost, {
+  #       :domain => 'foo.com',
+  #       :path => '/var/www/apps/foo'
+  #     }
+  #   end
+  class Manifest
+
+    class_inheritable_accessor :recipes
+    write_inheritable_attribute(:recipes, [])
+    attr_reader :puppet_resources
+    class_inheritable_accessor :__config__
+    write_inheritable_attribute(:__config__, Hash.new)
+
+    # Initialize a new instance of this manifest. This can take a
+    # config hash, which is immediately passed on to the configure
+    # method
+    def initialize(config = {})
+      if Process.uid == 0
+        Puppet[:confdir] = File.expand_path("/etc/shadow_puppet")
+        Puppet[:vardir] = File.expand_path("/var/shadow_puppet")
+      else
+        Puppet[:confdir] = File.expand_path("~/.shadow_puppet")
+        Puppet[:vardir] = File.expand_path("~/.shadow_puppet/var")
+      end
+      Puppet[:user] = Process.uid
+      Puppet[:group] = Process.gid
+      Puppet::Util::Log.newdestination(:console)
+
+      configure(config)
+      @executed = false
+      @puppet_resources = Hash.new do |hash, key|
+        hash[key] = {}
+      end
+    end
+
+    # Declares that the named method or methods will be called whenever
+    # execute is called on an instance of this class. If the last argument is
+    # a Hash, this hash is passed as an argument to all provided methods.
+    # If no options hash is provided, each method is passed the contents of
+    # <tt>configuration[method]</tt>.
+    #
+    # Subclasses of the Manifest class properly inherit the parent classes'
+    # calls to recipe.
+    def self.recipe(*methods)
+      return nil if methods.nil? || methods == []
+      options = methods.extract_options!
+      methods.each do |meth|
+        options = configuration[meth.to_sym] if options == {}
+        options ||= {}
+        recipes << [meth.to_sym, options]
+      end
+    end
+
+    # A hash describing any configuration that has been
+    # performed on the class. Modify this hash by calling configure:
+    #
+    #   class SampleManifest < ShadowPuppet::Manifest
+    #     configure(:name => 'test')
+    #   end
+    #
+    #   >> SampleManifest.configuration
+    #   => {:name => 'test'}
+    #
+    # All keys on this hash are coerced into symbols for ease of access.
+    #
+    # Subclasses of the Manifest class properly inherit the parent classes'
+    # configuration.
+    def self.configuration
+      __config__.deep_symbolize_keys
+    end
+
+    # Access to the configuration of the class of this instance.
+    #
+    #   class SampleManifest < ShadowPuppet::Manifest
+    #     configure(:name => 'test')
+    #   end
+    #
+    #   @manifest = SampleManifest.new
+    #   @manifest.configuration[:name] => "test"
+    def configuration
+      self.class.configuration
+    end
+
+    # Define configuration on this manifest. This is useful for storing things
+    # such as hostnames, password, or usernames that may change between
+    # different implementations of a shared manifest. Access this hash by
+    # calling <tt>configuration</tt>:
+    #
+    #   class SampleManifest < ShadowPuppet::Manifest
+    #     configure('name' => 'test')
+    #   end
+    #
+    #   >> SampleManifest.configuration
+    #   => {:name => 'test'}
+    #
+    # All keys on this hash are coerced into symbols for ease of access.
+    #
+    # Subsequent calls to configure perform a deep_merge of the provided
+    # <tt>hash</tt> into the pre-existing configuration.
+    def self.configure(hash)
+      __config__.deep_merge!(hash)
+    end
+
+    # Update the configuration of this manifest instance's class.
+    #
+    #   class SampleManifest < ShadowPuppet::Manifest
+    #     configure({})
+    #   end
+    #
+    #   @manifest = SampleManifest.new
+    #   @manifest.configure(:name => "test")
+    #   @manifest.configuration[:name] => "test"
+    def configure(hash)
+      self.class.configure(hash)
+    end
+    alias_method :configuration=, :configure
+
+    #An array of all methods defined for creation of Puppet Resources
+    def self.puppet_type_methods
+      Puppet::Type.eachtype { |t| t.name }.keys.map { |n| n.to_s }.sort.inspect
+    end
+
+    def name
+      @name ||= "#{self.class}##{self.object_id}"
+    end
+
+    #Create an instance method for every type that either creates or references
+    #a resource
+    def self.register_puppet_types
+      Puppet::Type.loadall
+      Puppet::Type.eachtype do |type|
+        #remove the method rdoc placeholders
+        remove_method(type.name) rescue nil
+        define_method(type.name) do |*args|
+          if args && args.flatten.size == 1
+            reference(type.name, args.first)
+          else
+            new_resource(type, args.first, args.last)
+          end
+        end
+      end
+    end
+    register_puppet_types
+
+    # Returns true if this Manifest <tt>respond_to?</tt> all methods named by
+    # calls to recipe, and if this Manifest has not been executed before.
+    def executable?
+      self.class.recipes.each do |meth,args|
+        return false unless respond_to?(meth)
+      end
+      return false if executed?
+      true
+    end
+
+    def missing_recipes
+      missing = self.class.recipes.each do |meth,args|
+        !respond_to?(meth)
+      end
+    end
+
+    # Execute this manifest, applying all resources defined. Execute returns
+    # true if successfull, and false if unsucessfull. By default, this
+    # will only execute a manifest that has not already been executed?.
+    # The +force+ argument, if true, removes this check.
+    def execute(force=false)
+      return false if executed? && !force
+      evaluate_recipes
+      apply
+    rescue Exception => e
+      false
+    else
+      true
+    ensure
+      @executed = true
+    end
+
+    # Execute this manifest, applying all resources defined. Execute returns
+    # true if successfull, and raises an exception if not. By default, this
+    # will only execute a manifest that has not already been executed?.
+    # The +force+ argument, if true, removes this check.
+    def execute!(force=false)
+      return false if executed? && !force
+      evaluate_recipes
+      apply
+    rescue Exception => e
+      raise e
+    else
+      true
+    ensure
+      @executed = true
+    end
+
+    protected
+
+    #Has this manifest instance been executed?
+    def executed?
+      @executed
+    end
+
+    #An Array of all currently defined resources.
+    def flat_resources
+      a = []
+      @puppet_resources.each_value do |by_type|
+        by_type.each_value do |by_name|
+          a << by_name
+        end
+      end
+      a
+    end
+
+    #A Puppet::TransBucket of all defined resoureces.
+    def export
+      transportable_objects = flat_resources.dup.reject { |a| a.nil? }.flatten.collect do |obj|
+        obj.to_trans
+      end
+      b = Puppet::TransBucket.new(transportable_objects)
+      b.name = name
+      b.type = "class"
+
+      return b
+    end
+
+    private
+
+    #Evaluate the methods calls queued in self.recipes
+    def evaluate_recipes
+      self.class.recipes.each do |meth, args|
+        case arity = method(meth).arity
+        when 1, -1
+          send(meth, args)
+        else
+          send(meth)
+        end
+      end
+    end
+
+    # Create a catalog of all contained Puppet Resources and apply that
+    # catalog to the currently running system
+    def apply(bucket = nil)
+      bucket ||= export()
+      catalog = bucket.to_catalog
+      catalog.apply
+      catalog.clear
+    end
+
+    def scope #:nodoc:
+      unless defined?(@scope)
+        # Set the code to something innocuous; we just need the
+        # scopes, not the interpreter.  Hackish, but true.
+        Puppet[:code] = " "
+        @interp = Puppet::Parser::Interpreter.new
+        require 'puppet/node'
+        @node = Puppet::Node.new(Facter.value(:hostname))
+        if env = Puppet[:environment] and env == ""
+          env = nil
+        end
+        @node.parameters = Facter.to_hash
+        @compile = Puppet::Parser::Compiler.new(@node, @interp.send(:parser, env))
+        @scope = @compile.topscope
+      end
+      @scope
+    end
+
+    #Create a reference to another Puppet Resource.
+    def reference(type, title)
+      Puppet::Parser::Resource::Reference.new(:type => type.to_s, :title => title.to_s, :scope => scope)
+    end
+
+    #Creates a new Puppet Resource.
+    def new_resource(type, name, params = {})
+      unless obj = @puppet_resources[type][name]
+        obj = Puppet::Parser::Resource.new(
+          :title => name,
+          :type => type.name,
+          :source => self,
+          :scope => scope
+        )
+        @puppet_resources[type][name] = obj
+      end
+
+      case type.name
+      when :exec
+        param = Puppet::Parser::Resource::Param.new(
+          :name => :path,
+          :value => ENV["PATH"],
+          :source => self
+        )
+        obj.send(:set_parameter, param)
+      end
+
+      params.each do |param_name, param_value|
+        param = Puppet::Parser::Resource::Param.new(
+          :name => param_name,
+          :value => param_value,
+          :source => self
+        )
+        obj.send(:set_parameter, param)
+      end
+
+      obj
+    end
+
+  end
+end

data/lib/shadow_puppet/test.rb

@@ -0,0 +1,69 @@
+module Puppet
+  module Parser
+    class Resource
+
+      # clearing out some puppet methods that we probably won't need for testing
+      # that are also used in the params hash when defining the resource.
+      undef path
+      undef source
+      undef require
+      
+      # This allows access to resource options as methods on the resource.
+      def method_missing name, *args
+        if params.keys.include? name.to_sym
+          params[name.to_sym].value
+        end
+      end
+    end
+  end
+end
+
+module ShadowPuppet
+  # To test manifests, access puppet resources using the plural form of the resource name.
+  # This returns a hash of all resources of that type.
+  #
+  #   manifest.execs
+  #   manifest.packages
+  #
+  # You can access resource options as methods on the resource
+  #
+  #   manifest.files['/etc/motd'].content
+  #   manifest.execs['service ssh restart'].onlyif
+  #
+  # ===Example
+  #
+  # Given this manifest:
+  #
+  #   class TestManifest < ShadowPuppet::Manifest
+  #     def myrecipe
+  #       file '/etc/motd', :content => 'Welcome to the machine!', :mode => '644'
+  #       exec 'newaliases', :refreshonly => true
+  #     end
+  #     recipe :myrecipe
+  #   end
+  #
+  # A test for the manifest could look like this:
+  #  
+  #   manifest = TestManifest.new
+  #   manifest.myrecipe
+  #   assert_match /Welcome/, manifest.files['/etc/motd']
+  #   assert manifest.execs['newaliases'].refreshonly
+  #
+  class Manifest
+    # Creates an instance method for every puppet type 
+    # that either creates or references a resource
+    def self.register_puppet_types_for_testing
+      Puppet::Type.loadall
+      Puppet::Type.eachtype do |type|
+        plural_type = type.name.to_s.downcase.pluralize
+        #undefine the method rdoc placeholders
+        undef_method(plural_type) rescue nil
+        define_method(plural_type) do |*args|
+          puppet_resources[type]
+        end
+      end
+    end
+    register_puppet_types_for_testing
+    
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification 
+name: snappycode-shadow_puppet
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 2
+  version: 0.3.2
+platform: ruby
+authors: 
+- Jesse Newland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-15 00:00:00 +00:00
+default_executable: shadow_puppet
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: puppet
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 24
+        - 8
+        version: 0.24.8
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: facter
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 4
+        version: 1.5.4
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id005
+description: A Ruby Puppet DSL
+email: 
+- jesse@railsmachine.com
+executables: 
+- shadow_puppet
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- bin/shadow_puppet
+files: 
+- README.rdoc
+- LICENSE
+- bin/shadow_puppet
+- examples/foo.rb
+- lib/shadow_puppet.rb
+- lib/shadow_puppet/manifest.rb
+- lib/shadow_puppet/core_ext.rb
+- lib/shadow_puppet/test.rb
+has_rdoc: true
+homepage: http://railsmachine.github.com/shadow_puppet
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --inline-source
+- --webcvs=http://github.com/railsmachine/shadow_puppet/tree/master/
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: moonshine
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: A Ruby Puppet DSL
+test_files: []
+