looksee 0.2.1 → 1.0.0

data/ext/mri/1.9.2/vm_opts.h

@@ -0,0 +1,51 @@
+/*-*-c-*-*/
+/**********************************************************************
+
+  vm_opts.h - VM optimize option
+
+  $Author: akr $
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+
+#ifndef RUBY_VM_OPTS_H
+#define RUBY_VM_OPTS_H
+
+/* Compile options.
+ * You can change these options at runtime by VM::CompileOption.
+ * Following definitions are default values.
+ */
+
+#define OPT_TRACE_INSTRUCTION        1
+#define OPT_TAILCALL_OPTIMIZATION    0
+#define OPT_PEEPHOLE_OPTIMIZATION    1
+#define OPT_SPECIALISED_INSTRUCTION  1
+#define OPT_INLINE_CONST_CACHE       1
+
+
+/* Build Options.
+ * You can't change these options at runtime.
+ */
+
+/* C compiler depend */
+#define OPT_DIRECT_THREADED_CODE     1
+#define OPT_TOKEN_THREADED_CODE      0
+#define OPT_CALL_THREADED_CODE       0
+
+/* VM running option */
+#define OPT_CHECKED_RUN              1
+#define OPT_INLINE_METHOD_CACHE      1
+#define OPT_BLOCKINLINING            0
+
+/* architecture independent, affects generated code */
+#define OPT_OPERANDS_UNIFICATION     0
+#define OPT_INSTRUCTIONS_UNIFICATION 0
+#define OPT_UNIFY_ALL_COMBINATION    0
+#define OPT_STACK_CACHING            0
+
+/* misc */
+#define SUPPORT_JOKE                 0
+
+#endif /* RUBY_VM_OPTS_H */

data/ext/mri/env-1.8.h

@@ -0,0 +1,27 @@
+struct FRAME {
+  VALUE self;
+  int argc;
+  ID last_func;
+  ID orig_func;
+  VALUE last_class;
+  struct FRAME *prev;
+  struct FRAME *tmp;
+  struct RNode *node;
+  int iter;
+  int flags;
+  unsigned long uniq;
+};
+
+struct SCOPE {
+  struct RBasic super;
+  ID *local_tbl;
+  VALUE *local_vars;
+  int flags;
+};
+
+struct RVarmap {
+  struct RBasic super;
+  ID id;
+  VALUE val;
+  struct RVarmap *next;
+};

data/ext/mri/eval_c-1.8.h

@@ -0,0 +1,27 @@
+struct BLOCK {
+  NODE *var;
+  NODE *body;
+  VALUE self;
+  struct FRAME frame;
+  struct SCOPE *scope;
+  VALUE klass;
+  NODE *cref;
+  int iter;
+  int vmode;
+  int flags;
+  int uniq;
+  struct RVarmap *dyna_vars;
+  VALUE orig_thread;
+  VALUE wrapper;
+  VALUE block_obj;
+  struct BLOCK *outer;
+  struct BLOCK *prev;
+};
+
+struct METHOD {
+  VALUE klass, rklass;
+  VALUE recv;
+  ID id, oid;
+  int safe_level;
+  NODE *body;
+};

data/ext/mri/mri.c

