tapping_device 0.4.10 → 0.5.3

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,175 @@
+class TappingDevice
+  module Output
+    class Payload < 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)}\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

@@ -1,13 +1,12 @@
-require "awesome_print"
 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
     ]
 
     ATTRS.each do |attr|
-      define_method attr do
+      define_method attr do |options = {}|
         self[attr]
       end
     end
@@ -20,54 +19,12 @@ 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]
+      method_object.source.strip if method_object.source_location
     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(awesome_print: false)
-      arguments_output = arguments.inspect
-      return_value_output = return_value.inspect
-
-      if awesome_print
-        arguments_output = arguments.ai(ruby19_syntax: true, multiline: false)
-        return_value_output = return_value.ai(ruby19_syntax: true, multiline: false)
-      end
-
-      <<~MSG
-      #{method_name_and_defined_class}
-          from: #{location}
-          <= #{arguments_output}
-          => #{return_value_output}
-
-      MSG
-    end
   end
 end

data/lib/tapping_device/trackable.rb

@@ -1,35 +1,101 @@
 class TappingDevice
   module Trackable
-    [:tap_on!, :tap_init!, :tap_assoc!, :tap_sql!, :tap_passed!].each do |method|
-      define_method method do |object, options = {}, &block|
-        new_device(options, &block).send(method, object)
-      end
+    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
 
     def print_traces(target, options = {})
-      options[:event_type] = :call
+      output_traces(target, options, output_action: :and_print)
+    end
+
+    def write_traces(target, options = {})
+      output_traces(target, options, output_action: :and_write)
+    end
+
+    def print_calls(target, options = {})
+      output_calls(target, options, output_action: :and_print)
+    end
+
+    def write_calls(target, options = {})
+      output_calls(target, options, output_action: :and_write)
+    end
 
-      device_1 = tap_on!(target, options) do |payload|
-        puts("Called #{payload.method_name_and_location}")
+    def print_mutations(target, options = {})
+      output_mutations(target, options, output_action: :and_print)
+    end
+
+    def write_mutations(target, options = {})
+      output_mutations(target, options, output_action: :and_write)
+    end
+
+    private
+
+    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) 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, device_options).send(output_action, options: output_options) do |output_payload, output_options|
+        output_payload.passed_at(output_options)
       end
-      [device_1, device_2]
+      CollectionProxy.new([device_1, device_2])
     end
 
-    def print_calls_in_detail(target, options = {})
-      awesome_print = options.delete(:awesome_print)
+    def output_mutations(target, options = {}, output_action:)
+      device_options, output_options = separate_options(options)
+
+      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
 
-      tap_on!(target, options) do |payload|
-        puts(payload.detail_call_info(awesome_print: awesome_print))
+    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
 
-    def new_device(options, &block)
-      TappingDevice.new(options, &block)
+    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

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,27 @@
+class TappingDevice
+  module Trackers
+    class InitializationTracker < TappingDevice
+      def build_payload(tp:, filepath:, line_number:)
+        payload = super
+        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 target.ancestors.include?(ActiveRecord::Base)
+          method_name == :new && receiver.ancestors.include?(target)
+        else
+          method_name == :initialize && receiver.is_a?(target)
+        end
+      end
+    end
+  end
+end