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

data/lib/pry/extended_commands/experimental.rb

@@ -1,7 +0,0 @@
-class Pry
-  module ExtendedCommands
-
-    Experimental = Pry::CommandSet.new do
-    end
-  end
-end

data/test/helper.rb

@@ -1,223 +0,0 @@
-unless Object.const_defined? 'Pry'
-  $:.unshift File.expand_path '../../lib', __FILE__
-  require 'pry'
-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}"
-
-require 'bacon'
-require 'open4'
-
-# A global space for storing temporary state during tests.
-Pad = OpenStruct.new
-def Pad.clear
-  @table = {}
-end
-
-# turn warnings off (esp for Pry::Hooks which will generate warnings
-# in tests)
-$VERBOSE = nil
-
-# Ensure we do not execute any rc files
-Pry::RC_FILES.clear
-
-# inject a variable into a binding
-def inject_var(name, value, b)
-  Thread.current[:__pry_local__] = value
-  b.eval("#{name} = Thread.current[:__pry_local__]")
-ensure
-  Thread.current[:__pry_local__] = nil
-end
-
-def constant_scope(*names)
-  names.each do |name|
-    Object.remove_const name if Object.const_defined?(name)
-  end
-
-  yield
-ensure
-  names.each do |name|
-    Object.remove_const name if Object.const_defined?(name)
-  end
-end
-
-def mri18_and_no_real_source_location?
-  Pry::Helpers::BaseHelpers.mri_18? && !(Method.instance_method(:source_location).owner == Method)
-end
-
-# 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
-
-# in case the tests call reset_defaults, ensure we reset them to
-# amended (test friendly) values
-class << Pry
-  alias_method :orig_reset_defaults, :reset_defaults
-  def reset_defaults
-    orig_reset_defaults
-
-    Pry.color = false
-    Pry.pager = false
-    Pry.config.should_load_rc      = false
-    Pry.config.should_load_local_rc= false
-    Pry.config.should_load_plugins = false
-    Pry.config.history.should_load = false
-    Pry.config.history.should_save = false
-    Pry.config.auto_indent         = false
-    Pry.config.hooks               = Pry::Hooks.new
-    Pry.config.collision_warning   = false
-  end
-end
-
-def mock_exception(*mock_backtrace)
-  e = StandardError.new("mock exception")
-  (class << e; self; end).class_eval do
-    define_method(:backtrace) { mock_backtrace }
-  end
-  e
-end
-
-Pry.reset_defaults
-
-# this is to test exception code (cat --ex)
-def broken_method
-  this method is broken
-end
-
-# sample doc
-def sample_method
-  :sample
-end
-
-# another sample doc
-def another_sample_method
-  :another_sample
-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
-
-def mock_pry(*args)
-
-  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
-
-def mock_command(cmd, args=[], opts={})
-  output = StringIO.new
-  ret = cmd.new(opts.merge(:output => output)).call_safely(*args)
-  Struct.new(:output, :return).new(output.string, ret)
-end
-
-def redirect_global_pry_input(new_io)
-  old_io = Pry.input
-    Pry.input = new_io
-    begin
-      yield
-    ensure
-      Pry.input = old_io
-    end
-end
-
-def redirect_global_pry_output(new_io)
-  old_io = Pry.output
-    Pry.output = new_io
-    begin
-      yield
-    ensure
-      Pry.output = old_io
-    end
-end
-
-class Module
-  public :remove_const
-  public :remove_method
-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
-
-class Pry
-
-  # null output class - doesn't write anywwhere.
-  class NullOutput
-    def self.puts(*) end
-    def self.string(*) end
-  end
-end
-
-# Open a temp file and yield it to the block, closing it after
-# @return [String] The path of the temp file
-def temp_file(ext='.rb')
-  file = Tempfile.new(['pry', ext])
-  yield file
-ensure
-  file.close(true) if file
-end
-
-
-CommandTester = Pry::CommandSet.new do
-  command "command1", "command 1 test" do
-    output.puts "command1"
-  end
-
-  command "command2", "command 2 test" do |arg|
-    output.puts arg
-  end
-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

data/test/test_completion.rb

