pry 0.9.10pre1-i386-mingw32 → 0.9.11-i386-mingw32

data/spec/fixtures/example_nesting.rb

@@ -0,0 +1,33 @@
+                                    # []
+class A                             # ["class A"]
+  def a; end                        # ["class A"]
+  class B; def b; end; end          # ["class A", "class B"]
+end                                 # []
+                                    # []
+class << A                          # ["class << A"]
+  class B                           # ["class << A", "class B"]
+    def c; end                      # ["class << A", "class B"]
+  end                               # ["class << A"]
+                                    # ["class << A"]
+  module F::B                       # ["class << A", "module F::B"]
+    def foo; end                    # ["class << A", "module F::B"]
+  end                               # ["class << A"]
+end                                 # []
+                                    # []
+module (:symbol.class)::Exciting    #
+  def foo; end                      #
+  class B                           #
+    def goo; end                    #
+  end                               #
+end                                 # []
+                                    # []
+module C                            # ["module C"]
+  class D                           # ["module C", "class D"]
+    def guh; foo.end; end           # ["module C", "class D"]
+  end                               # ["module C"]
+  def bar; :end; end                # ["module C"]
+  class << new.bar; end             # ["module C"]
+  class << new.bar; def f; end; end #
+                                    # ["module C"]
+  class << self; def mug; end; end  # ["module C", "class << self"]
+end                                 # []

data/spec/fixtures/show_source_doc_examples.rb

@@ -0,0 +1,15 @@
+# used by test_show_source.rb and test_documentation.rb
+class TestClassForShowSource
+  def alpha
+  end
+end
+
+class TestClassForShowSourceClassEval
+  def alpha
+  end
+end
+
+class TestClassForShowSourceInstanceEval
+  def alpha
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,34 @@
+unless Object.const_defined? 'Pry'
+  $:.unshift File.expand_path '../../lib', __FILE__
+  require 'pry'
+end
+
+require 'mocha/api'
+
+require 'pry/test/helper'
+require 'helpers/bacon'
+require 'helpers/mock_pry'
+
+class Module
+  public :remove_const
+  public :remove_method
+end
+
+# turn warnings off (esp for Pry::Hooks which will generate warnings
+# in tests)
+$VERBOSE = nil
+
+Pad = OpenStruct.new
+def Pad.clear
+  @table = {}
+end
+
+# to help with tracking down bugs that cause an infinite loop in the test suite
+if ENV["SET_TRACE_FUNC"]
+  require 'set_trace' if Pry::Helpers::BaseHelpers.rbx?
+  set_trace_func proc { |event, file, line, id, binding, classname|
+     STDERR.printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
+  }
+end
+
+puts "Ruby v#{RUBY_VERSION} (#{defined?(RUBY_ENGINE) ? RUBY_ENGINE : "ruby"}), Pry v#{Pry::VERSION}, method_source v#{MethodSource::VERSION}, CodeRay v#{CodeRay::VERSION}, Slop v#{Slop::VERSION}"

data/spec/helpers/bacon.rb

