warningshot 0.9.4 → 0.9.5

data/lib/warningshot/config.rb

@@ -0,0 +1,254 @@
+require File.dirname(__FILE__) / 'warning_shot' 
+require File.dirname(__FILE__) / 'template_generator'
+ 
+# This is a factory class for creating WarningShot hash configurations.
+#   Configurations can be created by passing a hash or block to
+#     WarningShot::Config.create
+#   OR
+#     By calling WarningShot::Config.parse_args (for command line, uses ARGV)
+#
+#   It also provies an interface for plugins to extend the CLI
+#     Config.cli => Provides access to add stuff to command line
+#     Config.cli_options => Provides a hash to store values into from within the OptionParser block
+#
+#   The resolver class also provides functions of the same name that shortcut to WarningShot::Config
+#
+# @example
+#   class WarningShot::MyResolver
+#     cli("-s", "--someflag=VALUE", String, "Add some feature") do |value|
+#       options[:some_value] = value
+#     end
+#
+module WarningShot
+  module Config
+    attr_reader :configuration
+    PARSER    = OptionParser.new
+
+    DEFAULTS  = {
+      :pload        => [],
+      :oload        => [],
+      :environment  => 'development',
+      :resolve      => false,
+      :config_paths => ['.'  / 'config' / 'warningshot', '~' / '.warningshot'],
+      :application  => '.',
+      :log_path     => '.' / 'log' / 'warningshot.log',
+      :log_level    => :info,
+      :growl        => false,
+      :verbose      => false,
+      :colorize     => true,
+      :resolvers    => ['~' / '.warningshot' / '*.rb']
+    }.freeze
+  
+    class << self      
+      
+      # Add command line flags to tail of CLI
+      # shortcut to WarningSHot::Config::PARSER.on_tail
+      #
+      # @see OptionParser
+      # 
+      # @param *opts [Array]
+      #
+      # @param &block [Proc]
+      #
+      # @api public
+      def cli(*opts,&block)
+        PARSER.on_tail(*opts,&block)
+      end
+      
+      # access to a hash for command line options use for Plugin to extend interface
+      #
+      # @return [Hash]
+      def cli_options
+        @@cli_options ||={}
+        @@cli_options
+      end
+
+      #
+      # Initialize a new WarningShot config
+      # 
+      # @example
+      #   Setting config with a hash
+      #   conf = WarningShot::Config.create({:environment=>"staging",:chickens=>true})
+      #
+      #   Setting config with a block
+      #   conf = WarningShot::Config.create do |c|
+      #     c[:environment] = "production"
+      #     c[:cool_feature] = true
+      #   end
+      #
+      #   Just using default config
+      #   conf = WarningShot::Config.create
+      #
+      #   Using a hash and a block, block wins
+      #   conf = WarningShot::Config.create({:environment=>"hash",:something=>true}) do |c|
+      #     c[:environment] = "blk"
+      #     c[:else] = true
+      #   end
+      #
+      def create(config={})
+        opt_config = config
+        if block_given?
+          blk_config = {}
+          yield(blk_config)
+          opt_config = opt_config.merge(blk_config)
+        end
+        WarningShot::Config::DEFAULTS.clone.merge(opt_config)
+      end
+      
+      def parse_args(argv = ARGV)
+        @@cli_options = {}
+        @@cli_options[:environment] = ENV["WARNING_SHOT_ENV"] if ENV["WARNING_SHOT_ENV"]
+      
+        WarningShot::Config::PARSER.banner   = WarningShot.header
+        WarningShot::Config::PARSER.banner += "\n"
+        WarningShot::Config::PARSER.banner += "Dependency Resolution Framework\n\n"
+        WarningShot::Config::PARSER.banner += "Usage: warningshot [options]"
+
+
+        WarningShot::Config::PARSER.separator "Standard Flags".center(80,'-')   
+        WarningShot::Config::PARSER.on("-e=STRING", "--environment=STRING", String, "Environment to test in","Default: #{DEFAULTS[:environment]}") do |env|
+          @@cli_options[:environment] = env
+        end
+        WarningShot::Config::PARSER.on("--resolve","Resolve missing dependencies (probably need sudo)") do |resolve|
+          @@cli_options[:resolve] = resolve
+        end
+        WarningShot::Config::PARSER.on("-a=PATH","--app=PATH", String, "Path to application", "Default: #{DEFAULTS[:application]}") do |app|
+          @@cli_options[:application] = app
+        end
+        WarningShot::Config::PARSER.on("-c=PATH","--configs=PATH", String,"Path to config directories (':' seperated)","Default: #{DEFAULTS[:config_paths].join(':')}") do |config|
+          @@cli_options[:config_paths] = config.split(':')
+        end
+        
+
+        WarningShot::Config::PARSER.separator "Resolver Loading Flags".center(80,'-')   
+        WarningShot::Config::PARSER.on("-r=PATH","--resolvers=PATH", String,"Globs to add'l resolvers (':' seperated)","Default: #{DEFAULTS[:resolvers].join(':')}") do |config|
+          @@cli_options[:resolvers] = config.split(':')
+        end
+        WarningShot::Config::PARSER.on("--oload=LIST", String, "Only load specified resolvers (Command seperated)") do |oload|
+          @@cli_options[:oload] = oload.split(',')
+          WarningShot.only_load *@@cli_options[:oload]
+        end
+        WarningShot::Config::PARSER.on("--pload=LIST", String, "Load specified resolvers only, setting sequential priority (Command seperated)") do |pload|
+          @@cli_options[:pload] = pload.split(',')
+          WarningShot.only_load *@@cli_options[:pload]
+        end
+        
+
+        WarningShot::Config::PARSER.separator "Output Flags".center(80,'-')        
+        WarningShot::Config::PARSER.on("-l=LOG","--log=LOG", String, "Path to log file", "Default: #{DEFAULTS[:log_path]}") do |log_path|        
+          @@cli_options[:log_path] = log_path
+        end
+        WarningShot::Config::PARSER.on("--loglevel=LEVEL",[:debug, :info, :warn, :error, :fatal], "Default: #{DEFAULTS[:log_level]}") do |log_level|
+          @@cli_options[:log_level] = log_level
+        end
+        WarningShot::Config::PARSER.on("-g", "--growl", "Output results via growl (Requires growlnotify)") do |growl|
+          @@cli_options[:growl] = growl
+        end
+        WarningShot::Config::PARSER.on("-p", "--[no-]prettycolors", "Colorize output") do |colorize|
+          @@cli_options[:colorize] = colorize
+        end
+        WarningShot::Config::PARSER.on("-v", "--verbose", "Output verbose information") do |verbose|
+          @@cli_options[:verbose] = verbose
+        end
+        WarningShot::Config::PARSER.on("--very-verbose", "Outputs debugging information, same as --loglevel=DEBUG") do |verbose|
+          @@cli_options[:verbose]   = true
+          @@cli_options[:log_level] = :debug
+        end
+
+        
+        WarningShot::Config::PARSER.separator "Prestaging Flags".center(80,'-')        
+        WarningShot::Config::PARSER.on("--build-deps", "Installs gems that WarningShot resolvers depend on into standard RubyGems path (probably need sudo)") do |deps|
+          build_deps_config = WarningShot::Config.create
+          WarningShot.load_addl_resolvers build_deps_config[:resolvers]
+          
+          warningshot_gem_recipe = []
+          Resolver.descendants(false).each do |klass|
+            klass.depends_on[:gem].each{ |gem_dep| warningshot_gem_recipe.push(gem_dep) }
+          end
+          
+          gem_resolver = WarningShot::GemResolver.new build_deps_config, *warningshot_gem_recipe
+          gem_resolver.test!
+          
+          if gem_resolver.failed.length == 0
+            puts 'WarningShot is A-OK!!!'
+          else
+            gem_resolver.resolve!
+            gem_resolver.resolved.each{|res_gem| puts "[SUCCESS]\t\t#{res_gem.name}" }
+
+            gem_resolver.unresolved.each{|unres_gem| puts "[FAILURE]\t\t#{unres_gem.name}" }
+          end
+          
+          exit
+        end
+        WarningShot::Config::PARSER.on("--list-deps", "List all core libs and gems that each resolver is dependent on") do |deps|
+          puts WarningShot.header
+          puts "Resolvers' dependencies:"
+
+          Resolver.descendants(false).each do |klass|
+            puts "\n#{klass}"
+            puts "  Core Lib Dependencies:"
+            klass.depends_on[:core].each do |core|
+              puts "    [#{core[:installed] ? 'INSTALLED' : 'MISSING'}]\t\t#{core[:name]}"
+            end
+
+            puts "  Gem Dependencies:"
+            klass.depends_on[:gem].each do |gem|
+              puts "    [#{gem[:installed] ? 'INSTALLED' : 'MISSING'}]\t\t#{gem[:name]}"
+            end
+          end
+
+          exit
+        end
+        
+
+        WarningShot::Config::PARSER.separator "Help, Info, & Etc. Flags".center(80,'-')
+        WarningShot::Config::PARSER.on("-t[PATH]","--templates[PATH]", String, "Generate template files", "Default: .") do |template_path|
+          template_path = @@cli_options[:config_paths].first if template_path.nil? || template_path.empty?
+          WarningShot::TemplateGenerator.create(template_path)
+          exit
+        end
+        WarningShot::Config::PARSER.on("--version", "Show version"){ 
+          WarningShot::Config::PARSER.parse!(argv)
+          conf = WarningShot::Config.create(@@cli_options)
+          
+          WarningShot.load_app(conf[:application])
+          WarningShot.load_addl_resolvers(conf[:resolvers])
+          
+          puts WarningShot.header
+          puts "Installed resolvers:"
+            Resolver.descendants(false).each { |klass| 
+              puts "\n#{klass}"
+              puts "  Tests: #{klass.tests.length}, Resolutions: #{klass.resolutions.length} [#{klass.resolutions.empty? ? 'irresolvable' : 'resolvable'}]"
+              puts "  #{klass.description}" 
+            }
+          exit
+        }
+        WarningShot::Config::PARSER.on("-h", "--help","Show this help message") { puts WarningShot::Config::PARSER; exit } 
+        WarningShot::Config::PARSER.on("--debugger","Enable debugging") do
+          begin
+            require "ruby-debug"
+            Debugger.start
+            Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+            puts "Debugger enabled"
+          rescue LoadError => ex
+            puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+            exit
+          end
+        end
+        
+        
+        WarningShot::Config::PARSER.separator "Resolver Specific Flags".center(80,'-')
+        
+        WarningShot::Config::PARSER.parse!(argv)
+        
+        @curr_config  = @@cli_options.clone
+        @@cli_options = {}
+        return WarningShot::Config.create(@curr_config)
+      rescue OptionParser::InvalidOption, OptionParser::InvalidArgument,OptionParser::NeedlessArgument => op
+        puts op
+        puts WarningShot::Config::PARSER; 
+      end
+      
+    end #End self
+  end #End Config
+end#End WarningShot

