looksee 1.0.0-universal-java-1.6

data/spec/columnizer_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Looksee::Columnizer do
+  describe ".columnize" do
+    def columnize(strings, width)
+      Looksee::Columnizer.columnize(strings, width)
+    end
+
+    it "should an empty string if there are no strings to display" do
+      columnize([], 5).should == ''
+    end
+
+    it "should render all strings on one line separated and indented by two spaces if they fit" do
+      columnize(['one', 'two'], 10).should == "  one  two\n"
+    end
+
+    it "should not wrap a string if it longer than the width" do
+      columnize(['looooooong'], 5).should == "  looooooong\n"
+    end
+
+    it "should render a string on the next line if there's not enough room" do
+      columnize(['a', 'looooooong'], 5).should == "  a         \n  looooooong\n"
+    end
+
+    it "should present 12 3-char strings 4 per line, sorted vertically, when the width is 20" do
+      strings = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff',
+        'ggg', 'hhh', 'iii', 'jjj', 'kkk', 'lll']
+      columnize(strings, 20).should == <<-EOS.gsub(/^ *\|/, '')
+        |  aaa  ddd  ggg  jjj
+        |  bbb  eee  hhh  kkk
+        |  ccc  fff  iii  lll
+      EOS
+    end
+
+    it "should leave the last column short if there aren't enough strings to fill it" do
+      strings = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff',
+        'ggg', 'hhh', 'iii', 'jjj', 'kkk']
+      columnize(strings, 20).should == <<-EOS.gsub(/^ *\|/, '')
+        |  aaa  ddd  ggg  jjj
+        |  bbb  eee  hhh  kkk
+        |  ccc  fff  iii
+      EOS
+    end
+
+    it "should pad out strings that are shorter than their column" do
+      columnize(['aa', 'b', 'c', 'dd'], 8).should == <<-EOS.gsub(/^ *\|/, '')
+        |  aa  c 
+        |  b   dd
+      EOS
+    end
+  end
+end

data/spec/core_ext_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Looksee::ObjectMixin do
+  describe "#ls" do
+    before do
+      @object = Object.new
+      Looksee.stubs(:default_specifiers).returns([:public, :overridden])
+    end
+
+    it "should return an Inspector for the object's lookup path" do
+      result = @object.ls
+      result.should be_a(Looksee::Inspector)
+      result.lookup_path.object.should.equal?(@object)
+    end
+
+    it "should use Looksee.default_specifiers if no args are given" do
+      @object.ls.visibilities.should == Set[:public, :overridden]
+    end
+
+    it "should set visibilities from the given symbols" do
+      inspector = @object.ls(:private)
+      inspector.visibilities.should == Set[:public, :overridden, :private]
+    end
+
+    it "should unset visibilities from the given 'no' symbols" do
+      inspector = @object.ls(:nooverridden)
+      inspector.visibilities.should == Set[:public]
+    end
+
+    it "should set filters from the given strings and regexp" do
+      inspector = @object.ls('aa', /bb/)
+      inspector.filters.should == Set['aa', /bb/]
+    end
+
+    it "should raise an ArgumentError if an invalid argument is given" do
+      lambda do
+        @object.ls(Object.new)
+      end.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/editor_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Looksee::Editor 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 '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 '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 '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 '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 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']
+  end
+
+  describe "#edit" do
+    TMP = "#{ROOT}/spec/tmp"
+
+    before do
+      FileUtils.mkdir_p TMP
+      make_editor "#{TMP}/edit"
+      @editor = Looksee::Editor.new("#{TMP}/edit %f %l")
+    end
+
+    after do
+      FileUtils.rm_rf TMP
+    end
+
+    def make_editor(path)
+      open(path, 'w') { |f| f.puts <<-EOS.demargin }
+        |#!/bin/sh
+        |echo $# $1 $2 > "#{TMP}/editor.out"
+      EOS
+      File.chmod 0755, 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
+    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
+    end
+
+    it "should not run the editor for primitives" do
+      @editor.edit('', :size)
+      File.should_not exist("#{TMP}/editor.out")
+    end
+  end
+end

