warning-shot 0.9.2 → 0.9.3

data/History.txt

@@ -1,3 +1,7 @@
+== 0.9.2 2008-03-13
+* 1 major enhancement:
+  * Finished logger class
+
 == 0.9.2 2008-03-13
 * 2 major enhancement:
   * Optional gem repos to check

data/lib/warning_shot.rb

@@ -6,8 +6,6 @@ require 'net/http'
 require 'net/https'
 require 'uri'
 
-
-
 #IMPORTANT remember to add new includes to Manifest.txt
 Dir.glob(File.join(File.dirname(__FILE__), "warning_shot/*.rb")).each {|f| 
   require f 
@@ -18,7 +16,6 @@ include RippleNetworks::WarningShot
 =begin
   Useful URLS:
     http://rubygems.rubyforge.org/rdoc/
-    http://en.wikipedia.org/wiki/ANSI_escape_code
     http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html
 =end
 
@@ -27,11 +24,6 @@ include RippleNetworks::WarningShot
 TODOs
 -->Change from http reqs to protocol http://etc, memcached://etc, ftp://etc...  
 
--->flag to install gems in first alt gem path
-
--->Implement a WarningShot.logger.(info,fatal,etc...) instead of current logging mechanism
-====>In programatic interface take a logger and override (for passing in external loggers)
-
 -->Further de-couple the dep_checker class
 
 -->Update GemHandler#installed? to use Gem::Requirement#satisfied_by?

data/lib/warning_shot/config_parser.rb

@@ -24,20 +24,20 @@ module RippleNetworks
             ws.configs[config_file] = global.concat(running_env)
             ws.configs[config_file].uniq!
 
-            ws.record("LOADED: #{config_file}.yml")
+            ws.logger.notice("LOADED: #{config_file}.yml")
           rescue Errno::ENOENT => e
             ws.configs[config_file] = {}
             configs_not_found += 1
-            ws.record("NOT FOUND: #{config_file}.yml",:warning)
+            ws.logger.warning("NOT FOUND: #{config_file}.yml")
           rescue Exception => e
-            ws.record(e.inspect)
+            ws.logger.error(e.inspect)
             ws.configs[config_file] = {} 
-            ws.record("MALFORMED: #{config_file}.yml",:error)
+            ws.logger.error("MALFORMED: #{config_file}.yml")
           end
         end
 
         if configs_not_found == DepChecker::DEP_FILES.size
-          ws.record("No configuration files found!\n\t\tTo generate run 'warning-shot --templates=PATH'",:info)
+          ws.logger.info("No configuration files found!\n\t\tTo generate run 'warning-shot --templates=PATH'")
         end
       end
       

data/lib/warning_shot/dep_checker.rb

@@ -19,7 +19,7 @@ module RippleNetworks
 =end
     class DepChecker
       include RippleNetworks::WarningShot
-      attr_reader :options, :warnings, :errors, :configs
+      attr_reader :options, :warnings, :errors, :configs, :logger
       
       LIB_DIRECTORY = $:[0]
       
@@ -52,33 +52,22 @@ module RippleNetworks
         :templates    => false,
         :gempath      => nil
       }
-      
-      #Set up CLEAR and Windows Add'l requirement
-      if PLATFORM =~ /win32/
-        CLEAR = `cls`
-        begin
-          require 'Win32/Console/ANSI' 
-        rescue LoadError => e
-          puts "Run: 'gem install win32console' for colored output"
-        end
-      else
-        CLEAR = `clear`
-      end
 
       
       def initialize(options=DEFAULTS)  
         @original_requires = $".clone
         
-        ObjectSpace.define_finalizer(self, lambda{ @log_file.close unless @log_file.closed? }) 
-        
         #Add directory information to defaults
-        DEFAULTS[:log]      = File.join(options[:dir],"log","warning_shot_#{options[:environment]}.log")
         DEFAULTS[:configs]  = File.join(options[:dir],"config","warning_shot")
-             
         @options = DEFAULTS.merge(options)
         
         #Map to correct running environment
         @options[:environment] = ENVIRONMENT_MAP[@options[:environment]]
+
+        @logger = Logger.new(
+          (@options[:log] || File.join(@options[:dir],"log","warning_shot_#{@options[:environment]}.log")),
+          {:verbose => @options[:verbose], :flush => @options[:flush]}
+        )
         
         #No errors or warnings
         @errors = 0
@@ -86,16 +75,9 @@ module RippleNetworks
         
         #initalize config file hash
         @configs = {}