data/lib/{warning_shot → warningshot}/dependency_resolver.rb

@@ -1,3 +1,8 @@
+require File.dirname(__FILE__) / 'warning_shot' 
+require File.dirname(__FILE__) / 'resolver' 
+require File.dirname(__FILE__) / 'config'
+require File.dirname(__FILE__) / 'logger'  
+
 module WarningShot
   class DependencyResolver
     
@@ -8,13 +13,19 @@ module WarningShot
       @dependency_tree  = {}
       @resolvers        = []
         
-      init_logger
+      self.init_logger
+      WarningShot.load_app(self[:application])
+      WarningShot.load_addl_resolvers(self[:resolvers])
             
       # Parsed yml files
       self.load_configs
       @dependency_tree.symbolize_keys!
     end
-    
+        
+    def [](k)
+      @config[k]  
+    end
+        
     # gets stats of all resolvers
     # @return [Hash] 
     #   :passed, :failed, :resolved, :unresolved
@@ -39,15 +50,15 @@ module WarningShot
     # 
     # @api private
     def init_logger
-      FileUtils.mkdir_p(File.dirname(File.expand_path(@config[:log_path]))) unless @config[:verbose]
+      FileUtils.mkdir_p(File.dirname(File.expand_path(self[:log_path]))) unless self[:verbose]
       
       @logger = Logger.new(
-        @config[:verbose] ? STDOUT : @config[:log_path], 10, 1024000
+        self[:verbose] ? STDOUT : self[:log_path], 10, 1024000
       )
