sawmill 0.1.15 → 0.1.16

data/lib/sawmill/entry_processor/compile_report.rb

@@ -1,15 +1,15 @@
 # -----------------------------------------------------------------------------
-# 
+#
 # Sawmill entry processor that generates reports
-# 
+#
 # -----------------------------------------------------------------------------
 # Copyright 2009 Daniel Azuma
-# 
+#
 # All rights reserved.
-# 
+#
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:
-# 
+#
 # * Redistributions of source code must retain the above copyright notice,
 #   this list of conditions and the following disclaimer.
 # * Redistributions in binary form must reproduce the above copyright notice,
@@ -18,7 +18,7 @@
 # * Neither the name of the copyright holder, nor the names of any other
 #   contributors to this software, may be used to endorse or promote products
 #   derived from this software without specific prior written permission.
-# 
+#
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -35,21 +35,21 @@
 
 
 module Sawmill
-  
-  
+
+
   module EntryProcessor
-    
-    
+
+
     # This processor collects and formats reports from descendant
     # entry processors.
-    
+
     class CompileReport < All
-      
-      
+
+
       # Create a report collection.
-      # 
+      #
       # Recognized options include:
-      # 
+      #
       # [<tt>:postprocessor</tt>]
       #   Postprocessor proc for individual reports.
       #   See to_postprocess_value.
@@ -62,7 +62,7 @@ module Sawmill
       # [<tt>:footer</tt>]
       #   Footer string for the final compiled report.
       #   Default is the empty string.
-      
+
       def initialize(*children_)
         opts_ = children_.last.kind_of?(::Hash) ? children_.pop : {}
         @postprocessor = opts_[:postprocessor]
@@ -71,32 +71,32 @@ module Sawmill
         @footer = opts_[:footer] || ''
         super(*children_)
       end
-      
-      
+
+
       # Separator string to be inserted between individual reports.
       attr_accessor :separator
-      
+
       # Header string for the final compiled report.
       attr_accessor :header
-      
+
       # Footer string for the final compiled report.
       attr_accessor :footer
-      
-      
+
+
       # Provide a postprocessor block for individual report values.
       # This block should take a single parameter and return a string
       # that should be included in the compiled report. It may also
       # return nil to indicate that the data should not be included.
-      
+
       def to_postprocess_value(&block_)
         @postprocessor = block_
       end
-      
-      
+
+
       # On finish, this processor calls finish on its descendants, converts
       # their values into strings and compiles them into a report. It then
       # returns that report as a string.
-      
+
       def finish
         values_ = super || []
         values_ = [values_] unless values_.kind_of?(::Array)
@@ -104,12 +104,12 @@ module Sawmill
         values_.compact!
         "#{@header}#{values_.join(@separator)}#{@footer}"
       end
-      
-      
+
+
     end
-    
-    
+
+
   end
-  
-  
+
+
 end

data/lib/sawmill/entry_processor/conditionals.rb

@@ -1,15 +1,15 @@
 # -----------------------------------------------------------------------------
-# 
+#
 # Sawmill basic entry processors that implement conditionals
-# 
+#
 # -----------------------------------------------------------------------------
 # Copyright 2009 Daniel Azuma
-# 
+#
 # All rights reserved.
-# 
+#
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:
-# 
+#
 # * Redistributions of source code must retain the above copyright notice,
 #   this list of conditions and the following disclaimer.
 # * Redistributions in binary form must reproduce the above copyright notice,
@@ -18,7 +18,7 @@
 # * Neither the name of the copyright holder, nor the names of any other
 #   contributors to this software, may be used to endorse or promote products
 #   derived from this software without specific prior written permission.
-# 
+#
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
@@ -35,39 +35,39 @@
 
 
 module Sawmill
-  
+
   module EntryProcessor
-    
-    
+
+
     # An "if" conditional.
-    # 
+    #
     # Takes a boolean condition processor and executes a processor on true
     # (and optionally another one on false).
-    # 
+    #
     # For example, this builds a processor that sends formatted log entries
     # to STDOUT only if their level is at least INFO:
-    # 
+    #
     #  processor = Sawmill::EntryProcessor.build do
     #    If(FilterByBasicFields(:level => :INFO), Format(STDOUT))
     #  end
-    
+
     class If < Base
-      
-      
+
+
       # Create an "if" conditional.
-      # 
+      #
       # The first parameter must be a processor whose methods return a
       # boolean value indicating whether the entry should be accepted.
       # The second parameter is a processor to run on accepted entries.
       # The optional third parameter is an "else" processor to run on
       # rejected entries.
-      
+
       def initialize(condition_, on_true_, on_false_=nil)
         @condition = condition_
         @on_true = on_true_
         @on_false = on_false_
       end