-        
-        #Flush log
-        flush_log! if @options[:flush]
-
-        #Open log
-        @log_file = File.open(@options[:log],"a+")
 
         #Check dependencies
         @which_installed = has_binary_prereqs?
-        puts CLEAR if @options[:verbose]
       end
 
 =begin rdoc
@@ -149,68 +131,117 @@ module RippleNetworks
 =end  
       def run
         start_time = Time.now
-        section
-          record("WarningShot (v. #{VERSION::INTERNAL}) - started @ #{start_time}")
-          check_framework
-          record("Environment: #{@options[:environment]}")
-          record("Framework: #{@framework}")
-
-        section("Loading YAML files:")    
-          ConfigParser.run(self)
-
-        section("Preloading classes")
-          class_loader("preload")
-
-        section("Checking class dependencies")
-          count = class_loader("classes")
-          record "#{count} classes not found",:error if count > 0
+        tmp_errors = 0
+        
+        @logger.heading
+        @logger.heading "WarningShot (v. #{VERSION::INTERNAL}) - started @ #{start_time}"
 
-        section("Checking binary dependencies")
-          count = check_binaries
-          record "#{count} binaries not found", :error if count > 0
+        check_framework
+        @logger.info("Environment: #{@options[:environment]}")
+        @logger.info("Framework: #{@framework}")
 
-        section("Checking filesystem dependencies")
-          count = check_filesystem
-          record "#{count} files/directories not found", :error if count > 0
+        @logger.heading("Loading YAML files:")    
+        ConfigParser.run(self)
 
-        section("Checking URL dependencies")
-          count = check_urls
-          record "#{count} sites unavailable", :error if count > 0
+        @logger.heading("Preloading classes")
+        class_loader("preload")
 
-        section("Checking gem dependencies")
-          #Initialize gem handler
+        @logger.heading("Checking class dependencies")
+        tmp_errors = class_loader("classes")
+        if tmp_errors > 0
+          @errors += tmp_errors
+          @logger.error("#{tmp_errors} classes not found!")
+        else
+          @logger.notice("All class dependencies found.")
+        end
+        
+        @logger.heading("Checking binary dependencies")
+        tmp_errors = check_binaries
+        if tmp_errors > 0
+          @errors += tmp_errors
+          @logger.error("#{tmp_errors} binaries not found!")
+        else
+          @logger.notice("All binaries found.")
+        end
+        
+        @logger.heading("Checking filesystem dependencies")
+        tmp_errors = check_filesystem
+        if tmp_errors > 0
+          @errors += tmp_errors
+          @logger.error("#{tmp_errors} files/directories not found!")
+        else
+          @logger.notice("All files/directories found.")
+        end
+        
+        @logger.heading("Checking URL dependencies")
+        tmp_errors = check_urls
+        if tmp_errors > 0
+          @errors += tmp_errors
+          @logger.error("#{tmp_errors} sites unavailable!")
+        else
+          @logger.notice("All sites found.")
+        end
 
-          gem_handler = GemHandler.new(self.configs["gems"],{
-            :install_all => @options[:gems],
-            :gem_path => @options[:gempath]
-          })
+        @logger.heading("Checking gem dependencies")
+        #Initialize Gem Handler
+        gem_handler = GemHandler.new(self.configs["gems"],{
+          :install_all => @options[:gems],
+          :gem_path => @options[:gempath]
+        })
           
-          gem_handler.each do |c_gem|
-            if c_gem.status != :installed
-              record("#{c_gem.name} v. #{c_gem.version}:: #{c_gem.details}", :error)
-            else
-              record("#{c_gem.name} v. #{c_gem.version} requirement met!")
-            end
+        tmp_errors = 0
+        gem_handler.each do |c_gem|
+          if c_gem.status != :installed
+            tmp_errors += 1
+            @logger.notice("#{c_gem.name} v. #{c_gem.version}:: #{c_gem.details}")
+          else
+             @logger.info("#{c_gem.name} v. #{c_gem.version} requirement met.")
           end
+        end
+        if tmp_errors > 0
+          @errors += tmp_errors
+          @logger.error("#{tmp_errors} gems are missing!")
+        else
+          @logger.notice("All gems found.")
+        end
+
+        #Load the ruby scripts (not run yet)
+        @logger.heading("Loading Ruby test scripts")
+        tmp_errors = load_ruby_scripts
+        if tmp_errors > 0
+          @errors += tmp_errors
+          @logger.error("#{tmp_errors} scripts failed to load!")
+        else
+          @logger.notice("All scripts loaded successfully.")
+        end
 
