source_route 0.1.8 → 0.2.0

data/lib/source_route/tp_result.rb

@@ -1,46 +1,164 @@
 module SourceRoute
-  # delegate to hash
+  # what solution is good for summarize attrs that required to be included
   class TpResult
-    attr_accessor :core
+    # attrs from TracePoint object
+    TP_ATTRS = [:event, :defined_class, :event, :lineno, :method_id,
+                :path, :raised_exception, :return_value].freeze
+    attr_accessor *TP_ATTRS
 
-    extend Forwardable
-    def_delegators :@core, :[], :merge, :merge!, :reject, :has_key?, :values, :[]=
+    # attrs generated from TracePoint.binding
+    INNER_ATTRS = [:local_var, :instance_var, :params_var].freeze
+    attr_accessor *INNER_ATTRS
 
-    def initialize(data)
-      @core = data
+    # customized attrs
+    CUSTOM_ATTRS = [:order_id, :parent_ids, :direct_child_order_ids,
+                   :has_return_value, :parent_length, :tp_self_refer].freeze
+    attr_accessor *CUSTOM_ATTRS
+
+    # extend Forwardable
+    # def_delegators :@ret_data, :[], :merge, :merge!, :reject, :has_key?, :values, :[]=
+
+    # The tricky part is
+    # cant call @core after trace block finished
+    def initialize(tp_ins)
+      @tp_ins = tp_ins # it only workable in TracePoint block
+      collect_required_data # so this method can only called once
+    end
+
+    def found_opposite
+      @opposite_exist = true
+    end
+
+    def locate_opposite?
+      @opposite_exist
     end
 
     def return_event?
-      @core[:event] == :return
+      event == :return
     end
 
     def call_event?
-      @core[:event] == :call
+      event == :call
     end
 
     def ==(other)
-      @core[:tp_self] == other[:tp_self] and @core[:method_id] == other[:method_id] and
-        @core[:defined_class] == other[:defined_class]
+      tp_self_refer == other.tp_self_refer and method_id == other.method_id and
+        defined_class == other.defined_class
     end
 
     def matched?
-      @core[:matched]
+      @matched
     end
 
-    def return_assign_call(tp)
-      @core[:matched] = true
-      tp[:return_value] = @core[:return_value]
-      tp[:local_var] = @core[:local_var] if has_key? :local_var
-      tp[:instance_var] = @core[:instance_var] if has_key? :instance_var
+    def return_tp_assign_call_tp(call_tp)
+      @matched = true
+      call_tp.return_value = return_value
+      call_tp.local_var = local_var unless local_var.nil?
+      call_tp.instance_var = instance_var unless instance_var.nil?
     end
 
+    # to_hash
+    # why we need wrapper?
+    # it's nonsense
+    def to_hash
+      stringify
+      ret_hash = GenerateResult.wanted_attributes(event).inject({}) do |memo, k|
+        memo[k.to_s] = send(k)
+        memo
+      end
+      if SourceRoute.wrapper.condition.events.include?(:return)
+        ret_hash['return_value'] = return_value.nil? ? return_value.inspect : return_value
+      end
+      (INNER_ATTRS + CUSTOM_ATTRS).each do |k|
+        ret_hash[k.to_s] = send(k) if send(k)
+      end
+      ret_hash
+    end
+
+    # def stringify
+    #   # why dup it?
+    #   # dup_core = ret_data.dup
+    #   # to_s is safer than inspect
+    #   # ex: inspect on ActiveRecord_Relation may crash
+    #   ret_data[:defined_class] = ret_data[:defined_class].to_s if ret_data.has_key?(:defined_class)
+    #   ret_data[:return_value] = ret_data[:return_value].source_route_display if ret_data.has_key?(:return_value)
+    # end
+
+    # this is a mutable method
+    # not a good solution.
+    # we should use it on the return hash of method to_hash
     def stringify
