tapping_device 0.4.9 → 0.5.2

data/lib/tapping_device.rb

@@ -2,9 +2,14 @@ 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"
+require "tapping_device/trackers/initialization_tracker"
+require "tapping_device/trackers/passed_tracker"
+require "tapping_device/trackers/association_call_tracker"
+require "tapping_device/trackers/method_call_tracker"
+require "tapping_device/trackers/mutation_tracker"
 
 class TappingDevice
 
@@ -16,7 +21,6 @@ class TappingDevice
   @devices = []
   @suspend_new = false
 
-  include SqlTappingMethods
   extend Manageable
 
   def initialize(options = {}, &block)
@@ -25,29 +29,25 @@ class TappingDevice
     @options = process_options(options)
     @calls = []
     @disabled = false
-    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?)
-  end
-
-  def tap_on!(object)
-    track(object, condition: :tap_on?)
-  end
-
-  def tap_passed!(object)
-    track(object, condition: :tap_passed?)
-  end
+    @with_condition = nil
+    TappingDevice.devices << self
+  end
+
+  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
 
-  def tap_assoc!(record)
-    raise "argument should be an instance of ActiveRecord::Base" unless record.is_a?(ActiveRecord::Base)
-    track(record, condition: :tap_associations?)
+    self
   end
 
-  def and_print(payload_method)
-    @output_block = -> (payload) { puts(payload.send(payload_method)) }
+  def with(&block)
+    @with_condition = block
   end
 
   def set_block(&block)
@@ -56,7 +56,7 @@ class TappingDevice
 
   def stop!
     @disabled = true
-    self.class.delete_device(self)
+    TappingDevice.delete_device(self)
   end
 
   def stop_when(&block)
@@ -79,48 +79,42 @@ class TappingDevice
     options[:descendants]
   end
 
-  private
-
-  def track(object, condition:)
+  def track(object)
     @target = object
-    @trace_point = TracePoint.new(options[:event_type]) do |tp|
-      if send(condition, object, tp)
-        filepath, line_number = get_call_location(tp)
-
-        next if should_be_skipped_by_paths?(filepath)
-
-        payload = build_payload(tp: tp, filepath: filepath, line_number: line_number)
+    validate_target!
 
-        record_call!(payload)
+    @trace_point = build_minimum_trace_point(event_type: options[:event_type]) do |payload|
+      record_call!(payload)
 
-        stop_if_condition_fulfilled(payload)
-      end
+      stop_if_condition_fulfilled!(payload)
     end
 
-    @trace_point.enable unless self.class.suspend_new
+    @trace_point.enable unless TappingDevice.suspend_new
 
     self
   end
 
-  def get_call_location(tp, padding: 0)
-    caller(get_trace_index(tp) + padding).first.split(":")[0..1]
-  end
+  private
 
-  def get_trace_index(tp)
-    if tp.event == :c_call
-      C_CALLER_START_POINT
-    else
-      CALLER_START_POINT
+  def build_minimum_trace_point(event_type:)
+    TracePoint.new(event_type) do |tp|
+      next unless filter_condition_satisfied?(tp)
+      next if is_tapping_device_call?(tp)
+
+      filepath, line_number = get_call_location(tp)
+      payload = build_payload(tp: tp, filepath: filepath, line_number: line_number)
+
+      next if should_be_skipped_by_paths?(filepath)
+      next unless with_condition_satisfied?(payload)
+
+      yield(payload)
     end
   end
 
-  def get_traces(tp)
-    if with_trace_to = options[:with_trace_to]
-      trace_index = get_trace_index(tp)
-      caller[trace_index..(trace_index + with_trace_to)]
-    else
-      []
-    end
+  def validate_target!; end
+
+  def filter_condition_satisfied?(tp)
+    false
   end
 
   # this needs to be placed upfront so we can exclude noise before doing more work
@@ -129,16 +123,29 @@ class TappingDevice
       (options[:filter_by_paths].present? && !options[:filter_by_paths].any? { |pattern| pattern.match?(filepath) })
   end
 
-  def build_payload(tp:, filepath:, line_number:)
-    arguments = {}
-    tp.binding.local_variables.each { |name| arguments[name] = tp.binding.local_variable_get(name) }
+  def is_tapping_device_call?(tp)
+    if tp.defined_class == TappingDevice::Trackable || tp.defined_class == TappingDevice
+      return true
+    end
 
+    if Module.respond_to?(:module_parents)
+      tp.defined_class.module_parents.include?(TappingDevice)
+    else
+      tp.defined_class.parents.include?(TappingDevice)
+    end
+  end
+
+  def with_condition_satisfied?(payload)
+    @with_condition.blank? || @with_condition.call(payload)
+  end
+
+  def build_payload(tp:, filepath:, line_number:)
     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,