-      
+
       def begin_record(entry_)
         if @condition.begin_record(entry_)
           @on_true.begin_record(entry_)
@@ -75,7 +75,7 @@ module Sawmill
           @on_false.begin_record(entry_)
         end
       end
-      
+
       def end_record(entry_)
         if @condition.end_record(entry_)
           @on_true.end_record(entry_)
@@ -83,7 +83,7 @@ module Sawmill
           @on_false.end_record(entry_)
         end
       end
-      
+
       def message(entry_)
         if @condition.message(entry_)
           @on_true.message(entry_)
@@ -91,7 +91,7 @@ module Sawmill
           @on_false.message(entry_)
         end
       end
-      
+
       def attribute(entry_)
         if @condition.attribute(entry_)
           @on_true.attribute(entry_)
@@ -99,7 +99,7 @@ module Sawmill
           @on_false.attribute(entry_)
         end
       end
-      
+
       def unknown_data(entry_)
         if @condition.unknown_data(entry_)
           @on_true.unknown_data(entry_)
@@ -107,337 +107,337 @@ module Sawmill
           @on_false.unknown_data(entry_)
         end
       end
-      
+
       def finish
         Util::ProcessorTools.collect_finish_values([@on_true, @on_false])
       end
-    
-      
+
+
     end
-    
-    
+
+
     # A boolean processor that returns the boolean negation of a given
     # processor.
-    # 
+    #
     # For example, this builds a processor that sends formatted log entries
     # to STDOUT only if their level is NOT at least INFO:
-    # 
+    #
     #  processor = Sawmill::EntryProcessor.build do
     #    If(Not(FilterByBasicFields(:level => :INFO)), Format(STDOUT))
     #  end
-    
+
     class Not < Base
-      
-      
+
+
       # Create a "not" boolean.
       # The parameter is a boolean processor to run. This processor returns
       # the boolean negation of its output.
-      
+
       def initialize(child_)
         @child = _interpret_processor(child_)
       end
-      
+
       def begin_record(entry_)
         !@child.begin_record(entry_)
       end
-      
+
       def end_record(entry_)
         !@child.end_record(entry_)
       end
-      
+
       def message(entry_)
         !@child.message(entry_)
       end
-      
+
       def attribute(entry_)
         !@child.attribute(entry_)
       end
-      
+
       def unknown_data(entry_)
         !@child.unknown_data(entry_)
       end
-      
+
       def finish
         @child.finish
       end
-    
-      
+
+
     end
-    
-    
+
+
     # A boolean processor that returns true if and only if all its child
     # processors return true. This version short-circuits the processing,
     # so once one child returns false, subsequent children are not called
     # at all.
-    # 
+    #
     # For example, this builds a processor that sends formatted log entries
     # to STDOUT only if their level is at least INFO AND the progname is
     # is "rails":
-    # 
+    #
     #  processor = Sawmill::EntryProcessor.build do
     #    If(And(FilterByBasicFields(:level => :INFO),
     #           FilterByBasicFields(:progname => 'rails')),
     #       Format(STDOUT))
     #  end
-    
+
     class And < Base
-      
-      
+
+
       # Create an "and" boolean.
       # The parameters are child processors whose return values should be
       # combined with an AND operation.
-      
+
       def initialize(*children_)
         @children = _interpret_processor_array(children_)
       end
-      
+
       def begin_record(entry_)
         @children.each do |child_|
           return false unless child_.begin_record(entry_)
         end
         true
       end
-      
+
       def end_record(entry_)
         @children.each do |child_|
           return false unless child_.end_record(entry_)
         end
         true
       end
-      
+
       def message(entry_)
         @children.each do |child_|
           return false unless child_.message(entry_)
         end
         true
       end
-      
+
       def attribute(entry_)
         @children.each do |child_|
           return false unless child_.attribute(entry_)
         end
         true
       end
-      
+
       def unknown_data(entry_)
         @children.each do |child_|
           return false unless child_.unknown_data(entry_)
         end
         true
       end
-      
+
       def finish
         Util::ProcessorTools.collect_finish_values(@children)
       end
-    
-      
+
+
     end
-    
-    
+
+
     # A boolean processor that returns true if and only if any of its child
     # processors returns true. This version short-circuits the processing,
     # so once one child returns true, subsequent children are not called
     # at all.
-    # 
+    #
     # For example, this builds a processor that sends formatted log entries
     # to STDOUT only if their level is at least INFO OR the progname is
     # "rails":
-    # 
+    #
     #  processor = Sawmill::EntryProcessor.build do
     #    If(Or(FilterByBasicFields(:level => :INFO),
     #          FilterByBasicFields(:progname => 'rails')),
     #       Format(STDOUT))
     #  end
-    
+
     class Or < Base
