object_tracer 1.0.0

data/lib/object_tracer/trackers/association_call_tracker.rb

@@ -0,0 +1,17 @@
+class ObjectTracer
+  module Trackers
+    class AssociactionCallTracker < ObjectTracer
+      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/object_tracer/trackers/initialization_tracker.rb

@@ -0,0 +1,53 @@
+class ObjectTracer
+  module Trackers
+    class InitializationTracker < ObjectTracer
+      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 = defined?(ActiveRecord) && 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
+          # 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
+      end
+    end
+  end
+end

data/lib/object_tracer/trackers/method_call_tracker.rb

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

data/lib/object_tracer/trackers/mutation_tracker.rb

@@ -0,0 +1,111 @@
+class ObjectTracer
+  module Trackers
+    class MutationTracker < ObjectTracer
+      def initialize(options, &block)
+        options[:hijack_attr_methods] = true
+        super
+        @snapshot_stack = []
+      end
+
+      def track(object)
+        super
+        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 ObjectTracer.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 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: Output::PayloadWrapper::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: Output::PayloadWrapper::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/object_tracer/trackers/passed_tracker.rb

@@ -0,0 +1,16 @@
+class ObjectTracer
+  module Trackers
+    # PassedTracker tracks calls that use the target object as an argument
+    class PassedTracker < ObjectTracer
+      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/object_tracer/version.rb

@@ -0,0 +1,3 @@
+class ObjectTracer
+  VERSION = "1.0.0"
+end

data/object_tracer.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "object_tracer/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "object_tracer"
+  spec.version       = ObjectTracer::VERSION
+  spec.authors       = ["st0012"]
+  spec.email         = ["stan001212@gmail.com"]
+
+  spec.summary       = %q{object_tracer lets you understand what your Ruby objects do without digging into the code}
+  spec.description   = %q{object_tracer lets you understand what your Ruby objects do without digging into the code} 
+  spec.homepage      = "https://github.com/st0012/object_tracer"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/st0012/object_tracer"
+  spec.metadata["changelog_uri"] = "https://github.com/st0012/object_tracer/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "method_source", "~> 1.0.0"
+  spec.add_dependency "pastel", "~> 0.7"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: object_tracer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- st0012
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: method_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: object_tracer 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"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- Makefile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- images/print_calls - single entry.png
+- images/print_calls.png
+- images/print_mutations.png
+- images/print_traces.png
+- lib/object_tracer.rb
+- lib/object_tracer/configuration.rb
+- lib/object_tracer/exceptions.rb
+- lib/object_tracer/manageable.rb
+- lib/object_tracer/method_hijacker.rb
+- lib/object_tracer/output.rb
+- lib/object_tracer/output/payload_wrapper.rb
+- lib/object_tracer/output/writer.rb
+- lib/object_tracer/payload.rb
+- lib/object_tracer/trackable.rb
+- lib/object_tracer/trackers/association_call_tracker.rb
+- lib/object_tracer/trackers/initialization_tracker.rb
+- lib/object_tracer/trackers/method_call_tracker.rb
+- lib/object_tracer/trackers/mutation_tracker.rb
+- lib/object_tracer/trackers/passed_tracker.rb
+- lib/object_tracer/version.rb
+- object_tracer.gemspec
+homepage: https://github.com/st0012/object_tracer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/st0012/object_tracer
+  source_code_uri: https://github.com/st0012/object_tracer
+  changelog_uri: https://github.com/st0012/object_tracer/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key: 
+specification_version: 4
+summary: object_tracer lets you understand what your Ruby objects do without digging
+  into the code
+test_files: []