jinyu-debug-tools 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b27dc3d03a58a63332f7e55bb274c52b526f201c
-  data.tar.gz: cbfe272959aa634d7d9a87f1d6be8b85bc6dee42
+  metadata.gz: e76e237ba83f99628fb902909eef4e7797ceec83
+  data.tar.gz: bc65d505c44891b8c5cdde01b71b38dbc28c929a
 SHA512:
-  metadata.gz: d42782d5e7304f04860cd56093c325d642d4807427096eaf3d9f57d454b75476eefa64693654b6356797d6c0e85cf91de4783c1940b3c20400a3cc2d4e67902b
-  data.tar.gz: cf3bb91f1705080677893258d22318aab0a4ec71025157ba97570c81156883a6f705885b9863ff97aded70a8fc4535803ab945df9166687821f6dff28e5b8421
+  metadata.gz: f7690ed8aa9f9da47d189f967412bfe9dee817734b8e73e5676ef97c51f1809292726704c027ee4c02007eb70f93381273a0a6ea73449b2016802bf1ad65a579
+  data.tar.gz: 258c3fe62b0915556f15507a6e28b165304a8fece43f5d19c0f76514a2eb6365271ff1b5eb30ea1a64f644d6ec535d6bd05246041719c54d80859e535b48c795

data/lib/utils/code_parser.rb

@@ -0,0 +1,161 @@
+module JinyuDebugTools
+  module CodeParser
+    class CodeNode
+    
+      def initialize(name)
+        @name = name
+        @children = []
+      end
+    
+      def get_name
+        @name
+      end
+    
+      def get_parent
+        @parent
+      end
+    
+      def set_parent(parent_node)
+        @parent = parent_node
+      end
+    
+      def append_child(child_node)
+        @children << child_node
+      end
+    
+      def set_level(level)
+        @level = level
+      end
+    
+      def get_level
+        @level
+      end
+    
+      def get_index
+        @index
+      end
+    
+      def set_index(list_index)
+        @index = list_index
+      end
+    
+      def to_s
+        @name
+      end
+    
+      def to_hash
+        children = @children.map(&:to_hash)
+        children = nil if children.empty?
+        {@name => children}
+      end
+    
+      def delete_child(child_node)
+        @children.delete(child_node)
+      end
+    
+    end
+    
+    
+    class CodeTree
+    
+      ROOT_NAME = 'JiNyUsUpErNoDe'
+    
+      def initialize
+        @root = CodeNode.new(ROOT_NAME).tap { |node| node.set_level(0) }
+        @node_level_list = []
+        @node_level_list << [@root, @root.get_level]
+        @root.set_index(@node_level_list.size - 1)
+      end
+    
+      def add_record(parent_name, child_name)
+        parent_node, parent_node_index = _find_parent_with_index(parent_name)
+    
+        child_level = parent_node.get_level + 1
+    
+        mistab_nodes = _find_mistab_nodes(parent_node_index, child_level)
+        if mistab_nodes.any?
+          mistab_nodes.each do |mistab_node|
+            mistab_node.set_parent(parent_node)
+            @root.delete_child(mistab_node)
+            parent_node.append_child(mistab_node)
+          end
+        end
+    
+        child_node = CodeNode.new(child_name)
+        child_node.set_level(child_level)
+        @node_level_list << child_node
+        child_node.set_index(@node_level_list.size - 1)
+        parent_node.append_child(child_node)
+        child_node.set_parent(parent_node)
+    
+        return child_node, child_node.get_index
+      end
+    
+      def get_reverse_index(index)
+        @node_level_list.size - 1 - index
+      end
+    
+      def _find_parent_with_index(parent_name)
+        if parent_name == @root.get_name
+          return @root, @root.get_index
+        end
+    
+        target_index_reverse = @node_level_list.size - 1
+    
+        node_level_list_reverse = @node_level_list.reverse
+        node_level_list_reverse.each_with_index do |node_level_pair, index|
+          node, level = *node_level_pair
+    
+          if node.get_name == parent_name
+            target_index_reverse = index
+            break
+          end
+        end
+    
+        target_node, target_level = node_level_list_reverse[target_index_reverse]
+        target_index = get_reverse_index(target_index_reverse)
+    
+        if target_node == @root
+          target_node, target_index = add_record(@root.get_name, parent_name)
+        end
+    
+        return target_node, target_index
+      end
+    
+      def _find_mistab_nodes(parent_node_index, child_level)
+        # ... because, the father node which attached on root directly like new
+        # would match this situation, parent is root and level < child_level
+        mistab_nodes = @node_level_list[parent_node_index...-1].select do |node, level|
+          next false if node.get_parent != @root
+          next false if node.get_level >= child_level
+          true
+        end
+    
+        return mistab_nodes
+      end
+    
+      def to_hash
+        @root.to_hash
+      end
+    
+      def my_pretty_print
+        require 'json'
+        output =  JSON.pretty_generate(self.to_hash)
+        output.gsub!(/[\{\}\[\],:]| null/,'')
+        output.gsub!(/^\s+$/,'')
+        output.gsub!(/^\n/,'')
+      end
+    end
+  
+    def self.parse_logs(log_str)
+      logs =log_str.each_line.map(&:chomp)
+      records = logs.map {|log| log.split(' ')}
+      tree = CodeTree.new
+      records.each do |parent_name, child_name|
+        tree.add_record(parent_name, child_name)
+      end
+    
+      return tree.my_pretty_print
+    end
+  end
+end

