trace-util-adv 0.2.3 → 0.2.4

data/CHANGELOG

@@ -1,9 +1,5 @@
-27-10-2009
+13-Nov-2009
 ==========
-* Created filter_factory.rb
-- will include convenience methods to create and operate on filters
-- should be used when registering filters in all cases
-
-* improved README documentation
-
-NOTE: Framework has become overly complex - simplify, and refactor next week! 
+* Test cases for basic and composite filters all pass
+* Created new filter: ArgumentsFilter
+* Major refactoring! 

data/{lib/TODO.txt → TODO.txt}

@@ -1,4 +1,12 @@
 TODO:
+----
+- Unit tests for appenders. action_handler
+- require txt_file_mutator
+
+---
+Add time to context for before- and after handle calls. Enable tracing time output 
+Allow for comparing time it takes to complete method and act upon it!
+Store method with come context on stack, to allow look up to compare with previous calls. Perhaps find average time it took to call this method etc.
 
 Support Intrusive trace statements
 ----------------------------------

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.2.4

data/lib/action_handler/action_handler.rb

@@ -0,0 +1,40 @@
+Dir.glob(File.join(File.dirname(__FILE__), '**/*.rb')).each {|f| require f }
+
+module Tracing
+  class ActionHandler
+    # supports:
+    # - Filter registration and execution    
+    # - Appender registration
+    include Tracing::FilterUse
+    include Tracing::Appender::Registration  
+  
+    # register filters and appenders
+    def initialize(init_options)
+      register_filters(init_options.filters)
+      register_appenders(init_options.appenders)
+    end 
+
+    # action for tracelogs that pass the filters
+    # by default send to all appenders for further processing!
+    def handle_allow(txt, context)
+      appenders.each do |appender|
+        appender.handle(txt, context)
+      end
+    end
+
+    # action for tracelogs that DO NOT pass the filters
+    def handle_not_allow(txt, context)
+    end
+
+    # handle tracelogs by applying filters and action handler methods
+    def handle(txt, context)
+      if filters_allow?(txt, context)
+        # puts "handle_allow: " + context[:method_name]
+        handle_allow(txt, context)
+      else
+        # puts "handle_not_allow: " + context[:method_name]        
+        handle_not_allow(txt, context)
+      end
+    end
+  end # class
+end # module

data/lib/{action_handler.rb → action_handler/action_handler_registration.rb}

@@ -1,14 +1,5 @@
-require 'filters/tracing_filter'
-require 'trace_appenders'
-
 module Tracing
   class ActionHandler
-    include Tracing::Filter::Registration    
-    include Tracing::Filter::Exec    
-    include Tracing::Appender::Registration  
-
-    attr_accessor :filters
-
     # enable registration of action handlers
     module Registration
       attr_accessor :action_handlers
@@ -44,7 +35,7 @@ module Tracing
           reg_action_handlers
         end        
       end      
-      
+  
       def create_action_handler(options)
         if options.kind_of? Tracing::ActionHandler
           options
@@ -66,34 +57,5 @@ module Tracing
         @action_handlers << new_action_handlers
       end
     end
-  
-    # register filters and appenders
-    def initialize(init_options)
-      register_filters(init_options[:filters])
-      register_appenders(init_options[:appenders] || init_options)
-    end 
-
-    # action for tracelogs that pass the filters
-    # by default send to all appenders for further processing!
-    def handle_allow(txt, context)
-      appenders.each do |appender|
-        appender.handle(txt, context)
-      end
-    end
-
-    # action for tracelogs that DO NOT pass the filters
-    def handle_not_allow(txt, context)
-    end
-
-    # handle tracelogs by applying filters and action handler methods
-    def handle(txt, context)
-      if filters_allow?(txt, context)
-        # puts "handle_allow: " + context[:method_name]
-        handle_allow(txt, context)
-      else
-        # puts "handle_not_allow: " + context[:method_name]        
-        handle_not_allow(txt, context)
-      end
-    end
-  end # class
-end # module
+  end
+end

data/lib/appenders/appender.rb

@@ -6,21 +6,9 @@ module Tracing
       # array of Appender instances
       attr_accessor :appender_mappings
 
-      # used to help construct/register Appender instances using convenience symbols
-      def default_appender_mappings
-        {
-          :logger => Tracing::LoggerAppender,
-          :stream => Tracing::StreamAppender,           
-          :xml => Tracing::XmlAppender,
-          :html => Tracing::HtmlAppender,          
-          :template => Tracing::TemplateLogAppender,          
-          :default => Tracing::StreamAppender
-        }
-      end
-
       def register_default_mappings
         @appender_mappings ||= {}
