tapping_device 0.4.9 → 0.5.2

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,53 +19,13 @@ 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]
     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,74 @@
 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 = {})
+      output_options = extract_output_options(options)
       options[:event_type] = :call
 
-      device_1 = tap_on!(target, options) do |payload|
-        puts("Called #{payload.method_name_and_location}")
+      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)
       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}")
+      CollectionProxy.new([device_1, device_2])
+    end
+
+    def print_calls(target, options = {})
+      output_options = extract_output_options(options)
+
+      tap_on!(target, options).and_print do |output_payload|
+        output_payload.detail_call_info(output_options)
       end
-      [device_1, device_2]
     end
 
-    def print_calls_in_detail(target, options = {})
-      awesome_print = options.delete(:awesome_print)
+    def print_mutations(target, options = {})
+      output_options = extract_output_options(options)
 
-      tap_on!(target, options) do |payload|
-        puts(payload.detail_call_info(awesome_print: awesome_print))
+      tap_mutation!(target, options).and_print do |output_payload|
+        output_payload.call_info_with_ivar_changes(output_options)
       end
     end
 
-    def new_device(options, &block)
-      TappingDevice.new(options, &block)
+    private
+
+    def extract_output_options(options)
+      {inspect: options.delete(:inspect), colorize: options.fetch(:colorize, true)}
+    end
+
+    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
+
+include TappingDevice::Trackable

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

data/lib/tapping_device/trackers/method_call_tracker.rb

@@ -0,0 +1,9 @@
+class TappingDevice
+  module Trackers
+    class MethodCallTracker < TappingDevice
+      def filter_condition_satisfied?(tp)
+        is_from_target?(tp)
+      end
+    end
+  end
+end

data/lib/tapping_device/trackers/mutation_tracker.rb

@@ -0,0 +1,132 @@
+require "pry" # for using Method#source
+
+class TappingDevice
+  module Trackers
+    class MutationTracker < TappingDevice
+      def initialize(options, &block)
+        super
+        @snapshot_stack = []
+      end
+
+      def track(object)
+        super
+        hijack_attr_writers
+        insert_snapshot_taking_trace_point
+        self
+      end
+
+      def stop!
+        super
+        @ivar_snapshot_trace_point.disable
+      end
+
+      private
+
+      # we need to snapshot instance variables at the beginning of every method call
+      # so we can get a correct state for the later comparison
+      def insert_snapshot_taking_trace_point
+        @ivar_snapshot_trace_point = build_minimum_trace_point(event_type: :call) do
+          snapshot_instance_variables
+        end
+
+        @ivar_snapshot_trace_point.enable unless TappingDevice.suspend_new
+      end
+
+      def filter_condition_satisfied?(tp)
+        return false unless is_from_target?(tp)
+
+        if snapshot_capturing_event?(tp)
+          true
+        else
+          @latest_instance_variables = target_instance_variables
+          @instance_variables_snapshot = @snapshot_stack.pop
+
+          @latest_instance_variables != @instance_variables_snapshot
+        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
+
+        if change_capturing_event?(tp)
+          payload[:ivar_changes] = capture_ivar_changes
+        end
+
+        payload
+      end
+
+      def capture_ivar_changes
+        changes = {}
+
+        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]}
+        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}
+        end
+
+        remained_keys = @latest_instance_variables.keys - additional_keys
+        remained_keys.each do |key|
+          next if @latest_instance_variables[key] == @instance_variables_snapshot[key]
+          changes[key] = {before: @instance_variables_snapshot[key], after: @latest_instance_variables[key]}
+        end
+
+        changes
+      end
+
+      def snapshot_instance_variables
+        @snapshot_stack.push(target_instance_variables)
+      end
+
+      def target_instance_variables
+        target.instance_variables.each_with_object({}) do |ivar, hash|
+          hash[ivar] = target.instance_variable_get(ivar)
+        end
+      end
+
+      def snapshot_capturing_event?(tp)
+        tp.event == :call
+      end
+
+      def change_capturing_event?(tp)
+        !snapshot_capturing_event?(tp)
+      end
+
+      # belows are debugging helpers
+      # I'll leave them for a while in case there's a bug in the tracker
+      def print_snapshot_stack(tp)
+        puts("===== STACK - #{tp.callee_id} (#{tp.event}) =====")
+        puts(@snapshot_stack)
+        puts("================ END STACK =================")
+      end
+
+      def print_state_comparison
+        puts("###############")
+        puts(@latest_instance_variables)
+        puts(@instance_variables_snapshot)
+        puts("###############")
+      end
+    end
+  end
+end

data/lib/tapping_device/trackers/passed_tracker.rb

@@ -0,0 +1,16 @@
+class TappingDevice
+  module Trackers
+    # PassedTracker tracks calls that use the target object as an argument
+    class PassedTracker < TappingDevice
+      def filter_condition_satisfied?(tp)
+        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
+          target == value rescue false
+        end
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/tapping_device/version.rb

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

data/tapping_device.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["st0012"]
   spec.email         = ["stan001212@gmail.com"]
 
-  spec.summary       = %q{tapping_device provides useful helpers to intercept method calls}
-  spec.description   = %q{tapping_device provides useful helpers to intercept method calls}
+  spec.summary       = %q{tapping_device lets you understand what your Ruby objects do without digging into the code}
+  spec.description   = %q{tapping_device lets you understand what your Ruby objects do without digging into the code} 
   spec.homepage      = "https://github.com/st0012/tapping_device"
   spec.license       = "MIT"
 
@@ -32,13 +32,12 @@ Gem::Specification.new do |spec|
     spec.add_dependency "activerecord", ">= 5.2"
   end
 
-  spec.add_dependency "awesome_print"
+  spec.add_dependency "pry" # for using Method#source in MutationTracker
 
   spec.add_development_dependency "sqlite3", ">= 1.3.6"
   spec.add_development_dependency "database_cleaner"
   spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "simplecov", "0.17.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tapping_device
 version: !ruby/object:Gem::Version
-  version: 0.4.9
+  version: 0.5.2
 platform: ruby
 authors:
 - st0012
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-20 00:00:00.000000000 Z
+date: 2020-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.2'
 - !ruby/object:Gem::Dependency
-  name: awesome_print
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -80,34 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -136,17 +122,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.17.1
-description: tapping_device provides useful helpers to intercept method calls
+description: tapping_device lets you understand what your Ruby objects do without
+  digging into the code
 email:
 - stan001212@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".DS_Store"
 - ".github/workflows/gempush.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -156,12 +145,21 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- images/print_calls - single entry.png
+- images/print_calls.png
+- images/print_mutations.png
+- images/print_traces.png
 - lib/tapping_device.rb
 - lib/tapping_device/exceptions.rb
 - lib/tapping_device/manageable.rb
+- lib/tapping_device/output_payload.rb
 - lib/tapping_device/payload.rb
-- lib/tapping_device/sql_tapping_methods.rb
 - lib/tapping_device/trackable.rb
+- lib/tapping_device/trackers/association_call_tracker.rb
+- lib/tapping_device/trackers/initialization_tracker.rb
+- lib/tapping_device/trackers/method_call_tracker.rb
+- lib/tapping_device/trackers/mutation_tracker.rb
+- lib/tapping_device/trackers/passed_tracker.rb
 - lib/tapping_device/version.rb
 - tapping_device.gemspec
 homepage: https://github.com/st0012/tapping_device
@@ -189,5 +187,6 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: tapping_device provides useful helpers to intercept method calls
+summary: tapping_device lets you understand what your Ruby objects do without digging
+  into the code
 test_files: []