pry 0.9.10pre1-java → 0.9.11-java

data/{test/test_command_set.rb → spec/command_set_spec.rb}

@@ -2,7 +2,10 @@ require 'helper'
 
 describe Pry::CommandSet do
   before do
-    @set = Pry::CommandSet.new{ import Pry::DefaultCommands::Help }
+    @set = Pry::CommandSet.new do
+      import Pry::Commands
+    end
+
     @ctx = {
       :target => binding,
       :command_set => @set
@@ -607,4 +610,18 @@ describe Pry::CommandSet do
       @set.process_line('nannnnnny oggggg')
     end
   end
+
+  if defined?(Bond)
+    describe '.complete' do
+      it "should list all command names" do
+        @set.create_command('susan'){ }
+        @set.complete('sus').should.include 'susan '
+      end
+
+      it "should delegate to commands" do
+        @set.create_command('susan'){ def complete(search); ['--foo']; end }
+        @set.complete('susan ').should == ['--foo']
+      end
+    end
+  end
 end

data/{test/test_command.rb → spec/command_spec.rb}

@@ -4,7 +4,7 @@ describe "Pry::Command" do
 
   before do
     @set = Pry::CommandSet.new
-    @set.import Pry::DefaultCommands::Help
+    @set.import Pry::Commands
   end
 
   describe 'call_safely' do
@@ -138,7 +138,6 @@ describe "Pry::Command" do
     end
   end
 
-
   describe 'context' do
     context = {
       :target => binding,
@@ -170,12 +169,16 @@ describe "Pry::Command" do
 
   describe 'classy api' do
 
-    it 'should call setup, then options, then process' do
+    it 'should call setup, then subcommands, then options, then process' do
       cmd = @set.create_command 'rooster', "Has a tasty towel" do
         def setup
           output.puts "setup"
         end
 
+        def subcommands(cmd)
+          output.puts "subcommands"
+        end
+
         def options(opt)
           output.puts "options"
         end
@@ -185,7 +188,7 @@ describe "Pry::Command" do
         end
       end
 
-      mock_command(cmd).output.should == "setup\noptions\nprocess\n"
+      mock_command(cmd).output.should == "setup\nsubcommands\noptions\nprocess\n"
     end
 
     it 'should raise a command error if process is not overridden' do
@@ -212,14 +215,14 @@ describe "Pry::Command" do
 
     it 'should provide opts and args as provided by slop' do
       cmd = @set.create_command 'lintilla', "One of 800,000,000 clones" do
-         def options(opt)
-           opt.on :f, :four, "A numeric four", :as => Integer, :optional_argument => true
-         end
+        def options(opt)
+          opt.on :f, :four, "A numeric four", :as => Integer, :optional_argument => true
+        end
 
-         def process
-           args.should == ['four']
-           opts[:f].should == 4
-         end
+        def process
+          args.should == ['four']
+          opts[:f].should == 4
+        end
       end
 
       mock_command(cmd, %w(--four 4 four))
@@ -234,6 +237,70 @@ describe "Pry::Command" do
       cmd.command_options[:shellwords].should == false
       cmd.command_options[:listing].should == 'number-one'
     end
+
+    it "should create subcommands" do
+      cmd = @set.create_command 'mum', 'Your mum' do
+        def subcommands(cmd)
+          cmd.command :yell
+        end
+
+        def process
+          opts.fetch_command(:blahblah).should == nil
+          opts.fetch_command(:yell).present?.should == true
+        end
+      end
+
+      mock_command(cmd, ['yell'])
+    end
+
+    it "should create subcommand options" do
+      cmd = @set.create_command 'mum', 'Your mum' do
+        def subcommands(cmd)
+          cmd.command :yell do
+            on :p, :person
+          end
+        end
+
+        def process
+          args.should == ['papa']
+          opts.fetch_command(:yell).present?.should == true
+          opts.fetch_command(:yell).person?.should == true
+        end
+      end
+
+      mock_command(cmd, %w|yell --person papa|)
+    end
+
+    it "should accept top-level arguments" do
+      cmd = @set.create_command 'mum', 'Your mum' do
+        def subcommands(cmd)
+          cmd.on :yell
+        end
+
+        def process
+          args.should == ['yell', 'papa', 'sonny', 'daughter']
+        end
+      end
+
+      mock_command(cmd, %w|yell papa sonny daughter|)
+    end
+
+    describe "explicit classes" do
+      before do
+        @x = Class.new(Pry::ClassCommand) do
+          options :baby => :pig
+          match /goat/
+          description "waaaninngggiiigygygygygy"
+        end
+      end
+
+      it 'subclasses should inherit options, match and description from superclass' do
+        k = Class.new(@x)
+        k.options.should == @x.options
+        k.match.should == @x.match
+        k.description.should == @x.description
+      end
+    end
   end
 
   describe 'tokenize' do
@@ -346,32 +413,34 @@ describe "Pry::Command" do
     before do
       @context = Object.new
       @set.command "walking-spanish", "down the hall", :takes_block => true do
-        inject_var(:@x, command_block.call, target)
+        PryTestHelpers.inject_var(:@x, command_block.call, target)
       end
       @set.import Pry::Commands
+
+      @t = pry_tester(@context, :commands => @set)
     end
 
     it 'should accept multiline blocks' do
-      redirect_pry_io(InputTester.new("walking-spanish | do",
-                                      "  :jesus",
-                                      "end",
-                                      "exit-all"), out = StringIO.new) do
-        Pry.start @context, :commands => @set
-      end
+      @t.eval <<-EOS
+        walking-spanish | do
+          :jesus
+        end
+      EOS
+
       @context.instance_variable_get(:@x).should == :jesus
     end
 
     it 'should accept normal parameters along with block' do
-      @set.block_command "walking-spanish", "litella's been screeching for a blind pig.", :takes_block => true do |x, y|
-        inject_var(:@x, x, target)
-        inject_var(:@y, y, target)
-        inject_var(:@block_var, command_block.call, target)
-      end
-      redirect_pry_io(InputTester.new("walking-spanish john carl| { :jesus }",
-                                      "exit-all")) do
-        Pry.start @context, :commands => @set
+      @set.block_command "walking-spanish",
+          "litella's been screeching for a blind pig.",
+          :takes_block => true do |x, y|
+        PryTestHelpers.inject_var(:@x, x, target)
+        PryTestHelpers.inject_var(:@y, y, target)
+        PryTestHelpers.inject_var(:@block_var, command_block.call, target)
       end
 
+      @t.eval 'walking-spanish john carl| { :jesus }'
+
       @context.instance_variable_get(:@x).should == "john"
       @context.instance_variable_get(:@y).should == "carl"
       @context.instance_variable_get(:@block_var).should == :jesus
@@ -379,29 +448,19 @@ describe "Pry::Command" do
 
     describe "single line blocks" do
       it 'should accept blocks with do ; end' do
-        redirect_pry_io(InputTester.new("walking-spanish | do ; :jesus; end",
-                                        "exit-all"), out = StringIO.new) do
-          Pry.start @context, :commands => @set
-        end
+        @t.eval 'walking-spanish | do ; :jesus; end'
         @context.instance_variable_get(:@x).should == :jesus
       end
 
       it 'should accept blocks with do; end' do
-        redirect_pry_io(InputTester.new("walking-spanish | do; :jesus; end",
-                                        "exit-all"), out = StringIO.new) do
-          Pry.start @context, :commands => @set
-        end
+        @t.eval 'walking-spanish | do; :jesus; end'
         @context.instance_variable_get(:@x).should == :jesus
       end
 
       it 'should accept blocks with { }' do
-        redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                        "exit-all"), out = StringIO.new) do
-          Pry.start @context, :commands => @set
-        end
+        @t.eval 'walking-spanish | { :jesus }'
         @context.instance_variable_get(:@x).should == :jesus
       end