-        section("Loading Ruby test scripts")
-          count = load_ruby_scripts
-          record("#{count} scripts failed to load",:error) if count > 0
+        #Run the ruby scripts
+        @logger.heading("Running ruby tests scripts")
+        tmp_errors = test_ruby_scripts
+        if tmp_errors > 0
+          @errors += tmp_errors
+          @logger.error("#{tmp_errors} ruby tests failed!")
+        else
+          @logger.notice("All ruby tests ran successfully.")
+        end
 
-        section("Running Ruby test scripts")
-          count = test_ruby_scripts
-          record("#{count} scripts failed",:error) if count > 0
+        #@logger.heading("Running shell tests scripts")
+        #tmp_errors = check_shell_scripts
+        #if tmp_errors > 0
+        #  @errors += tmp_errors
+        #  @logger.error("#{tmp_errors} shell tests failed!")
+        #else
+        #  @logger.info("All shell tests ran successfully.")
+        #end
+        
+        @logger.heading
+        @logger.heading("RESULTS")
 
-        #section("Shell script dependencies")
-          #count = check_shell_scripts
-          #record("#{count} scripts failed",:error) if count > 0
+        @logger.info("Total Warnings: #{@warnings}")
+        @logger.info("Total Errors: #{@errors}")
+        @logger.info("Checked in #{Time.now.to_f-start_time.to_f}s")
 
-        section
-        section("RESULTS")
-          record("Total Warnings #{@warnings}",(@warnings > 0) ? :warning : :info)
-          record("Total Errors: #{@errors}",(@errors > 0) ? :error : :info)
-          record("Checked in #{Time.now.to_f-start_time.to_f}s",:info)
-        section
+        @logger.heading
 
         #Status via growlnotify
         if @options[:growl]
@@ -223,54 +254,9 @@ module RippleNetworks
         end
 
         unload
-        @log_file.close unless @log_file.closed?
+        @logger.close
       end
