trace-util-adv 0.2.3 → 0.2.4

data/lib/templates/string_template.rb

@@ -1,30 +1,29 @@
 module Tracing 
-  module OutputTemplate
-    class StringTrace < BaseTrace
-      def before_template(context)
-        template = <<-EOF
-      <<= <%= context[:method_full_name] %> : BEGIN
-      -----------------------------------------------
-      <%= context[:args].inspect %>
-      ===============================================
-      EOF
-      end
+  class StringTemplate < BaseTemplate
+    def before_template(context)
+      template = <<-EOF
+    <<= <%= context[:method_full_name] %> : BEGIN
+    -----------------------------------------------
+    <%= context[:args].inspect %>
+    ===============================================
+    EOF
+    end
 
-      def before_block_template 
-        template = <<-EOF
-      (and a block)
-      -----------------------------------------------
-      EOF
-      end
-  
-      def end_template(context) 
-        template = <<-EOF
-      <<= <%= context[:method_full_name] %> : END
-      -----------------------------------------------
-      <%= context[:result] %>
-      ===============================================
-      EOF
-      end  
+    def before_block_template 
+      template = <<-EOF
+    (and a block)
+    -----------------------------------------------
+    EOF
     end
+
+    def end_template(context) 
+      template = <<-EOF
+    <<= <%= context[:method_full_name] %> : END
+    -----------------------------------------------
+    <%= context[:result] %>
+    ===============================================
+    EOF
+    end  
   end
+end
 end

data/lib/templates/template_mappings.rb

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

data/lib/templates/xml_template.rb

@@ -1,36 +1,35 @@
 module Tracing 
-  module OutputTemplate
-    class XmlTrace < BaseTrace
-      def before_template(context)
-        template = <<-EOF
-      <method name="<%= context[:method_full_name] %>">
-        <modules><%= context[:full_module_name] %></modules>
-        <class><%= context[:class_name].join(',') %></class>
-        <args><%= context[:args].inspect %></args>
-        #block#
-      EOF
-      end
+  class XmlTemplate < BaseTemplate
+    def before_template(context)
+      template = <<-EOF
+    <method name="<%= context[:method_full_name] %>">
+      <modules><%= context[:full_module_name] %></modules>
+      <class><%= context[:class_name].join(',') %></class>
+      <args><%= context[:args].inspect %></args>
+      #block#
+    EOF
+    end
 
-      def before_block_template 
-        template = <<-EOF
-      <block-arg>true</block-arg>
-      EOF
-      end
+    def before_block_template 
+      template = <<-EOF
+    <block-arg>true</block-arg>
+    EOF
+    end
 
-      def end_template(context) 
-        template = <<-EOF
-        <result><%= context[:result] %></result>
-      </method>
-      EOF
-      end
+    def end_template(context) 
+      template = <<-EOF
+      <result><%= context[:result] %></result>
+    </method>
+    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
 end

data/lib/trace-util-adv.rb

@@ -1,4 +1,24 @@
-require "core_extensions"
-require "trace_calls"
-require "output_templates"
-require "duration"
+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 'filters/include'
+include_folder('output_handler')
+require 'appenders/include'
+include_folder_rec('action_handlers')
+include_folder_rec('targets')

data/lib/trace_calls/trace_configuration.rb

@@ -0,0 +1,29 @@
+module Tracing
+  class Configuration
+    class << self 
+      def apply(options)
+        in_module = options[:module]
+        classes_to_trace = options[:classes]
+        classes_to_trace.each do |cls|
+          eval "#{in_module}::#{cls}.class_eval { include Tracing::TraceCalls }"
+        end            
+      end
+    end
+    
+    include Tracing::Filter::Registration
+    include Tracing::ActionHandler::Registration
+
+    attr_accessor :final_yield_action
+
+    def initialize(options)      
+      register_filters(options.filters)
+      register_action_handlers(options.action_handlers)
+      @final_yield_action = options.final_yield_action
+    end
+    
+  end
+end  
+
+
+   
+

data/lib/{trace_ext.rb → trace_calls/trace_ext.rb}

@@ -1,14 +1,19 @@
-require 'templates/trace_output_handler'
-require 'trace_filters'
-require 'action_handler'
-require 'trace_appenders'
+require 'extensions/include'
+require 'appenders/include'
+require "templates/include"
+require 'output_handler/output_handler'
+require 'action_handler/action_handler'
+require 'filters/filter_use'
+require "duration"
 
 module Tracing
   module TraceExt
-    # include Tracing::Filter::Registration
     include Tracing::Filter::Exec
 
     class << self
+      # supports 
+      # - Filter registration    
+      # - ActionHandler registration
       include Tracing::Filter::Registration
       include Tracing::ActionHandler::Registration
 
@@ -27,10 +32,6 @@ module Tracing
 
     end
 