-        @appender_mappings.merge!(default_appender_mappings)
+        @appender_mappings.merge!(Mappings.default_appender_mappings)
       end
 
       def register_appender_mappings(_appender_mappings)

data/lib/appenders/appender_mappings.rb

@@ -0,0 +1,13 @@
+module AppenderMappings    
+  # used to help construct/register Appender instances using convenience symbols
+  def self.defaults
+    {
+      :logger => Tracing::LoggerAppender,
+      :stream => Tracing::StreamAppender,           
+      :xml => Tracing::XmlAppender,
+      :html => Tracing::HtmlAppender,          
+      :template => Tracing::TemplateLogAppender,          
+      :default => Tracing::StreamAppender
+    }
+  end
+end

data/lib/appenders/base_appender.rb

@@ -1,8 +1,7 @@
 module Tracing
   # base appender (abstract)
   class BaseAppender
-    include Tracing::Filter::Registration  
-    include Tracing::Filter::Exec    
+    include Tracing::FilterUse
 
     attr_accessor :options
     attr_reader :tracer
@@ -10,17 +9,9 @@ module Tracing
     class << self
       attr_accessor :tracers
 
-      def default_tracers
-        {
-          :string => Tracing::OutputTemplate::StringTrace, 
-          :xml => Tracing::OutputTemplate::XmlTrace,
-          :html => Tracing::OutputTemplate::HtmlTrace,          
-          :default => Tracing::OutputTemplate::StringTrace
-        }
-      end
 
       def register_tracers(tracers = nil)
-        @tracers ||= default_tracers
+        @tracers ||= {} # default_tracers
         @tracers = @tracers.merge!(tracers || {})
       end
       

data/lib/appenders/file_appender.rb

@@ -1,19 +1,26 @@
+module Tracing
+  module DefaultPath
+    def default_path
+      return if !@default_path
+      if !File.exists?(@default_path)
+        FileUtils.mkdir_p @default_path
+      end
+      @default_path
+    end
+        
+    def default_path=(path)
+      @default_path = path
+    end
+  end
+end  
+
+
 module Tracing
   # File Appender
   class FileAppender < BaseAppender
-
+    include Tracing::DefaultPath
     class << self
-      def default_path
-        return if !@default_path
-        if !File.exists?(@default_path)
-          FileUtils.mkdir_p @default_path
-        end
-        @default_path
-      end
-            
-      def default_path=(path)
-        @default_path = path
-      end
+      include Tracing::DefaultPath
     end    
 
     # file
@@ -49,7 +56,8 @@ module Tracing
     end
 
     def file_path(file)
-      file = File.join(self.class.default_path, file) if self.class.default_path      
+      def_path = default_path || self.class.default_path
+      file = File.join(def_path, file) if self.class.default_path      
     end
 
 protected

data/lib/appenders/include.rb

@@ -0,0 +1,4 @@
+require 'appenders/base_appender'
+include_folder('appenders')
+include_folder_rec('appenders/types')
+

data/lib/appenders/types/README-NOTE.txt

@@ -0,0 +1,2 @@
+Html and Xml appenders should not be hardcoded to append to a file
+Simply include a FileAppender as a strategy if configured for this, but use file as default output strategy

data/lib/appenders/{html_appender.rb → types/html_appender.rb}

@@ -1,27 +1,7 @@
-# surround html ouput with wrapper-html
-# include jquery and css
-# collapse non-important regions and expand important ones
-
-# TODO: how to ensure html ouput finishes
-# file.seek(-20, IO:SEEK_END)
 module Tracing 
   class HtmlAppender < FileAppender   
     attr_accessor :to_file, :html_output
 
-    class << self
-      def default_path
-        return if !@default_path
-        if !File.exists?(@default_path)
-          FileUtils.mkdir_p @default_path
-        end
-        @default_path
-      end
-            
-      def default_path=(path)
-        @default_path = path
-      end
-    end    
-
     def initialize(init_options = nil)
       @tracer = Tracing::OutputTemplate::HtmlTrace.new      
       super(init_options)  
@@ -30,6 +10,10 @@ module Tracing
       return if !init_options
       # write to file
       @to_file = init_options[:to_file]  
+      
+      # override default path for class
+      @default_path = init_options[:default_path]  
+      
       if @to_file    
         write_wrap_file(to_file)
       else

data/lib/appenders/{xml_appender.rb → types/xml_appender.rb}

@@ -17,7 +17,7 @@ module Tracing
       end
     end    
 
-    def initialize(init_options)
+    def initialize(init_options = nil)
       @tracer = Tracing::OutputTemplate::XmlTrace.new      
       super(init_options)  
       @xml_output = xml_begin    

data/lib/extensions/array_extensions.rb

