looksee 3.0.0-universal-java-1.8

data/ext/mri/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/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

@@ -0,0 +1,2 @@
+require 'looksee/clean'
+require 'looksee/core_ext'

data/lib/looksee/adapter.rb

@@ -0,0 +1,8 @@
+module Looksee
+  module Adapter
+    autoload :Base, 'looksee/adapter/base'
+    autoload :MRI, "looksee/mri.#{Looksee::Config::CONFIG['DLEXT']}"
+    autoload :JRuby, 'looksee/JRuby.jar'
+    autoload :Rubinius, "looksee/adapter/rubinius"
+  end
+end

data/lib/looksee/adapter/base.rb

@@ -0,0 +1,105 @@
+module Looksee
+  module Adapter
+    class Base
+      #
+      # Return the chain of classes and modules which comprise the
+      # object's method lookup path.
+      #
+      def lookup_modules(object)
+        modules = []
+        klass = internal_class(object)
+        while klass
+          modules << klass
+          klass = internal_superclass(klass)
+        end
+        modules
+      end
+
+      #
+      # Return a description of the given module.
+      #
+      # This is used for the module labels in the Inspector output.
+      #
+      def describe_module(mod)
+        num_brackets = 0
+        object = mod
+        while singleton_class?(object)
+          num_brackets += 1
+          object = singleton_instance(object)
+        end
+
+        if included_class?(mod) || object.is_a?(Module)
+          description = module_name(object)
+          if description.empty?
+            is_class = real_module(object).is_a?(Class)
+            description = "unnamed #{is_class ? 'Class' : 'Module'}"
+          end
+        else
+          description = "#{module_name(object.class)} instance"
+        end
+
+        if num_brackets == 0
+          description
+        else
+          "#{'['*num_brackets}#{description}#{']'*num_brackets}"
+        end
+      end
+
+      def real_module(module_or_included_class)
+        module_or_included_class
+      end
+
+      def internal_superclass(klass)
+        raise NotImplementedError, "abstract"
+      end
+
+      def internal_class(object)
+        raise NotImplementedError, "abstract"
+      end
+
+      def included_class?(object)
+        raise NotImplementedError, "abstract"
+      end
+
+      def internal_public_instance_methods(mod)
+        raise NotImplementedError, "abstract"
+      end
+
+      def internal_protected_instance_methods(mod)
+        raise NotImplementedError, "abstract"
+      end
+
+      def internal_private_instance_methods(mod)
+        raise NotImplementedError, "abstract"
+      end
+
+      def internal_undefined_instance_methods(mod)
+        raise NotImplementedError, "abstract"
+      end
+
+      def singleton_class?(object)
+        raise NotImplementedError, "abstract"
+      end
+
+      def singleton_instance(singleton_class)
+        raise NotImplementedError, "abstract"
+      end
+
+      def module_name(mod)
+        raise NotImplementedError, "abstract"
+      end
+
+      if RUBY_VERSION >= '1.9.0' || Looksee.ruby_engine == 'rbx'
+        def source_location(method)
+          method.is_a?(UnboundMethod) or
+            raise TypeError, "expected UnboundMethod, got #{method.class}"
+          method.source_location
+        end
+      else
+        def source_location(method)
+          raise NotImplementedError, 'abstract'
+        end
+      end
+    end
+  end
+end

data/lib/looksee/adapter/rubinius.rb

@@ -0,0 +1,84 @@
+require 'looksee/adapter/base'
+require 'looksee/rbx'
+
+module Looksee
+  module Adapter
+    class Rubinius < Base
+      def internal_superclass(klass)
+        klass.direct_superclass
+      end
+
+      def internal_public_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
+        mod.method_table.public_names
+      end
+
+      def internal_protected_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
+        mod.method_table.protected_names
+      end
+
+      def internal_private_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
+        mod.method_table.private_names
+      end
+
+      def internal_undefined_instance_methods(mod)
+        return [] if !mod.origin.equal?(mod)
+        names = []
+        mod.method_table.entries.each do |(name, method, visibility)|
+          names << name if visibility.equal?(:undef)
+        end
+        names
+      end
+
+      def included_class?(object)
+        object.is_a?(::Rubinius::IncludedModule)
+      end
+
+      def singleton_class?(object)
+        object.is_a?(Class) && !!::Rubinius::Type.singleton_class_object(object)
+      end
+
+      def singleton_instance(singleton_class)
+        singleton_class?(singleton_class) or
+          raise TypeError, "expected singleton class, got #{singleton_class.class}"
+        ::Rubinius::Type.singleton_class_object(singleton_class)
+      end
+
+      def module_name(mod)
+        mod.is_a?(Module) or
+          raise TypeError, "expected module, got #{mod.class}"
+
+        if ::Rubinius::IncludedModule === mod
+          if Class === mod.module
+            "#{module_name(mod.module)} (origin)"
+          else
+            module_name(mod.module)
+          end
+        elsif ::Rubinius::Type.respond_to?(:module_name)
+          ::Rubinius::Type.module_name(mod) || ''
+        else
+          mod.__name__
+        end
+      end
+
+      def source_location(method)
+        method.is_a?(UnboundMethod) or
+          raise TypeError, "expected UnboundMethod, got #{method.class}"
+        source_location = method.source_location and
+          return source_location
+
+        # #source_location doesn't always work. If it returns nil, try
+        # a little harder.
+        case (executable = method.executable)
+        when ::Rubinius::BlockEnvironment::AsMethod
+          method = executable.instance_variable_get(:@block_env).method
+          [method.file.to_s, method.lines[1]]
+        when ::Rubinius::DelegatedMethod
+          executable.instance_variable_get(:@receiver).source_location
+        end
+      end
+    end
+  end
+end

