trace-util-adv 0.2.4 → 0.3.0

data/TODO.txt

@@ -1,7 +1,23 @@
 TODO:
 ----
-- Unit tests for appenders. action_handler
-- require txt_file_mutator
+- Clean up Appenders, Templates and Targets
+- Convenience Appenders
+  - LogFile
+  - HtmlFile
+  - XmlFile
+  - HtmlString
+  - XmlString
+  - Logger
+  
+  - Targets
+    - File
+    - String
+    - Stream (STDOUT, STDERR)    
+    - Stack
+    
+  - Add listener to Target?
+  
+  - Simplify with Listener model?
 
 ---
 Add time to context for before- and after handle calls. Enable tracing time output 

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.3.0

data/lib/appenders/appender.rb

@@ -8,7 +8,7 @@ module Tracing
 
       def register_default_mappings
         @appender_mappings ||= {}
-        @appender_mappings.merge!(Mappings.default_appender_mappings)
+        @appender_mappings.merge!(AppenderMappings.defaults)
       end
 
       def register_appender_mappings(_appender_mappings)

data/lib/appenders/base_appender.rb

@@ -4,24 +4,24 @@ module Tracing
     include Tracing::FilterUse
 
     attr_accessor :options
-    attr_reader :tracer
+    attr_reader :templates
     
     class << self
-      attr_accessor :tracers
+      attr_accessor :templates
 
 
-      def register_tracers(tracers = nil)
-        @tracers ||= {} # default_tracers
-        @tracers = @tracers.merge!(tracers || {})
+      def register_templates(templates = nil)
+        @templates ||= {} # default_templates
+        @templates = @templates.merge!(templates || {})
       end
       
-      def create_tracer(tracer)
-        tracers ||= register_tracers
-        if tracer.kind_of?(Symbol) || tracer.kind_of?(String)
-          tracer_class = tracers[tracer.to_sym] || tracers[:default]
-          tracer_class.new
-        elsif tracer.kind_of? Tracing::OutputTemplate::Trace
-          tracer
+      def create_template(template)
+        templates ||= register_templates
+        if template.kind_of?(Symbol) || template.kind_of?(String)
+          template_class = templates[template.to_sym] || templates[:default]
+          template_class.new
+        elsif template.kind_of? Tracing::BaseTemplate
+          template
         else
           nil
         end
@@ -33,18 +33,16 @@ module Tracing
       if init_options.kind_of? Hash
         @options = init_options[:options] || init_options
         register_filters(init_options[:filters])
-        tracer = @options[:tracer] if @options
-        return if !tracer
+        template = @options[:template] if @options
+        return if !template
 
-        tracer = self.class.create_tracer(tracer)      
-        @tracer = tracer         
+        @template = self.class.create_template(template)      
       elsif init_options.kind_of? Symbol
-        self.class.register_tracers
-        tracer = self.class.tracers[init_options]
+        self.class.register_templates
+        tracer = self.class.templates[init_options]
         return if !tracer
 
-        tracer = self.class.create_tracer(tracer)      
-        @tracer = tracer                 
+        @template = self.class.create_template(template)
       else
         raise Exception, "Appender must be initialized with Hash"
       end

data/lib/appenders/include.rb

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

data/lib/appenders/types/html_appender.rb

@@ -3,7 +3,7 @@ module Tracing
     attr_accessor :to_file, :html_output
 
     def initialize(init_options = nil)
-      @tracer = Tracing::OutputTemplate::HtmlTrace.new      
+      @tracer = Tracing::HtmlTemplate.new      
       super(init_options)  
       @html_output = html_begin 
 

data/lib/appenders/types/logger_appender.rb

@@ -36,7 +36,7 @@ module Tracing
     end    
 
     def initialize(init_options)
-      @tracer = Tracing::OutputTemplate::StringTrace.new      
+      @tracer = Tracing::StringTemplate.new      
       super(init_options)
                   
       if init_options.kind_of? Hash            

data/lib/appenders/types/xml_appender.rb

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

data/lib/extensions/hash_extensions.rb

@@ -7,6 +7,7 @@ class Hash
     self[:modules] = cls_name.modules if cls_name && !modules
     self[:class_name] = cls_name.class_name if cls_name
     calculate_full_names
