tapping_device 0.4.8 → 0.5.1

data/lib/tapping_device.rb

@@ -2,9 +2,9 @@ require "active_record"
 require "tapping_device/version"
 require "tapping_device/manageable"
 require "tapping_device/payload"
+require "tapping_device/output_payload"
 require "tapping_device/trackable"
 require "tapping_device/exceptions"
-require "tapping_device/sql_tapping_methods"
 
 class TappingDevice
 
@@ -16,7 +16,6 @@ class TappingDevice
   @devices = []
   @suspend_new = false
 
-  include SqlTappingMethods
   extend Manageable
 
   def initialize(options = {}, &block)
@@ -25,12 +24,16 @@ class TappingDevice
     @options = process_options(options)
     @calls = []
     @disabled = false
+    @with_condition = nil
     self.class.devices << self
   end
 
   def tap_init!(klass)
     raise "argument should be a class, got #{klass}" unless klass.is_a?(Class)
-    track(klass, condition: :tap_init?)
+    track(klass, condition: :tap_init?) do |payload|
+      payload[:return_value] = payload[:receiver]
+      payload[:receiver] = klass
+    end
   end
 
   def tap_on!(object)
@@ -46,8 +49,21 @@ class TappingDevice
     track(record, condition: :tap_associations?)
   end
 
-  def and_print(payload_method)
-    @output_block = -> (payload) { puts(payload.send(payload_method)) }
+  def and_print(payload_method = nil, &block)
+    @output_block =
+      if block
+        -> (output_payload) { puts(block.call(output_payload)) }
+      elsif payload_method
+        -> (output_payload) { puts(output_payload.send(payload_method)) }
+      else
+        raise "need to provide either a payload method name or a block"
+      end
+
+    self
+  end
+
+  def with(&block)
+    @with_condition = block
   end
 
   def set_block(&block)
@@ -81,7 +97,7 @@ class TappingDevice
 
   private
 
-  def track(object, condition:)
+  def track(object, condition:, &payload_block)
     @target = object
     @trace_point = TracePoint.new(options[:event_type]) do |tp|
       if send(condition, object, tp)
@@ -89,7 +105,16 @@ class TappingDevice
 
         next if should_be_skipped_by_paths?(filepath)
 
-        payload = build_payload(tp: tp, filepath: filepath, line_number: line_number)
+        payload = build_payload(tp: tp, filepath: filepath, line_number: line_number, &payload_block)
+
+        next unless with_condition_satisfied?(payload)
+
+        # skip TappingDevice related calls
+        if Module.respond_to?(:module_parents)
+          next if payload.defined_class.module_parents.include?(TappingDevice)
+        else
+          next if payload.defined_class.parents.include?(TappingDevice)
+        end
 
         record_call!(payload)
 
@@ -130,15 +155,12 @@ class TappingDevice
   end
 
   def build_payload(tp:, filepath:, line_number:)