-      _log_level = (@config[:log_level] || :debug).to_s.upcase
+      _log_level = (self[:log_level] || :info).to_s.upcase
 
       _formatter = WarningShot::LoggerFormatter.new
-      _formatter.colorize = @config[:colorize]
+      _formatter.colorize = self[:colorize]
 
       @logger.formatter = _formatter
       @logger.level     = Object.class_eval("Logger::#{_log_level}")
@@ -58,21 +69,26 @@ module WarningShot
     # @api private
     def run
       @logger.info "WarningShot v. #{WarningShot::VERSION}"
-      @logger.info "Environment: #{WarningShot.environment}; Application: #{WarningShot.framework}"
+      @logger.info "Environment: #{self.environment}; Application: #{WarningShot.application_type}"
       @logger.info "On host: #{WarningShot.hostname}"
       
-      WarningShot::Resolver.descendents.each do |klass|
+      WarningShot::Resolver.descendants.each do |klass|
+        next if klass.disabled?
+        
         @logger.info "\n#{'-'*60}"
 
         branch = @dependency_tree[klass.branch.to_sym]
 
         if branch.nil?
-          @logger.info "No config file was found for branch #{klass.branch}"
+          @logger.info "[SKIPPING] #{klass}, #{klass.branch}; No machine recipes was registered"
+          next
+        elsif branch.empty?
+          @logger.info "[SKIPPING] #{klass}, #{klass.branch}; No dependencies in machine recipe"
           next
         end
         
         klass.logger = @logger
