trace-util-adv 0.2.3 → 0.2.4

data/lib/core_extensions.rb

@@ -1,101 +0,0 @@
-require 'rule_match'
-
-class String
-  def modules
-    self.split("::")[0..-2]
-  end
-
-  def class_name
-    self.split("::")[-1..-1]
-  end
-  
-  def in_module?(module_name)
-    modules = self.modules
-    modules.include?(module_name)      
-  end
-  
-  def split_names
-    self.split(/\s|,/)
-  end
-  
-end  
-
-
-class Array
-  include Tracing::RuleMatch
-  
-  def add(obj)
-    self << obj
-    self.flatten!
-  end
-end
-
-class Symbol
-  def prefix(pre)
-    (pre.to_s + self.to_s).to_sym
-  end
-end
-
-class Hash
-  include Tracing::RuleMatch
-
-  def try_create_filter(symbol)
-    isymbol = has_i(symbol) || has_x(symbol)
-    # puts "try_create_filter: " + isymbol.inspect 
-    if isymbol   
-      filter_names = self[isymbol]
-      # puts "filter_names:" + filter_names.inspect
-      {symbol => {:include => filter_names}}
-    end
-  end
-  
-  def rules_allow_action(name)
-    rule_allow_action(name)
-  end  
-    
-  def rule_list(rules)
-    if rules.kind_of? String
-      rules.split_names 
-    else
-      rules
-    end
-  end 
-    
-  # return a symbol, either - :include, :exclude or :yield (let next filter decide)  
-  def rule_allow_action(name)
-    include_rules = rule_list(self[:include])
-    if include_rules && include_rules.size > 0
-      # puts "Rule include"            
-      res = include_rules.matches_any?(name)
-      return :include if res
-    end
-    exclude_rules = rule_list(self[:exclude])
-    if exclude_rules
-      # puts "Rule exclude"      
-      return :exclude if exclude_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  
-  
-protected  
-  def has_i(symbol)
-    isym = symbol.prefix('i')
-    self.has_key?(isym) ? isym : false
-  end
-
-  def has_x(symbol)
-    self.has_key?(symbol.prefix('i'))
-  end
-  
-end
-
-

data/lib/filters/base_filters.rb

@@ -1,178 +0,0 @@
-module Tracing
-
-  # abstract filter  
-  class BaseFilter
-    attr_reader :name
-    attr_accessor :rules
-
-    class << self
-      attr_accessor :filters
-
-      # register symbol => filter mappings
-      def register_filters(hash)
-        filters.merge!(hash)
-      end
-
-      # array of symbols
-      # [:special_filter, :stream_filter]
-      def unregister_filters(hash)
-        filters.reject!{|key, value| hash.include? key}
-      end
-
-      def filter_rule_mappings
-        {
-          :module_rules => :module_filter,
-          :class_rules => :class_filter,
-          :method_rules => :method_filter,        
-          :var_rules => :vars_filter,        
-          :modules => :composite_module_filter,
-          :classes => :composite_class_filter,
-          :vars => :composite_vars_filter
-        }
-      end
-
-      def convenience_map
-        {
-         :module => :module_filter,
-         :class => :class_filter,
-         :method => :method_filter,
-         :vars => :vars_filter,
-        }
-      end
-
-
-      def default_filters
-        {
-         :module_filter => Tracing::ModuleFilter,
-         :class_filter  => Tracing::ClassFilter,
-         :method_filter => Tracing::MethodFilter,
-         :vars_filter => Tracing::InstanceVarFilter,
-         :composite_module_filter => Tracing::CompositeModuleFilter,
-         :composite_class_filter => Tracing::CompositeClassFilter,
-         :composite_vars_filter => Tracing::CompositeInstanceVarFilter
-        }
-      end
-
-      def get_filter(options)
-        convenience_map.select do |key, _filter|
-          return _filter if options.has_key?(key) || options.has_key?(_filter)
-        end
-        filter_rule_mappings.select do |key, _filter|
-          return _filter if options.has_key? key
-        end
-        return options        
-      end
-
-      # Example:
-      # {:method, :include => 'hello,way'}
-      # {:class, :include => 'A,B', :exclude => 'C'}
-      def filter_by_hash(options)
-        filters ||= default_filters
-
-        # try by factory
-        new_filter = Tracing::Filter.create_filter(options) 
-        
-        # puts "New filter: #{new_filter.inspect}"
-        
-        options = new_filter if new_filter
-        
-        # try by other means
-        type = get_filter(options)      
-
-        if type && type.kind_of?(Symbol)
-          filter_class = filters[type]
-
-          # puts "filter class: #{filter_class}"
-        
-          # ensure options has rules                  
-          if filter_class
-            filter_class.new(options)
-          else
-            raise Exception, "Filterclass not found"
-          end
-        end
-      end
-
-      # TODO: Refactor using symbol map!
-      def create_filter(options)
-        if options.kind_of? Hash
-          _filter = filter_by_hash(options)
-        elsif options.kind_of? BaseFilter
-          options
-        else
-          nil
-        end
-      end
-    
-    end
-  
-    def initialize(options)
-      @name = options[:name] || "Unknown filter"      
-    end
-    
-    def name_allow_action(name)
-      res = rules.rules_allow_action(name)
-    end
-  end
-
-  # filter on module
-  class ModuleFilter < BaseFilter
-    def initialize(options)
-      super(options)
-      @rules = options[:module_rules] || {}
-    end
-
-    def allow_action(msg, context)
-      name = context[:full_module_name]
-      allow = name_allow_action(name)
-    end
-  end
-
-  # filter on class name
-  class ClassFilter < BaseFilter
-    def initialize(options)
-      super(options)      
-      @rules = options[:class_rules] || {}
-    end
-
-    def allow_action(msg, context)
-      name = context[:class_name]
-      allow = name_allow_action(name)
-    end
-  end
-
-
-  # filter on method
-  class MethodFilter < BaseFilter
-    def initialize(options)
-      super(options)      
-      @rules = options[:method_rules] || options[:method_filter] || {}
-    end
-
-    def allow_action(msg, context)
-      name = context[:method_name]
-      @encountered ||= []
-      name_allow_action(name)
-    end
-  end
-  
-  # filter on instance variables
-  class InstanceVarFilter < BaseFilter
-    attr_accessor :var_name
-        
-    def initialize(options)
-      super(options)      
-      @rules = options[:var_rules] || {}
-      var_name = options[:var_name]
-    end
-
-    def allow_action(msg, context)
-      obj = context[:self]
-      if var_name.kind_of?(Symbol) || var_name.kind_of?(String)
-        value = obj.instance_variable_get(var_name)      
-        return name_allow_action(value)
-      end
-      :yield
-    end    
-  end  
-end

