object_tracker 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54a446b93232eb855a137f08a67a61a5830ba71d
-  data.tar.gz: c0f8898440e271bd328e433f947cb73842169c92
+  metadata.gz: b64ab16d9d0b0d15225d24cf7121afb3061e88e8
+  data.tar.gz: 740e4ee7f4eacbbeba0c36211f4c3e032b505d1f
 SHA512:
-  metadata.gz: 74a1ff389ff3c7235a888c42b34b0ac6b224645ddb012920fa1f45c32354e27fcd4ff151dd70480c6f33df9a8d8d8d2648a9df44aece908976d583c44d0561f1
-  data.tar.gz: 52351e4b114d66cf31c906ac26d4791a45e95987a4034397dde712f57d74e6f51e18601a6e878444c1a1e1e7b4ef9a253d4d0b12fc6055fda0719d952eb8b5b8
+  metadata.gz: c1efef10178e161cb122b2c9a21dd4cf283251551100679c3017553dfefd66387558c3e54a3ff9d8ad64c32a9ffe52ba94a4bf2f1ec5c07766e9f1d4d894d9f7
+  data.tar.gz: 94ece458adbd7320c1d72b2c1f161d149179055dae3f8780baefe15262181b355c1afefb71b901d81cdc22df68510e70800b405961bea26601df63cf4350e17b

data/README.md

@@ -31,17 +31,41 @@ end
 
 Dog.track_all!
 Dog
-#=> inspect called from (irb):27
+    * called "inspect" [RUBY CORE]
+#=> Dog
 Dog.new.fetch('Hudog')
-#=> called new from (irb):27
-#=> called fetch with Hudog from (irb):27
+    * called "new" [RUBY CORE]
+    * called "fetch" with Hudog [(irb):4]
 #=> Fetch the ball Hudog!
 ```
 
 Or just track single method:
 
 ```ruby
-Dog.track! :fetch
+Dog.track :name
+```
+
+Or track methods for a single object:
+
+```ruby
+class Go
+  def fish
+    'We go!'
+  end
+end
+
+a = Go.new
+a.extend ObjectTracker
+a.track_all!
+```
+
+## Troubleshooting
+
+Having problems? Maybe a specific method is throwing some obscure error? Try ignoring that method, so we can get back on track!
+
+```ruby
+Dog.track_not :bad_doggy
+Dog.track_all! #=> will exclude tracking for :bad_doggy
 ```
 
 ## Contributing

data/lib/object_tracker.rb

@@ -4,33 +4,57 @@ fail "ObjectTracker #{ObjectTracker::VERSION} only supports Ruby 2+" if RUBY_VER
 
 module ObjectTracker
   def track(*args)
-    @__tracking ||= []
-    args.each { |arg| @__tracking << arg unless tracking?(arg) }
+    args.each do |method_name|
+      next if tracking?(method_name) || track_reserved_methods.include?(method_name)
+      if respond_to?(method_name)
+        track!(method_name => track_with_source(self, method_name))
+      elsif respond_to?(:allocate)
+        inst = allocate
+        if inst.respond_to?(method_name)
+          track!(method_name => track_with_source(inst, method_name))
+        else
+          fail UntrackableMethod, method_name
+        end
+      else
+        fail UntrackableMethod, method_name
+      end
+    end
+    nil
   end
 
-  def track!(*args)
-    track(*args)
-    start_tracking!
+  def tracking?(method_name)
+    tracking.keys.include?(method_name.to_sym)
   end
 
-  def track_all!
-    track!(*(methods | instance_methods))
+  def track_not(*args)
+    args.each do |method_name|
+      track_reserved_methods << method_name unless track_reserved_methods.include?(method_name)
+    end
+    nil
   end
 
-  def tracking?(method_name)
-    @__tracking.include?(method_name)
+  def track_all!
+    track_methods_for(self)
+    track_methods_for(allocate) if respond_to?(:allocate)
+    track!
   end
 
-  def start_tracking!
+  #
+  # PRIVATE
+  #
+
+  def track!(method_names = nil)
     mod = Module.new
-    @__tracking.each do |method_name|
+    Array(method_names || tracking).each do |method_name, source_def|
       mod.module_eval <<-RUBY, __FILE__, __LINE__
         def #{method_name}(*args, &block)
-          msg = "called #{method_name} "
+          msg = %Q(   * called "#{method_name}" )
           msg << "with " << args.join(', ') << " " if args.any?
-          msg << "from #{__FILE__}:#{__LINE__}"
+          msg << "[#{source_def}]"
           puts msg
           super
+        rescue NoMethodError => e
+          raise e if e.message !~ /no superclass/
         end
       RUBY
     end
@@ -41,6 +65,65 @@ module ObjectTracker
       end
     RUBY
 
-    prepend(mod)
+    # Handle both instance and class level extension
+    if respond_to?(:prepend)
+      prepend(mod)
+    else
+      extend(mod)
+    end
+  end
+
+  def track_methods_for(obj)
+    (obj.methods - track_reserved_methods).each do |method_name|
+      track_with_source(obj, method_name)
+    end
+  end
+
+  def track_with_source(obj, method_name)
+    source = obj.method(method_name).source_location || ['RUBY CORE']
+    tracking[method_name.to_sym] = source.join(':').split('/').last(5).join('/')
+  end
+
+  def tracking
+    @__tracking ||= {}
+  end
+
+  def track_reserved_methods
+    @__reserved_methods ||= [
+      :!,
+      :!=,
+      :!~,
+      :<,
+      :<=,
+      :<=>,
+      :==,
+      :===,
+      :=~,
+      :>,
+      :>=,
+      :[],
+      :[]=,
+      :__id__,
+      :__send__,
+      :`,
+      :public_send,
+      :send,
+      :class,
+      :track,
+      :tracking?,
+      :track_not,
+      :track_all!,
+      :track!,
+      :track_methods_for,
+      :track_with_source,
+      :tracking,
+      :track_reserved_methods
+    ]
+  end
+
+  class UntrackableMethod < StandardError
+    def initialize(method_name)
+      super "Can't track :#{method_name} because it's not defined on this class or it's instance"
+    end
   end
-end
+end

data/lib/object_tracker/version.rb

@@ -1,3 +1,3 @@
 module ObjectTracker
-  VERSION = "0.0.2"
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: object_tracker
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Ryan Buckley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-05 00:00:00.000000000 Z
+date: 2015-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -74,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Track method calls to any object.