looksee 1.1.0 → 2.0.0

data/ext/mri/2.1.0/method.h

@@ -0,0 +1,142 @@
+/**********************************************************************
+
+  method.h -
+
+  $Author: tmm1 $
+  created at: Wed Jul 15 20:02:33 2009
+
+  Copyright (C) 2009 Koichi Sasada
+
+**********************************************************************/
+#ifndef METHOD_H
+#define METHOD_H
+
+#include "internal.h"
+
+#ifndef END_OF_ENUMERATION
+# if defined(__GNUC__) &&! defined(__STRICT_ANSI__)
+#   define END_OF_ENUMERATION(key)
+# else
+#   define END_OF_ENUMERATION(key) END_OF_##key##_PLACEHOLDER = 0
+# endif
+#endif
+
+typedef enum {
+    NOEX_PUBLIC    = 0x00,
+    NOEX_NOSUPER   = 0x01,
+    NOEX_PRIVATE   = 0x02,
+    NOEX_PROTECTED = 0x04,
+    NOEX_MASK      = 0x06,
+    NOEX_BASIC     = 0x08,
+    NOEX_UNDEF     = NOEX_NOSUPER,
+    NOEX_MODFUNC   = 0x12,
+    NOEX_SUPER     = 0x20,
+    NOEX_VCALL     = 0x40,
+    NOEX_RESPONDS  = 0x80,
+
+    NOEX_BIT_WIDTH = 8,
+    NOEX_SAFE_SHIFT_OFFSET = ((NOEX_BIT_WIDTH+3)/4)*4 /* round up to nibble */
+} rb_method_flag_t;
+
+#define NOEX_SAFE(n) ((int)((n) >> NOEX_SAFE_SHIFT_OFFSET) & 0x0F)
+#define NOEX_WITH(n, s) (((s) << NOEX_SAFE_SHIFT_OFFSET) | (n) | (ruby_running ? 0 : NOEX_BASIC))
+#define NOEX_WITH_SAFE(n) NOEX_WITH((n), rb_safe_level())
+
+/* method data type */
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,
+    VM_METHOD_TYPE_CFUNC,
+    VM_METHOD_TYPE_ATTRSET,
+    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING,   /* wrapper for method_missing(id) */
+    VM_METHOD_TYPE_REFINED,
+
+    END_OF_ENUMERATION(VM_METHOD_TYPE)
+} rb_method_type_t;
+
+struct rb_call_info_struct;
+
+typedef struct rb_method_cfunc_struct {
+    VALUE (*func)(ANYARGS);
+    VALUE (*invoker)(VALUE (*func)(ANYARGS), VALUE recv, int argc, const VALUE *argv);
+    int argc;
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    const VALUE location;
+} rb_method_attr_t;
+
+typedef struct rb_iseq_struct rb_iseq_t;
+
+typedef struct rb_method_definition_struct {
+    rb_method_type_t type; /* method type */
+    ID original_id;
+    union {
+	rb_iseq_t * const iseq;            /* should be mark */
+	rb_method_cfunc_t cfunc;
+	rb_method_attr_t attr;
+	const VALUE proc;                 /* should be mark */
+	enum method_optimized_type {
+	    OPTIMIZED_METHOD_TYPE_SEND,
+	    OPTIMIZED_METHOD_TYPE_CALL,
+
+	    OPTIMIZED_METHOD_TYPE__MAX
+	} optimize_type;
+	struct rb_method_entry_struct *orig_me;
+    } body;
+    int alias_count;
+} rb_method_definition_t;
+
+typedef struct rb_method_entry_struct {
+    rb_method_flag_t flag;
+    char mark;
+    rb_method_definition_t *def;
+    ID called_id;
+    VALUE klass;                    /* should be mark */
+} rb_method_entry_t;
+
+struct unlinked_method_entry_list_entry {
+    struct unlinked_method_entry_list_entry *next;
+    rb_method_entry_t *me;
+};
+
+#define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
+
+void rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_method_flag_t noex);
+rb_method_entry_t *rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *option, rb_method_flag_t noex);
+rb_method_entry_t *rb_method_entry(VALUE klass, ID id, VALUE *define_class_ptr);
+rb_method_entry_t *rb_method_entry_at(VALUE obj, ID id);
+void rb_add_refined_method_entry(VALUE refined_class, ID mid);
+rb_method_entry_t *rb_resolve_refined_method(VALUE refinements,
+					     const rb_method_entry_t *me,
+					     VALUE *defined_class_ptr);
+rb_method_entry_t *rb_method_entry_with_refinements(VALUE klass, ID id,
+						    VALUE *defined_class_ptr);
+rb_method_entry_t *rb_method_entry_without_refinements(VALUE klass, ID id,
+						       VALUE *defined_class_ptr);
+
+rb_method_entry_t *rb_method_entry_get_without_cache(VALUE klass, ID id, VALUE *define_class_ptr);
+rb_method_entry_t *rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *, rb_method_flag_t noex);
+
+int rb_method_entry_arity(const rb_method_entry_t *me);
+int rb_method_entry_eq(const rb_method_entry_t *m1, const rb_method_entry_t *m2);
+st_index_t rb_hash_method_entry(st_index_t hash, const rb_method_entry_t *me);
+
+VALUE rb_method_entry_location(rb_method_entry_t *me);
+VALUE rb_mod_method_location(VALUE mod, ID id);
+VALUE rb_obj_method_location(VALUE obj, ID id);
+
+void rb_mark_method_entry(const rb_method_entry_t *me);
+void rb_free_method_entry(rb_method_entry_t *me);
+void rb_sweep_method_entry(void *vm);
+void rb_free_m_tbl(st_table *tbl);
+void rb_free_m_tbl_wrapper(struct method_table_wrapper *wrapper);
+
+#endif /* METHOD_H */