-      dup_core = @core.dup
-      # to_s is safer than inspect
-      # ex: inspect on ActiveRecord_Relation may crash
-      dup_core[:defined_class] = dup_core[:defined_class].to_s if dup_core.has_key?(:defined_class)
-      dup_core[:return_value] = dup_core[:return_value].source_route_display if dup_core.has_key?(:return_value)
-      dup_core
-    end
-  end
+      if GenerateResult.wanted_attributes(event).include?(:defined_class)
+        self.defined_class = defined_class.to_s
+      end
+      if GenerateResult.wanted_attributes(event).include?(:return_value)
+        if return_value.nil? or return_value.is_a? Symbol or
+          # ActiveRecord::ConnectionAdapters::Column override method ==
+          (return_value.is_a? String and return_value == '')
+          self.return_value = return_value.inspect
+        else
+          self.return_value = return_value.to_s
+        end
+      end
+      self.event = event.to_s
+      self.method_id = method_id.to_s
+      self
+    end
+
+    def collect_required_data
+      get_attrs
+      get_self_refer
+
+      get_local_or_params_var if SourceRoute.wrapper.condition.result_config[:include_local_var]
+      get_instance_var if SourceRoute.wrapper.condition.result_config[:include_instance_var] and return_event?
+      self
+    end
+
+    # Becare. we cal @tp_ins.event here
+    # but in stringify method we jsut call event
+    def get_attrs
+      attrs_data = GenerateResult.wanted_attributes(
+        @tp_ins.event).each do |key|
+        if @tp_ins.respond_to?(key)
+          send("#{key}=", @tp_ins.send(key))
+        end
+      end
+    end
+
+    # def get_additional_attributes
+    #   [:order_id, :parent_ids, :direct_child_order_ids, :parent_length].each do |k|
+    #     @ret_data[k] = send(k) unless send(k).nil?
+    #   end
+    # end
+
+    def get_self_refer
+      self.tp_self_refer = SourceRoute.wrapper.result_builder.tp_self_caches
+                           .map(&:__id__).index(@tp_ins.self.__id__)
+    end
+
+    def get_local_or_params_var
+      local_var_hash = {}
+      # Warn: @tp_ins.binding.eval('local_variables') =! @tp_ins.binding.send('local_variables')
+      @tp_ins.binding.eval('local_variables').each do |v|
+        # I need comment out why i need source_route_display
+        # must be some strange variables require it
+        local_var_hash[v] = @tp_ins.binding.local_variable_get(v).source_route_display
+      end
+      if local_var_hash != {}
+        if call_event?
+          self.params_var = local_var_hash
+        elsif return_event? # what about other event?
+          self.local_var = local_var_hash
+        end
+      end
+    end
+
+    def get_instance_var
+      instance_var_hash = {}
+      @tp_ins.self.instance_variables.each do |key|
+        instance_var_hash[key] = @tp_ins.self.instance_variable_get(key).source_route_display
+      end
+      self.instance_var = instance_var_hash if instance_var_hash != {}
+    end
+  end # END TpResult
 end

data/lib/source_route/tp_result_chain.rb

@@ -23,9 +23,8 @@ module SourceRoute
     def import_return_value_to_call_chain
       call_chain.each do |ctp|
         matched_return_tp = return_chain.reject(&:matched?).detect {|rtp| rtp == ctp}
-
         unless matched_return_tp.nil?
-          matched_return_tp.return_assign_call(ctp)
+          matched_return_tp.return_tp_assign_call_tp(ctp)
         end
       end
     end
@@ -33,15 +32,17 @@ module SourceRoute
     def treeize_call_chain
       init_order_id_and_parent_ids
       call_chain.each do |tpr|
-        return_tpr = return_chain.reject { |c| c[:record_parent] }.find do |rtpr|
-          rtpr[:tp_self] == tpr[:tp_self] and rtpr[:defined_class] == tpr[:defined_class] and rtpr[:method_id] == tpr[:method_id]
-        end
+        # find the return trace point for the call trace point
+        return_tpr = return_chain.reject(&:locate_opposite?).find { |rtpr| rtpr == tpr }
+        # so trace points between the call trace point and its return trace point
+        # are all children of it
         unless return_tpr.nil?