@@ -0,0 +1,86 @@
+# Colorize output (based on greeneggs (c) 2009 Michael Fleet)
+# TODO: Make own gem (assigned to rking)
+module Bacon
+  class Context
+    include PryTestHelpers
+  end
+
+  COLORS    = {'F' => 31, 'E' => 35, 'M' => 33, '.' => 32}
+  USE_COLOR = !(ENV['NO_PRY_COLORED_BACON'] == 'true') && Pry::Helpers::BaseHelpers.use_ansi_codes?
+
+  module TestUnitOutput
+    def handle_requirement(description)
+      error = yield
+
+      if error.empty?
+        print colorize_string('.')
+      else
+        print colorize_string(error[0..0])
+      end
+    end
+
+    def handle_summary
+      puts
+      puts ErrorLog if Backtraces
+
+      out = "%d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+
+      if Counter.values_at(:failed, :errors).inject(:+) > 0
+        puts colorize_string(out, 'F')
+      else
+        puts colorize_string(out, '.')
+      end
+    end
+
+    def colorize_string(text, color = nil)
+      if USE_COLOR
+        "\e[#{ COLORS[color || text] }m#{ text }\e[0m"
+      else
+        text
+      end
+    end
+  end
+end
+
+# Reset top-level binding at the beginning of each test case.
+module Bacon
+  class Context
+    def it_with_reset_binding(description, &block)
+      Pry.toplevel_binding = nil
+      it_without_reset_binding(description, &block)
+    end
+    alias it_without_reset_binding it
+    alias it it_with_reset_binding
+  end
+end
+
+# Support mocha
+# mocha-on-bacon (c) Copyright (C) 2011, Eloy Durán <eloy.de.enige@gmail.com>
+module Bacon
+  module MochaRequirementsCounter
+    def self.increment
+      Counter[:requirements] += 1
+    end
+  end
+
+  class Context
+    include Mocha::API
+
+    def it_with_mocha(description, &block)
+      it_without_mocha(description) do
+        begin
+          mocha_setup
+          block.call
+          mocha_verify(MochaRequirementsCounter)
+        rescue Mocha::ExpectationError => e
+          raise Error.new(:failed, e.message)
+        ensure
+          mocha_teardown
+        end
+      end
+    end
+    alias it_without_mocha it
+    alias it it_with_mocha
+  end
+end

data/spec/helpers/mock_pry.rb

@@ -0,0 +1,43 @@
+def mock_pry(*args)
+  args.flatten!
+  binding = args.first.is_a?(Binding) ? args.shift : binding()
+
+  input = InputTester.new(*args)
+  output = StringIO.new
+
+  redirect_pry_io(input, output) do
+    binding.pry
+  end
+
+  output.string
+end
+
+# Set I/O streams. Out defaults to an anonymous StringIO.
+def redirect_pry_io(new_in, new_out = StringIO.new)
+  old_in = Pry.input
+  old_out = Pry.output
+
+  Pry.input = new_in
+  Pry.output = new_out
+  begin
+    yield
+  ensure
+    Pry.input = old_in
+    Pry.output = old_out
+  end
+end
+
+class InputTester
+  def initialize(*actions)
+    @orig_actions = actions.dup
+    @actions = actions
+  end
+
+  def readline(*)
+    @actions.shift
+  end
+
+  def rewind
+    @actions = @orig_actions.dup
+  end
+end

data/spec/helpers/table_spec.rb