-    def method_full_name(context)
-      "#{context[:class_name]}.#{context[:method_name]}"
-    end
-
     def trace_method?(context)
       filters_allow?('', context)
     end

data/test/{test_action_handler.rb → action_handler/test_action_handler.rb}

@@ -1,8 +1,4 @@
-require "core_extensions"
-require "trace_calls"
-require "sample_filters"
-require "rubygems"
-require "duration"
+require "trace-util-adv"
 require "test/unit"
  
 class TestFilter < Test::Unit::TestCase

data/test/action_handler/test_create_action_handler.rb

@@ -0,0 +1,31 @@
+require "core_extensions"
+require "trace_calls"
+require "sample_filters"
+require "rubygems"
+require "duration"
+require "test/unit"
+ 
+class TestCreateActionHandler < Test::Unit::TestCase
+
+  def test_action_handlers
+    config = {:action_handlers => []}
+    result = config.action_handlers
+    assert_equal result.blank?, true, "Should result in empty action_handler list"    
+
+    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"    
+
+    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"    
+    assert_equal Tracing::MethodFilter, result[1].filters[0].class, "Should result in action handler with MethodFilter registered"    
+  end
+end

data/test/appenders/test_appender_tracers.rb

@@ -0,0 +1,56 @@
+require 'extensions/core_extensions'
+require 'filters/base_filters'
+require 'rules/hash_rule_extensions'
+require "test/unit"
+
+
+class TestAppenderTracers < Test::Unit::TestCase
+
+  def setup
+    # Trace filters
+    im_filter_1 = {:i_method_filter => "a,b"}
+    xym_class_1 = {:xy_class_filter => "C,D"}
+    @filters = [im_filter_1, xym_class_1]
+
+    @app_filter_1 = {:x_class_filter => "Dryml"}
+    @app_filter_2 = {:i_class_filter => "Template"}
+
+    @xml_tracer = {:type => :xml, :to_file => 'log_files/xml/traced.xml'}.tracer
+    @html_tracer = {:type => :html, :default_path => 'log_files/html/'}.tracer
+    @log_tracer = {:type => :log}.tracer
+    @stream_tracer = {:type => :stream}.tracer
+  end  
+  
+
+  def test_appender_register_tracer
+    # Trace configuration
+    appender_1 = {:tracer => @xml_tracer}.appender
+    assert_equal Tracing::XmlAppender, appender_1.class, "Should create instance of XmlAppender"
+
+    appender_2 = {:tracer => @html_tracer}.appender
+    assert_equal Tracing::HtmlAppender, appender_2.class, "Should create instance of HtmlAppender"
+
+    appender_3 = {:tracer => @log_tracer}.appender
+    assert_equal Tracing::HtmlAppender, appender_3.class, "Should create instance of LogAppender"
+
+    appender_4 = {:tracer => @stream_tracer}.appender
+    assert_equal Tracing::StreamAppender, appender_4.class, "Should create instance of Streamppender"
+  end
+
+
+  def test_appender_register_tracer_and_filters
+    # Trace configuration
+    appender_1 = {:tracer => @xml_tracer, :filters => @app_filter_1}.appender
+    assert_equal Tracing::XmlAppender, appender_1.class, "Should create instance of XmlAppender"
+
+    appender_2 = {:tracer => @html_tracer, :filters => @app_filter_1}.appender
+    assert_equal Tracing::HtmlAppender, appender_2.class, "Should create instance of HtmlAppender"
+
+    appender_3 = {:tracer => @log_tracer, :filters => @app_filter_1}.appender
+    assert_equal Tracing::HtmlAppender, appender_3.class, "Should create instance of LogAppender"
+
+    appender_4 = {:tracer => @stream_tracer, :filters => @app_filter_1}.appender
+    assert_equal Tracing::StreamAppender, appender_4.class, "Should create instance of Streamppender"
+  end
+
+end

data/test/appenders/test_create_appender.rb

@@ -0,0 +1,49 @@
+require 'extensions/core_extensions'
+require "test/unit"
+
+
+class TestAppenderTracers < Test::Unit::TestCase
+
+  def test_exec_xml_tracer
+    xml_tracer = {:type => :xml, :to_file => 'log_files/xml/traced.xml'}.tracer
+    assert_equal Tracing::XmlAppender, xml_tracer.class, "Should create instance of XmlTracer"
+    
+    xml_tracer.trace('hello world')    
+  end
+
+  def test_exec_html_tracer
+    html_tracer = {:type => :html, :default_path => 'log_files/html'}.tracer
+    assert_equal Tracing::HtmlAppender, html_tracer.class, "Should create instance of HtmlTracer"
+     
+    html_tracer.trace('hello world')
+  end
+
+  def test_exec_log_tracer
+    log_tracer = {:type => :log, :default_path => 'log_files'}.tracer
+    assert_equal Tracing::LoggerAppender, log_tracer.class, "Should create instance of LogTracer"
+    
+    log_tracer.trace('hello world')
+  end
+
+  def test_exec_log_tracer
+    appender = {:type => :stream, :stream => :STDOUT}.tracer
+    assert_equal Tracing::StreamAppender, log_tracer.class, "Should create instance of StreamTracer"
+    
+    stream_tracer.trace('hello world')
+  end
+
+  def test_create_appenders
+    config = {:appenders => []}
+    result = config.appenders
+    assert_equal result.blank?, true, "Should result in empty appender list"    
+
+    config = {:appenders => :html}
+    result = config.appenders
+    assert_equal result.class, Tracing::HtmlAppender, "Should result in empty appender list"    
+
+    config = {:appenders => [:xml, :html]}
+    result = config.appenders
+    assert_equal Tracing::XmlAppender, result[0].class, "Should result in xml appender"        
+    assert_equal Tracing::HtmlAppender, result[1].class, "Should also result in html appender"    
+  end
+end

