pry 0.9.8pre2 → 0.9.8pre3

data/test/test_command.rb

@@ -0,0 +1,317 @@
+require 'helper'
+
+describe "Pry::Command" do
+
+  before do
+    @set = Pry::CommandSet.new
+  end
+
+  describe 'call_safely' do
+
+    it 'should display a message if gems are missing' do
+      cmd = @set.command_class "ford-prefect", "From a planet near Beetlegeuse", :requires_gem => %w(ghijkl) do
+        #
+      end
+
+      mock_command(cmd, %w(hello world)).output.should =~ /install-command ford-prefect/
+    end
+
+    it 'should abort early if arguments are required' do
+      cmd = @set.command_class 'arthur-dent', "Doesn't understand Thursdays", :argument_required => true do
+        #
+      end
+
+      lambda {
+        mock_command(cmd, %w())
+      }.should.raise(Pry::CommandError)
+    end
+
+    it 'should return VOID without keep_retval' do
+      cmd = @set.command_class 'zaphod-beeblebrox', "Likes pan-Galactic Gargle Blasters" do
+        def process
+          3
+        end
+      end
+
+      mock_command(cmd).return.should == Pry::Command::VOID_VALUE
+    end
+
+    it 'should return the return value with keep_retval' do
+      cmd = @set.command_class 'tricia-mcmillian', "a.k.a Trillian", :keep_retval => true do
+        def process
+          5
+        end
+      end
+
+      mock_command(cmd).return.should == 5
+    end
+
+    it 'should call hooks in the right order' do
+      cmd = @set.command_class 'marvin', "Pained by the diodes in his left side" do
+        def process
+          output.puts 3 + args[0].to_i
+        end
+      end
+
+      @set.before_command 'marvin' do |i|
+        output.puts 2 + i.to_i
+      end
+      @set.before_command 'marvin' do |i|
+        output.puts 1 + i.to_i
+      end
+
+      @set.after_command 'marvin' do |i|
+        output.puts 4 + i.to_i
+      end
+
+      @set.after_command 'marvin' do |i|
+        output.puts 5 + i.to_i
+      end
+
+      mock_command(cmd, %w(2)).output.should == "3\n4\n5\n6\n7\n"
+    end
+
+    # TODO: This strikes me as rather silly...
+    it 'should return the value from the last hook with keep_retval' do
+      cmd = @set.command_class 'slartibartfast', "Designs Fjords", :keep_retval => true do
+        def process
+          22
+        end
+      end
+
+      @set.after_command 'slartibartfast' do 
+        10
+      end
+
+      mock_command(cmd).return.should == 10
+    end
+  end
+
+  describe 'help' do
+    it 'should default to the description for blocky commands' do
+      @set.command 'oolon-colluphid', "Raving Atheist" do
+        #
+      end
+
+      mock_command(@set.commands['help'], %w(oolon-colluphid), :command_set => @set).output.should =~ /Raving Atheist/
+    end
+
+    it 'should use slop to generate the help for classy commands' do
+      @set.command_class 'eddie', "The ship-board computer" do
+        def options(opt)
+          opt.banner "Over-cheerful, and makes a ticking noise."
+        end
+      end
+
+      mock_command(@set.commands['help'], %w(eddie), :command_set => @set).output.should =~ /Over-cheerful/
+    end
+
+    it 'should provide --help for classy commands' do
+      cmd = @set.command_class 'agrajag', "Killed many times by Arthur" do
+        def options(opt)
+          opt.on :r, :retaliate, "Try to get Arthur back"
+        end
+      end
+
+      mock_command(cmd, %w(--help)).output.should =~ /--retaliate/
+    end
+
+    it 'should provide a -h for classy commands' do
+      cmd = @set.command_class 'zarniwoop', "On an intergalactic cruise, in his office." do
+        def options(opt)
+          opt.on :e, :escape, "Help zaphod escape the Total Perspective Vortex"
+        end
+      end
+
+      mock_command(cmd, %w(--help)).output.should =~ /Total Perspective Vortex/
+    end
+
+    it 'should use the banner provided' do
+      cmd = @set.command_class 'deep-thought', "The second-best computer ever" do
+        banner <<-BANNER
+          Who's merest operational parameters, I am not worthy to compute.
+        BANNER
+      end
+
+      mock_command(cmd, %w(--help)).output.should =~ /Who\'s merest/
+    end
+  end
+
+
+  describe 'context' do
+    context = {
+      :target => binding,
+      :output => StringIO.new,
+      :eval_string => "eval-string",
+      :command_set => @set,
+      :pry_instance => Object.new
+    }
+
+    it 'should capture lots of stuff from the hash passed to new before setup' do
+      cmd = @set.command_class 'fenchurch', "Floats slightly off the ground" do
+        define_method(:setup) do
+          self.context.should == context
+          target.should == context[:target]
+          target_self.should == context[:target].eval('self')
+          output.should == context[:output]
+        end
+
+        define_method(:process) do
+          eval_string.should == "eval-string"
+          command_set.should == @set
+          _pry_.should == context[:pry_instance]
+        end
+      end
+
+      cmd.new(context).call
+    end
+  end
+
+  describe 'classy api' do
+
+    it 'should call setup, then options, then process' do
+      cmd = @set.command_class 'rooster', "Has a tasty towel" do
+        def setup
+          output.puts "setup"
+        end
+
+        def options(opt)
+          output.puts "options"
+        end
+
+        def process
+          output.puts "process"
+        end
+      end
+
+      mock_command(cmd).output.should == "setup\noptions\nprocess\n"
+    end
+
+    it 'should raise a command error if process is not overridden' do
+      cmd = @set.command_class 'jeltz', "Commander of a Vogon constructor fleet" do
+        def proccces
+          #
+        end
+      end
+
+      lambda {
+        mock_command(cmd)
+      }.should.raise(Pry::CommandError)
+    end
+
+    it 'should work if neither options, nor setup is overridden' do
+      cmd = @set.command_class 'wowbagger', "Immortal, insulting.", :keep_retval => true do
+        def process
+          5
+        end
+      end
+
+      mock_command(cmd).return.should == 5
+    end
+
+    it 'should provide opts and args as provided by slop' do
+      cmd = @set.command_class 'lintilla', "One of 800,000,000 clones" do
+         def options(opt)
+           opt.on :f, :four, "A numeric four", :as => Integer, :optional => true
+         end
+
+         def process
+           args.should == ['four']
+           opts[:f].should == 4
+         end
+      end
+
+      mock_command(cmd, %w(--four 4 four))
+    end
+  end
+
+  describe 'tokenize' do
+    it 'should interpolate string with #{} in them' do
+      cmd = @set.command 'random-dent' do |*args|
+        args.should == ["3", "8"]
+      end
+
+      foo = 5
+
+      cmd.new(:target => binding).process_line 'random-dent #{1 + 2} #{3 + foo}'
+    end
+
+    it 'should not fail if interpolation is not needed and target is not set' do
+      cmd = @set.command 'the-book' do |*args|
+        args.should == ['--help']
+      end
+
+      cmd.new.process_line 'the-book --help'
+    end
+
+    it 'should not interpolate commands with :interpolate => false' do
+      cmd = @set.command 'thor', 'norse god', :interpolate => false do |*args|
+        args.should == ['%(#{foo})']
+      end
+
+      cmd.new.process_line 'thor %(#{foo})'
+    end
+
+    it 'should use shell-words to split strings' do
+      cmd = @set.command 'eccentrica' do |*args|
+        args.should == ['gallumbits', 'eroticon', '6']
+      end
+
+      cmd.new.process_line %(eccentrica "gallumbits" 'erot''icon' 6)
+    end
+
+    it 'should split on spaces if shellwords is not used' do
+      cmd = @set.command 'bugblatter-beast', 'would eat its grandmother', :shellwords => false do |*args|
+        args.should == ['"of', 'traal"']
+      end
+
+      cmd.new.process_line %(bugblatter-beast "of traal")
+    end
+
+    it 'should add captures to arguments for regex commands' do
+      cmd = @set.command /perfectly (normal)( beast)?/i do |*args|
+        args.should == ['Normal', ' Beast', '(honest!)']
+      end
+
+      cmd.new.process_line %(Perfectly Normal Beast (honest!))
+    end
+  end
+
+  describe 'process_line' do
+    it 'should check for command name collisions if configured' do
+      old = Pry.config.collision_warning
+      Pry.config.collision_warning = true
+
+      cmd = @set.command 'frankie' do
+
+      end
+
+      frankie = 'boyle'
+      output = StringIO.new
+      cmd.new(:target => binding, :output => output).process_line %(frankie mouse)
+
+      output.string.should =~ /Command name collision/
+
+      Pry.config.collision_warning = old
+    end
+
+    it "should set the commands' arg_string and captures" do
+
+      cmd = @set.command /benj(ie|ei)/ do |*args|
+        self.arg_string.should == "mouse"
+        self.captures.should == ['ie']
+        args.should == ['ie', 'mouse']
+      end
+
+      cmd.new.process_line %(benjie mouse)
+    end
+
+    it "should raise an error if the line doesn't match the command" do
+      cmd = @set.command 'grunthos', 'the flatulent'
+
+      lambda {
+        cmd.new.process_line %(grumpos)
+      }.should.raise(Pry::CommandError)
+    end
+  end
+end

