pry 0.9.7.4-i386-mswin32 → 0.9.8-i386-mswin32

data/lib/pry/default_commands/easter_eggs.rb

@@ -8,7 +8,7 @@ class Pry
         run "show-input"
       end
 
-      command "get-naked" "" do
+      command "get-naked", "" do
         text = %{
 --
 We dont have to take our clothes off to have a good time.
@@ -60,8 +60,32 @@ they are lost for hours.
   text
 end
 
+      command "test-ansi", "" do
+        prev_color = Pry.color
+        Pry.color = true
 
-    end
+        picture = unindent <<-'EOS'.gsub(/[[:alpha:]!]/) { |s| text.red(s) }
+           ____      _______________________
+          /    \    |  A         W     G    |
+         / O  O \   |   N    I    O   N !   |
+        |        |  |    S    S    R I   !  |
+         \ \__/ / __|     I         K     ! |
+          \____/   \________________________|
+        EOS
+
+        if defined?(Win32::Console)
+          move_up = proc { |n| "\e[#{n}F" }
+        else
+          move_up = proc { |n| "\e[#{n}A\e[0G" }
+        end
+
+        output.puts "\n" * 6
+        output.puts picture.lines.map(&:chomp).reverse.join(move_up[1])
+        output.puts "\n" * 6
+        output.puts "** ENV['TERM'] is #{ENV['TERM']} **\n\n"
 
+        Pry.color = prev_color
+      end
+    end
   end
 end

data/lib/pry/default_commands/gems.rb

@@ -3,53 +3,81 @@ class Pry
 
     Gems = Pry::CommandSet.new do
 
-      command "gem-install", "Install a gem and refresh the gem cache.", :argument_required => true do |gem|
-        require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
-        begin
-          destination = File.writable?(Gem.dir) ? Gem.dir : Gem.user_dir
-          installer = Gem::DependencyInstaller.new :install_dir => destination
-          installer.install gem
-        rescue Errno::EACCES
-          raise CommandError, "Insufficient permissions to install `#{text.green gem}`."
-        rescue Gem::GemNotFoundException
-          raise CommandError, "Gem `#{text.green gem}` not found."
-        else
-          Gem.refresh
-          output.puts "Gem `#{text.green gem}` installed."
+      create_command "gem-install", "Install a gem and refresh the gem cache.", :argument_required => true do |gem|
+
+        banner <<-BANNER
+          Usage: gem-install GEM_NAME
+
+          Installs the given gem and refreshes the gem cache so that you can immediately 'require GEM_FILE'
+        BANNER
+
+        def setup
+          require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
         end
-      end
 
-      command "gem-cd", "Change working directory to specified gem's directory.", :argument_required => true do |gem|
-        specs = Gem::Specification.respond_to?(:each) ? Gem::Specification.find_all_by_name(gem) : Gem.source_index.find_name(gem)
-        spec  = specs.sort { |a,b| Gem::Version.new(b.version) <=> Gem::Version.new(a.version) }.first
-        if spec
-          Dir.chdir(spec.full_gem_path)
-        else
-          raise CommandError, "Gem `#{gem}` not found."
+        def process(gem)
+          begin
+            destination = File.writable?(Gem.dir) ? Gem.dir : Gem.user_dir
+            installer = Gem::DependencyInstaller.new :install_dir => destination
+            installer.install gem
+          rescue Errno::EACCES
+            raise CommandError, "Insufficient permissions to install `#{text.green gem}`."
+          rescue Gem::GemNotFoundException
+            raise CommandError, "Gem `#{text.green gem}` not found."
+          else
+            Gem.refresh
+            output.puts "Gem `#{text.green gem}` installed."
+          end
         end
       end
 
-      command "gem-list", "List/search installed gems. (Optional parameter: a regexp to limit the search)" do |pattern|
-        pattern = Regexp.new pattern.to_s, Regexp::IGNORECASE
-        gems    = if Gem::Specification.respond_to?(:each)
-                    Gem::Specification.select{|spec| spec.name =~ pattern }.group_by(&:name)
-                  else
-                    Gem.source_index.gems.values.group_by(&:name).select { |gemname, specs| gemname =~ pattern }
-                  end
-
-        gems.each do |gem, specs|
-          specs.sort! do |a,b|
-            Gem::Version.new(b.version) <=> Gem::Version.new(a.version)
-          end
+      create_command "gem-cd", "Change working directory to specified gem's directory.", :argument_required => true do |gem|
+        banner <<-BANNER
+          Usage: gem-cd GEM_NAME
 
-          versions = specs.each_with_index.map do |spec, index|
-            index == 0 ? text.bright_green(spec.version.to_s) : text.green(spec.version.to_s)
-          end
+          Change the current working directory to that in which the given gem is installed.
+        BANNER
 
-          output.puts "#{text.default gem} (#{versions.join ', '})"
+        def process(gem)
+          specs = Gem::Specification.respond_to?(:each) ? Gem::Specification.find_all_by_name(gem) : Gem.source_index.find_name(gem)
+          spec  = specs.sort { |a,b| Gem::Version.new(b.version) <=> Gem::Version.new(a.version) }.first
+          if spec
+            Dir.chdir(spec.full_gem_path)
+            output.puts(Dir.pwd)
+          else
+            raise CommandError, "Gem `#{gem}` not found."
+          end
         end
       end
 
+      create_command "gem-list", "List and search installed gems." do |pattern|
+        banner <<-BANNER
+          Usage: gem-list [REGEX]
+
+          List all installed gems, when a regex is provided, limit the output to those that
+          match the regex.
+        BANNER
+
+        def process(pattern=nil)
+          gems    = if Gem::Specification.respond_to?(:each)
+                      Gem::Specification.select{|spec| spec.name =~ pattern }.group_by(&:name)
+                    else
+                      Gem.source_index.gems.values.group_by(&:name).select { |gemname, specs| gemname =~ pattern }
+                    end
+
+          gems.each do |gem, specs|
+            specs.sort! do |a,b|
+              Gem::Version.new(b.version) <=> Gem::Version.new(a.version)
+            end
+
+            versions = specs.each_with_index.map do |spec, index|
+              index == 0 ? text.bright_green(spec.version.to_s) : text.green(spec.version.to_s)
+            end
+
+            output.puts "#{text.default gem} (#{versions.join ', '})"
+          end
+        end
+      end
     end
   end
 end

data/lib/pry/default_commands/input.rb

@@ -3,313 +3,245 @@ class Pry
 
     Input = Pry::CommandSet.new do
 
-      command "!", "Clear the input buffer. Useful if the parsing process goes wrong and you get stuck in the read loop.", :use_prefix => false do
-        output.puts "Input buffer cleared!"
-        eval_string.replace("")
-      end
-
-      command "show-input", "Show the contents of the input buffer for the current multi-line expression." do
-        render_output(false, 1, Pry.color ? CodeRay.scan(eval_string, :ruby).term : eval_string)
-      end
-
-      command(/amend-line(?: (-?\d+)(?:\.\.(-?\d+))?)?/, "Amend a line of input in multi-line mode. Type `amend-line --help` for more information. Aliases %",
-              :interpolate => false, :listing => "amend-line")  do |*args|
-        start_line_number, end_line_number, replacement_line = *args
-
-        opts = Slop.parse!(args.compact) do |opt|
-          opt.banner unindent <<-USAGE
-            Amend a line of input in multi-line mode. `amend-line N`, where the N in `amend-line N` represents line to replace.
-
-            Can also specify a range of lines using `amend-line N..M` syntax. Passing '!' as replacement content deletes the line(s) instead. Aliases: %N
-            e.g amend-line 1 puts 'hello world! # replace line 1'
-            e.g amend-line 1..4 !               # delete lines 1..4
-            e.g amend-line 3 >puts 'goodbye'    # insert before line 3
-            e.g amend-line puts 'hello again'   # no line number modifies immediately preceding line
-          USAGE
-
-          opt.on :h, :help, "This message." do
-            output.puts opt
-          end
+      create_command "!", "Clear the input buffer. Useful if the parsing process goes wrong and you get stuck in the read loop.", :use_prefix => false do
+        def process
+          output.puts "Input buffer cleared!"
+          eval_string.replace("")
         end
-
-        next if opts.h?
-
-        if eval_string.empty?
-          raise CommandError, "No input to amend."
-        end
-
-        replacement_line = "" if !replacement_line
-        input_array = eval_string.each_line.to_a
-
-        end_line_number = start_line_number.to_i if !end_line_number
-        line_range = start_line_number ? (one_index_number(start_line_number.to_i)..one_index_number(end_line_number.to_i))  : input_array.size - 1
-
-        # delete selected lines if replacement line is '!'
-        if arg_string == "!"
-          input_array.slice!(line_range)
-        elsif arg_string.start_with?(">")
-          insert_slot = Array(line_range).first
-          input_array.insert(insert_slot, arg_string[1..-1] + "\n")
-        else
-          input_array[line_range] = arg_string + "\n"
-        end
-        eval_string.replace input_array.join
-        run "show-input"
       end
 
-      alias_command(/%.?(-?\d+)?(?:\.\.(-?\d+))?/, /amend-line(?: (-?\d+)(?:\.\.(-?\d+))?)?/)
-
-      command "play", "Play back a string variable or a method or a file as input. Type `play --help` for more information." do |*args|
-        opts = Slop.parse!(args) do |opt|
-          opt.banner unindent <<-USAGE
-            Usage: play [OPTIONS] [--help]
-            Default action (no options) is to play the provided string variable
-            e.g `play _in_[20] --lines 1..3`
-            e.g `play -m Pry#repl --lines 1..-1`
-            e.g `play -f Rakefile --lines 5`
-          USAGE
-
-          opt.on :l, :lines, 'The line (or range of lines) to replay.', true, :as => Range
-          opt.on :m, :method, 'Play a method.', true
-          opt.on :f, "file", 'The file to replay in context.', true
-          opt.on :o, "open", 'When used with the -m switch, it plays the entire method except the last line, leaving the method definition "open". `amend-line` can then be used to modify the method.'
-          opt.on :h, :help, "This message." do
-            output.puts opt
-          end
+      create_command "show-input", "Show the contents of the input buffer for the current multi-line expression." do
+        def process
+          output.puts Code.new(eval_string).with_line_numbers
         end
+      end
 
-        if opts.m?
-          meth_name = opts[:m]
-          meth = get_method_or_raise(meth_name, target, {}, :omit_help)
-          next unless meth.source
-
-          range = opts.l? ? one_index_range_or_number(opts[:l]) : (0..-1)
-          range = (0..-2) if opts.o?
+      create_command(/amend-line(?: (-?\d+)(?:\.\.(-?\d+))?)?/) do
+        description "Amend a line of input in multi-line mode. Type `amend-line --help` for more information."
+        command_options :interpolate => false, :listing => "amend-line"
 
-          eval_string << Array(meth.source.each_line.to_a[range]).join
-        elsif opts.f?
-          file_name = File.expand_path(opts[:f])
+        banner <<-'BANNER'
+          Amend a line of input in multi-line mode. `amend-line N`, where the N in `amend-line N` represents line to replace.
 
-          if !File.exists?(file_name)
-            raise CommandError, "No such file: #{opts[:f]}"
-          end
+          Can also specify a range of lines using `amend-line N..M` syntax. Passing '!' as replacement content deletes the line(s) instead.
+          e.g amend-line 1 puts 'hello world! # replace line 1'
+          e.g amend-line 1..4 !               # delete lines 1..4
+          e.g amend-line 3 >puts 'goodbye'    # insert before line 3
+          e.g amend-line puts 'hello again'   # no line number modifies immediately preceding line
+        BANNER
 
-          text_array = File.readlines(file_name)
-          range = opts.l? ? one_index_range_or_number(opts[:l]) : (0..-1)
-          range = (0..-2) if opts.o?
+        def process
+          start_line_number, end_line_number, replacement_line = *args
 
-          _pry_.input_stack << _pry_.input
-          _pry_.input = StringIO.new(Array(text_array[range]).join)
-        else
-          if !args.first
-            raise CommandError, "No input to play command."
+          if eval_string.empty?
+            raise CommandError, "No input to amend."
           end
 
-          code = target.eval(args.first)
+          replacement_line = "" if !replacement_line
+          input_array = eval_string.each_line.to_a
 
-          range = opts.l? ? one_index_range_or_number(opts[:l]) : (0..-1)
-          range = (0..-2) if opts.o?
+          end_line_number = start_line_number.to_i if !end_line_number
+          line_range = start_line_number ? (one_index_number(start_line_number.to_i)..one_index_number(end_line_number.to_i))  : input_array.size - 1
 
-          eval_string << Array(code.each_line.to_a[range]).join
+          # delete selected lines if replacement line is '!'
+          if arg_string == "!"
+            input_array.slice!(line_range)
+          elsif arg_string.start_with?(">")
+            insert_slot = Array(line_range).first
+            input_array.insert(insert_slot, arg_string[1..-1] + "\n")
+          else
+            input_array[line_range] = arg_string + "\n"
+          end
+          eval_string.replace input_array.join
+          run "show-input"
         end
-
-        run "show-input" if !_pry_.valid_expression?(eval_string)
       end
 
-      command "hist", "Show and replay Readline history. Type `hist --help` for more info. Aliases: history" do |*args|
-        # exclude the current command from history.
-        history = Pry.history.to_a[0..-2]
-
-        opts = Slop.parse!(args) do |opt|
-          opt.banner "Usage: hist [--replay START..END] [--clear] [--grep PATTERN] [--head N] [--tail N] [--help] [--save [START..END] file.txt]\n"
-
-          opt.on :n, 'no-numbers', 'Omit line numbers.'
-
-          opt.on :g, :grep, 'A pattern to match against the history.', true
+      create_command "play" do
+        description "Play back a string variable or a method or a file as input. Type `play --help` for more information."
 
-          opt.on :head, 'Display the first N items of history.',
-                 :optional => true,
-                 :as       => Integer
+        banner <<-BANNER
+          Usage: play [OPTIONS] [--help]
 
-          opt.on :t, :tail, 'Display the last N items of history.',
-                 :optional => true,
-                 :as       => Integer
+          The play command enables you to replay code from files and methods as
+          if they were entered directly in the Pry REPL. Default action (no
+          options) is to play the provided string variable
 
-          opt.on :s, :show, 'Show the history corresponding to the history line (or range of lines).',
-                 :optional => true,
-                 :as       => Range
+          e.g: `play -i 20 --lines 1..3`
+          e.g: `play -m Pry#repl --lines 1..-1`
+          e.g: `play -f Rakefile --lines 5`
 
-          opt.on :e, :exclude, 'Exclude pry commands from the history.'
+          https://github.com/pry/pry/wiki/User-Input#wiki-Play
+        BANNER
 
-          opt.on :r, :replay, 'The line (or range of lines) to replay.', true,
-                 :as => Range
+        attr_accessor :content
 
-          opt.on "save", "Save history to a file. --save [start..end] output.txt. Pry commands are excluded from saved history.", true,
-                 :as => Range
-
-          opt.on :c, :clear, 'Clear the history.', :unless => :grep
+        def setup
+          self.content   = ""
+        end
 
-          opt.on :h, :help, 'Show this message.', :tail => true, :unless => :grep do
-            output.puts opt.help
+        def options(opt)
+          opt.on :m, :method, "Play a method's source.", true do |meth_name|
+            meth = get_method_or_raise(meth_name, target, {})
+            self.content << meth.source
           end
-        end
-        next if opts.help?
-
-        if opts.grep?
-          pattern = Regexp.new(arg_string.strip.split(/ /, 2).last.strip)
-          history.pop
-
-          history.map!.with_index do |element, index|
-            if element =~ pattern
-              if opts.n?
-                element
-              else
-                "#{text.blue index}: #{element}"
-              end
+          opt.on :d, :doc, "Play a method's documentation.", true do |meth_name|
+            meth = get_method_or_raise(meth_name, target, {})
+            text.no_color do
+              self.content << process_comment_markup(meth.doc, :ruby)
             end
           end
+          opt.on :c, :command, "Play a command's source.", true do |command_name|
+            command = find_command(command_name)
+            block = Pry::Method.new(find_command(command_name).block)
+            self.content << block.source
+          end
+          opt.on :f, :file, "Play a file.", true do |file|
+            self.content << File.read(File.expand_path(file))
+          end
+          opt.on :l, :lines, "Only play a subset of lines.", :optional => true, :as => Range, :default => 1..-1
+          opt.on :i, :in, "Play entries from Pry's input expression history. Takes an index or range.", :optional => true,
+          :as => Range, :default => -5..-1 do |range|
+            input_expressions = _pry_.input_array[range] || []
+            Array(input_expressions).each { |v| self.content << v }
+          end
+          opt.on :o, "open", 'When used with the -m switch, it plays the entire method except the last line, leaving the method definition "open". `amend-line` can then be used to modify the method.'
+        end
 
-          stagger_output history.compact.join "\n"
-          next
+        def process
+          perform_play
+          run "show-input" unless _pry_.complete_expression?(eval_string)
         end
 
-        if opts.head?
-          limit = opts['head'] || 10
-          list  = history.first limit
-          lines = list.join("\n")
-          if opts.n?
-            stagger_output lines
-          else
-            stagger_output text.with_line_numbers(lines, 0)
+        def process_non_opt
+          args.each do |arg|
+            begin
+              self.content << target.eval(arg)
+            rescue Pry::RescuableException
+              raise CommandError, "Prblem when evaling #{arg}."
+            end
           end
-          next
         end
 
-        if opts.tail?
-          limit = opts['tail'] || 10
-          offset = history.size - limit
-          offset = offset < 0 ? 0 : offset
+        def perform_play
+          process_non_opt
 
-          list  = history.last limit
-          lines = list.join("\n")
-          if opts.n?
-            stagger_output lines
-          else
-            stagger_output text.with_line_numbers(lines, offset)
+          if opts.present?(:lines)
+            self.content = restrict_to_lines(self.content, opts[:l])
           end
-          next
-        end
 
-        if opts.show?
-          range = opts['show']
-          start_line = range.is_a?(Range) ? range.first : range
-          lines = Array(history[range]).join("\n")
-          if opts.n?
-            stagger_output lines
-          else
-            stagger_output text.with_line_numbers(lines, start_line)
+          if opts.present?(:open)
+            self.content = restrict_to_lines(self.content, 1..-2)
           end
-          next
+
+          eval_string << self.content
         end
+      end
 
-        if opts.exclude?
-          history.map!.with_index do |element, index|
-            unless command_processor.valid_command? element
-              if opts.n?
-                element
-              else
-                "#{text.blue index}: #{element}"
-              end
+      create_command "hist", "Show and replay Readline history. Aliases: history" do
+        banner <<-USAGE
+          Usage: hist
+                 hist --head N
+                 hist --tail N
+                 hist --show START..END
+                 hist --grep PATTERN
+                 hist --clear
+                 hist --replay START..END
+                 hist --save [START..END] FILE
+        USAGE
+
+        def options(opt)
+          opt.on :H, :head, "Display the first N items.", :optional => true, :as => Integer
+          opt.on :T, :tail, "Display the last N items.", :optional => true, :as => Integer
+          opt.on :s, :show, "Show the given range of lines.", :optional => true, :as => Range
+          opt.on :G, :grep, "Show lines matching the given pattern.", true, :as => String
+          opt.on :c, :clear, "Clear the current session's history."
+          opt.on :r, :replay, "Replay a line or range of lines.", true, :as => Range
+          opt.on     :save, "Save history to a file.", true, :as => Range
+
+          opt.on :e, :'exclude-pry', "Exclude Pry commands from the history."
+          opt.on :n, :'no-numbers', "Omit line numbers."
+          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
+        end
+
+        def process
+          @history = Pry::Code(Pry.history.to_a)
+
+          @history = case
+            when opts.present?(:head)
+              @history.between(1, opts[:head] || 10)
+            when opts.present?(:tail)
+              @history.between(-(opts[:tail] || 10), -1)
+            when opts.present?(:show)
+              @history.between(opts[:show])
+            else
+              @history
             end
+
+          if opts.present?(:grep)
+            @history = @history.grep(opts[:grep])
           end
-          stagger_output history.compact.join "\n"
-          next
-        end
 
-        if opts.replay?
-          range = opts['replay']
-          actions = Array(history[range]).join("\n") + "\n"
-          _pry_.input_stack << _pry_.input
-          _pry_.input = StringIO.new(actions)
-          next
-        end
+          if opts.present?(:'exclude-pry')
+            @history = @history.select { |l, ln| !command_set.valid_command?(l) }
+          end
 
-        if opts.clear?
-          Pry.history.clear
-          output.puts 'History cleared.'
-          next
+          if opts.present?(:save)
+            process_save
+          elsif opts.present?(:clear)
+            process_clear
+          elsif opts.present?(:replay)
+            process_replay
+          else
+            process_display
+          end
         end
 
-        # FIXME: hack to save history (this must be refactored)
-        if opts["save"]
-          file_name = nil
-          hist_array = nil
+        def process_display
+          unless opts.present?(:'no-numbers')
+            @history = @history.with_line_numbers
+          end
+
+          render_output(@history, opts)
+        end
 
-          case opts["save"]
+        def process_save
+          case opts[:save]
           when Range
-            hist_array = Array(history[opts["save"]])
+            @history = @history.between(opts[:save])
 
-            if !args.first
+            unless args.first
               raise CommandError, "Must provide a file name."
             end
 
             file_name = File.expand_path(args.first)
           when String
-            hist_array = history
-            file_name =  File.expand_path(opts["save"])
+            file_name = File.expand_path(opts[:save])
           end
 
-          output.puts "Saving history in #{file_name} ..."
-          # exclude pry commands
-          hist_array.reject! do |element|
-            command_processor.valid_command?(element)
-          end
+          output.puts "Saving history in #{file_name}..."
 
-          File.open(file_name, 'w') do |f|
-            f.write hist_array.join("\n")
-          end
+          File.open(file_name, 'w') { |f| f.write(@history.to_s) }
 
-          output.puts "... history saved."
-          next
+          output.puts "History saved."
         end
 
-        lines = history.join("\n")
-        if opts.n?
-          stagger_output lines
-        else
-          stagger_output text.with_line_numbers(lines, 0)
-        end
-      end
-
-      alias_command "history", "hist"
-
-      helpers do
-        def one_index_number(line_number)
-          if line_number > 0
-            line_number - 1
-          elsif line_number < 0
-            line_number
-          else
-            line_number
-          end
+        def process_clear
+          Pry.history.clear
+          output.puts "History cleared."
         end
 
-        def one_index_range(range)
-          Range.new(one_index_number(range.begin), one_index_number(range.end))
-        end
+        def process_replay
+          @history = @history.between(opts[:r])
 
-        def one_index_range_or_number(range_or_number)
-          case range_or_number
-          when Range
-            one_index_range(range_or_number)
-          else
-            one_index_number(range_or_number)
-          end
+          _pry_.input_stack.push _pry_.input
+          _pry_.input = StringIO.new(@history.raw)
+          # eval_string << "#{@history.raw}\n"
+          # run "show-input" unless _pry_.complete_expression?(eval_string)
         end
-
       end
 
+      alias_command "history", "hist"
     end
-
   end
 end