data/test/{test_html_appender.rb → appenders/test_html_appender.rb}

@@ -20,17 +20,13 @@ class TestFilter < Test::Unit::TestCase
   def teardown
     ## Nothing really
   end
-    
-  def method_full_name(context)
-    "#{context[:class_name]}.#{context[:method_name]}"
-  end
-    
+        
   def test_filter
     cls_name = "Alpha::Beta::Gamma"
     name = "my_method"
     my_instance_variables = {:template_path => 'taglibs/rapid_core.dryml'}
     args = {:a => 7}
-    @context = {
+    context =  
       :modules => cls_name.modules,
       :class_name => cls_name.class_name,
       :full_class_name => cls_name,
@@ -46,7 +42,7 @@ class TestFilter < Test::Unit::TestCase
     name = "my_other_method"
 
     @context[:method_name] = name
-    @context[:method_full_name] = method_full_name(@context)
+    @context[:method_full_name] = method_full_name(@contex)
 
     @ah1.allow_append("BEGIN #{name}", @context)        
     

data/test/appenders/test_stream_appender.rb

@@ -0,0 +1,41 @@
+require "core_extensions"
+require "trace_calls"
+require "output_templates"
+require "sample_filters"
+require "rubygems"
+require "duration"
+require "test/unit"
+ 
+class TestStreamAppender < Test::Unit::TestCase
+
+  attr_reader :ah1, :filters
+
+  def setup
+    @stream_app = {:tracer => :stream, :stream => :out}      
+  end
+        
+  def test_filter
+    context = Testing.default_context
+    
+    @ah1.allow_append("BEGIN #{name}", @context)
+
+    name = "my_other_method"
+    context.method_name = name
+
+    @ah1.allow_append("BEGIN #{name}", @context)        
+    
+    context.result = "32"
+
+    @ah1.allow_append("END #{name}", @context)    
+
+    name = "my_method"
+    context.method_name = name
+        
+    context.result = "27"
+
+    @ah1.allow_append("END #{name}", @context)    
+  end
+  
+  
+end
+

data/test/appenders/test_template_log_appender.rb

@@ -0,0 +1,18 @@
+require "trace_util_adv"
+require "samples/include"
+  
+class TestDrymlTemplateLogging < Test::Unit::TestCase
+            
+  def test_dryml_template_tracing    
+    classes_to_trace = [ 'My']            
+    Tracing::TemplateLogAppender.default_path = 'log_files/templates'        
+    Tracing::TraceCalls.configure(:type => :template_log, :filters => Method_filter_dryml)                
+    my = Me::My.new
+    my.hello
+    my.hi_there
+    my.blip
+    my.blap
+  end
+  
+end
+

data/test/extensions/test_filters_creation.rb

@@ -0,0 +1,36 @@
+require 'extensions/core_extensions'
+require 'filters/base_filters'
+require 'rules/hash_rule_extensions'
+require "test/unit"
+
+
+class TestFiltersCreation < Test::Unit::TestCase
+
+  def test_try_create_method_include_filter
+    hash = {:i_method_filter => 'a,b'}
+    filter_hash = hash.create_filter
+    expected = {:method_filter => {:include => "a,b"}}
+    puts filter_hash.inspect
+    assert_equal expected, filter_hash, "Should create method include filter"
+  end
+
+  def test_filters_creation
+    # config = {:filters => []}
+    # result = config.filters
+    # assert_equal result.blank?, true, "Should result in empty filters list"    
+
+    im_filter = {:i_method_filter => "a,b"}
+    config = {:filters => im_filter}
+    
+    res = im_filter.filters
+    puts "res: #{res.inspect}"
+    
+    result = config.filters
+    puts "result: #{result.inspect}"
+    # assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
+  
+    # puts "rules: #{result.rules.inspect}"
+    # expected = {:method_filter => {:include => "a, b"} }
+    # assert_equal expected, result.rules, "Should result in method rules"    
+  end
+end