tapping_device 0.5.1 → 0.5.6

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,179 @@
+class TappingDevice
+  module Output
+    class Payload < Payload
+      UNDEFINED = "[undefined]"
+
+      alias :raw_arguments :arguments
+      alias :raw_return_value :return_value
+
+      def method_name(options = {})
+        if is_private_call?
+          ":#{super(options)} (private)"
+        else
+          ":#{super(options)}"
+        end
+      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)}\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 = "#{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
+end

data/lib/tapping_device/output/stdout_writer.rb

@@ -0,0 +1,9 @@
+class TappingDevice
+  module Output
+    class StdoutWriter < Writer
+      def write!(payload)
+        puts(generate_output(payload))
+      end
+    end
+  end
+end

data/lib/tapping_device/output/writer.rb

@@ -0,0 +1,20 @@
+class TappingDevice
+  module Output
+    class Writer
+      def initialize(options, output_block)
+        @options = options
+        @output_block = output_block
+      end
+
+      def write!(payload)
+        raise NotImplementedError
+      end
+
+      private
+
+      def generate_output(payload)
+        @output_block.call(Output::Payload.init(payload), @options)
+      end
+    end
+  end
+end

data/lib/tapping_device/payload.rb

@@ -2,7 +2,7 @@ class TappingDevice
   class Payload < Hash
     ATTRS = [
       :target, :receiver, :method_name, :method_object, :arguments, :return_value, :filepath, :line_number,
-      :defined_class, :trace, :tp, :sql
+      :defined_class, :trace, :tp, :ivar_changes, :is_private_call?
     ]
 
     ATTRS.each do |attr|
@@ -20,8 +20,7 @@ class TappingDevice
     end
 
     def method_head
-      source_file, source_line = method_object.source_location
-      IO.readlines(source_file)[source_line-1]
+      method_object.source.strip if method_object.source_location
     end
 
     def location(options = {})

data/lib/tapping_device/trackable.rb

@@ -1,44 +1,99 @@
 class TappingDevice
   module Trackable
-    [: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)
+    def tap_init!(object, options = {}, &block)
+      TappingDevice::Trackers::InitializationTracker.new(options, &block).track(object)
+    end
+
+    def tap_passed!(object, options = {}, &block)
+      TappingDevice::Trackers::PassedTracker.new(options, &block).track(object)
+    end
+
+    def tap_assoc!(object, options = {}, &block)
+      TappingDevice::Trackers::AssociactionCallTracker.new(options, &block).track(object)
+    end
+
+    def tap_on!(object, options = {}, &block)
+      TappingDevice::Trackers::MethodCallTracker.new(options, &block).track(object)
+    end
+
+    def tap_mutation!(object, options = {}, &block)
+      TappingDevice::Trackers::MutationTracker.new(options, &block).track(object)
+    end
+
+    [:calls, :traces, :mutations].each do |subject|
+      [:print, :write].each do |output_action|
+        helper_method_name = "#{output_action}_#{subject}"
+
+        define_method helper_method_name do |target, options = {}|
+          send("output_#{subject}", target, options, output_action: "and_#{output_action}")
+        end
+
+        define_method "with_#{helper_method_name}" do |options = {}|
+          send(helper_method_name, self, options)
+          self
+        end
+
+        define_method "#{output_action}_instance_#{subject}" do |target_klass, options = {}|
+          collection_proxy = AsyncCollectionProxy.new
+
+          tap_init!(target_klass, options.merge(force_recording: true)) do |payload|
+            collection_proxy << send(helper_method_name, payload.return_value, options)
+          end
+
+          collection_proxy
+        end
       end
     end
 
-    def print_traces(target, options = {})
-      options[:event_type] = :call
-      inspect = options.delete(:inspect)
-      colorize = options.fetch(:colorize, true)
+    private
 
-      device_1 = tap_on!(target, options).and_print do |output_payload|
-        "Called #{output_payload.method_name_and_location(inspect: inspect, colorize: colorize)}"
+    def output_calls(target, options = {}, output_action:)
+      device_options, output_options = separate_options(options)
+
+      tap_on!(target, device_options).send(output_action, options: output_options) do |output_payload, output_options|
+        output_payload.detail_call_info(output_options)
+      end
+    end
+
+    def output_traces(target, options = {}, output_action:)
+      device_options, output_options = separate_options(options)
+      device_options[:event_type] = :call
+
+      device_1 = tap_on!(target, device_options).send(output_action, options: output_options) do |output_payload, output_options|
+        "Called #{output_payload.method_name_and_location(output_options)}\n"
       end