@@ -0,0 +1,269 @@
+#include "ruby.h"
+
+#if RUBY_VERSION >= 192
+#  include "vm_core.h"
+#  include "method.h"
+#  include "ruby/st.h"
+#elif 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)));
+}
+
+#if RUBY_VERSION >= 192
+
+#  define VISIBILITY_TYPE rb_method_flag_t
+
+typedef struct add_method_if_matching_arg {
+  VALUE names;
+  VISIBILITY_TYPE visibility;
+} add_method_if_matching_arg_t;
+
+static int add_method_if_matching(ID method_name, rb_method_entry_t *me, add_method_if_matching_arg_t *arg) {
+  if (method_name == ID_ALLOCATOR)
+    return ST_CONTINUE;
+
+  if (UNDEFINED_METHOD_ENTRY_P(me))
+    return ST_CONTINUE;
+
+  if ((me->flag & NOEX_MASK) == arg->visibility)
+    rb_ary_push(arg->names, ID2SYM(method_name));
+
+  return ST_CONTINUE;
+}
+
+static int add_method_if_undefined(ID method_name, rb_method_entry_t *me, VALUE *names) {
+  if (UNDEFINED_METHOD_ENTRY_P(me))
+    rb_ary_push(*names, ID2SYM(method_name));
+  return ST_CONTINUE;
+}
+
+#else
+
+#  if RUBY_VERSION >= 190
+#    define VISIBILITY(node) ((node)->nd_body->nd_noex & NOEX_MASK)
+#  else
+#    define VISIBILITY(node) ((node)->nd_noex & NOEX_MASK)
+#  endif
+
+#  define VISIBILITY_TYPE unsigned long
+
+typedef struct add_method_if_matching_arg {
+  VALUE names;
+  VISIBILITY_TYPE visibility;
+} add_method_if_matching_arg_t;
+
+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 in ruby <= 1.8
+   *   * sets body to NULL in ruby >= 1.9
+   */
+  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 int add_method_if_undefined(ID method_name, NODE *body, VALUE *names) {
+  if (!body || !body->nd_body)
+    rb_ary_push(*names, ID2SYM(method_name));
+  return ST_CONTINUE;
+}
+
+#endif
+
+static VALUE internal_instance_methods(VALUE klass, VISIBILITY_TYPE 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);
+}
+
+/*
+ * 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;
+}
+
+VALUE Looksee_singleton_class_p(VALUE self, VALUE object) {
+  return BUILTIN_TYPE(object) == T_CLASS && FL_TEST(object, FL_SINGLETON) ? Qtrue : Qfalse;
+}
+
+VALUE Looksee_singleton_instance(VALUE self, VALUE singleton_class) {
+  if (BUILTIN_TYPE(singleton_class) == T_CLASS && FL_TEST(singleton_class, FL_SINGLETON)) {
+    VALUE object;
+    if (!st_lookup(RCLASS_IV_TBL(singleton_class), rb_intern("__attached__"), (st_data_t *)&object))
+      rb_raise(rb_eRuntimeError, "[looksee bug] can't find singleton object");
+    return object;
+  } else {
+    rb_raise(rb_eTypeError, "expected singleton class, got %s", rb_obj_classname(singleton_class));
+  }
+}
+
+VALUE Looksee_module_name(VALUE self, VALUE module) {
+  if (BUILTIN_TYPE(module) == T_CLASS || BUILTIN_TYPE(module) == T_MODULE) {
+    VALUE name = rb_mod_name(module);
+    return name == Qnil ? rb_str_new2("") : name;
+  } else {
+    rb_raise(rb_eTypeError, "expected module, got %s", rb_obj_classname(module));
+  }
+}
+
+#if RUBY_VERSION < 190
+
+#include "env-1.8.h"
+#include "eval_c-1.8.h"
+
+/*
+ * Return the source file and line number of the given object and method.
+ */
+VALUE Looksee_source_location(VALUE self, VALUE unbound_method) {
+  if (!rb_obj_is_kind_of(unbound_method, rb_cUnboundMethod))
+    rb_raise(rb_eTypeError, "expected UnboundMethod, got %s", rb_obj_classname(unbound_method));
+
+  struct METHOD *method;
+  Data_Get_Struct(unbound_method, struct METHOD, method);
+
+  NODE *node;
+  switch (nd_type(method->body)) {
+    // Can't be a FBODY or ZSUPER.
+  case NODE_SCOPE:
+    node = method->body->nd_defn;
+    break;
+  case NODE_BMETHOD:
+    {
+      struct BLOCK *block;
+      Data_Get_Struct(method->body->nd_orig, struct BLOCK, block);
+      (node = block->frame.node) || (node = block->body);
+      // Proc#to_s suggests this may be NULL sometimes.
+      if (!node)
+        return Qnil;
+    }
+    break;
+  case NODE_DMETHOD:
+    {
+      struct METHOD *original_method;
+      NODE *body = method->body;
+      Data_Get_Struct(body->nd_orig, struct METHOD, original_method);
+      node = original_method->body->nd_defn;
+    }
+    break;
+  default:
+    rb_raise(rb_eRuntimeError, "[LOOKSEE BUG] unexpected NODE type: %d", nd_type(method->body));
+  }
+  VALUE file = rb_str_new2(node->nd_file);
+  VALUE line = INT2NUM(nd_line(node));
+  VALUE location = rb_ary_new2(2);
+  rb_ary_store(location, 0, file);
+  rb_ary_store(location, 1, line);
+  return location;
+}
+
+#endif
+
+void Init_mri(void) {
+  VALUE mLooksee = rb_const_get(rb_cObject, rb_intern("Looksee"));
+  VALUE mAdapter = rb_const_get(mLooksee, rb_intern("Adapter"));
+  VALUE mBase = rb_const_get(mAdapter, rb_intern("Base"));
+  VALUE mMRI = rb_define_class_under(mAdapter, "MRI", mBase);
+  rb_define_method(mMRI, "internal_superclass", Looksee_internal_superclass, 1);
+  rb_define_method(mMRI, "internal_class", Looksee_internal_class, 1);
+  rb_define_method(mMRI, "internal_class_to_module", Looksee_internal_class_to_module, 1);
+  rb_define_method(mMRI, "internal_public_instance_methods", Looksee_internal_public_instance_methods, 1);
+  rb_define_method(mMRI, "internal_protected_instance_methods", Looksee_internal_protected_instance_methods, 1);
+  rb_define_method(mMRI, "internal_private_instance_methods", Looksee_internal_private_instance_methods, 1);
+  rb_define_method(mMRI, "internal_undefined_instance_methods", Looksee_internal_undefined_instance_methods, 1);
+  rb_define_method(mMRI, "singleton_class?", Looksee_singleton_class_p, 1);
+  rb_define_method(mMRI, "singleton_instance", Looksee_singleton_instance, 1);
+  rb_define_method(mMRI, "module_name", Looksee_module_name, 1);
+#if RUBY_VERSION < 190
+  rb_define_method(mMRI, "source_location", Looksee_source_location, 1);
+#endif
+}

