Compile Time? Runtime? Anytime!

class Complex

require "complex"

v1 = Complex(2,3)

»

Complex(2, 3)

v2 = 2.im

»

Complex(0, 2)

v1 + v2

»

Complex(2, 5)

v1 * v2

»

Complex(-6, 4)

v2**2

»

Complex(-4, 0)

Math.sin(v1)

»

Complex(9.154499147, -4.16890696)

v1 < v2

»

false

v2**2 == -4

»

true

constants

Complex::I

0 +1_i

class methods

new

Complex.new( a,b) ->aComplex

Returns a + b_i.

a

b

Result

Number

Number

a + b_i

Complex

0

a

Complex

Complex

Complex( a.real - b.image, a.image + b.real )

Number

Complex

Complex( a - b.image, b.real )

instance methods

Arithmetic operations

Performs various arithmetic operations on ref.

<=>

ref<=>other-> -1, 0, +1

Returns ref.abs<=>other.abs.

==

ref==anObject->trueorfalse

If anObjectis a complex number, returnstrueif its real and imaginary parts matchref. IfanObjectis a simple number, returnstrueifref.realequalsanObjectandref.imageis zero. Otherwise, attempts to coerceanObjectto a complex number and compares the result.

abs

ref.abs ->aFloat

Absolute value.

abs2

ref.abs2 ->aFloat

Square of absolute value.

arg

ref.arg ->aFloat

Argument (angle from (1,0)).

conjugate

ref.conjugate ->aComplex

Complex conjugate.

image

ref.image ->aNumeric

The imaginary part of ref.

polar

ref.polar ->anArray

Returns the two-element array: [c.abs,c.arg].

real

ref.real ->aNumeric

The real part of ref.

to_f

ref.to_f ->aComplex

Returns Complex(real.to_f, image.to_f).

to_i

ref.to_i ->aComplex

Returns Complex(real.to_i, image.to_i).

to_r

ref.to_r ->aComplex

Returns Complex(real.to_r, image.to_r), converting both parts of the complex to a rational number.

to_s

ref.to_s ->aString

String representation of ref.

class Date

require 'date'

d = Date.new(2000, 3, 31)

»

#<Date: 2451635,2299161>

[d.year, d.yday, d.wday]

»

[2000, 91, 5]

[d.month, d.mday]

»

[3, 31]

[d.cwyear, d.cweek, d.cwday]

»

[2000, 13, 5]

[d.jd, d.mjd]

»

[2451635, 51634.5]

(d << 1).to_s

»

"2000-02-29"

d.succ.to_s

»

"2000-04-01"

(d + 100).to_s

»

"2000-07-09"

d.leap?

»

true

Date.new(2000, 3, -10).to_s

»

"2000-03-22"

d1 = Date.neww(2000, 13, 7)

»

#<Date: 2451637,2299161>

d1.to_s

»

"2000-04-02"

[d1.cwday, d1.wday]

»

[7, 0]

Abbreviations used describing dates

mixins

Comparable:

<, <=, ==, >=, >, between?

class methods

exist2?

Date.exist2?( year,yday,sg=Date::ITALY) ->jd

Converts a yearandydayinto a Julian day number, returningnilon error.

exist?

Date.exist?( year,mon,mday,sg=Date::ITALY) ->jd

Converts a year,mon, andmdayinto a Julian day number, ornilif the parameters are invalid.

existw?

Date.existw?( cyear,cweek,cwday,sg=Date::ITALY) ->jd

Converts a cyear,cweek, andcwdayinto a Julian day number.

gregorian_leap?

Date.gregorian_leap?( year) ->trueorfalse

If yeardoes not end with ``00'', returnstrueifyearis divisible by 4, otherwise returnstrueifyearis divisible by 400.

julian_leap?

Date.julian_leap?( year) ->trueorfalse

Returns trueifyearis divisible by 4.

leap?

Date.leap?( year) ->trueorfalse

Synonym for Date.gregorian_leap?.

new

Date.new( year=-4712,mon=1,mday=1,sg=Date::ITALY) ->aNewDate

Returns a Datefor the givenyear,mon, andmday. Ifmonis negative, it counts back from the end of the year. Ifmdayis negative, it counts back from the end of the month.

new1

Date.new1( jd,sg=Date::ITALY) ->aNewDate

Creates a Datecorresponding to the given Julian day number.

new2