-
     end
 
     describe "block-related content removed from arguments" do
@@ -409,36 +468,33 @@ describe "Pry::Command" do
       describe "arg_string" do
         it 'should remove block-related content from arg_string (with one normal arg)' do
           @set.block_command "walking-spanish", "down the hall", :takes_block => true do |x, y|
-            inject_var(:@arg_string, arg_string, target)
-            inject_var(:@x, x, target)
-          end
-          redirect_pry_io(InputTester.new("walking-spanish john| { :jesus }",
-                                          "exit-all")) do
-            Pry.start @context, :commands => @set
+            PryTestHelpers.inject_var(:@arg_string, arg_string, target)
+            PryTestHelpers.inject_var(:@x, x, target)
           end
+
+          @t.eval 'walking-spanish john| { :jesus }'
+
           @context.instance_variable_get(:@arg_string).should == @context.instance_variable_get(:@x)
         end
 
         it 'should remove block-related content from arg_string (with no normal args)' do
           @set.block_command "walking-spanish", "down the hall", :takes_block => true do
-            inject_var(:@arg_string, arg_string, target)
-          end
-          redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                          "exit-all")) do
-            Pry.start @context, :commands => @set
+            PryTestHelpers.inject_var(:@arg_string, arg_string, target)
           end
+
+          @t.eval 'walking-spanish | { :jesus }'
+
           @context.instance_variable_get(:@arg_string).should == ""
         end
 
         it 'should NOT remove block-related content from arg_string when :takes_block => false' do
           block_string = "| { :jesus }"
           @set.block_command "walking-spanish", "homemade special", :takes_block => false do
