Methods
% (Quaternion)
* (FileList)
* (Units::Unit)
* (Quaternion)
** (Quaternion)
** (Units::Unit)
+ (Quaternion)
+ (BuilderObject)
+ (REXMLBuilder)
+@ (Interval)
- (Quaternion)
-@ (Interval)
/ (Units::Unit)
/ (Quaternion)
<< (DebugSocket)
<< (StateParser::Marker)
<< (Dictionary)
<< (REXMLBuilder)
<< (SSLSocketWrap)
<< (Tuple)
<=> (NilClass)
<=> (Quaternion)
<=> (Association)
<=> (Tuple)
== (FileList)
== (Lisp::DottedPair)
== (OpenObject)
== (NackClass)
== (Dictionary)
== (Quaternion)
== (Units::Unit)
=== (TracePoint)
=== (Interval)
=~ (Tuple)
>> (Kernel)
Mock (lib/facets/more/mock.rb)
Quaternion (lib/facets/more/quaternion.rb)
[] (Interval)
[] (Tuple)
[] (FloatString)
[] (HTTP::Message::Headers)
[] (NullClass)
[] (LRUCache)
[] (Tuple)
[] (Coroutine)
[] (FileList)
[] (Lisp::DottedPair)
[] (SyncHash::Delegator)
[] (Dictionary)
[] (SyncHash::Inheritor)
[] (Association)
[] (Annotation)
[] (OpenObject)
[]= (SyncHash::Inheritor)
[]= (OpenObject)
[]= (FloatString)
[]= (SyncHash::Delegator)
[]= (StaticHash)
[]= (Tuple)
[]= (HTTP::Message::Headers)
[]= (LRUCache)
[]= (Coroutine)
[]= (Dictionary)
__as__ (BasicObject)
__call__ (Recorder)
__fetch__ (OpenObject)
__key__? (OpenObject)
__keys__ (OpenObject)
__merge__ (OpenObject)
__parent__ (OpenCascade)
__parent__= (OpenCascade)
__self__ (BasicObject)
__store__ (OpenObject)
__table__ (OpenObject)
__update__ (OpenObject)
__value__ (Reference)
abs (Quaternion)
abs2 (Quaternion)
accumulate (Lisp)
acos (Quaternion)
active (TracePoint)
active= (TracePoint)
add (Web::CookieManager)
add (FileList)
add (Snapshot)
add_matching (FileList)
add_mirror (Downloader)
add_mirrors (Downloader)
add_tag (RubyTals)
addr (SSLSocketWrap)
after (Aspects::ClassMethods)
after (Numeric)
ago (Numeric)
ago (Time)
all? (Lisp)
amplitude (Quaternion)
ann (Module)
ann ()
annotated? (Module)
annotated_methods (Module)
annotation ()
annotation (Module)
ansi (BBCode)
ansi_to_bbcode (BBCode)
ansi_to_html (BBCode)
append (Lisp)
append_features (Module)
append_features (Aspects)
append_features (Multiton)
arg1 (Quaternion)
arg2 (Quaternion)
arg3 (Quaternion)
argf (System)
argv (System)
around (Aspects::ClassMethods)
asin (Quaternion)
assoc (Lisp)
associations (Kernel)
at_beginning_of_day (Time)
at_beginning_of_month (Time)
at_beginning_of_week (Time)
at_beginning_of_year (Time)
at_midnight (Time)
atan (Quaternion)
atom? (Lisp)
attlist! (REXMLBuilder::REXMLUtil)
attlist! (XMLHelper)
atto (Numeric)
attr (Module)
auto (Dictionary)
back (TracePoint)
bar (Console::ProgressBar)
bar_mark= (Console::ProgressBar)
base (Units::Converter::ExchangeRate::XMethods)
bbcode_to_ansi (BBCode)
bbcode_to_html (BBCode)
become (Reference)
before (Numeric)
before (Aspects::ClassMethods)
begin (Interval)
beginning_of_day (Time)
beginning_of_month (Time)
beginning_of_week (Time)
beginning_of_year (Time)
big? (BinaryReader::ByteOrder)
big_endian? (BinaryReader::ByteOrder)
bind (TracePoint)
bit (Numeric)
bit (Numeric)
bit? (Integer)
bit_set? (Integer)
bitmask (Kernel)
bitmask? (Integer)
bits (Numeric)
bits (Numeric)
blank (FloatString)
body (HTTP::Message)
body= (HTTP::Message)
body_size= (HTTP::Message::Headers)
build (HashBuilder)
build (HashBuilder)
builder (BuilderObject)
builder (REXMLBuilder)
builder (BuilderObject)
builder_include (BuilderObject)
byte (Numeric)
byte (Numeric)
byte_order (BinaryReader::ByteOrder)
byte_order (BinaryReader)
byte_order= (BinaryReader)
byteorder (BinaryReader::ByteOrder)
byteorder (BinaryReader)
byteorder= (BinaryReader)
bytes (Numeric)
bytes (Console::ProgressBar)
bytes (Numeric)
calculate_exclude_regexp (FileList)
call (Task)
call (NackClass)
call_with_data (NackClass)
called (TracePoint)
callee (TracePoint)
car (Lisp)
cast_from (Symbol)
cast_from (Object)
cast_from (Integer)
cast_from (Array)
cast_from (String)
cast_from (Float)
cast_from_array (Tuple)
cast_from_string (Tuple)
cast_to (Object)
cdata (XMLHelper)
cdata (REXMLBuilder::REXMLUtil)
cdr (Lisp)
centi (Numeric)
check (Crypt)
check_cookie_accept_domain (Web::CookieManager)
check_expired_cookies (Web::CookieManager)
check_mask (SSLSocketWrap)
check_units (Units::Unit)
child_status (System)
class_inherit (Module)
class_methods (Module)
class_name (ORMSupport)
classify (ORMSupport)
classname (ORMSupport)
clean_eval (Units::Converter)
clear (SyncHash::Delegator)
clear (LRUCache)
clear (PQueue)
clear (SyncHash::Inheritor)
clear (Dictionary)
clear_bit (Integer)
clear_bitmask (Integer)
clear_current (StateParser::State)
clear_exclude (FileList)
clear_ignore_patterns (FileList)
clear_line (Console::ANSICode)
clear_screen (Console::ANSICode)
clone (PQueue)
clone (FileList)
clone (Cloneable)
close (DebugSocket)
close (SSLSocketWrap)
closed (Interval)
closed? (SSLSocketWrap)
clr (Console::ANSICode)
cls (Console::ANSICode)
cmp (Heap::Min)
cmp (NilClass)
cmp (Heap::Max)
cmp_idx (Heap)
coding (System)
coding= (System)
coerce (Quaternion)
collect (TagIterator)
colors (Console::ANSICode)
comment (XMLHelper)
comment (REXMLBuilder::REXMLUtil)
compatible_with? (Units::Unit)
compile (RubyTals)
complete (Task)
compute_checksum (Downloader)
conjugate (Quaternion)
conn_request (Client)
connect_timeout (Client)
connect_timeout= (Client)
cons (Lisp)
consonto (Lisp)
constraint_to_lambda (Tuple)
content (HTTP::Message)
content (HTTP::Message::Body)
contenttype (HTTP::Message::Headers)
contenttype (HTTP::Message)
contenttype= (HTTP::Message::Headers)
contenttype= (HTTP::Message)
continue (Coroutine)
conversions (Units::Converter)
convert_bytes (Console::ProgressBar)
convert_conversion (Units::Converter)
converter (Units::Converter)
converter (Units::Value)
converters (Units::Converter)
cookie_error (Web::CookieManager)
cos (Quaternion)
cosh (Quaternion)
country_mapping (Units::Converter::ExchangeRate::XMethods)
create_query_multipart_str (HTTP::Message)
create_query_part_str (HTTP::Message)
create_query_uri (HTTP::Message::Headers)
create_request (Client)
create_socket (DebugSocket)
create_ssl_socket (SSLSocketWrap)
cross_product (Quaternion)
crypt (Crypt)
current (Units::Converter)
current_begins (StateParser::State)
current_ends (StateParser::State)
current_info (StateParser::State)
current_match (StateParser::State)
current_token (StateParser::State)
data (Units::Converter::ExchangeRate::CachedXMethods)
data (System)
data (Units::Converter::ExchangeRate::XMethods)
day (Numeric)
days (Numeric)
debug (System)
debug_dev (Client)
debug_dev= (Client)
deci (Numeric)
decode_conversion (Units::Converter)
default_input (System)
default_key (ORMSupport)
default_output (System)
default_output= (System)
default_redirect_uri_callback (Client)
default_system (ORMSupport)
defin (System)
define_annotation (Module)
define_ansicolor_method (Console::ANSICode)
defout (System)
defout= (System)
defuse (Timer)
degenerate? (Interval)
deka (Numeric)
delete (Client)
delete (SyncHash::Delegator)
delete (LRUCache)
delete (SyncHash::Inheritor)
delete (Dictionary)
delete_async (Client)
delete_if (Dictionary)
demand (Kernel)
desc (Taskable)
desc! (Taskable)
described_tasks (Taskable)
detect (EnumerablePass)
direction (Interval)
discard? (Web::Cookie)
display (Console::ANSICode)
distance (Interval)
divider (Tuple)
divmod (Quaternion)
divmod_D4 (Quaternion)
do_additive_op (Units::Value)
do_get_block (Client)
do_get_header (Client)
do_get_stream (Client)
do_multiplicative_op (Units::Value)
do_op (Units::Unit)
doctype! (REXMLBuilder::REXMLUtil)
doctype! (XMLHelper)
document (XMLHelper)
document (REXMLBuilder::REXMLUtil)
domain_match (Web::CookieUtils)
domain_orig? (Web::Cookie)
dot_product (Quaternion)
down (Semaphore)
down (Console::ANSICode)
downheap (PQueue)
download (Downloader)
driver (Units::Converter::ExchangeRate::XMethods)
drop (Lisp)
duckcall (Method::Probe)
dump (XOXO)
dump (HTTP::Message::Body)
dump (HTTP::Message::Headers)
dump (HTTP::Message)
dump_chunk (HTTP::Message::Body)
dump_chunk_size (HTTP::Message::Body)
dump_dummy_request_response (Client)
dump_last_chunk (HTTP::Message::Body)
dump_line (HTTP::Message::Headers)
dup (FileList)
dup (Dictionary)
dup (Cloneable)
each (Dictionary)
each (Interval)
each (Elementor)
each (StateParser::Marker)
each (OpenObject)
each (Task)
each (Lisp::DottedPair)
each (Tuple)
each_block (TagIterator)
each_index (Tuple)
each_key (Dictionary)
each_pair (Dictionary)
each_pop (PQueue)
each_value (Dictionary)
each_with_index (PQueue)
echo (Mock)
egrep (FileList)
elapsed (Console::ProgressBar)
element (REXMLBuilder::REXMLUtil)
element (XMLHelper)
element! (XMLHelper)
element! (REXMLBuilder::REXMLUtil)
empty (FloatString)
empty? (StateParser::Marker)
empty? (PQueue)
empty? (Tuple)
end (Interval)
end_trigger (StateParser::State)
entity! (XMLHelper)
entity! (REXMLBuilder::REXMLUtil)
enumcollect (TagIterator)
enumtag (TagIterator)
env (System)
environment (System)
eof? (SSLSocketWrap)
eol (Console::ProgressBar)
eql? (Tuple)
eql? (Interval)
equal? (Lisp)
error_info (System)
error_position (System)
esc (HTMLHelper)
escape (HTTP::Message)
escape_query (HTTP::Message)
escformat (HTMLHelper)
eta (Console::ProgressBar)
event? (TracePoint)
event_map (TracePoint)
eventless? (TracePoint)
every (Array)
every! (Array)
exa (Numeric)
exbi (Numeric)
exclude (FileList)
exclude? (FileList)
exclude_begin? (Interval)
exclude_end? (Interval)
exclude_first? (Interval)
exclude_last? (Interval)
exclusive (Semaphore)
execute (Console::Command)
execute (Console::Command)
execute (RubyTals)
execute_directives (Lisp::Format)
exists? (Lisp)
exit_status (System)
exp (Quaternion)
expired? (Expirable)
expires_after (Expirable)
expires_spread (Expirable)
explode (Lisp)
ext (FileList)
extend (Module)
extentions (System)
extract (Downloader)
extract_data (Units::Converter)
femto (Numeric)
fetch (Downloader)
file_transfer_mode (Console::ProgressBar)
fill (FloatString)
filter (Lisp)
find (EnumerablePass)
find (Web::CookieManager)
find (PathList::Finder)
find_closeenumtag (TagIterator)
find_closetag (TagIterator)
find_cookie_info (Web::CookieManager)
find_element (TagIterator)
find_openenumtag (TagIterator)
find_opentag (TagIterator)
findclass (ORMSupport)
finish (StateMachine)
finish (Console::ProgressBar)
first (Interval)
first (Tuple)
first (TagIterator)
first (LRUCache)
first_closed (Interval)
first_opened (Interval)
flag (Web::Cookie)
flush (StateMachine)
flush (SSLSocketWrap)
foldleft (Lisp)
foldright (Lisp)
for_this (TagIterator)
foreign_key (ORMSupport)
forget (JSON::State)
format (Lisp)
format (Lisp)
format= (Console::ProgressBar)
format_arguments= (Console::ProgressBar)
format_time (Console::ProgressBar)
fortnight (Numeric)
fortnights (Numeric)
from_now (Numeric)
from_state (JSON::State)
from_string (Time)
from_string (Class)
from_yaml (Units::Converter)
fs (System)
fs= (System)
future (Kernel)
gcd (Quaternion)
generate_salt (Crypt)
generic? (Quaternion)
get (Client)
get (HTTP::Message::Headers)
get_async (Client)
get_content (Client)
get_first (TagIterator)
get_nth (TagIterator)
get_rate (Units::Converter::ExchangeRate::XMethods)
get_rate (Units::Converter::ExchangeRate)
get_rate (Units::Converter::ExchangeRate::CachedXMethods)
get_width (Console::ProgressBar)
gets (SSLSocketWrap)
gets (DebugSocket)
gibi (Numeric)
giga (Numeric)
gsub (FileList)
gsub! (FileList)
half_closed (Interval)
halt (Console::ProgressBar)
hash (Quaternion)
hash (Tuple)
head (Client)
head_async (Client)
head_match? (Web::CookieUtils)
header (HTTP::Message)
header= (HTTP::Message)
heapify (Heap)
hecto (Numeric)
hide (BasicObject)
hour (Numeric)
hours (Numeric)
html_to_ansi (BBCode)
html_to_bbcode (BBCode)
http_date (HTTP)
image (Quaternion)
implode (Lisp)
import (FileList)
in (Time)
in_day_range? (Time)
inc (Console::ProgressBar)
include (FileList)
include (Module)
include? (Interval)
include? (PathList::Finder)
include_advice_modules (Aspects)
index (Tuple)
inheritance (Annotation)
inherited (Heap)
inherited (Uninheritable)
inheritor (Object)
inherits (Annotation)
init_request (HTTP::Message::Headers)
init_response (HTTP::Message::Headers)
initialize_copy (Method::Probe)
initialize_copy (OpenObject)
inner_append (FloatString)
inner_insert (FloatString)
input_field_separator (System)
input_field_separator= (System)
input_line_number (System)
input_lineno (System)
input_record_separator (System)
input_record_separator= (System)
insert (Dictionary)
inspect (NullClass)
inspect (Console::ProgressBar)
inspect (Units::Unit)
inspect (Recorder)
inspect (OpenObject)
inspect (Lisp::DottedPair)
inspect (Dictionary)
inspect (Association)
inspect (Quaternion)
inspect (Units::Value)
inspect (Tuple)
instance_function (Functor)
instance_map (Task::Graph)
instance_objects (Functor)
instance_self (Functor)
instance_targets (Functor)
instance_task (Taskable)
instance_tasks (Taskable)
instruct (XMLHelper)
instruct (REXMLBuilder::REXMLUtil)
instruction (REXMLBuilder::REXMLUtil)
instruction (XMLHelper)
interface (Downloader)
interface= (Downloader)
internal_size (Heap)
inverse (Quaternion)
invert (Dictionary)
invert! (Association)
is_complex? (Quaternion)
is_quaternion? (Quaternion)
is_real? (Quaternion)
is_unit_vector? (Quaternion)
is_vector? (Quaternion)
j (Kernel)
jj (Kernel)
join_quotedstr (Web::Cookie)
json_check_circular (Hash)
json_check_circular (Array)
json_creatable? (Class)
json_create (String)
json_shift (Array)
json_shift (Hash)
json_transform (Array)
json_transform (Hash)
keep_alive_enabled? (HTTP)
key_auto (Dictionary)
key_name (ORMSupport)
key_new (Dictionary)
keyname (ORMSupport)
keys (SyncHash::Inheritor)
keys (SyncHash::Delegator)
keys (Dictionary)
keys (Mock)
kibi (Numeric)
kilo (Numeric)
last (StateParser::Marker)
last (Tuple)
last (LRUCache)
last (Interval)
last_closed (Interval)
last_month (Time)
last_opened (Interval)
last_year (Time)
later (Numeric)
latitude (Quaternion)
ldiv (Quaternion)
ldivmod (Quaternion)
ldivmod_D4 (Quaternion)
left (Console::ANSICode)
left (Heap)
length (Lisp)
length (Tuple)
length (Interval)
limit (Timer)
line_end_processing (System)
link (Lisp)
list (Lisp)
little? (BinaryReader::ByteOrder)
little_endian? (BinaryReader::ByteOrder)
lmod (Quaternion)
lmod_D4 (Quaternion)
load (HTTP::Message)
load (XOXO)
load_cookies (Web::CookieManager)
load_path (System)
load_yaml (Units::Converter)
loaded_features (System)
log (Quaternion)
log_connect (DebugSocket)
longitude (Quaternion)
loop_structure (RubyTals)
lru (LRUCache)
lru_append (LRUCache)
lru_clear (LRUCache)
lru_delete (LRUCache)
lru_insert (LRUCache)
lru_join (LRUCache)
lru_touch (LRUCache)
magnitude (Quaternion)
major (Tuple)
make_cookie_str (Web::CookieManager)
make_legal (PQueue)
make_xoxo (XOXO)
map (Lisp)
marshal_dump (OpenObject)
marshal_from_cgi (HTMLHelper)
marshal_load (OpenObject)
marshal_to_cgi (HTMLHelper)
match? (Web::Cookie)
max (Interval)
mebi (Numeric)
mega (Numeric)
member? (Lisp)
member? (Interval)
merge (Dictionary)
merge! (Dictionary)
method_annotation (Module)
method_missing (Reference)
method_missing (Functor)
method_missing (NackClass)
method_missing (Units)
method_missing (HashBuilder)
method_missing (Elementor)
method_missing (BasicObject::Self)
method_missing (Units::Value)
method_missing (XMLBuilder)
method_missing (OpenObject)
method_missing (REXMLBuilder)
method_missing (Annotation)
method_missing (Numeric)
method_missing (Units::Converter)
method_missing (BasicObject)
method_missing (Units::Unit)
method_missing (OpenCascade)
method_missing (YAMLStruct)
method_missing (NullClass)
method_missing (Recorder)
method_missing (HTMLBuilder)
method_missing (Method::Probe)
method_name (TracePoint)
method_overloads (Module)
micro (Numeric)
midnight (Time)
migration (Method)
milli (Numeric)
mime_type (HTTP::Message)
min (Interval)
minor (Tuple)
minute (Numeric)
minutes (Numeric)
mirrors (Downloader)
mixin_parameters (Module)
mock (Mock)
mock (StateParser::State)
mocks (Mock)
monday (Time)
monitored_download (Downloader)
month (Numeric)
months (Numeric)
months_ago (Time)
months_since (Time)
move (Console::ANSICode)
multiparam_query? (HTTP::Message)
multiton_id (Tuple)
mutable_methods (Array)
nack (Kernel)
nail (lib/facets/more/nackclass.rb)
nano (Numeric)
network? (BinaryReader::ByteOrder)
new (Annotation)
new (Units::Unit)
new (Web::CookieManager)
new (Timer)
new (OpenObject)
new (Downloader::Mirror)
new (Semaphore)
new (YAMLStruct)
new (NackClass)
new (Elementor)
new (Lisp::DottedPair)
new (PQueue)
new (SSLSocketWrap)
new (Interval)
new (Task::Graph)
new (Client)
new (Snapshot)
new (Task)
new (Quaternion)
new (XMLHelper)
new (DebugSocket)
new (TracePoint)
new (HashBuilder)
new (FileList)
new (PathList)
new (SyncArray)
new (ValueHolder)
new (Coroutine)
new (REXMLBuilder)
new (LRUCache)
new (Association)
new (JSON::State)
new (Recorder)
new (FloatString)
new (REXMLBuilder::REXMLUtil)
new (Units::Converter)
new (Dictionary)
new (IORedirect)
new (Class)
new (HTTP::Message)
new (Web::Cookie)
new (NullClass)
new (BasicObject::Self)
new (HTTP::Message::Body)
new (Heap::Min)
new (BuilderObject)
new (Console::Command)
new (Reference)
new (OpenCascade)
new (TagIterator)
new (Functor)
new (Pool)
new (Heap)
new (Tuple)
new (Downloader)
new (SimpleStringIO)
new (Console::ProgressBar)
new (StateParser)
new (Heap::Max)
new (StateParser::Marker)
new (SyncHash)
new (StateParser::State)
new (Method::Probe)
new (Units::Value)
new (HTTP::Message::Headers)
new_by (Dictionary)
new_request (HTTP::Message)
new_response (HTTP::Message)
next_end (StateParser::State)
next_month (Time)
next_offset (StateParser::State)
next_start (StateParser::State)
next_week (Time)
next_year (Time)
nil? (NullClass)
no_proxy (Client)
no_proxy= (Client)
no_proxy? (Client)
notation! (REXMLBuilder::REXMLUtil)
notation! (XMLHelper)
nth (TagIterator)
nth_tailer (TagIterator)
null (Kernel)
null? (Interval)
null? (NullClass)
null? (Lisp)
null? (Object)
observe (Aspect)
observer (Aspects::ClassMethods)
obtain (Pool)
octet_units (Numeric)
ofs (System)
ofs= (System)
on_timeout (Timer)
oneliner (RubyOneLiners)
oneliners (RubyOneLiners)
opened (Interval)
options (Client)
options (System)
options_async (Client)
order (Dictionary)
order_by (Dictionary)
ors (System)
ors= (System)
orthogonal_split (Quaternion)
out (REXMLBuilder)
out (BuilderObject)
outer_append (FloatString)
outer_insert (FloatString)
output_field_separator (System)
output_field_separator= (System)
output_record_separator (System)
output_record_separator= (System)
overload (Module)
override? (Web::Cookie)
p (Semaphore)
pair! (Lisp)
pair? (Lisp)
pairlis (Lisp)
parent (Heap)
parse (StateParser)
parse (Web::Cookie)
parse (RubyTals)
parse (Web::CookieManager)
parse (JSON)
parse (JSON::Parser)
parse_array (JSON::Parser)
parse_attribute (TagIterator)
parse_constraint (Tuple)
parse_object (JSON::Parser)
parse_string (JSON::Parser)
parse_value (JSON::Parser)
path_orig? (Web::Cookie)
pebi (Numeric)
peer_cert (SSLSocketWrap)
percentage (Console::ProgressBar)
peta (Numeric)
pi (XMLHelper)
pi (REXMLBuilder::REXMLUtil)
pico (Numeric)
pid (System)
platform (System)
polar (Quaternion)
polar (Quaternion)
pop (Dictionary)
pop (PQueue)
pop (StateParser::Marker)
pop (Pool)
pop (Tuple)
pop (Heap)
pop_array (PQueue)
post (Aspects::ClassMethods)
post (Client)
post_async (Client)
post_connection_check (SSLSocketWrap)
post_content (Client)
pot (Tuple)
pre (Aspects::ClassMethods)
prerequisite (Task)
pretty_unparse (JSON)
prioritize_urls (Downloader)
process_id (System)
prod (Lisp)
program_loop (System)
program_name (System)
program_name= (System)
promise (Kernel)
protocol_version (Client)
protocol_version= (Client)
proxy (Client)
proxy= (Client)
pull (Tuple)
push (Tuple)
push (Heap)
push (Dictionary)
push (PQueue)
push (Pool)
push_all (Heap)
push_array (PQueue)
put (Client)
put_async (Client)
raise_error (NackClass)
raw (REXMLBuilder::REXMLUtil)
rdiv (Quaternion)
re_enumerate (FloatString)
read (DebugSocket)
read (SSLSocketWrap)
read_cstring (BinaryReader)
read_int16_big (BinaryReader)
read_int16_little (BinaryReader)
read_int16_native (BinaryReader)
read_int32_big (BinaryReader)
read_int32_little (BinaryReader)
read_int32_native (BinaryReader)
read_int8 (BinaryReader)
read_uint8 (BinaryReader)
read_word16_big (BinaryReader)
read_word16_little (BinaryReader)
read_word16_native (BinaryReader)
read_word32_big (BinaryReader)
read_word32_little (BinaryReader)
read_word32_native (BinaryReader)
read_word8 (BinaryReader)
readn (BinaryReader)
real (Quaternion)
real_part (Quaternion)
reason (HTTP::Message)
reason= (HTTP::Message)
receive_timeout (Client)
receive_timeout= (Client)
redirect (IORedirect)
redirect? (HTTP::Status)
redirect_uri_callback= (Client)
reduce (Lisp)
ref (Kernel)
register (Units::Converter)
register_binary_unit (Units::Converter)
register_currency (Units::Converter)
register_length_unit (Units::Converter)
register_prefixed_unit (Units::Converter)
register_si_unit (Units::Converter)
register_unit (Units::Converter)
register_unit_internal (Units::Converter)
registered? (Units::Converter)
registered_converters (Units::Converter)
registered_units (Units::Converter)
reject (Dictionary)
reject! (Dictionary)
release (System)
remember (JSON::State)
renumerate (FloatString)
reorder (Dictionary)
reparse (StateParser)
replace (Dictionary)
replace_array (PQueue)
replace_top (PQueue)
replace_top_low (PQueue)
repr (Lisp::DottedPair)
request (Client)
request_async (Client)
request_line (HTTP::Message::Headers)
required (System)
reset (Timer)
reset (Client)
reset_all (Client)
reset_limit (Timer)
resolve (FileList)
resolve_add (FileList)
resolve_exclude (FileList)
response_status_code= (HTTP::Message::Headers)
response_status_line (HTTP::Message::Headers)
restore (Console::ANSICode)
restore (Snapshot)
restore_snapshot (ValueHolder)
restore_snapshot (Struct)
restore_snapshot (Array)
restore_snapshot (Hash)
restore_snapshot (Object)
restore_snapshot (String)
resume (Coroutine)
retry_connect (Client)
reverse (Lisp)
reversed (Interval)
right (Heap)
right (Console::ANSICode)
rindex (Tuple)
rmod (Quaternion)
rmod_D4 (Quaternion)
rotate (Quaternion)
rotate_angle (Quaternion)
rotation (Quaternion)
round (Quaternion)
round_D4 (Quaternion)
rs (System)
rs= (System)
ru (BinaryReader)
ru_swap (BinaryReader)
rubylibdir (System)
rubypath (System)
run (Coroutine)
running? (Timer)
safe (System)
save (Console::ANSICode)
save_all_cookies (Web::CookieManager)
save_cookie_store (Client)
save_cookies (Web::CookieManager)
second (Numeric)
seconds (Numeric)
seconds_since_midnight (Time)
secure? (Web::Cookie)
seen? (JSON::State)
select (Dictionary)
select_default_ignore_patterns (FileList)
self (Reference)
self (TracePoint)
send_task (Object)
send_timeout (Client)
send_timeout= (Client)
sentinels (Interval)
set (Console::ProgressBar)
set (Lisp)
set (HTTP::Message::Headers)
set_basic_auth (Client)
set_bit (Integer)
set_bitmask (Integer)
set_car! (Lisp)
set_cdr! (Lisp)
set_content (HTTP::Message::Body)
set_cookie_store (Client)
set_flag (Web::Cookie)
set_header (HTTP::Message::Headers)
shift (Dictionary)
shift (Tuple)
show (Console::ProgressBar)
show_progress (Console::ProgressBar)
signal (Semaphore)
signature (Method)
sin (Quaternion)
since (Time)
since (Numeric)
singleton_method_added (PromoteSelf)
sinh (Quaternion)
size (SyncHash::Inheritor)
size (Heap)
size (SyncHash::Delegator)
size (Tuple)
size (Interval)
size (HTTP::Message::Body)
socket_sync= (Client)
sort (Heap)
sort_internal (Heap)
spin (Mock)
sqrt (Quaternion)
ssl_connect (SSLSocketWrap)
start (Timer)
start (Timer::Dummy)
start (IORedirect)
start_of_day (Time)
stat (Console::ProgressBar)
stat_for_file_transfer (Console::ProgressBar)
status (HTTP::Message)
status= (HTTP::Message)
stderr (System)
stderr= (System)
stdin (System)
stdin= (System)
stdout (System)
stdout= (System)
step (Interval)
stop (Coroutine)
stop (Timer::Dummy)
stop (IORedirect)
stop (Timer)
stopped? (Timer)
store (Dictionary)
store_only (Dictionary)
strfbits (Numeric)
strfbytes (Numeric)
strip_bbcode (BBCode)
strongly_connected_components_from (TSort)
sub (FileList)
sub! (FileList)
succ (NilClass)
sum (Lisp)
support_unicode= (JSON)
support_unicode? (JSON)
swap (Heap)
sync (SSLSocketWrap)
sync= (SSLSocketWrap)
sync_body (HTTP::Message)
sync_header (HTTP::Message)
synchronize (Semaphore)
table_name (ORMSupport)
tableize (ORMSupport)
tablename (ORMSupport)
tagexist? (TagIterator)
tagnext (TagIterator)
tail_match? (Web::CookieUtils)
take (Lisp)
take_snapshot (Struct)
take_snapshot (ValueHolder)
take_snapshot (Array)
take_snapshot (String)
take_snapshot (Object)
take_snapshot (Hash)
tan (Quaternion)
tanh (Quaternion)
task (Taskable)
tebi (Numeric)
teeny (Tuple)
tera (Numeric)
test_bit (Integer)
test_bitmask (Integer)
text (REXMLBuilder::REXMLUtil)
text (XMLHelper)
timed (Kernel)
title (Console::ProgressBar)
to (Units::Value)
to_a (PQueue)
to_a (Elementor)
to_a (Quaternion)
to_a (Lisp::DottedPair)
to_a (OpenObject)
to_a (Tuple)
to_a (Dictionary)
to_a (FileList)
to_ary (Association)
to_ary (Elementor)
to_ary (FileList)
to_ary (Tuple)
to_c (Quaternion)
to_c2 (Quaternion)
to_elementor (Array)
to_elementor! (Array)
to_end_of_day (Time)
to_h (HashBuilder)
to_h (OpenObject)
to_hash (OpenObject)
to_json (Hash)
to_json (TrueClass)
to_json (NilClass)
to_json (Object)
to_json (Integer)
to_json (String)
to_json (FalseClass)
to_json (Array)
to_json (Float)
to_json_raw (String)
to_json_raw_object (String)
to_openobject (OpenObject)
to_openobject (Hash)
to_openobject (Proc)
to_proc (OpenObject)
to_s (Association)
to_s (BuilderObject)
to_s (REXMLBuilder)
to_s (Units::Unit)
to_s (FileList)
to_s (Units::Value)
to_s (NackClass)
to_s (FloatString)
to_s (YAMLStruct)
to_s (Heap)
to_s (PathList)
to_s (REXMLBuilder)
to_s (Tuple)
to_s (Lisp::DottedPair)
to_s (Dictionary)
to_s (Quaternion)
to_start_of_day (Time)
to_str (FloatString)
to_t (Tuple)
to_t (String)
to_t (Array)
to_tuple (Tuple)
to_v (Quaternion)
token (StateMachine)
tokenIsUnit? (StateMachine)
tokenIsUnit? (StateMachine)
tokens (StateMachine)
tokens (StateMachine)
tomorrow (Time)
top (PQueue)
top (Heap)
total_dot_num (Web::CookieUtils)
total_overflow= (Console::ProgressBar)
total_time (Timer)
touch! (Expirable)
trace (TracePoint)
trace (Client)
trace_async (Client)
transfer_rate (Console::ProgressBar)
trigger (StateParser::State)
trigger_finish (StateParser::State)
trigger_flush (StateParser::State)
tsort_each_child (Task::Graph)
uncolored (Console::ANSICode)
undescribed_tasks (Taskable)
undo (FloatString)
unit_vector (Quaternion)
unitless? (Units::Unit)
unparse (JSON)
unshift (Tuple)
unshift (Dictionary)
until (Numeric)
up (Console::ANSICode)
up (Semaphore)
update (Dictionary)
upheap (PQueue)
use? (Web::Cookie)
utf16_to_utf8 (JSON)
utf8_to_json (JSON)
utf8_to_utf16 (JSON)
v (Semaphore)
value_new (Dictionary)
values (SyncHash::Delegator)
values (SyncHash::Inheritor)
values (Dictionary)
values (Tuple)
vector (Quaternion)
vector (Quaternion)
verbose (System)
verbose= (System)
version (HTTP::Message)
version (System)
version= (HTTP::Message)
wait (Semaphore)
week (Numeric)
weeks (Numeric)
with_unit_converter (Units)
wrap (Aspect)
wrap (Aspects::ClassMethods)
wrap (Aspect)
wrap (Aspects)
wrap_enumerable_method (EnumerablePass)
write (SimpleStringIO)
xml (REXMLBuilder::REXMLUtil)
xml (XMLHelper)
year (Numeric)
years (Numeric)
years_ago (Time)
years_since (Time)
yesterday (Time)
zip (Lisp)
~ (Interval)