123456789_123456789_123456789_123456789_123456789_

Class: Warning::buffer

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::String
Instance Chain:
Inherits: String
Defined in: error.c

Class Method Summary

::String - Inherited

.new

Returns a new string object containing a copy of str.

.try_convert

Try to convert obj into a ::String, using to_str method.

Instance Attribute Summary

::String - Inherited

#ascii_only?

Returns true for a string which has only ASCII characters.

#empty?

Returns true if str has a length of zero.

#valid_encoding?

Returns true for a string which is encoded correctly.

Instance Method Summary

::String - Inherited

#%

Format—Uses str as a format specification, and returns the result of applying it to arg.

#*

Copy — Returns a new ::String containing integer copies of the receiver.

#+

Concatenation—Returns a new ::String containing other_str concatenated to str.

#+@

If the string is frozen, then return duplicated mutable string.

#-@

If the string is frozen, then return the string itself.

#<<

Appends the given object to str.

#<=>

Comparison—Returns -1, 0, +1, or nil depending on whether string is less than, equal to, or greater than other_string.

#==

Equality—Returns whether str == obj, similar to Object#==.

#===

Alias for String#==.

#=~

Match—If obj is a ::Regexp, use it as a pattern to match against str,and returns the position the match starts, or nil if there is no match.

#[]

Element Reference — If passed a single index, returns a substring of one character at that index.

#[]=

Element Assignment—Replaces some or all of the content of str.

#b

Returns a copied string whose encoding is ASCII-8BIT.

#bytes

Returns an array of bytes in str.

#bytesize

Returns the length of str in bytes.

#byteslice

Byte Reference—If passed a single ::Integer, returns a substring of one byte at that position.

#capitalize

Returns a copy of str with the first character converted to uppercase and the remainder to lowercase.

#capitalize!

Modifies str by converting the first character to uppercase and the remainder to lowercase.

#casecmp

Case-insensitive version of String#<=>.

#casecmp?

Returns true if str and other_str are equal after Unicode case folding, false if they are not equal.

#center

Centers str in width.

#chars

Returns an array of characters in str.

#chomp

Returns a new ::String with the given record separator removed from the end of str (if present).

#chomp!

Modifies str in place as described for String#chomp, returning str, or nil if no modifications were made.

#chop

Returns a new ::String with the last character removed.

#chop!

Processes str as for String#chop, returning str, or nil if str is the empty string.

#chr

Returns a one-character string at the beginning of the string.

#clear

Makes string empty.

#codepoints

Returns an array of the ::Integer ordinals of the characters in str.

#concat

Concatenates the given object(s) to str.

#count

Each other_str parameter defines a set of characters to count.

#crypt

Applies a one-way cryptographic hash to str by invoking the standard library function crypt(3) with the given salt string.

#delete

Returns a copy of str with all characters in the intersection of its arguments deleted.

#delete!

Performs a delete operation in place, returning str, or nil if str was not modified.

#delete_prefix

Returns a copy of str with leading prefix deleted.

#delete_prefix!

Deletes leading prefix from str, returning nil if no change was made.

#delete_suffix

Returns a copy of str with trailing suffix deleted.

#delete_suffix!

Deletes trailing suffix from str, returning nil if no change was made.

#downcase

Returns a copy of str with all uppercase letters replaced with their lowercase counterparts.

#downcase!

Downcases the contents of str, returning nil if no changes were made.

#dump

Produces a version of str with all non-printing characters replaced by \nnn notation and all special characters escaped.

#each_byte

Passes each byte in str to the given block, or returns an enumerator if no block is given.

#each_char

Passes each character in str to the given block, or returns an enumerator if no block is given.

#each_codepoint

Passes the ::Integer ordinal of each character in str, also known as a codepoint when applied to Unicode strings to the given block.

#each_grapheme_cluster

Passes each grapheme cluster in str to the given block, or returns an enumerator if no block is given.

#each_line

Splits str using the supplied parameter as the record separator ($/ by default), passing each substring in turn to the supplied block.

#encode

The first form returns a copy of str transcoded to encoding encoding.

#encode!

The first form transcodes the contents of str from str.encoding to encoding.

#encoding

Alias for Regexp#encoding.

#end_with?

Returns true if str ends with one of the suffixes given.

#eql?

Two strings are equal if they have the same length and content.

#force_encoding

Changes the encoding to encoding and returns self.

#freeze,
#getbyte

returns the indexth byte as an integer.

#grapheme_clusters

Returns an array of grapheme clusters in str.

#gsub

Returns a copy of str with all occurrences of pattern substituted for the second argument.

#gsub!

Performs the substitutions of String#gsub in place, returning str, or nil if no substitutions were performed.

#hash

Return a hash based on the string's length, content and encoding.

#hex

Treats leading characters from str as a string of hexadecimal digits (with an optional sign and an optional 0x) and returns the corresponding number.

#include?

Returns true if str contains the given string or character.

#index

Returns the index of the first occurrence of the given substring or pattern (regexp) in str.

#initialize_copy

Alias for String#replace.

#insert

Inserts other_str before the character at the given index, modifying str.

#inspect

Returns a printable version of str, surrounded by quote marks, with special characters escaped.

#intern

Returns the ::Symbol corresponding to str, creating the symbol if it did not previously exist.

#length

Returns the character length of str.

#lines

Returns an array of lines in str split using the supplied record separator ($/ by default).

#ljust

If integer is greater than the length of str, returns a new ::String of length integer with str left justified and padded with padstr; otherwise, returns str.

#lstrip