@@ -0,0 +1,42 @@
+class Array
+  include Tracing::RuleMatch
+    
+  def add(obj)
+    self << obj
+    self.flatten!
+    self.compact! if self
+  end
+    
+  def rule_list
+    self
+  end
+      
+  # iterate and return filters array
+  def filters
+    _filters = []
+    self.each do |_filter|
+      _filters.add(_filter.filters)
+    end
+    _filters                    
+  end
+
+  # iterate and return action_handlers array
+  def action_handlers
+    _action_handlers = []
+    self.each do |_action_handler|
+      _action_handlers.add(_action_handler.action_handlers)
+    end
+    _action_handlers                
+  end
+
+  # iterate and return action_handlers array
+  def appenders
+    _appenders = []
+    self.each do |_appender|
+      _appenders.add(_appender.appenders)
+    end
+    _appenders        
+  end
+  
+  
+end

data/lib/extensions/hash_extensions.rb

@@ -0,0 +1,181 @@
+class Hash
+  
+  def context
+    modules = self[:modules]
+    cls_name = self[:class_name]
+    method_name = self[:method_name]
+    self[:modules] = cls_name.modules if cls_name && !modules
+    self[:class_name] = cls_name.class_name if cls_name
+    calculate_full_names
+  end
+  
+  def method_name=(name)
+    self[:method_name] = name
+    calculate_full_method_name
+  end
+
+  def result=(res)
+    self[:result] = res
+  end
+
+  
+  def set_context(hash)
+    modules = hash[:modules]
+    cls_name = hash[:class_name]
+    method_name = hash[:method_name]
+    args = hash[:args]
+    vars = hash[:vars]
+    self[:modules] = cls_name.modules if cls_name
+    self[:modules] = modules if modules
+
+    self[:class_name] = cls_name.class_name if cls_name
+    self[:method_name] = method_name if method_name
+    self[:args] = args if args
+    self[:vars] = vars if vars
+
+    calculate_full_names  
+  end
+
+  def full_modules_name
+    self[:modules].join("::") if self[:modules]
+  end
+
+  def full_class_name
+    mod_name = self.full_modules_name
+    name = self[:class_name]
+    name = "#{mod_name}::#{name}" if !mod_name.blank?
+  end
+
+  def full_method_name
+    cls_name = self.full_class_name
+    name = self[:method_name]
+    name = "#{cls_name}.#{name}" if !cls_name.blank?
+  end
+
+
+  def configuration
+    Tracing::Configuration.new(self)
+  end
+  
+  def final_yield_action
+    self[:final_yield_action] || :include
+  end
+  
+  # return filter
+  def filters
+    filter_list = self[:filters]  
+    # puts "filter_list: #{filter_list.inspect}"  
+    if filter_list
+      filter_list.filters              
+    else
+      # puts "create filter from: #{self.inspect}"
+      x = self.create_filter
+      # puts "created filter: #{x.inspect}"
+      x
+    end        
+  end
+
+  # return action_handler
+  def action_handlers
+    action_handler_list = self[:action_handlers]
+    if action_handler_list
+      action_handler_list.action_handlers        
+    else
+      Tracing::ActionHandler.new(self)
+    end
+  end
+
+  # return action_handler
+  def appenders        
+    appender_list = self[:appenders]
+    appender_list.appenders
+  end
+
+  # return tracer
+  def tracer     
+    tracer_key = self[:tracer]
+    tracer_class = Mappings.default_tracer_mappings[tracer_key]   
+    tracer_class.new
+  end
+    
+  def create_filter
+    return self.filters if self[:filters]
+    hash = self.create_filter_hash || self    
+    if hash    
+      filter_class = hash.filter_class
+      # puts "hash: #{hash.inspect} -> class: #{filter_class}"
+      return filter_class.new(hash) if filter_class
+    end
+    nil    
+  end  
+
+  def create_filter_hash
+  # puts "TRY create_filter: " + name_hash.inspect
+    [:module_filter, :class_filter, :method_filter, :vars_filter].each do |symbol|
+      # puts "symbol:" + symbol.to_s
+      res = self.try_create_filter_hash(symbol) 
+      # puts "Filter created:" + res.inspect     
+      return res if res
+    end
+    # puts "no filter could be created :("
+    nil
+  end    
+
+  def try_create_filter_hash(symbol)
+    _symbol = has_any_prefix(symbol)
+    puts _symbol.inspect
+    return if !_symbol
+    
+    prefix = _symbol[:prefix]
+    filter_sym = _symbol[:filter_symbol]
+    # 
+    filter_names = self[filter_sym]
+    # 
+    rule_symbol = prefix.to_sym.rule
+    {symbol => {rule_symbol => filter_names}}    
+  end
+
+  def map(key)
+    clazz = self[key]
+    return clazz if clazz
+    self[:default]
+  end
+
+  def filter_class
+    Mappings.convenience_map.select do |key, _filter|
+      return _filter.filter_class if self.has_key?(key) || self.has_key?(_filter)
+    end
+    Mappings.filter_rule_mappings.select do |key, _filter|
+      return _filter.filter_class if self.has_key? key
+    end
+    nil
+  end
+  
+protected  
+
+  def calculate_full_names
+    self[:full_modules_name] = full_modules_name
+    self[:full_class_name] = full_class_name
+    calculate_full_method_name    
+  end
+    
+  def calculate_full_method_name
+    self[:full_method_name] = full_method_name
+  end
+
+  def has_prefix(symbol, prefix)
+    sym = symbol.prefix(prefix)
+    self.has_key?(sym) ? {:filter_symbol => sym, :prefix => prefix} : false
+  end
+
+  def has_any_prefix(symbol)
+    ['iy', 'xy', 'i', 'x'].each do |prefix|
+      hash_result = has_prefix(symbol, prefix)
+      return hash_result if hash_result         
+    end  
+    false
+  end    
+end  
+
+
+

