looksee 3.0.0-universal-java-1.8

data/spec/looksee/clean_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Looksee do
+  describe ".[]" do
+    before do
+      @object = Object.new
+      Looksee.stub(default_specifiers: [:public, :overridden])
+    end
+
+    it "should return an Inspector for the object's lookup path" do
+      result = Looksee[@object]
+      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
+      Looksee[@object].visibilities.should == Set[:public, :overridden]
+    end
+
+    it "should set visibilities from the given symbols" do
+      inspector = Looksee[@object, :private]
+      inspector.visibilities.should == Set[:public, :overridden, :private]
+    end
+
+    it "should unset visibilities from the given 'no' symbols" do
+      inspector = Looksee[@object, :nooverridden]
+      inspector.visibilities.should == Set[:public]
+    end
+
+    it "should set filters from the given strings and regexp" do
+      inspector = Looksee[@object, 'aa', /bb/]
+      inspector.filters.should == Set['aa', /bb/]
+    end
+
+    it "should raise an ArgumentError if an invalid argument is given" do
+      lambda do
+        Looksee[@object, Object.new]
+      end.should raise_error(ArgumentError)
+    end
+  end
+end

data/spec/looksee/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/looksee/core_ext_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Looksee::ObjectMixin do
+  describe "#ls" do
+    before do
+      @object = Object.new
+      Looksee.stub(:default_specifiers).and_return([])
+    end
+
+    it "should return an Inspector for the object's lookup path using the given arguments" do
+      result = @object.ls(:private)
+      result.should be_a(Looksee::Inspector)
+      result.lookup_path.object.should.equal?(@object)
+      result.visibilities.should == Set[:private]
+    end
+  end
+end

data/spec/looksee/editor_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Looksee::Editor do
+  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 '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
+  end
+
+  describe "#edit" do
+    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
+      set_up_editor
+
+      file, line = *source_location
+      open(file, 'w') { |f| f.puts "class C\n  def f\n  end\nend" }
+      load file
+    end
+
+    after do
+      Object.send(:remove_const, :C)
+      FileUtils.rm_rf tmp
+    end
+
+    def set_up_editor
+      open(editor_path, 'w') { |f| f.puts <<-EOS.demargin }
+        |#!/bin/sh
+        |echo $# $1 $2 > "#{editor_output}"
+      EOS
+      File.chmod 0755, editor_path
+    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 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 raise NoSourceLocationError and not run the editor if no source location is available" do
+      Looksee.adapter.stub(source_location: nil)
+      expect { editor.edit(object, :f) }.to raise_error(Looksee::NoSourceLocationError)
+      editor_invocation.should be_nil
+    end
+  end
+end

data/spec/looksee/inspector_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe Looksee::Inspector do
+  include TemporaryClasses
+  use_test_adapter
+
+  describe "#inspect" do
+    before do
+      Looksee.stub(:default_lookup_path_options).and_return({})
+      Looksee.stub(:styles).and_return(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.stub(:default_width).and_return(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.stub(:styles).and_return(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/looksee/lookup_path_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Looksee::LookupPath do
+  include TemporaryClasses
+
+  describe "#entries" do
+    use_test_adapter
+
+    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 == false
+      @lookup_path.entries[1].overridden?('public1').should == true
+    end
+  end
+
+  describe "#find" do
+    before do
+      temporary_module(:M) { def f; end }
+      temporary_class(:C) { include M; def f; end }
+      @object = C.new
+    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 find methods in included modules" do
+      M.class_eval { def g; end }
+      lookup_path = Looksee::LookupPath.new(@object)
+      method = lookup_path.find('g')
+      method.owner.should == M
+      method.name.should == (RUBY_VERSION < "1.9.0" ? 'g' : :g)
+    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)
+      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 = C.new
+      Looksee.adapter.stub(internal_public_instance_methods: [:a, :c, :b])
+      @lookup_path = Looksee::LookupPath.new(@object)
+      @lookup_path.entries.first.map{|name, visibility| name}.should == ['a', 'b', 'c']
+    end
+  end
+end