trace-util-adv 0.2.4 → 0.3.0

data/lib/filters/include.rb

@@ -1,8 +1,4 @@
-dir = 'filters/'
-require dir + 'filter'
-include_folder_rec(dir + 'simple')
-include_folder_rec(dir + 'composite')
-include_folder_rec(dir + 'list')
-include_folder_rec(dir + 'msg_context')
-include_folder_rec(dir + 'executor')
-include_folder(dir)
+require 'filters/filter'
+rfolders = Require.rfolder('filters', {:folders => ['simple', 'composite', 'list', 'msg_context', 'executor'], :root_files => :after, :exclude => 'include'})
+
+

data/lib/filters/list/list_instance_var_filter.rb

@@ -6,6 +6,7 @@ module Tracing
     end
 
     def allow_action(msg, context)
+      puts "LIF"
       action = rules[:default] || :yield      
       var_rules = rules[:vars]
       # puts "var rules: #{var_rules.inspect}"

data/lib/filters/name_filter.rb

@@ -0,0 +1,13 @@
+module Tracing
+  class NameFilter
+    attr_accessor :options
+    
+    def initialize(options)
+      @options = options
+    end
+
+    def allow?(name)
+      true
+    end        
+  end
+end

data/lib/filters/simple/argument_filter.rb

@@ -5,11 +5,12 @@ module Tracing
         
     def initialize(options)
       super(options)    
-      @rules = options[:arg_rules] || {}
+      @rules = options[:arg_rules] || options[:args_filter] || {}
       @var_name = options[:arg_name]
     end
 
     def allow_action(msg, context)
+      puts "AMF"
       obj = context[:args]
       if var_name.kind_of?(Symbol) || var_name.kind_of?(String)
         key = var_name.to_sym

data/lib/filters/simple/class_filter.rb

@@ -3,7 +3,7 @@ module Tracing
   class ClassFilter < BaseFilter
     def initialize(options)
       super(options)      
-      @rules = options[:class_rules] || {}
+      @rules = options[:class_rules] || options[:class_filter] || {}
     end
 
     def allow_action(msg, context)

data/lib/filters/simple/instance_var_filter.rb

@@ -6,20 +6,23 @@ module Tracing
     def initialize(options)
       super(options)    
       # puts "create inst.var filter: #{options.inspect}"  
-      @rules = options[:var_rules] || {}
+      @rules = options[:var_rules] || options[:vars_filter] || {}
       @var_name = options[:var_name]
     end
 
     def allow_action(msg, context)
-      # puts "InstanceVarFilter.allow_action"
+      puts "InstanceVarFilter.allow_action"
       obj = context[:self]
-      # puts "var_name: #{var_name}"
+      puts "var_name: #{var_name}"
       if var_name.kind_of?(Symbol) || var_name.kind_of?(String)
         value = obj.instance_variable_get("@#{var_name}")      
-        # puts "value: #{value}"
+        puts "value: #{value}"
         return name_allow_action(value)
-      end
-      :yield
+      else
+        puts "return default :yield"
+        :yield
+      end            
     end    
+    
   end  
 end  

data/lib/filters/simple/method_filter.rb

@@ -9,6 +9,7 @@ module Tracing
     end
 
     def allow_action(msg, context)
+      puts "MethF"
       name = context[:method_name]
       # puts "allow name?: #{name}"
       allow = name_allow_action(name)

data/lib/filters/simple/module_filter.rb

@@ -3,12 +3,15 @@ module Tracing
   class ModuleFilter < BaseFilter
     def initialize(options)
       super(options)
-      @rules = options[:module_rules] || {}
+      @rules = options[:module_rules] || options[:module_filter] || {}
     end
 
     def allow_action(msg, context)
+      puts "ModuleF"
       name = context[:full_modules_name]
-      allow = name_allow_action(name)
+      puts "name: #{name}"
+      # allow = name_allow_action(name)
     end
   end
-end  
+end  
+

data/lib/rules/rule_match.rb

@@ -3,15 +3,15 @@ module Tracing
     class RuleTypeError < RuntimeError; end  
   
     def matches_any?(name) 
-      puts "matches any: #{name.inspect}"
+      # puts "matches any: #{name.inspect}"
       self.any? do |rule| 
-        puts "rule:" + rule.inspect
-        puts "against:" + name.inspect
+        # puts "rule:" + rule.inspect
+        # puts "against:" + name.inspect
         if rule.kind_of? Regexp
           # match return position of match, or nil if no match
           # here converted into boolean result
           match = !(name =~ rule).nil? 
-          puts "match: #{match}"
+          # puts "match: #{match}"
           match
         elsif rule.kind_of? String
           match = (name == rule)