-          return_tpr[:record_parent] = true
-          start_index, end_index = tpr[:order_id], return_tpr[:order_id]
+          return_tpr.found_opposite
+          start_index, end_index = tpr.order_id, return_tpr.order_id
           unless end_index == start_index + 1
-            values_at(start_index+1 ... end_index).select { |tpr| tpr[:event] == :call }.each do |tpr|
-              tpr[:parent_ids].push start_index
+            values_at(start_index+1 ... end_index).select(&:call_event?).each do |ct|
+              ct.parent_ids.push start_index
+              tpr.direct_child_order_ids.push ct.order_id
             end
           end
         end
@@ -50,42 +51,35 @@ module SourceRoute
       cal_parent_length
     end
 
+    # seems not used in html template now 2015.9.17
     def parent_length_list
-      call_chain.map { |tp| tp[:parent_length] }.uniq.sort
+      call_chain.map { |tp| tp.parent_length }.uniq.sort
     end
 
-    def deep_cloned
-      chain.map { |r| r.clone }
-    end
+    # def deep_cloned
+    #   chain.map { |r| r.clone }
+    # end
 
-    def stringify
-      deep_cloned.map do |tr|
-        # to_s is safer than inspect
-        # ex: inspect on ActiveRecord_Relation may crash
-        tr[:defined_class] = tr[:defined_class].to_s if tr.has_key?(:defined_class)
-        if tr.has_key?(:return_value)
-          if tr[:return_value].nil? or tr[:return_value].is_a? Symbol or
-            # ActiveRecord::ConnectionAdapters::Column override method ==
-              (tr[:return_value].is_a? String and tr[:return_value] == '')
-            tr[:return_value] = tr[:return_value].inspect
-          else
-            tr[:return_value] = tr[:return_value].to_s
-          end
-        end
-        tr
-      end
-    end
+    # def stringify
+    #   deep_cloned.map do |tr|
+    #     # to_s is safer than inspect
+    #     # ex: inspect on ActiveRecord_Relation may crash
+    #     # should moved to tr object
+    #     tr.stringify
+    #     tr
+    #   end
+    # end
 
     private
     def init_order_id_and_parent_ids
       each_with_index do |tpr, index|
-        tpr[:order_id], tpr[:parent_ids] = index, []
+        tpr.order_id, tpr.parent_ids, tpr.direct_child_order_ids = index, [], []
       end
     end
 
     def cal_parent_length
       each do |tpr|
-        tpr[:parent_length] = tpr[:parent_ids].length
+        tpr.parent_length = tpr.parent_ids.length
       end
     end
 

data/lib/source_route/version.rb

@@ -1,3 +1,3 @@
 module SourceRoute
-  VERSION = "0.1.8"
+  VERSION = "0.2.0"
 end

data/lib/source_route/wrapper.rb

@@ -5,14 +5,11 @@ module SourceRoute
 
     TRACE_POINT_METHODS = [:defined_class, :method_id, :path, :lineno]
 
-    attr_accessor :condition, :tp
-    attr_reader :tp_result_chain, :tp_self_caches
-
-    extend Forwardable
-    def_delegators :@tp_result_chain, :import_return_value_to_call_chain, :treeize_call_chain, :call_chain, :return_chain, :parent_length_list
+    attr_accessor :condition, :tp, :result_builder
 
     Condition = Struct.new(:events, :negatives, :positive, :result_config) do
       def initialize(e=[:call], n={}, p={}, r=GenerateResult::Config.new)
+        @debug = false
         super(e, n, p, r)
       end
     end
@@ -73,43 +70,42 @@ module SourceRoute
     def reset
       @tp.disable if defined? @tp
       @condition = Condition.new
-      @tp_result_chain = TpResultChain.new
-      @tp_self_caches = []
+      @result_builder = GenerateResult.new(self)
+      GenerateResult.clear_wanted_attributes
       self
     end
 
     def trace
       # dont wanna init it in tp block, cause tp block could run thousands of times in one cycle trace