-            inject_var(:@arg_string, arg_string, target)
-          end
-          redirect_pry_io(InputTester.new("walking-spanish #{block_string}",
-                                          "exit-all")) do
-            Pry.start @context, :commands => @set
+            PryTestHelpers.inject_var(:@arg_string, arg_string, target)
           end
+
+          @t.eval "walking-spanish #{block_string}"
+
           @context.instance_variable_get(:@arg_string).should == block_string
         end
       end
@@ -447,26 +503,24 @@ describe "Pry::Command" do
         describe "block_command" do
           it "should remove block-related content from arguments" do
             @set.block_command "walking-spanish", "glass is full of sand", :takes_block => true do |x, y|
-              inject_var(:@x, x, target)
-              inject_var(:@y, y, target)
-            end
-            redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                            "exit-all"), out = StringIO.new) do
-              Pry.start @context, :commands => @set
+              PryTestHelpers.inject_var(:@x, x, target)
+              PryTestHelpers.inject_var(:@y, y, target)
             end
+
+            @t.eval 'walking-spanish | { :jesus }'
+
             @context.instance_variable_get(:@x).should == nil
             @context.instance_variable_get(:@y).should == nil
           end
 
           it "should NOT remove block-related content from arguments if :takes_block => false" do
             @set.block_command "walking-spanish", "litella screeching for a blind pig", :takes_block => false do |x, y|
-              inject_var(:@x, x, target)
-              inject_var(:@y, y, target)
-            end
-            redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                            "exit-all"), out = StringIO.new) do
-              Pry.start @context, :commands => @set
+              PryTestHelpers.inject_var(:@x, x, target)
+              PryTestHelpers.inject_var(:@y, y, target)
             end
+
+            @t.eval 'walking-spanish | { :jesus }'
+
             @context.instance_variable_get(:@x).should == "|"
             @context.instance_variable_get(:@y).should == "{"
           end
@@ -476,14 +530,13 @@ describe "Pry::Command" do
           it "should remove block-related content from arguments" do
             @set.create_command "walking-spanish", "punk sanders carved one out of wood", :takes_block => true do
               def process(x, y)
-                inject_var(:@x, x, target)
-                inject_var(:@y, y, target)
+                PryTestHelpers.inject_var(:@x, x, target)
+                PryTestHelpers.inject_var(:@y, y, target)
               end
             end
-            redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                            "exit-all"), out = StringIO.new) do
-              Pry.start @context, :commands => @set
-            end
+
+            @t.eval 'walking-spanish | { :jesus }'
+
             @context.instance_variable_get(:@x).should == nil
             @context.instance_variable_get(:@y).should == nil
           end
@@ -491,14 +544,13 @@ describe "Pry::Command" do
           it "should NOT remove block-related content from arguments if :takes_block => false" do
             @set.create_command "walking-spanish", "down the hall", :takes_block => false do
               def process(x, y)
-                inject_var(:@x, x, target)
-                inject_var(:@y, y, target)
+                PryTestHelpers.inject_var(:@x, x, target)
+                PryTestHelpers.inject_var(:@y, y, target)
               end
             end
-            redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                            "exit-all")) do
-              Pry.start @context, :commands => @set
-            end
+
+            @t.eval 'walking-spanish | { :jesus }'
+
             @context.instance_variable_get(:@x).should == "|"
             @context.instance_variable_get(:@y).should == "{"
           end
@@ -510,13 +562,11 @@ describe "Pry::Command" do
       describe "{} style blocks" do
         it 'should accept multiple parameters' do
           @set.block_command "walking-spanish", "down the hall", :takes_block => true do
-            inject_var(:@x, command_block.call(1, 2), target)
+            PryTestHelpers.inject_var(:@x, command_block.call(1, 2), target)
           end
 
