pry 0.9.12.6 → 0.10.0.pre2

data/pry.gemspec

@@ -1,29 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/pry/version', __FILE__)
-
-Gem::Specification.new do |s|
-  s.name    = "pry"
-  s.version = Pry::VERSION
-
-  s.authors = ["John Mair (banisterfiend)", "Conrad Irwin", "Ryan Fitzgerald"]
-  s.email = ["jrmair@gmail.com", "conrad.irwin@gmail.com", "rwfitzge@gmail.com"]
-  s.summary = "An IRB alternative and runtime developer console"
-  s.description = s.summary
-  s.homepage = "http://pry.github.com"
-
-  s.executables   = ["pry"]
-  s.require_paths = ["lib"]
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- spec/*`.split("\n")
-
-  s.add_dependency 'coderay',       '~> 1.0'
-  s.add_dependency 'slop',          '~> 3.4'
-  s.add_dependency 'method_source', '~> 0.8'
-
-  s.add_development_dependency 'bacon', '~> 1.2'
-  s.add_development_dependency 'open4', '~> 1.3'
-  s.add_development_dependency 'rake',  '~> 0.9'
-  s.add_development_dependency 'mocha', '~> 0.13.1'
-  # TODO: make this a plain dependency:
-  s.add_development_dependency 'bond',  '~> 0.4.2'
-end

data/spec/Procfile

@@ -1,3 +0,0 @@
-# Run this with:
-# gem install foreman && foreman start -f spec/Procfile
-pryhere: sh -c '(cd ..; rake pry)'

data/spec/cli_spec.rb

@@ -1,78 +0,0 @@
-require 'helper'
-
-describe Pry::Hooks do
-  before do
-    Pry::CLI.reset
-  end
-
-  describe "parsing options" do
-    it 'should raise if no options defined' do
-      lambda { Pry::CLI.parse_options(["--nothing"]) }.should.raise Pry::CLI::NoOptionsError
-    end
-  end
-
-  describe "adding options" do
-    it "should be able to add an option" do
-      run = false
-
-      Pry::CLI.add_options do
-        on :optiontest, "A test option" do
-          run = true
-        end
-      end.parse_options(["--optiontest"])
-
-      run.should == true
-    end
-
-    it "should be able to add multiple options" do
-      run = false
-      run2 = false
-
-      Pry::CLI.add_options do
-        on :optiontest, "A test option" do
-          run = true
-        end
-      end.add_options do
-        on :optiontest2, "Another test option" do
-          run2 = true
-        end
-      end.parse_options(["--optiontest", "--optiontest2"])
-
-      run.should == true
-      run2.should == true
-    end
-
-  end
-
-  describe "processing options" do
-    it "should be able to process an option" do
-      run = false
-
-      Pry::CLI.add_options do
-        on :optiontest, "A test option"
-      end.process_options do |opts|
-        run = true if opts.present?(:optiontest)
-      end.parse_options(["--optiontest"])
-
-      run.should == true
-    end
-
-    it "should be able to  process multiple options" do
-      run = false
-      run2 = false
-
-      Pry::CLI.add_options do
-        on :optiontest, "A test option"
-        on :optiontest2, "Another test option"
-      end.process_options do |opts|
-        run = true if opts.present?(:optiontest)
-      end.process_options do |opts|
-        run2 = true if opts.present?(:optiontest2)
-      end.parse_options(["--optiontest", "--optiontest2"])
-
-      run.should == true
-      run2.should == true
-    end
-
-  end
-end

data/spec/code_object_spec.rb

@@ -1,277 +0,0 @@
-require 'helper'
-
-describe Pry::CodeObject do
-  describe "basic lookups" do
-    before do
-      @obj = Object.new
-      def @obj.ziggy
-        "a flight of scarlet pigeons thunders round my thoughts"
-      end
-
-      class ClassyWassy
-        def piggy
-          binding
-        end
-      end
-
-      @p = Pry.new
-      @p.binding_stack = [binding]
-    end
-
-    after do
-      Object.remove_const(:ClassyWassy)
-    end
-
-    it 'should lookup methods' do
-      m = Pry::CodeObject.lookup("@obj.ziggy", @p)
-      m.is_a?(Pry::Method).should == true
-      m.name.to_sym.should == :ziggy
-    end
-
-    it 'should lookup modules' do
-      m = Pry::CodeObject.lookup("ClassyWassy", @p)
-      m.is_a?(Pry::WrappedModule).should == true
-      m.source.should =~ /piggy/
-    end
-
-    it 'should lookup procs' do
-      my_proc = proc { :hello }
-      @p.binding_stack = [binding]
-      m = Pry::CodeObject.lookup("my_proc", @p)
-      m.is_a?(Pry::Method).should == true
-      m.source.should =~ /hello/
-    end
-
-    describe 'commands lookup' do
-      before do
-        @p = Pry.new
-        @p.binding_stack = [binding]
-      end
-
-      it 'should return command class' do
-        @p.commands.command "jeremy-jones" do
-          "lobster"
-        end
-        m = Pry::CodeObject.lookup("jeremy-jones", @p)
-        (m <= Pry::Command).should == true
-        m.source.should =~ /lobster/
-      end
-
-      describe "class commands" do
-        before do
-          class LobsterLady < Pry::ClassCommand
-            match "lobster-lady"
-            description "nada."
-            def process
-              "lobster"
-            end
-          end
-        end
-
-        after do
-          Object.remove_const(:LobsterLady)
-        end
-
-        it 'should return Pry::ClassCommand class when looking up class command' do
-          Pry.commands.add_command(LobsterLady)
-          m = Pry::CodeObject.lookup("lobster-lady", @p)
-          (m <= Pry::ClassCommand).should == true
-          m.source.should =~ /class LobsterLady/
-          Pry.commands.delete("lobster-lady")
-        end
-
-        it 'should return Pry::WrappedModule when looking up command class directly (as a class, not as a command)' do
-          Pry.commands.add_command(LobsterLady)
-          m = Pry::CodeObject.lookup("LobsterLady", @p)
-          m.is_a?(Pry::WrappedModule).should == true
-          m.source.should =~ /class LobsterLady/
-          Pry.commands.delete("lobster-lady")
-        end
-      end
-
-      it 'looks up commands by :listing name as well' do
-        @p.commands.command /jeremy-.*/, "", :listing => "jeremy-baby" do
-          "lobster"
-        end
-        m = Pry::CodeObject.lookup("jeremy-baby", @p)
-        (m <= Pry::Command).should == true
-        m.source.should =~ /lobster/
-      end
-
-      it 'finds nothing when passing nil as the first argument' do
-        Pry::CodeObject.lookup(nil, @p).should == nil
-      end
-
-    end
-
-    it 'should lookup instance methods defined on classes accessed via local variable' do
-      o = Class.new do
-        def princess_bubblegum
-          "mathematic!"
-        end
-      end
-
-      @p.binding_stack = [binding]
-      m = Pry::CodeObject.lookup("o#princess_bubblegum", @p)
-      m.is_a?(Pry::Method).should == true
-      m.source.should =~ /mathematic!/
-    end
-
-    it 'should lookup class methods defined on classes accessed via local variable' do
-      o = Class.new do
-        def self.finn
-          "4 realzies"
-        end
-      end
-      @p.binding_stack = [binding]
-      m = Pry::CodeObject.lookup("o.finn", @p)
-      m.is_a?(Pry::Method).should == true
-      m.source.should =~ /4 realzies/
-    end
-
-    it 'should lookup the class of an object (when given a variable)' do
-      moddy = ClassyWassy.new
-      @p.binding_stack = [binding]
-      m = Pry::CodeObject.lookup("moddy", @p)
-      m.is_a?(Pry::WrappedModule).should == true
-      m.source.should =~ /piggy/
-    end
-
-    describe "inferring object from binding when lookup str is empty/nil" do
-      before do
-        @b1 = Pry.binding_for(ClassyWassy)
-        @b2 = Pry.binding_for(ClassyWassy.new)
-      end
-
-      describe "infer module objects" do
-        it 'should infer module object when binding self is a module' do
-          ["", nil].each do |v|
-            @p.binding_stack = [@b1]
-            m = Pry::CodeObject.lookup(v, @p)
-            m.is_a?(Pry::WrappedModule).should == true
-            m.name.should =~ /ClassyWassy/
-          end
-        end
-
-        it 'should infer module object when binding self is an instance' do
-          ["", nil].each do |v|
-            @p.binding_stack = [@b2]
-            m = Pry::CodeObject.lookup(v, @p)
-            m.is_a?(Pry::WrappedModule).should == true
-            m.name.should =~ /ClassyWassy/
-          end
-        end
-      end
-
-      describe "infer method objects" do
-        it 'should infer method object from binding when inside method context' do
-          b = ClassyWassy.new.piggy
-
-          ["", nil].each do |v|
-            @p.binding_stack = [b]
-            m = Pry::CodeObject.lookup(v, @p)
-            m.is_a?(Pry::Method).should == true
-            m.name.should =~ /piggy/
-          end
-        end
-      end
-    end
-  end
-
-  describe "lookups with :super" do
-    before do
-      class MyClassyWassy; end
-      class CuteSubclass < MyClassyWassy; end
-      @p = Pry.new
-      @p.binding_stack = [binding]
-    end
-
-    after do
-      Object.remove_const(:MyClassyWassy)
-      Object.remove_const(:CuteSubclass)
-    end
-
-    it 'should lookup original class with :super => 0' do
-      m = Pry::CodeObject.lookup("CuteSubclass", @p, :super => 0)
-      m.is_a?(Pry::WrappedModule).should == true
-      m.wrapped.should == CuteSubclass
-    end
-
-    it 'should lookup immediate super class with :super => 1' do
-      m = Pry::CodeObject.lookup("CuteSubclass", @p, :super => 1)
-      m.is_a?(Pry::WrappedModule).should == true
-      m.wrapped.should == MyClassyWassy
-    end
-
-    it 'should ignore :super parameter for commands' do
-      p = Pry.new
-      p.commands.command "jeremy-jones" do
-        "lobster"
-      end
-      p.binding_stack = [binding]
-      m = Pry::CodeObject.lookup("jeremy-jones", p, :super => 10)
-      m.source.should =~ /lobster/
-    end
-  end
-
-  describe "precedence" do
-    before do
-      class ClassyWassy
-        class Puff
-          def tiggy
-          end
-        end
-
-        def Puff
-        end
-
-        def piggy
-        end
-      end
-
-      Object.class_eval do
-        def ClassyWassy
-          :ducky
-        end
-      end
-
-      @p = Pry.new
-      @p.binding_stack = [binding]
-    end
-
-    after do
-      Object.remove_const(:ClassyWassy)
-      Object.remove_method(:ClassyWassy)
-    end
-
-    it 'should look up methods before classes (at top-level)' do
-      m = Pry::CodeObject.lookup("ClassyWassy", @p)
-      m.is_a?(Pry::Method).should == true
-      m.source.should =~ /ducky/
-    end
-
-    it 'should look up classes before methods when namespaced' do
-      m = Pry::CodeObject.lookup("ClassyWassy::Puff", @p)
-      m.is_a?(Pry::WrappedModule).should == true
-      m.source.should =~ /tiggy/
-    end
-
-    it 'should look up locals before methods' do
-      b = Pry.binding_for(ClassyWassy)
-      b.eval("piggy = Puff.new")
-      @p.binding_stack = [b]
-      o = Pry::CodeObject.lookup("piggy", @p)
-      o.is_a?(Pry::WrappedModule).should == true
-    end
-
-    # actually locals are never looked up (via co.default_lookup)  when they're classes, it
-    # just falls through to co.method_or_class
-    it 'should look up classes before locals' do
-      c = ClassyWassy
-      @p.binding_stack = [binding]
-      o = Pry::CodeObject.lookup("c", @p)
-      o.is_a?(Pry::WrappedModule).should == true
-      o.wrapped.should == ClassyWassy
-    end
-  end
-end

