tapping_device 0.5.2 → 0.5.7

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, :ivar_changes
+      :defined_class, :trace, :tag, :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

@@ -20,47 +20,80 @@ class TappingDevice
       TappingDevice::Trackers::MutationTracker.new(options, &block).track(object)
     end
 
-    def print_traces(target, options = {})
-      output_options = extract_output_options(options)
-      options[:event_type] = :call
+    [:calls, :traces, :mutations].each do |subject|
+      [:print, :write].each do |output_action|
+        helper_method_name = "#{output_action}_#{subject}"
 
-      device_1 = tap_on!(target, options).and_print do |output_payload|
-        "Called #{output_payload.method_name_and_location(output_options)}"
-      end
-      device_2 = tap_passed!(target, options).and_print do |output_payload|
-        output_payload.passed_at(output_options)
+        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
-      CollectionProxy.new([device_1, device_2])
     end
 
-    def print_calls(target, options = {})
-      output_options = extract_output_options(options)
+    private
+
+    def output_calls(target, options = {}, output_action:)
+      device_options, output_options = separate_options(options)
 
-      tap_on!(target, options).and_print do |output_payload|
+      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 print_mutations(target, options = {})
-      output_options = extract_output_options(options)
+    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, 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 output_mutations(target, options = {}, output_action:)
+      device_options, output_options = separate_options(options)
 
-      tap_mutation!(target, options).and_print do |output_payload|
+      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
 
-    private
+    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
 
-    def extract_output_options(options)
-      {inspect: options.delete(:inspect), colorize: options.fetch(:colorize, true)}
+      [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)
@@ -68,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/initialization_tracker.rb

@@ -1,8 +1,25 @@
 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
@@ -16,8 +33,17 @@ class TappingDevice
         receiver = tp.self
         method_name = tp.callee_id
 
-        if target.ancestors.include?(ActiveRecord::Base)
-          method_name == :new && receiver.ancestors.include?(target)
+        if @is_active_record_model
+          # ActiveRecord redefines model classes' .new method,
+          # so instead of calling Model#initialize, it'll actually call Model.new
+          # see https://github.com/rails/rails/blob/master/activerecord/lib/active_record/inheritance.rb#L50
+          method_name == :new &&
+            receiver.is_a?(Class) &&
+            # this checks if the model class is the target class or a subclass of it
+            receiver.ancestors.include?(target) &&
+            # Model.new triggers both c_return and return events. so we should only return in 1 type of the events
+            # otherwise the callback will be triggered twice
+            tp.event == :return
         else
           method_name == :initialize && receiver.is_a?(target)
         end

data/lib/tapping_device/trackers/mutation_tracker.rb

@@ -1,16 +1,14 @@
-require "pry" # for using Method#source
-
 class TappingDevice
   module Trackers
     class MutationTracker < TappingDevice
       def initialize(options, &block)
+        options[:hijack_attr_methods] = true
         super
         @snapshot_stack = []
       end
 
       def track(object)
         super
-        hijack_attr_writers
         insert_snapshot_taking_trace_point
         self
       end
@@ -45,24 +43,6 @@ class TappingDevice
         end
       end
 
-      def hijack_attr_writers
-        writer_methods = target.methods.grep(/\w+=/)
-        writer_methods.each do |method_name|
-          if target.method(method_name).source.match?(/attr_writer|attr_accessor/)
-            ivar_name = "@#{method_name.to_s.sub("=", "")}"
-
-            # need to use instance_eval to make the call site location consistent with normal methods
-            target.instance_eval(
-              <<~CODE
-                def #{method_name}(val)
-                  #{ivar_name} = val
-                end
-              CODE
-            )
-          end
-        end
-      end
-
       def build_payload(tp:, filepath:, line_number:)
         payload = super
 
@@ -78,12 +58,12 @@ class TappingDevice
 
         additional_keys = @latest_instance_variables.keys - @instance_variables_snapshot.keys
         additional_keys.each do |key|
-          changes[key] = {before: OutputPayload::UNDEFINED, after: @latest_instance_variables[key]}
+          changes[key] = {before: Output::Payload::UNDEFINED, after: @latest_instance_variables[key]}
         end
 
         removed_keys = @instance_variables_snapshot.keys - @latest_instance_variables.keys
         removed_keys.each do |key|
-          changes[key] = {before: @instance_variables_snapshot[key], after: OutputPayload::UNDEFINED}
+          changes[key] = {before: @instance_variables_snapshot[key], after: Output::Payload::UNDEFINED}
         end
 
         remained_keys = @latest_instance_variables.keys - additional_keys

data/lib/tapping_device/version.rb

@@ -1,3 +1,3 @@
 class TappingDevice
-  VERSION = "0.5.2"
+  VERSION = "0.5.7"
 end

data/tapping_device.gemspec

@@ -33,6 +33,8 @@ Gem::Specification.new do |spec|
   end
 
   spec.add_dependency "pry" # for using Method#source in MutationTracker
+  spec.add_dependency "activesupport"
+  spec.add_dependency "pastel"
 
   spec.add_development_dependency "sqlite3", ">= 1.3.6"
   spec.add_development_dependency "database_cleaner"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tapping_device
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.7
 platform: ruby
 authors:
 - st0012
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-10 00:00:00.000000000 Z
+date: 2020-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -38,6 +38,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -137,6 +165,7 @@ files:
 - ".rspec"
 - ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -150,9 +179,15 @@ files:
 - images/print_mutations.png
 - images/print_traces.png
 - lib/tapping_device.rb
+- lib/tapping_device/configurable.rb
 - lib/tapping_device/exceptions.rb
 - lib/tapping_device/manageable.rb
-- lib/tapping_device/output_payload.rb
+- lib/tapping_device/method_hijacker.rb
+- lib/tapping_device/output.rb
+- lib/tapping_device/output/file_writer.rb
+- lib/tapping_device/output/payload.rb
+- lib/tapping_device/output/stdout_writer.rb
+- lib/tapping_device/output/writer.rb
 - lib/tapping_device/payload.rb
 - lib/tapping_device/trackable.rb
 - lib/tapping_device/trackers/association_call_tracker.rb

data/lib/tapping_device/output_payload.rb

@@ -1,173 +0,0 @@
-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