+    self
   end
   
   def method_name=(name)
@@ -85,17 +86,31 @@ class Hash
     end
   end
 
-  # return action_handler
   def appenders        
     appender_list = self[:appenders]
-    appender_list.appenders
+    return appender_list.appenders if appender_list
+    template = self.template
+    if template
+      puts template.inspect
+    else
+      puts "no template"
+    end
   end
 
-  # return tracer
-  def tracer     
-    tracer_key = self[:tracer]
-    tracer_class = Mappings.default_tracer_mappings[tracer_key]   
-    tracer_class.new
+  # Rework?
+  def appender        
+    puts self[:template].inspect
+    # appenders
+  end
+
+
+  # return template
+  def template     
+    puts "Template from : #{self.inspect}"
+    template_key = self[:template] || self[:type]
+    template_class = TemplateMappings.defaults[template_key]
+    puts template_class.inspect
+    template_class.new self if template_class
   end
     
   def create_filter
@@ -103,15 +118,19 @@ class Hash
     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
+      if filter_class
+        filter_class.new(hash) 
+      else
+        nil
+      end
+    else
+      nil
     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|
+    [:module_filter, :class_filter, :method_filter, :vars_filter, :args_filter].each do |symbol|
       # puts "symbol:" + symbol.to_s
       res = self.try_create_filter_hash(symbol) 
       # puts "Filter created:" + res.inspect     
@@ -123,14 +142,14 @@ class Hash
 
   def try_create_filter_hash(symbol)
     _symbol = has_any_prefix(symbol)
-    puts _symbol.inspect
+    # 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
@@ -142,10 +161,10 @@ class Hash
   end
 
   def filter_class
-    Mappings.convenience_map.select do |key, _filter|
+    FilterMappings.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|
+    FilterMappings.rules_map.select do |key, _filter|
       return _filter.filter_class if self.has_key? key
     end
     nil
@@ -154,13 +173,16 @@ class Hash
 protected  
 
   def calculate_full_names
-    self[:full_modules_name] = full_modules_name
-    self[:full_class_name] = full_class_name
+    fmm = full_modules_name
+    fcm = full_class_name
+    self[:full_modules_name] = fmm if fmm
+    self[:full_class_name] = fcm if fcm
     calculate_full_method_name    
   end
     
   def calculate_full_method_name
-    self[:full_method_name] = full_method_name
+    fmn = full_method_name
+    self[:full_method_name] = fmn if fmn
   end
 
   def has_prefix(symbol, prefix)

data/lib/extensions/hash_rule_extensions.rb

@@ -2,6 +2,7 @@ class Hash
   include Tracing::RuleMatch
   
   def rules_allow_action(name)
+    puts "Hash: rules_allow_action"
     rule_allow_action(name)
   end  
     
@@ -12,6 +13,9 @@ class Hash
   # 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
+    
+    puts "include_rules: #{include_rules.inspect}, name: #{name}"
+    
     if !include_rules.blank?
       # puts "Rule include"            
       res = include_rules.matches_any?(name)

data/lib/extensions/symbol_extensions.rb

@@ -4,27 +4,29 @@ class Symbol
   end
 
   def filter_class
-    mapper = Mappings.default_filters
+    mapper = FilterMappings.defaults
     mapper.map(self)
   end
   
   def trace_class
-    mapper = Mappings::default_tracer_mappings
+    mapper = TemplateMappings.defaults
     mapper.map(self)
   end
   
   def appender_class
-    mapper = Mappings::default_appender_mappings
+    mapper = AppenderMappings.defaults
     mapper.map(self)  
   end
   
   def rule
-    mapper = Mappings::rule_symbol_mappings
+    mapper = RuleMappings.prefix_map
     mapper.map(self)  
   end
   
   def appenders
-    self.appender_class.new
+    puts "Appenders from: #{self.inspect}"
+    puts "appender_class: #{self.appender_class.inspect}"
+    self.appender_class.new nil
   end
   
 end

data/lib/filters/composite/composite_class_filter.rb

@@ -7,6 +7,7 @@ module Tracing
 
     # filter on class names and then methods within those classes
     def allow_action(msg, context)