-        resolver = klass.new(*branch)
+        resolver = klass.new(@config,*branch)
 
         @resolvers << resolver
         
@@ -85,10 +101,10 @@ module WarningShot
         
         @logger.info "Passed: #{resolver.passed.size} / Failed: #{resolver.failed.size}"
 
-        if WarningShot::Config.configuration[:resolve] && !klass.resolutions.empty?
+        if self[:resolve] && !klass.resolutions.empty?
           @logger.info "#{resolver.class}; branch: #{klass.branch} [RESOLVING]"
 
-          klass.before_filters(:resolution).each{|p| p.call}
+          klass.before_filters(:resolution).each{|p| p.call}        
           resolver.resolve! 
           klass.after_filters(:resolution).each{|p| p.call}
           
@@ -105,10 +121,10 @@ module WarningShot
     #
     # @api protected
     def load_configs
-      @config[:config_paths].each do |config_path|
+      self[:config_paths].each do |config_path|
         #Parse the global/running env configs out of the YAML files.
-        Dir[config_path / WarningShot::ConfigExt].each do |config_file|
-          # Use WarningShot::ConfigExt & regexp on extension to make supporting add'l
+        Dir[config_path / WarningShot::RecipeExt].each do |config_file|
+          # Use WarningShot::RecipeExt & regexp on extension to make supporting add'l
           # file types easier in the future
           case File.extname(config_file)
           when /.y(a)?ml/
@@ -132,8 +148,13 @@ module WarningShot
     def parse_yml(file)
       #if only on branch is specified in a yaml file it may not come back as an array
       branches  = YAML::load(File.open(file,'r'))
-      branches = [branches] unless branches.is_a? Array
       
+      if branches === false
+        @logger.error "Skipping malformed Yaml file: #{file}"
+        return
+      end
+      
+      branches = [branches] unless branches.is_a? Array
       branches.each do |branch|
         branch_name = branch[:branch]
         dependency_tree[branch_name] ||= []
@@ -150,6 +171,6 @@ module WarningShot
         @dependency_tree[branch_name].delete(nil)
       end
     end
-    
+      
   end
 end

data/lib/{warning_shot → warningshot}/growl.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) / 'warning_shot' 
+
 module WarningShot
   class Growl
     

