BMorearty-looksee 0.1.1

data/.autotest

@@ -0,0 +1,9 @@
+Autotest.add_hook :initialize do |at|
+  at.add_mapping(/ext\/.*\/(.*)\.[ch]/) do |_, m|
+        ["test/test_#{m[1]}_extn.rb"]
+      end
+end
+
+Autotest.add_hook :run_command do |at|
+  system "rake compile"
+end

data/History.txt

@@ -0,0 +1,18 @@
+== 0.1.1 2009-08-27
+
+* Add colors method and lc shortcut.
+
+== 0.1.0 2009-08-20
+
+* Add methods undefined with Module#undef_method.  Blue by default.
+
+== 0.0.2 2009-07-28
+
+* Added #grep to filter methods shown: lp(object).grep(/pattern/)
+* Fix #1: Play nice with Wirble.
+* Fix #3: Don't die when examining immediate objects (fixnum, symbol,
+  true, false, nil)
+
+== 0.0.1 2009-07-05
+
+* Hi.

data/Manifest.txt

@@ -0,0 +1,21 @@
+.autotest
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+ext/looksee/extconf.rb
+ext/looksee/looksee.c
+ext/looksee/node-1.9.h
+lib/looksee.rb
+lib/looksee/shortcuts.rb
+lib/looksee/version.rb
+lib/looksee/wirble_compatibility.rb
+looksee.gemspec
+script/console
+script/destroy
+script/generate
+spec/looksee_spec.rb
+spec/spec_helper.rb
+spec/wirble_compatibility_spec.rb
+tasks/extconf.rake
+tasks/extconf/looksee.rake

data/README.rdoc

@@ -0,0 +1,129 @@
+= Looksee
+
+* http://github.com/oggy/looksee
+
+== DESCRIPTION
+
+Looksee lets you examine the method lookup path of objects in ways not
+possible in plain ruby.
+
+== SYNOPSIS
+
+Pop this in your .irbrc :
+
+    require 'looksee/shortcuts'
+
+This defines a method +lp+ ("lookup path") which lets you do:
+
+    irb(main):001:0> lp []
+    => Array
+      &            concat      frozen?      push          taguri
+      *            count       hash         rassoc        taguri=
+      +            cycle       include?     reject        take
+      -            delete      index        reject!       take_while
+      <<           delete_at   indexes      replace       to_a
+      <=>          delete_if   indices      reverse       to_ary
+      ==           drop        insert       reverse!      to_s
+      []           drop_while  inspect      reverse_each  to_yaml
+      []=          each        join         rindex        transpose
+      assoc        each_index  last         select        uniq
+      at           empty?      length       shift         uniq!
+      choice       eql?        map          shuffle       unshift
+      clear        fetch       map!         shuffle!      values_at
+      collect      fill        nitems       size          yaml_initialize
+      collect!     find_index  pack         slice         zip
+      combination  first       permutation  slice!        |
+      compact      flatten     pop          sort
+      compact!     flatten!    product      sort!
+    Enumerable
+      all?        each_slice       first     min        reverse_each
+      any?        each_with_index  grep      min_by     select
+      collect     entries          group_by  minmax     sort
+      count       enum_cons        include?  minmax_by  sort_by
+      cycle       enum_slice       inject    none?      take
+      detect      enum_with_index  map       one?       take_while
+      drop        find             max       partition  to_a
+      drop_while  find_all         max_by    reduce     zip
+      each_cons   find_index       member?   reject
+    Object
+      taguri  taguri=  to_yaml  to_yaml_properties  to_yaml_style
+    Kernel
+      ==        hash                        object_id
+      ===       id                          private_methods
+      =~        inspect                     protected_methods
+      __id__    instance_eval               public_methods
+      __send__  instance_exec               respond_to?
+      class     instance_of?                send
+      clone     instance_variable_defined?  singleton_methods
+      display   instance_variable_get       taint
+      dup       instance_variable_set       tainted?
+      enum_for  instance_variables          tap
+      eql?      is_a?                       to_a
+      equal?    kind_of?                    to_enum
+      extend    method                      to_s
+      freeze    methods                     type
+      frozen?   nil?                        untaint
+
+It'll also color the methods according to whether they're public,
+protected, private, undefined (using Module#undef_method), or
+overridden.  So pretty.  You gotta try it.  The default colors are:
+
+    public:     green
+    protected:  yellow
+    private:    red
+    undefined:  blue
+    overridden: black
+
+To remind yourself what each looksee color means in irb:
+
+    lc
+
+By default, it shows public and protected methods.  Add private ones
+like so:
+
+    lp [], :private => true
+    lp [], :private          # shortcut
+
+Or if you don't want protected:
+
+    lp [], :protected => false
+
+There are variations too.  And you can configure things.  And you can
+use it as a library without polluting the built-in classes.  See:
+
+    $ ri Looksee
+
+Enjoy!
+
+== INSTALL
+
+  gem install looksee
+
+== FEATURES/PROBLEMS
+
+* Currently only does MRI 1.8, 1.9.
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2009 George Ogata
+
+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/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+
+require './lib/looksee/version'
+
+Hoe.plugin :newgem
+Hoe.plugin :email  # from seattlerb - configure via ~/.hoerc
+
+$hoe = Hoe.spec 'looksee' do
+  self.developer 'George Ogata', 'george.ogata@gmail.com'
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+  self.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"],
+    ['rspec', '>= 1.2.7'],
+    ['mocha', '>= 0.9.5'],
+  ]
+end
+
+# Configure the clean and clobber tasks.
+require 'rake/clean'
+require 'rbconfig'
+CLEAN.include('**/*.o')
+CLOBBER.include("ext/looksee/looksee.#{Config::CONFIG['DLEXT']}")
+
+require 'newgem/tasks' # loads /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+desc "Rebuild the gem from scratch."
+task :regem => [:clobber, :gem]
+
+# Force build before running specs.
+Rake::Task['spec'].prerequisites << 'extconf:compile'
+
+task :default => :spec