data/test/test_command_set.rb

@@ -3,7 +3,10 @@ require 'helper'
 describe Pry::CommandSet do
   before do
     @set = Pry::CommandSet.new
-    @ctx = Pry::CommandContext.new
+    @ctx = {
+      :target => binding,
+      :command_set => @set
+    }
   end
 
   it 'should call the block used for the command when it is called' do
@@ -24,11 +27,11 @@ describe Pry::CommandSet do
     @set.run_command @ctx, 'foo', 1, 2, 3
   end
 
-  it 'should use the first argument as self' do
+  it 'should use the first argument as context' do
     ctx = @ctx
 
     @set.command 'foo' do
-      self.should == ctx
+      self.context.should == ctx
     end
 
     @set.run_command @ctx, 'foo'
@@ -159,9 +162,9 @@ describe Pry::CommandSet do
     @set.desc('foo').should == 'bar'
   end
 
-  it 'should return Pry::CommandContext::VOID_VALUE for commands by default' do
+  it 'should return Pry::Command::VOID_VALUE for commands by default' do
     @set.command('foo') { 3 }
-    @set.run_command(@ctx, 'foo').should == Pry::CommandContext::VOID_VALUE
+    @set.run_command(@ctx, 'foo').should == Pry::Command::VOID_VALUE
   end
 
   it 'should be able to keep return values' do