Date.new2( year=-4712,yday=1,sg=Date::ITALY) ->aNewDate

Returns a Datefor the givenyearandyday. Ifydayis negative, it counts back from the end of the year.

new3

Date.new3( year=-4712,mon=1,mday=1,sg=Date::ITALY) ->aNewDate

Synonym for Date.new.

neww

Date.neww( cyear=1582,cweek=41,cwday=5,sg=Date::ITALY) ->aNewDate

Returns a Datefor the givencyear,cweek, andcwday. Ifcweekis negative, it counts back from the end of the year. Ifcwdayis negative, it counts back from the end of the week.

today

Date.today( sg=Date::ITALY) ->aNewDate

Returns a Datefor today.

instance methods

Accessors

ref.year ->yearref.yday ->ydayref.mjd ->mjdref.mon ->monref.month ->monref.mday ->mdayref.day ->mdayref.cwyear ->cwyearref.cweek ->cweekref.cwday ->cwdayref.wday ->wday

Returns the given component of refas a number.

+

ref+anInteger->aNewDate

Returns a new DateanIntegerdays fromref.

--

ref-anInteger->aNewDateref-anOtherDate->anInteger

The first form returns a new DateanIntegerdays beforeref. The second form returns the number of days betweenrefandanOtherDate.

<<

ref<<anInteger->aNewDate

Returns a new Dateformed by subtractinganIntegermonths toref, adjusting themdayvalue back to the last day of the month if it otherwise exceeds it.

<=>

ref<=>anOther-> -1, 0, +1

anOthermust be aNumeric, in which case it is treated as a Julian day number, or aDate. Returns -1, 0, +1 ifrefis less than, equal to, or greater thananOther. See moduleComparableon page 402.

===

ref===anOther->trueorfalse

anOthermust be aNumeric, in which case it is treated as a Julian day number, or aDate. Returnstrueif the Julian day number ofanOtheris the same asref.

>>

ref>>anInteger->aNewDate

Returns a new Dateformed by addinganIntegermonths toref, adjusting themdayvalue back to the last day of the month if it otherwise exceeds it.

downto

ref.downto(aDateMin) {| date | block }

-> ref

Invokes block with dates from refdown toaDateMin.

england

ref.england ->aDate

Equivalent to ref.newsg(Date::ENGLAND).

gregorian

ref.gregorian ->aDate

Equivalent to ref.newsg(Date::GREGORIAN).

italy

ref.italy ->aDate

Equivalent to ref.newsg(Date::ITALY).

jd

ref.jd ->jd

Returns the Julian day number for ref.

julian

ref.julian ->aDate

Equivalent to ref.newsg(Date::JULIAN).

leap?

ref.leap? ->trueorfalse

Returns trueifreffalls within a leap year.

mjd

ref.mjd ->mjd

Returns the Julian day number of refconverted to a modified Julian day number.

newsg

ref.newsg(sg=Date::ITALY) ->aNewDate

Returns a new Date.

next

ref.next ->aNewDate

Synonym for ref.succ.

ns?

ref.ns? ->trueorfalse

Returns trueifreffalls in the period of New Style dates.

os?

ref.os? ->trueorfalse

Returns trueifreffalls in the period of Old Style dates.

sg

ref.sg ->anInteger

Returns the Julian day number of the start of New Style dates for ref.

step

ref.step(aDateLimit,step) {| date | block }

-> ref

Invokes block with dates starting at ref, incrementing bystepdays, ending at the first date greater thanaDateLimit(less than for a negative step).

succ

ref.succ ->aNewDate

Returns the date of refplus one day.

to_s

ref.to_s ->aString

Returns selfas ``year-mon-mday.''

upto

ref.upto(aDateMax) {| date | block }

-> ref

Invokes block with dates from reftoaDateMax.

Library: English

require "English"

$OUTPUT_FIELD_SEPARATOR = ' -- '

"waterbuffalo" =~ /buff/

print $LOADED_FEATURES, $POSTMATCH, $PID, "\n"

print $", $', $$, "\n"

English.rb -- alo -- 19685 --

English.rb -- alo -- 19685 --

$*

$ARGV

$"

$LOADED_FEATURES

$?

$CHILD_STATUS

$&

$MATCH

$<

$DEFAULT_INPUT

$.

$NR

$>

$DEFAULT_OUTPUT

$,

$OFS

$!

$ERROR_INFO