-          redirect_pry_io(InputTester.new("walking-spanish | { |x, y| [x, y] }",
-                                          "exit-all")) do
-            Pry.start @context, :commands => @set
-          end
+          @t.eval 'walking-spanish | { |x, y| [x, y] }'
+
           @context.instance_variable_get(:@x).should == [1, 2]
         end
       end
@@ -525,16 +575,16 @@ describe "Pry::Command" do
         it 'should accept multiple parameters' do
           @set.create_command "walking-spanish", "litella", :takes_block => true do
             def process
-              inject_var(:@x, command_block.call(1, 2), target)
+              PryTestHelpers.inject_var(:@x, command_block.call(1, 2), target)
             end
           end
 
-          redirect_pry_io(InputTester.new("walking-spanish | do |x, y|",
-                                          "  [x, y]",
-                                          "end",
-                                          "exit-all")) do
-            Pry.start @context, :commands => @set
-          end
+          @t.eval <<-EOS
+            walking-spanish | do |x, y|
+              [x, y]
+            end
+          EOS
+
           @context.instance_variable_get(:@x).should == [1, 2]
         end
       end
@@ -542,11 +592,7 @@ describe "Pry::Command" do
 
     describe "closure behaviour" do
       it 'should close over locals in the definition context' do
-        redirect_pry_io(InputTester.new("var = :hello",
-                                        "walking-spanish | { var }",
-                                        "exit-all")) do
-          Pry.start @context, :commands => @set
-        end
+        @t.eval 'var = :hello', 'walking-spanish | { var }'
         @context.instance_variable_get(:@x).should == :hello
       end
     end
@@ -555,12 +601,11 @@ describe "Pry::Command" do
       describe "block_command" do
         it "should expose block in command_block method" do
           @set.block_command "walking-spanish", "glass full of sand", :takes_block => true do
-            inject_var(:@x, command_block.call, target)
-          end
-          redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                          "exit-all")) do
-            Pry.start @context, :commands => @set
+            PryTestHelpers.inject_var(:@x, command_block.call, target)
           end
+
+          @t.eval 'walking-spanish | { :jesus }'
+
           @context.instance_variable_get(:@x).should == :jesus
         end
       end
@@ -569,39 +614,39 @@ describe "Pry::Command" do
         it "should NOT expose &block in create_command's process method" do
           @set.create_command "walking-spanish", "down the hall", :takes_block => true do
             def process(&block)
-              inject_var(:@x, block.call, target)
+              block.call
             end
           end
-          redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                          "exit-all")) do
-            Pry.start @context, :commands => @set
-          end
-          @context.instance_variable_get(:@x).should == nil
+          @out = StringIO.new
+
+          proc {
+            @t.eval 'walking-spanish | { :jesus }'
+          }.should.raise(NoMethodError)
         end
 
         it "should expose block in command_block method" do
           @set.create_command "walking-spanish", "homemade special", :takes_block => true do
             def process
-              inject_var(:@x, command_block.call, target)
+              PryTestHelpers.inject_var(:@x, command_block.call, target)
             end
           end
-          redirect_pry_io(InputTester.new("walking-spanish | { :jesus }",
-                                          "exit-all"), out = StringIO.new) do
-            Pry.start @context, :commands => @set
-          end
+
+          @t.eval 'walking-spanish | { :jesus }'
+
           @context.instance_variable_get(:@x).should == :jesus
         end
       end
     end
   end
 
-  describe "commands made with custom sub-classes" do
-    before do
+  describe "a command made with a custom sub-class" do
 
+    before do
       class MyTestCommand < Pry::ClassCommand
         match /my-*test/
-        description "So just how many sound technicians does it take to change a lightbulb? 1? 2? 3? 1-2-3? Testing?"
-        options :shellwords => false, :listing => "my-test"
+        description 'So just how many sound technicians does it take to' \
+          'change a lightbulb? 1? 2? 3? 1-2-3? Testing?'
+        options :shellwords => false, :listing => 'my-test'
 
         def process
           output.puts command_name * 2
@@ -615,13 +660,71 @@ describe "Pry::Command" do
       Pry.commands.delete 'my-test'
     end
 
-    it "should allow creating custom sub-classes of Pry::Command" do
-      mock_pry("my---test").should =~ /my-testmy-test/
+    it "allows creation of custom subclasses of Pry::Command" do
+      pry_eval('my---test').should =~ /my-testmy-test/
     end
 
