methodfinder 1.2.0 → 1.2.1

data/README.markdown

@@ -38,6 +38,22 @@ Inside `find_method`'s block, the receiver is available as block
 argument and the special method `unknown` is used as a placeholder for
 the desired method.
 
+#### Blacklists
+
+You can exclude methods from being tried by editing the hashes
+`MethodFinder::INSTANCE_METHOD_BLACKLIST` and
+`MethodFinder::CLASS_METHOD_BLACKLIST`. Both use the class/module
+as key and an array of method names as values (note that class, module
+and method names have to be symbols).
+
+For example, to blacklist the instance method `shutdown` of `Object`,
+you would do
+
+    MethodFinder::INSTANCE_METHOD_BLACKLIST[:Object] << :shutdown
+
+This might come in handy when using `MethodFinder` together with other
+gems as such as `interactive_editor`.
+
 ### MethodFinder.find\_classes\_and_modules
 
 A simple method to return all currently defined modules and classes.
@@ -76,11 +92,6 @@ I initially wrote this for the students of the core Ruby course on
 to me (not saying it doesn't work there, just that I test in plain
 IRB, not with `script/console`).  
 
-Todo
----
-
-* a method black list (maybe)
-
 Thanks
 ---
 
@@ -88,6 +99,7 @@ Thanks
 * Ryan Bates for
 [suggesting](https://github.com/citizen428/methodfinder/issues/closed#issue/3)
 what eventually became `Object#find_method`.
+* Jan Lelis for [implementing blacklists](https://github.com/citizen428/methodfinder/issues/closed#issue/4).
 
 License
 ---

data/lib/methodfinder.rb

@@ -2,60 +2,75 @@ require 'stringio'
 
 class Object
   def find_method(*args, &block)
-    self.methods.sort.map(&:intern).select do |met|
+    MethodFinder.methods_to_try(self).select do |met|
       self.class.class_eval %{ alias :unknown #{met} }
-      obj = self.dup rescue self
-      yield obj rescue nil
+        obj = self.dup rescue self
+        yield obj rescue nil
+      end
     end
   end
-end
-
-class MethodFinder
-  ARGS = {
-    :cycle => [1] # prevent cycling forever
-  }
-
-  class << self
-    def find(obj, res, *args, &block)
-      redirect_streams
-
-      obj.methods.sort.map(&:intern).select do |met|
-        o = obj.dup rescue obj
-        m = o.method(met)
-        if m.arity <= args.size
-          a = args.empty? && ARGS.has_key?(met) ? ARGS[met] : args
-          m.call(*a, &block) == res rescue nil
+
+  class MethodFinder
+    ARGS = {
+      :cycle => [1] # prevent cycling forever
+    }
+
+    # Blacklisting methods, e.g. { :Object => [:ri, :vim] }
+    INSTANCE_METHOD_BLACKLIST = Hash.new { |h, k| h[k] = [] }
+    CLASS_METHOD_BLACKLIST = Hash.new { |h, k| h[k] = [] }
+
+    class << self
+      def find(obj, res, *args, &block)
+        redirect_streams
+
+        methods_to_try(obj).select do |met|
+          o = obj.dup rescue obj
+          m = o.method(met)
+          if m.arity <= args.size
+            a = args.empty? && ARGS.has_key?(met) ? ARGS[met] : args
+            m.call(*a, &block) == res rescue nil
+          end
         end
+      ensure
+        restore_streams
       end
-    ensure
-      restore_streams
-    end
 
-    def find_classes_and_modules
-      constants = Object.constants.sort.map { |c| Object.const_get(c) }
-      constants.select { |c| c.class == Class || c.class == Module}
-    end
+      # Added by Jan Lelis
+      def methods_to_try(obj)
+        ret = obj.methods.map(&:intern)
+        blacklist = obj.is_a?(Module) ? CLASS_METHOD_BLACKLIST : INSTANCE_METHOD_BLACKLIST
+        klass = obj.is_a?(Module) ? obj : obj.class
 
-    def find_in_class_or_module(c, pattern=/./)
-      cs = Object.const_get(c.to_s)
-      class_methods = cs.methods(false) rescue []
-      instance_methods = cs.instance_methods(false)
-      all_methods = class_methods + instance_methods
-      all_methods.grep(/#{pattern}/).sort
-    end
+        klass.ancestors.each { |ancestor| ret -= blacklist[ancestor.to_s.intern] }
 
-    def redirect_streams
-      @orig_stdout = $stdout
-      @orig_stderr = $stderr
-      $stdout = StringIO.new
-      $stderr = StringIO.new
-    end
+        ret.sort
+      end
+
+      def find_classes_and_modules
+        constants = Object.constants.sort.map { |c| Object.const_get(c) }
+        constants.select { |c| c.class == Class || c.class == Module}
+      end
+
+      def find_in_class_or_module(c, pattern=/./)
+        cs = Object.const_get(c.to_s)
+        class_methods = cs.methods(false) rescue []
+        instance_methods = cs.instance_methods(false)
+        all_methods = class_methods + instance_methods
+        all_methods.grep(/#{pattern}/).sort
+      end
+
+      def redirect_streams
+        @orig_stdout = $stdout
+        @orig_stderr = $stderr
+        $stdout = StringIO.new
+        $stderr = StringIO.new
+      end
 
-    def restore_streams
-      $stdout = @orig_stdout
-      $stderr = @orig_stderr
+      def restore_streams
+        $stdout = @orig_stdout
+        $stderr = @orig_stderr
+      end
     end
+    private_class_method :redirect_streams, :restore_streams
   end
-  private_class_method :redirect_streams, :restore_streams
-end
 

metadata

@@ -2,7 +2,7 @@
 name: methodfinder
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors: 
 - Michael Kohl
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-09 00:00:00 +02:00
+date: 2011-04-16 00:00:00 +02:00
 default_executable: 
 dependencies: []