data/lib/{warning_shot → warningshot}/logger.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) / 'warning_shot' 
+
 module WarningShot
   class LoggerFormatter < Logger::Formatter
 

data/lib/{warning_shot → warningshot}/resolver.rb

@@ -1,3 +1,5 @@
+require File.dirname(__FILE__) / 'warning_shot' 
+
 # API access for resolvers
 #
 # @example
@@ -10,46 +12,78 @@
 module WarningShot
   module Resolver
     module ClassMethods
-      attr_reader :raw_cli_ext
       
-      # extends command line interface
+      # creates a list of gems that the resolver is dependent on for different features
+      #   The goal of this is that WarningShot will not need a bunch of libraries installed unless
+      #   the end users needs that specific functionality.  If a corelib/gem is missing the logger will
+      #   receive warnings if a particular functionality that needs that library is enabled and its missing
+      #   The missing GEMS can be installed with: warningshot --build-deps
+      #   All resolvers' dependencies can be viewed with: warningshot --list-deps
+      #
+      # @param type [Symbol[:core|:gem]]
+      #   the type of library it depends on, core lib or gem
+      #
+      # @param req_name [String]
+      #   What would normally go in 'require'
+      #
+      # @param dep_opts [Hash]
+      #   :disable [Boolean] Default: true  
+      #       Should the resolver be disabled if the gem is missing
+      #   :unregister [Array[Symbol]]       
+      #       Test / Resolutions to unregister
+      #   :name [String]                
+      #       Alternate name to use to install missing gem with warningshot --build-deps
+      #       Example: require 'net/scp' would need gem install net-scp
+      #   :version [String]
+      #       The version to install
+      #   :source [String]
+      #       Alternate gem source
+      #
+      def add_dependency(type,req_name,dep_opts={})
+        require req_name
+        dep_opts[:installed] = true
+      rescue LoadError => ex
+        self.disable! unless dep_opts[:disable] === false
+        dep_opts[:installed] = false        
+      ensure
+        @dependent_libs ||= {:core => [], :gem => []}
+
+        #if an alternate name isn't specified refer to it by the req_name
+        dep_opts[:name] ||= req_name
+        @dependent_libs[type].push dep_opts
+      end
+      
+      # list the gems the resolver relies on
+      #
+      # @return [Hash]
+      def depends_on
+        @dependent_libs ||= {:core => [], :gem => []}
+      end
+      
+      # provides shortcut to WarningShot::Config.cli_options
+      #
+      # @see WarningShot::Config
+      #
+      # @return [Hash]
+      #   
+      def options
+        WarningShot::Config.cli_options
+      end
+
+      # provides shortcut to WarningShot::Config.cli
+      #
+      # @see OptionParser
+      # @see WarningShot::Config
       # 
-      # @param opts [Hash]
-      #     Keys and example values
-      #       :short => "-s",
-      #       :long => "--longflag",
-      #       :default => "my_value",
-      #       :description => "Command line description",
-      #       :name => "keyname", #required
-      #       :type => String #[:list, :of, :available, :values]
-      #       :default_desc => "Default: my_value"
+      # @param *opts [Array]
+      #
+      # @param &block [Proc]
+      #
       # @api public
-      def cli(opts)
-        @raw_cli_ext ||= []
-        #Do not extend the interface if the class is being 
+      def cli(*opts,&block)
         return if self.disabled?
         
-        ##A keyname for the option is required
-        return if opts[:name].nil?
-        @raw_cli_ext << opts
-        
-        clean_opts = [
-          opts[:short],
-          opts[:long],
-          opts[:type],
-          opts[:description],
-          opts[:default_desc]
-        ]
-        clean_opts.delete(nil)
-        
-        #Set the default value if it was given
-        opt_name = opts[:name].intern
-        WarningShot::Config[opt_name] = opts[:default]
-        
-        WarningShot.parser.on_tail(*clean_opts) do |val|
-          WarningShot::Config[opt_name] = val
-        end
-
+        WarningShot::Config.cli(*opts, &block)
       end
       
       # Setter/Getter for resolver branch, 
@@ -128,6 +162,23 @@ module WarningShot
         @disabled = true
       end
       