data/lib/filters/composite_filters.rb

@@ -1,71 +0,0 @@
-module Tracing
-  class CompositeClassFilter < BaseFilter
-    def initialize(options)
-      super(options)      
-      @rules = options || {}
-    end
-
-    # filter on class names and then methods within those classes
-    def allow?(msg, context)
-      # class name of context
-      class_name = context[:class_name]
-      rules[:classes].each do |clazz|
-        names=clazz[:names]
-        next if !names.matches_any?(name)
-        # if name matches rule
-        method_filter = MethodFilter.new(clazz)
-        return false if !method_filter.allow?(msg, context)
-      end
-      return true
-    end
-  end
-
-  class CompositeModuleFilter < BaseFilter
-    def initialize(options)
-      super(options)      
-      @rules = options || {}
-    end
-
-    # filter on module names and then on class names and methods within those modules
-    def allow?(msg, context)
-      modules_name = context[:full_module_name]
-      rules[:modules].each do |_module|
-        # get names of modules to match
-        names = _module[:names]
-        # test if current module name matches any of the module names for this rule
-        next if !names.matches_any?(modules_name)
-        # if name matches rule
-        if _module[:classes]
-          composite_class_filter = CompositeClassFilter.new(_module)
-          return false if !composite_class_filter.allow?(msg, context)
-        end
-        if _module[:class_rules]
-          class_filter = ClassFilter.new(_module)
-          return false if !class_filter.allow?(msg, context)
-        end
-        if _module[:method_rules]
-          method_filter = MethodFilter.new(_module)
-          return false if !method_filter.allow?(msg, context)
-        end
-      end
-      # log it!
-      true
-    end
-  end
-
-  class CompositeInstanceVarFilter < BaseFilter
-    def initialize(options)
-      super(options)      
-      @rules = options || {}
-    end
-
-    def allow?(msg, context)
-      rules[:vars].each do |var|
-        var_filter = InstanceVarFilter.new(var)
-        return false if !var_filter.allow?(msg, context)
-      end
-      true
-    end
-  end
-
-end

data/lib/output_templates.rb

@@ -1,5 +0,0 @@
-require 'erb'
-require 'templates/base_template'
-require 'templates/string_template'
-require 'templates/html_template'
-require 'templates/xml_template'

data/lib/sample_filters.rb

