sawmill 0.1.15 → 0.1.16

data/lib/sawmill/record_processor.rb

@@ -1,15 +1,15 @@
 # -----------------------------------------------------------------------------
-# 
+#
 # Sawmill record processor interface
-# 
+#
 # -----------------------------------------------------------------------------
 # 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,62 +35,62 @@
 
 
 module Sawmill
-  
-  
+
+
   # Entry processors are objects that receive a stream of log records and
   # perform some action. Some processors perform their own action, while
   # others could filter records and forward them to other processors.
-  # 
+  #
   # The API contract for a record processor is specified by the class
   # Sawmill::RecordProcessor::Base. Processors could subclass that base
   # class, or could just duck-type the methods.
-  # 
+  #
   # Sawmill's basic record processor classes live into this module's
   # namespace, but this is not a requirement for your own processors.
-  
+
   module RecordProcessor
-    
-    
+
+
     class Builder  # :nodoc:
       include ::Blockenspiel::DSL
     end
-    
-    
+
+
     # A base class for record processors.
-    # 
+    #
     # Record processors need not necessarily subclass this class, but should
     # at least duck-type the methods.
-    # 
+    #
     # If a class subclasses this class, *and* lives in the RecordProcessor
     # namespace, then it will automatically be available in the build
     # interface. See RecordProcessor#build.
-    
+
     class Base
-      
-      
+
+
       # Receive and process a Sawmill::Record.
-      
+
       def record(record_)
         true
       end
-      
-      
+
+
       # Receive and process an entry that falls outside a record.
-      
+
       def extra_entry(entry_)
         true
       end
-      
-      
+
+
       # Close down the processor, perform any finishing tasks, and return
       # any final calculated value.
-      # 
+      #
       # After this is called, the processor should ignore any further entries.
-      # 
+      #
       # The return value can be used to communicate a final computed value,
       # analysis report, or other data back to the caller. It may also be
       # nil, signalling no finish value.
-      # 
+      #
       # Note that some processors function to multiplex other processors. In
       # such a case, their finish value needs to be an aggregate of the
       # values returned by their descendants. To handle these cases, we
@@ -103,12 +103,12 @@ module Sawmill
       # actually return an array _as_ a value, you must wrap it in another
       # array, indicating "an array of one finish value, and that finish
       # value also happens to be an array itself".
-      
+
       def finish
         nil
       end
-      
-      
+
+
       def self.inherited(subclass_)  # :nodoc:
         if subclass_.name =~ /^Sawmill::RecordProcessor::([^:]+)$/
           name_ = $1
@@ -119,23 +119,23 @@ module Sawmill
           end
         end
       end
-      
-      
+
+
       # Add a method to the processor building DSL. You may call this method
       # in the DSL to create an instance of this record processor.
       # You must pass a method name that begins with a lower-case letter or
       # underscore.
-      # 
+      #
       # Processors that subclass Sawmill::RecordProcessor::Base and live in
       # the Sawmill::RecordProcessor namespace will have their class name
       # automatically added to the DSL. This method is primarily for other
       # processors that do not live in that module namespace.
-      # 
+      #
       # See Sawmill::RecordProcessor#build for more information.
-      # 
+      #
       # Raises Sawmill::Errors::DSLMethodError if the given name is already
       # taken.
-      
+
       def self.add_dsl_method(name_)
         klass_ = self
         if name_.to_s !~ /^[a-z_]/
@@ -150,14 +150,14 @@ module Sawmill
           end
         end
       end
-      
-      
+
+
       private
-      
+
       def _interpret_processor_array(param_)  # :nodoc:
         param_.flatten.map{ |processor_| _interpret_processor(processor_) }
       end
-      
+
       def _interpret_processor(param_)  # :nodoc:
         case param_
         when ::Class
@@ -168,34 +168,34 @@ module Sawmill
           raise ::ArgumentError, "Unknown processor object of type #{param_.class.name}"
         end
       end
-      
-      
+
+
     end
-    
-    
+
+
     # A convenience DSL for building sets of processors. This is typically
     # useful for constructing if-expressions using the boolean operation
     # processors.
-    # 
+    #
     # Every record processor that lives in the Sawmill::RecordProcessor
     # module and subclasses Sawmill::RecordProcessor::Base can be
     # instantiated by using its name as a function call. Other processors
     # may also add themselves to the DSL by calling
     # Sawmill::RecordProcessor::Base#add_dsl_method.
-    # 
+    #
     # For example:
-    # 
+    #
     #  Sawmill::RecordProcessor.build do
     #    If(Or(FilterByRecordId('12345678'), FilterByRecordId('abcdefg')),
     #       Format(STDOUT))
     #  end
-    
+
     def self.build(&block_)
       ::Blockenspiel.invoke(block_, Builder.new)
     end
-    
-    
+
+
   end
-  
-  
+
+
 end