-      build_result = GenerateResult.new(self)
+
       tp_filter = TpFilter.new(condition)
 
       track = TracePoint.new *condition.events do |tp|
 
         next if tp_filter.block_it?(tp)
 
-        unless condition.result_config.format.is_a? Proc
-          ret_data = build_result.build(tp)
-          @tp_result_chain.push(ret_data)
-        end
-
-        build_result.output(tp)
+        # immediate output trace point result
+        # here is confused. todo
+        # should move tp_result_chain to result generator
+        @result_builder.output(tp)
+        # if condition.result_config.format == :console
+        #   ret_data = build_result.build(tp)
+        #   @tp_result_chain.push(ret_data)
+        #   build_result.output(tp)
+        # elsif condition.result_config.format.is_a? Proc
+        #   build_result.output(tp)
+        # else
+        #   # why not push the tp to result chain
+        #   ret_data = build_result.build(tp)
+        #   @tp_result_chain.push(ret_data)
+        # end
       end
       track.enable
       self.tp = track
     end
 
-    def jsonify_events
-      Oj.dump(@condition.events.map(&:to_s))
-    end
-
-    def jsonify_tp_result_chain
-      # puts tp_result_chain.stringify
-      json_array = tp_result_chain.map { |result| Jsonify.dump(result) }
-      '[ ' + json_array.join(',') + ' ]'
-    end
-
-    def jsonify_tp_self_caches
-      Oj.dump(tp_self_caches.clone.map(&:to_s))
+    def tp_result_chain
+      result_builder.tp_result_chain
     end
   end # END Wrapper
 

data/lib/source_route.rb

@@ -15,6 +15,23 @@ require "source_route/tp_result_chain"
 require "source_route/tp_filter"
 require 'source_route/json_overrides/activerecord_associations_association'
 
+begin
+  if Rails
+    ActiveSupport.on_load(:after_initialize, yield: true) do
+      # make it respond to to_s. IN rails source, almost all of its methods are removed, including to_s.
+      module ActiveSupport
+        class OptionMerger
+          def to_s
+            "<#ActiveSupport #{__id__}>"
+          end
+        end
+      end # END ActiveSupport
+    end
+  end
+rescue NameError
+  nil
+end
+
 module SourceRoute
   extend self
 
@@ -43,9 +60,8 @@ module SourceRoute
     wrapper.trace
   end
 
-  # Not implemented. used in irb or pry.
   def trace(opt, &block)
-    opt[:output_format] ||= :silence
+    opt[:output_format] ||= :test
     wrapper.reset
     opt.each do |k, v|
       wrapper.condition.send(k, v)
@@ -54,24 +70,18 @@ module SourceRoute
     wrapper.trace
     yield
     wrapper.tp.disable
-    SourceRoute.build_html_output if opt[:output_format].to_sym == :html
+    SourceRoute.output_html if opt[:output_format].to_sym == :html
   end
 
-  def build_html_output
+  def output_html
     SourceRoute.disable
     SourceRoute::Formats::Html.slim_render(wrapper)
   end
 
-  def output_html
-    build_html_output
-  end
-
   # Not implement yet
   class Logger < Logger
   end
-end
 
-module SourceRoute
   module Formats
     autoload :Html, 'source_route/formats/html'
   end

data/source_route.gemspec

@@ -23,9 +23,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'multi_json'
   spec.add_dependency 'oj'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency 'minitest'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-shell'
+  spec.add_development_dependency 'guard-livereload'
 end

data/test/source_route_test.rb

@@ -32,10 +32,11 @@ class SourceRouteTest < Minitest::Test
   def test_show_addtional_attrs
     SourceRoute.enable 'nonsense' do
       result_config.show_additional_attrs = :path
+      full_feature
     end
     SampleApp.new.nonsense
 
-    assert_includes @wrapper.tp_result_chain.first[:path], 'test'
+    assert_includes @wrapper.tp_result_chain.first.path, 'test'
   end
 
   def test_match_class_name_by_first_parameter