@@ -1,62 +0,0 @@
-require 'helper'
-
-describe Pry::InputCompleter do
-
-  before do
-    # The AMQP gem has some classes like this:
-    #  pry(main)> AMQP::Protocol::Test::ContentOk.name
-    #  => :content_ok
-    module SymbolyName
-      def self.name; :symboly_name; end
-    end
-  end
-
-  after do
-    Object.remove_const :SymbolyName
-  end
-
-  # another jruby hack :((
-  if !Pry::Helpers::BaseHelpers.jruby?
-    it "should not crash if there's a Module that has a symbolic name." do
-      completer = Pry::InputCompleter.build_completion_proc(Pry.binding_for(Object.new))
-      lambda{ completer.call "a.to_s." }.should.not.raise Exception
-    end
-  end
-
-  it 'should take parenthesis and other characters into account for symbols' do
-    b         = Pry.binding_for(Object.new)
-    completer = Pry::InputCompleter.build_completion_proc(b)
-
-    lambda { completer.call(":class)") }.should.not.raise(RegexpError)
-  end
-
-  it 'should complete instance variables' do
-    object = Object.new
-
-    object.instance_variable_set(:'@name', 'Pry')
-    object.class.send(:class_variable_set, :'@@number', 10)
-
-    object.instance_variables.map { |v| v.to_sym } \
-      .include?(:'@name').should == true
-
-    object.class.class_variables.map { |v| v.to_sym } \
-      .include?(:'@@number').should == true
-
-    completer = Pry::InputCompleter.build_completion_proc(
-      Pry.binding_for(object)
-    )
-
-    # Complete instance variables.
-    completer.call('@na').include?('@name').should                 == true
-    completer.call('@name.down').include?('@name.downcase').should == true
-
-    # Complete class variables.
-    completer = Pry::InputCompleter.build_completion_proc(
-      Pry.binding_for(object.class)
-    )
-
-    completer.call('@@nu').include?('@@number').should              == true
-    completer.call('@@number.cl').include?('@@number.class').should == true
-  end
-end
-

data/test/test_control_d_handler.rb

@@ -1,45 +0,0 @@
-require 'helper'
-
-describe Pry::DEFAULT_CONTROL_D_HANDLER do
-  describe 'control-d press' do
-    before do
-      @control_d = "Pry::DEFAULT_CONTROL_D_HANDLER.call('', _pry_)"
-      @binding_stack = "self.binding_stack = _pry_.binding_stack.dup"
-    end
-
-   describe 'in an expression' do
-      it 'should clear out passed string' do
-        str = "hello world"
-        Pry::DEFAULT_CONTROL_D_HANDLER.call(str, nil)
-        str.should == ""
-      end
-    end
-
-    describe 'at top-level session' do
-      it 'should break out of a REPL loop' do
-        instance = nil
-        redirect_pry_io(InputTester.new(@control_d)) do
-          instance = Pry.new
-          instance.repl
-        end
-
-        instance.binding_stack.should.be.empty
-      end
-    end
-
-    describe 'in a nested session' do
-      it 'should pop last binding from the binding stack' do
-        base = OpenStruct.new
-        base.obj = OpenStruct.new
-
-        redirect_pry_io(InputTester.new("cd obj", "self.stack_size = _pry_.binding_stack.size",
-                                        @control_d, "self.stack_size = _pry_.binding_stack.size", "exit-all")) do
-          Pry.start(base)
-        end
-
-        base.obj.stack_size.should == 2
-        base.stack_size.should == 1
-      end
-    end
-  end
-end

data/test/test_default_commands/test_cd.rb