+      # enables a resolver (enabled by default)
+      #
+      # @example
+      #   class MyResolver
+      #     include WarningShot::Resolver
+      #     disable!
+      #   end
+      #
+      #   # Maybe you only want to enable it under some conditions
+      #   MyResolver.enabled! if my_merb_or_rails_env == 'production'
+      #   MyResolver.enabled! if @pickles.count == @chickens.count
+      #
+      # @api public
+      def enable!
+        @disabled = false
+      end
+      
       # Determines if resolver is disabled
       #
       # @return [Boolean]
@@ -164,7 +215,7 @@ module WarningShot
       #   How to cast the data to an object
       # 
       # @api public
-      def cast(klass=nil,&block)
+      def typecast(klass=nil,&block)
         if klass.nil?
           klass = :default
         else
@@ -172,8 +223,8 @@ module WarningShot
         end
         (@yaml_to_object_methods||={})[klass] = block
       end
-      
-      # calls the block defined by Resolver#cast to convert
+            
+      # calls the block defined by Resolver#typecast to convert
       #   the yaml data to an object
       #
       # @param data [~YAML::load]
@@ -240,8 +291,7 @@ module WarningShot
       #
       #   register :resolution, :if => lambda{|dependency| 
       #     #This will determin if resolution should be attempted
-      #     # this would only resolve in production
-      #     WarningShot.environment == 'production'
+      #     my_special_instance == true
       #   } do |dependency|
       #       my_method_that_would_resolve dependency
       #   end
@@ -302,6 +352,14 @@ module WarningShot
         end
       end
       
+      # removes all test/resolutions from a resolver
+      #
+      # @api public
+      def flush!
+        flush_tests!
+        flush_resolutions!
+      end
+      
       # Removes all tests from a resolver
       #
       # @api public
@@ -379,7 +437,7 @@ module WarningShot
       # 
       # @api private
       def test!