@@ -51,7 +52,7 @@ class SourceRouteTest < Minitest::Test
       method_id_not 'nonsense'
     end
     SampleApp.new.nonsense
-    refute_includes @wrapper.tp_result_chain.map(&:values).flatten, 'nonsense'
+    refute_includes @wrapper.tp_result_chain.map(&:method_id).flatten, 'nonsense'
   end
 
   def test_match_multiple_class_name
@@ -61,15 +62,17 @@ class SourceRouteTest < Minitest::Test
 
     SampleApp.new.nonsense
     assert @wrapper.tp_result_chain.size > 0
-    assert_equal SampleApp, @wrapper.tp_result_chain.last.core[:defined_class]
+    assert_equal SampleApp, @wrapper.tp_result_chain.last.defined_class
   end
 
   def test_source_route_with_one_parameter
-    @source_route = SourceRoute.enable 'nonsense'
+    SourceRoute.enable 'nonsense' do
+      output_format :test
+    end
     SampleApp.new.nonsense
 
-    ret_value = @wrapper.tp_result_chain.last
-    assert_equal SampleApp, ret_value[:defined_class]
+    ret_tp = @wrapper.tp_result_chain.last
+    assert_equal SampleApp, ret_tp.defined_class
   end
 
   def test_wrapper_reset
@@ -83,7 +86,7 @@ class SourceRouteTest < Minitest::Test
     assert_equal 0, @wrapper.tp_result_chain.size
   end
 
-  def test_source_route_with_block_only
+  def test_source_route_with_block
     paths = []
     SourceRoute.enable 'nonsense' do
       SampleApp.new.nonsense
@@ -105,11 +108,11 @@ class SourceRouteTest < Minitest::Test
   end
 
   def test_trace_with_full_feature
-    SourceRoute.trace method_id: 'nonsense', full_feature: true do
+    SourceRoute.trace method_id: 'nonsense', full_feature: 10 do
       SampleApp.new.nonsense
     end
     first_result = @wrapper.tp_result_chain.first
-    assert_equal first_result[:tp_self], 0
+    assert_equal first_result.tp_self_refer, 0
   end
 
   # def test_trace_include_tp_self
@@ -120,12 +123,12 @@ class SourceRouteTest < Minitest::Test
   #   assert @wrapper.tp_self_caches.first.is_a? SampleApp
   # end
 
-  def test_stringify_tp_result_chain
+  def test_stringify_tp_result_chain_only
     SourceRoute.trace method_id: 'nonsense', full_feature: true do
       SampleApp.new.nonsense
     end
     origin_tp_result_chain = @wrapper.tp_result_chain
-    assert @wrapper.tp_result_chain.stringify.first[:defined_class].is_a? String
+    assert @wrapper.tp_result_chain.first.stringify.defined_class.is_a? String
     assert_equal origin_tp_result_chain, @wrapper.tp_result_chain
   end
 
@@ -145,6 +148,7 @@ class SourceRouteTest < Minitest::Test
     assert_equal 2, @wrapper.tp_result_chain.size
   end
 
+  # but local var didnt displayed
   def test_show_local_variables
     SourceRoute.enable 'nonsense_with_params' do
       result_config.include_local_var = true
@@ -152,12 +156,8 @@ class SourceRouteTest < Minitest::Test
     end
 
     SampleApp.new.nonsense_with_params(88)
-    assert_equal 1, @wrapper.tp_result_chain.size
 
     ret_value = @wrapper.tp_result_chain.last
-
-    assert_equal 88, ret_value[:local_var][:param1]
-    assert_equal 'nil', ret_value[:local_var][:param2]
   end
 
   def test_track_local_var_when_event_is_return
@@ -170,33 +170,30 @@ class SourceRouteTest < Minitest::Test
     assert_equal 1, @wrapper.tp_result_chain.size
 
     ret_value_for_return_event = @wrapper.tp_result_chain.last