-      device_2 = tap_passed!(target, options).and_print do |output_payload|
-        output_payload.passed_at(inspect: inspect, colorize: colorize)
+      device_2 = tap_passed!(target, device_options).send(output_action, options: output_options) do |output_payload, output_options|
+        output_payload.passed_at(output_options)
       end
       CollectionProxy.new([device_1, device_2])
     end
 
-    def print_calls(target, options = {})
-      inspect = options.delete(:inspect)
-      colorize = options.fetch(:colorize, true)
+    def output_mutations(target, options = {}, output_action:)
+      device_options, output_options = separate_options(options)
 
-      tap_on!(target, options).and_print do |output_payload|
-        output_payload.detail_call_info(inspect: inspect, colorize: colorize)
+      tap_mutation!(target, device_options).send(output_action, options: output_options) do |output_payload, output_options|
+        output_payload.call_info_with_ivar_changes(output_options)
       end
     end
 
-    def new_device(options, &block)
-      TappingDevice.new(options, &block)
+    def separate_options(options)
+      output_options = Output::DEFAULT_OPTIONS.keys.each_with_object({}) do |key, hash|
+        hash[key] = options.fetch(key, TappingDevice.config[key])
+        options.delete(key)
+      end
+
+      [options, output_options]
     end
 
+    # CollectionProxy delegates chained actions to multiple devices
     class CollectionProxy
+      CHAINABLE_ACTIONS = [:stop!, :stop_when, :with]
+
       def initialize(devices)
         @devices = devices
       end
 
-      [:stop!, :stop_when, :with].each do |method|
+      CHAINABLE_ACTIONS.each do |method|
         define_method method do |&block|
           @devices.each do |device|
             device.send(method, &block)
@@ -46,6 +101,32 @@ class TappingDevice
         end
       end
     end
+
+    # AsyncCollectionProxy delegates chained actions to multiple device "asyncronously"
+    # when we use tapping methods like `tap_init!` to create sub-devices
+    # we need to find a way to pass the chained actions to every sub-device that's created
+    # and this can only happen asyncronously as we won't know when'll that happen
+    class AsyncCollectionProxy < CollectionProxy
+      def initialize(devices = [])
+        super
+        @blocks = {}
+      end
+
+      CHAINABLE_ACTIONS.each do |method|
+        define_method method do |&block|
+          super(&block)
+          @blocks[method] = block
+        end
+      end
+
+      def <<(device)
+        @devices << device
+
+        @blocks.each do |method, block|
+          device.send(method, &block)
+        end
+      end
+    end
   end
 end
 

data/lib/tapping_device/trackers/association_call_tracker.rb

@@ -0,0 +1,17 @@
+class TappingDevice
+  module Trackers
+    class AssociactionCallTracker < TappingDevice
+      def validate_target!
+        raise NotAnActiveRecordInstanceError.new(target) unless target.is_a?(ActiveRecord::Base)
+      end
+
+      def filter_condition_satisfied?(tp)
+        return false unless is_from_target?(tp)
+
+        model_class = target.class
+        associations = model_class.reflections
+        associations.keys.include?(tp.callee_id.to_s)
+      end
+    end
+  end
+end

data/lib/tapping_device/trackers/initialization_tracker.rb

@@ -0,0 +1,44 @@
+class TappingDevice
+  module Trackers
+    class InitializationTracker < TappingDevice
+      def initialize(options = {}, &block)
+        super
+        event_type = @options[:event_type]
+        # if a class doesn't override the 'initialize' method
+        # Class.new will only trigger c_return or c_call
+        @options[:event_type] = [event_type, "c_#{event_type}"]
+      end
+
+      def track(object)
+        super
+        @is_active_record_model = target.ancestors.include?(ActiveRecord::Base)
+        self
+      end
+
+      def build_payload(tp:, filepath:, line_number:)
+        payload = super
+
+        return payload if @is_active_record_model
+
+        payload[:return_value] = payload[:receiver]
+        payload[:receiver] = target
+        payload
+      end
+
+      def validate_target!
+        raise NotAClassError.new(target) unless target.is_a?(Class)
+      end
+
+      def filter_condition_satisfied?(tp)
+        receiver = tp.self
+        method_name = tp.callee_id
+
+        if @is_active_record_model
+          method_name == :new && receiver.is_a?(Class) && receiver.ancestors.include?(target)
+        else
+          method_name == :initialize && receiver.is_a?(target)
+        end
+      end
+    end
+  end
+end