data/ext/looksee/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+$CPPFLAGS << " -DRUBY_VERSION=#{RUBY_VERSION.tr('.', '')}"
+dir_config("looksee")
+
+create_makefile("looksee")

data/ext/looksee/looksee.c

@@ -0,0 +1,144 @@
+#include "ruby.h"
+
+#if RUBY_VERSION >= 190
+#  include "node-1.9.h"
+#  include "ruby/st.h"
+#else
+#  include "node.h"
+#  include "st.h"
+#endif
+
+#if RUBY_VERSION < 187
+#  define RCLASS_IV_TBL(c) (RCLASS(c)->iv_tbl)
+#  define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+#  define RCLASS_SUPER(c) (RCLASS(c)->super)
+#endif
+
+/*
+ * Return the internal superclass of this class.
+ *
+ * This is either a Class or "IClass."  IClasses represent Modules
+ * included in the ancestry, and should be treated as opaque objects
+ * in ruby space. Convert the IClass to a Module using #iclass_to_module
+ * before using it in ruby.
+ */
+VALUE Looksee_internal_superclass(VALUE self, VALUE internal_class) {
+  VALUE super = RCLASS_SUPER(internal_class);
+  if (!super)
+    return Qnil;
+  return super;
+}
+
+/*
+ * Return the internal class of the given object.
+ *
+ * This is either the object's singleton class, if it exists, or the
+ * object's birth class.
+ */
+VALUE Looksee_internal_class(VALUE self, VALUE object) {
+  return CLASS_OF(object);
+}
+
+/*
+ * Return the class or module that the given internal class
+ * represents.
+ *
+ * If a class is given, this is the class.  If an iclass is given,
+ * this is the module it represents in the lookup chain.
+ */
+VALUE Looksee_internal_class_to_module(VALUE self, VALUE internal_class) {
+  if (!SPECIAL_CONST_P(internal_class)) {
+    switch (BUILTIN_TYPE(internal_class)) {
+    case T_ICLASS:
+      return RBASIC(internal_class)->klass;
+    case T_CLASS:
+      return internal_class;
+    }
+  }
+  rb_raise(rb_eArgError, "not an internal class: %s", RSTRING_PTR(rb_inspect(internal_class)));
+}
+
+typedef struct add_method_if_matching_arg {
+  VALUE names;
+  int visibility;
+} add_method_if_matching_arg_t;
+
+#if RUBY_VERSION < 190
+#  define VISIBILITY(node) ((node)->nd_noex & NOEX_MASK)
+#else
+#  define VISIBILITY(node) ((node)->nd_body->nd_noex & NOEX_MASK)
+#endif
+
+static int add_method_if_matching(ID method_name, NODE *body, add_method_if_matching_arg_t *arg) {
+  /* This entry is for the internal allocator function. */
+  if (method_name == ID_ALLOCATOR)
+    return ST_CONTINUE;
+
+  /* Module#undef_method sets body->nd_body to NULL. */
+  if (!body || !body->nd_body)
+    return ST_CONTINUE;
+
+  if (VISIBILITY(body) == arg->visibility)
+    rb_ary_push(arg->names, ID2SYM(method_name));
+  return ST_CONTINUE;
+}
+
+static VALUE internal_instance_methods(VALUE klass, long visibility) {
+  add_method_if_matching_arg_t arg;
+  arg.names = rb_ary_new();
+  arg.visibility = visibility;
+  st_foreach(RCLASS_M_TBL(klass), add_method_if_matching, (st_data_t)&arg);
+  return arg.names;
+}
+
+/*
+ * Return the list of public instance methods (as Symbols) of the
+ * given internal class.
+ */
+VALUE Looksee_internal_public_instance_methods(VALUE self, VALUE klass) {
+  return internal_instance_methods(klass, NOEX_PUBLIC);
+}
+
+/*
+ * Return the list of protected instance methods (as Symbols) of the
+ * given internal class.
+ */
+VALUE Looksee_internal_protected_instance_methods(VALUE self, VALUE klass) {
+  return internal_instance_methods(klass, NOEX_PROTECTED);
+}
+
+/*
+ * Return the list of private instance methods (as Symbols) of the
+ * given internal class.
+ */
+VALUE Looksee_internal_private_instance_methods(VALUE self, VALUE klass) {
+  return internal_instance_methods(klass, NOEX_PRIVATE);
+}
+
+static int add_method_if_undefined(ID method_name, NODE *body, VALUE *names) {
+  /* Module#undef_method sets body->nd_body to NULL. */
+  if (body && !body->nd_body)
+    rb_ary_push(*names, ID2SYM(method_name));
+  return ST_CONTINUE;
+}
+
+/*
+ * Return the list of undefined instance methods (as Symbols) of the
+ * given internal class.
+ */
+VALUE Looksee_internal_undefined_instance_methods(VALUE self, VALUE klass) {
+  VALUE names = rb_ary_new();
+  st_foreach(RCLASS_M_TBL(klass), add_method_if_undefined, (st_data_t)&names);
+  return names;
+}
+
+void Init_looksee(void) {
+  VALUE mLooksee = rb_define_module("Looksee");
+  rb_define_singleton_method(mLooksee, "internal_superclass", Looksee_internal_superclass, 1);
+  rb_define_singleton_method(mLooksee, "internal_class", Looksee_internal_class, 1);
+  rb_define_singleton_method(mLooksee, "internal_class_to_module", Looksee_internal_class_to_module, 1);
+  rb_define_singleton_method(mLooksee, "internal_public_instance_methods", Looksee_internal_public_instance_methods, 1);
+  rb_define_singleton_method(mLooksee, "internal_protected_instance_methods", Looksee_internal_protected_instance_methods, 1);
+  rb_define_singleton_method(mLooksee, "internal_private_instance_methods", Looksee_internal_private_instance_methods, 1);
+  rb_define_singleton_method(mLooksee, "internal_undefined_instance_methods", Looksee_internal_undefined_instance_methods, 1);
+}

