gun_dog 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8553b5cae7081c781faffb51279789d50c10b352
-  data.tar.gz: f1dae43fce48c756e6bc004a7708879d3f1e7d94
+  metadata.gz: efabc10a53ec099193771fc99c5f2b81f058c4d6
+  data.tar.gz: fa3ddf6614c1ba10ab5d7edaf96fc86e118592cc
 SHA512:
-  metadata.gz: bab212ec57b6f8d3b10b8fbb4adda795a932aa6b539ecd53b35b3977d628040696fe9544d49508f24be2c4827195b86100269694a8a05cb1ffd8f421c955cc70
-  data.tar.gz: 53117f89da46453a9e567265ab8bb781c2c6431b859b713fdefa57c502b5f62355ef9e1456001fe5c88439505bfa0704bcd7f432cd7ca4610f0155e6d71107b8
+  metadata.gz: 56fbd2df15fef26b10fcd08d6e38698e00bb82016f98584ccc031dfd71bfb62a55eaf3c64f8718a2b4d71316bee315dc5bd7f8c29ee6c34e7dd30786dbae34e6
+  data.tar.gz: b822005d9050925dce5979fb35d89237daea139422ab22dd45c6803b9b4e2e1051b69325a69cf01d85ecccb118680c39e6183850917253cd2afeff78f7a656ae

data/gun_dog.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "multi_json", "~> 1.12"
   spec.add_dependency "activesupport", ">= 4.2.9"
+  spec.add_dependency "method_source"
 
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/gun_dog/call_record.rb

@@ -2,7 +2,7 @@ module GunDog
   class CallRecord
     using ClassEncoding
 
-    attr_accessor :args, :return_value, :method_name
+    attr_accessor :args, :return_value, :method_name, :extra_module
     attr_accessor :stack
 
     attr_writer :internal, :cyclical, :dynamic
@@ -11,8 +11,8 @@ module GunDog
       cr = new(
         Utilities.get_class(json['klass']),
         json['method_name'],
-        class_method: json['class_method'],
-        generated: json['generated']
+        origin: json['origin'],
+        extra_module: ( Utilities.get_class(json['extra_module']) if json['extra_module'] )
       )
 
       cr.instance_eval do
@@ -26,11 +26,11 @@ module GunDog
       cr
     end
 
-    def initialize(klass, method_name, class_method: false, generated: false)
+    def initialize(klass, method_name, origin: false, extra_module: nil)
       @klass = klass
       @method_name = method_name
-      @class_method = class_method
-      @generated = generated
+      @origin = origin
+      @extra_module = extra_module
     end
 
     def method_location
@@ -50,11 +50,32 @@ module GunDog
     end
 
     def class_method?
-      !!@class_method
+      @origin == :eigen
     end
 
-    def generated?
-      !!@generated
+    def origin
+      @origin
+    end
+
+    def special_origin?
+      [:meta, :included, :refinement].include?(@origin)
+    end
+
+    def origin_string
+      case @origin
+      when :meta
+        '[generated]'
+      when :included
+        "[#{unbound_method.owner.name.to_s}]"
+      when :extended
+        "[#{extra_module.name.to_s} (extended)]"
+      when :prepended
+        "[#{unbound_method.owner.name.to_s} (prepended)]"
+      when :refinement
+        "[using #{extra_module.split('@')[1][0..-2]}]"
+      else
+        nil
+      end
     end
 
     def unbound_method
@@ -66,7 +87,7 @@ module GunDog
     end
 
     def call_record_signature
-      "#{generated? ? "[generated] " : nil } \
+      "#{origin_string} \
         def #{class_method? ? "self." : nil}#{method_name}(#{type_signatures(args)}) : #{return_value.class} \
         #{ internal? ? " (internal)" : nil } \
         #{ cyclical? ? " (cyclical)" : nil } \
