tapping_device 0.5.2 → 0.5.7

data/lib/tapping_device.rb

@@ -1,10 +1,15 @@
 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/method_hijacker"
 require "tapping_device/trackers/initialization_tracker"
 require "tapping_device/trackers/passed_tracker"
 require "tapping_device/trackers/association_call_tracker"
@@ -23,29 +28,19 @@ class TappingDevice
 
   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
     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
-
-    self
-  end
-
   def with(&block)
     @with_condition = block
   end
@@ -83,6 +78,8 @@ class TappingDevice
     @target = object
     validate_target!
 
+    MethodHijacker.new(@target).hijack_methods! if options[:hijack_attr_methods]
+
     @trace_point = build_minimum_trace_point(event_type: options[:event_type]) do |payload|
       record_call!(payload)
 
@@ -97,15 +94,19 @@ class TappingDevice
   private
 
   def build_minimum_trace_point(event_type:)
-    TracePoint.new(event_type) do |tp|
+    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)
+      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
@@ -130,7 +131,7 @@ class TappingDevice
 
     if Module.respond_to?(:module_parents)
       tp.defined_class.module_parents.include?(TappingDevice)
-    else
+    elsif Module.respond_to?(:parents)
       tp.defined_class.parents.include?(TappingDevice)
     end
   end
@@ -151,15 +152,14 @@ 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),
+      tag: options[:tag],
       tp: tp
     })
   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)
+    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
@@ -201,13 +201,19 @@ 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
 
@@ -227,7 +233,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)
@@ -236,10 +242,18 @@ class TappingDevice
     end
   end
 
+  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/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

data/lib/tapping_device/output/file_writer.rb

@@ -0,0 +1,21 @@
+class TappingDevice
+  module Output
+    class FileWriter < Writer
+      def initialize(options, output_block)
+        @path = options[:log_file]
+
+        File.write(@path, "") # clean file
+
+        super
+      end
+
+      def write!(payload)
+        output = generate_output(payload)
+
+        File.open(@path, "a") do |f|
+          f << output
+        end
+      end
+    end
+  end
+end

data/lib/tapping_device/output/payload.rb

@@ -0,0 +1,166 @@
+require "pastel"
+
+class TappingDevice
+  module Output
+    class Payload < Payload
+      UNDEFINED = "[undefined]"
+      PRIVATE_MARK = " (private)"
+
+      PASTEL = Pastel.new
+      PASTEL.alias_color(:orange, :bright_red, :bright_yellow)
+
+      alias :raw_arguments :arguments
+      alias :raw_return_value :return_value
+
+      def method_name(options = {})
+        name = ":#{super(options)}"
+
+        name += " [#{tag}]" if tag
+        name += PRIVATE_MARK if is_private_call?
+
+        name
+      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
+
+      PAYLOAD_ATTRIBUTES = {
+        method_name: {symbol: "", color: :bright_blue},
+        location: {symbol: "from:", color: :green},
+        return_value: {symbol: "=>", color: :magenta},
+        arguments: {symbol: "<=", color: :orange},
+        ivar_changes: {symbol: "changes:\n", color: :blue},
+        defined_class: {symbol: "#", color: :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]
+            PASTEL.send(color, call_result)
+          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 = PASTEL.orange(arg_name) if options[:colorize]
+        msg = "Passed as #{arg_name} in '#{defined_class(options)}##{method_name(options)}' at #{location(options)}\n"
+        msg += "  > #{method_head}\n" 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 = PASTEL.orange(ivar)
+            before = PASTEL.bright_blue(before.to_s)
+            after = PASTEL.bright_blue(after.to_s)
+          end
+
+          "      #{ivar}: #{before} => #{after}"
+        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 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
+end