kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Backport lib/reline, ext/readline, and lib/irb for 3.0.1 (#4085)

Browse source 
* Get rid of inconsistent dll linkages against vcpkg readline

* [ruby/irb] Enhance colored inspect output

dffcdb5269

* [ruby/irb] Add color_printer.rb to gemspec

b4df0fd8b2

* [ruby/irb] Fix failing tests

7723ade899

* irb: add more syntax errors colorizing support (#3967)

* [ruby/irb] Do not colorize partially-correct inspect

This is to prevent a yellow-mixed output for ActiveSupport::TimeWithZone.

Follows up https://github.com/ruby/irb/pull/159 and https://github.com/ruby/ruby/pull/3967.

a5804c3560

* [ruby/irb] Remove unnecessary ignore_error in dispatch_seq

Just forgotten in a5804c3560

e42e548793

* Increase timeout for reline with --jit-wait

for failures like:
http://ci.rvm.jp/logfiles/brlog.trunk-mjit-wait.20201229-130509
http://ci.rvm.jp/logfiles/brlog.trunk-mjit-wait.20201229-165132
http://ci.rvm.jp/logfiles/brlog.trunk-mjit-wait.20201228-015519

* [ruby/irb] Stringify when a non-object is passed to PP#text

If a nested object is passed to #pp, it may be sometimes passed to the #text
method as an object without being stringified.

This is fixed on the Ruby main repository;
433a3be86a
but it was a bug of Ripper so still needs this workaround for using irb
as a gem on Ruby 3.0.0 or earlier.

Co-authored-by: k0kubun <takashikkbn@gmail.com>

8d13df22ee

* [ruby/irb] Newline in oneliner def doesn't reset indent

This closes ruby/irb#132.

43456dcf5e

* [ruby/irb] Escape invalid byte sequence in Exception

This fixes ruby/irb#141.

0815317d42

* [ruby/irb] Handle indentations related to keyword "do" correctly

This fixes ruby/irb#158.

964643400b

* [ruby/irb] Heredoc may contain multiple newlines in a single token

Use the start token as the indentation criteria so that it works properly in
heredoc.

ref. https://github.com/ruby/reline/pull/242

9704808dfd

* [ruby/irb] Use Ripper::Lexer#scan to take broken tokens

ref. https://github.com/ruby/reline/pull/242

54f90cb6c9

* [ruby/irb] Use error tokens if there are no correct tokens in the same place

For example, the broken code "%www" will result in only one error token.

9fa39a7cf3

* [ruby/irb] Ensure to restore $VERBOSE

cef474a76a

* 600x larger timeout for Reline

I didn't notice it's msec. 2.5s is too short.
http://ci.rvm.jp/results/trunk-mjit-wait@phosphorus-docker/3311385

* [ruby/irb] fix typo in `IRB::Irb#convert_invalid_byte_sequence`

d09d3c3d68

* [ruby/irb] do not escape a predicate method for doc namespace

* Fixes #88

d431a30af4

* [ruby/irb] refactoring an error handling in `IRB::Inspector`

* moved rescue clause to `#inspect_value` to catch all failures in inspectors
* test with all (currently five kind of) inspect modes
  - tweaked the input due to only `Marshal` can inspect(dump) a `BasicObject`

9d112fab8e

* [ruby/irb] Use Exception#full_message to show backtrace in the correct order

[Bug #17466]

1c76845cca

* [ruby/irb] Fix BACK_TRACE_LIMIT logic

30dc5d43fe

* irb: Drop lines from backtrace for tests in Ruby repository

* [ruby/reline] Update cursor correctly when just cursor moving

This fixes ruby/reline#236 and ruby/reline#239.

3e3c89d00b

* [ruby/reline] Correct var names in Reline were different from vi-*-mode-string

8255fc93b9

* [ruby/reline] Remove debug print

d7fbaedc6a

* [ruby/reline] Suppress crashing when auto_indent_proc returns broken indent info

Co-authored-by: Juanito Fatas <me@juanitofatas.com>

7c24276275

* [ruby/reline] Suppress crashing when dynamic_prompt_proc returns a broken prompt list

Co-authored-by: Juanito Fatas <me@juanitofatas.com>

558f7be168

* [ruby/reline] Suppress auto indent for adding newlines in pasting

Co-authored-by: Juanito Fatas <me@juanitofatas.com>

074bb017a7

* [ruby/reline] Add acknowledgments and license for rb-readline

19df59b916

* [ruby/irb] Fix comment, irb gem supports 2.5.0 or older

36118015ba

* should use `assert_include` here.

Random ordering test can introduce antoher candidate so it should be
`assert_include`.

* [ruby/irb] Add missing require

This is useful if you want to use IRB::ColorPrinter as a library like:

```
begin
  require 'irb/color_printer'
  IRB::ColorPrinter.pp(obj)
rescue LoadError
  pp(obj)
end
```

f8461691c7

* [ruby/irb] Make IRB::ColorPrinter.pp compatible with PP.pp

The incompatible interface is not helpful, again if you want to use it
as a standalone library, falling it back to PP.

Original PP.pp also ends with `out << "\n"`.

4c74c7d84c

* Suppress constant redefinition warnings

* Fix the failing test with XDG_CONFIG_HOME

* [ruby/irb] Version 1.3.1

c230d08911

* [ruby/reline] Handle ed_search_{prev,next}_history in multiline correctly

The current line was being handled incorrectly when displaying the hit
history, so it has been fixed to be correct.

a3df4343b3

* [ruby/reline] Move the cursor correctly when deleting at eol

This fixes ruby/reline#246.

07a73ba601

* [ruby/reline] Version 0.2.1

a3b3c6ee60

* [ruby/reline] Initialize a variable just in case

29b10f6e98

* [ruby/reline] Tests with yamatanooroti don't need chdir

Because of chdir, log files ware created in temporary directries on Windows.

200b469a68

* [ruby/reline] Windows needs more times to wait rendering

53ff2b09c7

* [ruby/reline] Support for change in Windows-specific behavior at eol

The behavior of automatically moving the cursor to the next line when
displaying a char at the eol on Windows suddenly disappeared.

cad4de6ee8

* [ruby/reline] Reline::Windows.erase_after_cursor erases attributes too

68b961dfc7

* [ruby/irb] [ruby/irb] [ruby/reline] Version 0.2.2

dfb710946f

1a1cdf9628

fe99faf8bd

* [ruby/irb] handle `__ENCODING__` as a keyword as well

a6a33d908f

* [ruby/irb] handle repeated exception separately

fcf6b34bc5

* [ruby/irb] skip a failling test on TruffleRuby

* due to the difference of backtrace pointed out by @aycabta

5e00a0ae61

* [ruby/irb] Version 1.3.2

a7699026cc

Co-authored-by: Nobuyoshi Nakada <nobu@ruby-lang.org>
Co-authored-by: Takashi Kokubun <takashikkbn@gmail.com>
Co-authored-by: Nobuhiro IMAI <nov@yo.rim.or.jp>
Co-authored-by: Koichi Sasada <ko1@atdot.net>
Co-authored-by: Hiroshi SHIBATA <hsbt@ruby-lang.org>
This commit is contained in:
aycabta 2021-01-19 13:01:31 +09:00 • committed by GitHub
parent 29777cb32a
commit 58509767d1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
26 changed files with 812 additions and 163 deletions
Download patch file Download diff file Expand all files Collapse all files

12
ext/readline/readline.c
View file

@ -78,7 +78,7 @@ static ID id_special_prefixes;
#ifndef HAVE_RL_USERNAME_COMPLETION_FUNCTION
# define rl_username_completion_function username_completion_function
#else
char *rl_username_completion_function(const char *, int);
RUBY_EXTERN char *rl_username_completion_function(const char *, int);
#endif
#ifndef HAVE_RL_COMPLETION_MATCHES
# define rl_completion_matches completion_matches
@ -689,7 +689,7 @@ readline_s_insert_text(VALUE self, VALUE str)
#endif
#if defined(HAVE_RL_DELETE_TEXT)
int rl_delete_text(int, int);
RUBY_EXTERN int rl_delete_text(int, int);
static const char *
str_subpos(const char *ptr, const char *end, long beg, long *sublen, rb_encoding *enc)
{
@ -1148,7 +1148,7 @@ readline_s_get_screen_size(VALUE self)
#endif
#ifdef HAVE_RL_VI_EDITING_MODE
int rl_vi_editing_mode(int, int);
RUBY_EXTERN int rl_vi_editing_mode(int, int);
/*
* call-seq:
* Readline.vi_editing_mode -> nil
@ -1187,7 +1187,7 @@ readline_s_vi_editing_mode_p(VALUE self)
#endif
#ifdef HAVE_RL_EMACS_EDITING_MODE
int rl_emacs_editing_mode(int, int);
RUBY_EXTERN int rl_emacs_editing_mode(int, int);
/*
* call-seq:
* Readline.emacs_editing_mode -> nil
@ -1672,7 +1672,7 @@ readline_s_get_filename_quote_characters(VALUE self)
#endif
#ifdef HAVE_RL_REFRESH_LINE
int rl_refresh_line(int, int);
RUBY_EXTERN int rl_refresh_line(int, int);
/*
* call-seq:
* Readline.refresh_line -> nil
@ -1919,7 +1919,7 @@ username_completion_proc_call(VALUE self, VALUE str)
}
#ifdef HAVE_RL_CLEAR_SIGNALS
int rl_clear_signals(void);
RUBY_EXTERN int rl_clear_signals(void);
#endif
#undef rb_intern

98
lib/irb.rb
View file

@ -574,10 +574,35 @@ module IRB
next
end
handle_exception(exc)
@context.workspace.local_variable_set(:_, exc)
exc = nil
end
end
end
def convert_invalid_byte_sequence(str)
str = str.force_encoding(Encoding::ASCII_8BIT)
conv = Encoding::Converter.new(Encoding::ASCII_8BIT, Encoding::UTF_8)
dst = String.new
begin
ret = conv.primitive_convert(str, dst)
case ret
when :invalid_byte_sequence
conv.insert_output(conf.primitive_errinfo[3].dump[1..-2])
redo
when :undefined_conversion
c = conv.primitive_errinfo[3].dup.force_encoding(conv.primitive_errinfo[1])
conv.insert_output(c.dump[1..-2])
redo
when :incomplete_input
conv.insert_output(conv.primitive_errinfo[3].dump[1..-2])
when :finished
end
break
end while nil
dst
end
def handle_exception(exc)
if exc.backtrace && exc.backtrace[0] =~ /\/irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
!(SyntaxError === exc) && !(EncodingError === exc)
@ -587,49 +612,44 @@ module IRB
irb_bug = false
end
if STDOUT.tty?
attr = ATTR_TTY
print "#{attr[1]}Traceback#{attr[]} (most recent call last):\n"
else
attr = ATTR_PLAIN
end
messages = []
lasts = []
levels = 0
if exc.backtrace
count = 0
exc.backtrace.each do |m|
m = @context.workspace.filter_backtrace(m) or next unless irb_bug
count += 1
if attr == ATTR_TTY
m = sprintf("%9d: from %s", count, m)
order = nil
if '2.5.0' == RUBY_VERSION
# Exception#full_message doesn't have keyword arguments.
message = exc.full_message # the same of (highlight: true, order: bottom)
order = :bottom
elsif '2.5.1' <= RUBY_VERSION && RUBY_VERSION < '3.0.0'
if STDOUT.tty?
message = exc.full_message(order: :bottom)
order = :bottom
else
m = "\tfrom #{m}"
message = exc.full_message(order: :top)
order = :top
end
if messages.size < @context.back_trace_limit
messages.push(m)
elsif lasts.size < @context.back_trace_limit
lasts.push(m).shift
levels += 1
else # '3.0.0' <= RUBY_VERSION
message = exc.full_message(order: :top)
order = :top
end
message = convert_invalid_byte_sequence(message)
message = message.gsub(/((?:^\t.+$\n)+)/) { |m|
case order
when :top
lines = m.split("\n")
when :bottom
lines = m.split("\n").reverse
end
end
end
if attr == ATTR_TTY
unless lasts.empty?
puts lasts.reverse
printf "... %d levels...\n", levels if levels > 0
end
puts messages.reverse
end
m = exc.to_s.split(/\n/)
print "#{attr[1]}#{exc.class} (#{attr[4]}#{m.shift}#{attr[0, 1]})#{attr[]}\n"
puts m.map {|s| "#{attr[1]}#{s}#{attr[]}\n"}
if attr == ATTR_PLAIN
puts messages
unless lasts.empty?
puts lasts
printf "... %d levels...\n", levels if levels > 0
end
unless irb_bug
lines = lines.map { |l| @context.workspace.filter_backtrace(l) }.compact
if lines.size > @context.back_trace_limit
omit = lines.size - @context.back_trace_limit
lines = lines[0..(@context.back_trace_limit - 1)]
lines << "\t... %d levels..." % omit
end
end
lines = lines.reverse if order == :bottom
lines.map{ |l| l + "\n" }.join
}
puts message
end
print "Maybe IRB bug!\n" if irb_bug
end

19
lib/irb/color.rb
View file

@ -17,7 +17,7 @@ module IRB # :nodoc:
CYAN = 36
TOKEN_KEYWORDS = {
on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__'],
on_kw: ['nil', 'self', 'true', 'false', '__FILE__', '__LINE__', '__ENCODING__'],
on_const: ['ENV'],
}
private_constant :TOKEN_KEYWORDS
@ -60,6 +60,10 @@ module IRB # :nodoc:
on_words_beg: [[RED, BOLD], ALL],
on_parse_error: [[RED, REVERSE], ALL],
compile_error: [[RED, REVERSE], ALL],
on_assign_error: [[RED, REVERSE], ALL],
on_alias_error: [[RED, REVERSE], ALL],
on_class_name_error:[[RED, REVERSE], ALL],
on_param_error: [[RED, REVERSE], ALL],
}
rescue NameError
# Give up highlighting Ripper-incompatible older Ruby
@ -67,6 +71,9 @@ module IRB # :nodoc:
end
private_constant :TOKEN_SEQ_EXPRS
ERROR_TOKENS = TOKEN_SEQ_EXPRS.keys.select { |k| k.to_s.end_with?('error') }
private_constant :ERROR_TOKENS
class << self
def colorable?
$stdout.tty? && supported? && (/mswin|mingw/ =~ RUBY_PLATFORM || (ENV.key?('TERM') && ENV['TERM'] != 'dumb'))
@ -107,7 +114,7 @@ module IRB # :nodoc:
# If `complete` is false (code is incomplete), this does not warn compile_error.
# This option is needed to avoid warning a user when the compile_error is happening
# because the input is not wrong but just incomplete.
def colorize_code(code, complete: true)
def colorize_code(code, complete: true, ignore_error: false)
return code unless colorable?
symbol_state = SymbolState.new
@ -115,6 +122,11 @@ module IRB # :nodoc:
length = 0
scan(code, allow_last_error: !complete) do |token, str, expr|
# IRB::ColorPrinter skips colorizing fragments with any invalid token
if ignore_error && ERROR_TOKENS.include?(token)
return Reline::Unicode.escape_for_print(code)
end
in_symbol = symbol_state.scan_token(token)
str.each_line do |line|
line = Reline::Unicode.escape_for_print(line)
@ -180,11 +192,12 @@ module IRB # :nodoc:
end
end
end
ensure
$VERBOSE = verbose
end
def dispatch_seq(token, expr, str, in_symbol:)
if token == :on_parse_error or token == :compile_error
if ERROR_TOKENS.include?(token)
TOKEN_SEQ_EXPRS[token][0]
elsif in_symbol
[YELLOW]

28
lib/irb/color_printer.rb Normal file
View file

@ -0,0 +1,28 @@
# frozen_string_literal: true
require 'pp'
require 'irb/color'
module IRB
class ColorPrinter < ::PP
def self.pp(obj, out = $>, width = 79)
q = ColorPrinter.new(out, width)
q.guard_inspect_key {q.pp obj}
q.flush
out << "\n"
end
def text(str, width = nil)
unless str.is_a?(String)
str = str.inspect
end
width ||= str.length
case str
when /\A#</, '=', '>'
super(Color.colorize(str, [:GREEN]), width)
else
super(Color.colorize_code(str, ignore_error: true), width)
end
end
end
end

22
lib/irb/completion.rb
View file

@ -47,7 +47,7 @@ module IRB
when /^((["'`]).*\2)\.([^.]*)$/
# String
receiver = $1
message = Regexp.quote($3)
message = $3
candidates = String.instance_methods.collect{|m| m.to_s}
if doc_namespace
@ -59,7 +59,7 @@ module IRB
when /^(\/[^\/]*\/)\.([^.]*)$/
# Regexp
receiver = $1
message = Regexp.quote($2)
message = $2
candidates = Regexp.instance_methods.collect{|m| m.to_s}
if doc_namespace
@ -71,7 +71,7 @@ module IRB
when /^([^\]]*\])\.([^.]*)$/
# Array
receiver = $1
message = Regexp.quote($2)
message = $2
candidates = Array.instance_methods.collect{|m| m.to_s}
if doc_namespace
@ -83,7 +83,7 @@ module IRB
when /^([^\}]*\})\.([^.]*)$/
# Proc or Hash
receiver = $1
message = Regexp.quote($2)
message = $2
proc_candidates = Proc.instance_methods.collect{|m| m.to_s}
hash_candidates = Hash.instance_methods.collect{|m| m.to_s}
@ -117,7 +117,7 @@ module IRB
when /^([A-Z].*)::([^:.]*)$/
# Constant or class methods
receiver = $1
message = Regexp.quote($2)
message = $2
begin
candidates = eval("#{receiver}.constants.collect{|m| m.to_s}", bind)
candidates |= eval("#{receiver}.methods.collect{|m| m.to_s}", bind)
@ -134,7 +134,7 @@ module IRB
# Symbol
receiver = $1
sep = $2
message = Regexp.quote($3)
message = $3
candidates = Symbol.instance_methods.collect{|m| m.to_s}
if doc_namespace
@ -147,7 +147,7 @@ module IRB
# Numeric
receiver = $~[:num]
sep = $~[:sep]
message = Regexp.quote($~[:mes])
message = $~[:mes]
begin
instance = eval(receiver, bind)
@ -169,7 +169,7 @@ module IRB
# Numeric(0xFFFF)
receiver = $1
sep = $2
message = Regexp.quote($3)
message = $3
begin
instance = eval(receiver, bind)
@ -201,7 +201,7 @@ module IRB
# variable.func or func.func
receiver = $1
sep = $2
message = Regexp.quote($3)
message = $3
gv = eval("global_variables", bind).collect{|m| m.to_s}.push("true", "false", "nil")
lv = eval("local_variables", bind).collect{|m| m.to_s}
@ -244,7 +244,7 @@ module IRB
# unknown(maybe String)
receiver = ""
message = Regexp.quote($1)
message = $1
candidates = String.instance_methods(true).collect{|m| m.to_s}
if doc_namespace
@ -294,7 +294,7 @@ module IRB
Operators = %w[% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ ! != !~]
def self.select_message(receiver, message, candidates, sep = ".")
candidates.grep(/^#{message}/).collect do |e|
candidates.grep(/^#{Regexp.quote(message)}/).collect do |e|
case e
when /^[a-zA-Z_]/
receiver + sep + e

26
lib/irb/inspector.rb
View file

@ -100,29 +100,27 @@ module IRB # :nodoc:
# Proc to call when the input is evaluated and output in irb.
def inspect_value(v)
@inspect.call(v)
rescue
puts "(Object doesn't support #inspect)"
''
end
end
Inspector.def_inspector([false, :to_s, :raw]){|v| v.to_s}
Inspector.def_inspector([true, :p, :inspect]){|v|
begin
result = v.inspect
if IRB.conf[:MAIN_CONTEXT]&.use_colorize? && Color.inspect_colorable?(v)
result = Color.colorize_code(result)
end
result
rescue NoMethodError
puts "(Object doesn't support #inspect)"
''
end
}
Inspector.def_inspector([:pp, :pretty_inspect], proc{require "pp"}){|v|
result = v.pretty_inspect.chomp
Inspector.def_inspector([:p, :inspect]){|v|
result = v.inspect
if IRB.conf[:MAIN_CONTEXT]&.use_colorize? && Color.inspect_colorable?(v)
result = Color.colorize_code(result)
end
result
}
Inspector.def_inspector([true, :pp, :pretty_inspect], proc{require "irb/color_printer"}){|v|
if IRB.conf[:MAIN_CONTEXT]&.use_colorize?
IRB::ColorPrinter.pp(v, '').chomp
else
v.pretty_inspect.chomp
end
}
Inspector.def_inspector([:yaml, :YAML], proc{require "yaml"}){|v|
begin
YAML.dump(v)

1
lib/irb/irb.gemspec
View file

@ -38,6 +38,7 @@ Gem::Specification.new do |spec|
"lib/irb/cmd/pushws.rb",
"lib/irb/cmd/subirb.rb",
"lib/irb/color.rb",
"lib/irb/color_printer.rb",
"lib/irb/completion.rb",
"lib/irb/context.rb",
"lib/irb/easter-egg.rb",

133
lib/irb/ruby-lex.rb
View file

@ -106,24 +106,72 @@ class RubyLex
end
end
ERROR_TOKENS = [
:on_parse_error,
:compile_error,
:on_assign_error,
:on_alias_error,
:on_class_name_error,
:on_param_error
]
def ripper_lex_without_warning(code)
verbose, $VERBOSE = $VERBOSE, nil
tokens = nil
self.class.compile_with_errors_suppressed(code) do |inner_code, line_no|
tokens = Ripper.lex(inner_code, '-', line_no)
lexer = Ripper::Lexer.new(inner_code, '-', line_no)
if lexer.respond_to?(:scan) # Ruby 2.7+
tokens = []
pos_to_index = {}
lexer.scan.each do |t|
if pos_to_index.has_key?(t[0])
index = pos_to_index[t[0]]
found_tk = tokens[index]
if ERROR_TOKENS.include?(found_tk[1]) && !ERROR_TOKENS.include?(t[1])
tokens[index] = t
end
else
pos_to_index[t[0]] = tokens.size
tokens << t
end
end
else
tokens = lexer.parse
end
end
$VERBOSE = verbose
tokens
ensure
$VERBOSE = verbose
end
def find_prev_spaces(line_index)
return 0 if @tokens.size == 0
md = @tokens[0][2].match(/(\A +)/)
prev_spaces = md.nil? ? 0 : md[1].count(' ')
line_count = 0
@tokens.each_with_index do |t, i|
if t[2].include?("\n")
line_count += t[2].count("\n")
if line_count >= line_index
return prev_spaces
end
if (@tokens.size - 1) > i
md = @tokens[i + 1][2].match(/(\A +)/)
prev_spaces = md.nil? ? 0 : md[1].count(' ')
end
end
end
prev_spaces
end
def set_auto_indent(context)
if @io.respond_to?(:auto_indent) and context.auto_indent_mode
@io.auto_indent do |lines, line_index, byte_pointer, is_newline|
if is_newline
md = lines[line_index - 1].match(/(\A +)/)
prev_spaces = md.nil? ? 0 : md[1].count(' ')
@tokens = ripper_lex_without_warning(lines[0..line_index].join("\n"))
prev_spaces = find_prev_spaces(line_index)
depth_difference = check_newline_depth_difference
depth_difference = 0 if depth_difference < 0
prev_spaces + depth_difference * 2
else
code = line_index.zero? ? '' : lines[0..(line_index - 1)].map{ |l| l + "\n" }.join
@ -360,14 +408,8 @@ class RubyLex
next if index > 0 and tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
case t[2]
when 'do'
if index > 0 and tokens[index - 1][3].anybits?(Ripper::EXPR_CMDARG | Ripper::EXPR_ENDFN | Ripper::EXPR_ARG)
# method_with_block do; end
indent += 1
else
# while cond do; end # also "until" or "for"
# This "do" doesn't increment indent because "while" already
# incremented.
end
syntax_of_do = take_corresponding_syntax_to_kw_do(tokens, index)
indent += 1 if syntax_of_do == :method_calling
when 'def', 'case', 'for', 'begin', 'class', 'module'
indent += 1
when 'if', 'unless', 'while', 'until'
@ -382,6 +424,40 @@ class RubyLex
indent
end
def take_corresponding_syntax_to_kw_do(tokens, index)
syntax_of_do = nil
# Finding a syntax correnponding to "do".
index.downto(0) do |i|
tk = tokens[i]
# In "continue", the token isn't the corresponding syntax to "do".
#is_continue = process_continue(@tokens[0..(i - 1)])
# continue ではなく、直前に (:on_ignored_nl|:on_nl|:on_comment):on_sp* みたいなのがあるかどうかを調べる
non_sp_index = tokens[0..(i - 1)].rindex{ |t| t[1] != :on_sp }
first_in_fomula = false
if non_sp_index.nil?
first_in_fomula = true
elsif [:on_ignored_nl, :on_nl, :on_comment].include?(tokens[non_sp_index][1])
first_in_fomula = true
end
if tk[3].anybits?(Ripper::EXPR_CMDARG) and tk[1] == :on_ident
# The target method call to pass the block with "do".
syntax_of_do = :method_calling
break if first_in_fomula
elsif tk[1] == :on_kw && %w{while until for}.include?(tk[2])
# A loop syntax in front of "do" found.
#
# while cond do # also "until" or "for"
# end
#
# This "do" doesn't increment indent because the loop syntax already
# incremented.
syntax_of_do = :loop_syntax
break if first_in_fomula
end
end
syntax_of_do
end
def check_newline_depth_difference
depth_difference = 0
open_brace_on_line = 0
@ -410,7 +486,7 @@ class RubyLex
case t[1]
when :on_ignored_nl, :on_nl, :on_comment
if index != (@tokens.size - 1)
if index != (@tokens.size - 1) and in_oneliner_def != :BODY
depth_difference = 0
open_brace_on_line = 0
end
@ -428,14 +504,8 @@ class RubyLex
next if index > 0 and @tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
case t[2]
when 'do'
if index > 0 and @tokens[index - 1][3].anybits?(Ripper::EXPR_CMDARG | Ripper::EXPR_ENDFN | Ripper::EXPR_ARG)
# method_with_block do; end
depth_difference += 1
else
# while cond do; end # also "until" or "for"
# This "do" doesn't increment indent because "while" already
# incremented.
end
syntax_of_do = take_corresponding_syntax_to_kw_do(@tokens, index)
depth_difference += 1 if syntax_of_do == :method_calling
when 'def', 'case', 'for', 'begin', 'class', 'module'
depth_difference += 1
when 'if', 'unless', 'while', 'until', 'rescue'
@ -445,6 +515,8 @@ class RubyLex
end
when 'else', 'elsif', 'ensure', 'when', 'in'
depth_difference += 1
when 'end'
depth_difference -= 1
end
end
end
@ -488,11 +560,13 @@ class RubyLex
case t[1]
when :on_ignored_nl, :on_nl, :on_comment
corresponding_token_depth = nil
spaces_at_line_head = 0
is_first_spaces_of_line = true
is_first_printable_of_line = true
open_brace_on_line = 0
if in_oneliner_def != :BODY
corresponding_token_depth = nil
spaces_at_line_head = 0
is_first_spaces_of_line = true
is_first_printable_of_line = true
open_brace_on_line = 0
end
next
when :on_sp
spaces_at_line_head = t[2].count(' ') if is_first_spaces_of_line
@ -514,7 +588,12 @@ class RubyLex
when :on_kw
next if index > 0 and @tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
case t[2]
when 'def', 'do', 'case', 'for', 'begin', 'class', 'module'
when 'do'
syntax_of_do = take_corresponding_syntax_to_kw_do(@tokens, index)
if syntax_of_do == :method_calling
spaces_of_nest.push(spaces_at_line_head)
end
when 'def', 'case', 'for', 'begin', 'class', 'module'
spaces_of_nest.push(spaces_at_line_head)
when 'rescue'
unless t[3].allbits?(Ripper::EXPR_LABEL)

4
lib/irb/version.rb
View file

@ -11,7 +11,7 @@
#
module IRB # :nodoc:
VERSION = "1.3.0"
VERSION = "1.3.2"
@RELEASE_VERSION = VERSION
@LAST_UPDATE_DATE = "2020-12-25"
@LAST_UPDATE_DATE = "2021-01-18"
end

1
lib/irb/workspace.rb
View file

@ -128,6 +128,7 @@ EOF
def filter_backtrace(bt)
return nil if bt =~ /\/irb\/.*\.rb/
return nil if bt =~ /\/irb\.rb/
return nil if bt =~ /tool\/lib\/.*\.rb|runner\.rb/ # for tests in Ruby repository
case IRB.conf[:CONTEXT_MODE]
when 1
return nil if bt =~ %r!/tmp/irb-binding!

12
lib/reline/config.rb
View file

@ -34,8 +34,8 @@ class Reline::Config
show-all-if-unmodified
visible-stats
show-mode-in-prompt
vi-cmd-mode-icon
vi-ins-mode-icon
vi-cmd-mode-string
vi-ins-mode-string
emacs-mode-string
enable-bracketed-paste
isearch-terminators
@ -56,8 +56,8 @@ class Reline::Config
@key_actors[:emacs] = Reline::KeyActor::Emacs.new
@key_actors[:vi_insert] = Reline::KeyActor::ViInsert.new
@key_actors[:vi_command] = Reline::KeyActor::ViCommand.new
@vi_cmd_mode_icon = '(cmd)'
@vi_ins_mode_icon = '(ins)'
@vi_cmd_mode_string = '(cmd)'
@vi_ins_mode_string = '(ins)'
@emacs_mode_string = '@'
# https://tiswww.case.edu/php/chet/readline/readline.html#IDX25
@history_size = -1 # unlimited
@ -270,9 +270,9 @@ class Reline::Config
@show_mode_in_prompt = false
end
when 'vi-cmd-mode-string'
@vi_cmd_mode_icon = retrieve_string(value)
@vi_cmd_mode_string = retrieve_string(value)
when 'vi-ins-mode-string'
@vi_ins_mode_icon = retrieve_string(value)
@vi_ins_mode_string = retrieve_string(value)
when 'emacs-mode-string'
@emacs_mode_string = retrieve_string(value)
when *VARIABLE_NAMES then

76
lib/reline/line_editor.rb
View file

@ -68,24 +68,24 @@ class Reline::LineEditor
end
end
private def check_mode_icon
mode_icon = nil
private def check_mode_string
mode_string = nil
if @config.show_mode_in_prompt
if @config.editing_mode_is?(:vi_command)
mode_icon = @config.vi_cmd_mode_icon
mode_string = @config.vi_cmd_mode_string
elsif @config.editing_mode_is?(:vi_insert)
mode_icon = @config.vi_ins_mode_icon
mode_string = @config.vi_ins_mode_string
elsif @config.editing_mode_is?(:emacs)
mode_icon = @config.emacs_mode_string
mode_string = @config.emacs_mode_string
else
mode_icon = '?'
mode_string = '?'
end
end
if mode_icon != @prev_mode_icon
if mode_string != @prev_mode_string
@rerender_all = true
end
@prev_mode_icon = mode_icon
mode_icon
@prev_mode_string = mode_string
mode_string
end
private def check_multiline_prompt(buffer, prompt)
@ -99,8 +99,8 @@ class Reline::LineEditor
prompt = @prompt
end
if simplified_rendering?
mode_icon = check_mode_icon
prompt = mode_icon + prompt if mode_icon
mode_string = check_mode_string
prompt = mode_string + prompt if mode_string
return [prompt, calculate_width(prompt, true), [prompt] * buffer.size]
end
if @prompt_proc
@ -112,6 +112,7 @@ class Reline::LineEditor
use_cached_prompt_list = true
end
end
use_cached_prompt_list = false if @rerender_all
if use_cached_prompt_list
prompt_list = @cached_prompt_list
else
@ -119,15 +120,21 @@ class Reline::LineEditor
@prompt_cache_time = Time.now.to_f
end
prompt_list.map!{ prompt } if @vi_arg or @searching_prompt
mode_icon = check_mode_icon
prompt_list = prompt_list.map{ |pr| mode_icon + pr } if mode_icon
mode_string = check_mode_string
prompt_list = prompt_list.map{ |pr| mode_string + pr } if mode_string
prompt = prompt_list[@line_index]
prompt = prompt_list[0] if prompt.nil?
prompt = prompt_list.last if prompt.nil?
if buffer.size > prompt_list.size
(buffer.size - prompt_list.size).times do
prompt_list << prompt_list.last
end
end
prompt_width = calculate_width(prompt, true)
[prompt, prompt_width, prompt_list]
else
mode_icon = check_mode_icon
prompt = mode_icon + prompt if mode_icon
mode_string = check_mode_string
prompt = mode_string + prompt if mode_string
prompt_width = calculate_width(prompt, true)
[prompt, prompt_width, nil]
end
@ -218,7 +225,7 @@ class Reline::LineEditor
@eof = false
@continuous_insertion_buffer = String.new(encoding: @encoding)
@scroll_partial_screen = nil
@prev_mode_icon = nil
@prev_mode_string = nil
@drop_terminate_spaces = false
reset_line
end
@ -370,6 +377,7 @@ class Reline::LineEditor
end
new_highest_in_this = calculate_height_by_width(prompt_width + calculate_width(@line.nil? ? '' : @line))
# FIXME: end of logical line sometimes breaks
rendered = false
if @add_newline_to_end_of_buffer
rerender_added_newline
@add_newline_to_end_of_buffer = false
@ -471,7 +479,7 @@ class Reline::LineEditor
calculate_height_by_lines(@buffer_of_lines[0..(@line_index - 1)], prompt_list || prompt)
end
first_line_diff = new_first_line_started_from - @first_line_started_from
new_cursor, _, new_started_from, _ = calculate_nearest_cursor(@line, @cursor, @started_from, @byte_pointer, false)
new_cursor, new_cursor_max, new_started_from, new_byte_pointer = calculate_nearest_cursor(@buffer_of_lines[@line_index], @cursor, @started_from, @byte_pointer, false)
new_started_from = calculate_height_by_width(prompt_width + new_cursor) - 1
calculate_scroll_partial_screen(@highest_in_all, new_first_line_started_from + new_started_from)
@previous_line_index = nil
@ -485,6 +493,8 @@ class Reline::LineEditor
@first_line_started_from = new_first_line_started_from
@started_from = new_started_from
@cursor = new_cursor
@cursor_max = new_cursor_max
@byte_pointer = new_byte_pointer
move_cursor_down(first_line_diff + @started_from)
Reline::IOGate.move_cursor_column((prompt_width + @cursor) % @screen_size.last)
false
@ -666,17 +676,13 @@ class Reline::LineEditor
Reline::IOGate.move_cursor_column(0)
if line.nil?
if calculate_width(visual_lines[index - 1], true) == Reline::IOGate.get_screen_size.last
# reaches the end of line
if Reline::IOGate.win?
# A newline is automatically inserted if a character is rendered at
# eol on command prompt.
else
# When the cursor is at the end of the line and erases characters
# after the cursor, some terminals delete the character at the
# cursor position.
move_cursor_down(1)
Reline::IOGate.move_cursor_column(0)
end
# Reaches the end of line.
#
# When the cursor is at the end of the line and erases characters
# after the cursor, some terminals delete the character at the
# cursor position.
move_cursor_down(1)
Reline::IOGate.move_cursor_column(0)
else
Reline::IOGate.erase_after_cursor
move_cursor_down(1)
@ -685,10 +691,6 @@ class Reline::LineEditor
next
end
@output.write line
if Reline::IOGate.win? and calculate_width(line, true) == Reline::IOGate.get_screen_size.last
# A newline is automatically inserted if a character is rendered at eol on command prompt.
@rest_height -= 1 if @rest_height > 0
end
@output.flush
if @first_prompt
@first_prompt = false
@ -1129,6 +1131,7 @@ class Reline::LineEditor
new_lines = whole_lines
end
new_indent = @auto_indent_proc.(new_lines, @line_index, @byte_pointer, @check_new_auto_indent)
new_indent = @cursor_max if new_indent&.> @cursor_max
if new_indent&.>= 0
md = new_lines[@line_index].match(/\A */)
prev_indent = md[0].count(' ')
@ -1329,7 +1332,7 @@ class Reline::LineEditor
cursor_line = @line.byteslice(0, @byte_pointer)
insert_new_line(cursor_line, next_line)
@cursor = 0
@check_new_auto_indent = true
@check_new_auto_indent = true unless Reline::IOGate.in_pasting?
end
end
@ -1722,7 +1725,7 @@ class Reline::LineEditor
@buffer_of_lines = Reline::HISTORY[@history_pointer].split("\n")
@buffer_of_lines = [String.new(encoding: @encoding)] if @buffer_of_lines.empty?
@line_index = line_no
@line = @buffer_of_lines.last
@line = @buffer_of_lines[@line_index]
@rerender_all = true
else
@line = Reline::HISTORY[@history_pointer]
@ -1770,7 +1773,7 @@ class Reline::LineEditor
@line_index = line_no
end
@buffer_of_lines = [String.new(encoding: @encoding)] if @buffer_of_lines.empty?
@line = @buffer_of_lines.last
@line = @buffer_of_lines[@line_index]
@rerender_all = true
else
if @history_pointer.nil? and substr.empty?
@ -2385,6 +2388,9 @@ class Reline::LineEditor
width = Reline::Unicode.get_mbchar_width(mbchar)
@cursor_max -= width
if @cursor > 0 and @cursor >= @cursor_max
byte_size = Reline::Unicode.get_prev_mbchar_size(@line, @byte_pointer)
mbchar = @line.byteslice(@byte_pointer - byte_size, byte_size)
width = Reline::Unicode.get_mbchar_width(mbchar)
@byte_pointer -= byte_size
@cursor -= width
end

2
lib/reline/reline.gemspec
View file

@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
spec.homepage = 'https://github.com/ruby/reline'
spec.license = 'Ruby'
spec.files = Dir['BSDL', 'COPYING', 'README.md', 'lib/**/*']
spec.files = Dir['BSDL', 'COPYING', 'README.md', 'license_of_rb-readline', 'lib/**/*']
spec.require_paths = ['lib']
spec.required_ruby_version = Gem::Requirement.new('>= 2.5')

2
lib/reline/version.rb
View file

@ -1,3 +1,3 @@
module Reline
VERSION = '0.2.0'
VERSION = '0.2.2'
end

1
lib/reline/windows.rb
View file

@ -258,6 +258,7 @@ class Reline::Windows
cursor = csbi[4, 4].unpack('L').first
written = 0.chr * 4
@@FillConsoleOutputCharacter.call(@@hConsoleHandle, 0x20, get_screen_size.last - cursor_pos.x, cursor, written)
@@FillConsoleOutputAttribute.call(@@hConsoleHandle, 0, get_screen_size.last - cursor_pos.x, cursor, written)
end
def self.scroll_down(val)

38
test/irb/test_color.rb
View file

@ -1,6 +1,7 @@
# frozen_string_literal: false
require 'test/unit'
require 'irb/color'
require 'irb/color_printer'
require 'rubygems'
require 'stringio'
@ -49,7 +50,7 @@ module TestIRB
'"#{}"' => "#{RED}#{BOLD}\"#{CLEAR}#{RED}\#{#{CLEAR}#{RED}}#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}",
':"a#{}b"' => "#{YELLOW}:\"#{CLEAR}#{YELLOW}a#{CLEAR}#{YELLOW}\#{#{CLEAR}#{YELLOW}}#{CLEAR}#{YELLOW}b#{CLEAR}#{YELLOW}\"#{CLEAR}",
':"a#{ def b; end; \'c\' + "#{ :d }" }e"' => "#{YELLOW}:\"#{CLEAR}#{YELLOW}a#{CLEAR}#{YELLOW}\#{#{CLEAR} #{GREEN}def#{CLEAR} #{BLUE}#{BOLD}b#{CLEAR}; #{GREEN}end#{CLEAR}; #{RED}#{BOLD}'#{CLEAR}#{RED}c#{CLEAR}#{RED}#{BOLD}'#{CLEAR} + #{RED}#{BOLD}\"#{CLEAR}#{RED}\#{#{CLEAR} #{YELLOW}:#{CLEAR}#{YELLOW}d#{CLEAR} #{RED}}#{CLEAR}#{RED}#{BOLD}\"#{CLEAR} #{YELLOW}}#{CLEAR}#{YELLOW}e#{CLEAR}#{YELLOW}\"#{CLEAR}",
"[__FILE__, __LINE__]" => "[#{CYAN}#{BOLD}__FILE__#{CLEAR}, #{CYAN}#{BOLD}__LINE__#{CLEAR}]",
"[__FILE__, __LINE__, __ENCODING__]" => "[#{CYAN}#{BOLD}__FILE__#{CLEAR}, #{CYAN}#{BOLD}__LINE__#{CLEAR}, #{CYAN}#{BOLD}__ENCODING__#{CLEAR}]",
":self" => "#{YELLOW}:#{CLEAR}#{YELLOW}self#{CLEAR}",
":class" => "#{YELLOW}:#{CLEAR}#{YELLOW}class#{CLEAR}",
"[:end, 2]" => "[#{YELLOW}:#{CLEAR}#{YELLOW}end#{CLEAR}, #{BLUE}#{BOLD}2#{CLEAR}]",
@ -82,9 +83,23 @@ module TestIRB
tests.merge!({
"[1]]]\u0013" => "[#{BLUE}#{BOLD}1#{CLEAR}]#{RED}#{REVERSE}]#{CLEAR}#{RED}#{REVERSE}]#{CLEAR}#{RED}#{REVERSE}^S#{CLEAR}",
})
tests.merge!({
"def req(true) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(#{RED}#{REVERSE}true#{CLEAR}) #{RED}#{REVERSE}end#{CLEAR}",
"nil = 1" => "#{RED}#{REVERSE}nil#{CLEAR} = #{BLUE}#{BOLD}1#{CLEAR}",
"alias $x $1" => "#{GREEN}alias#{CLEAR} #{GREEN}#{BOLD}$x#{CLEAR} #{RED}#{REVERSE}$1#{CLEAR}",
"class bad; end" => "#{GREEN}class#{CLEAR} #{RED}#{REVERSE}bad#{CLEAR}; #{GREEN}end#{CLEAR}",
"def req(@a) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(#{RED}#{REVERSE}@a#{CLEAR}) #{GREEN}end#{CLEAR}",
})
else
tests.merge!({
"[1]]]\u0013" => "[1]]]^S",
})
tests.merge!({
"def req(true) end" => "def req(true) end",
"nil = 1" => "#{CYAN}#{BOLD}nil#{CLEAR} = #{BLUE}#{BOLD}1#{CLEAR}",
"alias $x $1" => "#{GREEN}alias#{CLEAR} #{GREEN}#{BOLD}$x#{CLEAR} $1",
"class bad; end" => "#{GREEN}class#{CLEAR} bad; #{GREEN}end#{CLEAR}",
"def req(@a) end" => "#{GREEN}def#{CLEAR} #{BLUE}#{BOLD}req#{CLEAR}(@a) #{GREEN}end#{CLEAR}",
})
end
@ -138,6 +153,23 @@ module TestIRB
end
end
IRBTestColorPrinter = Struct.new(:a)
def test_color_printer
unless ripper_lexer_scan_supported?
skip 'Ripper::Lexer#scan is supported in Ruby 2.7+'
end
{
1 => "#{BLUE}#{BOLD}1#{CLEAR}\n",
IRBTestColorPrinter.new('test') => "#{GREEN}#<struct TestIRB::TestColor::IRBTestColorPrinter#{CLEAR} a#{GREEN}=#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}#{RED}test#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}#{GREEN}>#{CLEAR}\n",
Ripper::Lexer.new('1').scan => "[#{GREEN}#<Ripper::Lexer::Elem:#{CLEAR} on_int@1:0 END token: #{RED}#{BOLD}\"#{CLEAR}#{RED}1#{CLEAR}#{RED}#{BOLD}\"#{CLEAR}#{GREEN}>#{CLEAR}]\n",
Class.new{define_method(:pretty_print){|q| q.text("[__FILE__, __LINE__, __ENCODING__]")}}.new => "[#{CYAN}#{BOLD}__FILE__#{CLEAR}, #{CYAN}#{BOLD}__LINE__#{CLEAR}, #{CYAN}#{BOLD}__ENCODING__#{CLEAR}]\n",
}.each do |object, result|
actual = with_term { IRB::ColorPrinter.pp(object, '') }
assert_equal(result, actual, "Case: IRB::ColorPrinter.pp(#{object.inspect}, '')")
end
end
def test_inspect_colorable
{
1 => true,
@ -170,6 +202,10 @@ module TestIRB
Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
end
def ripper_lexer_scan_supported?
Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
end
def with_term
stdout = $stdout
io = StringIO.new

8
test/irb/test_completion.rb
View file

@ -47,5 +47,13 @@ module TestIRB
assert_include candidates, word
end
end
def test_complete_predicate?
candidates = IRB::InputCompletor.retrieve_completion_data("1.posi", bind: binding)
assert_include candidates, '1.positive?'
namespace = IRB::InputCompletor.retrieve_completion_data("1.positive?", bind: binding, doc_namespace: true)
assert_equal "Integer.positive?", namespace
end
end
end

169
test/irb/test_context.rb
View file

@ -83,6 +83,7 @@ module TestIRB
end
def test_eval_input
skip if RUBY_ENGINE == 'truffleruby'
verbose, $VERBOSE = $VERBOSE, nil
input = TestInputMethod.new([
"raise 'Foo'\n",
@ -95,7 +96,7 @@ module TestIRB
irb.eval_input
end
assert_empty err
assert_pattern_list([:*, /RuntimeError \(.*Foo.*\).*\n/,
assert_pattern_list([:*, /\(irb\):1:in `<main>': Foo \(RuntimeError\)\n/,
:*, /#<RuntimeError: Foo>\n/,
:*, /0$/,
:*, /0$/,
@ -104,17 +105,43 @@ module TestIRB
$VERBOSE = verbose
end
def test_eval_object_without_inspect_method
verbose, $VERBOSE = $VERBOSE, nil
def test_eval_input_raise2x
skip if RUBY_ENGINE == 'truffleruby'
input = TestInputMethod.new([
"BasicObject.new\n",
"raise 'Foo'\n",
"raise 'Bar'\n",
"_\n",
])
irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
out, err = capture_output do
irb.eval_input
end
assert_empty err
assert(/\(Object doesn't support #inspect\)\n(=> )?\n/, out)
assert_pattern_list([
:*, /\(irb\):1:in `<main>': Foo \(RuntimeError\)\n/,
:*, /\(irb\):2:in `<main>': Bar \(RuntimeError\)\n/,
:*, /#<RuntimeError: Bar>\n/,
], out)
end
def test_eval_object_without_inspect_method
verbose, $VERBOSE = $VERBOSE, nil
all_assertions do |all|
IRB::Inspector::INSPECTORS.invert.each_value do |mode|
all.for(mode) do
input = TestInputMethod.new([
"[BasicObject.new, Class.new]\n",
])
irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
irb.context.inspect_mode = mode
out, err = capture_output do
irb.eval_input
end
assert_empty err
assert_match(/\(Object doesn't support #inspect\)\n(=> )?\n/, out)
end
end
end
ensure
$VERBOSE = verbose
end
@ -234,7 +261,7 @@ module TestIRB
irb.eval_input
end
assert_empty err
assert_equal("=> #{value.inspect}\n", out)
assert_equal("=> \n#{value.pretty_inspect}", out)
input.reset
irb.context.echo = true
@ -243,7 +270,7 @@ module TestIRB
irb.eval_input
end
assert_empty err
assert_equal("=> #{value.inspect[0..(input.winsize.last - 9)]}...\e[0m\n=> #{value.inspect}\n", out)
assert_equal("=> \n#{value.pretty_inspect[0..3]}...\n=> \n#{value.pretty_inspect}", out)
input.reset
irb.context.echo = true
@ -252,7 +279,7 @@ module TestIRB
irb.eval_input
end
assert_empty err
assert_equal("=> #{value.inspect}\n=> #{value.inspect}\n", out)
assert_equal("=> \n#{value.pretty_inspect}=> \n#{value.pretty_inspect}", out)
input.reset
irb.context.echo = false
@ -408,5 +435,131 @@ module TestIRB
assert_equal("=> abc\ndef\n",
out)
end
def test_eval_input_with_exception
skip if RUBY_ENGINE == 'truffleruby'
verbose, $VERBOSE = $VERBOSE, nil
input = TestInputMethod.new([
"def hoge() fuga; end; def fuga() raise; end; hoge\n",
])
irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
out, err = capture_output do
irb.eval_input
end
assert_empty err
if '2.5.0' <= RUBY_VERSION && RUBY_VERSION < '3.0.0'
expected = [
:*, /Traceback \(most recent call last\):\n/,
:*, /\t 2: from \(irb\):1:in `<main>'\n/,
:*, /\t 1: from \(irb\):1:in `hoge'\n/,
:*, /\(irb\):1:in `fuga': unhandled exception\n/,
]
else
expected = [
:*, /\(irb\):1:in `fuga': unhandled exception\n/,
:*, /\tfrom \(irb\):1:in `hoge'\n/,
:*, /\tfrom \(irb\):1:in `<main>'\n/,
]
end
assert_pattern_list(expected, out)
ensure
$VERBOSE = verbose
end
def test_eval_input_with_invalid_byte_sequence_exception
skip if RUBY_ENGINE == 'truffleruby'
verbose, $VERBOSE = $VERBOSE, nil
input = TestInputMethod.new([
%Q{def hoge() fuga; end; def fuga() raise "A\\xF3B"; end; hoge\n},
])
irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
out, err = capture_output do
irb.eval_input
end
assert_empty err
if '2.5.0' <= RUBY_VERSION && RUBY_VERSION < '3.0.0'
expected = [
:*, /Traceback \(most recent call last\):\n/,
:*, /\t 2: from \(irb\):1:in `<main>'\n/,
:*, /\t 1: from \(irb\):1:in `hoge'\n/,
:*, /\(irb\):1:in `fuga': A\\xF3B \(RuntimeError\)\n/,
]
else
expected = [
:*, /\(irb\):1:in `fuga': A\\xF3B \(RuntimeError\)\n/,
:*, /\tfrom \(irb\):1:in `hoge'\n/,
:*, /\tfrom \(irb\):1:in `<main>'\n/,
]
end
assert_pattern_list(expected, out)
ensure
$VERBOSE = verbose
end
def test_eval_input_with_long_exception
skip if RUBY_ENGINE == 'truffleruby'
verbose, $VERBOSE = $VERBOSE, nil
nesting = 20
generated_code = ''
nesting.times do |i|
generated_code << "def a#{i}() a#{i + 1}; end; "
end
generated_code << "def a#{nesting}() raise; end; a0\n"
input = TestInputMethod.new([
generated_code
])
irb = IRB::Irb.new(IRB::WorkSpace.new(Object.new), input)
out, err = capture_output do
irb.eval_input
end
assert_empty err
if '2.5.0' <= RUBY_VERSION && RUBY_VERSION < '3.0.0'
expected = [
:*, /Traceback \(most recent call last\):\n/,
:*, /\t... 5 levels...\n/,
:*, /\t16: from \(irb\):1:in `a4'\n/,
:*, /\t15: from \(irb\):1:in `a5'\n/,
:*, /\t14: from \(irb\):1:in `a6'\n/,
:*, /\t13: from \(irb\):1:in `a7'\n/,
:*, /\t12: from \(irb\):1:in `a8'\n/,
:*, /\t11: from \(irb\):1:in `a9'\n/,
:*, /\t10: from \(irb\):1:in `a10'\n/,
:*, /\t 9: from \(irb\):1:in `a11'\n/,
:*, /\t 8: from \(irb\):1:in `a12'\n/,
:*, /\t 7: from \(irb\):1:in `a13'\n/,
:*, /\t 6: from \(irb\):1:in `a14'\n/,
:*, /\t 5: from \(irb\):1:in `a15'\n/,
:*, /\t 4: from \(irb\):1:in `a16'\n/,
:*, /\t 3: from \(irb\):1:in `a17'\n/,
:*, /\t 2: from \(irb\):1:in `a18'\n/,
:*, /\t 1: from \(irb\):1:in `a19'\n/,
:*, /\(irb\):1:in `a20': unhandled exception\n/,
]
else
expected = [
:*, /\(irb\):1:in `a20': unhandled exception\n/,
:*, /\tfrom \(irb\):1:in `a19'\n/,
:*, /\tfrom \(irb\):1:in `a18'\n/,
:*, /\tfrom \(irb\):1:in `a17'\n/,
:*, /\tfrom \(irb\):1:in `a16'\n/,
:*, /\tfrom \(irb\):1:in `a15'\n/,
:*, /\tfrom \(irb\):1:in `a14'\n/,
:*, /\tfrom \(irb\):1:in `a13'\n/,
:*, /\tfrom \(irb\):1:in `a12'\n/,
:*, /\tfrom \(irb\):1:in `a11'\n/,
:*, /\tfrom \(irb\):1:in `a10'\n/,
:*, /\tfrom \(irb\):1:in `a9'\n/,
:*, /\tfrom \(irb\):1:in `a8'\n/,
:*, /\tfrom \(irb\):1:in `a7'\n/,
:*, /\tfrom \(irb\):1:in `a6'\n/,
:*, /\tfrom \(irb\):1:in `a5'\n/,
:*, /\tfrom \(irb\):1:in `a4'\n/,
:*, /\t... 5 levels...\n/,
]
end
assert_pattern_list(expected, out)
ensure
$VERBOSE = verbose
end
end
end

4
test/irb/test_init.rb
View file

@ -21,6 +21,7 @@ module TestIRB
def test_rc_file
backup_irbrc = ENV.delete("IRBRC") # This is for RVM...
backup_xdg_config_home = ENV.delete("XDG_CONFIG_HOME")
backup_home = ENV["HOME"]
Dir.mktmpdir("test_irb_init_#{$$}") do |tmpdir|
ENV["HOME"] = tmpdir
@ -35,11 +36,13 @@ module TestIRB
end
ensure
ENV["HOME"] = backup_home
ENV["XDG_CONFIG_HOME"] = backup_xdg_config_home
ENV["IRBRC"] = backup_irbrc
end
def test_rc_file_in_subdir
backup_irbrc = ENV.delete("IRBRC") # This is for RVM...
backup_xdg_config_home = ENV.delete("XDG_CONFIG_HOME")
backup_home = ENV["HOME"]
Dir.mktmpdir("test_irb_init_#{$$}") do |tmpdir|
ENV["HOME"] = tmpdir
@ -57,6 +60,7 @@ module TestIRB
end
ensure
ENV["HOME"] = backup_home
ENV["XDG_CONFIG_HOME"] = backup_xdg_config_home
ENV["IRBRC"] = backup_irbrc
end

8
test/irb/test_raise_no_backtrace_exception.rb
View file

@ -13,5 +13,13 @@ module TestIRB
raise e
IRB
end
def test_raise_exception_with_invalid_byte_sequence
skip if RUBY_ENGINE == 'truffleruby'
bundle_exec = ENV.key?('BUNDLE_GEMFILE') ? ['-rbundler/setup'] : []
assert_in_out_err(bundle_exec + %w[-rirb -W0 -e IRB.start(__FILE__) -- -f --], <<~IRB, /A\\xF3B \(StandardError\)/, [])
raise StandardError, "A\\xf3B"
IRB
end
end
end

155
test/irb/test_ruby_lex.rb
View file

@ -263,6 +263,129 @@ module TestIRB
end
end
def test_corresponding_syntax_to_keyword_do_in_class
input_with_correct_indents = [
Row.new(%q(class C), nil, 2, 1),
Row.new(%q( while method_name do), nil, 4, 2),
Row.new(%q( 3), nil, 4, 2),
Row.new(%q( end), 2, 2, 1),
Row.new(%q( foo do), nil, 4, 2),
Row.new(%q( 3), nil, 4, 2),
Row.new(%q( end), 2, 2, 1),
Row.new(%q(end), 0, 0, 0),
]
lines = []
input_with_correct_indents.each do |row|
lines << row.content
assert_indenting(lines, row.current_line_spaces, false)
assert_indenting(lines, row.new_line_spaces, true)
assert_nesting_level(lines, row.nesting_level)
end
end
def test_corresponding_syntax_to_keyword_do
input_with_correct_indents = [
Row.new(%q(while i > 0), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(while true), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(while ->{i > 0}.call), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(while ->{true}.call), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(while i > 0 do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(while true do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(while ->{i > 0}.call do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(while ->{true}.call do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(foo do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(foo true do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(foo ->{true} do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
Row.new(%q(foo ->{i > 0} do), nil, 2, 1),
Row.new(%q( 3), nil, 2, 1),
Row.new(%q(end), 0, 0, 0),
]
lines = []
input_with_correct_indents.each do |row|
lines << row.content
assert_indenting(lines, row.current_line_spaces, false)
assert_indenting(lines, row.new_line_spaces, true)
assert_nesting_level(lines, row.nesting_level)
end
end
def test_heredoc_with_indent
input_with_correct_indents = [
Row.new(%q(<<~Q), nil, 0, 0),
Row.new(%q({), nil, 0, 0),
Row.new(%q( #), nil, 0, 0),
Row.new(%q(}), nil, 0, 0),
]
lines = []
input_with_correct_indents.each do |row|
lines << row.content
assert_indenting(lines, row.current_line_spaces, false)
assert_indenting(lines, row.new_line_spaces, true)
assert_nesting_level(lines, row.nesting_level)
end
end
def test_oneliner_def_in_multiple_lines
input_with_correct_indents = [
Row.new(%q(def a()=[), nil, 4, 2),
Row.new(%q( 1,), nil, 4, 1),
Row.new(%q(].), 0, 0, 0),
Row.new(%q(to_s), nil, 0, 0),
]
lines = []
input_with_correct_indents.each do |row|
lines << row.content
assert_indenting(lines, row.current_line_spaces, false)
assert_indenting(lines, row.new_line_spaces, true)
assert_nesting_level(lines, row.nesting_level)
end
end
def test_broken_heredoc
if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7.0')
skip 'This test needs Ripper::Lexer#scan to take broken tokens'
end
input_with_correct_indents = [
Row.new(%q(def foo), nil, 2, 1),
Row.new(%q( <<~Q), nil, 2, 1),
Row.new(%q( Qend), nil, 2, 1),
]
lines = []
input_with_correct_indents.each do |row|
lines << row.content
assert_indenting(lines, row.current_line_spaces, false)
assert_indenting(lines, row.new_line_spaces, true)
assert_nesting_level(lines, row.nesting_level)
end
end
PromptRow = Struct.new(:prompt, :content)
class MockIO_DynamicPrompt
@ -319,5 +442,37 @@ module TestIRB
expected_prompt_list = input_with_prompt.map(&:prompt)
assert_dynamic_prompt(lines, expected_prompt_list)
end
def test_broken_percent_literal
if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7.0')
skip 'This test needs Ripper::Lexer#scan to take broken tokens'
end
ruby_lex = RubyLex.new
tokens = ruby_lex.ripper_lex_without_warning('%wwww')
pos_to_index = {}
tokens.each_with_index { |t, i|
assert_nil(pos_to_index[t[0]], "There is already another token in the position of #{t.inspect}.")
pos_to_index[t[0]] = i
}
end
def test_broken_percent_literal_in_method
if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.7.0')
skip 'This test needs Ripper::Lexer#scan to take broken tokens'
end
ruby_lex = RubyLex.new
tokens = ruby_lex.ripper_lex_without_warning(<<~EOC.chomp)
def foo
%wwww
end
EOC
pos_to_index = {}
tokens.each_with_index { |t, i|
assert_nil(pos_to_index[t[0]], "There is already another token in the position of #{t.inspect}.")
pos_to_index[t[0]] = i
}
end
end
end

14
test/reline/helper.rb
View file

@ -96,4 +96,18 @@ class Reline::TestCase < Test::Unit::TestCase
def assert_cursor_max(expected)
assert_equal(expected, @line_editor.instance_variable_get(:@cursor_max))
end
def assert_line_index(expected)
assert_equal(expected, @line_editor.instance_variable_get(:@line_index))
end
def assert_whole_lines(expected)
previous_line_index = @line_editor.instance_variable_get(:@previous_line_index)
if previous_line_index
lines = @line_editor.whole_lines(index: previous_line_index)
else
lines = @line_editor.whole_lines
end
assert_equal(expected, lines)
end
end

47
test/reline/test_key_actor_emacs.rb
View file

@ -2233,6 +2233,53 @@ class Reline::KeyActor::Emacs::Test < Reline::TestCase
assert_line('def hoge')
end
def test_ed_search_prev_next_history_in_multibyte
Reline::HISTORY.concat([
"def hoge\n 67890\n 12345\nend", # old
"def aiu\n 0xDEADBEEF\nend",
"def foo\n 12345\nend" # new
])
@line_editor.multiline_on
input_keys(' 123')
# The ed_search_prev_history doesn't have default binding
@line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
assert_whole_lines(['def foo', ' 12345', 'end'])
assert_line_index(1)
assert_whole_lines(['def foo', ' 12345', 'end'])
assert_byte_pointer_size(' 123')
assert_cursor(5)
assert_cursor_max(7)
assert_line(' 12345')
@line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
assert_line_index(2)
assert_whole_lines(['def hoge', ' 67890', ' 12345', 'end'])
assert_byte_pointer_size(' 123')
assert_cursor(5)
assert_cursor_max(7)
assert_line(' 12345')
@line_editor.__send__(:ed_search_prev_history, "\C-p".ord)
assert_line_index(2)
assert_whole_lines(['def hoge', ' 67890', ' 12345', 'end'])
assert_byte_pointer_size(' 123')
assert_cursor(5)
assert_cursor_max(7)
assert_line(' 12345')
@line_editor.__send__(:ed_search_next_history, "\C-n".ord)
assert_line_index(1)
assert_whole_lines(['def foo', ' 12345', 'end'])
assert_byte_pointer_size(' 123')
assert_cursor(5)
assert_cursor_max(7)
assert_line(' 12345')
@line_editor.__send__(:ed_search_next_history, "\C-n".ord)
assert_line_index(1)
assert_whole_lines(['def foo', ' 12345', 'end'])
assert_byte_pointer_size(' 123')
assert_cursor(5)
assert_cursor_max(7)
assert_line(' 12345')
end
=begin # TODO: move KeyStroke instance from Reline to LineEditor
def test_key_delete
input_keys('ab')

18
test/reline/test_key_actor_vi.rb
View file

@ -1434,4 +1434,22 @@ class Reline::KeyActor::ViInsert::Test < Reline::TestCase
assert_cursor(4)
assert_cursor_max(4)
end
def test_ed_delete_next_char_at_eol
input_keys('"あ"')
assert_line('"あ"')
assert_byte_pointer_size('"あ"')
assert_cursor(4)
assert_cursor_max(4)
input_keys("\C-[")
assert_line('"あ"')
assert_byte_pointer_size('"あ')
assert_cursor(3)
assert_cursor_max(4)
input_keys('xa"')
assert_line('"あ"')
assert_byte_pointer_size('"あ"')
assert_cursor(4)
assert_cursor_max(4)
end
end

1
test/reline/test_within_pipe.rb
View file

@ -8,6 +8,7 @@ class Reline::WithinPipeTest < Reline::TestCase
@reader, @output_writer = IO.pipe((RELINE_TEST_ENCODING rescue Encoding.default_external))
@output = Reline.output = @output_writer
@config = Reline.send(:core).config
@config.keyseq_timeout *= 600 if defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? # for --jit-wait CI
@line_editor = Reline.send(:core).line_editor
end

76
test/reline/yamatanooroti/test_rendering.rb
View file

@ -14,14 +14,12 @@ begin
FileUtils.rm_rf(@tmpdir)
Dir.mkdir(@tmpdir)
end
Dir.chdir(@tmpdir)
@inputrc_backup = ENV['INPUTRC']
@inputrc_file = ENV['INPUTRC'] = File.join(@tmpdir, 'temporaty_inputrc')
File.unlink(@inputrc_file) if File.exist?(@inputrc_file)
end
def teardown
Dir.chdir(@pwd)
FileUtils.rm_rf(@tmpdir)
ENV['INPUTRC'] = @inputrc_backup
ENV.delete('RELINE_TEST_PROMPT') if ENV['RELINE_TEST_PROMPT']
@ -152,7 +150,7 @@ begin
EOC
end
def test_mode_icon_emacs
def test_mode_string_emacs
write_inputrc <<~LINES
set show-mode-in-prompt on
LINES
@ -164,7 +162,7 @@ begin
EOC
end
def test_mode_icon_vi
def test_mode_string_vi
write_inputrc <<~LINES
set editing-mode vi
set show-mode-in-prompt on
@ -180,7 +178,7 @@ begin
EOC
end
def test_original_mode_icon_emacs
def test_original_mode_string_emacs
write_inputrc <<~LINES
set show-mode-in-prompt on
set emacs-mode-string [emacs]
@ -193,7 +191,7 @@ begin
EOC
end
def test_original_mode_icon_with_quote
def test_original_mode_string_with_quote
write_inputrc <<~LINES
set show-mode-in-prompt on
set emacs-mode-string "[emacs]"
@ -206,7 +204,7 @@ begin
EOC
end
def test_original_mode_icon_vi
def test_original_mode_string_vi
write_inputrc <<~LINES
set editing-mode vi
set show-mode-in-prompt on
@ -224,7 +222,7 @@ begin
EOC
end
def test_mode_icon_vi_changing
def test_mode_string_vi_changing
write_inputrc <<~LINES
set editing-mode vi
set show-mode-in-prompt on
@ -450,6 +448,18 @@ begin
EOC
end
def test_broken_prompt_list
start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/bin/multiline_repl --broken-dynamic-prompt}, startup_message: 'Multiline REPL.')
write("def hoge\n 3\nend")
close
assert_screen(<<~EOC)
Multiline REPL.
[0000]> def hoge
[0001]> 3
[0001]> end
EOC
end
def test_enable_bracketed_paste
omit if Reline::IOGate.win?
write_inputrc <<~LINES
@ -515,6 +525,7 @@ begin
end
end
EOC
sleep 1
close
assert_screen(<<~EOC)
prompt> prompt
@ -561,6 +572,7 @@ begin
end
end
EOC
sleep 1
write("\C-p" * 6)
close
assert_screen(<<~EOC)
@ -608,7 +620,7 @@ begin
end
end
EOC
sleep 0.3
sleep 1
write("\C-p" * 5)
write("\C-n" * 3)
close
@ -620,6 +632,52 @@ begin
EOC
end
def test_update_cursor_correctly_when_just_cursor_moving
start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/bin/multiline_repl}, startup_message: 'Multiline REPL.')
write("def hoge\n 01234678")
write("\C-p")
write("\C-b")
write("\C-n")
write('5')
write("\C-e")
write('9')
close
assert_screen(<<~EOC)
Multiline REPL.
prompt> def hoge
prompt> 0123456789
EOC
end
def test_suppress_auto_indent_just_after_pasted
start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/bin/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
write("def hoge\n [[\n 3]]\ned")
write("\C-bn")
close
assert_screen(<<~EOC)
Multiline REPL.
prompt> def hoge
prompt> [[
prompt> 3]]
prompt> end
EOC
end
def test_suppress_auto_indent_for_adding_newlines_in_pasting
start_terminal(5, 30, %W{ruby -I#{@pwd}/lib #{@pwd}/bin/multiline_repl --auto-indent}, startup_message: 'Multiline REPL.')
write("<<~Q\n")
write("{\n #\n}")
write("#")
close
assert_screen(<<~EOC)
Multiline REPL.
prompt> <<~Q
prompt> {
prompt> #
prompt> }#
EOC
end
private def write_inputrc(content)
File.open(@inputrc_file, 'w') do |f|
f.write content