Display a warning on stderr. Will ask question if it is not nil.
Display an error message in a location expected to get error messages. Will ask question if it is not nil.
A neighbor is code that is at or above the current indent line.
First we build a block with all neighbors. If we can’t go further then we decrease the indentation threshold and expand via indentation i.e. ‘expand_indent`
Handles two general cases.
## Case #1: Check code inside of methods/classes/etc.
It’s important to note, that not everything in a given indentation level can be parsed as valid code even if it’s part of valid code. For example:
1 hash = {
2 name: "richard",
3 dog: "cinco",
4 }
In this case lines 2 and 3 will be neighbors, but they’re invalid until ‘expand_indent` is called on them.
When we are adding code within a method or class (at the same indentation level), use the empty lines to denote the programmer intended logical chunks. Stop and check each one. For example:
1 def dog
2 print "dog"
3
4 hash = {
5 end
If we did not stop parsing at empty newlines then the block might mistakenly grab all the contents (lines 2, 3, and 4) and report them as being problems, instead of only line 4.
## Case #2: Expand/grab other logical blocks
Once the search algorithm has converted all lines into blocks at a given indentation it will then ‘expand_indent`. Once the blocks that generates are expanded as neighbors we then begin seeing neighbors being other logical blocks i.e. a block’s neighbors may be another method or class (something with keywords/ends).
For example:
1 def bark 2 3 end 4 5 def sit 6 end
In this case if lines 4, 5, and 6 are in a block when it tries to expand neighbors it will expand up. If it stops after line 2 or 3 it may cause problems since there’s a valid kw/end pair, but the block will be checked without it.
We try to resolve this edge case with ‘lookahead_balance_one_line` below.
Given an already existing block in the frontier, expand it to see if it contains our invalid syntax
Opening characters like ‘{` need closing characters # like `}`.
When a mis-match count is detected, suggest the missing member.
For example if there are 3 ‘}` and only two `{` return `“{”`
do nothing
Checks the user and password.
If password is not provided, then user is split, using URI::Generic.split_userinfo, to pull user and +password.
See also URI::Generic.check_user, URI::Generic.check_password.
Checks the user v component for RFC2396 compliance and against the URI::Parser Regexp for :USERINFO.
Can not have a registry or opaque component defined, with a user component defined.
Protected setter for the password component v.
See also URI::Generic.password=.
Returns the userinfo ui as [user, password] if properly formatted as ‘user:password’.
Returns the user component after URI decoding.
Checks the opaque v component for RFC2396 compliance and against the URI::Parser Regexp for :OPAQUE.
Can not have a host, port, user, or path component defined, with an opaque component defined.
Merges a base path base, with relative path rel, returns a modified base path.
Private setter for scope val.
Private setter for filter val.
Invoked by IO.select to ask whether the specified descriptors are ready for specified events within the specified timeout.
Expected to return the 3-tuple of Array of IOs that are ready.
Invoked by Timeout.timeout to execute the given block within the given duration. It can also be invoked directly by the scheduler or user code.
Attempt to limit the execution time of a given block to the given duration if possible. When a non-blocking operation causes the block‘s execution time to exceed the specified duration, that non-blocking operation should be interrupted by raising the specified exception_class constructed with the given exception_arguments.
General execution timeouts are often considered risky. This implementation will only interrupt non-blocking operations. This is by design because it’s expected that non-blocking operations can fail for a variety of unpredictable reasons, so applications should already be robust in handling these conditions and by implication timeouts.
However, as a result of this design, if the block does not invoke any non-blocking operations, it will be impossible to interrupt it. If you desire to provide predictable points for timeouts, consider adding +sleep(0)+.
If the block is executed successfully, its result will be returned.
The exception will typically be raised using Fiber#raise.
Returns the one-character string which cause Encoding::UndefinedConversionError.
ec = Encoding::Converter.new("ISO-8859-1", "EUC-JP") begin ec.convert("\xa0") rescue Encoding::UndefinedConversionError puts $!.error_char.dump #=> "\xC2\xA0" p $!.error_char.encoding #=> #<Encoding:UTF-8> end
primitive_errinfo returns important information regarding the last error as a 5-element array:
[result, enc1, enc2, error_bytes, readagain_bytes]
result is the last result of primitive_convert.
Other elements are only meaningful when result is :invalid_byte_sequence, :incomplete_input or :undefined_conversion.
enc1 and enc2 indicate a conversion step as a pair of strings. For example, a converter from EUC-JP to ISO-8859-1 converts a string as follows: EUC-JP -> UTF-8 -> ISO-8859-1. So [enc1, enc2] is either [“EUC-JP”, “UTF-8”] or [“UTF-8”, “ISO-8859-1”].
error_bytes and readagain_bytes indicate the byte sequences which caused the error. error_bytes is discarded portion. readagain_bytes is buffered portion which is read again on next conversion.
Example:
# \xff is invalid as EUC-JP. ec = Encoding::Converter.new("EUC-JP", "Shift_JIS") ec.primitive_convert(src="\xff", dst="", nil, 10) p ec.primitive_errinfo #=> [:invalid_byte_sequence, "EUC-JP", "Shift_JIS", "\xFF", ""] # HIRAGANA LETTER A (\xa4\xa2 in EUC-JP) is not representable in ISO-8859-1. # Since this error is occur in UTF-8 to ISO-8859-1 conversion, # error_bytes is HIRAGANA LETTER A in UTF-8 (\xE3\x81\x82). ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ec.primitive_convert(src="\xa4\xa2", dst="", nil, 10) p ec.primitive_errinfo #=> [:undefined_conversion, "UTF-8", "ISO-8859-1", "\xE3\x81\x82", ""] # partial character is invalid ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ec.primitive_convert(src="\xa4", dst="", nil, 10) p ec.primitive_errinfo #=> [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""] # Encoding::Converter::PARTIAL_INPUT prevents invalid errors by # partial characters. ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") ec.primitive_convert(src="\xa4", dst="", nil, 10, Encoding::Converter::PARTIAL_INPUT) p ec.primitive_errinfo #=> [:source_buffer_empty, nil, nil, nil, nil] # \xd8\x00\x00@ is invalid as UTF-16BE because # no low surrogate after high surrogate (\xd8\x00). # It is detected by 3rd byte (\00) which is part of next character. # So the high surrogate (\xd8\x00) is discarded and # the 3rd byte is read again later. # Since the byte is buffered in ec, it is dropped from src. ec = Encoding::Converter.new("UTF-16BE", "UTF-8") ec.primitive_convert(src="\xd8\x00\x00@", dst="", nil, 10) p ec.primitive_errinfo #=> [:invalid_byte_sequence, "UTF-16BE", "UTF-8", "\xD8\x00", "\x00"] p src #=> "@" # Similar to UTF-16BE, \x00\xd8@\x00 is invalid as UTF-16LE. # The problem is detected by 4th byte. ec = Encoding::Converter.new("UTF-16LE", "UTF-8") ec.primitive_convert(src="\x00\xd8@\x00", dst="", nil, 10) p ec.primitive_errinfo #=> [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "@\x00"] p src #=> ""