data/lib/sawmill/record_processor/compile_report.rb

@@ -1,15 +1,15 @@
 # -----------------------------------------------------------------------------
-# 
+#
 # Sawmill record 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 RecordProcessor
-    
-    
+
+
     # This processor collects and formats reports from descendant
     # record processors.
-    
+
     class CompileReport < All
-      
-      
+
+
       # Create a report collection.
-      # 
+      #
       # Recognized options include:
-      # 
+      #
       # [<tt>:postprocessor</tt>]
       #   Postprocessor proc for individual reports.
       # [<tt>:separator</tt>]
@@ -60,7 +60,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]
@@ -69,32 +69,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)
@@ -102,12 +102,12 @@ module Sawmill
         values_.compact!
         "#{@header}#{values_.join(@separator)}#{@footer}"
       end
-      
-      
+
+
     end
-    
-    
+
+
   end
-  
-  
+
+
 end

data/lib/sawmill/record_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 RecordProcessor
-    
-    
+
+
     # 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 records
     # to STDOUT only if they have a "user" attribute of "daniel":
-    # 
+    #
     #  processor = Sawmill::RecordProcessor.build do
     #    If(FilterByAttributes('user' => 'daniel'), 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 record should be accepted.
       # The second parameter is a processor to run on accepted records.
       # The optional third parameter is an "else" processor to run on
       # rejected records.
-      
+
       def initialize(condition_, on_true_, on_false_=nil)
         @condition = condition_
         @on_true = on_true_
         @on_false = on_false_
       end
-      
+
       def record(record_)
         if @condition.record(record_)
           @on_true.record(record_)
@@ -75,7 +75,7 @@ module Sawmill
           @on_false.record(record_)
         end
       end
-      
+
       def extra_entry(entry_)
         if @condition.extra_entry(entry_)
           @on_true.extra_entry(entry_)
@@ -83,247 +83,247 @@ module Sawmill
           @on_false.extra_entry(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 records
     # to STDOUT only if they do NOT have a "user" attribute of "daniel":
-    # 
+    #
     #  processor = Sawmill::RecordProcessor.build do
     #    If(Not(FilterByAttributes('user' => 'daniel')), 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 record(record_)
         !@child.record(record_)
       end
-      
+
       def extra_entry(entry_)
         !@child.extra_entry(record_)
       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 records
     # to STDOUT only if they have a "user" attribute of "daniel" AND their
     # record ID is '12345678':
-    # 
+    #
     #  processor = Sawmill::RecordProcessor.build do
     #    If(And(FilterByAttributes('user' => 'daniel'),
     #           FilterByRecordID('12345678')),
     #       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 record(record_)
         @children.each do |child_|
           return false unless child_.record(record_)
         end
         true
       end
-      
+
       def extra_entry(entry_)
         @children.each do |child_|
           return false unless child_.extra_entry(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 records
     # to STDOUT only if they have a "user" attribute of "daniel" OR their
     # record ID is '12345678':
-    # 
+    #
     #  processor = Sawmill::RecordProcessor.build do
     #    If(Or(FilterByAttributes('user' => 'daniel'),
     #          FilterByRecordID('12345678')),
     #       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 record(record_)
         @children.each do |child_|
           return true if child_.record(record_)
         end
         false
       end
-      
+
       def extra_entry(entry_)
         @children.each do |child_|
           return true if child_.extra_entry(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 records
     # to STDOUT only if they have a "user" attribute of "daniel" AND their
     # record ID is '12345678':
-    # 
+    #
     #  processor = Sawmill::RecordProcessor.build do
     #    If(All(FilterByAttributes('user' => 'daniel'),
     #           FilterByRecordID('12345678')),
     #       Format(STDOUT))
     #  end
-    # 
+    #
     # This processor just formats both to STDOUT and STDERR:
-    # 
+    #
     #  processor = Sawmill::RecordProcessor.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 record(record_)
         @children.inject(true) do |result_, child_|
           child_.record(record_) && result_
         end
       end
-      
+
       def extra_entry(entry_)
         @children.inject(true) do |result_, child_|
           child_.extra_entry(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 records
     # to STDOUT only if they have a "user" attribute of "daniel" OR their
     # record ID is '12345678':
-    # 
+    #
     #  processor = Sawmill::RecordProcessor.build do
     #    If(Any(FilterByAttributes('user' => 'daniel'),
     #           FilterByRecordID('12345678')),
     #       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 record(record_)
         @children.inject(false) do |result_, child_|
           child_.record(record_) || result_
         end
       end
-      
+
       def extra_entry(entry_)
         @children.inject(false) do |result_, child_|
           child_.extra_entry(entry_) || result_
         end
       end
-      
+
       def finish
         Util::ProcessorTools.collect_finish_values(@children)
       end
-      
-      
+
+
     end
-    
-    
+
+
   end
-  
+
 end