data/lib/extensions/hash_rule_extensions.rb

@@ -0,0 +1,50 @@
+class Hash
+  include Tracing::RuleMatch
+  
+  def rules_allow_action(name)
+    rule_allow_action(name)
+  end  
+    
+  def rule_list
+    rules
+  end 
+    
+  # return a symbol, either - :include, :exclude or :exclude_and_yield, :include_and_yield or :yield (let next filter decide)  
+  def rule_allow_action(name)
+    include_rules = self[:include].rule_list
+    if !include_rules.blank?
+      # puts "Rule include"            
+      res = include_rules.matches_any?(name)
+      return :include if res
+    end
+    exclude_rules = self[:exclude].rule_list
+    if !exclude_rules.blank?
+      # puts "Rule exclude"      
+      return :exclude if exclude_rules.matches_any?(name)
+    end
+
+    rules = self[:exclude_and_yield].rule_list
+    if !rules.blank?
+      # puts "Rule exclude"      
+      return :exclude_and_yield if rules.matches_any?(name)
+    end
+
+    rules = self[:include_and_yield].rule_list
+    if !rules.blank?
+      # puts "Rule exclude"      
+      return :include_and_yield if rules.matches_any?(name)
+    end
+
+
+    # puts "Not included or excluded"          
+    if !self[:default].nil?
+      # puts "Return default: #{self[:default]}"
+      return self[:default]      
+    end
+    # puts "Rule yields"
+    return :yield
+  rescue RuleTypeError
+    # puts "error"
+    return :exclude    
+  end  
+end

data/lib/extensions/include.rb

@@ -0,0 +1 @@
+Dir.glob(File.join(File.dirname(__FILE__), '**/*.rb')).each {|f| require f }

data/lib/extensions/nilclass_extensions.rb

@@ -0,0 +1,10 @@
+class NilClass
+  def rule_list  
+    nil
+  end
+
+  def split_names  
+    nil
+  end
+
+end

data/lib/extensions/object_extensions.rb

@@ -0,0 +1,19 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+  
+  def rule_list
+    self
+  end
+
+  def appenders
+    self
+  end
+
+  def filters
+    self
+  end
+  
+end
+

data/lib/extensions/string_extensions.rb

@@ -0,0 +1,35 @@
+class String
+  def modules
+    self.split("::")[0..-2]
+  end
+
+  def class_name
+    name = self.split("::")[-1..-1]
+    name = name[0] if name.kind_of? Array 
+    name
+  end
+  
+  def in_module?(module_name)
+    modules = self.modules
+    modules.include?(module_name)      
+  end
+  
+  def rule_list  
+    self.split_names 
+  end
+  
+  def split_names
+    if self.include?(",")
+      s = self.gsub(/\s/, '')
+      s.split(",") if s
+    else
+      self.split(" ")
+    end
+  end
+  
+  # return name matching rules as array
+  # split " ", ","
+  def rules
+  end
+  
+end  

data/lib/extensions/symbol_extensions.rb

@@ -0,0 +1,30 @@
+class Symbol
+  def prefix(pre)
+    (pre.to_s + '_' + self.to_s).to_sym
+  end
+
+  def filter_class
+    mapper = Mappings.default_filters
+    mapper.map(self)
+  end
+  
+  def trace_class
+    mapper = Mappings::default_tracer_mappings
+    mapper.map(self)
+  end
+  
+  def appender_class
+    mapper = Mappings::default_appender_mappings
+    mapper.map(self)  
+  end
+  
+  def rule
+    mapper = Mappings::rule_symbol_mappings
+    mapper.map(self)  
+  end
+  
+  def appenders
+    self.appender_class.new
+  end
+  
+end