Returns a copy of str with leading whitespace removed.

#lstrip!

Removes leading whitespace from str, returning nil if no change was made.

#match

Converts pattern to a ::Regexp (if it isn't already one), then invokes its match method on str.

#match?

Converts pattern to a ::Regexp (if it isn't already one), then returns a true or false indicates whether the regexp is matched str or not without updating $~ and other related variables.

#next

Returns the successor to str.

#next!

Equivalent to String#succ, but modifies the receiver in place.

#oct

Treats leading characters of str as a string of octal digits (with an optional sign) and returns the corresponding number.

#ord

Return the ::Integer ordinal of a one-character string.

#partition

Searches sep or pattern (regexp) in the string and returns the part before it, the match, and the part after it.

#prepend

Prepend—Prepend the given strings to str.

#replace

Replaces the contents and taintedness of str with the corresponding values in other_str.

#reverse

Returns a new string with the characters from str in reverse order.

#reverse!

Reverses str in place.

#rindex

Returns the index of the last occurrence of the given substring or pattern (regexp) in str.

#rjust

If integer is greater than the length of str, returns a new ::String of length integer with str right justified and padded with padstr; otherwise, returns str.

#rpartition

Searches sep or pattern (regexp) in the string from the end of the string, and returns the part before it, the match, and the part after it.

#rstrip

Returns a copy of str with trailing whitespace removed.

#rstrip!

Removes trailing whitespace from str, returning nil if no change was made.

#scan

Both forms iterate through str, matching the pattern (which may be a ::Regexp or a ::String).

#scrub

If the string is invalid byte sequence then replace invalid bytes with given replacement character, else returns self.

#scrub!

If the string is invalid byte sequence then replace invalid bytes with given replacement character, else returns self.

#setbyte

modifies the indexth byte as integer.

#size

Alias for String#length.

#slice

Alias for String#[].

#slice!

Deletes the specified portion from str, and returns the portion deleted.

#split

Divides str into substrings based on a delimiter, returning an array of these substrings.

#squeeze

Builds a set of characters from the other_str parameter(s) using the procedure described for String#count.

#squeeze!

Squeezes str in place, returning either str, or nil if no changes were made.

#start_with?

Returns true if str starts with one of the prefixes given.

#strip

Returns a copy of str with leading and trailing whitespace removed.

#strip!

Removes leading and trailing whitespace from str.

#sub

Returns a copy of str with the first occurrence of pattern replaced by the second argument.

#sub!

Performs the same substitution as String#sub in-place.

#succ

Alias for String#next.

#succ!

Alias for String#next!.

#sum

Returns a basic n-bit checksum of the characters in str, where n is the optional ::Integer parameter, defaulting to 16.

#swapcase

Returns a copy of str with uppercase alphabetic characters converted to lowercase and lowercase characters converted to uppercase.

#swapcase!

Equivalent to String#swapcase, but modifies the receiver in place, returning str, or nil if no changes were made.

#to_c

Returns a complex which denotes the string form.

#to_f

Returns the result of interpreting leading characters in str as a floating point number.

#to_i

Returns the result of interpreting leading characters in str as an integer base base (between 2 and 36).

#to_r

Returns the result of interpreting leading characters in str as a rational.

#to_s

Returns self.

#to_str

Alias for String#to_s.

#to_sym

Alias for String#intern.

#tr

Returns a copy of str with the characters in from_str replaced by the corresponding characters in to_str.

#tr!

Translates str in place, using the same rules as String#tr.

#tr_s

Processes a copy of str as described under String#tr, then removes duplicate characters in regions that were affected by the translation.

#tr_s!

Performs String#tr_s processing on str in place, returning str, or nil if no changes were made.

#undump

Produces unescaped version of str.

#unicode_normalize

Unicode Normalization—Returns a normalized form of str, using Unicode normalizations NFC, NFD, NFKC, or NFKD.

#unicode_normalize!

Destructive version of String#unicode_normalize, doing Unicode normalization in place.

#unicode_normalized?

Checks whether str is in Unicode normalization form form, which can be any of the four values :nfc, :nfd, :nfkc, or :nfkd.

#unpack

Decodes str (which may contain binary data) according to the format string, returning an array of each value extracted.

#unpack1

Decodes str (which may contain binary data) according to the format string, returning the first value extracted.

#upcase

Returns a copy of str with all lowercase letters replaced with their uppercase counterparts.

#upcase!

Upcases the contents of str, returning nil if no changes were made.

#upto

Iterates through successive values, starting at str and ending at other_str inclusive, passing each value in turn to the block.

::Comparable - Included

#<

Compares two objects based on the receiver's <=> method, returning true if it returns -1.

#<=

Compares two objects based on the receiver's <=> method, returning true if it returns -1 or 0.

#==

Compares two objects based on the receiver's <=> method, returning true if it returns 0.

#>

Compares two objects based on the receiver's <=> method, returning true if it returns 1.

#>=

Compares two objects based on the receiver's <=> method, returning true if it returns 0 or 1.

#between?

Returns false if obj <=> min is less than zero or if anObject <=> max is greater than zero, true otherwise.

#clamp

Returns min if obj <=> min is less than zero, max if obj <=> max is greater than zero and obj otherwise.

Constructor Details

This class inherits a constructor from String

Instance Method Details

#write(*args)

[ GitHub ]

  
# File 'error.c', line 300

static VALUE
warning_write(int argc, VALUE *argv, VALUE buf)
{
    while (argc-- > 0) {
	rb_str_append(buf, *argv++);
    }
    return buf;
}