data/lib/looksee/clean.rb

@@ -4,6 +4,10 @@ require 'set'
 module Looksee
   Config = Object.const_defined?(:RbConfig) ? ::RbConfig : ::Config
 
+  NoMethodError = Class.new(RuntimeError)
+  NoSourceLocationError = Class.new(RuntimeError)
+  NoSourceFileError = Class.new(RuntimeError)
+
   autoload :VERSION, 'looksee/version'
   autoload :Adapter, 'looksee/adapter'
   autoload :Columnizer, 'looksee/columnizer'

data/lib/looksee/core_ext.rb

@@ -42,38 +42,31 @@ module Looksee
       Inspector.new(lookup_path, options)
     end
 
-    #
-    # Open an editor at the named method's definition.
-    #
-    # Uses Looksee.editor to determine the editor command to run.
-    #
-    # Only works for methods for which file and line numbers are
-    # accessible.
-    #
-    def edit(name)
-      Editor.new(Looksee.editor).edit(self, name)
-    end
-
-    def self.rename(renamings)  # :nodoc:
-      renamings.each do |old_name, new_name|
-        alias_method new_name, old_name
-        remove_method old_name
-      end
+    def self.rename(name)  # :nodoc:
+      name = name[:ls] if name.is_a?(Hash)
+      alias_method name, :ls
+      remove_method :ls
     end
   end
 
   #
-  # Rename the methods added to every object. Example:
+  # Rename the #ls method, added to every object. Example:
+  #
+  #     rename :_ls
+  #
+  # This renames Looksee's #ls method to #_ls.
   #
-  #     rename :ls => :_ls, :edit => :_edit
+  # For backward compatibility, the old-style invocation is also
+  # supported. Please note this is deprecated.
   #
-  def self.rename(renamings)
-    ObjectMixin.rename(renamings)
+  #     rename :ls => :_ls
+  #
+  def self.rename(name)
+    ObjectMixin.rename(name)
   end
 
-  (ENV['LOOKSEE_METHODS'] || '').scan(/([\w_]+)=([\w_]+)/) do
-    rename $1.to_sym => $2.to_sym
-  end
+  name = ENV['LOOKSEE_METHOD'] and
+    rename name
 
   Object.send :include, ObjectMixin
 end

data/lib/looksee/editor.rb

@@ -14,9 +14,15 @@ module Looksee
     #
     def edit(object, method_name)
       method = LookupPath.new(object).find(method_name.to_s) or
-        return
+        raise NoMethodError, "no method `#{method_name}' in lookup path of #{object.class} instance"
       file, line = Looksee.adapter.source_location(method)
-      run(file, line) unless line.nil?
+      if !file
+        raise NoSourceLocationError, "no source location for #{method.owner}##{method.name}"
+      elsif !File.exist?(file)
+        raise NoSourceFileError, "cannot find source file: #{file}"
+      else
+        run(file, line)
+      end
     end
 
     #

data/lib/looksee/help.rb

@@ -40,7 +40,7 @@ module Looksee
         |          ...
         |        }
         |
-        |  object.edit(method)
+        |  object.ls.edit(method)
         |
         |    Jump to the source of the given method. Set your editor
         |    with Looksee.editor or the LOOKSEE_EDITOR environment

data/lib/looksee/inspector.rb

@@ -11,12 +11,27 @@ module Looksee
     attr_reader :visibilities
     attr_reader :filters
 
+    #
+    # Print the method lookup path of self. See the README for details.
+    #
     def inspect
       lookup_path.entries.reverse.map do |entry|
         inspect_entry(entry)
       end.join("\n")
     end
 