data/ext/rbx/rbx.c

@@ -0,0 +1,13 @@
+#include "ruby.h"
+
+VALUE Looksee_internal_class(VALUE self, VALUE object) {
+  return CLASS_OF(object);
+}
+
+void Init_rbx(void) {
+  VALUE mLooksee = rb_const_get(rb_cObject, rb_intern("Looksee"));
+  VALUE mAdapter = rb_const_get(mLooksee, rb_intern("Adapter"));
+  VALUE mBase = rb_const_get(mAdapter, rb_intern("Base"));
+  VALUE mRubinius = rb_define_class_under(mAdapter, "Rubinius", mBase);
+  rb_define_method(mRubinius, "internal_class", Looksee_internal_class, 1);
+}

data/lib/looksee.rb

@@ -1,386 +1,5 @@
-require "rbconfig"
-require File.dirname(__FILE__) + "/../ext/looksee/looksee.#{Config::CONFIG['DLEXT']}"
-require "looksee/version"
+require 'looksee/clean'
+require 'looksee/core_ext'
 
-#
-# Looksee lets you inspect the method lookup path of an object.  There
-# are two ways to use it:
-#
-# 1. Keep all methods contained in the Looksee namespace:
-#
-#     require 'looksee'
-#
-# 2. Let it all hang out:
-#
-#     require 'looksee/shortcuts'
-#
-# The latter adds the following shortcuts to the built-in classes:
-#
-#   Object#lookup_path
-#   Object#dump_lookup_path
-#   Object#lp
-#   Object#lpi
-#
-# See their docs.
-#
-# == Usage
-#
-# In irb:
-#
-#     require 'looksee/shortcuts'
-#     lp some_object
-#
-# +lp+ returns a LookupPath object, which has +inspect+ defined to
-# print things out pretty.  By default, it shows public, protected,
-# undefined, and overridden methods.  They're all colored, which makes
-# showing overridden methods not such a strange idea.
-#
-# Some examples of the other shortcuts:
-#
-#     lpi Array
-#     some_object.lookup_path
-#     foo.bar.baz.dump_lookup_path.and.more
-#
-# If you're being namespace-clean, you'll need to do:
-#
-#     require 'looksee'
-#     Looksee.lookup_path(thing)  # like "lp thing"
-#
-# For a quick reference:
-#
-#     Looksee.help
-#
-# == Configuration
-#
-# Set these:
-#
-#     Looksee.default_lookup_path_options
-#     Looksee.default_width
-#     Looksee.styles
-#
-# See their docs.
-#
-module Looksee
-  class << self
-    #
-    # Return a collection of methods that +object+ responds to,
-    # according to the options given.  The following options are
-    # recognized:
-    #
-    # * +:public+ - include public methods
-    # * +:protected+ - include protected methods
-    # * +:private+ - include private methods
-    # * +:undefined+ - include undefined methods (see Module#undef_method)
-    # * +:overridden+ - include methods overridden by subclasses
-    #
-    # The default (if options is nil or omitted) is given by
-    # #default_lookup_path_options.
-    #
-    def lookup_path(object, *options)
-      normalized_options = Looksee.default_lookup_path_options.dup
-      hash_options = options.last.is_a?(Hash) ? options.pop : {}
-      options.each do |option|
-        normalized_options[option] = true
-      end
-      normalized_options.update(hash_options)
-      LookupPath.for(object, normalized_options)
-    end
-
-    #
-    # The default options passed to lookup_path.
-    #
-    # Default: <tt>{:public => true, :protected => true, :undefined =>
-    # true, :overridden => true}</tt>
-    #
-    attr_accessor :default_lookup_path_options
-
-    #
-    # The width to use for displaying output, when not available in
-    # the COLUMNS environment variable.
-    #
-    # Default: 80
-    #
-    attr_accessor :default_width
-
-    #
-    # The default styles to use for the +inspect+ strings.
-    #
-    # This is a hash with keys:
-    #
-    # * :module
-    # * :public
-    # * :protected
-    # * :private
-    # * :undefined
-    # * :overridden
-    #
-    # The values are format strings.  They should all contain a single
-    # "%s", which is where the name is inserted.
-    #
-    # Default:
-    #
-    #       {
-    #         :module     => "\e[1;37m%s\e[0m", # white
-    #         :public     => "\e[1;32m%s\e[0m", # green
-    #         :protected  => "\e[1;33m%s\e[0m", # yellow
-    #         :private    => "\e[1;31m%s\e[0m", # red
-    #         :undefined  => "\e[1;34m%s\e[0m", # blue
-    #         :overridden => "\e[1;30m%s\e[0m", # black
-    #       }
-    #
-    attr_accessor :styles
-
-    #
-    # Return the chain of classes and modules which comprise the
-    # object's method lookup path.
-    #
-    def lookup_modules(object)
-      modules = []
-      klass = Looksee.internal_class(object)
-      while klass
-        modules << Looksee.internal_class_to_module(klass)
-        klass = Looksee.internal_superclass(klass)
-      end
-      modules
-    end
-  end
-
-  self.default_lookup_path_options = {:public => true, :protected => true, :undefined => true, :overridden => true}
-  self.default_width = 80
-  self.styles = {
-    :module     => "\e[1;37m%s\e[0m", # white
-    :public     => "\e[1;32m%s\e[0m", # green
-    :protected  => "\e[1;33m%s\e[0m", # yellow
-    :private    => "\e[1;31m%s\e[0m", # red
-    :undefined  => "\e[1;34m%s\e[0m", # blue
-    :overridden => "\e[1;30m%s\e[0m", # black
-  }
-
-  class LookupPath
-    attr_reader :entries
-
-    def initialize(entries)
-      @entries = entries
-    end
-
-    #
-    # Create a LookupPath for the given object.
-    #
-    # Options may be given to restrict which visibilities are
-    # included.
-    #
-    #   :public
-    #   :protected
-    #   :private
-    #   :undefined
-    #   :overridden
-    #
-    def self.for(object, options={})
-      entries = entries_for(object, options)
-      new(entries)
-    end
-
-    #
-    # Return a new LookupPath which only contains names matching the
-    # given pattern.
-    #
-    def grep(pattern)
-      entries = self.entries.map do |entry|
-        entry.grep(pattern)
-      end
-      self.class.new(entries)
-    end
-
-    def inspect(options={})
-      options = normalize_inspect_options(options)
-      entries.map{|e| e.inspect(options)}.join("\n")
-    end
-
-    private  # -------------------------------------------------------
-
-    def self.entries_for(object, options)
-      seen = {}
-      Looksee.lookup_modules(object).map do |mod|
-        entry = Entry.for(mod, seen, options)
-        entry.methods.each{|m| seen[m] = true}
-        entry
-      end
-    end
-
-    def normalize_inspect_options(options)
-      options[:width] ||= ENV['COLUMNS'].to_i.nonzero? || Looksee.default_width
-      options
-    end
-
-    #
-    # An entry in the LookupPath.
-    #
-    # Contains a module and its methods, along with visibility
-    # information (public, private, etc.).
-    #
-    class Entry
-      def initialize(mod, methods=[], visibilities={})
-        @module = mod
-        @methods = methods
-        @visibilities = visibilities
-      end
-
-      def self.for(mod, seen, options)
-        entry = new(mod)
-        entry.initialize_for(seen, options)
-        entry
-      end
-
-      attr_reader :module, :methods
-
-      def initialize_for(seen, options)
-        add_methods(Looksee.internal_public_instance_methods(@module).map{|sym| sym.to_s}   , :public   , seen) if options[:public   ]
-        add_methods(Looksee.internal_protected_instance_methods(@module).map{|sym| sym.to_s}, :protected, seen) if options[:protected]
-        add_methods(Looksee.internal_private_instance_methods(@module).map{|sym| sym.to_s}  , :private  , seen) if options[:private  ]
-        add_methods(Looksee.internal_undefined_instance_methods(@module).map{|sym| sym.to_s}, :undefined, seen) if options[:undefined]
-        @methods.sort!
-      end
-
-      def grep(pattern)
-        methods = []
-        visibilities = {}
-        @methods.each do |name|
-          if name[pattern]
-            methods << name
-            visibilities[name] = @visibilities[name]
-          end
-        end
-        self.class.new(@module, methods, visibilities)
-      end
-
-      #
-      # Return the name of the class or module.
-      #
-      # Singleton classes are displayed in brackets.  Singleton class
-      # of singleton classes are displayed in double brackets.  But
-      # you'd never need that, would you?
-      #
-      def module_name
-        name = @module.to_s  # #name doesn't do singleton classes right
-        nil while name.sub!(/#<Class:(.*)>/, '[\\1]')
-        name
-      end
-
-      #
-      # Yield each method along with its visibility (:public,
-      # :private, :protected, :undefined, or :overridden).
-      #
-      def each
-        @methods.each do |name|
-          yield name, @visibilities[name]
-        end
-      end
-
-      include Enumerable
-
-      #
-      # Return a nice, pretty string for inspection.
-      #
-      # Contains the module name, plus the method names laid out in
-      # columns.  Pass a :width option to control the output width.
-      #
-      def inspect(options={})
-        string = styled_module_name << "\n" << Columnizer.columnize(styled_methods, options[:width])
-        string.chomp
-      end
-
-      private  # -----------------------------------------------------
-
-      def add_methods(methods, visibility, seen)
-        methods.each do |method|
-          @methods << method
-          @visibilities[method] = seen[method] ? :overridden : visibility
-        end
-      end
-
-      def styled_module_name
-        Looksee.styles[:module] % module_name
-      end
-
-      def styled_methods
-        map do |name, visibility|
-          Looksee.styles[visibility] % name
-        end
-      end
-    end
-  end
-
-  module Columnizer
-    class << self
-      #
-      # Arrange the given strings in columns, restricted to the given
-      # width.  Smart enough to ignore content in terminal control
-      # sequences.
-      #
-      def columnize(strings, width)
-        return '' if strings.empty?
-
-        num_columns = 1
-        layout = [strings]
-        loop do
-          break if layout.first.length <= 1
-          next_layout = layout_in_columns(strings, num_columns + 1)
-          break if layout_width(next_layout) > width
-          layout = next_layout
-          num_columns += 1
-        end
-
-        pad_strings(layout)
-        rectangularize_layout(layout)
-        layout.transpose.map do |row|
-          '  ' + row.compact.join('  ')
-        end.join("\n") << "\n"
-      end
-
-      private  # -----------------------------------------------------
-
-      def layout_in_columns(strings, num_columns)
-        strings_per_column = (strings.length / num_columns.to_f).ceil
-        (0...num_columns).map{|i| strings[i*strings_per_column...(i+1)*strings_per_column] || []}
-      end
-
-      def layout_width(layout)
-        widths = layout_column_widths(layout)
-        widths.inject(0){|sum, w| sum + w} + 2*layout.length
-      end
-
-      def layout_column_widths(layout)
-        layout.map do |column|
-          column.map{|string| display_width(string)}.max || 0
-        end
-      end
-
-      def display_width(string)
-        # remove terminal control sequences
-        string.gsub(/\e\[.*?m/, '').length
-      end
-
-      def pad_strings(layout)
-        widths = layout_column_widths(layout)
-        layout.each_with_index do |column, i|
-          column_width = widths[i]
-          column.each do |string|
-            padding = column_width - display_width(string)
-            string << ' '*padding
-          end
-        end
-      end
-
-      def rectangularize_layout(layout)
-        return if layout.length == 1
-        height = layout[0].length
-        layout[1..-1].each do |column|
-          column.length == height or
-            column[height - 1] = nil
-        end
-      end
-    end
-  end
-end
-
-require 'looksee/wirble_compatibility'
+# Ugh.
+Looksee::WirbleCompatibility.init