@@ -0,0 +1,83 @@
+require 'helper'
+
+describe 'Formatting Table' do
+  it 'knows about colorized fitting' do
+    t = Pry::Helpers::Table.new %w(hihi), :column_count => 1
+    t.fits_on_line?(4).should == true
+    t.items = []
+    t.fits_on_line?(4).should == true
+
+    t.items = %w(hi hi)
+    t.fits_on_line?(4).should == true
+    t.column_count = 2
+    t.fits_on_line?(4).should == false
+
+    t.items = %w(
+      a   ccc
+      bb  dddd
+    ).sort
+    t.fits_on_line?(8).should == true
+    t.fits_on_line?(7).should == false
+  end
+
+  describe 'formatting - should order downward and wrap to columns' do
+    FAKE_COLUMNS = 62
+    def try_round_trip(expected)
+      things = expected.split(/\s+/).sort
+      actual = Pry::Helpers.tablify(things, FAKE_COLUMNS).to_s.strip
+      [expected, actual].each{|e| e.gsub! /\s+$/, ''}
+      if actual != expected
+        bar = '-'*25
+        puts \
+          bar+'expected'+bar,
+          expected,
+          bar+'actual'+bar,
+          actual
+      end
+      actual.should == expected
+    end
+
+    it 'should handle a tiny case' do
+      try_round_trip(<<-eot)
+asdf  asfddd  fdass
+      eot
+    end
+
+    it 'should handle the basic case' do
+      try_round_trip(<<-eot)
+aadd            ddasffssdad  sdsaadaasd      ssfasaafssd
+adassdfffaasds  f            sdsfasddasfds   ssssdaa
+assfsafsfsds    fsasa        ssdsssafsdasdf
+      eot
+    end
+
+    it 'should handle... another basic case' do
+      try_round_trip(<<-EOT)
+aaad            dasaasffaasf    fdasfdfss       safdfdddsasd
+aaadfasassdfff  ddadadassasdf   fddsasadfssdss  sasf
+aaddaafaf       dddasaaaaaa     fdsasad         sddsa
+aas             dfsddffdddsdfd  ff              sddsfsaa
+adasadfaaffds   dsfafdsfdfssda  ffadsfafsaafa   ss
+asddaadaaadfdd  dssdss          ffssfsfafaadss  ssas
+asdsdaa         faadf           fsddfff         ssdfssff
+asfadsssaaad    fasfaafdssd     s
+      EOT
+    end
+
+    it 'should handle colors' do
+      try_round_trip(<<-EOT)
+\e[31maaaaaaaaaa\e[0m                      \e[31mccccccccccccccccccccccccccccc\e[0m
+\e[31mbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\e[0m  \e[31mddddddddddddd\e[0m
+      EOT
+    end
+
+    it 'should handle empty input' do
+      try_round_trip('')
+    end
+
+    it 'should handle one-token input' do
+      try_round_trip('asdf')
+    end
+  end
+
+end

data/{test/test_history_array.rb → spec/history_array_spec.rb}

@@ -3,6 +3,7 @@ require 'helper'
 describe Pry::HistoryArray do
   before do
     @array = Pry::HistoryArray.new 10
+    @populated = @array.dup << 1 << 2 << 3 << 4
   end
 
   it 'should have a maximum size specifed at creation time' do
@@ -10,49 +11,40 @@ describe Pry::HistoryArray do
   end
 
   it 'should be able to be added objects to' do
-    @array << 1 << 2 << 3
-    @array.size.should == 3
-    @array.to_a.should == [1, 2, 3]
+    @populated.size.should == 4
+    @populated.to_a.should == [1, 2, 3, 4]
   end
 
   it 'should be able to access single elements' do
-    @array << 1 << 2 << 3
-    @array[2].should == 3
+    @populated[2].should == 3
   end
 
   it 'should be able to access negative indices' do
-    @array << 1 << 2 << 3
-    @array[-1].should == 3
+    @populated[-1].should == 4
   end
 
   it 'should be able to access ranges' do
-    @array << 1 << 2 << 3 << 4
-    @array[1..2].should == [2, 3]
+    @populated[1..2].should == [2, 3]
   end
 
   it 'should be able to access ranges starting from a negative index' do
-    @array << 1 << 2 << 3 << 4
-    @array[-2..3].should == [3, 4]
+    @populated[-2..3].should == [3, 4]
   end
 
   it 'should be able to access ranges ending at a negative index' do
-    @array << 1 << 2 << 3 << 4
-    @array[2..-1].should == [3, 4]
+    @populated[2..-1].should == [3, 4]
   end
 
   it 'should be able to access ranges using only negative indices' do
-    @array << 1 << 2 << 3 << 4
-    @array[-2..-1].should == [3, 4]
+    @populated[-2..-1].should == [3, 4]
   end
 
   it 'should be able to use range where end is excluded' do
-    @array << 1 << 2 << 3 << 4
-    @array[-2...-1].should == [3]
+    @populated[-2...-1].should == [3]
   end
 
   it 'should be able to access slices using a size' do
-    @array << 1 << 2 << 3 << 4
-    @array[-3, 2].should == [2, 3]
+    @populated[-3, 2].should == [2, 3]
   end
 
   it 'should remove older entries' do
@@ -62,4 +54,14 @@ describe Pry::HistoryArray do
     @array[1].should  == 1
     @array[10].should == 10
   end
+
+  it 'should not be larger than specified maximum size' do
+    12.times { |n| @array << n }
+    @array.entries.compact.size.should == 10
+  end
+
+  it 'should pop!' do
+    @populated.pop!
+    @populated.to_a.should == [1, 2, 3]
+  end
 end

data/{test/test_indent.rb → spec/indent_spec.rb}

@@ -150,6 +150,11 @@ TXT
     @indent.indent(input).should == output
   end
 
+  it "should correctly handle while <foo> do" do
+    input = "while 5 do\n5\nend"
+    @indent.indent(input).should == "while 5 do\n  5\nend"
+  end
+
   it "should ident case statements" do
     input = <<TXT.strip
 case foo
@@ -274,4 +279,23 @@ OUTPUT
 
     @indent.indent(input).should == output
   end
+
+  describe "nesting" do
+      test = File.read("spec/fixtures/example_nesting.rb")
+
+      test.lines.each_with_index do |line, i|
+        result = line.split("#").last.strip
+        if result == ""
+          it "should fail to parse nesting on line #{i + 1} of example_nesting.rb" do
+            lambda {
+              Pry::Indent.nesting_at(test, i + 1)
+            }.should.raise(Pry::Indent::UnparseableNestingError)
+          end
+        else
+          it "should parse nesting on line #{i + 1} of example_nesting.rb" do
+            Pry::Indent.nesting_at(test, i + 1).should == eval(result)
+          end
+        end
+      end
+    end
 end

data/{test/test_input_stack.rb → spec/input_stack_spec.rb}

@@ -72,6 +72,10 @@ describe "Pry#input_stack" do
   end
 
   if "".respond_to?(:encoding)
+    after do
+      Pry.line_buffer = [""]
+      Pry.current_line = 1
+    end
     it "should pass strings to Pry in the right encoding" do
       input1 = "'f｡｡'.encoding.name" # utf-8, see coding declaration
       input2 = input1.encode('Shift_JIS')

data/{test/test_method.rb → spec/method_spec.rb}

@@ -1,4 +1,5 @@
 require 'helper'
+require 'set'
 
 describe Pry::Method do
   it "should use String names for compatibility" do
@@ -72,6 +73,16 @@ describe Pry::Method do
       meth = Pry::Method.from_str("klass.meth#initialize", Pry.binding_for(binding))
       meth.name.should == "initialize"
     end
+
+    it 'should look up methods using instance::bar syntax' do
+      klass = Class.new{ def self.meth; Class.new; end }
+      meth = Pry::Method.from_str("klass::meth", Pry.binding_for(binding))
+      meth.name.should == "meth"
+    end
+
+    it 'should not raise an exception if receiver does not exist' do
+      lambda { Pry::Method.from_str("random_klass.meth", Pry.binding_for(binding)) }.should.not.raise
+    end
   end
 
   describe '.from_binding' do
@@ -118,6 +129,17 @@ describe Pry::Method do
       m.source_line.should == b.line
       m.name.should == "gag"
     end
+
+    if defined?(BasicObject) && !Pry::Helpers::BaseHelpers.rbx? # rubinius issue 1921
+      it "should find the right method from a BasicObject" do
+        a = Class.new(BasicObject) { def gag; ::Kernel.binding; end; def self.line; __LINE__; end }
+
+        m = Pry::Method.from_binding(a.new.gag)
+        m.owner.should == a
+        m.source_file.should == __FILE__
+        m.source_line.should == a.line
+      end
+    end
   end
 
   describe 'super' do
@@ -397,5 +419,47 @@ describe Pry::Method do
       meth.send(:method_name_from_first_line, "def obj_name.x").should == "x"
     end
   end
-end
 
+  describe 'method aliases' do
+    before do
+      @class = Class.new {
+        def eat
+        end
+
+        alias fress eat
+        alias_method :omnomnom, :fress
+
+        def eruct
+        end
+      }
+    end
+
+    it 'should be able to find method aliases' do
+      meth = Pry::Method(@class.new.method(:eat))
+      aliases = Set.new(meth.aliases)
+
+      aliases.should == Set.new(["fress", "omnomnom"])
+    end
+
+    it 'should return an empty Array if cannot find aliases' do
+      meth = Pry::Method(@class.new.method(:eruct))
+      meth.aliases.should.be.empty
+    end
+
+    it 'should not include the own name in the list of aliases' do
+      meth = Pry::Method(@class.new.method(:eat))
+      meth.aliases.should.not.include "eat"
+    end
+
+    unless Pry::Helpers::BaseHelpers.mri_18?
+      # Ruby 1.8 doesn't support this feature.
+      it 'should be able to find aliases for methods implemented in C' do
+        meth = Pry::Method(Hash.new.method(:key?))
+        aliases = Set.new(meth.aliases)
+
+        aliases.should == Set.new(["include?", "member?", "has_key?"])
+      end
+    end
+
+  end
+end