-    it "should show the source of the process method" do
-      mock_pry("show-command my-test").should =~ /output.puts command_name/
+    if !mri18_and_no_real_source_location?
+      it "shows the source of the process method" do
+        pry_eval('show-source my-test').should =~ /output.puts command_name/
+      end
     end
+
+    describe "command options hash" do
+      it "is always present" do
+        options_hash = {
+          :requires_gem      => [],
+          :keep_retval       => false,
+          :argument_required => false,
+          :interpolate       => true,
+          :shellwords        => false,
+          :listing           => 'my-test',
+          :use_prefix        => true,
+          :takes_block       => false
+        }
+        MyTestCommand.options.should == options_hash
+      end
+
+      describe ":listing option" do
+        it "defaults to :match if not set explicitly" do
+          class HappyNewYear < Pry::ClassCommand
+            match 'happy-new-year'
+            description 'Happy New Year 2013'
+          end
+          Pry.commands.add_command HappyNewYear
+
+          HappyNewYear.options[:listing].should == 'happy-new-year'
+
+          Pry.commands.delete 'happy-new-year'
+        end
+
+        it "can be set explicitly" do
+          class MerryChristmas < Pry::ClassCommand
+            match 'merry-christmas'
+            description 'Merry Christmas!'
+            command_options :listing => 'happy-holidays'
+          end
+          Pry.commands.add_command MerryChristmas
+
+          MerryChristmas.options[:listing].should == 'happy-holidays'
+
+          Pry.commands.delete 'merry-christmas'
+        end
+
+        it "equals to :match option's inspect, if :match is Regexp" do
+          class CoolWinter < Pry::ClassCommand
+            match /.*winter/
+            description 'Is winter cool or cool?'
+          end
+          Pry.commands.add_command CoolWinter
+
+          CoolWinter.options[:listing].should == '/.*winter/'
+
+          Pry.commands.delete /.*winter/
+        end
+      end
+    end
+
   end
 
   describe "commands can save state" do
@@ -648,49 +751,47 @@ describe "Pry::Command" do
         end
 
       end.import Pry::Commands
+
+      @t = pry_tester(:commands => @set)
     end
 
     it 'should save state for the command on the Pry#command_state hash' do
-      instance = nil
-      redirect_pry_io(InputTester.new("litella",
-                                      "exit-all")) do
-        instance = Pry.new(:commands => @set)
-        instance.repl
-      end
-
-      instance.command_state["litella"].my_state.should == 1
+      @t.eval 'litella'
+      @t.pry.command_state["litella"].my_state.should == 1
     end
 
     it 'should ensure state is maintained between multiple invocations of command' do
-      instance = nil
-      redirect_pry_io(InputTester.new("litella", "litella",
-                                      "exit-all")) do
-        instance = Pry.new(:commands => @set)
-        instance.repl
-      end
-
-      instance.command_state["litella"].my_state.should == 2
+      @t.eval 'litella'
+      @t.eval 'litella'
+      @t.pry.command_state["litella"].my_state.should == 2
     end
 
     it 'should ensure state with same name stored seperately for each command' do
-      instance = nil
-      redirect_pry_io(InputTester.new("litella", "sanders", "exit-all")) do
-        instance = Pry.new(:commands => @set)
-        instance.repl
-      end
+      @t.eval 'litella', 'sanders'
 
-      instance.command_state["litella"].my_state.should == 1
-      instance.command_state["sanders"].my_state.should =="wood"
+      @t.pry.command_state["litella"].my_state.should == 1
+      @t.pry.command_state["sanders"].my_state.should =="wood"
     end
 
     it 'should ensure state is properly saved for regex commands' do
-      instance = nil
-      redirect_pry_io(InputTester.new("hello-world", "Hello-world", "exit-all")) do
-        instance = Pry.new(:commands => @set)
-        instance.repl
-      end
+      @t.eval 'hello-world', 'Hello-world'
+      @t.pry.command_state[/[Hh]ello-world/].my_state.should == 4
+    end
+  end
 
-      instance.command_state[/[Hh]ello-world/].my_state.should == 4
+  if defined?(Bond)
+    describe 'complete' do
+      it 'should return the arguments that are defined' do
+        @set.create_command "torrid" do
+          def options(opt)
+            opt.on :test
+            opt.on :lest
+            opt.on :pests
+          end
+        end
+
+        @set.complete('torrid ').should.include('--test ')
+      end
     end
   end