data/spec/inspector_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Looksee::Inspector do
+  include TemporaryClasses
+
+  describe "#inspect" do
+    before do
+      Looksee.stubs(:default_lookup_path_options).returns({})
+      Looksee.stubs(:styles).returns(Hash.new{'%s'})
+
+      @object = Object.new
+      temporary_module :M
+      temporary_class(:C) { include M }
+      Looksee.adapter.ancestors[@object] = [C, M]
+    end
+
+    describe "output width" do
+      before do
+        Looksee.adapter.public_methods[C] = ['aa', 'bb', 'cc', 'dd', 'ee', 'ff', 'gg', 'hh', 'ii', 'jj']
+        Looksee.adapter.public_methods[M] = ['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg', 'hhh']
+        @lookup_path = Looksee::LookupPath.new(@object)
+      end
+
+      it "should columnize output to the given width, if any" do
+        inspector = Looksee::Inspector.new(@lookup_path, :visibilities => [:public], :width => 20)
+        inspector.inspect.should == <<-EOS.demargin.chomp
+          |M
+          |  aaa  ccc  eee  ggg
+          |  bbb  ddd  fff  hhh
+          |C
+          |  aa  cc  ee  gg  ii
+          |  bb  dd  ff  hh  jj
+        EOS
+      end
+
+      it "should columnize output to the current terminal width, if detectable" do
+        original_columns = ENV['COLUMNS']
+        ENV['COLUMNS'] = '20'
+        begin
+          inspector = Looksee::Inspector.new(@lookup_path, :visibilities => [:public])
+          inspector.inspect.should == <<-EOS.demargin.chomp
+            |M
+            |  aaa  ccc  eee  ggg
+            |  bbb  ddd  fff  hhh
+            |C
+            |  aa  cc  ee  gg  ii
+            |  bb  dd  ff  hh  jj
+          EOS
+        ensure
+          ENV['COLUMNS'] = original_columns
+        end
+      end
+
+      it "should columnize output to the configured default otherwise" do
+        Looksee.stubs(:default_width).returns(20)
+        inspector = Looksee::Inspector.new(@lookup_path, :visibilities => [:public])
+        inspector.inspect.should == <<-EOS.demargin.chomp
+          |M
+          |  aaa  ccc  eee  ggg
+          |  bbb  ddd  fff  hhh
+          |C
+          |  aa  cc  ee  gg  ii
+          |  bb  dd  ff  hh  jj
+        EOS
+      end
+    end
+
+    it "should not show any blank lines if a module has no methods" do
+      Looksee.adapter.public_methods[M] = [:public1, :public2]
+      lookup_path = Looksee::LookupPath.new(@object)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |M
+        |  public1  public2
+        |C
+      EOS
+    end
+
+    it "should show singleton classes as class names in brackets" do
+      Looksee.adapter.ancestors[C] = [C.singleton_class]
+      Looksee.adapter.public_methods[C.singleton_class] = [:public1, :public2]
+      lookup_path = Looksee::LookupPath.new(C)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |[C]
+        |  public1  public2
+      EOS
+    end
+
+    it "should handle singleton classes of singleton classes correctly" do
+      Looksee.adapter.ancestors[C.singleton_class] = [C.singleton_class.singleton_class]
+      Looksee.adapter.public_methods[C.singleton_class.singleton_class] = [:public1, :public2]
+      lookup_path = Looksee::LookupPath.new(C.singleton_class)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |[[C]]
+        |  public1  public2
+      EOS
+    end
+
+    it "should only show methods of the selected visibilities" do
+      temporary_class :E
+      Looksee.adapter.set_methods(E, [:public], [:protected], [:private], [:undefined])
+      Looksee.adapter.ancestors[@object] = [E]
+      lookup_path = Looksee::LookupPath.new(@object)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:protected])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |E
+        |  protected
+      EOS
+    end
+
+    it "should show overridden methods if selected" do
+      Looksee.adapter.set_methods(C, [:public], [:protected], [:private], [:undefined])
+      Looksee.adapter.set_methods(M, [:public], [:protected], [:private], [:undefined])
+      lookup_path = Looksee::LookupPath.new(@object)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :overridden])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |M
+        |  public
+        |C
+        |  public
+      EOS
+    end
+
+    it "should not show overridden methods if not selected" do
+      Looksee.adapter.set_methods(C, [:public], [:protected], [:private], [:undefined])
+      Looksee.adapter.set_methods(M, [:public], [:protected], [:private], [:undefined])
+      lookup_path = Looksee::LookupPath.new(@object)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :nooverridden])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |M
+        |C
+        |  public
+      EOS
+    end
+
+    it "should only show methods that match the given filters, if any are given" do
+      Looksee.adapter.public_methods[C] = [:ab, :ax, :ba, :xa]
+      Looksee.adapter.public_methods[M] = [:ab, :ax, :ba, :xa]
+      lookup_path = Looksee::LookupPath.new(@object)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :overridden], :filters => [/^a/, 'b'])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |M
+        |  ab  ax  ba
+        |C
+        |  ab  ax  ba
+      EOS
+    end
+  end
+
+  describe ".styles" do
+    before do
+      styles = {
+        :module     => "`%s'",
+        :public     => "{%s}",
+        :protected  => "[%s]",
+        :private    => "<%s>",
+        :undefined  => "~%s~",
+        :overridden => "(%s)",
+      }
+      Looksee.stubs(:styles).returns(styles)
+    end
+
+    it "should delimit each word with the configured delimiters" do
+      temporary_class :C
+      c = C.new
+      Looksee.adapter.ancestors[c] = [C]
+      Looksee.adapter.set_methods(C, [:public], [:protected], [:private], [:undefined])
+      lookup_path = Looksee::LookupPath.new(c)
+      inspector = Looksee::Inspector.new(lookup_path, :visibilities => [:public, :protected, :private, :undefined, :overridden])
+      inspector.inspect.should == <<-EOS.demargin.chomp
+        |\`C\'
+        |  <private>  [protected]  {public}  ~undefined~
+      EOS
+    end
+  end
+end

data/spec/lookup_path_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Looksee::LookupPath do
+  include TemporaryClasses
+
+  describe "#entries" do
+    before do
+      temporary_module :M
+      temporary_class(:C) { include M }
+      @object = Object.new
+      Looksee.adapter.ancestors[@object] = [C, M]
+      Looksee.adapter.set_methods(M, [:public1, :public2], [:protected1, :protected2], [:private1, :private2], [:undefined1, :undefined2])
+      Looksee.adapter.set_methods(C, [:public1, :public2], [:protected1, :protected2], [:private1, :private2], [:undefined1, :undefined2])
+      @lookup_path = Looksee::LookupPath.new(@object)
+    end
+
+    it "should contain an entry for each module in the object's lookup path" do
+      @lookup_path.entries.map{|entry| entry.module}.should == [C, M]
+    end
+
+    it "should include methods of all visibilities, including overridden ones" do
+      @lookup_path.entries[0].methods.should == {
+        'public1'    => :public   , 'public2'    => :public,
+        'protected1' => :protected, 'protected2' => :protected,
+        'private1'   => :private  , 'private2'   => :private,
+        'undefined1' => :undefined, 'undefined2' => :undefined,
+      }
+      @lookup_path.entries[1].methods.should == {
+        'public1'    => :public   , 'public2'    => :public,
+        'protected1' => :protected, 'protected2' => :protected,
+        'private1'   => :private  , 'private2'   => :private,
+        'undefined1' => :undefined, 'undefined2' => :undefined,
+      }
+    end
+
+    it "should know which methods have been overridden" do
+      @lookup_path.entries[0].overridden?('public1').should be_false
+      @lookup_path.entries[1].overridden?('public1').should be_true
+    end
+  end
+
+  describe "#find" do
+    before do
+      temporary_module(:M) { def f; end }
+      temporary_class(:C) { include M; def f; end }
+      @object = Object.new
+      Looksee.adapter.ancestors[@object] = [C, M]
+      Looksee.adapter.set_methods(M, [:f], [], [], [])
+      Looksee.adapter.set_methods(C, [:f], [], [], [])
+    end
+
+    it "should return the unoverridden UnboundMethod for the given method name" do
+      lookup_path = Looksee::LookupPath.new(@object)
+      method = lookup_path.find('f')
+      method.owner.should == C
+      method.name.should == (RUBY_VERSION < "1.9.0" ? 'f' : :f)
+    end
+
+    it "should return nil if the method does not exist" do
+      lookup_path = Looksee::LookupPath.new(@object)
+      lookup_path.find('g').should be_nil
+    end
+
+    it "should return nil if the method has been undefined" do
+      C.send(:undef_method, :f)
+      Looksee.adapter.public_methods[C].delete(:f)
+      Looksee.adapter.undefined_methods[C] << :f
+      lookup_path = Looksee::LookupPath.new(@object)
+      lookup_path.find('f').should be_nil
+    end
+  end
+
+  describe Looksee::LookupPath::Entry do
+    it "should iterate over methods in alphabetical order" do
+      temporary_class(:C)
+      @object = Object.new
+      Looksee.adapter.public_methods[C] = [:a, :c, :b]
+      Looksee.adapter.ancestors[@object] = [C]
+      @lookup_path = Looksee::LookupPath.new(@object)
+      @lookup_path.entries.size.should == 1
+      @lookup_path.entries.first.map{|name, visibility| name}.should == ['a', 'b', 'c']
+    end
+  end
+end