2013-02-12 07:42:29 -05:00
|
|
|
require 'pry/terminal'
|
2013-10-29 00:25:13 -04:00
|
|
|
|
|
|
|
# A Pry::Pager is an IO-like object that accepts text and either prints it
|
|
|
|
# immediately, prints it one page at a time, or streams it to an external
|
|
|
|
# program to print one page at a time.
|
2013-11-02 21:46:01 -04:00
|
|
|
module Pry::Pager
|
2013-10-29 00:25:13 -04:00
|
|
|
class StopPaging < StandardError
|
|
|
|
end
|
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
# Send the given text through the best available pager (if Pry.pager is
|
|
|
|
# enabled).
|
|
|
|
# @param [String] text A piece of text to run through a pager.
|
|
|
|
# @param [#<<] output ($stdout) An object to send output to.
|
|
|
|
def self.page(text, out = $stdout)
|
|
|
|
pager = best_available(out)
|
2013-10-29 00:25:13 -04:00
|
|
|
pager << text
|
|
|
|
ensure
|
|
|
|
pager.close if pager
|
|
|
|
end
|
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
# Return an instance of the "best" available pager class -- SystemPager if
|
|
|
|
# possible, SimplePager if SystemPager isn't available, and NullPager if the
|
|
|
|
# user has disabled paging. All pagers accept output with #puts, #print,
|
|
|
|
# #write, and #<<. You must call #close when you're done writing output to a
|
|
|
|
# pager.
|
|
|
|
def self.best_available(output)
|
|
|
|
if !Pry.pager
|
|
|
|
NullPager.new(output)
|
|
|
|
elsif !SystemPager.available? || Pry::Helpers::BaseHelpers.jruby?
|
2013-10-29 00:25:13 -04:00
|
|
|
SimplePager.new(output)
|
2012-08-09 11:43:46 -04:00
|
|
|
else
|
2013-11-02 21:40:56 -04:00
|
|
|
SystemPager.new(output)
|
2012-08-09 11:43:46 -04:00
|
|
|
end
|
2012-08-08 17:57:19 -04:00
|
|
|
end
|
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
# A "pager" that actually just prints all output as it comes in. Used when
|
|
|
|
# Pry.pager is false.
|
|
|
|
class NullPager
|
|
|
|
def initialize(out)
|
|
|
|
@out = out
|
|
|
|
end
|
2013-10-29 00:25:13 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
def puts(str)
|
|
|
|
print "#{str.chomp}\n"
|
|
|
|
end
|
2013-10-29 00:25:13 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
def print(str)
|
|
|
|
write str
|
|
|
|
end
|
|
|
|
alias << print
|
2013-10-29 00:25:13 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
def write(str)
|
|
|
|
@out.write str
|
|
|
|
end
|
2013-11-02 17:14:51 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
def close
|
|
|
|
end
|
2012-08-08 18:29:51 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
private
|
2013-11-02 17:14:51 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
def height
|
|
|
|
@height ||= Pry::Terminal.height!
|
|
|
|
end
|
2013-11-02 17:14:51 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
def width
|
|
|
|
@width ||= Pry::Terminal.width!
|
|
|
|
end
|
2013-11-02 17:14:51 -04:00
|
|
|
end
|
2013-10-29 00:25:13 -04:00
|
|
|
|
2013-11-02 21:40:56 -04:00
|
|
|
# SimplePager is a very simple pure-Ruby implementation of paging. We use it
|
|
|
|
# on JRuby and when we can't find an external pager to use.
|
|
|
|
class SimplePager < NullPager
|
2013-10-29 00:25:13 -04:00
|
|
|
def initialize(*)
|
|
|
|
super
|
2013-11-02 17:14:51 -04:00
|
|
|
@tracker = PageTracker.new(height - 3, width)
|
2013-10-29 00:25:13 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def write(str)
|
|
|
|
str.lines.each do |line|
|
2013-11-02 21:40:56 -04:00
|
|
|
@out.puts line
|
2013-11-02 17:14:51 -04:00
|
|
|
@tracker.record line
|
2013-10-29 00:25:13 -04:00
|
|
|
|
2013-11-02 17:14:51 -04:00
|
|
|
if @tracker.page?
|
2013-10-29 00:25:13 -04:00
|
|
|
@out.puts "\n<page break> --- Press enter to continue " \
|
|
|
|
"( q<enter> to break ) --- <page break>"
|
|
|
|
raise StopPaging if $stdin.gets.chomp == "q"
|
2013-11-02 17:14:51 -04:00
|
|
|
@tracker.reset
|
2012-08-08 18:29:51 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2013-11-02 17:14:51 -04:00
|
|
|
# SystemPager buffers output until we're pretty sure it's at least a
|
|
|
|
# page long, then invokes an external pager and starts streaming
|
|
|
|
# output to it. If close is called before then, it just prints out
|
|
|
|
# the buffered content.
|
2013-11-02 21:40:56 -04:00
|
|
|
class SystemPager < NullPager
|
2012-10-26 09:09:07 -04:00
|
|
|
def self.default_pager
|
2013-01-18 20:58:11 -05:00
|
|
|
pager = ENV["PAGER"] || ""
|
|
|
|
|
|
|
|
# Default to less, and make sure less is being passed the correct options
|
2013-11-02 17:14:51 -04:00
|
|
|
if pager.strip.empty? or pager =~ /^less\b/
|
2013-01-18 20:58:11 -05:00
|
|
|
pager = "less -R -S -F -X"
|
|
|
|
end
|
|
|
|
|
|
|
|
pager
|
2012-10-26 09:09:07 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def self.available?
|
2013-01-18 20:58:11 -05:00
|
|
|
if @system_pager.nil?
|
|
|
|
@system_pager = begin
|
|
|
|
pager_executable = default_pager.split(' ').first
|
|
|
|
`which #{ pager_executable }`
|
|
|
|
rescue
|
|
|
|
false
|
|
|
|
end
|
|
|
|
else
|
|
|
|
@system_pager
|
|
|
|
end
|
2012-10-26 09:09:07 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def initialize(*)
|
|
|
|
super
|
2013-11-02 17:14:51 -04:00
|
|
|
@tracker = PageTracker.new(height, width)
|
|
|
|
@buffer = ""
|
2012-10-26 09:09:07 -04:00
|
|
|
end
|
|
|
|
|
2013-10-29 00:25:13 -04:00
|
|
|
def write(str)
|
2013-11-02 17:14:51 -04:00
|
|
|
if invoked_pager?
|
|
|
|
pager.write str
|
|
|
|
else
|
|
|
|
@tracker.record str
|
|
|
|
@buffer << str
|
|
|
|
|
|
|
|
if @tracker.page?
|
|
|
|
pager.write @buffer
|
|
|
|
end
|
|
|
|
end
|
2013-10-29 00:25:13 -04:00
|
|
|
rescue Errno::EPIPE
|
2013-11-02 18:54:21 -04:00
|
|
|
raise StopPaging
|
2013-10-29 00:25:13 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def close
|
2013-11-02 17:14:51 -04:00
|
|
|
if invoked_pager?
|
|
|
|
pager.close
|
|
|
|
else
|
|
|
|
@out.puts @buffer
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
|
|
|
|
def invoked_pager?
|
|
|
|
@pager
|
|
|
|
end
|
|
|
|
|
|
|
|
def pager
|
|
|
|
@pager ||= IO.popen(self.class.default_pager, 'w')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# PageTracker tracks output to determine whether it's likely to take up a
|
|
|
|
# whole page. This doesn't need to be super precise, but we can use it for
|
|
|
|
# SimplePager and to avoid invoking the system pager unnecessarily.
|
|
|
|
#
|
|
|
|
# One simplifying assumption is that we don't need page? to return true on
|
|
|
|
# the basis of an incomplete line. Long lines should be counted as multiple
|
|
|
|
# lines, but we don't have to transition from false to true until we see a
|
|
|
|
# newline.
|
|
|
|
class PageTracker
|
|
|
|
def initialize(rows, cols)
|
|
|
|
@rows, @cols = rows, cols
|
|
|
|
reset
|
|
|
|
end
|
|
|
|
|
|
|
|
def record(str)
|
|
|
|
str.lines.each do |line|
|
|
|
|
if line.end_with? "\n"
|
|
|
|
@row += ((@col + line_length(line) - 1) / @cols) + 1
|
|
|
|
@col = 0
|
|
|
|
else
|
2013-11-02 18:46:38 -04:00
|
|
|
@col += line_length(line)
|
2013-11-02 17:14:51 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def page?
|
|
|
|
@row >= @rows
|
|
|
|
end
|
|
|
|
|
|
|
|
def reset
|
|
|
|
@row = 0
|
|
|
|
@col = 0
|
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
|
|
|
|
# Approximation of the printable length of a given line, without the
|
|
|
|
# newline and without ANSI color codes.
|
|
|
|
def line_length(line)
|
|
|
|
line.chomp.gsub(/\e\[[\d;]*m/, '').length
|
2012-08-08 17:57:19 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|