data/lib/utils/method_debugger.rb

@@ -12,7 +12,8 @@ module JinyuDebugTools
           alias_method "__#{method_name}".to_sym, method_name
 
           define_method(method_name) do |*method_args, &block|
-            puts "jinyu.debug: #{caller[0]} calls #{method_name}, #{method_args}" if !method_name.to_sym.match(/^__/)
+            caller_file = caller[0].split('/').last
+            puts "jinyu.debug: #{caller_file} calls #{method_name}, #{method_args.map(&:class)}" if !method_name.to_sym.match(/^__/)
             self.send("__#{method_name}".to_sym, *method_args, &block)
           end
         end

data/lib/utils/record_formatter.rb

@@ -0,0 +1,50 @@
+module JinyuDebugTools
+  class RecordFormatter
+  
+    ELEMENT_MAPPING = {
+        :file_name => 1,
+        :line_number => 2,
+        :from_method => 3,
+        :to_method => 4,
+        :arguments => 5
+    }
+
+		# "abc.rb:123:in `cde!' calls fgh?, [String]"  
+    REG = /^(.*?)\.rb\:(\d+)\:in \`([a-zA-Z_0-9 \?\!]*?)\' calls ([a-zA-Z0-9_\?\!]+)\, \[(.*?)\]/
+    def self.format_raw_log(raw_log, required_element_names)
+  
+      raw_log_lines = raw_log.each_line.map(&:chomp)
+      p raw_log_lines.first
+      raw_log_elements = raw_log_lines.map do |line|
+        _, file_name, line_number, from_method, to_method, arguments_str = *REG.match(line)
+				# [String, Array]
+        arguments = arguments_str.split(', ')
+			
+				# in block in cde!
+        from_method = from_method.split(' ').last
+
+				# the same as match result, ignore the matched sentence
+        [nil, file_name, line_number, from_method, to_method, arguments]
+      end
+  
+      result = raw_log_elements.map do |raw_log_element|
+        required_element_names.map do |required_element_name|
+          raw_log_element[ELEMENT_MAPPING[required_element_name]]
+        end
+      end
+  
+      return result
+    end
+  
+    def self.format_raw_log_file(file_name)
+      output_file_name = "#{file_name}.record"
+      log_raw = File.open(file_name).read
+      result = RecordFormatter.format_raw_log(log_raw, [:from_method, :to_method])
+      File.open(output_file_name, 'w+') do |file|
+        result.each do |line|
+          file.puts(line.join(' '))
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jinyu-debug-tools
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Yukai Jin
@@ -16,7 +16,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/utils/code_parser.rb
 - lib/utils/method_debugger.rb
+- lib/utils/record_formatter.rb
 homepage: https://github.com/fish1928/JinyuDebugTools
 licenses:
 - MIT