@@ -77,8 +98,8 @@ module GunDog
       {
         "klass" => @klass.json_encoded,
         "method_name" => method_name.to_s,
-        "class_method" => class_method?,
-        "generated" => generated?,
+        "origin" => origin,
+        "extra_module" => @extra_module,
         "internal" => internal?,
         "cyclical" => cyclical?,
         "dynamic" => dynamic?,
@@ -95,6 +116,8 @@ module GunDog
         #TODO pass v here back through this method to show the type signatures for each method rather than
         # individual arguments
         args.each_pair.map { |k,v| "#{k} : #{v ? v.to_s : v.class}" }.join(', ')
+      elsif origin == :refinement
+        '?'
       else
         args.each_pair.map { |k,v| "#{k} : #{v.class}" }.join(', ')
       end

data/lib/gun_dog/trace_maker.rb

@@ -1,19 +1,25 @@
 require 'active_support/core_ext/module/anonymous'
+require 'method_source'
 
 module GunDog
   class TraceMaker
-    attr_reader :trace_report, :return_trace, :call_trace, :klass, :complete_call_list
+    using GunDog::Utilities::RefinementIntrospection
+
+    attr_reader :trace_report, :return_trace, :call_trace, :klass, :complete_call_list, :c_call_trace
 
     def initialize(klass, suppress: [], &exec_block)
       @klass = klass
       @trace_report = TraceReport.new(klass, suppression_set: build_suppression_set(suppress))
       @trace_report.stack << MethodOwnerStackFrame.new(GunDog, :trace)
       @ancestor_cache = {}
+      @included_cache = {}
       @exec_block = exec_block
+      @mrt_tracers = []
     end
 
     def exec
       set_trace
+      wrap_accessor_functions
 
       call_trace.enable do
         return_trace.enable do
@@ -24,6 +30,8 @@ module GunDog
       trace_report.finalize_report
       trace_report
     ensure
+      @mrt_tracers.each(&:disable)
+      unwrap_accessor_functions
       call_trace.disable
       return_trace.disable
     end
@@ -33,6 +41,36 @@ module GunDog
       set_call_trace
     end
 
+    def unwrap_accessor_functions
+      accessor_methods.map do |m|
+        klass.send(:remove_method, m)
+
+        if m.to_s[-1] == '='
+          klass.send :attr_writer, m[0..-2]
+        else
+          klass.send :attr_reader, m
+        end
+      end
+    end
+
+    def wrap_accessor_functions
+      accessor_methods.map do |m|
+        if m.to_s[-1] == '='
+          klass.module_eval <<~RUBY, __FILE__, __LINE__
+              def #{m.to_s}(arg1)
+                @#{m.to_s[0..-2]} = arg1
+              end
+          RUBY
+        else
+          klass.module_eval <<~RUBY, __FILE__, __LINE__
+              def #{m.to_s}
+                @#{m.to_s}
+              end
+          RUBY
+        end
+      end
+    end
+
     def set_return_trace
       @return_trace ||= TracePoint.new(:return) do |tp|
         trace_report.stack.pop
@@ -41,52 +79,75 @@ module GunDog
 
     def set_call_trace
       @call_trace ||= TracePoint.new(:call) do |tp|
-        trace_report.stack << MethodOwnerStackFrame.new(tp.defined_class, tp.method_id)
+        begin
+          tp.disable
 
-        tp.disable
+          trace_report.stack << MethodOwnerStackFrame.new(tp.defined_class, tp.method_id)
 
-        binding_class = tp.binding.eval('self').class
-        trace_type = trace_method(binding_class, tp.defined_class)
+          binding_class = tp.binding.receiver.class
+          trace_type = trace_method(binding_class, tp.defined_class, tp.self)
+          method_id = tp.binding.eval('__callee__') || tp.method_id
 
-        unless trace_type
-          tp.enable
-          next
-        end
+          unless trace_type
+            tp.enable
+            next
+          end
 
-        method_id = tp.binding.eval('__callee__') || tp.method_id
+          call_record = nil
 
-        called_method = if trace_type == :meta
-          tp.binding.eval('self').method(method_id)
-        else
-          tp.self.method(tp.method_id)
-        end
+          if trace_type == :refinement
+            call_record = CallRecord.new(
+              klass,
+              method_id,
+              origin: trace_type,
+              extra_module: tp.defined_class.to_s
+            )
+          else
+            called_method = if trace_type == :meta || trace_type == :included
+                              tp.binding.eval('self').method(method_id)
+                            else
+                              tp.self.method(tp.method_id)
+                            end
+
+            call_record = CallRecord.new(
+              klass,
+              called_method.name,
+              origin: trace_type,
+              extra_module: (tp.defined_class if trace_type == :extended)
+            )
+
+            call_record.args = called_method.parameters.each.with_object({}) do |p, memo|
+              memo[p.last] = tp.binding.local_variable_get(p.last)
+            end
+          end
 
-        # next if trace_report.suppression_set.include?(called_method.unbind)
+          trace_report.call_records << call_record
 
-        call_record = CallRecord.new(
-          klass,
-          called_method.name,
-          class_method: trace_type == :eigen,
-          generated: trace_type == :meta
-        )
+          mrt = set_method_return_trace(call_record)
+          @mrt_tracers << mrt
+          mrt.enable
 
-        call_record.args = called_method.parameters.each.with_object({}) do |p, memo|
-          memo[p.last] = tp.binding.local_variable_get(p.last)
+          tp.enable
+        rescue => e
+          STDOUT.puts "#{tp.method_id} => #{trace_type} (#{tp.defined_class})"
+          puts "#{e.class} => #{e.message}"
+          puts "=============================================================================="
+          puts e.backtrace
+          puts "=============================================================================="
+          tp.disable
         end
-
-        trace_report.call_records << call_record
-
-        set_method_return_trace(call_record).enable
-
-        tp.enable
       end
     end
 
-    def trace_method(binding_class, defined_class)
+    def trace_method(binding_class, defined_class, obj)
       return :eigen if defined_class == klass.singleton_class
       return false if binding_class != klass
-      return :meta if klass < defined_class && (defined_class.anonymous? || after_super?(defined_class))
+      return :refinement if defined_class.is_refinement?
+      return :meta if klass < defined_class && defined_class.anonymous?
+      return :prepended if klass < defined_class && prepended?(defined_class)
+      return :included if klass < defined_class && after_super?(defined_class)
       return :instance if defined_class == klass
+      return :extended if obj.singleton_class < defined_class && after_super?(defined_class)
       false
     end
 
@@ -101,16 +162,25 @@ module GunDog
       end
     end
 
+    def prepended?(defined_class)
+      if @included_cache.has_key?(defined_class)
+        @included_cache[defined_class]
+      else
+        ancestors = klass.ancestors
+        @included_cache[defined_class] = ancestors.index(klass) > ancestors.index(defined_class)
+      end
+    end
+
     def set_method_return_trace(call_record)
       # instantiate a new return tracepoint to watch for the return of this
       # method only
-      #
       TracePoint.new(:return) do |mrt|
         method_id = mrt.binding.eval('__callee__') || mrt.method_id
         next if method_id != call_record.method_name
         mrt.disable
         call_record.return_value = mrt.return_value
 
+
         if trace_report.stack.internal_stack?
           call_record.internal = true
           call_record.stack = trace_report.stack.since_first_klass_entry
@@ -126,6 +196,15 @@ module GunDog
       end
     end
 
+    private
+
+    def accessor_methods
+      @accessor_methods ||= klass.instance_methods.map { |m| klass.instance_method(m) }
+        .select { |m| m.owner == klass }
+        .select { |m| m.source =~ /attr/ }
+        .map { |m| m.name }
+    end
+
     def build_suppression_set(suppression_list)
       suppression_list.map { |method_id|
         begin

data/lib/gun_dog/trace_stack.rb

@@ -1,5 +1,7 @@
 module GunDog
   class TraceStack < Array
+    using Utilities::RefinementIntrospection
+
     attr_reader :collaborating_classes, :klass
 
     def self.from_json(json)
@@ -22,7 +24,13 @@ module GunDog
     end
 
     def classes_in_stack
-      self.group_by(&:klass).keys.to_set
+      self.group_by { |frame|
+        if refined_class = frame.klass.to_s[/#<refinement:(.*?)@/,1]
+          Kernel.const_get(refined_class)
+        else
+          frame.klass
+        end
+      }.keys.to_set
     end
 
     def initialize(klass)
@@ -51,6 +59,7 @@ module GunDog
     end
 
     def preceded_by_traced_klass?
+      # FIXME this method is terribly ineffcient
       traced_klasses = self.map(&:klass)
       traced_klasses.include?(klass) || traced_klasses.include?(klass.singleton_class)
     end
@@ -85,7 +94,9 @@ module GunDog
     end
 
     def frame_owned_by_traced_klass?(frame)
-      frame.klass == klass || frame.klass.singleton_class == klass.singleton_class
+      return true if frame.klass == klass
+      return true if frame.klass.singleton_class == klass.singleton_class
+      return true if frame.klass.refined_class == klass
     end
 
     def as_json

data/lib/gun_dog/utilities.rb

@@ -1,5 +1,22 @@
 module GunDog
   module Utilities
+    module RefinementIntrospection
+      refine Module do
+        def is_refinement?
+          to_s.present? && to_s =~ /refinement/
+        end
+
+        def refined_class
+          target = to_s[/#<refinement:(.*?)@/,1]
+          return nil unless target
+          const_get(target)
+        rescue NoMethodError => e
+          # hack - this is raised on AR objects if you call to_s before the
+          # the inherited hooks are finished running
+        end
+      end
+    end
+
     class UnencodableClass; end
 
     def self.get_class(str)
@@ -13,7 +30,6 @@ module GunDog
         begin
           eval(str)
         rescue => e
-          require 'pry'; binding.pry
           e.message
         end
       end

data/lib/gun_dog/version.rb

@@ -1,3 +1,3 @@
 module GunDog
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gun_dog
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Stephen Prater
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-19 00:00:00.000000000 Z
+date: 2017-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.9
+- !ruby/object:Gem::Dependency
+  name: method_source
+  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: bundler
   requirement: !ruby/object:Gem::Requirement