method_locator 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+.idea/*
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ryan LeCompte
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,142 @@
+# Method Locator
+
+Method Locator is a Ruby gem that allows you to easily determine the method lookup path of a particular
+object / class / module, as well as find all places (represented as UnboundMethod instances) where
+a callable method is defined on an object. This is very useful in an environment such as Rails where
+you are unsure where a method may be defined or overridden. Note that by default, Ruby tends to hide
+singleton classes when you invoke Class#ancestors. The new Object#method_lookup_path does not hide
+these singleton classes and will return them, so that you get a true representation of how Ruby
+performs lookups for methods.
+
+## Installation
+
+Method Locator is available as a RubyGem:
+
+    gem install method_locator
+
+## Examples
+
+```ruby
+module M1
+  def foo
+    puts "foo from M1"
+  end
+end
+
+module M2
+  def foo
+    puts "foo from M2"
+  end
+end
+
+module M3
+  def blah
+    puts "blah from M3"
+  end
+end
+
+module M4
+  def self.hello
+    puts "hello from M4"
+  end
+end
+
+class A
+  def foo
+    puts "foo from A"
+  end
+
+  def self.blah
+    puts "blah from A"
+  end
+end
+
+class B < A
+  include M1
+  include M2
+
+  def foo
+    puts "foo from B"
+  end
+
+  def self.blah
+    puts "blah from B"
+  end
+end
+
+B.extend(M3)
+
+b = B.new
+
+def b.foo
+  puts "foo from b's singleton class!"
+end
+
+puts "all method owners of b#foo"
+b.methods_for(:foo).each { |m| puts "#{m.name}, owner: #{m.owner}" }
+
+puts "all method owners of B.blah"
+B.methods_for(:blah).each { |m| puts "#{m.name}, owner: #{m.owner}" }
+
+puts "all method owners of B.new"
+B.methods_for(:new).each { |m| puts "#{m.name}, owner: #{m.owner}" }
+
+puts "all method owners of M4.hello"
+M4.methods_for(:hello).each { |m| puts "#{m.name}, owner: #{m.owner}" }
+
+puts "method lookup path for b"
+p b.method_lookup_path
+
+puts "method lookup path for B"
+p B.method_lookup_path
+
+puts "method lookup path for M2"
+p M2.method_lookup_path
+
+
+# OUTPUT
+
+all method owners of b#foo
+foo, owner: #<Class:#<B:0x007fcc74031d38>>
+foo, owner: B
+foo, owner: M2
+foo, owner: M1
+foo, owner: A
+
+all method owners of B.blah
+blah, owner: #<Class:B>
+blah, owner: M3
+blah, owner: #<Class:A>
+
+all method owners of B.new
+new, owner: Class
+
+all method owners of M4.hello
+hello, owner: #<Class:M4>
+
+method lookup path for b
+[#<Class:#<B:0x007fcc74031d38>>, B, M2, M1, A, Object, MethodLocator, Kernel, BasicObject]
+
+method lookup path for B
+[#<Class:B>, M3, #<Class:A>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, MethodLocator, Kernel, BasicObject]
+
+method lookup path for M2
+[#<Class:M2>, Module, Object, MethodLocator, Kernel, BasicObject]
+```
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Authors
+
+* Ryan LeCompte
+
+## Copyright
+
+Copyright (c) 2011 Ryan LeCompte. See LICENSE for
+further details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/method_locator.rb

@@ -0,0 +1,43 @@
+require "method_locator/version"
+
+# MethodLocator finds all method definitions in an object instance, class, or
+# module ancestor chain. This code will make more sense if you understand Ruby's
+# object model and method lookup path. A great explanation of this can be found in:
+# "Ruby's Eigenclasses Demystified" - http://blog.madebydna.com/all/code/2011/06/24/eigenclasses-demystified.html
+
+module MethodLocator
+  def methods_for(meth)
+    method_lookup_path.each_with_object([]) do |clazz, matches|
+      matches << clazz.instance_method(meth) if instance_methods_for(clazz).include?(meth)
+    end
+  end
+
+  def method_lookup_path
+    module_or_regular_object? ? nonclass_lookup_path : class_lookup_path
+  end
+
+  private
+
+  def module_or_regular_object?
+    self.class == Module || !is_a?(Class)
+  end
+
+  def nonclass_lookup_path
+    self.class.ancestors.unshift(singleton_class)
+  end
+
+  def class_lookup_path
+    lookup_path = ancestors.grep(Class).map(&:singleton_class) + Class.ancestors
+    # reverse is used here since included_modules contains all modules defined in
+    # the current class as well as in its ancestors.
+    lookup_path.reverse.map do |clazz|
+      [clazz.included_modules, clazz]
+    end.flatten.uniq.reverse
+  end
+
+  def instance_methods_for(clazz)
+    clazz.instance_methods(false) + clazz.private_instance_methods(false)
+  end
+end
+
+Object.send(:include, MethodLocator)

data/lib/method_locator/version.rb

@@ -0,0 +1,3 @@
+module MethodLocator
+  VERSION = "0.0.1"
+end

data/method_locator.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "method_locator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "method_locator"
+  s.version     = MethodLocator::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ryan LeCompte"]
+  s.email       = ["lecompte@gmail.com"]
+  s.homepage    = "http://github.com/ryanlecompte/method_locator"
+  s.summary     = %q{Method Locator provides a way to traverse an object's method lookup path to find all places where a method may be defined.}
+  s.description = %q{Method Locator provides a way to traverse an object's method lookup path to find all places where a method may be defined.}
+
+  s.rubyforge_project = "method_locator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("rspec", "~> 2.5.0")
+end

data/spec/method_locator/method_locator_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+
+describe MethodLocator do
+
+  describe "#methods_for" do
+    it "returns proper methods for regular object instances" do
+      instance = B.new
+
+      def instance.foo
+      end
+
+      instance.methods_for(:foo).map(&:owner).should == [instance.singleton_class,
+                                                         B,
+                                                         M2,
+                                                         M1,
+                                                         A]
+    end
+
+    it "returns proper methods for classes" do
+      B.methods_for(:blah).map(&:owner).should == [B.singleton_class, M3, A.singleton_class]
+    end
+
+    it "returns proper methods for modules" do
+      M4.methods_for(:hello).map(&:owner).should == [M4.singleton_class]
+    end
+  end
+
+  describe "#method_lookup_path" do
+    it "returns proper path for regular object instances" do
+      instance = B.new
+      method_lookup_path_for(instance).should == [instance.singleton_class,
+                                                  B,
+                                                  M2,
+                                                  M1,
+                                                  A,
+                                                  Object,
+                                                  MethodLocator,
+                                                  Kernel,
+                                                  BasicObject]
+    end
+
+    it "returns proper path for classes" do
+      method_lookup_path_for(B).should == [B.singleton_class,
+                                           M3,
+                                           A.singleton_class,
+                                           Object.singleton_class,
+                                           BasicObject.singleton_class,
+                                           Class,
+                                           Module,
+                                           Object,
+                                           MethodLocator,
+                                           Kernel,
+                                           BasicObject]
+    end
+
+    it "returns proper path for modules" do
+      method_lookup_path_for(M2).should == [M2.singleton_class,
+                                            Module,
+                                            Object,
+                                            MethodLocator,
+                                            Kernel,
+                                            BasicObject]
+    end
+  end
+
+  def method_lookup_path_for(obj)
+    allowed_items = [obj, M1, M2, M3, M4, A, B, Class, Module, Object, MethodLocator, Kernel, BasicObject]
+    allowed_items = allowed_items + allowed_items.map(&:singleton_class)
+    obj.method_lookup_path.keep_if { |c| allowed_items.include?(c) }
+  end
+end
+
+
+module M1
+  def foo
+  end
+end
+
+module M2
+  def foo
+  end
+end
+
+module M3
+  def blah
+  end
+end
+
+module M4
+  def self.hello
+  end
+end
+
+class A
+  def foo
+  end
+
+  def self.blah
+  end
+end
+
+class B < A
+  include M1
+  include M2
+
+  def foo
+  end
+
+  def self.blah
+  end
+end
+
+B.extend(M3)

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'method_locator'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: method_locator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan LeCompte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-21 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70159058806000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *70159058806000
+description: Method Locator provides a way to traverse an object's method lookup path
+  to find all places where a method may be defined.
+email:
+- lecompte@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/method_locator.rb
+- lib/method_locator/version.rb
+- method_locator.gemspec
+- spec/method_locator/method_locator_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ryanlecompte/method_locator
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: method_locator
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Method Locator provides a way to traverse an object's method lookup path
+  to find all places where a method may be defined.
+test_files:
+- spec/method_locator/method_locator_spec.rb
+- spec/spec_helper.rb