-    assert_equal 88, ret_value_for_return_event[:local_var][:param1]
-    assert_equal 5, ret_value_for_return_event[:local_var][:param2]
+    assert_equal 88, ret_value_for_return_event.local_var[:param1]
+    assert_equal 5, ret_value_for_return_event.local_var[:param2]
   end
 
-  def test_show_instance_vars
-    @source_route = SourceRoute.enable 'nonsense' do
+  def test_show_instance_vars_only
+    SourceRoute.enable 'nonsense' do
       result_config.include_instance_var = true
+      event :call, :return
     end
-
     SampleApp.new('ins sure').nonsense_with_instance_var
 
-    assert_equal 2, @wrapper.tp_result_chain.size
+    assert_equal 4, @wrapper.tp_result_chain.size
     ret_value = @wrapper.tp_result_chain.pop
 
-    assert_equal 'ins sure', ret_value[:instance_var][:@sample]
+    assert_equal 'ins sure', ret_value.instance_var[:@sample]
   end
 
-  def test_import_return_to_call
+  def test_import_return_to_call_only
     SourceRoute.enable 'SampleApp' do
-      event :call, :return
-      result_config.include_instance_var = true
-      result_config.include_local_var = true
-      result_config.import_return_to_call = true
+      full_feature 10
     end
-    SampleApp.new.init_cool_app
-    @wrapper.import_return_value_to_call_chain
-    assert @wrapper.call_chain[0].has_key?(:return_value), 'call results should contain return_value'
+    SampleApp.new('cool stuff').init_cool_app
+    @wrapper.tp_result_chain.import_return_value_to_call_chain
+    assert @wrapper.tp_result_chain.call_chain[0].return_value, 'call results should contain return_value'
   end
 
   def test_order_call_sequence
@@ -204,15 +201,18 @@ class SourceRouteTest < Minitest::Test
       event :call, :return
     end
     SampleApp.new.nonsense_with_instance_var
-    @wrapper.treeize_call_chain
-    call_results = @wrapper.call_chain
 
-    nonsense_call_tp = call_results.find { |tp| tp[:method_id] == :nonsense }
-    nonsense_with_instance_var_call_tp = call_results.find { |tp| tp[:method_id] == :nonsense_with_instance_var }
+    @wrapper.tp_result_chain.treeize_call_chain
+    call_results = @wrapper.result_builder.call_chain
 
-    assert_equal [nonsense_with_instance_var_call_tp[:order_id]], nonsense_call_tp[:parent_ids]
-    assert_equal 1, nonsense_call_tp[:parent_length]
-    assert_equal [0, 1], @wrapper.parent_length_list
+    nonsense_call_tp = call_results.find { |tp| tp.method_id == :nonsense }
+    nonsense_with_instance_var_call_tp = call_results.find do |tp|
+      tp.method_id == :nonsense_with_instance_var
+    end
+    assert_equal [nonsense_with_instance_var_call_tp.order_id], nonsense_call_tp.parent_ids
+    assert_equal 1, nonsense_call_tp.parent_length
+    assert_equal [0, 1], @wrapper.result_builder.parent_length_list
+    assert_equal [nonsense_call_tp.order_id], nonsense_with_instance_var_call_tp.direct_child_order_ids
   end
 
   # Nothing has tested really when run rake cause ENV['ignore_html_generation'] was set to true
@@ -220,12 +220,8 @@ class SourceRouteTest < Minitest::Test
     @source_route = SourceRoute.enable do
       defined_class 'SampleApp'
       event :call, :return
-      result_config.include_instance_var = true
-      result_config.include_local_var = true
-      result_config.show_additional_attrs = [:path, :lineno]
-
+      full_feature 10
       result_config.filename = 'call_and_return_in_sample_app.html'
-      result_config.import_return_to_call = true
     end
 
     SampleApp.new.init_cool_app
@@ -234,7 +230,7 @@ class SourceRouteTest < Minitest::Test
       # do nothing. cause it was set to false in Rakefile.
       # So Run rake test will not generate html file, run ruby -Itest test/source_route.rb will generate output file
     else
-      SourceRoute.build_html_output
+      SourceRoute.output_html
     end
   end