tapping_device 0.5.0 → 0.5.5

data/lib/tapping_device.rb

@@ -1,11 +1,20 @@
 require "active_record"
+require "active_support/core_ext/module/introspection"
+require "pry" # for using Method#source
+
 require "tapping_device/version"
 require "tapping_device/manageable"
 require "tapping_device/payload"
-require "tapping_device/output_payload"
+require "tapping_device/output"
 require "tapping_device/trackable"
+require "tapping_device/configurable"
 require "tapping_device/exceptions"
-require "tapping_device/sql_tapping_methods"
+require "tapping_device/method_hijacker"
+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
 
@@ -17,51 +26,19 @@ class TappingDevice
   @devices = []
   @suspend_new = false
 
-  include SqlTappingMethods
   extend Manageable
 
+  include Configurable
+  include Output::Helpers
+
   def initialize(options = {}, &block)
     @block = block
     @output_block = nil
-    @options = process_options(options)
+    @options = process_options(options.dup)
     @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?) do |payload|
-      payload[:return_value] = payload[:receiver]
-      payload[:receiver] = klass
-    end
-  end
-
-  def tap_on!(object)
-    track(object, condition: :tap_on?)
-  end
-
-  def tap_passed!(object)
-    track(object, condition: :tap_passed?)
-  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?)
-  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
-
-    self
+    TappingDevice.devices << self
   end
 
   def with(&block)
@@ -74,7 +51,7 @@ class TappingDevice
 
   def stop!
     @disabled = true
-    self.class.delete_device(self)
+    TappingDevice.delete_device(self)
   end
 
   def stop_when(&block)
@@ -97,50 +74,48 @@ class TappingDevice
     options[:descendants]
   end
 
-  private
-
-  def track(object, condition:, &payload_block)
+  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)
+    validate_target!
 
-        payload = build_payload(tp: tp, filepath: filepath, line_number: line_number, &payload_block)
+    MethodHijacker.new(@target).hijack_methods! if options[:hijack_attr_methods]
 
-        next unless with_condition_satisfied?(payload)
-
-        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)
+
+      filepath, line_number = get_call_location(tp)
+      payload = build_payload(tp: tp, filepath: filepath, line_number: line_number)
+
+      unless @options[:force_recording]
+        next if is_tapping_device_call?(tp)
+        next if should_be_skipped_by_paths?(filepath)
+        next unless with_condition_satisfied?(payload)
+        next if payload.is_private_call? && @options[:ignore_private]
+        next if !payload.is_private_call? && @options[:only_private]
+      end
+
+      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
@@ -149,8 +124,24 @@ class TappingDevice
       (options[:filter_by_paths].present? && !options[:filter_by_paths].any? { |pattern| pattern.match?(filepath) })
   end
 
+  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)
+    elsif Module.respond_to?(:parents)
+      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 = Payload.init({
+    Payload.init({
       target: @target,
       receiver: tp.self,
       method_name: tp.callee_id,
@@ -161,60 +152,38 @@ class TappingDevice
       line_number: line_number,
       defined_class: tp.defined_class,
       trace: get_traces(tp),
+      is_private_call?: tp.defined_class.private_method_defined?(tp.callee_id),
       tp: tp
     })
-
-    yield(payload) if block_given?
-
-    payload
-  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)
+  def get_method_object_from(target, method_name)
+    Object.instance_method(:method).bind(target).call(method_name)
+  rescue NameError
+    # if any part of the program uses Refinement to extend its methods
+    # we might still get NoMethodError when trying to get that method outside the scope
+    nil
   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)
+  def get_call_location(tp, padding: 0)
+    caller(get_trace_index(tp) + padding).first.split(":")[0..1]
   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
-
-    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
+  def get_trace_index(tp)
+    if tp.event == :c_call
+      C_CALLER_START_POINT
+    else
+      CALLER_START_POINT
     end
-  rescue
-    false
   end
 
-  def get_method_object_from(target, method_name)
-    target.method(method_name)
-  rescue ArgumentError
-    method_method = Object.method(:method).unbind
-    method_method.bind(target).call(method_name)
-  rescue NameError
-    # if any part of the program uses Refinement to extend its methods
-    # we might still get NoMethodError when trying to get that method outside the scope
-    nil
+  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)
@@ -231,29 +200,28 @@ class TappingDevice
   end
 
   def process_options(options)