@@ -184,7 +187,7 @@ describe Pry::CommandSet do
     end
 
     @set.run_command(@ctx, 'foo')
-    Pry::CommandContext.new.should.not.respond_to :my_helper
+    Pry::Command.subclass('foo', '', {}, Module.new).new({:target => binding}).should.not.respond_to :my_helper
   end
 
   it 'should not recreate a new helper module when helpers is called' do
@@ -241,8 +244,8 @@ describe Pry::CommandSet do
   end
 
   it "should provide a 'help' command" do
-    @ctx.command_set = @set
-    @ctx.output = StringIO.new
+    @ctx[:command_set] = @set
+    @ctx[:output] = StringIO.new
 
     lambda {
       @set.run_command(@ctx, 'help')
@@ -255,12 +258,12 @@ describe Pry::CommandSet do
     @set.command 'moo', "Mooerizes" do; end
     @set.command 'boo', "Booerizes" do; end
 
-    @ctx.command_set = @set
-    @ctx.output = StringIO.new
+    @ctx[:command_set] = @set
+    @ctx[:output] = StringIO.new
 
     @set.run_command(@ctx, 'help')
 
-    doc = @ctx.output.string
+    doc = @ctx[:output].string
 
     order = [doc.index("boo"),
              doc.index("foo"),
@@ -331,15 +334,15 @@ describe Pry::CommandSet do
       end
 
       it 'should share the context with the original command' do
-        @ctx.target = "test target string"
+        @ctx[:target] = "test target string".__binding__
         before_val  = nil
         orig_val    = nil
         @set.command('foo') { orig_val = target }
         @set.before_command('foo') { before_val = target }
         @set.run_command(@ctx, 'foo')
 
-        before_val.should == @ctx.target
-        orig_val.should == @ctx.target
+        before_val.should == @ctx[:target]
+        orig_val.should == @ctx[:target]
       end
 
       it 'should work when applied multiple times' do
@@ -375,15 +378,15 @@ describe Pry::CommandSet do
       end
 
       it 'should share the context with the original command' do
-        @ctx.target = "test target string"
-        after_val  = nil
+        @ctx[:target] = "test target string".__binding__
+        after_val   = nil
         orig_val    = nil
         @set.command('foo') { orig_val = target }
         @set.after_command('foo') { after_val = target }
         @set.run_command(@ctx, 'foo')
 
-        after_val.should == @ctx.target
-        orig_val.should == @ctx.target
+        after_val.should == @ctx[:target]
+        orig_val.should == @ctx[:target]
       end
 
       it 'should determine the return value for the command' do
@@ -418,4 +421,135 @@ describe Pry::CommandSet do
     end
 
   end
+
+  describe 'find_command' do
+    it 'should find commands with the right string' do
+      cmd = @set.command('rincewind'){ }
+      @set.find_command('rincewind').should == cmd
+    end
+
+    it 'should not find commands with spaces before' do
+      cmd = @set.command('luggage'){ }
+      @set.find_command(' luggage').should == nil
+    end
+
+    it 'should find commands with arguments after' do
+      cmd = @set.command('vetinari'){ }
+      @set.find_command('vetinari --knock 3').should == cmd
+    end
+
+    it 'should find commands with names containing spaces' do
+      cmd = @set.command('nobby nobbs'){ }
+      @set.find_command('nobby nobbs --steal petty-cash').should == cmd
+    end
+
+    it 'should find command defined by regex' do
+      cmd = @set.command(/(capt|captain) vimes/i){ }
+      @set.find_command('Capt Vimes').should == cmd
+    end
+
+    it 'should find commands defined by regex with arguments' do
+      cmd = @set.command(/(cpl|corporal) Carrot/i){ }
+      @set.find_command('cpl carrot --write-home').should == cmd
+    end
+
+    it 'should not find commands by listing' do
+      cmd = @set.command(/werewol(f|ve)s?/, 'only once a month', :listing => "angua"){ }
+      @set.find_command('angua').should == nil
+    end
+
+    it 'should not find commands without command_prefix' do
+      Pry.config.command_prefix = '%'
+      cmd = @set.command('detritus'){ }
+      @set.find_command('detritus').should == nil
+      Pry.config.command_prefix = ''
+    end
+
+    it "should find commands that don't use the prefix" do
+      Pry.config.command_prefix = '%'
+      cmd = @set.command('colon', 'Sergeant Fred', :use_prefix => false){ }
+      @set.find_command('colon').should == cmd
+      Pry.config.command_prefix = ''
+    end
+  end
+
+  describe '.valid_command?' do
+    it 'should be true for commands that can be found' do
+      cmd = @set.command('archchancellor')
+      @set.valid_command?('archchancellor of_the?(:University)').should == true
+    end
+
+    it 'should be false for commands that can\'' do
+      @set.valid_command?('def monkey(ape)').should == false
+    end
+
+    it 'should not cause argument interpolation' do
+      cmd = @set.command('hello')
+      lambda {
+        @set.valid_command?('hello #{raise "futz"}')
+      }.should.not.raise
+    end
+  end
+
+  describe '.process_line' do
+
+    it 'should return Result.new(false) if there is no matching command' do
+     result = @set.process_line('1 + 42')
+     result.command?.should == false
+     result.void_command?.should == false
+     result.retval.should == nil
+    end
+
+    it 'should return Result.new(true, VOID) if the command is not keep_retval' do
+      @set.command_class('mrs-cake') do
+        def process; 42; end
+      end
+
+      result = @set.process_line('mrs-cake')
+      result.command?.should == true
+      result.void_command?.should == true
+      result.retval.should == Pry::Command::VOID_VALUE
+    end
+
+    it 'should return Result.new(true, retval) if the command is keep_retval' do
+      @set.command_class('magrat', 'the maiden', :keep_retval => true) do
+        def process; 42; end
+      end
+
+      result = @set.process_line('magrat')
+      result.command?.should == true
+      result.void_command?.should == false
+      result.retval.should == 42
+    end
+
+    it 'should pass through context' do
+      ctx = {
+        :eval_string => "bloomers",
+        :pry_instance => Object.new,
+        :output => StringIO.new,
+        :target => binding
+      }
+      @set.command_class('agnes') do
+        define_method(:process) do
+          eval_string.should == ctx[:eval_string]
+          output.should == ctx[:output]
+          target.should == ctx[:target]
+          _pry_.should == ctx[:pry_instance]
+        end
+      end
+
+      @set.process_line('agnes', ctx)
+    end
+
+    it 'should add command_set to context' do
+      set = @set
+      @set.command_class(/nann+y ogg+/) do
+        define_method(:process) do
+          command_set.should == set
+        end
+      end
+
+      @set.process_line('nannnnnny oggggg')
+    end
+  end
 end