+      puts "CC"
       # class name of context
       class_name = context[:class_name]
       action = rules[:default] || :yield

data/lib/filters/composite/composite_module_filter.rb

@@ -7,6 +7,7 @@ module Tracing
 
     # filter on module names and then on class names and methods within those modules
     def allow_action(msg, context)
+      puts "CM"
       modules_name = context[:full_modules_name]
       action = rules[:default] || :yield 
       # puts "modules_name: #{modules_name}"     

data/lib/filters/executor/filter_exec.rb

@@ -22,16 +22,18 @@ module Tracing
         # default allow return value
         allow = (final_yield_action == :exclude ? false : true)               
         
-        # puts "default allow: #{allow}"
+        puts "default allow: #{allow}"
         # puts "filters: #{@filters}"  
         
         return allow if @filters.blank?        
         
+        puts "iterate filters"
         @filters.each do |_filter|
+          puts "filter:" + _filter.inspect
           # apply filter
           if _filter 
             res = _filter.allow_action(msg, context)
-            # puts "res: #{res}"  
+            puts "res: #{res}"  
 
             if (res == :include_and_yield)
               allow = true
@@ -53,6 +55,8 @@ module Tracing
               break
             end
             # puts "yielding..."
+          else
+            puts "filter is null"
           end
         end
         # puts "filters_allow?: #{allow}"

data/lib/filters/filter.rb

@@ -1,15 +1,4 @@
 module Tracing
-
-  # interface (abstract class)
-  # instances of this form can be used as filters inside include/exclude lists
-  class NameFilter 
-    # return boolean
-    def allow?(name)
-      true
-    end
-  end
-
-
   # abstract filter  
   class BaseFilter
     attr_reader :name
@@ -17,11 +6,13 @@ module Tracing
 
     class << self
       attr_accessor :filters
-    
+        
       # register symbol => filter mappings
       def register_filters(hash)
-        @filters ||= {}
-        filters.merge!(hash)
+        # puts "register_filters: #{hash.inspect}"
+        @filters ||= {}        
+        @filters.merge!(hash)
+        return @filters
       end
 
       # array of symbols
@@ -31,13 +22,17 @@ module Tracing
         filters.reject!{|key, value| hash.include? key}
       end    
     end
-  
+    
     def initialize(options = {})
       @name = options[:name] || "Unknown filter"      
     end
     
     def name_allow_action(name)
-      res = rules.rules_allow_action(name)
+      puts "name_allow_action: #{name}"
+      # res = rules.rules_allow_action(name)
     end
   end  
-end
+end
+
+Tracing::BaseFilter.register_filters({})
+

data/lib/filters/filter_factory.rb

@@ -6,7 +6,7 @@ module Tracing::Filter
     # puts "TRY create_filter: " + name_hash.inspect
       [:module_filter, :class_filter, :method_filter, :vars_filter].each do |symbol|
         # puts "symbol:" + symbol.to_s
-        res = name_hash.try_create_filter(symbol) 
+        res = name_hash.try_create_filter_hash symbol
         # puts "Filter created:" + res.inspect     
         return res if res
       end

data/lib/filters/filter_mappings.rb

@@ -6,9 +6,10 @@ module FilterMappings
       :class_rules => :class_filter,
       :method_rules => :method_filter,        
       :var_rules => :vars_filter,        
+      :arg_rules => :args_filter,        
       :modules => :composite_module_filter,
       :classes => :composite_class_filter,
-      :vars => :composite_vars_filter
+      :vars => :list_vars_filter
     }
   end
 
@@ -28,9 +29,10 @@ module FilterMappings
      :class_filter  => Tracing::ClassFilter,
      :method_filter => Tracing::MethodFilter,
      :vars_filter => Tracing::InstanceVarFilter,
+     :args_filter => Tracing::ArgumentFilter,
      :composite_module_filter => Tracing::CompositeModuleFilter,
      :composite_class_filter => Tracing::CompositeClassFilter,
-     :composite_vars_filter => Tracing::CompositeInstanceVarFilter
+     :list_vars_filter => Tracing::ListInstanceVarFilter
     }
   end  
 end