$\

$ORS

$@

$ERROR_POSITION

$\

$OUTPUT_RECORD_SEPARATOR

$;

$FIELD_SEPARATOR

$,

$OUTPUT_FIELD_SEPARATOR

$;

$FS

$$

$PID

$=

$IGNORECASE

$'

$POSTMATCH

$.

$INPUT_LINE_NUMBER

$`

$PREMATCH

$/

$INPUT_RECORD_SEPARATOR

$$

$PROCESS_ID

$~

$LAST_MATCH_INFO

$0

$PROGRAM_NAME

$+

$LAST_PAREN_MATCH

$/

$RS

$_

$LAST_READ_LINE

module Find

require "find"

Find.find("/etc/passwd", "/var/spool/lp1", ".") do |f|

  Find.prune if f == "."

  puts f

end

/etc/passwd

/var/spool/lp1

/var/spool/lp1/status

/var/spool/lp1/lock

/var/spool/lp1/.seq

class methods

find

ref.find([aName]^* ) {| aFileName | block }

Calls the associated block with the name of every file and directory listed as arguments, then recursively on their subdirectories, and so on.

prune

ref.prune

Skips the current file or directory, restarting the loop with the next entry. If the current file is a directory, that directory will not be recursively entered. Meaningful only within the block associated with Find::find.

class File

require 'ftools'

File.copy 'testfile', 'testfile1'

»

true

File.compare 'testfile', 'testfile1'

»

true

class methods

cmp

ref.cmp(name1,name2,verbose=false) ->trueorfalse

Synonym for File.compare .

compare

ref.compare(name1,name2,verbose=false) ->trueorfalse

Returns trueonly if the contents of filesname1andname2are identical.

copy

ref.copy(fromName,toName,verbose=false) ->trueorfalse

Equivalent to calling File.syscopy , but logs the attempt to$stderrifverboseis notfalse.

cp

ref.cp(fromName,toName,verbose=false) ->trueorfalse

Synonym for File.copy .

install

ref.install(fromName,toName,aMode=nil,verbose=false)

Copies file fromNameto filetoNameusingFile.syscopy , unlesstoNamealready exists and has the same content asfromName. Sets the mode of the resulting file toaModeunlessaModeisnil.

makedirs

ref.makedirs([dirName]^* [,aBoolean])

Creates the given directories, logging each attempt to $stderrif the last parameter istrue. Creates any missing parent directories as required.

mkpath

ref.mkpath([dirName]^* [,aBoolean])

Synonym for File.makedirs .

move

ref.move(fromName,toName,verbose=false) ->trueorfalse

Effectively renames fromNametotoName, logging to$stderrifverboseis notfalse.

mv

ref.mv(fromName,toName,verbose=false) ->trueorfalse

Synonym for File.move .

rm_f

ref.rm_f([fileName]^* [,aBoolean]) ->anInteger

Synonym for File.safe_unlink (the name refers to the Unixrm -fcommand).

safe_unlink

ref.safe_unlink([fileName]^* [,aBoolean]) ->anIntegerornil

Unlinks (deletes) the given files, logging to $stderrif the last parameter istrue. The method attempts to make all files writable before unlinking them, so no errors will occur deleting read-only files. Returns the number of files deleted, ornilon error.

syscopy

ref.syscopy(fromName,toName) ->trueorfalse

Efficiently copies the file named fromNametotoName. IftoNamenames a directory, the destination will be a file in that directory with the same basename asfromName. After the copy, the file mode oftoNamewill be the same as that offromName. Returnstrueon success.

class GetoptLong

# Call using "ruby example.rb --size 10k -v -q a.txt b.doc"

require 'getoptlong'

# specify the options we accept and initialize

# the option parser

opts = GetoptLong.new(

  [ "--size",    "-s",            GetoptLong::REQUIRED_ARGUMENT ],

  [ "--verbose", "-v",            GetoptLong::NO_ARGUMENT ],

  [ "--query",   "-q",            GetoptLong::NO_ARGUMENT ],

  [ "--check",   "--valid", "-c", GetoptLong::NO_ARGUMENT ]

)

# process the parsed options

opts.each do |opt, arg|

  puts "Option: #{opt}, arg #{arg.inspect}"

end

puts "Remaining args: #{ARGV.join(', ')}"

Option: --size, arg "10k"

Option: --verbose, arg ""

Option: --query, arg ""

Remaining args: a.txt, b.doc

constants

Per-option constants

NO_ARGUMENT

Flags an option that takes no argument.

OPTIONAL_ARGUMENT

A nonoption following this option will be used as this option's argument.

REQUIRED_ARGUMENT

This option must be followed by an argument.

Overall constants

PERMUTE

Options and their arguments will be shuffled to the front of the command line.

REQUIRE_ORDER

Options and their arguments must appear at the start of the command line. The first nonoption terminates option processing.

RETURN_IN_ORDER

Return options in the order in which they occur on the command line.

class methods

new

GetoptLong.new( [options]^* ) ->ref

Returns a new option parser. Any optionsare passed toref.set_options.

instance methods

each

ref.each {| anOption, anArgument | block }

Loops calling GetoptLong#get, passing the returned option and argument to the associated block. The loop ends whengetreturnsnilforanOption.

error?

ref.error? ->anException

Returns an Exceptionobject documenting any error that has occurred, ornilif there has not been an error.

error_message

ref.error_message ->aString

Returns the text of the last error message.

get

ref.get -> [anOption,anArgument]

Returns the next option, along with any associated argument. If there is no argument, nilis returned foranArgument. If there are no remaining unprocessed options, or if there is an error in option processing andquiethas been set,nilis returned foranOption. Otherwise, if there is an error, a message is written to$stderrand an exception (a subclass ofStandardError) is raised.

The option string returned is the first option that was given in the corresponding array passed to set_options.

get_option

ref.get_option -> [anOption,anArgument]

Synonym for GetoptLong#get.

ordering

ref.ordering ->aFixnum

Returns the current ordering.

ordering=

ref.ordering =aFixnum

Sets the ordering to one of PERMUTE,REQUIRE_ORDER, orRETURN_IN_ORDER. Quietly ignored if the environment variablePOSIXLY_CORRECTis set. Ordering may not be changed once option processing has been started.

quiet

ref.quiet ->trueorfalse

Returns the current value of the quietattribute.

quiet=

ref.quiet =trueorfalse

Sets the current value of the quietattribute. Iffalse, any errors encountered are reported to$stderr.

quiet?

ref.quiet? ->trueorfalse

Synonym for GetoptLong#quiet.

set_options

ref.set_options([anOptArray]^* ) ->ref

Each parameter is an array specifying a single internal option. The array contains one or more strings specifying the external form(s) of the option, and one of the flags NO_ARGUMENT,OPTIONAL_ARGUMENT, orREQUIRED_ARGUMENT. See the sample code on page 448 for examples of use.

terminate

ref.terminate ->ref

Terminates option processing. Any remaining arguments are written back to ARGV. This may be called from within aGetoptLong#eachor on its own. For example, calling the following program using ``ruby example.rb --size 10k -v -term -q a.txt b.doc'' will leave the-qand filenames inARGV.

produces:

terminated?

ref.terminated? ->trueorfalse

Returns trueif option processing has been terminated.

module mkmf

require 'mkmf'

create_makefile("Test")

constants

PLATFORM

varies

A constant string that describes the platform on which Ruby is running, such as ``mswin32'' or ``i686-linux.''

$CFLAGS

Global variable for compiler flags.

$LDFLAGS

Global variable for linker flags.

instance methods

create_makefile

create_makefile( target)

Creates a Makefilefor an extension namedtarget. If this method is not called, noMakefileis created.

dir_config

dir_config( name)

Looks for directory configuration options for namegiven as arguments to this program or to the original build of Ruby. These arguments may be one of:

The given directories will be added to the appropriate search paths (include or link) in the Makefile.

find_library

find_library( name,function,[path]⁺ ) ->trueorfalse

Same as have_library, but will also search in the given directory paths.

have_func

have_func( function) ->trueorfalse

If the named function exists in the standard compile environment, adds the directive -DHAVE_FUNCTIONto the compile command in theMakefileand returnstrue.

have_header

have_header( header) ->trueorfalse

If the given header file can be found in the standard search path, adds the directive -DHAVE_HEADERto the compile command in theMakefileand returnstrue.

have_library

have_library( library,function) ->trueorfalse

If the given function exists in the named library, which must exist in the standard search path or in a directory added with dir_config, adds the library to the link command in theMakefileand returnstrue.

module ParseDate

StringGuess?

yy

mm

dd

hh

min

sec

zone

wd

1999-09-05 23:55:21+0900

F

1999

9

5

23

55

21

+0900

--

1983-12-25

F

1983

12

25

--

--

--

--

--

1965-11-10 T13:45

F

1965

11

10

13

45

--

--

--

10/9/75 1:30pm

F

75

10

9

13

30

--

--

--

10/9/75 1:30pm

T

1975

10

9

13

30

--

--

--

Mon Feb 28 17:15:49 CST 2000

F

2000

2

28

17

15

49

CST

1

Tue, 02-Mar-99 11:20:32 GMT

F

99

3

2

11

20

32

GMT

2

Tue, 02-Mar-99 11:20:32 GMT

T

1999

3

2

11

20

32

GMT

2

12-January-1990, 04:00 WET

F

1990

1

12

4

0

--

WET

--

4/3/99

F

99

4

3

--

--

--

--

--

4/3/99

T

1999

4

3

--

--

--

--

--

10th February, 1976

F

1976

2

10

--

--

--

--

--

March 1st, 84

T

1984

3

1

--

--

--

--

--

Friday

F

--

--

--

--

--

--

--

5

class methods

parsedate

ref.parsedate(aString,guessYear=false) -> [year,mon,mday,hour,min,sec,zone,wday]

Parses a string containing a date and/or a time, returning an array of Fixnumobjects containing the various components.nilis returned for fields that cannot be parsed fromaString. If the result contains a year that is less than 100 andguessYearis true,parsedatewill return a year value equal toyearplus 2000 ifyearis less than 69,yearplus 1900 otherwise.

Library: profile

require 'profile'

def ackerman(m, n)

  if m == 0 then  n+1

  elsif n == 0 and m > 0 then ackerman(m-1, 1)

  else ackerman(m-1, ackerman(m, n-1))

  end

end

ackerman(3,3)

time seconds seconds calls ms/call ms/call name

74.04 2.51 2.51 2432 1.03 42.68 Object#ackerman

14.16 2.99 0.48 3676 0.13 0.13 Fixnum#==

9.14 3.30 0.31 2431 0.13 0.13 Fixnum#-

2.36 3.38 0.08 1188 0.07 0.07 Fixnum#+

0.29 3.39 0.01 57 0.18 0.18 Fixnum#>

0.00 3.39 0.00 1 0.00 0.00 Module#method_added

0.00 3.39 0.00 1 0.00 3390.00 #toplevel

class PStore

require "pstore"

class T

  def initialize(val, left=nil, right=nil)

    @val, @left, @right = val, left, right

  end

  def to_a

    [ @val, @left.to_a, @right.to_a ]

  end

end

store = PStore.new("/tmp/store")

store.transaction do

   store['names'] = [ 'Douglas', 'Barenberg', 'Meyer' ]

   store['tree']  = T.new('top',

                      T.new('A', T.new('B')),

                      T.new('C', T.new('D', nil, T.new('E'))))

end

# now read it back in

store.transaction do

   puts "Roots: #{store.roots.join(', ')}"

   puts store['names'].join(', ')

   puts store['tree'].to_a.inspect

end

Roots: names, tree

Douglas, Barenberg, Meyer

["top", ["A", ["B", [], []], []], ["C", ["D", [], ["E", [], []]], []]]

class methods

new

PStore.new( aFilename) ->aPStore

Returns a new PStoreobject associated with the given file. If the file exists, its contents must have been previously written byPStore.

instance methods

[ ]

ref[anObject] ->anOtherObject

Root Access---Returns the root of an object hierarchy identified by anObject. An exception is raised ifanObjectdoes not identify a root.

[ ]=

ref[anObject] =anOtherObject->anOtherObject

Root Creation---Sets anOtherObjectas the base of the object hierarchy to be identified usinganObject.

abort

ref.abort

Terminates this transaction, losing any changes made to the object hierarchies.

commit

ref.commit

Terminates the current transaction, saving the object hierarchies into the store's file.

path

ref.path ->aString

Returns the name of the file associated with this store.

root?

ref.root?(anObject) ->trueorfalse

Returns trueifanObjectis the key of a root in this store.

roots

ref.roots ->anArray

Returns an array containing the keys of the root objects available in this store.

transaction

ref.transaction {|ref| block }

-> anObject

If the file associated with refexists, reads in the object hierarchies from it. It then executes the associated block, passing inref. The block may use this parameter to access the roots of the hierarchies and hence access the persistent objects. If the block callsPStore#abort, or if it raises an exception, no data is saved back to the associated file. Otherwise, if it invokesPStore#commit, or if it terminates normally, the object hierarchies are written back to the file. The value returned is the value returned by the block.

class Tempfile

require "tempfile"

tf = Tempfile.new("afile")

tf.path

»

"/tmp/afile19701.0"

tf.puts("Cosi Fan Tutte")

»

nil

tf.close

»

nil

tf.open

»

#<File:0x40195040>

tf.gets

»

"Cosi Fan Tutte\n"

tf.close(true)

»

#<File:0x40195040>

class methods

new

Tempfile.new( basename,tmpdir=<see below> ) ->ref

Constructs a temporary file in the given directory. The file name is built by concatenating basename, the current process id and (as an extension) a unique sequence number. If thetmpdirparameter is not supplied, it defaults to the value of one of the environment variablesTMPDIR,TMP, orTEMP, or to the directory/tmp.

The file is then opened using mode ``w+'', which allows reading and writing and deletes any existing content (see Table 22.5 on page 326).

instance methods

close

ref.close(final=false)

Closes ref. Iffinalistrue, deletes the underlying real file. Iffinalisfalse,refmay be subsequently reopened. In all cases, the underlying file is deleted when the program terminates.

open

ref.open

Reopens refusing mode ``r+'', which allows reading and writing but does not delete existing content.

path

ref.path ->aString

Returns the full path of the underlying file.

class Mutex

require 'thread'

sema4 = Mutex.new

a = Thread.new {

  sema4.synchronize {

    # access shared resource

  }

}

b = Thread.new {

  sema4.synchronize {

    # access shared resource

  }

}

instance methods

lock

ref.lock ->ref

Attempts to grab the lock and waits if it isn't available.

locked?

ref.locked? ->trueorfalse

Returns trueif this lock is currently held by some thread.

synchronize

ref.synchronize { block } ->ref

Obtains a lock (using Mutex#lock), runs the block, and releases the lock when the block completes.

try_lock

ref.try_lock ->trueorfalse

Attempts to obtain the lock and returns immediately. Returns trueif the lock was granted.

unlock

ref.unlock ->refornil

Releases the lock. Returns nilifrefwasn't locked.

class ConditionVariable

require 'thread'

mutex = Mutex.new

resource = ConditionVariable.new

a = Thread.new {

  mutex.synchronize {

    # Thread 'a' now needs the resource

    resource.wait(mutex)

    # 'a' can now have the resource

  }

}

b = Thread.new {

  mutex.synchronize {

    # Thread 'b' has finished using the resource

    resource.signal

  }

}

instance methods

broadcast

ref.broadcast

Wakes up all threads waiting for this lock.

signal

ref.signal

Wakes up the first thread in line waiting for this lock.

wait

ref.wait(aMutex) ->aMutex

Releases the lock held in aMutexand waits; reacquires the lock on wakeup.

Library: timeout

require "timeout"

for snooze in 1..2

  puts "About to sleep for #{snooze}"

  timeout(1.5) do

    sleep(snooze)

  end

  puts "That was refreshing"

end

About to sleep for 1

That was refreshing

About to sleep for 2

/tc/usr/lib/ruby/1.6/timeout.rb:37: execution expired (TimeoutError)

from prog.rb:5:in `timeout'

from prog.rb:5

from prog.rb:3:in `each'

from prog.rb:3

class WeakRef

require "weakref"

ref = "fol de rol"

puts "Initial object is #{ref}"

ref = WeakRef.new(ref)

puts "Weak reference is #{ref}"

ObjectSpace.garbage_collect

puts "But then it is #{ref}"

Initial object is fol de rol

Weak reference is fol de rol

prog.rb:8: Illegal Reference - probably recycled (WeakRef::RefError)

ref = WeakRef.new(someObject)

#

# .. some time later

#

gcWasDisabled = GC.disable

if ref.weakref_alive?

  # do stuff with 'ref'

end

GC.enable unless gcWasDisabled

class methods

new

WeakRef.new( anObject) ->ref

Creates and returns a weak reference to anObject. All future references toanObjectshould be made usingref.

instance methods

weakref_alive?

ref.weakref_alive? ->trueorfalse

Returns falseif the object referenced byrefhas been garbage collected.