@@ -28,6 +28,7 @@ module Tracing
     end
   
     def rules_allow_action(name)
+      puts "rules_allow_action: #{name}"
       self.each do |rule|
         res = rule.rule_allow_action(name)
         return :exclude if (res == :exclude)

data/lib/targets/file_target.rb

@@ -1,10 +1,21 @@
 module Tracing
   class FileTarget
     include Tracing::DefaultPath
+
+    attr_accessor :to_file    
+    
     class << self
       include Tracing::DefaultPath
     end    
 
+    def initialize(options)
+      def_path = options[:default_path]
+      _to_file = options[:to_file]
+
+      @default_path = def_path if def_path
+      @to_file = _to_file if _to_file
+    end
+
     def append(txt, context)
       file = get_file(context)
       write_file(file, txt)

data/lib/templates/base_template.rb

@@ -2,20 +2,19 @@ require 'templates/trace_output_handler'
 
 module Tracing 
   class BaseTemplate
-      include Tracing::OutputHandler
+    include Tracing::OutputHandler
       
-      def handle_after_call(context)
-        template = end_template(context)
-        output(template, context)              
+    def handle_after_call(context)
+      template = end_template(context)
+      output(template, context)              
+    end
+
+    def handle_before_call(context)
+      template = before_template(context)
+      if context[:block]       
+        template << before_block_template
       end
-  
-      def handle_before_call(context)
-        template = before_template(context)
-        if context[:block]       
-          template << before_block_template
-        end
-        output(template, context)
-      end  
+      output(template, context)
     end  
   end
 end

data/lib/templates/html_template.rb

@@ -1,47 +1,46 @@
 module Tracing 
   class HtmlTemplate < BaseTemplate
       
-      def before_template(context)
-        # method_name = context[:method_full_name]
-        # args = context[:args].inspect
-        template = <<-EOF
-        <div class="method-title"><%= context[:method_full_name] %></div>
-        <div class="method-body">
-          <div class="begin">
-            <div class="method-name"><%= context[:method_full_name] %> :: BEGIN</div>
-            <div class="args">
-              <div class="method-args"><%= context[:args] %> </div>
-              #block#
-            </div>
+    def before_template(context)
+      # method_name = context[:method_full_name]
+      # args = context[:args].inspect
+      template = <<-EOF
+      <div class="method-title"><%= context[:method_full_name] %></div>
+      <div class="method-body">
+        <div class="begin">
+          <div class="method-name"><%= context[:method_full_name] %> :: BEGIN</div>
+          <div class="args">
+            <div class="method-args"><%= context[:args] %> </div>
+            #block#
           </div>
-      EOF
-      end
+        </div>
+    EOF
+    end
 
-      def before_block_template 
-        template = <<-EOF
-      <div class="method block-arg">(and a block)</div>
-      EOF
-      end
+    def before_block_template 
+      template = <<-EOF
+    <div class="method block-arg">(and a block)</div>
+    EOF
+    end
 
-      def end_template(context) 
-        # method_name = context[:method_full_name]
-        # result = context[:result].inspect
-        template = <<-EOF
-          <div class="end">
-            <div class="method-name"><%= context[:method_full_name] %> :: END</div>
-            <div class="method-result"><%= context[:result] %></div>
-          </div>
+    def end_template(context) 
+      # method_name = context[:method_full_name]
+      # result = context[:result].inspect
+      template = <<-EOF
+        <div class="end">
+          <div class="method-name"><%= context[:method_full_name] %> :: END</div>
+          <div class="method-result"><%= context[:result] %></div>
         </div>
-      EOF
-      end
+      </div>
+    EOF
+    end
 