-      
-      
+
+
       # Create an "or" boolean.
       # The parameters are child processors whose return values should be
       # combined with an OR operation.
-      
+
       def initialize(*children_)
         @children = _interpret_processor_array(children_)
       end
-      
+
       def begin_record(entry_)
         @children.each do |child_|
           return true if child_.begin_record(entry_)
         end
         false
       end
-      
+
       def end_record(entry_)
         @children.each do |child_|
           return true if child_.end_record(entry_)
         end
         false
       end
-      
+
       def message(entry_)
         @children.each do |child_|
           return true if child_.message(entry_)
         end
         false
       end
-      
+
       def attribute(entry_)
         @children.each do |child_|
           return true if child_.attribute(entry_)
         end
         false
       end
-      
+
       def unknown_data(entry_)
         @children.each do |child_|
           return true if child_.unknown_data(entry_)
         end
         false
       end
-      
+
       def finish
         Util::ProcessorTools.collect_finish_values(@children)
       end
-    
-      
+
+
     end
-    
-    
+
+
     # A boolean processor that returns true if and only if all its child
     # processors return true. This version does not short-circuit the
     # processing, so all children are always called even if an early one
     # returns false. Thus, this processor is also a good one to use as a
     # multiplexor to simply run a bunch of processors.
-    # 
+    #
     # For example, this builds a processor that sends formatted log entries
     # to STDOUT only if their level is at least INFO AND the progname is
     # "rails":
-    # 
+    #
     #  processor = Sawmill::EntryProcessor.build do
     #    If(All(FilterByBasicFields(:level => :INFO),
     #           FilterByBasicFields(:progname => 'rails')),
     #       Format(STDOUT))
     #  end
-    # 
+    #
     # This processor just formats both to STDOUT and STDERR:
-    # 
+    #
     #  processor = Sawmill::EntryProcessor.build do
     #    All(Format(STDOUT), Format(STDERR))
     #  end
-    
+
     class All < Base
-      
-      
+
+
       # Create an "all" boolean.
       # The parameters are child processors whose return values should be
       # combined with an AND operation.
-      
+
       def initialize(*children_)
         @children = _interpret_processor_array(children_)
       end
-      
+
       def begin_record(entry_)
         @children.inject(true) do |result_, child_|
           child_.begin_record(entry_) && result_
         end
       end
-      
+
       def end_record(entry_)
         @children.inject(true) do |result_, child_|
           child_.end_record(entry_) && result_
         end
       end
-      
+
       def message(entry_)
         @children.inject(true) do |result_, child_|
           child_.message(entry_) && result_
         end
       end
-      
+
       def attribute(entry_)
         @children.inject(true) do |result_, child_|
           child_.attribute(entry_) && result_
         end
       end
-      
+
       def unknown_data(entry_)
         @children.inject(true) do |result_, child_|
           child_.unknown_data(entry_) && result_
         end
       end
-      
+
       def finish
         Util::ProcessorTools.collect_finish_values(@children)
       end
-    
-      
+
+
     end
-    
-    
+
+
     # A boolean processor that returns true if and only if any of its child
     # processors returns true. This version does not short-circuit the
     # processing, so all children are always called even if an early one
     # returns true.
-    # 
+    #
     # For example, this builds a processor that sends formatted log entries
     # to STDOUT only if their level is at least INFO OR the progname is
     # "rails":
-    # 
+    #
     #  processor = Sawmill::EntryProcessor.build do
     #    If(Any(FilterByBasicFields(:level => :INFO),
     #           FilterByBasicFields(:progname => 'rails')),
     #       Format(STDOUT))
     #  end
-    
+
     class Any < Base
-      
-      
+
+
       # Create an "any" boolean.
       # The parameters are child processors whose return values should be
       # combined with an OR operation.
-      
+
       def initialize(*children_)
         @children = _interpret_processor_array(children_)
       end
-      
+
       def begin_record(entry_)
         @children.inject(false) do |result_, child_|
           child_.begin_record(entry_) || result_
         end
       end
-      
+
       def end_record(entry_)
         @children.inject(false) do |result_, child_|
           child_.end_record(entry_) || result_
         end
       end
-      
+
       def message(entry_)
         @children.inject(false) do |result_, child_|
           child_.message(entry_) || result_
         end
       end
-      
+
       def attribute(entry_)
         @children.inject(false) do |result_, child_|
           child_.attribute(entry_) || result_
         end
       end
-      
+
       def unknown_data(entry_)
         @children.inject(false) do |result_, child_|
           child_.unknown_data(entry_) || result_
         end
       end
-      
+
       def finish
         Util::ProcessorTools.collect_finish_values(@children)
       end
-    
-      
+
+
     end
-    
-    
+
+
   end
-  
+
 end