data/ext/looksee/node-1.9.h

@@ -0,0 +1,35 @@
+/* MRI 1.9 does not install node.h.  This is the part we need. */
+
+typedef struct RNode {
+    unsigned long flags;
+    char *nd_file;
+    union {
+	struct RNode *node;
+	ID id;
+	VALUE value;
+	VALUE (*cfunc)(ANYARGS);
+	ID *tbl;
+    } u1;
+    union {
+	struct RNode *node;
+	ID id;
+	long argc;
+	VALUE value;
+    } u2;
+    union {
+	struct RNode *node;
+	ID id;
+	long state;
+	struct global_entry *entry;
+	long cnt;
+	VALUE value;
+    } u3;
+} NODE;
+
+#define nd_body  u2.node
+#define nd_noex  u3.id
+
+#define NOEX_PUBLIC    0x00
+#define NOEX_PRIVATE   0x02
+#define NOEX_PROTECTED 0x04
+#define NOEX_MASK      0x06

data/lib/looksee/shortcuts.rb

@@ -0,0 +1,63 @@
+=begin
+
+Include this to pollute the standard ruby modules with handy aliases.
+Perfect for your .irbrc, or for punching into your program to work out
+what that +flazbot+ variable can do.
+
+=end
+
+require 'looksee'
+
+class Object
+  private  # ---------------------------------------------------------
+
+  #
+  # Alias for Looksee.lookup_path.
+  #
+  # (Added by Looksee.)
+  #
+  def lp(*args)
+    Looksee.lookup_path(*args)
+  end
+
+  #
+  # Run Looksee.lookup_path on an instance of the given class.
+  #
+  # (Added by Looksee.)
+  #
+  def lpi(klass, *args)
+    Looksee.lookup_path(klass.allocate, *args)
+  end
+
+  #
+  # Run Looksee.colors to return the current color mappings.
+  #
+  # (Added by Looksee.)
+  #
+  def lc
+    Looksee.colors
+  end
+
+  public  # ----------------------------------------------------------
+
+  #
+  # Call Looksee.lookup_path on this object.
+  #
+  # (Added by Looksee.)
+  #
+  def lookup_path(*args)
+    Looksee.lookup_path(self, *args)
+  end
+
+  #
+  # Dump the lookup path to standard output, and return self.
+  #
+  # Good for stuffing in a call chain.
+  #
+  # (Added by Looksee.)
+  #
+  def dump_lookup_path(*args)
+    p lookup_path(*args)
+    self
+  end
+end