-      # override
-      def handle_before_call(context)
-        template = before_template(context)
-        block_replace = context[:block] ? before_block_template : ""
-        template.gsub!(/#block#/, block_replace)
-        output(template, context)
-      end
+    # override
+    def handle_before_call(context)
+      template = before_template(context)
+      block_replace = context[:block] ? before_block_template : ""
+      template.gsub!(/#block#/, block_replace)
+      output(template, context)
     end
   end
 end

data/lib/templates/string_template.rb

@@ -25,5 +25,4 @@ module Tracing
     EOF
     end  
   end
-end
 end

data/lib/templates/template_mappings.rb

@@ -1,10 +1,10 @@
 module TemplateMappings  
   def self.defaults
     {
-      :string => Tracing::OutputTemplate::StringTrace, 
-      :xml => Tracing::OutputTemplate::XmlTrace,
-      :html => Tracing::OutputTemplate::HtmlTrace,          
-      :default => Tracing::OutputTemplate::StringTrace
+      :string => Tracing::StringTemplate, 
+      :xml => Tracing::XmlTemplate,
+      :html => Tracing::HtmlTemplate,          
+      :default => Tracing::StringTemplate
     }
   end
 end

data/lib/templates/xml_template.rb

@@ -31,5 +31,4 @@ module Tracing
       output(template, context)
     end
   end
-end
 end

data/lib/trace-util-adv.rb

@@ -1,24 +1,40 @@
 require 'rubygems'
 require 'duration'
-
-def include_folder_rec(name)
-  Dir.glob(File.join(File.dirname(__FILE__), "#{name}/**/*.rb")).each {|f| 
-    puts f
-    require f 
-  }
-end
-
-def include_folder(name)
-  Dir.glob(File.join(File.dirname(__FILE__), "#{name}/*.rb")).each {|f| 
-    puts f
-    require f 
-  }
-end
-
-include_folder_rec('rules')
-include_folder_rec('extensions')
+require 'require-magic'
+Require.base_path = File.dirname(__FILE__)
+Require.rfolder 'rules'
+Require.folder 'extensions'
 require 'filters/include'
-include_folder('output_handler')
+Require.folder 'output_handler'
 require 'appenders/include'
-include_folder_rec('action_handlers')
-include_folder_rec('targets')
+Require.rfolder('action_handler')
+Require.rfolder('targets')
+Require.rfolder('templates')
+Require.folder('trace_calls')
+
+
+# Module_filter = {
+#   :name => 'my modules',
+#   :default => :exclude,
+#   :module_rules => [{
+#     # id of modules rule set
+#     :name => ['my_modules'],
+#     :include => [/Hobo/],
+#     :exclude => [/Dryml/],
+#     :default => :exclude
+#   }]
+# }
+# 
+#   _filter = Module_filter
+# 
+#   context = {:modules => ['Blip', 'Blap']}.context
+#   
+#   puts context.inspect
+# 
+#   options = {:filters => _filter}    
+#   exec = Tracing::Filter::Executor.new(options)       
+#   result = exec.filters_allow?('msg', context)
+# 
+#   puts "Result:" + result.inspect  
+# 
+#   assert_equal false, result, "Filter should NOT allow passage"    

data/lib/trace_calls/trace_ext.rb

@@ -11,23 +11,10 @@ module Tracing
     include Tracing::Filter::Exec
 
     class << self
-      # supports 
-      # - Filter registration    
-      # - ActionHandler registration
-      include Tracing::Filter::Registration
-      include Tracing::ActionHandler::Registration
-
-      attr_accessor :final_yield_action
-
-      def configure(options)
-        # puts "Filters before config: " + Tracing::TraceExt.filters.inspect        
-        
-        register_filters(options[:filters])
-        
-        # puts "Filters after config: " + Tracing::TraceExt.filters.inspect        
-        
-        register_action_handlers(options[:action_handlers] || options)
-        @final_yield_action = options[:final_yield] || :include
+      attr_accessor :configuration
+
+      def configure(configuration)
+        @configuration ||= configuration if configuration.kind_of? Tracing::Configuration
       end
 
     end

data/test/action_handler/include.rb

@@ -0,0 +1,4 @@
+require "trace-util-adv"
+Require.base_path = File.dirname(__FILE__)
+Require.folder "../samples"
+require "test/unit"

data/test/action_handler/test_action_handler.rb

@@ -1,5 +1,4 @@
-require "trace-util-adv"
-require "test/unit"
+require 'include'
  
 class TestFilter < Test::Unit::TestCase
 

data/test/action_handler/test_create_action_handler.rb

@@ -1,9 +1,4 @@
-require "core_extensions"
-require "trace_calls"
-require "sample_filters"
-require "rubygems"
-require "duration"
-require "test/unit"
+require 'include'
  
 class TestCreateActionHandler < Test::Unit::TestCase
 
@@ -15,14 +10,16 @@ class TestCreateActionHandler < Test::Unit::TestCase
     config = {:action_handlers => {:appenders => :html}}
     result = config.action_handlers
     assert_equal Tracing::HtmlAppender, result.appenders[0].class, "Should result in action handler with HtmlAppender registered"    
-
+  end
+  
+  def test_ah
     config = {:action_handlers => {:filters => {:i_method_filter => "a,b"}}}
     result = config.action_handlers
     assert_equal Tracing::MethodFilter, result.filters[0].class, "Should result in action handler with MethodFilter registered"    
-
+    
     ah1 = {:filters => {:i_method_filter => "a,b"}, :appenders => :html}
     ah2 = {:filters => {:x_method_filter => "c,d"}, :appenders => :xml}
-  
+      
     config = {:action_handlers => [ah1, ah2]}
     result = config.action_handlers
     assert_equal Tracing::MethodFilter, result[0].filters[0].class, "Should result in action handler with MethodFilter registered"