+    #
+    # Open an editor at the named method's definition.
+    #
+    # Uses Looksee.editor to determine the editor command to run.
+    #
+    # Only works for methods for which file and line numbers are
+    # accessible.
+    #
+    def edit(name)
+      Editor.new(Looksee.editor).edit(lookup_path.object, name)
+    end
+
     private
 
     def inspect_entry(entry)

data/lib/looksee/version.rb

@@ -1,5 +1,5 @@
 module Looksee
-  VERSION = [1, 1, 0]
+  VERSION = [2, 0, 0]
 
   class << VERSION
     include Comparable

data/spec/adapter_spec.rb

@@ -95,33 +95,33 @@ describe "Looksee.adapter" do
     def self.it_should_list_methods_with_visibility(visibility)
       it "should return the list of #{visibility} instance methods defined directly on a class" do
         temporary_class :C
-        replace_methods C, visibility => [:one, :two]
+        add_methods C, visibility => [:one, :two]
         @adapter.send(target_method, C).to_set.should == Set[:one, :two]
       end
 
       it "should return the list of #{visibility} instance methods defined directly on a module" do
         temporary_module :M
-        replace_methods M, visibility => [:one, :two]
+        add_methods M, visibility => [:one, :two]
         @adapter.send(target_method, M).to_set.should == Set[:one, :two]
       end
 
       it "should return the list of #{visibility} instance methods defined directly on a singleton class" do
         temporary_class :C
         c = C.new
-        replace_methods c.singleton_class, visibility => [:one, :two]
+        add_methods c.singleton_class, visibility => [:one, :two]
         @adapter.send(target_method, c.singleton_class).to_set.should == Set[:one, :two]
       end
 
       it "should return the list of #{visibility} instance methods defined directly on a class' singleton class" do
         temporary_class :C
-        replace_methods C.singleton_class, visibility => [:one, :two], :class_singleton => true
+        add_methods C.singleton_class, visibility => [:one, :two], :class_singleton => true
         @adapter.send(target_method, C.singleton_class).to_set.should == Set[:one, :two]
       end
 
       # Worth checking as ruby keeps undef'd methods in method tables.
       it "should not return undefined methods" do
         temporary_class :C
-        replace_methods C, visibility => [:removed]
+        add_methods C, visibility => [:removed]
         C.send(:undef_method, :removed)
         @adapter.send(target_method, C).to_set.should == Set[]
       end
@@ -130,7 +130,7 @@ describe "Looksee.adapter" do
     def self.it_should_not_list_methods_with_visibility(visibility1, visibility2)
       it "should not return any #{visibility1} or #{visibility2} instance methods" do
         temporary_class :C
-        replace_methods C, {visibility1 => [:a], visibility2 => [:b]}
+        add_methods C, {visibility1 => [:a], visibility2 => [:b]}
         @adapter.send(target_method, C).to_set.should == Set[]
       end
     end

data/spec/editor_spec.rb

@@ -1,128 +1,110 @@
 require 'spec_helper'
 
 describe Looksee::Editor do
-  def editor_command(command)
-    Looksee::Editor.new(command).command_for('FILE', 'LINE')
-  end
+  describe "#command_for" do
+    def editor_command(command)
+      Looksee::Editor.new(command).command_for('FILE', 'LINE')
+    end
 