data/lib/looksee/version.rb

@@ -0,0 +1,3 @@
+module Looksee
+  VERSION = '0.1.0'
+end

data/lib/looksee/wirble_compatibility.rb

@@ -0,0 +1,86 @@
+module Looksee
+  module WirbleCompatibility
+    class << self
+      def wirble_loaded?
+        Object.const_defined?(:Wirble) &&
+          Wirble.is_a?(Module) &&
+          Wirble.respond_to?(:colorize)
+      end
+
+      def wirble_colorizing?
+        IRB::Irb.method_defined?(:non_color_output_value)
+      end
+
+      def hook_into_wirble_load
+        unless Object.const_defined?(:Wirble)
+          Object.const_set :Wirble, Module.new
+        end
+        Wirble.send :extend, WirbleLoadHook
+      end
+
+      def hook_into_wirble_colorize
+        class << Wirble
+          def colorize_with_looksee(*args)
+            # If this gets called twice, Wirble will fuck up the
+            # aliases.  Disable colorizing first to reset them.
+            if WirbleCompatibility.hooked_into_irb_output_value?
+              Wirble::Colorize.disable
+            end
+            colorize_without_looksee(*args)
+            WirbleCompatibility.hook_into_irb_output_value
+          end
+
+          alias colorize_without_looksee colorize
+          alias colorize colorize_with_looksee
+        end
+      end
+
+      def hook_into_irb_output_value
+        IRB::Irb.class_eval do
+          def output_value_with_looksee
+            if @context.last_value.is_a?(Looksee::LookupPath)
+              non_color_output_value
+            else
+              output_value_without_looksee
+            end
+          end
+
+          alias output_value_without_looksee output_value
+          alias output_value output_value_with_looksee
+        end
+      end
+
+      def hooked_into_irb_output_value?
+        IRB::Irb.method_defined?(:output_value_with_looksee)
+      end
+
+      def init
+        #
+        # How wirble is used:
+        #
+        #  * Wirble is required/loaded.  Defines Wirble module, with methods like Wirble.colorize.
+        #  * Wirble.init is called.  Nothing interesting.
+        #  * Wirble.colorize is called.  Hooks into IRB::Irb.output_value via an alias.
+        #
+        if !wirble_loaded?
+          hook_into_wirble_load
+        elsif !wirble_colorizing?
+          hook_into_wirble_colorize
+        else
+          hook_into_irb_output_value
+        end
+      end
+    end
+
+    module WirbleLoadHook
+      def singleton_method_added(name)
+        if name == :colorize && !respond_to?(:colorize_with_looksee)
+          WirbleCompatibility.hook_into_wirble_colorize
+        end
+        super
+      end
+    end
+  end
+end
+
+Looksee::WirbleCompatibility.init