-      
-      
-=begin rdoc
-  *Name*:: record
-  *Access*:: public
-  *Description*:: Record message to log
-  *Last_Edited*:: Wed Dec 12 15:37:21 PST 2007
-  ===Parameters
-  * Name: level
-    * Description: Message level :error, :warning, :info, :none
-    * Datatype: Symbol
-    * Default: :info
-    * Required: false
-=end
-      def record(msg,level=:none)
-        if [:error,:warning,:info,:fatal].include? level
-          msg = %{#{level.to_s.upcase}: #{msg}}
-        end
-
-        case level
-        when :error
-          @errors += 1
-        when :warning
-          @warnings += 1
-        end
-
-        @log_file.puts msg 
-
-        if @options[:verbose]
-          case level
-          when :info
-            msg = "\e[37m#{msg}\e[0m"
-          when :error
-            msg = "\e[31m#{msg}\e[0m"
-          when :warning
-            msg = "\e[33m#{msg}\e[0m"
-          when :fatal
-            msg = "\e[1m\e[5m#{msg}\e[0m"
-          end     
-          
-          puts msg
-
-          Kernel.exit if level == :fatal
-        end
-      end      
-      
+         
       
       private 
       
@@ -314,23 +300,6 @@ module RippleNetworks
         gmsg += %{ --image #{File.join(LIB_DIRECTORY,"..","images",img)}} unless img.nil?
         %x{#{gmsg}}
       end
-
-
-=begin rdoc
-  *Name*:: section
-  *Access*:: private
-  *Description*:: Display a section seperator
-  *Last_Edited*:: Mon Dec 17 10:45:52 PST 2007
-  ===Parameters
-  * Name: title
-    * Description:  Puts a title in the seperator
-    * Datatype: string
-    * Default: None
-    * Required: False
-=end
-      def section(title="")
-        record %{#{title.center(60,"-") }}
-      end
     
       
 =begin rdoc
@@ -348,28 +317,15 @@ module RippleNetworks
 		  
     		  if @options[:growl]
     		    unless DepChecker.has_binary? "growlnotify"
-        		  record "Could not locate: `growlnotify`", :warning
+        		  @logger.warning "Could not locate: `growlnotify`"
       		  end
     	    end
 	        return true
     		else
-    			record "Could not locate: `which`; required for binaries dependencies\n\tbinaries.yml will be skipped!!!", :error
+    			@logger.error "Could not locate: `which`; required for binaries dependencies\n\tbinaries.yml will be skipped!!!"
     			return false
     		end
       end
-
-
-=begin rdoc
-  *Name*:: flush_log!
-  *Access*:: private
-  *Description*:: Flushes log file if it exists
-  *Last_Edited*:: Wed Dec 12 15:04:11 PST 2007
-=end
-      def flush_log!
-        File.truncate(@options[:log],0) if File.exists? @options[:log]
-        #File.unlink @options[:log] if File.exists? @options[:log]
-        #FileUtils.touch @options[:log]
-      end
       
       
 =begin rdoc
@@ -392,16 +348,18 @@ module RippleNetworks
             #TODO Mute output from requires, ie "puts"
             #@@@ Rescue block doesn't seem to be catching error.
             require klass
-            record("FOUND: #{klass}")
+            @logger.info("FOUND: #{klass}")
           rescue LoadError => e
             case mode
-              when "preload"
-                record("NOT FOUND: #{klass}",:fatal)
-              when "classes"
-                errors += 1
-                record("NOT FOUND: #{klass}",:error)
-              else
-                record("Invalid class_loader mode",:fatal)
+            when "preload"
+              @logger.fatal("NOT FOUND: #{klass}")
+              Kernel.exit
+            when "classes"
+              errors += 1
+              @logger.error("NOT FOUND: #{klass}")
+            else
+              @logger.fatal("Invalid class_loader mode")
+              Kernel.exit
             end
           end
         end
@@ -422,10 +380,10 @@ module RippleNetworks
         if @which_installed
           @configs["binaries"].each do |binary|
             if DepChecker.has_binary? binary
-              record("INSTALLED: #{binary}")
+              @logger.info("INSTALLED: #{binary}")
             else
               errors += 1
-              record("NOT FOUND: #{binary}",:error)
+              @logger.error("NOT FOUND: #{binary}")
             end
           end
         
@@ -446,13 +404,13 @@ module RippleNetworks
         
         @configs["filesystem"].each do |path|
           if File.file?(path)
-    				record("FOUND (file): #{path}")
+    				@logger.info("FOUND (file): #{path}")
     			elsif File.directory?(path)
-    				record("FOUND (directory): #{path}")
+    				@logger.info("FOUND (directory): #{path}")
     			elsif File.exists?(path)
-            record("FOUND: #{path}")
+            @logger.info("FOUND: #{path}")
     			else
-            record("NOT FOUND: #{path}", :error)
+            @logger.error("NOT FOUND: #{path}")
     				errors += 1
     			end
         end
@@ -482,16 +440,20 @@ module RippleNetworks
             http_code = response.code.to_i
             
             if @options[:strict] && http_code == 200
-              record("CONNECTED (#{http_code}): #{uri}")
+              @logger.info("CONNECTED (#{http_code}): #{uri}")
             elsif http_code >= 200 && http_code < 300
-              record("CONNECTED (#{http_code}): #{uri}", ((http_code != 200)? :warning : nil))
+              if (http_code != 200)
+                @logger.warning("CONNECTED (#{http_code}): #{uri}")
+              else
+                @logger.info("CONNECTED (#{http_code}): #{uri}")
+              end
             else
               errors += 1
-              record("UNAVAILABLE (#{http_code}): #{uri}", :error)
+              @logger.error("UNAVAILABLE (#{http_code}): #{uri}")
             end
           rescue Exception => e
             errors += 1
-            record("An exception occurred: #{e.message} while connecting to: #{uri}", :error)
+            @logger.error("An exception occurred: #{e.message} while connecting to: #{uri}")
           end
         end
         
@@ -509,8 +471,8 @@ module RippleNetworks
           begin        
             require pre_script if File.exists? pre_script
           rescue
-            record "Failed to load: #{pre_script}", :fatal
-            errors +=1
+            @logger.fatal "Failed to load: #{pre_script}"
+            Kernel.exit
           end
           
           Dir.new(scripts_path).each { |script|
@@ -524,8 +486,8 @@ module RippleNetworks
                   begin
                     require s if File.exists? s
                   rescue
-                    record "Failed to load: #{s}",:fatal
-                    errors +=1
+                    @logger.fatal "Failed to load: #{s}"
+                    Kernel.exit
                   end
               }
               
@@ -537,12 +499,13 @@ module RippleNetworks
           begin
             require post_script if File.exists? post_script
           rescue
-            record "Failed to load: #{pre_script}", :fatal
-            errors +=1
+            @logger.fatal "Failed to load: #{pre_script}"
+            Kernel.exit
           end
         rescue Exception => e
-           record e
-           record "Script directory not found, try running 'warning-shot --templates=PATH'", :warning
+          @logger.fatal(e)
+          @logger.fatal "Script directory not found, try running 'warning-shot --templates=PATH'"
+          Kernel.exit
         end 
         
         return errors
@@ -556,15 +519,16 @@ module RippleNetworks
             result, message = test.run()
             
             unless result
-              record %{#{test.class} test failed!},:error
-              record(%{\tMessage from #{test.class} test: #{message}}) unless message.nil?
+              @logger.error %{#{test.class} test failed!}
+              @logger.notice(%{Message from #{test.class} test: #{message}}) unless message.nil?
               errors += 1
             else
-              record(%{#{test.class} test passed!},:info)
-              record(%{\tMessage from #{test.class} test: #{message}}) unless message.nil?
+              @logger.info(%{#{test.class} test passed!})
+              @logger.notice(%{Message from #{test.class} test: #{message}}) unless message.nil?
             end
           rescue Exception => e
-            record %{An error occured while processing: #{test.class}\n#{e}}, :fatal
+            @logger.fatal %{An error occured while processing: #{test.class}\n#{e}}
+            @logger.notice "This test may be inconclusive..."
             errors += 1
           end
         end

data/lib/warning_shot/logger.rb

@@ -2,16 +2,99 @@
 module RippleNetworks
   module WarningShot
     class Logger
+      #Set up CLEAR and Windows Add'l requirement
+      if PLATFORM =~ /win32/
+        CLEAR = `cls`
+        begin
+          require 'Win32/Console/ANSI' 
+        rescue LoadError => e
+          puts "Run: 'gem install win32console' for colored output"
+        end
+      else
+        CLEAR = `clear`
+      end
+    
       
-      def initialize(path,verbose=false);end;
+      ESCAPE_SEQ = {
+        :notice     => "\e[37m%s\e[0m",
+        :warning  => "\e[33m%s\e[0m",
+        :debug    => "\e[34m%s\e[0m",
+        :error    => "\e[31m%s\e[0m",
+        :fatal    => "\e[1m\e[5m%s\e[0m"
+      }
+
+      
+      DEFAULTS = {
+        :verbose => false,
+        :flush => false
+      }
+      
+      def initialize(path,opts={})
+        options = DEFAULTS.merge(opts)
+        @verbose = options[:verbose]
+        
+        @log_file = File.open(path,"a+")
+        
+        #Flush log
+        flush_log!(path) if options[:flush]
+        
+        #Clear console
+        puts CLEAR if @verbose
+      end
+      
+      def heading(title="");
+        msg = %{#{title.center(60,"-") }}
+        @log_file.puts msg
+        puts msg if @verbose
+      end  
+      
+      def close()
+        @log_file.close unless @log_file.closed?
+      end
+      
+      def info(msg)
+        @log_file.puts msg
+        puts msg if @verbose
+      end
+      
+      def notice(msg)
+        frm_msg = output_msg(:notice,msg)
+        @log_file.puts frm_msg
+        puts frm_msg if @verbose
+      end
+      
+      def debug(msg)
+        frm_msg = output_msg(:debug,msg)
+        @log_file.puts frm_msg
+        puts frm_msg if @verbose
+      end
+      
+      def error(msg)
+        frm_msg = output_msg(:error,msg)
+        @log_file.puts frm_msg
+        puts frm_msg if @verbose
+      end
+      
+      def warning(msg)
+        frm_msg = output_msg(:warning,msg)
+        @log_file.puts frm_msg
+        puts frm_msg if @verbose
+      end
+      
+      def fatal(msg)
+        frm_msg = output_msg(:fatal,msg)
+        @log_file.puts frm_msg
+        puts frm_msg if @verbose
+      end
       
-      def info();end;
-      def debug();end;
-      def error();end;
-      def warning();end;
-      def fatal();end;
+      private
+      def output_msg(type,msg)
+        frm_msg = sprintf(ESCAPE_SEQ[type],%{[#{type.to_s.upcase}]\t #{msg}})
+      end
       
-      def close();end;
+      def flush_log!(log_file)
+        File.truncate(log_file,0) if File.exists? log_file  
+      end
     end
   end
 end

data/lib/warning_shot/version.rb

@@ -3,7 +3,7 @@ module WarningShot #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 9
-    TINY  = 2
+    TINY  = 3
     RC    = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>warning_shot</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/warning_shot"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/warning_shot" class="numbers">0.9.2</a>
+      <a href="http://rubyforge.org/projects/warning_shot" class="numbers">0.9.3</a>
     </div>
     <h1>&#x2192; &#8216;warning_shot&#8217;</h1>
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: warning-shot
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors: 
 - Cory O'Daniel