@@ -1,97 +0,0 @@
-# my_instance_variables = {:template_path => 'taglibs/rapid_core.dryml'}
-# args = {:a => 7}
-# context = {
-#   :modules => cls_name.modules,
-#   :class_name => cls_name.class_name,
-#   :full_class_name => cls_name,
-#   :method_name => name,
-#   :args => args,
-#   :block => false,
-#   :vars => my_instance_variables # to carry @template_path etc.
-# } 
-
-Module_filter_A = {
-  :name => 'my modules',
-  :module_rules => [{
-    # id of modules rule set
-    :name => ['my_modules'],
-    :include => [/Al/],
-    :exclude => [/Be/],
-    :default => true
-  }
-]}
-
-Class_filter_A = {
-  :name => 'my classes',  
-  :class_rules => [{
-    # id of class rule set
-    :name => 'my_classes',
-    :include => [/MyCl/],
-    :exclude => [/NotMy/],
-    :include_and_yield => ['blap'],    
-    :default => false
-  }]
-}
-
-Method_filter_A = {
-  :name => 'my methods',  
-  :method_rules => [{
-    # id of method rule set
-    :name => 'my_methods',
-    :include => [/by.*/, 'compile', 'do_it'],
-    :exclude => ['my.*'],
-    :exclude_and_yield => ['blip'],
-    :default => false
-  }]
-}
-
-Class_composite_filter_A = {
-  # id of composite rule set  
-  :name => 'Template stuff',
-  :classes => [{
-    :names => ['My', /My/],
-    :method_rules => {
-      :include => [/by.*/, 'DRYMLBuilder'],
-      :exclude => ['Taglib'],
-      :default => false
-    }
-  }]
-}
-
-Module_composite_filter_A = {
-  # id of composite rule set    
-  :name => 'dryml_filter',
-  :modules => [{
-    :names => ['Hobo:Dryml', /Dryml/],
-    :class_rules => {
-      :include => [/Template.*/, 'DRYMLBuilder'],
-      :exclude => ['Taglib'],
-      :default => true
-    },
-    :method_rules => {
-      :include => [/Template.*/, 'DRYMLBuilder'],
-      :exclude => ['Taglib'],
-      :default => true
-    }
-  }]
-}
-
-
-# for specific instance_vars, match on values (after .to_s on var)  
-Var_composite_filter_A = {
-  :name => 'template_path',
-  :vars => [{
-    :name => 'template_path', :type => :string,
-    :var_rules => {
-      :include => [/.*\/taglib\/.*/], 
-      :exclude => [/.*\/rapid_.*/]         
-    } 
-    },
-    {
-      :name => 'template_path', 
-      :var_rules => {
-        :exclude => [/.*\/rapid_.*/],         
-        :default => true
-      } 
-    }]
-}

data/lib/trace_appenders.rb

@@ -1,9 +0,0 @@
-require 'appenders/appender_registration'
-require 'appenders/appender'
-require 'appenders/base_appender'
-require 'appenders/file_appender'
-require 'appenders/logger_appender'
-require 'appenders/stream_appender'
-require 'appenders/xml_appender'
-require 'appenders/html_appender'
-require 'appenders/template_log_appender'

data/lib/trace_filters.rb

@@ -1,4 +0,0 @@
-require 'filters/tracing_filter'
-require 'filters/base_filters'
-require 'filters/composite_filters'
-require 'filters/filter_factory'

data/test/test_appender.rb

@@ -1,29 +0,0 @@
-require "core_extensions"
-require "trace_calls"
-require "sample_filters"
-require "rubygems"
-require "duration"
-require "test/unit"
- 
-class TestFilter < Test::Unit::TestCase
-
-  attr_reader :ah1, :filters
-
-  def setup
-    # Tracing::Appender.register_default_mappings    
-    
-    # test all the ways an appender can be initialized!
-    @ah1 = Tracing::LoggerAppender.new(:tracer => :html)      
-  end
-
-  def teardown
-    ## Nothing really
-  end
-    
-  def test_filter
-    puts @ah1.inspect
-  end
-  
-  
-end
-

data/test/test_file_appender.rb

@@ -1,32 +0,0 @@
-require "core_extensions"
-require "trace_calls"
-require "sample_filters"
-require "rubygems"
-require "duration"
-require "test/unit"
- 
-class TestFilter < Test::Unit::TestCase
-
-  attr_reader :ah1, :filters
-
-  def setup
-    # Tracing::Appender.register_default_mappings    
-    @file = 'test.txt'
-    
-    # test all the ways an appender can be initialized!
-    @file_appender = Tracing::FileAppender.new({:overwrite => true, :to_file => @file})
-  end
-
-  def teardown
-    ## Nothing really
-  end
-    
-  def test_filter
-    @file_appender.write_file(@file, "Hello World")
-    marker_txt = 'World'
-    @file_appender.insert_into_file(@file, 'My old ', marker_txt)
-  end
-  
-  
-end
-