-    options[:filter_by_paths] ||= []
-    options[:exclude_by_paths] ||= []
-    options[:with_trace_to] ||= 50
-    options[:root_device] ||= self
-    options[:event_type] ||= :return
+    options[:filter_by_paths] ||= config[:filter_by_paths]
+    options[:exclude_by_paths] ||= config[:exclude_by_paths]
+    options[:with_trace_to] ||= config[:with_trace_to]
+    options[:event_type] ||= config[:event_type]
+    options[:hijack_attr_methods] ||= config[:hijack_attr_methods]
+    options[:track_as_records] ||= config[:track_as_records]
+    options[:ignore_private] ||= config[:ignore_private]
+    options[:only_private] ||= config[:only_private]
+    # for debugging the gem more easily
+    options[:force_recording] ||= false
+
     options[:descendants] ||= []
-    options[:track_as_records] ||= false
+    options[:root_device] ||= self
     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
@@ -264,7 +232,7 @@ class TappingDevice
   def record_call!(payload)
     return if @disabled
 
-    @output_block.call(OutputPayload.init(payload)) if @output_block
+    write_output!(payload) if @output_writer
 
     if @block
       root_device.calls << @block.call(payload)
@@ -273,7 +241,18 @@ class TappingDevice
     end
   end
 
-  def with_condition_satisfied?(payload)
-    @with_condition.blank? || @with_condition.call(payload)
+  def write_output!(payload)
+    @output_writer.write!(payload)
+  end
+
+  def stop_if_condition_fulfilled!(payload)
+    if @stop_when&.call(payload)
+      stop!
+      root_device.stop!
+    end
+  end
+
+  def config
+    TappingDevice.config
   end
 end

data/lib/tapping_device/configurable.rb

@@ -0,0 +1,27 @@
+require "active_support/configurable"
+require "active_support/concern"
+
+class TappingDevice
+  module Configurable
+    extend ActiveSupport::Concern
+
+    DEFAULTS = {
+      filter_by_paths: [],
+      exclude_by_paths: [],
+      with_trace_to: 50,
+      event_type: :return,
+      hijack_attr_methods: false,
+      track_as_records: false,
+      ignore_private: false,
+      only_private: false
+    }.merge(TappingDevice::Output::DEFAULT_OPTIONS)
+
+    included do
+      include ActiveSupport::Configurable
+
+      DEFAULTS.each do |key, value|
+        config[key] = value
+      end
+    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/method_hijacker.rb

@@ -0,0 +1,51 @@
+class TappingDevice
+  class MethodHijacker
+    attr_reader :target
+
+    def initialize(target)
+      @target = target
+    end
+
+    def hijack_methods!
+      target.methods.each do |method_name|
+        if is_writer_method?(method_name)
+          redefine_writer_method!(method_name)
+        elsif is_reader_method?(method_name)
+          redefine_reader_method!(method_name)
+        end
+      end
+    end
+
+    private
+
+    def is_writer_method?(method_name)
+      has_definition_source?(method_name) && method_name.match?(/\w+=/) && target.method(method_name).source.match?(/attr_writer|attr_accessor/)
+    end
+
+    def is_reader_method?(method_name)
+      has_definition_source?(method_name) && target.method(method_name).source.match?(/attr_reader|attr_accessor/)
+    end
+
+    def has_definition_source?(method_name)
+      target.method(method_name).source_location
+    end
+
+    def redefine_writer_method!(method_name)
+      ivar_name = "@#{method_name.to_s.sub("=", "")}"
+
+      target.instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method_name}(val)
+          #{ivar_name} = val
+        end
+      RUBY
+    end
+
+    def redefine_reader_method!(method_name)
+      target.instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method_name}
+          @#{method_name}
+        end
+      RUBY
+    end
+  end
+end

data/lib/tapping_device/output.rb

@@ -0,0 +1,42 @@
+require "tapping_device/output/payload"
+require "tapping_device/output/writer"
+require "tapping_device/output/stdout_writer"
+require "tapping_device/output/file_writer"
+
+class TappingDevice
+  module Output
+    DEFAULT_OPTIONS = {
+      inspect: false,
+      colorize: true,
+      log_file: "/tmp/tapping_device.log"
+    }
+
+    module Helpers
+      def and_write(payload_method = nil, options: {}, &block)
+        and_output(payload_method, options: options, writer_klass: FileWriter, &block)
+      end
+
+      def and_print(payload_method = nil, options: {}, &block)
+        and_output(payload_method, options: options, writer_klass: StdoutWriter, &block)
+      end
+
+      def and_output(payload_method = nil, options: {}, writer_klass:, &block)
+        output_block = generate_output_block(payload_method, block)
+        @output_writer = writer_klass.new(options, output_block)
+        self
+      end
+
+      private
+
+      def generate_output_block(payload_method, block)
+        if block
+          block
+        elsif payload_method
+          -> (output_payload, output_options) { output_payload.send(payload_method, output_options) }
+        else
+          raise "need to provide either a payload method name or a block"
+        end
+      end
+    end
+  end
+end