-    arguments = {}
-    tp.binding.local_variables.each { |name| arguments[name] = tp.binding.local_variable_get(name) }
-
-    Payload.init({
+    payload = Payload.init({
       target: @target,
       receiver: tp.self,
       method_name: tp.callee_id,
       method_object: get_method_object_from(tp.self, tp.callee_id),
-      arguments: arguments,
+      arguments: collect_arguments(tp),
       return_value: (tp.return_value rescue nil),
       filepath: filepath,
       line_number: line_number,
@@ -146,6 +168,10 @@ class TappingDevice
       trace: get_traces(tp),
       tp: tp
     })
+
+    yield(payload) if block_given?
+
+    payload
   end
 
   def tap_init?(klass, tp)
@@ -176,15 +202,7 @@ class TappingDevice
     return false if is_from_target?(self, tp)
     return false if tp.defined_class == TappingDevice::Trackable || tp.defined_class == TappingDevice
 
-    method_object = get_method_object_from(tp.self, tp.callee_id)
-    return false unless method_object.is_a?(Method)
-    # if a no-arugment method is called, tp.binding.local_variables will be those local variables in the same scope
-    # so we need to make sure the method takes arguments, then we can be sure that the locals are arguments
-    return false unless method_object && method_object.arity.to_i > 0
-
-    argument_values = tp.binding.local_variables.map { |name| tp.binding.local_variable_get(name) }
-
-    argument_values.any? do |value|
+    collect_arguments(tp).values.any? do |value|
       # during comparison, Ruby might perform data type conversion like calling `to_sym` on the value
       # but not every value supports every conversion methods
       object == value rescue false
@@ -204,6 +222,19 @@ class TappingDevice
     nil
   end
 
+  def collect_arguments(tp)
+    parameters =
+      if RUBY_VERSION.to_f >= 2.6
+        tp.parameters
+      else
+        get_method_object_from(tp.self, tp.callee_id)&.parameters || []
+      end.map { |parameter| parameter[1] }
+
+    tp.binding.local_variables.each_with_object({}) do |name, args|
+      args[name] = tp.binding.local_variable_get(name) if parameters.include?(name)
+    end
+  end
+
   def process_options(options)
     options[:filter_by_paths] ||= []
     options[:exclude_by_paths] ||= []
@@ -238,7 +269,7 @@ class TappingDevice
   def record_call!(payload)
     return if @disabled
 
-    @output_block.call(payload) if @output_block
+    @output_block.call(OutputPayload.init(payload)) if @output_block
 
     if @block
       root_device.calls << @block.call(payload)
@@ -246,4 +277,8 @@ class TappingDevice
       root_device.calls << payload
     end
   end
+
+  def with_condition_satisfied?(payload)
+    @with_condition.blank? || @with_condition.call(payload)
+  end
 end

data/lib/tapping_device/output_payload.rb

@@ -0,0 +1,145 @@
+class TappingDevice
+  class OutputPayload < Payload
+    alias :raw_arguments :arguments
+    alias :raw_return_value :return_value
+
+    def method_name(options = {})
+      ":#{super(options)}"
+    end
+
+    def arguments(options = {})
+      generate_string_result(raw_arguments, options[:inspect])
+    end
+
+    def return_value(options = {})
+      generate_string_result(raw_return_value, options[:inspect])
+    end
+
+    def self.full_color_code(code)
+    end
+
+    COLOR_CODES = {
+      green: 10,
+      yellow: 11,
+      blue: 12,
+      megenta: 13,
+      cyan: 14,
+      orange: 214
+    }
+
+    COLORS = COLOR_CODES.each_with_object({}) do |(name, code), hash|
+      hash[name] = "\u001b[38;5;#{code}m"
+    end.merge(
+      reset: "\u001b[0m",
+      nocolor: ""
+    )
+
+    PAYLOAD_ATTRIBUTES = {
+      method_name: {symbol: "", color: COLORS[:blue]},
+      location: {symbol: "from:", color: COLORS[:green]},
+      sql: {symbol: "QUERIES", color: COLORS[:nocolor]},
+      return_value: {symbol: "=>", color: COLORS[:megenta]},
+      arguments: {symbol: "<=", color: COLORS[:orange]},
+      defined_class: {symbol: "#", color: COLORS[:yellow]}
+    }
+
+    PAYLOAD_ATTRIBUTES.each do |attribute, attribute_options|
+      color = attribute_options[:color]
+
+      alias_method "original_#{attribute}".to_sym, attribute
+
+      # regenerate attributes with `colorize: true` support
+      define_method attribute do |options = {}|
+        call_result = send("original_#{attribute}", options)
+
+        if options[:colorize]
+          "#{color}#{call_result}#{COLORS[:reset]}"
+        else
+          call_result
+        end
+      end
+
+      define_method "#{attribute}_with_color" do |options = {}|
+        send(attribute, options.merge(colorize: true))
+      end
+
+      PAYLOAD_ATTRIBUTES.each do |and_attribute, and_attribute_options|
+        next if and_attribute == attribute
+
+        define_method "#{attribute}_and_#{and_attribute}" do |options = {}|
+          "#{send(attribute, options)} #{and_attribute_options[:symbol]} #{send(and_attribute, options)}"
+        end
+
+        define_method "#{attribute}_and_#{and_attribute}_with_color" do |options = {}|
+          send("#{attribute}_and_#{and_attribute}", options.merge(colorize: true))
+        end
+      end
+    end
+
+    def passed_at(options = {})
+      with_method_head = options.fetch(:with_method_head, false)
+      arg_name = raw_arguments.keys.detect { |k| raw_arguments[k] == target }
+
+      return unless arg_name
+
+      arg_name = ":#{arg_name}"
+      arg_name = value_with_color(arg_name, :orange) if options[:colorize]
+      msg = "Passed as #{arg_name} in '#{defined_class(options)}##{method_name(options)}' at #{location(options)}"
+      msg += "\n  > #{method_head.strip}" if with_method_head
+      msg
+    end
+
+    def detail_call_info(options = {})
+      <<~MSG
+      #{method_name_and_defined_class(options)}
+          from: #{location(options)}
+          <= #{arguments(options)}
+          => #{return_value(options)}
+
+      MSG
+    end
+
+    private
+
+    def value_with_color(value, color)
+      "#{COLORS[color]}#{value}#{COLORS[:reset]}"
+    end
+
+    def generate_string_result(obj, inspect)
+      case obj
+      when Array
+        array_to_string(obj, inspect)
+      when Hash
+        hash_to_string(obj, inspect)
+      when String
+        "\"#{obj}\""
+      else
+        inspect ? obj.inspect : obj.to_s
+      end
+    end
+
+    def array_to_string(array, inspect)
+      elements_string = array.map do |elem|
+        generate_string_result(elem, inspect)
+      end.join(", ")
+      "[#{elements_string}]"
+    end
+
+    def hash_to_string(hash, inspect)
+      elements_string = hash.map do |key, value|
+        "#{key.to_s}: #{generate_string_result(value, inspect)}"
+      end.join(", ")
+      "{#{elements_string}}"
+    end
+
+    def obj_to_string(element, inspect)
+      to_string_method = inspect ? :inspect : :to_s
+
+      if !inspect && element.is_a?(String)
+        "\"#{element}\""
+      else
+        element.send(to_string_method)
+      end
+    end
+  end
+end

data/lib/tapping_device/payload.rb

@@ -6,7 +6,7 @@ class TappingDevice
     ]
 
     ATTRS.each do |attr|
-      define_method attr do
+      define_method attr do |options = {}|
         self[attr]
       end
     end
@@ -19,45 +19,13 @@ class TappingDevice
       h
     end
 
-    def passed_at(with_method_head: false)
-      arg_name = arguments.keys.detect { |k| arguments[k] == target }
-      return unless arg_name
-      msg = "Passed as '#{arg_name}' in method ':#{method_name}'"
-      msg += "\n  > #{method_head.strip}" if with_method_head
-      msg += "\n  at #{location}"
-      msg
-    end
-
     def method_head
       source_file, source_line = method_object.source_location
       IO.readlines(source_file)[source_line-1]
     end
 
-    def location
+    def location(options = {})
       "#{filepath}:#{line_number}"
     end
-
-    SYMBOLS = {
-      location: "FROM",
-      sql: "QUERIES",
-      return_value: "=>",
-      arguments: "<=",
-      defined_class: "#"
-    }
-
-    SYMBOLS.each do |name, symbol|
-      define_method "method_name_and_#{name}" do
-        ":#{method_name} #{symbol} #{send(name)}"
-      end
-    end
-
-    def detail_call_info
-      <<~MSG
-      #{method_name_and_defined_class}
-        <= #{arguments}
-        => #{return_value || "nil"}
-        FROM #{location}
-      MSG
-    end
   end
 end

data/lib/tapping_device/trackable.rb

@@ -1,6 +1,6 @@
 class TappingDevice
   module Trackable
-    [:tap_on!, :tap_init!, :tap_assoc!, :tap_sql!, :tap_passed!].each do |method|
+    [:tap_on!, :tap_init!, :tap_assoc!, :tap_passed!].each do |method|
       define_method method do |object, options = {}, &block|
         new_device(options, &block).send(method, object)
       end
@@ -8,24 +8,45 @@ class TappingDevice
 
     def print_traces(target, options = {})
       options[:event_type] = :call
+      inspect = options.delete(:inspect)
+      colorize = options.fetch(:colorize, true)
 
-      device_1 = tap_on!(target, options) do |payload|
-        puts("Called #{payload.method_name_and_location}")
+      device_1 = tap_on!(target, options).and_print do |output_payload|
+        "Called #{output_payload.method_name_and_location(inspect: inspect, colorize: colorize)}"
       end
-      device_2 = tap_passed!(target, options) do |payload|
-        arg_name = payload.arguments.keys.detect { |k| payload.arguments[k] == target }
-        next unless arg_name
-        puts("Passed as '#{arg_name}' in '#{payload.defined_class}##{payload.method_name}' at #{payload.location}")
+      device_2 = tap_passed!(target, options).and_print do |output_payload|
+        output_payload.passed_at(inspect: inspect, colorize: colorize)
       end
-      [device_1, device_2]
+      CollectionProxy.new([device_1, device_2])
     end
 
-    def print_calls_in_detail(target, options = {})
-      tap_on!(target, options).and_print(:detail_call_info)
+    def print_calls(target, options = {})
+      inspect = options.delete(:inspect)
+      colorize = options.fetch(:colorize, true)
+
+      tap_on!(target, options).and_print do |output_payload|
+        output_payload.detail_call_info(inspect: inspect, colorize: colorize)
+      end
     end
 
     def new_device(options, &block)
       TappingDevice.new(options, &block)
     end
+
+    class CollectionProxy
+      def initialize(devices)
+        @devices = devices
+      end
+
+      [:stop!, :stop_when, :with].each do |method|
+        define_method method do |&block|
+          @devices.each do |device|
+            device.send(method, &block)
+          end
+        end
+      end
+    end
   end
 end
+
+include TappingDevice::Trackable

data/lib/tapping_device/version.rb

@@ -1,3 +1,3 @@
 class TappingDevice
-  VERSION = "0.4.8"
+  VERSION = "0.5.1"
 end

data/tapping_device.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["st0012"]
   spec.email         = ["stan001212@gmail.com"]
 
-  spec.summary       = %q{tapping_device provides useful helpers to intercept method calls}
-  spec.description   = %q{tapping_device provides useful helpers to intercept method calls}
+  spec.summary       = %q{tapping_device lets you understand what your Ruby objects do without digging into the code}
+  spec.description   = %q{tapping_device lets you understand what your Ruby objects do without digging into the code} 
   spec.homepage      = "https://github.com/st0012/tapping_device"
   spec.license       = "MIT"
 
@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "database_cleaner"
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "simplecov", "0.17.1"
 end