-        dependencies.each do |dep|   
+        dependencies.each do |dep|  
           self.class.tests.each{ |test_meta|  
             dep.met = process_block :test, dep, test_meta
             break if dep.met
@@ -392,10 +450,12 @@ module WarningShot
       # @api private
       def resolve!
         dependencies.each do |dep|
-          self.class.resolutions.each{ |resolution_meta|     
-            dep.resolved = process_block :resolution, dep, resolution_meta
-            break if dep.resolved
-          }
+          unless dep.met
+            self.class.resolutions.each{ |resolution_meta|     
+              dep.resolved = process_block :resolution, dep, resolution_meta
+              break if dep.resolved
+            }
+          end
         end
       end
       
@@ -407,11 +467,7 @@ module WarningShot
       # @api private
       def unresolved
         dependencies.inject([]){ |list,dep| 
-          if !dep.met && !dep.resolved
-            list << dep 
-          else
-            list
-          end
+          (!dep.met && !dep.resolved) ? (list << dep) : (list)
         }
       end
       
@@ -423,25 +479,18 @@ module WarningShot
       # @api private
       def failed
         dependencies.inject([]){ |list,dep|
-          unless dep.met
-            list << dep
-          else
-            list
-          end
+          dep.met ? (list) : (list << dep)
         }
       end
       
       # list of successful dependencies
       #
       # @return [Array<Objects>]
+      #
       # @api private
       def passed
         dependencies.inject([]){ |list,dep| 
-          if dep.met
-            list << dep
-          else
-            list
-          end
+          dep.met ? (list << dep) : (list)
         }
       end
       
@@ -453,15 +502,15 @@ module WarningShot
       # @api private
       def resolved        
         dependencies.inject([]){ |list,dep| 
-          if(!dep.met && dep.resolved)
-            list << dep 
-          else
-            list
-          end
+          (!dep.met && dep.resolved) ? (list << dep) : (list)
         }
       end
       
-      # loads up instance variables for new test
+      # setups up a resolver with config and dependencies
+      #
+      # @param config [WarningShot::Config]
+      #   Configuration to use
+      #
       # @param *deps [Array]
       #   Dependencies from YAML file
       #
@@ -472,8 +521,10 @@ module WarningShot
       #       resolved [Boolean] Was teh dependency resolved
       #
       # @api semi-public
-      def initialize(*deps)
+      def initialize(config,*deps)
+        @config = config
         @dependencies = Set.new
+        
         deps.each do |dep|
           # Cast YAML data as described in resolver.
           dep = self.class.yaml_to_object(dep)
@@ -482,10 +533,7 @@ module WarningShot
           @dependencies.add dep
         end
       end
-   
-      attr_accessor :logger
-      attr_accessor :dependencies
-      
+         
       protected
        # processes a test or resolution block
        # 
@@ -494,7 +542,6 @@ module WarningShot
        # 
        # @param dep <Hash>
        #    Dependency parsed from yaml configs (Currently Hash)
-       #    TODO; once Dependencies are an object besides Hash, this may need to be changed
        #
        # @param block_info <Hash>
        #   The block details and proc
@@ -502,33 +549,72 @@ module WarningShot
        # @return <Boolean>
        #   Was the block successful; meaning conditions passed and block returned true
        #
+       # @note
+       #    If anyone knows a better way then doing the arity check go for it.  I'd
+       #      like the register api to 'just work' and not have the writer worry about
+       #      a dependency or a configuration unless they need it.  I know that a Proc 
+       #      works no matter how many arguments are passed to it, but a lambda checks
+       #      to make sure its the correct number, and apparently "do;end;" and "{ }"
+       #      check for the number of arguments.
+       # 
+       #      Also note for this, :unless, :if and the block all need a different set of
+       #        params because someone may have registered a :if condition that has a different
+       #        signature than the test/resolution block
+       #
+       #        register(:test,:if=>lambda{WarningShot.hostname=="boogertron"}) do |dep,config|
+       #          puts "A test that needs dep & config"
+       #        end
+       #
        # @api private
        def process_block(type, dep, block_info)
+         block_params = case block_info[type].arity
+         when 1
+           dep
+         when 2
+           [dep,self.config]
+         end
+         
+         if_params = case
+         when 1
+           dep
+         when 2
+           [dep,self.config]
+         end if block_info[:if]
+         
+         unless_params = case
+         when 1
+           dep
+         when 2
+           [dep,self.config]
+         end if block_info[:unless]
+    
          if !block_info[:if] && !block_info[:unless]
-           # no condition, run block
-           return block_info[type].call(dep)
-         elsif block_info[:if] && block_info[:if].call(dep)
-           #if Condition given and it applies, run block          
-           return block_info[type].call(dep)
-         elsif block_info[:unless] && !block_info[:unless].call(dep)
-           #unless Condition given and it applies, run block
-           return block_info[type].call(dep)
+           #if no conditions, run block
+           return block_info[type].call(block_params)
+         elsif block_info[:if] && block_info[:if].call(if_params)
+           #elsif 'if' Condition given and it applies, run block          
+           return block_info[type].call(block_params)
+         elsif block_info[:unless] && !block_info[:unless].call(unless_params)
+           #elsif 'unless' Condition given and it applies, run block
+           return block_info[type].call(block_params)
          end
 
          return false
        end
     end
     
-    @@descendents = []
-    def self.descendents
-      #Filter out descendents that are disabled
-      temp_descendents = []
-      @@descendents.each do |klass|
-        temp_descendents.push(klass) unless klass.disabled?
-      end
+    @@descendants = []
+    def self.descendants(filter_disabled=true)
+      #Filter out descendants that are disabled
+      temp_descendants = []
+      
+
+      @@descendants.each{ |klass|
+        temp_descendants.push(klass) unless filter_disabled && klass.disabled?
+      }
 
       #Sort by order
-      temp_descendents.sort_by{|desc| desc.order}
+      temp_descendants.sort_by{|desc| desc.order}
     end
 
     
@@ -536,7 +622,9 @@ module WarningShot
     def self.included(subclass)
       subclass.extend ClassMethods
       subclass.send :include, InstanceMethods
-      @@descendents.push subclass
+      subclass.send :attr_reader, :config
+      subclass.send :attr_accessor, :dependencies
+      @@descendants.push subclass
     end
   end
 end