-  it "should infer the file and line arguments for 'vi'" do
-    editor_command('vi').should == ['vi', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'vi'" do
+      editor_command('vi').should == ['vi', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'vim'" do
-    editor_command('vim').should == ['vim', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'vim'" do
+      editor_command('vim').should == ['vim', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'gvim'" do
-    editor_command('gvim').should == ['gvim', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'gvim'" do
+      editor_command('gvim').should == ['gvim', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'emacs'" do
-    editor_command('emacs').should == ['emacs', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'emacs'" do
+      editor_command('emacs').should == ['emacs', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'xemacs'" do
-    editor_command('xemacs').should == ['xemacs', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'xemacs'" do
+      editor_command('xemacs').should == ['xemacs', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'aquamacs'" do
-    editor_command('aquamacs').should == ['aquamacs', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'aquamacs'" do
+      editor_command('aquamacs').should == ['aquamacs', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'pico'" do
-    editor_command('pico').should == ['pico', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'pico'" do
+      editor_command('pico').should == ['pico', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'nano'" do
-    editor_command('nano').should == ['nano', '+LINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'nano'" do
+      editor_command('nano').should == ['nano', '+LINE', 'FILE']
+    end
 
-  it "should infer the file and line arguments for 'mate'" do
-    editor_command('mate').should == ['mate', '-lLINE', 'FILE']
-  end
+    it "should infer the file and line arguments for 'mate'" do
+      editor_command('mate').should == ['mate', '-lLINE', 'FILE']
+    end
 
-  it "should support escaped '%'-signs" do
-    editor_command('%% %f %l').should == ['%', 'FILE', 'LINE']
-  end
+    it "should support escaped '%'-signs" do
+      editor_command('%% %f %l').should == ['%', 'FILE', 'LINE']
+    end
 
-  it "should not infer file and line arguments for unknown editors" do
-    editor_command('wtfbbq').should == ['wtfbbq']
+    it "should not infer file and line arguments for unknown editors" do
+      editor_command('wtfbbq').should == ['wtfbbq']
+    end
   end
 
   describe "#edit" do
-    TMP = "#{ROOT}/spec/tmp"
+    let(:tmp) { "#{ROOT}/spec/tmp" }
+    let(:editor_path) { "#{tmp}/edit" }
+    let(:editor_output) { "#{tmp}/edit.out" }
+    let(:editor) { Looksee::Editor.new("#{editor_path} %f %l") }
+    let(:editor_invocation) { File.exist?(editor_output) ? File.read(editor_output) : nil }
+    let(:source_location) { ["#{tmp}/c.rb", 2] }
+    let(:object) { C.new }
 
     before do
-      FileUtils.mkdir_p TMP
-      make_editor "#{TMP}/edit"
-      @editor = Looksee::Editor.new("#{TMP}/edit %f %l")
+      FileUtils.mkdir_p tmp
+      set_up_editor
+
+      file, line = *source_location
+      FileUtils.touch file
+      Object.const_set(:C, Class.new { def f; end })
+      Looksee.adapter.set_methods(C, [:f], [], [], [])
+      Looksee.adapter.set_source_location(C, :f, source_location)
+      Looksee.adapter.ancestors[object] = [C, Object]
     end
 
     after do
-      FileUtils.rm_rf TMP
+      Object.send(:remove_const, :C)
+      FileUtils.rm_rf tmp
     end
 
-    def make_editor(path)
-      open(path, 'w') { |f| f.puts <<-EOS.demargin }
+    def set_up_editor
+      open(editor_path, 'w') { |f| f.puts <<-EOS.demargin }
         |#!/bin/sh
-        |echo $# $1 $2 > "#{TMP}/editor.out"
+        |echo $# $1 $2 > "#{editor_output}"
       EOS
-      File.chmod 0755, path
+      File.chmod 0755, editor_path
     end
 
-    def with_source_file
-      path = "#{TMP}/c.rb"
-      open(path, 'w') { |f| f.puts <<-EOS.demargin }
-        |class C
-        |  def f
-        |  end
-        |end
-      EOS
-      begin
-        load path
-        Looksee.adapter.set_methods(C, [:f], [], [], [])
-        yield path
-      ensure
-        Object.send(:remove_const, :C)
-      end
+    it "should run the editor on the method's source location if available" do
+      editor.edit(object, :f)
+      editor_invocation.should == "2 #{source_location.join(' ')}\n"
     end
 
-    it "should run the editor on the method's source location if available" do
-      with_source_file do |path|
-        c = C.new
-        Looksee.adapter.ancestors[c] = [C, Object]
-        Looksee.adapter.set_source_location(C, :f, [path, 2])
-        @editor.edit(c, :f)
-        File.read("#{TMP}/editor.out").should == "2 #{path} 2\n"
-      end
-    end
-
-    it "should not run the editor if the source file does not exist" do
-      with_source_file do |path|
-        FileUtils.rm_f path
-        @editor.edit(C.new, :f)
-        File.should_not exist("#{TMP}/editor.out")
-      end
-    end
-
-    it "should not run the editor for methods defined with eval where no source file specified" do
-      eval <<-EOS.demargin
-        |class ::C
-        |  def f
-        |  end
-        |end
-      EOS
-      begin
-        @editor.edit(C.new, :f)
-        File.should_not exist("#{TMP}/editor.out")
-      ensure
-        Object.send(:remove_const, :C)
-      end
+    it "should raise NoMethodError and not run the editor if the method does not exist" do
+      expect { editor.edit(object, :x) }.to raise_error(Looksee::NoMethodError)
+      editor_invocation.should be_nil
+    end
+
+    it "should raise NoSourceFileError and not run the editor if the source file does not exist" do
+      FileUtils.rm_f source_location.first
+      expect { editor.edit(object, :f) }.to raise_error(Looksee::NoSourceFileError)
+      editor_invocation.should be_nil
     end
 
-    it "should not run the editor for primitives" do
-      @editor.edit('', :size)
-      File.should_not exist("#{TMP}/editor.out")
+    it "should raise NoSourceLocationError and not run the editor if no source location is available" do
+      Looksee.adapter.set_source_location(C, :f, nil)
+      expect { editor.edit(object, :f) }.to raise_error(Looksee::NoSourceLocationError)
+      editor_invocation.should be_nil
     end
   end
 end