data/spec/code_spec.rb

@@ -1,219 +0,0 @@
-require 'helper'
-
-describe Pry::Code do
-  describe '.from_file' do
-    should 'read lines from a file on disk' do
-      Pry::Code.from_file('lib/pry.rb').length.should > 0
-    end
-
-    should 'read lines from Pry\'s line buffer' do
-      pry_eval ':hay_guys'
-      Pry::Code.from_file('(pry)').grep(/:hay_guys/).length.should == 1
-    end
-
-    should 'default to Ruby' do
-      temp_file('') do |f|
-        Pry::Code.from_file(f.path).code_type.should == :ruby
-      end
-    end
-
-    should 'check the extension' do
-      temp_file('.c') do |f|
-        Pry::Code.from_file(f.path).code_type.should == :c
-      end
-    end
-
-    should 'use the provided extension' do
-      temp_file('.c') do |f|
-        Pry::Code.from_file(f.path, :ruby).code_type.should == :ruby
-      end
-    end
-
-    should 'raise an error if the file doesn\'t exist' do
-      proc do
-        Pry::Code.from_file('/knalkjsdnalsd/alkjdlkq')
-      end.should.raise(MethodSource::SourceNotFoundError)
-    end
-
-    should 'check for files relative to origin pwd' do
-      Dir.chdir('spec') do |f|
-        Pry::Code.from_file('spec/' + File.basename(__FILE__)).code_type.should == :ruby
-      end
-    end
-
-    should 'find files that are relative to the current working directory' do
-      Dir.chdir('spec') do |f|
-        Pry::Code.from_file(File.basename(__FILE__)).code_type.should == :ruby
-      end
-    end
-  end
-
-  describe '.from_method' do
-    should 'read lines from a method\'s definition' do
-      m = Pry::Method.from_obj(Pry, :load_history)
-      Pry::Code.from_method(m).length.should > 0
-    end
-  end
-
-  describe '#initialize' do
-    before do
-      @str = Pry::Helpers::CommandHelpers.unindent <<-CODE
-        def hay
-          :guys
-        end
-      CODE
-
-      @array = ['def hay', '  :guys', 'end']
-    end
-
-    should 'break a string into lines' do
-      Pry::Code.new(@str).length.should == 3
-    end
-
-    should 'accept an array' do
-      Pry::Code.new(@array).length.should == 3
-    end
-
-    it 'an array or string should produce an equivalent object' do
-      Pry::Code.new(@str).should == Pry::Code.new(@array)
-    end
-  end
-
-  describe 'filters and formatters' do
-    before do
-      @code = Pry::Code(Pry::Helpers::CommandHelpers.unindent <<-STR)
-        class MyProgram
-          def self.main
-            puts 'Hello, world!'
-          end
-        end
-      STR
-    end
-
-    describe 'filters' do
-      describe '#between' do
-        should 'work with an inclusive range' do
-          @code = @code.between(1..3)
-          @code.length.should == 3
-          @code.should =~ /\Aclass MyProgram/
-          @code.should =~ /world!'\Z/
-        end
-
-        should 'default to an inclusive range' do
-          @code = @code.between(3, 5)
-          @code.length.should == 3
-        end
-
-        should 'work with an exclusive range' do
-          @code = @code.between(2...4)
-          @code.length.should == 2
-          @code.should =~ /\A  def self/
-          @code.should =~ /world!'\Z/
-        end
-
-        should 'use real line numbers for positive indices' do
-          @code = @code.after(3, 3)
-          @code = @code.between(4, 4)
-          @code.length.should == 1
-          @code.should =~ /\A  end\Z/
-        end
-      end
-
-      describe '#before' do
-        should 'work' do
-          @code = @code.before(3, 1)
-          @code.should =~ /\A  def self\.main\Z/
-        end
-      end
-
-      describe '#around' do
-        should 'work' do
-          @code = @code.around(3, 1)
-          @code.length.should == 3
-          @code.should =~ /\A  def self/
-          @code.should =~ /  end\Z/
-        end
-      end
-
-      describe '#after' do
-        should 'work' do
-          @code = @code.after(3, 1)
-          @code.should =~ /\A  end\Z/
-        end
-      end
-
-      describe '#grep' do
-        should 'work' do
-          @code = @code.grep(/end/)
-          @code.length.should == 2
-        end
-      end
-    end
-
-    describe 'formatters' do
-      describe '#with_line_numbers' do
-        should 'show line numbers' do
-          @code = @code.with_line_numbers
-          @code.should =~ /1:/
-        end
-
-        should 'disable line numbers when falsy' do
-          @code = @code.with_line_numbers
-          @code = @code.with_line_numbers(false)
-          @code.should.not =~ /1:/
-        end
-      end
-
-      describe '#with_marker' do
-        should 'show a marker in the right place' do
-          @code = @code.with_marker(2)
-          @code.should =~ /^ =>   def self/
-        end
-
-        should 'disable the marker when falsy' do
-          @code = @code.with_marker(2)
-          @code = @code.with_marker(false)
-          @code.should =~ /^  def self/
-        end
-      end
-
-      describe '#with_indentation' do
-        should 'indent the text' do
-          @code = @code.with_indentation(2)
-          @code.should =~ /^    def self/
-        end
-
-        should 'disable the indentation when falsy' do
-          @code = @code.with_indentation(2)
-          @code = @code.with_indentation(false)
-          @code.should =~ /^  def self/
-        end
-      end
-    end
-
-    describe 'composition' do
-      describe 'grep and with_line_numbers' do
-        should 'work' do
-          @code = @code.grep(/end/).with_line_numbers
-          @code.should =~ /\A4:   end/
-          @code.should =~ /5: end\Z/
-        end
-      end
-
-      describe 'grep and before and with_line_numbers' do
-        should 'work' do
-          @code = @code.grep(/e/).before(5, 5).with_line_numbers
-          @code.should =~ /\A2:   def self.main\n3:/
-          @code.should =~ /4:   end\Z/
-        end
-      end
-
-      describe 'before and after' do
-        should 'work' do
-          @code = @code.before(4, 2).after(2)
-          @code.should == "    puts 'Hello, world!'"
-        end
-      end
-    end
-  end
-end