data/lib/looksee/clean.rb

@@ -0,0 +1,169 @@
+require "rbconfig"
+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'
+  autoload :Editor, 'looksee/editor'
+  autoload :Help, 'looksee/help'
+  autoload :Inspector, 'looksee/inspector'
+  autoload :LookupPath, 'looksee/lookup_path'
+  autoload :WirbleCompatibility, 'looksee/wirble_compatibility'
+
+  class << self
+    #
+    # The default options passed to #ls.
+    #
+    # Default: <tt>[:public, :protected, :private, :undefined,
+    # :overridden]</tt>
+    #
+    attr_accessor :default_specifiers
+
+    #
+    # 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
+
+    #
+    # The editor command, used for Object#edit.
+    #
+    # This string should contain a "%f", which is replaced with the
+    # file name, and/or "%l" which is replaced with the line number. A
+    # "%%" is replaced with "%".
+    #
+    # If the LOOKSEE_EDITOR environment variable is set, it is used as
+    # the default. Otherwise, we use the following heuristic:
+    #
+    # If EDITOR is set, we use that. If it looks like vi, emacs, or
+    # textmate, we also append options to position the cursor on the
+    # appropriate line. If EDITOR is not set, we use "vi +%l %f".
+    #
+    attr_accessor :editor
+
+    #
+    # The interpreter adapter.
+    #
+    # Encapsulates the interpreter-specific functionality.
+    #
+    attr_accessor :adapter
+
+    #
+    # Wrapper around RUBY_ENGINE that's always defined.
+    #
+    attr_accessor :ruby_engine
+
+    #
+    # Return a Looksee::Inspector for the given +object+.
+    #
+    # +args+ is an optional list of specifiers.
+    #
+    #   * +:public+ - include public methods
+    #   * +:protected+ - include public methods
+    #   * +:private+ - include public methods
+    #   * +:undefined+ - include public methods (see Module#undef_method)
+    #   * +:overridden+ - include public methods
+    #   * +:nopublic+ - include public methods
+    #   * +:noprotected+ - include public methods
+    #   * +:noprivate+ - include public methods
+    #   * +:noundefined+ - include public methods (see Module#undef_method)
+    #   * +:nooverridden+ - include public methods
+    #   * a string - only include methods containing this string (may
+    #     be used multiple times)
+    #   * a regexp - only include methods matching this regexp (may
+    #     be used multiple times)
+    #
+    # The default (if options is nil or omitted) is given by
+    # #default_lookup_path_options.
+    #
+    def [](object, *args)
+      options = {:visibilities => Set[], :filters => Set[]}
+      (Looksee.default_specifiers + args).each do |arg|
+        case arg
+        when String, Regexp
+          options[:filters] << arg
+        when :public, :protected, :private, :undefined, :overridden
+          options[:visibilities].add(arg)
+        when :nopublic, :noprotected, :noprivate, :noundefined, :nooverridden
+          visibility = arg.to_s.sub(/\Ano/, '').to_sym
+          options[:visibilities].delete(visibility)
+        else
+          raise ArgumentError, "invalid specifier: #{arg.inspect}"
+        end
+      end
+      lookup_path = LookupPath.new(object)
+      Inspector.new(lookup_path, options)
+    end
+
+    #
+    # Show a quick reference.
+    #
+    def help
+      Help.new
+    end
+  end
+
+  self.default_specifiers = [:public, :protected, :private, :undefined, :overridden]
+  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
+  }
+  self.editor = ENV['LOOKSEE_EDITOR'] || ENV['EDITOR'] || 'vi'
+
+  if Object.const_defined?(:RUBY_ENGINE)
+    self.ruby_engine = RUBY_ENGINE
+  else
+    self.ruby_engine = 'ruby'
+  end
+
+  case ruby_engine
+  when 'jruby'
+    self.adapter = Adapter::JRuby.new
+  when 'rbx'
+    self.adapter = Adapter::Rubinius.new
+  else
+    self.adapter = Adapter::MRI.new
+  end
+end

data/lib/looksee/columnizer.rb

@@ -0,0 +1,73 @@
+module Looksee
+  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