@@ -1,321 +0,0 @@
-require 'helper'
-
-describe 'Pry::DefaultCommands::Cd' do
-  before do
-    @o, @obj = Object.new, Object.new
-    @obj.instance_variable_set(:@x, 66)
-    @obj.instance_variable_set(:@y, 79)
-    @o.instance_variable_set(:@obj, @obj)
-
-    # Shortcuts. They save a lot of typing.
-    @bs1 = "Pad.bs1 = _pry_.binding_stack.dup"
-    @bs2 = "Pad.bs2 = _pry_.binding_stack.dup"
-    @bs3 = "Pad.bs3 = _pry_.binding_stack.dup"
-
-    @os1 = "Pad.os1 = _pry_.command_state['cd'].old_stack.dup"
-    @os2 = "Pad.os2 = _pry_.command_state['cd'].old_stack.dup"
-
-    @self  = "Pad.self = self"
-    @inner = "Pad.inner = self"
-    @outer = "Pad.outer = self"
-  end
-
-  after do
-    Pad.clear
-  end
-
-  describe 'state' do
-    it 'should not to be set up in fresh instance' do
-      redirect_pry_io(InputTester.new(@os1, "exit-all")) do
-        Pry.start(@o)
-      end
-
-      Pad.os1.should == nil
-    end
-  end
-
-  describe 'old stack toggling with `cd -`' do
-    describe 'in fresh pry instance' do
-      it 'should not toggle when there is no old stack' do
-        redirect_pry_io(InputTester.new("cd -", @bs1, "cd -",
-                                         @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval("self") }.should == [@o]
-        Pad.bs2.map { |v| v.eval("self") }.should == [@o]
-      end
-    end
-
-    describe 'when an error was raised' do
-      it 'should ensure cd @ raises SyntaxError' do
-        mock_pry("cd @").should =~ /SyntaxError/
-      end
-
-      it 'should not toggle and should keep correct old stack' do
-        redirect_pry_io(InputTester.new("cd @", @os1, "cd -", @os2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.os1.should == []
-        Pad.os2.should == []
-      end
-
-      it 'should not toggle and should keep correct current binding stack' do
-        redirect_pry_io(InputTester.new("cd @", @bs1, "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval("self") }.should == [@o]
-        Pad.bs2.map { |v| v.eval("self") }.should == [@o]
-      end
-    end
-
-    describe 'when using simple cd syntax' do
-      it 'should toggle' do
-        redirect_pry_io(InputTester.new("cd :mon_dogg", "cd -", @bs1,
-                                        "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval("self") }.should == [@o]
-        Pad.bs2.map { |v| v.eval("self") }.should == [@o, :mon_dogg]
-      end
-    end
-
-    describe "when using complex cd syntax" do
-      it 'should toggle with a complex path (simple case)' do
-        redirect_pry_io(InputTester.new("cd 1/2/3", "cd -", @bs1,
-                                        "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, 1, 2, 3]
-      end
-
-      it 'should toggle with a complex path (more complex case)' do
-        redirect_pry_io(InputTester.new("cd 1/2/3", "cd ../4", "cd -",
-                                        @bs1, "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o, 1, 2, 3]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, 1, 2, 4]
-      end
-    end
-
-    describe 'series of cd calls' do
-      it 'should toggle with fuzzy `cd -` calls' do
-        redirect_pry_io(InputTester.new("cd :mon_dogg", "cd -", "cd 42", "cd -",
-                                        @bs1, "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, 42]
-      end
-    end
-
-    describe 'when using cd ..' do
-      it 'should toggle with a simple path' do
-        redirect_pry_io(InputTester.new("cd :john_dogg", "cd ..", @bs1,
-                                        "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, :john_dogg]
-      end
-
-      it 'should toggle with a complex path' do
-        redirect_pry_io(InputTester.new("cd 1/2/3/../4", "cd -", @bs1,
-                                        "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, 1, 2, 4]
-      end
-    end
-
-    describe 'when using cd ::' do
-      it 'should toggle' do
-        redirect_pry_io(InputTester.new("cd ::", "cd -", @bs1,
-                                        "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, TOPLEVEL_BINDING.eval("self")]
-      end
-    end
-
-    describe 'when using cd /' do
-      it 'should toggle' do
-        redirect_pry_io(InputTester.new("cd /", "cd -", @bs1, "cd :john_dogg",
-                                        "cd /", "cd -", @bs2, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, :john_dogg]
-      end
-    end
-
-    describe 'when using ^D (Control-D) key press' do
-      before do
-        @control_d = "Pry::DEFAULT_CONTROL_D_HANDLER.call('', _pry_)"
-      end
-
-      it 'should keep correct old binding' do
-        redirect_pry_io(InputTester.new("cd :john_dogg", "cd :mon_dogg",
-                                        "cd :kyr_dogg", @control_d, @bs1,
-                                        "cd -", @bs2, "cd -", @bs3, "exit-all")) do
-          Pry.start(@o)
-        end
-
-        Pad.bs1.map { |v| v.eval('self') }.should == [@o, :john_dogg, :mon_dogg]
-        Pad.bs2.map { |v| v.eval('self') }.should == [@o, :john_dogg, :mon_dogg, :kyr_dogg]
-        Pad.bs3.map { |v| v.eval('self') }.should == [@o, :john_dogg, :mon_dogg]
-      end
-    end
-  end
-
-  it 'should cd into simple input' do
-    redirect_pry_io(InputTester.new("cd :mon_ouie", @inner, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.inner.should == :mon_ouie
-  end
-
-  it 'should break out of session with cd ..' do
-    redirect_pry_io(InputTester.new("cd :inner", @inner, "cd ..", @outer, "exit-all")) do
-      Pry.start(:outer)
-    end
-
-    Pad.inner.should == :inner
-    Pad.outer.should == :outer
-  end
-
-  it "should not leave the REPL session when given 'cd ..'" do
-    redirect_pry_io(InputTester.new("cd ..", @self, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.self.should == @o
-  end
-
-  it 'should break out to outer-most session with cd /' do
-    redirect_pry_io(InputTester.new("cd :inner", @inner, "cd 5", "Pad.five = self",
-                                    "cd /", @outer, "exit-all")) do
-      Pry.start(:outer)
-    end
-
-    Pad.inner.should == :inner
-    Pad.five.should == 5
-    Pad.outer.should == :outer
-  end
-
-  it 'should break out to outer-most session with just cd (no args)' do
-    redirect_pry_io(InputTester.new("cd :inner", @inner, "cd 5", "Pad.five = self",
-                                    "cd", @outer, "exit-all")) do
-      Pry.start(:outer)
-    end
-
-    Pad.inner.should == :inner
-    Pad.five.should == 5
-    Pad.outer.should == :outer
-  end
-
-  it 'should cd into an object and its ivar using cd obj/@ivar syntax' do
-    redirect_pry_io(InputTester.new("cd @obj/@x", @bs1, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.bs1.map { |v| v.eval("self") }.should == [@o, @obj, 66]
-  end
-
-  it 'should cd into an object and its ivar using cd obj/@ivar/ syntax (note following /)' do
-    redirect_pry_io(InputTester.new("cd @obj/@x/", @bs1, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.bs1.map { |v| v.eval("self") }.should == [@o, @obj, 66]
-  end
-
-  it 'should cd into previous object and its local using cd ../local syntax' do
-    redirect_pry_io(InputTester.new("cd @obj", "local = :local", "cd @x",
-                                    "cd ../local", @bs1, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.bs1.map { |v| v.eval("self") }.should == [@o, @obj, :local]
-  end
-
-  it 'should cd into an object and its ivar and back again using cd obj/@ivar/.. syntax' do
-    redirect_pry_io(InputTester.new("cd @obj/@x/..", @bs1, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.bs1.map { |v| v.eval("self") }.should == [@o, @obj]
-  end
-
-  it 'should cd into an object and its ivar and back and then into another ivar using cd obj/@ivar/../@y syntax' do
-    redirect_pry_io(InputTester.new("cd @obj/@x/../@y", @bs1, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.bs1.map { |v| v.eval("self") }.should == [@o, @obj, 79]
-  end
-
-  it 'should cd back to top-level and then into another ivar using cd /@ivar/ syntax' do
-    redirect_pry_io(InputTester.new("@z = 20", "cd @obj/@x/", "cd /@z",
-                                     @bs1, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.bs1.map { |v| v.eval("self") }.should == [@o, 20]
-  end
-
-  it 'should start a session on TOPLEVEL_BINDING with cd ::' do
-    redirect_pry_io(InputTester.new("cd ::", @self, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.self.should == TOPLEVEL_BINDING.eval("self")
-  end
-
-  it 'should cd into complex input (with spaces)' do
-    def @o.hello(x, y, z)
-      :mon_ouie
-    end
-
-    redirect_pry_io(InputTester.new("cd hello 1, 2, 3", @self, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.self.should == :mon_ouie
-  end
-
-  it 'should not cd into complex input when it encounters an exception' do
-    redirect_pry_io(InputTester.new("cd 1/2/swoop_a_doop/3",
-                                    @bs1, "exit-all")) do
-      Pry.start(@o)
-    end
-
-    Pad.bs1.map { |v| v.eval("self") }.should == [@o]
-  end
-
-  # Regression test for ticket #516.
-  #it 'should be able to cd into the Object BasicObject.' do
-  #  mock_pry('cd BasicObject.new').should.not =~ /\Aundefined method `__binding__'/
-  #end
-
-  # Regression test for ticket #516
-  # Possibly move higher up.
-  it 'should not fail with undefined BasicObject#is_a?' do
-    mock_pry('cd BasicObject.new').should.not =~ /undefined method `is_a\?'/
-  end
-end