@@ -148,51 +155,6 @@ class TappingDevice
     })
   end
 
-  def tap_init?(klass, tp)
-    receiver = tp.self
-    method_name = tp.callee_id
-
-    if klass.ancestors.include?(ActiveRecord::Base)
-      method_name == :new && receiver.ancestors.include?(klass)
-    else
-      method_name == :initialize && receiver.is_a?(klass)
-    end
-  end
-
-  def tap_on?(object, tp)
-    is_from_target?(object, tp)
-  end
-
-  def tap_associations?(object, tp)
-    return false unless tap_on?(object, tp)
-
-    model_class = object.class
-    associations = model_class.reflections
-    associations.keys.include?(tp.callee_id.to_s)
-  end
-
-  def tap_passed?(object, tp)
-    # we don't care about calls from the device instance or helper methods
-    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|
-      # 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
-    end
-  rescue
-    false
-  end
-
   def get_method_object_from(target, method_name)
     target.method(method_name)
   rescue ArgumentError
@@ -204,6 +166,40 @@ class TappingDevice
     nil
   end
 
+  def get_call_location(tp, padding: 0)
+    caller(get_trace_index(tp) + padding).first.split(":")[0..1]
+  end
+
+  def get_trace_index(tp)
+    if tp.event == :c_call
+      C_CALLER_START_POINT
+    else
+      CALLER_START_POINT
+    end
+  end
+
+  def get_traces(tp)
+    if with_trace_to = options[:with_trace_to]
+      trace_index = get_trace_index(tp)
+      caller[trace_index..(trace_index + with_trace_to)]
+    else
+      []
+    end
+  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] ||= []
@@ -215,19 +211,12 @@ class TappingDevice
     options
   end
 
-  def stop_if_condition_fulfilled(payload)
-    if @stop_when&.call(payload)
-      stop!
-      root_device.stop!
-    end
-  end
-
-  def is_from_target?(object, tp)
+  def is_from_target?(tp)
     comparsion = tp.self
-    is_the_same_record?(object, comparsion) || object.__id__ == comparsion.__id__
+    is_the_same_record?(comparsion) || target.__id__ == comparsion.__id__
   end
 
-  def is_the_same_record?(target, comparsion)
+  def is_the_same_record?(comparsion)
     return false unless options[:track_as_records]
     if target.is_a?(ActiveRecord::Base) && comparsion.is_a?(target.class)
       primary_key = target.class.primary_key
@@ -238,7 +227,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 +235,11 @@ class TappingDevice
       root_device.calls << payload
     end
   end
+
+  def stop_if_condition_fulfilled!(payload)
+    if @stop_when&.call(payload)
+      stop!
+      root_device.stop!
+    end
+  end
 end

data/lib/tapping_device/exceptions.rb

@@ -1,4 +1,16 @@
 class TappingDevice
   class Exception < StandardError
   end
+
+  class NotAnActiveRecordInstanceError < Exception
+    def initialize(object)
+      super("target object should be an instance of ActiveRecord::Base, got #{object}")
+    end
+  end
+
+  class NotAClassError < Exception
+    def initialize(object)
+      super("target object should be a class, got #{object}")
+    end
+  end
 end

data/lib/tapping_device/output_payload.rb

@@ -0,0 +1,173 @@
+class TappingDevice
+  class OutputPayload < Payload
+    UNDEFINED = "[undefined]"
+
+    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
+
+    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]},
+      return_value: {symbol: "=>", color: COLORS[:megenta]},
+      arguments: {symbol: "<=", color: COLORS[:orange]},
+      ivar_changes: {symbol: "changes:\n", color: COLORS[:blue]},
+      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
+
+    def ivar_changes(options = {})
+      super.map do |ivar, value_changes|
+        before = generate_string_result(value_changes[:before], options[:inspect])
+        after = generate_string_result(value_changes[:after], options[:inspect])
+
+        if options[:colorize]
+          ivar = "#{COLORS[:orange]}#{ivar}#{COLORS[:reset]}"
+          before = "#{COLORS[:blue]}#{before.to_s}#{COLORS[:reset]}"
+          after = "#{COLORS[:blue]}#{after.to_s}#{COLORS[:reset]}"
+        end
+
+        "      #{ivar}: #{before.to_s} => #{after.to_s}"
+      end.join("\n")
+    end
+
+    def call_info_with_ivar_changes(options = {})
+      <<~MSG
+      #{method_name_and_defined_class(options)}
+          from: #{location(options)}
+          changes:
+      #{ivar_changes(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 UNDEFINED
+        UNDEFINED
+      when String
+        "\"#{obj}\""
+      when nil
+        "nil"
+      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