data/test/test_filters.rb

@@ -1,112 +0,0 @@
-require "core_extensions"
-require "trace_calls"
-require "output_templates"
-require "sample_filters"
-require "rubygems"
-require "duration"
-require "test/unit"
-
-# configure use of TraceExt
-module Me
-  class My     
-
-    def hello
-      puts "Hello cruel World!"
-    end   
-
-    def hi_there
-      puts "Hello cruel World!"
-    end   
-
-    def blip
-      puts "Blip!"
-    end   
-
-    def blap
-      puts "Blap!"
-    end   
-
-  end    
-end
-
-Method_filter_hello = {
-  :name => 'my methods',  
-  :method_rules => [{
-    # id of method rule set
-    :name => 'my_methods',
-    :include => [/hi.*/, 'blip', 'blap'],
-    :exclude => ['hello'],
-    :default => false
-  }]
-}    
- 
-  
-class TestFilter < Test::Unit::TestCase
-
-  attr_reader :ah1, :filters
-
-  def setup
-    # module filter is created (see sample filters)
-    # @module_filter = Tracing::ModuleFilter.new(Module_filter_A)        
-
-    # Appender is configured with some appender options and a Tracer
-    # string_tracer = Tracing::OutputTemplate::StringTrace.new        
-    # template_log_options = {:options => {:overwrite => false, :time_limit => 2.minutes}, :tracer => string_tracer}
-    # tla1 = Tracing::TemplateLogAppender.new(:options => {:overwrite => false, :time_limit => 2.minutes}, :tracer => :string)  
-    
-    # action handler is configured with a set of filters and a set of appenders
-    # the appenders are called in turn if log statement passes all filters!
-    @ah1 = Tracing::ActionHandler.new(:filters => @filters = [Module_filter_A, Method_filter_A], :appenders => :logger)    
-
-    appender_options = {:options => {:overwrite => false, :time_limit => 2.minutes}, :type => :logger, :tracer => :string}
-
-    # @ah2 = Tracing::ActionHandler.new(:filters => @filters = [Module_filter_A, Method_filter_A], :appenders => appender_options)    
-
-    # TraceExt is configured with a set of action handlers
-    # on any method call the set of action handlers are called if all initial filters are passed 
-    # Tracing::TraceExt.register_action_handlers([ah1])
-  end
-
-  def teardown
-    ## Nothing really
-  end
-            
-  def test_filter
-    # module_filter = Tracing::ModuleFilter.new(Module_filter_A)   
-    
-    # TraceExt can be configured with a set of 'initial' filters, that determine if the method should have theaspects applied at all     
-    # Tracing::TraceExt.register_filters([module_filter])
-    # , :filters => Class_filter_A     
-    # Tracing::TraceExt.configure(:action_handlers => [ah1])
-    # Tracing::TraceExt.configure(:appenders => :logger)
-    
-    dryml_classes_to_trace = [ 'My']
-
-    dryml_classes_to_trace.each do |cls|
-      str = "Me::#{cls}.class_eval { include Tracing::TraceCalls }"
-      puts str
-      eval str
-    end    
-    
-    # Me::My.class_eval { include Tracing::TraceCalls }
-        
-    Tracing::HtmlAppender.default_path = 'log_files/html'
-        
-    # Tracing::TraceExt.configure(:appenders => {:type => :html, :to_file => 'log_files/html/traced.html'})    
-    Tracing::TraceExt.configure(:type => :html, :to_file => 'traced4.html', :filters => Method_filter_hello)        
-        
-    # Tracing::TraceExt.configure(:filters => Class_filter_A)
-    # 
-    my = Me::My.new
-    my.hello
-    my.hi_there
-    my.blip
-    my.blap
-
-    
-    # my.action_handlers(['a', 'b'], context)           
-  end
-  
-  
-end
-

data/test/test_filters_create.rb

@@ -1,28 +0,0 @@
-require "core_extensions"
-require "trace_calls"
-require "output_templates"
-require "rubygems"
-require "duration"
-require "test/unit"
- 
-class TestFilter < Test::Unit::TestCase
-
-  def teardown
-    ## Nothing really
-  end
-    
-  def test_filter_create
-
-    names = %w{blip blop}
-    puts "create include method filter, names: #{names}" 
-    method_filter_B = Tracing::Filter.create_filter({:imethod_filter =>  names})
-    
-    f = Tracing::BaseFilter.create_filter(method_filter_B)
-    
-    puts method_filter_B.inspect
-    puts f.inspect
-  end
-  
-  
-end
-