var search_data = {"index":{"searchIndex":["acl","aclentry","acllist","argf","abbrev","addrinfo","ambiguoustaskerror","ambiguoustaskerror","argumenterror","array","base64","basicobject","basicsocket","benchmark","tms","bigdecimal","bigmath","binding","bundler","apiresponsemismatcherror","buildmetadata","bundlererror","cli","add","binstubs","cache","check","clean","common","config","base","console","doctor","exec","gem","info","init","inject","install","issue","list","lock","open","outdated","package","platform","plugin","pristine","remove","show","update","viz","compactindexclient","cache","error","updater","mismatchedchecksumerror","connectionpool","error","poolshuttingdownerror","timedstack","wrapper","currentruby","cyclicdependencyerror","definition","depproxy","dependency","deployment","deprecate","deprecatederror","dsl","dslerror","endpointspecification","env","environmentpreserver","featureflag","fetcher","authenticationrequirederror","badauthenticationerror","base","certificatefailureerror","compactindex","dependency","downloader","fallbackerror","index","networkdownerror","sslerror","toomanyrequestserror","fileutils","dryrun","nowrite","streamutils_","verbose","friendlyerrors","gemhelper","gemhelpers","platformmatch","geminstaller","gemnotfound","gemremotefetcher","gemrequireerror","gemversionpromoter","gemdeps","gemfileerror","gemfileevalerror","gemfilelocknotfound","gemfilenotfound","gemspecerror","genericsystemcallerror","giterror","graph","graphvizclient","httperror","index","injector","installerror","installhookerror","installer","invalidoption","lazyspecification","identifier","lockfileerror","lockfilegenerator","lockfileparser","marshalerror","matchplatform","mirrorsockets","molinillo","circulardependencyerror","compatibility","delegates","resolutionstate","specificationprovider","dependencygraph","action","addedgenocircular","deleteedge","detachvertexnamed","log","tag","vertex","dependencystate","nosuchdependencyerror","possibilitystate","resolutionstate","resolver","resolution","conflict","possibilityset","unwinddetails","resolvererror","specificationprovider","ui","versionconflict","nospaceondeviceerror","operationnotsupportederror","parallelinstaller","specinstallation","patherror","permissionerror","persistent","net","http","persistent","error","persistenthttp","plugin","api","source","dsl","plugingemfileerror","events","index","commandconflict","sourceconflict","installer","git","rubygems","malformattedplugin","sourcelist","undefinedcommanderror","unknownsourceerror","pluginerror","processlock","productionerror","remotespecification","resolver","specgroup","retry","rubydsl","rubygemsgeminstaller","rubyversion","rubyversionmismatch","rubygemsintegration","gem","runtime","securityerror","settings","mirror","mirrorconfig","mirrors","tcpsocketprobe","validator","rule","sharedhelpers","similaritydetector","socketaddress","source","gemspec","git","gitcommanderror","gitnotallowederror","gitnotinstallederror","gitproxy","missinggitrevisionerror","metadata","path","installer","rubygems","remote","sourcelist","specset","standalone","stubspecification","sudonotpermittederror","temporaryresourceerror","thor","actions","capturableerb","classmethods","base","classmethods","command","coreext","orderedhash","dynamiccommand","dynamictask","group","hiddencommand","hiddentask","invocation","classmethods","lineeditor","basic","readline","pathcompletion","nestedcontext","rakecompat","shell","basic","color","html","task","util","threadcreationerror","ui","rgproxy","shell","silent","uri","badurierror","error","escape","ftp","file","generic","http","https","invalidcomponenterror","invalidurierror","ldap","ldaps","mailto","parser","regexp","rfc2396_parser","rfc2396_regexp","pattern","uricredentialsfilter","versionconflict","versionranges","reqr","virtualprotocolerror","worker","wrappedexception","yamlserializer","yamllibrarysyntaxerror","yamlsyntaxerror","cgi","cookie","html3","html4","html4fr","html4tr","html5","htmlextension","invalidencoding","queryextension","session","filestore","memorystore","nullstore","pstore","util","csv","deletesuffix","fieldsconverter","malformedcsverror","matchp","parser","inputsscanner","invalidencoding","scanner","unoptimizedstringio","row","table","writer","class","closedqueueerror","comparable","complex","conditionvariable","continuation","coverage","dbm","dbmerror","debugger__","drb","drbarray","drbbadscheme","drbbaduri","drbconn","drbconnerror","drberror","drbidconv","drbidconv","drbmessage","drbobject","drbobject","drbobservable","drbprotocol","drbremoteerror","drbsslsocket","sslconfig","drbserver","invokemethod18mixin","drbservernotfound","drbtcpsocket","drbunixsocket","drbundumped","drbundumped","drbunknown","drbunknownerror","extserv","extservmanager","gw","gwidconv","threadobject","timeridconv","timerholder2","invalidindexerror","weakidconv","weakset","data","date","error","datetime","delegator","didyoumean","digest","base","class","instance","md5","rmd160","sha1","dir","env","eoferror","erb","defmethod","util","exception_type","exception_type","exception_type","exception_type","encoding","compatibilityerror","converter","converternotfounderror","invalidbytesequenceerror","undefinedconversionerror","encodingerror","english","enumerable","enumerator","arithmeticsequence","chain","generator","lazy","producer","yielder","errno","econnaborted","econnreset","eproto","error","etc","exception","exceptionformatrix","errdimensionmismatch","errnotregular","erroperationnotdefined","erroperationnotimplemented","falseclass","fcntl","fiber","fibererror","fiddle","basictypes","cparser","cstruct","cstructbuilder","cstructentity","cunion","cunionentity","closure","blockcaller","compositehandler","dlerror","function","handle","importer","pointer","win32types","file","file::constants","stat","filetest","fileutils","dryrun","nowrite","streamutils_","verbose","find","float","floatdomainerror","forwardable","frozenerror","gc","profiler","gdbm","gdbmerror","gdbmfatalerror","gem","availableset","basicspecification","bundlerversionfinder","command","commandlineerror","commandmanager","commands","buildcommand","certcommand","checkcommand","cleanupcommand","contentscommand","dependencycommand","environmentcommand","fetchcommand","generateindexcommand","helpcommand","infocommand","installcommand","listcommand","lockcommand","mirrorcommand","opencommand","outdatedcommand","ownercommand","pristinecommand","pushcommand","querycommand","rdoccommand","searchcommand","servercommand","setupcommand","makedirs","signincommand","signoutcommand","sourcescommand","specificationcommand","stalecommand","uninstallcommand","unpackcommand","updatecommand","whichcommand","yankcommand","configfile","conflicterror","consoleui","defaultuserinteraction","dependency","dependencyerror","dependencyinstaller","dependencylist","dependencyremovalexception","dependencyresolutionerror","deprecate","doctor","documenterror","endofyamlexception","errorreason","exception","ext","builderror","builder","cmakebuilder","configurebuilder","extconfbuilder","rakebuilder","fakefetcher","filepermissionerror","formatexception","gemnotfoundexception","gemnotinhomeexception","gemrunner","gemcutterutilities","impossibledependencieserror","indexer","installerror","installupdateoptions","installer","fakepackage","installertestcase","invalidspecificationexception","licenses","list","loaderror","localremoteoptions","missingspecerror","missingspecversionerror","mockgemui","inputeoferror","systemexitexception","tty","termerror","nametuple","noaliasyamltree","operationnotsupportederror","package","digestio","error","formaterror","nonseekableio","old","patherror","tarheader","tarinvaliderror","tarreader","entry","unexpectedeof","tartestcase","tarwriter","boundedstream","fileoverflow","restrictedstream","toolongfilename","packagetask","pathsupport","platform","platformmismatch","remoteerror","remotefetcher","fetcherror","unknownhosterror","remoteinstallationcancelled","remoteinstallationskipped","remotesourceexception","request","requestset","gemdependencyapi","lockfile","parseerror","parser","tokenizer","requirement","badrequirementerror","resolver","apiset","apispecification","activationrequest","bestset","composedset","conflict","currentset","dependencyrequest","gitset","gitspecification","indexset","indexspecification","installedspecification","installerset","localspecification","lockset","lockspecification","molinillo","circulardependencyerror","delegates","resolutionstate","specificationprovider","dependencygraph","action","addedgenocircular","deleteedge","detachvertexnamed","log","tag","vertex","dependencystate","nosuchdependencyerror","possibilitystate","resolutionstate","resolver","resolution","resolvererror","specificationprovider","ui","versionconflict","requirementlist","set","sourceset","specspecification","specification","stats","vendorset","vendorspecification","rubyversionmismatch","runtimerequirementnotmeterror","s3urisigner","configurationerror","instanceprofileerror","safeyaml","security","exception","policy","signer","trustdir","securityoption","server","silentui","source","git","installed","local","lock","specificfile","vendor","sourcefetchproblem","sourcelist","specfetcher","specificgemnotfoundexception","specification","specificationpolicy","streamui","silentdownloadreporter","silentprogressreporter","simpleprogressreporter","threadeddownloadreporter","verboseprogressreporter","stubspecification","systemexitexception","testcase","specfetchersetup","staticset","text","uninstallerror","uninstaller","unsatisfiabledependencyerror","uriformatter","uriparser","uriparsing","userinteraction","util","validator","verificationerror","version","versionoption","getoptlong","ambiguousoption","error","invalidoption","missingargument","needlessargument","httpclientexception","httpgatewaytimeout","httpmovedtemporarily","httpmultiplechoice","httprequestentitytoolarge","httprequesttimeout","httprequesturitoolarge","httprequesturitoolarge","httprequesturitoolong","httprequestedrangenotsatisfiable","hash","io","eagainwaitreadable","eagainwaitwritable","einprogresswaitreadable","einprogresswaitwritable","ewouldblockwaitreadable","ewouldblockwaitwritable","waitreadable","waitwritable","generic_readable","generic_writable","ioerror","ipaddr","addressfamilyerror","error","invalidaddresserror","invalidprefixerror","ipsocket","irb","abort","cantchangebinding","cantreturntonormalmode","cantshifttomultiirbmode","canvas","color","symbolstate","context","contextextender","extendcommand","changeworkspace","currentworkingworkspace","foreground","fork","help","info","irbcommand","jobs","kill","load","nop","popworkspace","pushworkspace","require","source","workspaces","extendcommandbundle","fileinputmethod","frame","frameoverflow","frameunderflow","history","illegalparameter","illegalrcgenerator","inputmethod","inspector","irb","irbalreadydead","irbloader","irbswitchedtocurrentthread","jobmanager","loadabort","locale","methodextender","nosuchjob","notimplementederror","notifier","abstractnotifier","compositenotifier","errundefinednotifier","errunrecognizedlevel","levelednotifier","nomsgnotifier","outputmethod","notimplementederror","readlineinputmethod","reidlineinputmethod","rubymodel","stdioinputmethod","stdiooutputmethod","undefinedpromptmode","unrecognizedswitch","vec","workspace","indexerror","integer","interrupt","invocationerror","json","circulardatastructure","ext","generator","generatormethods","array","bignum","falseclass","fixnum","float","hash","integer","nilclass","object","string","extend","trueclass","state","parser","generatorerror","genericobject","jsonerror","missingunicodesupport","nestingerror","parsererror","unparsererror","jacobian","kconv","kernel","keyerror","lusolve","loaderror","localjumperror","logger","makemakefile","logging","rbconfig","string_or_failed_format","malformattedargumenterror","marshal","matchdata","math","domainerror","matrix","eigenvaluedecomposition","lupdecomposition","method","module","monitor","monitormixin","conditionvariable","mutex","mutex_m","nkf","nameerror","net","apop","apopsession","ftp","bufferedsslsocket","bufferedsocket","mlsxentry","nullsocket","ftpconnectionerror","ftperror","ftppermerror","ftpprotoerror","ftpreplyerror","ftptemperror","http","copy","delete","get","head","lock","mkcol","move","options","patch","post","propfind","proppatch","put","trace","unlock","httpaccepted","httpalreadyreported","httpbadgateway","httpbadrequest","httpbadresponse","httpclienterror","httpconflict","httpcontinue","httpcreated","httpearlyhints","exception_type","httpexceptions","httpexpectationfailed","httpfaileddependency","httpfatalerror","httpforbidden","httpmovedtemporarily","httpgatewaytimeout","httpgenericrequest","httpgone","httpheader","httpheadersyntaxerror","httpimused","httpinformation","httpinsufficientstorage","httpinternalservererror","httplengthrequired","httplocked","httploopdetected","httpmethodnotallowed","httpmisdirectedrequest","httpmovedpermanently","httpmultistatus","httpmultiplechoice","httpnetworkauthenticationrequired","httpnocontent","httpnonauthoritativeinformation","httpnotacceptable","httpnotextended","httpnotfound","httpnotimplemented","httpnotmodified","httpok","httppartialcontent","httprequestentitytoolarge","httppaymentrequired","httppermanentredirect","httppreconditionfailed","httppreconditionrequired","httpprocessing","httpproxyauthenticationrequired","httprequestedrangenotsatisfiable","httpredirection","httprequest","httprequestheaderfieldstoolarge","httprequesttimeout","httpresetcontent","httpresponse","exception_type","httpseeother","httpservererror","httpclientexception","httpserviceunavailable","httpsuccess","httpswitchprotocol","httptemporaryredirect","httptoomanyrequests","httprequesturitoolong","httpunauthorized","httpunavailableforlegalreasons","httpunknownresponse","httpunprocessableentity","httpunsupportedmediatype","httpupgraderequired","httpuseproxy","httpvariantalsonegotiates","httpversionnotsupported","imap","badresponseerror","bodytypeattachment","bodytypebasic","bodytypeextension","bodytypemessage","bodytypemultipart","bodytypetext","byeresponseerror","crammd5authenticator","dataformaterror","digestmd5authenticator","error","flagcounterror","loginauthenticator","noresponseerror","numvalidator","plainauthenticator","responseerror","responseparseerror","unknownresponseerror","opentimeout","pop3","popauthenticationerror","popbadresponse","poperror","popmail","protoautherror","protocommanderror","protofatalerror","protoretriableerror","protoservererror","protosyntaxerror","protounknownerror","protocretryerror","protocolerror","readtimeout","smtp","response","smtpauthenticationerror","smtperror","smtpfatalerror","smtpserverbusy","smtpsyntaxerror","smtpunknownerror","smtpunsupportedcommand","writeadapter","writetimeout","newton","nilclass","nomatchingpatternerror","nomemoryerror","nomethoderror","notimplementederror","numeric","oleproperty","object","parseerror","timeouterror","objectspace","internalobjectwrapper","weakmap","observable","open3","openssl","asn1","asn1data","asn1error","constructive","objectid","primitive","bn","bnerror","buffering","cipher","cipher","ciphererror","config","configerror","digest","digesterror","engine","engineerror","extconfig","hmac","hmacerror","kdf","kdferror","netscape","spki","spkierror","ocsp","basicresponse","certificateid","ocsperror","request","response","singleresponse","opensslerror","pkcs12","pkcs12error","pkcs5","pkcs7","pkcs7error","recipientinfo","signerinfo","pkey","dh","dherror","dsa","dsaerror","ec","group","error","point","error","ecerror","pkey","pkeyerror","rsa","rsaerror","random","randomerror","ssl","sslcontext","sslerror","sslerrorwaitreadable","sslerrorwaitwritable","sslserver","sslsocket","session","sessionerror","socketforwarder","x509","attribute","attributeerror","crl","crlerror","certificate","certificateerror","extension","extensionerror","extensionfactory","name","rfc2253dn","nameerror","request","requesterror","revoked","revokederror","store","storecontext","storeerror","openstruct","openuri","httperror","httpredirect","meta","openread","optionparser","ac","acceptables","ambiguousargument","ambiguousoption","arguable","completinghash","completion","invalidargument","invalidoption","list","missingargument","needlessargument","optionmap","parseerror","switch","noargument","optionalargument","placedargument","requiredargument","pp","ppmethods","pstore","error","pty","childexited","pathname","pool","prettyprint","singleline","prime","eratosthenesgenerator","eratosthenessieve","generator23","pseudoprimegenerator","trialdivision","trialdivisiongenerator","proc","process","gid","status","sys","uid","psych","badalias","classloader","restricted","coder","disallowedclass","emitter","exception","handler","dumperoptions","handlers","recorder","json","stream","treebuilder","nodes","alias","document","mapping","node","scalar","sequence","stream","omap","parser","mark","scalarscanner","set","stream","streaming","classmethods","syntaxerror","treebuilder","visitors","depthfirst","emitter","jsontree","noaliasruby","toruby","visitor","yamltree","queue","rdoc","rdoc","alias","anonclass","anymethod","attr","classmodule","codeobject","comment","constant","context","crossreference","erbio","erbpartial","encoding","error","extend","generator","ghostmethod","i18n","include","markdown","memoentry","parseerror","ruleinfo","markup","metamethod","methodattr","mixin","normalclass","normalmodule","options","parser","c","changelog","markdown","rd","ripperstatelex","innerstatelex","ruby","rubytools","simple","text","rd","rdoc","ri","error","require","rdoc","servlet","singleclass","stats","store","error","missingfileerror","task","text","tokenstream","tomdoc","toplevel","rdoctask","rexml","attlistdecl","attribute","attributes","cdata","child","comment","dtd","attlistdecl","elementdecl","entitydecl","notationdecl","parser","declaration","doctype","document","element","elementdecl","elements","encoding","entity","entityconst","externalentity","formatters","default","pretty","transitive","functions","iosource","instruction","light","node","namespace","node","notationdecl","output","parent","parseexception","parsers","baseparser","lightparser","pullevent","pullparser","sax2parser","streamparser","treeparser","ultralightparser","xpathparser","quickpath","referencewriter","sax2listener","security","source","sourcefactory","streamlistener","text","undefinednamespaceexception","validation","choice","event","interleave","oneormore","optional","ref","relaxng","sequence","state","validationexception","validator","zeroormore","xmldecl","xmltokens","xpath","xpathnode","xpathparser","rss","atom","commonmodel","contentmodel","classmethods","dateconstruct","duplicatelinkchecker","entry","feed","author","category","contributor","entry","content","published","source","summary","generator","icon","id","link","logo","rights","subtitle","title","updated","personconstruct","email","name","uri","textconstruct","uricontentmodel","basedublincoremodel","baselistener","basemodel","baseparser","basetrackbackmodel","contentmodel","conversionerror","converter","dublincoremodel","dublincoremodel","element","error","itunesbasemodel","ituneschannelmodel","itunescategory","itunesimage","itunesowner","itunesitemmodel","itunesduration","itunesmodelutils","imagefaviconmodel","imagefavicon","imageitemmodel","imageitem","imagemodelutils","invalidrsserror","listenermixin","maker","atom","entry","channel","cloud","description","generator","skipdays","day","skiphours","hour","image","items","item","textinput","feed","channel","categories","category","cloud","generator","links","link","skipdays","day","skiphours","hour","image","items","item","categories","category","content","enclosure","guid","links","link","source","categories","category","generator","icon","links","link","logo","textinput","atomcategory","atomgenerator","atomlink","atomlogo","atompersonconstructbase","atompersons","atomtextconstruct","atomtextconstructbase","ensurexmlcontent","base","channelbase","authorsbase","authorbase","categoriesbase","categorybase","cloudbase","contributorsbase","contributorbase","copyrightbase","descriptionbase","generatorbase","itunescategories","itunescategory","itunesimage","itunesowner","linksbase","linkbase","skipdaysbase","daybase","skiphoursbase","hourbase","titlebase","contentmodel","dublincoremodel","itunesbasemodel","ituneschannelmodel","itunescategoriesbase","itunescategorybase","itunesimagebase","itunesownerbase","itunesitemmodel","itunesdurationbase","imagebase","imagefaviconmodel","imagefaviconbase","imageitemmodel","imageitembase","itemsbase","itembase","contentbase","descriptionbase","enclosurebase","guidbase","itunesduration","rightsbase","sourcebase","iconbase","logobase","rightsbase","subtitlebase","titlebase","titlebase","rss09","rss091","channel","image","items","item","textinput","rss092","channel","image","items","item","textinput","channel","authors","author","categories","category","cloud","contributors","contributor","copyright","description","generator","links","link","skipdays","day","skiphours","hour","title","image","items","item","authors","author","categories","category","content","contributors","contributor","description","enclosure","guid","links","link","rights","source","authors","author","categories","category","contributors","contributor","generator","icon","links","link","logo","rights","subtitle","title","title","textinput","rss10","channel","authors","author","categories","category","cloud","contributors","contributor","copyright","description","generator","links","link","skipdays","day","skiphours","hour","title","image","items","item","authors","author","categories","category","content","contributors","contributor","description","enclosure","guid","links","link","rights","source","authors","author","categories","category","contributors","contributor","generator","icon","links","link","logo","rights","subtitle","title","title","textinput","rss20","channel","categories","category","cloud","generator","skipdays","day","skiphours","hour","image","items","item","authors","author","categories","category","enclosure","guid","source","links","link","textinput","rssbase","setupdefaultdate","setupdefaultlanguage","slashmodel","syndicationmodel","taxonomytopicmodel","taxonomytopicsbase","taxonomytopicbase","taxonomytopicsmodel","taxonomytopicsbase","textinputbase","trackbackmodel","trackbackaboutsbase","trackbackaboutbase","xmlstylesheets","xmlstylesheet","missingattributeerror","missingtagerror","nserror","notavailablevalueerror","notexpectedtagerror","notseterror","notvalidxmlparser","notwellformederror","overlappedprefixerror","parser","rdf","bag","li","channel","image","items","seq","textinput","image","item","li","seq","li","textinput","rexmllikexmlparser","rexmllistener","rexmlparser","rss09","rss10","rootelementmixin","rss","channel","cloud","image","item","category","enclosure","guid","source","skipdays","day","skiphours","hour","textinput","setupmaker","slashmodel","syndicationmodel","taxonomytopicmodel","taxonomytopic","taxonomytopicsmodel","taxonomytopics","bag","toomuchtagerror","trackbackmodel10","trackbackabout","trackbackping","trackbackmodel20","trackbackabout","trackbackping","trackbackutils","unknownconversionmethoderror","unknowntagerror","unsupportedmakerversionerror","utils","csv","explicitcleanother","inheritedreader","yesother","xml","element","xmlparserlistener","xmlparsernotfound","xmlparserparser","xmlscanlistener","xmlscanparser","xmlstylesheet","xmlstylesheetmixin","racc","accept","actiontable","compileerror","cparseparams","debugflags","error","goto","grammar","definitionenv","precedencedefinitionenv","grammarfileparser","result","grammarfilescanner","iset","item","locationpointer","logfilegenerator","ormark","parseerror","parseerror","parser","parserclassgenerator","parserfilegenerator","params","prec","rrconflict","reduce","rule","srconflict","shift","sourcetext","state","statetransitiontable","statetransitiontablegenerator","states","sym","symboltable","useraction","rake","random","formatter","range","rangeerror","rational","readline","regexp","regexperror","reline","core","requiredargumentmissingerror","resolv","dns","config","nxdomain","otherresolverror","decodeerror","encodeerror","name","query","requester","requesterror","resource","any","cname","domainname","generic","hinfo","in","a","aaaa","srv","wks","loc","minfo","mx","ns","ptr","soa","txt","hosts","ipv4","ipv6","loc","alt","coord","size","mdns","resolverror","resolvtimeout","rinda","drbobjecttemplate","invalidhashtuplekey","notifytemplateentry","requestcancelederror","requestexpirederror","rindaerror","ringfinger","ringprovider","ringserver","simplerenewer","template","templateentry","tuple","tuplebag","tuplebin","tupleentry","tuplespace","tuplespaceproxy","waittemplateentry","ripper","filter","rubylex","terminatelineinput","rubyvm","abstractsyntaxtree","node","instructionsequence","mjit","runtimeerror","sdbm","sdbmerror","sockssocket","scripterror","securerandom","securityerror","set","shellwords","signal","signalexception","simpledelegator","singleforwardable","singleton","sizedqueue","socket","ancillarydata","constants","ifaddr","option","udpsource","socketerror","sortedset","standarderror","stopiteration","string","stringio","stringscanner","error","struct","symbol","syntaxerror","syslog","constants","facility","level","logger","formatter","macros","option","systemcallerror","systemexit","systemstackerror","tcpserver","tcpsocket","tsort","cyclic","tempio","tempfile","thread","location","threaderror","threadgroup","time","timeout","error","timeouterror","tracepoint","tracer","trueclass","typeerror","udpsocket","unixserver","unixsocket","uri","badurierror","error","escape","ftp","file","generic","http","https","invalidcomponenterror","invalidurierror","ldap","ldaps","mailto","parser","regexp","rfc2396_parser","rfc2396_regexp","pattern","unboundmethod","uncaughtthrowerror","undefinedtaskerror","spellchecker","undefinedtaskerror","unicodenormalize","unknownargumenterror","spellchecker","vector","zerovectorerror","webrick","accesslog","accesslogerror","basiclog","cgi","config","cookie","daemon","genericserver","htmlutils","httpauth","authenticator","basicauth","digestauth","htdigest","htgroup","htpasswd","proxyauthenticator","proxybasicauth","proxydigestauth","userdb","httpproxyserver","httprequest","httpresponse","chunkedwrapper","invalidheader","httpserver","httpservererror","httpservlet","abstractservlet","cgihandler","defaultfilehandler","erbhandler","filehandler","httpservleterror","prochandler","httpstatus","clienterror","eoferror","error","info","redirect","servererror","status","success","httputils","formdata","httpversion","log","snirequest","servererror","simpleserver","utils","timeouthandler","win32ole","variant","win32olequeryinterfaceerror","win32oleruntimeerror","win32ole_event","win32ole_method","win32ole_param","win32ole_record","win32ole_type","win32ole_typelib","win32ole_variable","win32ole_variant","warning","weakref","referror","xml","parser","xmlencoding_ja","sjishandler","xmp","stringinputmethod","yaml","dbm","store","syck","syck","zerodivisionerror","zlib","buferror","dataerror","deflate","error","gzipfile","crcerror","error","lengtherror","nofooter","gzipreader","gzipwriter","inprogresserror","inflate","memerror","needdict","streamend","streamerror","versionerror","zstream","fatal","!()","!()","!=()","!=()","!~()","%()","%()","%()","%()","%()","%()","%()","&()","&()","&()","&()","&()","&()","&()","&()","*()","*()","*()","*()","*()","*()","*()","*()","*()","*()","*()","**()","**()","**()","**()","**()","**()","**()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+()","+@()","+@()","+@()","+@()","+@()","+@()","+@()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-()","-@()","-@()","-@()","-@()","-@()","-@()","-@()","-@()","-@()","-@()","-@()","/()","/()","/()","/()","/()","/()","/()","/()","/()","/()","<()","<()","<()","<()","<()","<()","<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<<()","<=()","<=()","<=()","<=()","<=()","<=()","<=()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","<=>()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","==()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","===()","=~()","=~()","=~()","=~()","=~()","=~()","=~()","=~()","=~()",">()",">()",">()",">()",">()",">()",">()",">=()",">=()",">=()",">=()",">=()",">=()",">=()",">>()",">>()",">>()",">>()",">>()",">>()",">>()","apop()","asciiz()","additiveexpr()","andexpr()","array()","bigdecimal()","csv()","complex()","currentcontext()","d()","debug()","debug=()","delegateclass()","digest()","digest()","digest()","e()","equalityexpr()","filterexpr()","float()","functioncall()","hash()","i()","integer()","json()","jobmanager()","log_mask()","log_upto()","locationpath()","multiplicativeexpr()","nodetest()","orexpr()","pi()","pathexpr()","pathname()","permalink?()","predicate()","primaryexpr()","proxy()","rational()","relationalexpr()","relativelocationpath()","sp()","sp_z()","string()","string()","uri()","uri()","uri()","uri()","unaryexpr()","unionexpr()","z()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","[]=()","^()","^()","^()","^()","^()","_()","_permalink?()","__callee__()","__dependencies()","__dir__()","__drbref()","__drbref()","__drburi()","__drburi()","__evaluate__()","__exit__()","__getobj__()","__getobj__()","__id__()","__materialize__()","__method__()","__raise__()","__send__()","__setobj__()","__setobj__()","__swap__()","__swap__()","__to_xpath_helper()","__validate()","_ac_arg_enable()","_add()","_added?()","_attrs()","_attrs()","_check_ac_args()","_compute_expand()","_defmetasyntax()","_delayed_add()","_dump()","_dump()","_dump()","_dump()","_dump()","_enumerable_collect()","_enumerable_collect_concat()","_enumerable_drop()","_enumerable_drop_while()","_enumerable_filter()","_enumerable_filter_map()","_enumerable_find_all()","_enumerable_flat_map()","_enumerable_grep()","_enumerable_grep_v()","_enumerable_map()","_enumerable_reject()","_enumerable_select()","_enumerable_take()","_enumerable_take_while()","_enumerable_uniq()","_enumerable_with_index()","_enumerable_zip()","_execute()","_getproperty()","_gets_noecho()","_groups()","_httpdate()","_id2ref()","_intern()","_invoke()","_ipv4_compat?()","_iso8601()","_jisx0301()","_load()","_load()","_load()","_load()","_load()","_local_specification()","_make_label()","_no_crlf_check()","_ns()","_parse()","_parse()","_parse()","_parse()","_parse_date_if_needed()","_path_to?()","_populate_relations()","_racc_do_parse_c()","_racc_do_parse_rb()","_racc_do_reduce()","_racc_evalact()","_racc_init_sysvars()","_racc_setup()","_racc_yyparse_c()","_racc_yyparse_rb()","_recursive_predecessors()","_recursive_successors()","_regist()","_remote_specification()","_remote_specification()","_reverse()","_rfc2822()","_rfc3339()","_rfc822()","_segments()","_set_default_values()","_set_default_values()","_set_default_values()","_set_default_values()","_set_default_values()","_set_default_values()","_set_last_value()","_setproperty()","_setup_maker_element()","_split_segments()","_strptime()","_strptime()","_tags()","_tilde_requirements()","_to_string()","_validate()","_version()","_wrap()","_xmlschema()","`()","a()","abbrev()","abbrev()","abbrev()","abbreviate()","abbreviate()","abort()","abort()","abort()","abort()","abort()","abort_on_exception()","abort_on_exception()","abort_on_exception=()","abort_on_exception=()","abort_threads()","abs()","abs()","abs()","abs()","abs()","abs()","abs()","abs2()","abs2()","absolute()","absolute()","absolute?()","absolute?()","absolute?()","absolute?()","absolute_matches()","absolute_path()","absolute_path()","absolute_path()","absolute_path?()","ac_arg_disable()","ac_arg_enable()","ac_arg_with()","accept()","accept()","accept()","accept()","accept()","accept()","accept()","accept()","accept()","accept()","accept()","accept()","accept()","accept?()","accept_charset()","accept_charset=()","accept_loop()","accept_nonblock()","accept_nonblock()","accept_nonblock()","accept_nonblock()","accept_uri_http()","access_log()","acct()","acos()","acosh()","act2actid()","action()","action()","action_name()","action_name()","action_name()","action_name()","action_name()","action_name()","action_name()","action_name()","action_name()","action_name()","action_out()","actions()","activate()","activate_dependencies()","activate_new_spec()","activate_platform!()","activate_spec()","activated()","activated()","activated()","activated=()","activated?()","activated_gem_paths()","active?()","active?()","active_count()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add()","add!()","add?()","add_git()","add_alias()","add_alias()","add_alias()","add_alias()","add_alias()","add_alias()","add_always_install()","add_attribute()","add_attribute()","add_attribute()","add_attribute()","add_attributes()","add_authenticator()","add_bindir()","add_bulk_threshold_option()","add_bundled_with()","add_c_enclosure()","add_c_variables()","add_cert()","add_certid()","add_certificate()","add_certificate()","add_checksums()","add_child_vertex()","add_child_vertex()","add_class()","add_class()","add_class_or_module()","add_clear_sources_option()","add_color()","add_color()","add_command()","add_comment()","add_common_option()","add_constant()","add_constant()","add_constant()","add_converter()","add_crl()","add_crl()","add_current_platform()","add_data()","add_date()","add_dependencies()","add_dependency()","add_dependency_with_type()","add_development_dependency()","add_dictionary()","add_edge()","add_edge()","add_edge_no_circular()","add_edge_no_circular()","add_edge_no_circular()","add_edge_no_circular()","add_element()","add_element()","add_entry()","add_event_to_arry()","add_event_to_arry()","add_extend()","add_extension()","add_extension()","add_extension()","add_extra_args()","add_field()","add_file()","add_file()","add_file()","add_file()","add_file()","add_file_digest()","add_file_signed()","add_file_simple()","add_filter()","add_generator()","add_git_source()","add_git_source()","add_git_sources()","add_handler()","add_have_children_element()","add_hook()","add_html()","add_include()","add_include()","add_install_update_options()","add_key_option()","add_link()","add_listener()","add_listener()","add_listener()","add_listener()","add_listener()","add_listener()","add_listener()","add_local()","add_local_remote_options()","add_locked_ruby_version()","add_maker()","add_method()","add_method()","add_method()","add_module()","add_module()","add_module_alias()","add_module_by_normal_module()","add_namespace()","add_need_initialize_variable()","add_need_initialize_variable()","add_nonce()","add_nonce()","add_observer()","add_option()","add_other_element()","add_otp_option()","add_owners()","add_parser_run_info()","add_path()","add_path()","add_path_source()","add_platform()","add_platform()","add_platform_option()","add_platforms()","add_plugin_source()","add_plural_form()","add_prerelease_option()","add_protocol()","add_protocol()","add_proxy_option()","add_recipient()","add_regexp_handling()","add_remote()","add_require()","add_response_handler()","add_revoked()","add_row()","add_rubygems_remote()","add_rubygems_source()","add_rubygems_source()","add_rule()","add_rule_block()","add_runtime_dependency()","add_runtime_options!()","add_section()","add_section()","add_security_option()","add_self_to_load_path()","add_signer()","add_source()","add_source()","add_source_gem()","add_source_option()","add_source_to_list()","add_sources()","add_specific_extra_args()","add_specs()","add_start_rule()","add_status()","add_stress_to_class()","add_symlink()","add_text()","add_to()","add_to_classes_or_modules()","add_to_element_method()","add_to_fetcher()","add_to_history?()","add_to_load_path()","add_to_load_path()","add_token()","add_token_listener()","add_tokens()","add_trace_func()","add_unconverted_fields()","add_update_sources_option()","add_user_code()","add_value()","add_version_option()","add_vertex()","add_vertex()","add_vertex()","add_vertex()","add_word_pair()","added?()","addent()","additional_base_requirements_for_resolve()","additional_message()","addr()","addr()","addr()","addr()","addr_mask()","addr_port()","addrel()","addsym()","adjugate()","adjust_headers()","adler()","adler32()","adler32_combine()","advise()","afamily()","after_resolution()","after_resolution()","after_resolution()","ajd()","alert()","alert()","alert_error()","alert_error()","alert_warning()","alert_warning()","alias()","alias()","alias()","alias?()","alias?()","alias_extension()","alias_method()","aliases()","aliases_for()","alien()","alive?()","alive?()","alive?()","alive?()","alive?()","alive?()","all()","all()","all()","all=()","all?()","all?()","all?()","all_aliases()","all_classes()","all_classes_and_modules()","all_commands()","all_dependencies()","all_errors()","all_files()","all_modules()","all_names()","all_requirements()","all_sources()","all_sources()","all_spec_names()","all_specs()","all_specs()","all_symbols()","all_tasks()","allbits?()","allocate()","allocation_class_path()","allocation_generation()","allocation_method_id()","allocation_sourcefile()","allocation_sourceline()","allow?()","allow_addr?()","allow_git_ops?()","allow_incompatible_default_type!()","allow_missing?()","allow_missing?()","allow_missing?()","allow_missing?()","allow_missing?()","allow_nan?()","allow_socket?()","allow_sudo?()","allowed_in_path()","allowed_push_host()","alphanumeric()","alpn_protocol()","already_tagged?()","alt_name_or_x509_entry()","alternate=()","amjd()","amount_constrained()","amount_constrained()","ancestor?()","ancestor?()","ancestors()","ancestors()","ancestors()","ancestors()","ancestors()","angle()","angle()","angle()","angle_with()","answer_match()","antisymmetric?()","any?()","any?()","any?()","any?()","any?()","any_content()","any_to_s()","anybits?()","api_fetcher?()","api_fetcher?()","api_fetcher?()","api_fetchers()","api_key()","api_keys()","apop?()","apop?()","apop?()","app_cache()","app_cache_dirname()","app_cache_dirname()","app_cache_dirname()","app_cache_path()","app_cache_path()","app_cache_path()","app_config_path()","app_script_text()","append()","append()","append()","append_data()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_features()","append_field_value()","append_file()","append_formatted_table()","append_to()","append_to_file()","appendable?()","apply()","apply_auth()","apply_func()","apply_offset()","approximate_recommendation()","are_colors_disabled?()","aref()","aref()","aref()","aref_prefix()","aref_prefix()","aref_prefix()","arg()","arg()","arg()","arglists()","args()","args()","argument()","arguments()","arguments()","argv()","argv0()","arity()","arity()","arity()","array()","array_attributes()","array_nl()","array_nl=()","array_to_s()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_json()","as_path_source()","as_unicode()","ascend()","ascii_compatible?()","ascii_only?()","ascii_only?()","asciicompat_encoding()","asctime()","asctime()","asin()","asinh()","ask()","ask()","ask()","ask()","ask()","ask()","ask()","ask_and_set()","ask_and_set_test_framework()","ask_filtered()","ask_for_password()","ask_for_password()","ask_for_spec_from()","ask_if_ok()","ask_simply()","ask_yes_no()","ask_yes_no()","asn1_flag()","asn1_flag=()","assert_activate()","assert_contains_make_command()","assert_directory_exists()","assert_headers_equal()","assert_path_exists()","asset()","assign_names()","assignment_expression?()","assoc()","assoc()","assoc()","at()","at()","at()","at()","at_exit()","atan()","atan()","atan2()","atanh()","atime()","atime()","atime()","atime()","atom_symbol()","atom_validate()","atom_validate()","atom_validate()","atom_validate()","atom_validate()","atom_validate()","attempt()","attempt_to_activate()","attempt_to_activate()","attempt_to_activate_existing_spec()","attempt_to_activate_new_spec()","attempt_to_filter_existing_spec()","attempt_to_swap_possibility()","attempts()","attempts()","attlistdecl()","attlistdecl()","attlistdecl?()","attr()","attr_accessor()","attr_reader()","attr_writer()","attribute()","attribute()","attribute_names()","attribute_of()","attributes()","attributes()","attributes()","attributes()","attributes=()","attributes=()","attributes=()","attributes_of()","auth_capable?()","auth_cram_md5()","auth_data=()","auth_login()","auth_method()","auth_only()","auth_only()","auth_plain()","auth_tag()","auth_tag=()","auth_tag_len=()","authenticate()","authenticate()","authenticate()","authenticate()","authenticated?()","author()","author=()","authors()","authors=()","auto_indent()","auto_indent_proc=()","auto_install()","autoclose=()","autoclose?()","autoload()","autoload()","autoload?()","autoload?()","avail_in()","avail_out()","avail_out=()","available()","available?()","available?()","available?()","available?()","available?()","available_specs()","available_tags()","axe()","b()","backport_base_dir()","backport_cache_file()","backport_ext_builder_monitor()","backport_spec_file()","backtrace()","backtrace()","backtrace()","backtrace()","backtrace_locations()","backtrace_locations()","backtracking!()","backup()","banner()","banner()","banner()","base()","base()","base()","base64()","base64_encode()","base64_uri_escape()","base64digest()","base64digest()","base64digest!()","base64digest!()","base_dir()","base_dir()","base_label()","base_label()","base_name()","base_name()","base_path()","basename()","basename()","basename()","basic()","basic_auth()","basic_auth()","basic_encode()","basic_quote_characters()","basic_quote_characters=()","basic_quote_characters=()","basic_word_break_characters()","basic_word_break_characters=()","basic_word_break_characters=()","basis()","beep()","before()","before_resolution()","before_resolution()","before_resolution()","before_running_rdoc()","before_running_rdoc()","begin()","begin()","begin()","begin_adding()","begin_transport()","beginning_of_line?()","begins?()","benchmark()","benchmark()","best_available()","between?()","bin_dir()","bin_file()","bin_file_names()","bin_for_find()","bin_key()","bin_path()","bin_path()","bin_path()","binary=()","binary?()","binary?()","binary_mode()","bind()","bind()","bind()","bind()","bind()","bind_call()","bind_function()","binding()","binding()","binding()","binding_requirement_in_set?()","binding_requirements_for_conflict()","bindir()","bindir()","bindir()","binmode()","binmode()","binmode()","binmode?()","binmode?()","binmode?()","binread()","binread()","binstubs()","binwrite()","binwrite()","birthtime()","birthtime()","birthtime()","birthtime()","bit_length()","bit_set?()","blinding_off!()","blinding_on!()","blksize()","block_given?()","block_length()","block_length()","block_length()","block_params=()","block_size()","blockdev?()","blockdev?()","blockdev?()","blockdev?()","blockquote()","blocks()","bm()","bm()","bmbm()","bmbm()","body()","body()","body=()","body=()","body_exist?()","body_permitted?()","body_reader()","body_stream=()","bool()","bool()","bool_attr()","boolean()","boolean_argument()","boolean_writer()","both?()","bottom()","bottom()","branch()","break_on_newline()","break_outmost_groups()","break_points()","breakable()","breakable()","broadaddr()","broadcast()","broadcast()","bsearch()","bsearch()","bsearch_index()","bubblebabble()","bubblebabble()","bubblebabble()","buffer_initial_length()","buffer_initial_length=()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build()","build2()","build2()","build_args()","build_args()","build_args()","build_args=()","build_args=()","build_dependency()","build_details_for_unwind()","build_eigenvectors()","build_exception()","build_extensions()","build_extensions()","build_extensions()","build_fields_converter()","build_gem()","build_gem()","build_gem()","build_gem_lines()","build_header_fields_converter()","build_heading()","build_indices()","build_info_dir()","build_info_file()","build_marshal_gemspecs()","build_message()","build_message()","build_modern_index()","build_modern_indices()","build_package()","build_paragraph()","build_parser_fields_converter()","build_path_query()","build_path_query()","build_rake_in()","build_scanner()","build_verbatim()","build_writer_fields_converter()","built_at()","built_gem_path()","builtin_curves()","builtin_gem?()","bump()","bundle_path()","bundle_update_bundler_version()","bundle_worker()","bundler_cert_store()","bundler_dependency_version()","bundler_major_version()","bundler_path()","bundler_plugin_api_source?()","bundler_ruby_lib()","bundler_version()","bundler_version_with_reason()","bundles_for_gem()","by_col()","by_col!()","by_col_or_row()","by_col_or_row!()","by_id()","by_row()","by_row!()","byte()","byte()","bytes()","bytes()","bytes()","bytes()","bytes()","bytes()","bytes()","bytes()","bytes()","bytes_read()","bytesize()","byteslice()","ca_file=()","ca_path=()","cache()","cache()","cache()","cache()","cache()","cache()","cache()","cache_dir()","cache_dir()","cache_dir()","cache_file()","cache_globally()","cache_path()","cache_path()","cache_path()","cache_path()","cache_path()","cache_path()","cache_slug()","cache_update_path()","cache_update_path()","cached!()","cached!()","cached!()","cached!()","cached!()","cached?()","cached_built_in_gem()","cached_gem()","cached_path()","cached_revision()","cached_revision_checked_out?()","cached_specs()","cachesize=()","calc_checksum()","calc_indent()","calculate()","calculate_checksum()","call()","call()","call()","call()","call()","call()","call()","call()","call_seq=()","callcc()","callee_id()","caller()","caller_locations()","camel_case()","can_display_colors?()","can_display_colors?()","can_display_colors?()","can_install_in_parallel?()","can_lock?()","can_lock?()","can_lock?()","can_parse()","can_parse_by_name()","can_retry?()","cancel()","cancel()","cancel()","canceled?()","candidate()","candidate()","candidate()","canonical()","canonical=()","canonical_each()","canonical_label()","canonical_segments()","canonname()","capabilities()","capability()","capable?()","capable_auth_types()","capable_cram_md5_auth?()","capable_login_auth?()","capable_plain_auth?()","capable_starttls?()","capitalize()","capitalize()","capitalize()","capitalize!()","caption()","capture()","capture2()","capture2()","capture2e()","capture2e()","capture3()","capture3()","capture_and_filter_stderr()","capture_and_ignore_stderr()","captures()","captures()","casecmp()","casecmp()","casecmp?()","casecmp?()","casefold?()","catch()","catch()","catch()","catch()","cause()","cbrt()","cc_command()","cd()","cd()","cd()","cd()","cdata()","cdata()","cdata?()","cdatas()","cdiv()","ceil()","ceil()","ceil()","ceil()","ceil()","ceil()","ceiling()","center()","cert()","cert=()","cert_files()","cert_path()","cert_status()","cert_store=()","certid()","certid()","certificate=()","certificates()","certificates=()","certificates_matching()","certs()","chain()","chain()","challenge()","challenge()","challenge()","challenge=()","change_encoding()","change_privilege()","change_privilege()","change_reason()","change_workspace()","changed()","changed?()","character()","characters()","chardev?()","chardev?()","chardev?()","chardev?()","charpos()","chars()","chars()","chars()","chars()","charset()","chdir()","chdir()","chdir()","chdir()","chdir()","chdir()","chdir()","check()","check()","check()","check()","check()","check!()","check_auth_args()","check_auth_continue()","check_auth_method()","check_auth_response()","check_cert()","check_chain()","check_circular?()","check_closed()","check_continue()","check_credentials_permissions()","check_data()","check_default_type!()","check_deprecated_options()","check_executable_overwrite()","check_files()","check_for_activated_spec!()","check_for_corrupt_lockfile()","check_for_deployment_mode!()","check_for_group_conflicts_in_cli_options()","check_for_options_conflicts()","check_gems()","check_generator()","check_header()","check_headers()","check_headers()","check_home_permissions()","check_host()","check_host()","check_insecure_method()","check_inspect_key()","check_installed_gems()","check_installed_gems?()","check_int()","check_key()","check_key()","check_la()","check_modeline()","check_modify()","check_names()","check_names()","check_nonce()","check_ns()","check_opaque()","check_opaque()","check_password()","check_password()","check_password()","check_password()","check_path()","check_path()","check_port()","check_port()","check_primary_source_safety()","check_private_key()","check_range()","check_response()","check_root()","check_ruby_version()","check_rules_nullable()","check_rules_useless()","check_scheme()","check_scheme()","check_signedness()","check_sizeof()","check_sources_consistency!()","check_symbols_nullable()","check_symbols_useless()","check_terminals()","check_termination()","check_to()","check_to()","check_trust()","check_trust_policy()","check_typecode()","check_typecode()","check_typo_squatting()","check_unknown_options!()","check_unknown_options!()","check_until()","check_useless()","check_user()","check_user()","check_user()","check_user()","check_userinfo()","check_userinfo()","check_userinfo()","check_userinfo()","check_validity()","check_winsize_changed()","checkbox()","checkbox_group()","checkin()","checkout()","checkout()","checksum_for_file()","checksum_type()","checksums()","child()","child_name()","children()","children()","children()","children()","children()","children()","children()","chmod()","chmod()","chmod()","chmod()","chmod()","chmod()","chmod()","chmod()","chmod_r()","chmod_r()","chmod_r()","chmod_r()","chomp()","chomp()","chomp!()","choose()","choose_from_list()","choose_from_list()","chop()","chop()","chop!()","chown()","chown()","chown()","chown()","chown()","chown()","chown()","chown_r()","chown_r()","chown_r()","chown_r()","chr()","chr()","chroot()","chruby_version()","chunk()","chunk()","chunk_while()","chunk_while()","chunked=()","chunked?()","chunked?()","cipher()","cipher()","cipher=()","ciphers()","ciphers()","ciphers=()","ciphers=()","cis()","civil()","civil()","clamp()","class()","class_attributes()","class_eval()","class_exec()","class_file()","class_method_list()","class_methods()","class_name()","class_name()","class_option()","class_options()","class_path()","class_variable_defined?()","class_variable_get()","class_variable_set()","class_variables()","classes()","classes_and_modules()","classes_hash()","classes_hash()","classify()","clean()","clean()","clean()","clean?()","clean_after_install?()","clean_env()","clean_exec()","clean_gems()","clean_load_path()","clean_system()","clean_text()","cleanpath()","cleanup()","cleanup()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear()","clear_bit!()","clear_cache()","clear_comment()","clear_comments()","clear_default_specs()","clear_gemspec_cache()","clear_paths()","clear_paths()","clear_screen()","cli_help()","client_ca()","client_cert_cb()","client_error?()","client_error?()","client_fetcher()","clobber_task_description()","clobber_task_description()","clobber_task_name()","clobber_task_name()","clock_getres()","clock_gettime()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","clone()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close()","close!()","close_all()","close_enabled?()","close_on_exec=()","close_on_exec?()","close_read()","close_read()","close_read()","close_write()","close_write()","close_write()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed?()","closed_read?()","closed_write?()","cmds()","cmp()","cmp()","cmp()","cmp()","cmp()","cmp()","cmp()","cmp_issuer()","cmsg_is?()","code()","code_around_binding()","codepage()","codepage=()","codepoints()","codepoints()","codepoints()","codepoints()","coerce()","coerce()","coerce()","coerce()","coerce()","coerce()","coerce()","coerce()","coerce()","coerce_other()","cofactor()","cofactor()","cofactor_expansion()","col_sep()","collect()","collect()","collect()","collect()","collect()","collect()","collect!()","collect!()","collect!()","collect!()","collect2()","collect_attributes()","collect_attrs()","collect_concat()","collect_concat()","collect_first_comment()","collect_method()","collect_method()","collect_tokens()","colorable?()","colorize()","colorize_code()","column()","column()","column()","column_separator()","column_vector()","column_vectors()","columns()","combination()","combine()","combine()","combine_rubygems_sources()","comma_breakable()","command()","command()","command=()","command?()","command_help()","command_names()","command_plugin()","commands()","commands()","commands()","comment()","comment()","comment()","comment=()","comment=()","comment?()","comment_lines()","comments()","commercial()","commercial()","commit()","committed?()","common_installer_setup()","common_installer_teardown()","common_options()","compact()","compact()","compact()","compact()","compact!()","compact!()","compact_index_client()","compact_index_request()","compact_specs()","compare()","compare_by_identity()","compare_by_identity()","compare_by_identity?()","compare_by_identity?()","compare_file()","compare_file()","compare_file()","compare_file()","compare_language()","compare_stream()","compare_stream()","compare_stream()","compare_stream()","compatible?()","compatible?()","compile()","compile()","compile_error()","compile_file()","compile_option()","compile_option=()","complain()","complete()","complete()","complete()","complete()","complete()","completer_quote_characters()","completer_quote_characters=()","completer_quote_characters=()","completer_word_break_characters()","completer_word_break_characters=()","completer_word_break_characters=()","completion_append_character()","completion_append_character=()","completion_append_character=()","completion_case_fold()","completion_case_fold()","completion_case_fold=()","completion_case_fold=()","completion_options()","completion_proc()","completion_proc()","completion_proc=()","completion_proc=()","completion_quote_character()","completion_quote_character()","component()","component()","component()","component()","component()","component()","component_ary()","component_ary()","compose_sets()","compress()","compress_indices()","compute_dfa()","compute_expand()","compute_hash()","compute_heads()","compute_key()","compute_locate()","compute_nfa()","compute_nullable()","compute_nullable_0()","compute_primes()","compute_requires()","compute_useless()","concat()","concat()","concat()","concat()","concat()","concat()","concat_ruby_version_requirements()","conf()","config()","config()","config_file()","config_file_name()","configuration()","configuration()","configuration=()","configure()","configure()","configure_connection_for_https()","configure_gem_home()","configure_gem_home_and_path()","configure_gem_path()","configure_gem_version_promoter()","configure_options()","configured_bundle_path()","configured_uri_for()","confirm()","confirm()","confirm()","confirm_all()","conflict?()","conflict_fixing_possibilities?()","conflicting_dependencies()","conflicting_dependencies()","conflicts()","conflicts()","conflicts()","confstr()","conftest_source()","conj()","conj()","conj()","conjugate()","conjugate()","conjugate()","connect()","connect()","connect()","connect()","connect()","connect()","connect()","connect()","connect_address()","connect_from()","connect_internal()","connect_nonblock()","connect_nonblock()","connect_to()","connection()","connection_close?()","connection_for()","connection_for()","connection_for()","connection_keep_alive?()","connection_stored?()","conservative_version()","consider_local?()","consider_remote?()","console()","console()","console_mode()","console_mode=()","const_defined?()","const_get()","const_get_safely()","const_load()","const_missing()","const_set()","const_source_location()","constants()","constants()","construct()","consume()","consume()","consume_rbuff()","contains()","contains?()","contains_requirable_file?()","content()","content=()","content=()","content_encoding()","content_is_set?()","content_length()","content_length()","content_length()","content_length=()","content_length=()","content_range()","content_setup()","content_type()","content_type()","content_type()","content_type()","content_type()","content_type=()","content_type=()","content_writer()","contents()","contents()","contents()","context()","context()","context()","context=()","continue?()","continue_entry_body()","continue_timeout=()","conv_arg()","converge_dependencies()","converge_locals()","converge_locked_specs()","converge_path_source_to_gemspec_source()","converge_path_sources_to_gemspec_sources()","converge_paths()","converge_rubygems_sources()","converge_sources()","convert()","convert()","convert()","convert()","convert()","convert()","convert()","convert()","convert_attr_reader()","convert_fields()","convert_to_backward_compatible_key()","convert_to_uri()","convert_to_uri()","convert_to_uri()","convert_to_uri()","converted_value()","converter=()","converters()","convertible_int()","convpath()","cooked()","cooked!()","copy()","copy()","copy()","copy()","copy()","copy()","copy()","copy_entry()","copy_entry()","copy_entry()","copy_entry()","copy_file()","copy_file()","copy_file()","copy_file()","copy_file()","copy_internal()","copy_nonce()","copy_stream()","copy_stream()","copy_stream()","copy_stream()","copy_stream()","copy_to()","copy_to()","copy_to()","core()","core_to_state()","coredump?()","correct?()","correct_error()","correct_for_windows_path()","correct_for_windows_path()","corrections()","corrections()","cos()","cos()","cosh()","count()","count()","count()","count()","count()","count()","count_imemo_objects()","count_nodes()","count_objects()","count_objects_size()","count_observers()","count_symbols()","count_tdata_objects()","covector()","cover?()","cover?()","coverage_level=()","cp()","cp()","cp()","cp()","cp_lr()","cp_lr()","cp_lr()","cp_lr()","cp_r()","cp_r()","cp_r()","cp_r()","cpu_match()","cram_md5_challenge()","cram_md5_response()","cram_secret()","crc()","crc32()","crc32_combine()","crc_table()","creatable?()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create()","create_bundle_path()","create_cert()","create_cert_email()","create_cert_self_signed()","create_conflict()","create_conflict()","create_document()","create_entries()","create_entry()","create_ext()","create_ext_from_array()","create_ext_from_hash()","create_ext_from_string()","create_extension()","create_file()","create_from()","create_guid()","create_header()","create_items()","create_key()","create_link()","create_listeners()","create_listeners()","create_makefile()","create_new_id()","create_option_parser()","create_request()","create_request_pool()","create_response()","create_self_signed_cert()","create_self_signed_cert()","create_ssl_params()","create_ssl_params()","create_threads()","create_tmap()","create_value()","created_specs()","credential_filtered_string()","credential_filtered_uri()","credentials_for()","credentials_path()","credless_remotes()","cref_pop()","cref_push()","critical()","critical=()","critical?()","crl=()","crls()","crls=()","cross()","cross()","cross_check_for_errors()","cross_product()","crypt()","css()","csv_attr_reader()","csv_integer_writer()","csv_writer()","ctime()","ctime()","ctime()","ctime()","ctime()","ctime()","ctrl_cmd()","current()","current()","current()","current=()","current_cert()","current_command()","current_command_chain()","current_crl()","current_dependencies()","current_dependencies()","current_element()","current_env?()","current_group()","current_line()","current_line()","current_platform?()","current_platforms()","current_ruby()","current_section()","current_server()","current_server()","curry()","curry()","cursor()","cursor=()","cursor_down()","cursor_left()","cursor_right()","cursor_up()","curve_name()","cwday()","cweek()","cwyear()","cycle()","cycle()","d()","daemon()","data()","data()","data()","data()","data=()","data_type()","datadir()","datadir()","date()","date=()","date=()","date=()","date=()","date_writer()","datetime_format()","datetime_format=()","day()","day()","day_fraction()","dclone()","dclone()","dclone()","dclone()","dclone()","deafen()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug()","debug!()","debug=()","debug=()","debug?()","debug?()","debug?()","debug?()","debug?()","debug?()","debug?()","debug?()","debug_format_result()","debug_output()","debug_output=()","debug_output=()","debug_thread_info()","declare()","declare_precedence()","decode()","decode()","decode()","decode()","decode64()","decode_all()","decode_utf7()","decode_www_form()","decode_www_form()","decode_www_form_component()","decode_www_form_component()","deconstruct()","deconstruct()","deconstruct_keys()","deconstruct_keys()","decref()","decrypt()","decrypt()","dedent_string()","dedent_string()","deduplicate()","deduplicate_call_seq()","deep_clone()","def_array_element()","def_atom_persons()","def_atom_text_construct()","def_children_accessor()","def_class()","def_class_accessor()","def_class_accessor()","def_classed_element()","def_classed_element_without_accessor()","def_classed_elements()","def_convert()","def_corresponded_attr_reader()","def_corresponded_attr_writer()","def_csv_accessor()","def_csv_element()","def_delegator()","def_delegator()","def_delegators()","def_delegators()","def_element_class_accessor()","def_elements_class_accessor()","def_elements_class_accessor()","def_else_enc()","def_erb_method()","def_erb_method()","def_explicit_clean_other_accessor()","def_extend_command()","def_extend_command()","def_get_text_element()","def_head_option()","def_iconv_convert()","def_inspector()","def_instance_delegator()","def_instance_delegators()","def_method()","def_module()","def_notifier()","def_notifier()","def_notifier()","def_option()","def_other_element()","def_other_element_without_accessor()","def_post_proc()","def_pre_proc()","def_same_enc()","def_single_delegator()","def_single_delegators()","def_tail_option()","def_to_euc_jp_from_iso_2022_jp()","def_to_euc_jp_from_shift_jis()","def_to_euc_jp_from_utf_8()","def_to_iso_2022_jp_from_euc_jp()","def_to_iso_8859_1_from_utf_8()","def_to_shift_jis_from_euc_jp()","def_to_shift_jis_from_utf_8()","def_to_utf_8_from_euc_jp()","def_to_utf_8_from_iso_8859_1()","def_to_utf_8_from_shift_jis()","def_uconv_convert_if_can()","def_yes_other_accessor()","default()","default()","default()","default()","default=()","default_acl()","default_argc_limit()","default_attempts()","default_bindir()","default_bundle_dir()","default_bundle_dir()","default_cert_path()","default_command()","default_dir()","default_event_sources()","default_exec_format()","default_ext_dir_for()","default_external()","default_external=()","default_gem()","default_gem?()","default_gem_spec()","default_gemfile()","default_gemfile()","default_id_conv()","default_imap_port()","default_imaps_port()","default_internal()","default_internal=()","default_key_path()","default_load_limit()","default_lockfile()","default_lockfile()","default_ole_types()","default_parser()","default_parser=()","default_passive()","default_passive=()","default_path()","default_path()","default_pop3_port()","default_pop3s_port()","default_port()","default_port()","default_port()","default_port()","default_port()","default_port()","default_port()","default_port()","default_prerelease()","default_proc()","default_proc=()","default_retries()","default_rubygems_dirs()","default_source()","default_sources()","default_spec_cache_dir()","default_spec_file()","default_specifications_dir()","default_specifications_dir()","default_src_encoding()","default_ssl_context()","default_ssl_port()","default_ssl_port()","default_stubs()","default_stubs()","default_submission_port()","default_task()","default_title=()","default_tls_port()","default_tls_port()","default_value()","defaults()","defaults()","defaults_str()","defaults_str()","define()","define()","define()","define()","define()","define()","define_actions()","define_by_keywords()","define_finalizer()","define_head()","define_method()","define_singleton_method()","define_tail()","define_task()","defined_class()","defined_event?()","defined_in?()","definition()","definition()","definition()","definition()","definition()","definition_lists()","definition_method()","deflate()","deflate()","deflate()","deflate()","degree()","delegate()","delegate()","deletable?()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete()","delete!()","delete!()","delete?()","delete_all()","delete_all()","delete_all()","delete_all()","delete_at()","delete_at()","delete_attribute()","delete_edge()","delete_edge()","delete_edge()","delete_edge()","delete_element()","delete_field()","delete_first()","delete_first()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_if()","delete_legacy_args()","delete_legacy_args()","delete_namespace()","delete_observer()","delete_observers()","delete_passwd()","delete_passwd()","delete_prefix()","delete_prefix!()","delete_suffix()","delete_suffix()","delete_suffix!()","delete_text()","delete_unless_alive()","deleted?()","denominator()","denominator()","denominator()","denominator()","denominator()","depend_rules()","dependencies()","dependencies()","dependencies()","dependencies()","dependencies()","dependencies()","dependencies()","dependencies()","dependencies_count_for()","dependencies_eql?()","dependencies_for()","dependencies_for()","dependencies_for()","dependencies_for()","dependencies_for()","dependencies_for()","dependencies_for_activated_platforms()","dependencies_for_source_changed?()","dependencies_installed?()","dependencies_to_gemfile()","dependency()","dependency_api_uri()","dependency_names()","dependency_names_to_double_check()","dependency_names_to_double_check()","dependency_order()","dependency_specs()","dependent_gems()","dependent_specs()","deprecate()","deprecate()","deprecate_constant()","deprecate_option()","depth()","depth()","depth()","depth=()","deq()","deq()","deq()","dequote()","dequote()","desc()","desc()","descend()","descendant()","descendant_recursive()","descendent?()","descendent?()","description()","description()","description=()","deserialize()","destination_encoding()","destination_encoding()","destination_encoding()","destination_encoding_name()","destination_encoding_name()","destination_root()","destination_root=()","det()","det()","det_e()","detab()","detach()","detach_vertex_named()","detach_vertex_named()","detach_vertex_named()","detach_vertex_named()","detached()","detached=()","detached?()","detect()","detect()","detect_encoding()","detect_encoding()","detect_gemdeps()","detect_idle_timeout()","detect_row_separator()","determinant()","determinant()","determinant_bareiss()","determinant_e()","determine_encoding()","determine_terminals()","dev()","dev_major()","dev_minor()","development?()","development?()","development_dependencies()","dfa()","dfa()","dfdxi()","dh_compute_key()","diagonal()","diagonal?()","diagonalize()","diff()","difference()","difference()","dig()","dig()","dig()","dig()","dig()","dig()","dig_perfect_match_proc=()","digest()","digest()","digest()","digest()","digest()","digest()","digest()","digest!()","digest_length()","digest_length()","digest_length()","digits()","digraph()","dir()","dir()","dir()","dir_config()","direct_ancestors()","direct_ancestors()","directory()","directory?()","directory?()","directory?()","directory?()","directory?()","directory?()","directory_makable?()","dirname()","dirname()","dirs()","dirs=()","disable()","disable()","disable()","disable_close()","disable_required_check!()","disable_ssl()","disable_ssl()","disable_ssl()","disable_starttls()","disable_tls()","disasm()","disasm()","disassemble()","disassemble()","disconnect()","disconnected?()","disjoint?()","dispatch()","dispatch_seq()","dispid()","display()","display()","display()","display?()","display?()","display_header()","display_nothing_outdated_message()","div()","div()","div()","divide()","divmod()","divmod()","divmod()","divmod()","dlload()","dlopen()","dlopen()","dlunwrap()","dlwrap()","dn()","dn()","dn=()","dn=()","do_get()","do_get()","do_get()","do_head()","do_options()","do_options()","do_post()","do_aliases()","do_attrs()","do_boot_defclass()","do_classes_and_modules()","do_configuration()","do_constants()","do_finish()","do_finish()","do_helo()","do_includes()","do_install()","do_methods()","do_missing()","do_not_reverse_lookup()","do_not_reverse_lookup()","do_not_reverse_lookup=()","do_not_reverse_lookup=()","do_not_reverse_lookup=()","do_reply()","do_resolve_sr()","do_start()","do_start()","do_validate()","do_validate=()","do_write()","do_write()","doc_dir()","doc_root()","doc_stats()","doctor()","doctor()","doctor()","doctor()","doctype()","doctype()","doctype()","doctype()","doctype()","doctype?()","doctype_end()","document()","document()","document()","document()","document()","document()","document?()","document?()","document_children=()","document_self=()","document_self_or_methods()","documentation_page()","documentation_search()","documentation_source()","documented?()","documented?()","documented?()","documented?()","domain=()","done()","done()","done()","done()","done()","done?()","done_adding()","done_documenting=()","done_installing()","dot()","dot()","dot_pat()","dot_pat_str()","double_check_for()","double_check_for()","double_check_for()","double_check_for_index()","double_fig()","down()","down()","down()","down()","down()","down()","down()","down()","down()","down()","downcase()","downcase()","downcase!()","download()","download()","download()","download()","download()","download()","download()","download_cache_path()","download_gem()","download_gem()","download_reporter()","download_to_cache()","download_to_cache()","downloader()","downto()","downto()","dowrite()","draw()","drop()","drop()","drop()","drop_while()","drop_while()","drop_while()","dsa_sign_asn1()","dsa_verify_asn1()","dst?()","dstaddr()","dummy?()","dummy?()","dummy_makefile()","dump()","dump()","dump()","dump()","dump()","dump()","dump()","dump()","dump_all()","dump_coder()","dump_exception()","dump_hash()","dump_ivars()","dump_list()","dump_stream()","dup()","dup()","dup()","dup()","dup()","dylibs()","dylibs_darwin()","dylibs_ldd()","dynamic_prompt()","dynamic_width()","dynamic_width_stty()","dynamic_width_tput()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each()","each2()","each_address()","each_address()","each_address()","each_address()","each_address()","each_ancestor()","each_attribute()","each_attribute()","each_builtin()","each_byte()","each_byte()","each_byte()","each_byte()","each_byte()","each_byte()","each_capitalized()","each_capitalized_name()","each_certificate()","each_char()","each_char()","each_char()","each_char()","each_char()","each_child()","each_child()","each_child()","each_child()","each_child()","each_classmodule()","each_codepoint()","each_codepoint()","each_codepoint()","each_codepoint()","each_cons()","each_const()","each_constant()","each_data()","each_element()","each_element_with_attribute()","each_element_with_text()","each_entry()","each_entry()","each_entry()","each_entry()","each_extend()","each_filename()","each_grapheme_cluster()","each_header()","each_include()","each_index()","each_index()","each_index()","each_index()","each_key()","each_key()","each_key()","each_key()","each_key()","each_key()","each_key()","each_key()","each_la()","each_line()","each_line()","each_line()","each_line()","each_line()","each_line()","each_line()","each_line()","each_line()","each_line()","each_localized_path()","each_mail()","each_method()","each_name()","each_name()","each_name()","each_name()","each_name()","each_nonterminal()","each_object()","each_option()","each_option()","each_pair()","each_pair()","each_pair()","each_pair()","each_pair()","each_pair()","each_pair()","each_pair()","each_pair()","each_pair()","each_pair()","each_parent()","each_prime()","each_recursive()","each_reduce()","each_resource()","each_response_header()","each_rule()","each_rule()","each_section()","each_shift()","each_slice()","each_source()","each_spec()","each_state()","each_strongly_connected_component()","each_strongly_connected_component()","each_strongly_connected_component_from()","each_strongly_connected_component_from()","each_sublocale()","each_t()","each_terminal()","each_unnode()","each_value()","each_value()","each_value()","each_value()","each_value()","each_value()","each_value()","each_value()","each_value()","each_with_index()","each_with_index()","each_with_index()","each_with_index()","each_with_object()","each_with_object()","each_with_something()","eager()","earlier_version?()","easter_egg()","ec2_metadata_credentials_json()","ec2_metadata_request()","ecdh_curves=()","echo=()","echo?()","echo?()","edit_path()","egd()","egd_bytes()","egid()","egid=()","ehlo()","eid()","eid()","eigen()","eigensystem()","eigenvalue_matrix()","eigenvalues()","eigenvector_matrix()","eigenvector_matrix_inv()","eigenvectors()","either_version_older_than_locked()","element()","element()","element=()","element_initialize_arguments?()","elementdecl()","elementdecl()","elementdecl?()","elements()","elements_to_f()","elements_to_f()","elements_to_i()","elements_to_i()","elements_to_r()","elements_to_r()","emacs_editing_mode()","emacs_editing_mode()","emacs_editing_mode?()","emacs_editing_mode?()","email_to_name()","embed_library()","embedded_action()","emit_coder()","emit_row()","emphasis()","empty()","empty()","empty()","empty()","empty()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty?()","empty_content?()","empty_content?()","empty_directory()","empty_marshal_checksum()","empty_marshal_data()","enable()","enable()","enable()","enable_close()","enable_config()","enable_fallback_scsv()","enable_shared()","enable_ssl()","enable_ssl()","enable_ssl()","enable_starttls()","enable_starttls_auto()","enable_tls()","enabled?()","enabled?()","enabled?()","enc_key()","enclose()","enclosed?()","encode()","encode()","encode()","encode()","encode!()","encode!()","encode64()","encode_fallback()","encode_multipart_form_data()","encode_utf7()","encode_with()","encode_www_form()","encode_www_form()","encode_www_form_component()","encode_www_form_component()","encoding()","encoding()","encoding()","encoding()","encoding()","encoding()","encoding()","encoding()","encoding()","encoding()","encoding()","encoding=()","encoding=()","encoding=()","encoding_system_needs()","encoding_updated()","encoding_updated()","encrypt()","encrypt()","end()","end()","end()","end()","end?()","endelement()","end_document()","end_document()","end_document()","end_document()","end_element()","end_element?()","end_mapping()","end_mapping()","end_precedence_declaration()","end_prefix_mapping()","end_resolution()","end_resolution()","end_seen?()","end_sequence()","end_sequence()","end_stream()","end_stream()","end_stream()","end_transport()","end_with?()","end_with?()","ended?()","endgrent()","endpwent()","engines()","england()","enq()","enq()","enq()","enqueue_specs()","enqueued?()","ensure_all_gems_in_lockfile!()","ensure_default_gem_subdirectories()","ensure_dependency()","ensure_equivalent_gemfile_and_lockfile()","ensure_gem_subdirectories()","ensure_loadable_spec()","ensure_mod_sequence_value()","ensure_number()","ensure_nz_number()","ensure_safe_gem_name()","ensure_same_dependencies()","ensure_specs_are_compatible!()","ensure_xml_content()","enter()","enter()","enter()","enterable?()","entered?()","entity()","entity()","entity()","entity()","entity()","entity?()","entity_class()","entity_class()","entity_expansion_limit()","entity_expansion_limit()","entity_expansion_limit=()","entity_expansion_limit=()","entity_expansion_text_limit()","entity_expansion_text_limit()","entity_expansion_text_limit=()","entity_expansion_text_limit=()","entitydecl()","entitydecl()","entitydecl?()","entries()","entries()","entries()","entries()","entry_details()","entry_versions()","entrywise_product()","enum_for()","enum_for()","env()","env()","env_requirement()","env_table()","environment()","environment()","environment()","eof()","eof()","eof()","eof()","eof()","eof()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eof?()","eos?()","eos?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","eql?()","equal?()","equal_source?()","equal_sources?()","equality_relational_compare()","equivalent_remotes?()","equivalent_rubygems_remotes?()","equivalent_rubygems_sources?()","equivalent_source?()","equivalent_sources?()","erase_line()","erase_screen()","erf()","erfc()","errno()","error()","error()","error()","error()","error()","error()","error()","error()","error()","error()","error()","error!()","error=()","error?()","error?()","error?()","error?()","error?()","error?()","error_bytes()","error_char()","error_depth()","error_message()","error_message()","error_print()","error_string()","errors()","errors()","errors()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape()","escape8bit()","escapeelement()","escapehtml()","escape_element()","escape_form()","escape_globs()","escape_html()","escape_html()","escape_path()","escape_userpass()","escape_userpass()","etag_for()","euid()","euid=()","eval()","eval()","eval()","eval_gemfile()","eval_gemspec()","eval_history=()","eval_input()","eval_script()","eval_yaml_gemspec()","evaluate()","evaluate()","evaluate()","evaluate_predicate()","even?()","event()","event?()","event_interface()","event_location()","event_location()","event_type()","exact?()","exact?()","examine()","exception()","exception()","exception()","exception()","exception()","exception()","exception_class()","exclude()","exclude_end?()","exclude_end?()","exclusive()","exec()","exec()","exec()","exec_command()","exec_format()","exec_if()","executable()","executable=()","executable?()","executable?()","executable?()","executable?()","executable_real?()","executable_real?()","executable_real?()","executable_real?()","executables()","executables()","executables=()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execute()","execution_mode()","execution_mode=()","exeext()","exist?()","exist?()","exist?()","exist?()","exist?()","exists?()","exists?()","exists?()","exit()","exit()","exit()","exit()","exit()","exit()","exit!()","exit!()","exit_on_failure?()","exit_status()","exit_value()","exited?()","exitstatus()","exp()","exp()","expand()","expand()","expand()","expand()","expand_dependencies()","expand_hexstring()","expand_pair()","expand_path()","expand_path()","expand_ref_in()","expand_tabs()","expand_value()","expanded_dependencies()","expanded_name()","expanded_original_path()","expanded_path()","expanded_platforms()","expect()","expected()","expected()","expected()","expected()","expected()","expected()","expired?()","expired?()","expires()","expires=()","explain()","explanation()","explicit?()","explicit_clean_other_attr_reader()","explicit_clean_other_writer()","explicit_scope?()","exponent()","export()","export()","export()","export()","expr()","expunge()","ext_lock()","extend()","extend_object()","extend_object()","extend_object()","extend_object()","extended()","extension()","extension()","extension?()","extension_cache_path()","extension_cache_slug()","extension_cache_slug()","extension_cache_slug()","extension_dir()","extension_dir()","extension_dir_name()","extensions()","extensions()","extensions()","extensions()","extensions()","extensions()","extensions()","extensions()","extensions=()","extensions=()","extensions=()","extensions=()","extensions=()","extensions=()","extensions_dir()","extern()","external_encoding()","external_encoding()","external_encoding()","external_encoding()","extname()","extname()","extra_args()","extra_args=()","extra_rdoc_files()","extra_rdoc_files=()","extract()","extract()","extract()","extract()","extract()","extract()","extract_bin()","extract_call_seq()","extract_circular_gems()","extract_files()","extract_files()","extract_files()","extract_files()","extract_gem_info()","extract_reference()","facility()","fail()","fail!()","fail_attempt()","failed?()","failure_message()","fallback_timeout=()","false()","family()","family()","family_addrinfo()","fast_generate()","fastmode=()","fatal()","fatal()","fatal()","fatal!()","fatal?()","fatal?()","fcntl()","fcntl()","fcntl()","fdatasync()","fdiv()","fdiv()","fdiv()","fdiv()","fdiv()","feature_flag()","features()","feed()","feed_info()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch()","fetch_all_remote_specs()","fetch_connection()","fetch_file()","fetch_gem()","fetch_gemspec_files()","fetch_http()","fetch_http()","fetch_https()","fetch_internal()","fetch_latest_specs()","fetch_names()","fetch_path()","fetch_path()","fetch_platform()","fetch_platform()","fetch_resource()","fetch_s3()","fetch_s3_config()","fetch_server()","fetch_server()","fetch_size()","fetch_size()","fetch_spec()","fetch_spec()","fetch_spec()","fetch_spec()","fetch_spec()","fetch_specs()","fetch_uri()","fetch_valid_mirror_for()","fetch_values()","fetcher()","fetcher()","fetcher=()","fetchers()","fetchers()","field()","field?()","field_row?()","field_size_limit()","field_size_limit()","fields()","file()","file()","file()","file?()","file?()","file?()","file?()","file?()","file?()","file_collision()","file_field()","file_input?()","file_name()","file_name()","filename()","filename()","filename()","filename_quote_characters()","filename_quote_characters=()","filename_quote_characters=()","fileno()","fileno()","fileno()","fileno()","files()","files=()","files_hash()","files_in()","files_in_default_gem()","files_in_gem()","filesystem_access()","fill()","fill()","fill_breakable()","fill_rbuff()","filter()","filter()","filter()","filter()","filter()","filter()","filter()","filter()","filter()","filter()","filter!()","filter!()","filter!()","filter!()","filter!()","filter=()","filter=()","filter_backtrace()","filter_backtrace()","filter_dep_specs()","filter_map()","filter_map()","filter_nodeset()","filter_possibilities_after_unwind()","filter_possibilities_for_parent_unwind()","filter_possibilities_for_primary_unwind()","filter_uri()","filtered_possibility_set()","filtered_specs_by_groups()","final()","find()","find()","find()","find()","find()","find()","find()","find()","find()","find_active_stub_by_path()","find_alias_command()","find_alias_comment()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all()","find_all_by_full_name()","find_all_by_name()","find_all_satisfiers()","find_all_template()","find_ancestor_local_symbol()","find_attr_comment()","find_attribute()","find_attribute_named()","find_body()","find_by_name()","find_by_name_and_platform()","find_by_namespace()","find_by_path()","find_c_enclosure()","find_class()","find_class_and_command_by_namespace()","find_class_and_task_by_namespace()","find_class_comment()","find_class_method_named()","find_class_named()","find_class_named()","find_class_named_from()","find_class_or_module()","find_class_or_module()","find_command()","find_command_possibilities()","find_command_possibilities()","find_const_comment()","find_constant_named()","find_data()","find_directory()","find_enclosing_module_named()","find_encoding()","find_executable()","find_external_alias()","find_external_alias_named()","find_file()","find_file_named()","find_file_named()","find_files()","find_files_for_gem()","find_first_recursive()","find_gem()","find_gemfile()","find_gemspec()","find_header()","find_home()","find_in_cache()","find_in_source_paths()","find_in_unresolved()","find_in_unresolved_tree()","find_inactive_by_path()","find_index()","find_index()","find_index()","find_indexed_specs()","find_instance_method_named()","find_latest_files()","find_library()","find_local_revision()","find_local_symbol()","find_local_symbol()","find_method()","find_method_named()","find_modifiers()","find_module_named()","find_module_named()","find_module_named()","find_name()","find_name()","find_override_comment()","find_paths()","find_proxy()","find_proxy()","find_resolved_spec()","find_response()","find_spec()","find_spec_by_name_and_version()","find_spec_for_exe()","find_state_for()","find_state_for()","find_symbol()","find_symbol_module()","find_task_possibilities()","find_text_page()","find_type()","find_unique()","find_unresolved_default_spec()","finger()","fingerprint()","finish()","finish()","finish()","finish()","finish()","finish()","finish()","finish()","finish()","finish()","finish()","finish()","finish_page_dir()","finish_resolve()","finished?()","finished_installing?()","finite?()","finite?()","finite?()","finite?()","fips_mode()","fips_mode=()","first()","first()","first()","first()","first()","first()","first()","first()","first?()","first_column()","first_lineno()","first_lineno()","first_minor()","fix()","fix()","fix_basic_object_inheritance()","fix_ident()","fix_ident()","fixed_anchor?()","fixed_encoding?()","fixup_swapped_children()","flags()","flags=()","flags=()","flat_map()","flat_map()","flat_map()","flatten()","flatten()","flatten()","flatten!()","flatten!()","flock()","flock()","floor()","floor()","floor()","floor()","floor()","floor()","floor()","flush()","flush()","flush()","flush()","flush()","flush()","flush()","flush()","flush()","flush()","flush_buffer()","flush_delayed()","flush_left()","flush_next_in()","flush_next_out()","flush_sessions()","fnmatch()","fnmatch()","fnmatch?()","fnmatch?()","following()","following_node_of()","footer()","for()","for()","for()","for()","for?()","for_cache()","for_current_gems()","for_fd()","for_fd()","for_many()","for_spec()","for_spec?()","force()","force_documentation=()","force_encoding()","force_quotes?()","force_zone!()","foreach()","foreach()","foreach()","foreach()","foreach()","fork()","fork()","fork()","form()","form_data=()","format()","format()","format()","format()","format()","format()","format=()","format_date()","format_datetime()","format_message()","format_severity()","format_text()","format_time()","format_time()","formatted_program_filename()","formatted_usage()","formatted_usage()","formatted_versions_with_platforms()","formatter()","formatter=()","frac()","fragment=()","fragment=()","free()","free()","free=()","freeze()","freeze()","freeze()","freeze()","freeze()","freeze()","freeze()","freeze()","freeze()","freeze()","freeze()","frexp()","friday?()","friday?()","friendly_path()","from()","from()","from_file()","from_hash()","from_list()","from_lock()","from_lock()","from_lock()","from_module()","from_name()","from_name()","from_prime_division()","from_specs()","from_state()","from_string()","from_stub()","from_superclass()","from_yaml()","front()","front()","front()","frozen?()","frozen_bundle?()","fsync()","fsync()","ftype()","ftype()","ftype()","fu_blksize()","fu_blksize()","fu_default_blksize()","fu_default_blksize()","fu_stream_blksize()","fu_stream_blksize()","fu_windows?()","fu_windows?()","full_gem_path()","full_gem_path()","full_gem_path()","full_message()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name()","full_name=()","full_old_name()","full_require_paths()","full_require_paths()","full_spec()","full_version()","fully_documented?()","fully_documented?()","fully_expanded_name()","function()","g()","gamma()","garbage_collect()","garbage_collect()","garbage_collect()","gather_files()","gcd()","gcd()","gcdlcm()","gem()","gem()","gem()","gem()","gem()","gem()","gem_bindir()","gem_cache()","gem_command()","gem_contents()","gem_dir()","gem_dir()","gem_dir()","gem_dir()","gem_file_list()","gem_from_path()","gem_install_dir()","gem_install_dir()","gem_install_message()","gem_key()","gem_mirrors()","gem_name?()","gem_not_found_message()","gem_original_require()","gem_path()","gem_path()","gem_platforms()","gem_push?()","gem_push_host()","gem_remote_fetcher()","gem_repository?()","gem_version_promoter()","gemfile()","gemfile()","gemfile_install()","gemfile_names()","gemfile_root()","gems_dir()","gems_dir()","gems_installed_for()","gemspec()","gemspec()","gemspec()","gemspec_cached_path()","gemspec_cached_path()","gemspec_stubs_in()","gen_action_tables()","gen_body_table()","gen_const_table()","gen_goto_tables()","gen_random()","gen_random()","gen_random_openssl()","gen_random_urandom()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate()","generate!()","generate_bin()","generate_bin()","generate_bin()","generate_bin_script()","generate_bin_symlink()","generate_bundler_executable_stubs()","generate_canonical_query_params()","generate_canonical_request()","generate_default_dirs()","generate_event()","generate_executable_stubs()","generate_index()","generate_key()","generate_key!()","generate_key!()","generate_line()","generate_parser()","generate_parser_file()","generate_prime()","generate_signature()","generate_standalone_bundler_executable_stubs()","generate_states()","generate_string_to_sign()","generate_tag()","generate_windows_script()","generation_hook()","generation_hook()","generator()","generator_descriptions()","generator_for()","generic()","generic()","generic_local_platform()","generic_local_platform()","get()","get()","get()","get()","get()","get()","get()","get2()","get_all_gem_names()","get_all_gem_names_and_versions()","get_attribute()","get_attribute_ns()","get_attributes()","get_bool()","get_byte()","get_candidate_gems()","get_candidates()","get_cert_files()","get_class_or_module()","get_class_specification()","get_console()","get_constant()","get_constant()","get_definition()","get_elements()","get_embdoc_tk()","get_env_editor()","get_fields()","get_file_and_line_from_caller()","get_first()","get_formatted_specs_and_deps()","get_gems_to_cleanup()","get_group()","get_heredoc_tk()","get_hosts_for()","get_included_module_with_optional_parens()","get_input()","get_instance()","get_key_string()","get_line()","get_listeners()","get_namespace()","get_namespace()","get_namespace()","get_nth_prime()","get_one_gem_name()","get_one_optional_argument()","get_op_tk()","get_option()","get_otp()","get_passwd()","get_passwd()","get_passwd()","get_path()","get_platform_from_requirements()","get_primary_gems()","get_print()","get_procs()","get_proxy_from_env()","get_quoted_re()","get_regexp_tk()","get_relative_path()","get_renewer()","get_response()","get_response()","get_response()","get_screen_size()","get_screen_size()","get_set()","get_squashed_tk()","get_string_tk()","get_symbol_or_name()","get_symbol_tk()","get_tagged_response()","get_text()","get_thread()","get_time()","get_tk()","get_tk_until()","get_tkread()","get_value()","get_version_from_requirements()","get_version_semver_portion_value()","get_words_tk()","getacl()","getaddress()","getaddress()","getaddress()","getaddress()","getaddress()","getaddress_orig()","getaddresses()","getaddresses()","getaddresses()","getaddresses()","getaddrinfo()","getaddrinfo()","getbinaryfile()","getbyte()","getbyte()","getbyte()","getbyte()","getbyte()","getbyte()","getc()","getc()","getc()","getc()","getc()","getc()","getch()","getch()","getch()","getdir()","getegid()","geteuid()","getgid()","getgm()","getgrent()","getgrgid()","getgrnam()","gethostbyaddr()","gethostbyname()","gethostbyname()","gethostname()","getifaddrs()","getlocal()","getlogin()","getname()","getname()","getname()","getname()","getnameinfo()","getnameinfo()","getnames()","getnames()","getnames()","getnames()","getok()","getopts()","getopts()","getopts()","getpass()","getpass()","getpeereid()","getpeername()","getpgid()","getpgrp()","getpriority()","getpty()","getpwent()","getpwnam()","getpwuid()","getquota()","getquotaroot()","getresource()","getresources()","getrlimit()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","gets()","getservbyname()","getservbyport()","getservername()","getservername()","getsid()","getsockname()","getsockopt()","getsockopt()","getter()","gettextfile()","getuid()","getutc()","getwd()","getwd()","getwd()","getwd()","getwd()","getwd()","gid()","gid()","gid=()","git()","git()","git()","git_commit_sha()","git_gem()","git_null()","git_path()","git_present?()","git_proxy()","git_push()","git_retry()","git_scope()","git_source()","git_source()","git_version()","git_version()","git_version()","git_version()","github()","github()","glob()","glob()","glob()","glob_files_in_dir()","glob_pattern()","global_config_file()","global_index_file()","global_root()","global_rubygems_source=()","global_variables()","globs_for()","gm()","gmt?()","gmt_offset()","gmtime()","gmtoff()","goto()","goto_column()","goto_id()","grammar()","grant_privilege()","grant_privilege()","grapheme_clusters()","great_job()","gregorian()","gregorian?()","gregorian_leap?()","grep()","grep()","grep_v()","grep_v()","group()","group()","group()","group()","group()","group()","group()","group()","group=()","group_by()","group_entries()","group_possibilities()","group_sub()","groups()","groups()","groups()","groups=()","groups_text()","grpowned?()","grpowned?()","grpowned?()","grpowned?()","gsub()","gsub()","gsub!()","gsub_file()","guard_clean()","guard_inspect_key()","guess()","guess()","guess()","guess()","guess_type()","guess_type_if_need()","guid()","guid()","gunzip()","gunzip()","gunzip()","gzip()","gzip()","gzip()","gzip()","gzip_to()","h()","h()","h()","h()","hadamard_product()","handle()","handle_argument_error?()","handle_argument_error?()","handle_arguments()","handle_attr()","handle_class_module()","handle_constants()","handle_entitydecl()","handle_error()","handle_exception()","handle_ifdefs_in()","handle_interrupt()","handle_method()","handle_missing_or_push_dependency_state()","handle_missing_or_push_dependency_state()","handle_no_command_error()","handle_no_method_error?()","handle_no_method_error?()","handle_options()","handle_pipe()","handle_singleton()","handle_tab_width()","handler()","handler()","handler=()","handlers()","handles?()","has_app_cache?()","has_app_cache?()","has_attributes?()","has_conflicts?()","has_elements?()","has_expires?()","has_key?()","has_key?()","has_key?()","has_key?()","has_key?()","has_key?()","has_key?()","has_local_dependencies?()","has_name?()","has_name?()","has_next?()","has_post_install_message?()","has_revision_cached?()","has_rubygems_remotes?()","has_text?()","has_value?()","has_value?()","has_value?()","has_value?()","has_value?()","has_value?()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash()","hash=()","hash?()","hash_algorithm()","hash_old()","have_author?()","have_author?()","have_author?()","have_author?()","have_children_elements()","have_const()","have_content?()","have_devel?()","have_extensions?()","have_file?()","have_framework()","have_func()","have_git?()","have_header()","have_library()","have_macro()","have_option?()","have_option?()","have_rdoc_4_plus?()","have_required_elements?()","have_required_elements?()","have_required_elements?()","have_required_elements?()","have_required_values?()","have_required_values?()","have_required_values?()","have_required_values?()","have_required_values?()","have_required_values?()","have_required_values?()","have_required_values?()","have_required_values?()","have_required_values?()","have_struct_member()","have_type()","have_var()","have_xml_content?()","have_xml_content?()","have_xml_content?()","head()","head2()","head?()","header()","header()","header()","header()","header()","header?()","header_convert()","header_converters()","header_fields_converter()","header_group_message()","header_outdated_message()","header_row?()","header_row?()","header_row?()","headers()","headers()","headers()","headers()","headers=()","headers=()","helo()","help()","help()","help()","help()","help()","help()","helpcontext()","helpcontext()","helpfile()","helpfile()","helpstring()","helpstring()","here?()","here?()","here?()","heredoc_end?()","hermitian?()","hessenberg_to_real_schur()","hex()","hex()","hexdigest()","hexdigest()","hexdigest()","hexdigest()","hexdigest!()","hexdigest!()","hexencode()","hidden()","hidden?()","hidden?()","hidden?()","hidden?()","hierarchical?()","hierarchical?()","hierarchical?()","hierarchical?()","higher()","history_file()","history_file=()","hkdf()","hmac_md5()","home()","home()","home_workspace()","hook()","hook()","hook_plugins()","host()","host()","host()","host()","host=()","host=()","host=()","hostname()","hostname()","hostname=()","hostname=()","hostname=()","hour()","hour()","hour()","hour=()","hour=()","href=()","hstack()","hstack()","html()","html()","html_escape()","html_escape()","html_escape()","html_name()","html_name()","hton()","http_default_port()","http_header()","http_proxy()","http_url()","http_url()","http_version()","httpdate()","httpdate()","httpdate()","httpdate()","httpdate()","httponly=()","https?()","https_default_port()","hypot()","i()","i_i_sym_list()","icon()","icon=()","iconv()","id()","id()","id()","id2name()","idempotent?()","ident()","identical?()","identical?()","identical?()","identical?()","identical?()","identical?()","identifier()","identity()","identity()","idle()","idle_done()","if_modified_since()","ifindex()","iflush()","ignorable_dependency?()","ignore()","ignore_broken_line()","ignore_config?()","ignore_unknown_element()","ignore_unknown_element=()","ignore_whitespace_nodes()","ignored?()","imag()","imag()","imag()","image()","image_button()","image_size=()","imaginary()","imaginary()","imaginary()","img()","implemented_ole_types()","implicit?()","import()","import_function()","import_symbol()","import_value()","in6_addr()","in_addr()","in_bundle?()","in_locked_deps?()","in_path()","in_root()","in_transaction()","in_transaction_wr()","inc()","inc()","include()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","include?()","included()","included()","included()","included()","included()","included()","included()","included_modules()","incompatible_argument_styles()","incompatible_argument_styles()","incomplete_input?()","incref()","increment()","indent()","indent()","indent()","indent()","indent=()","indent_re()","indent_text()","indent_text()","indentation()","indentation=()","independent?()","independent?()","index()","index()","index()","index()","index()","index()","index()","index()","index()","index()","index_file()","index_for()","index_in_parent()","indicate_progress()","indicate_progress()","indicate_progress()","indicate_progress()","indicate_progress()","infinite?()","infinite?()","infinite?()","infinite?()","infinity?()","inflate()","inflate()","inflate()","inflate()","inflate()","inflate()","info()","info()","info()","info()","info()","info()","info!()","info?()","info?()","info?()","info?()","info_path()","info_roots()","inherit_convert_attr_reader()","inherited()","inherited()","inherited()","inherited()","inherited_array_reader()","inherited_base()","inherited_base()","inherited_hash_reader()","inherited_reader()","init()","init()","init()","init()","init()","init_line_conversion_system()","init_ruby_model()","init_with()","init_with_ary()","init_with_hash()","initgroups()","initial_start_rdf()","initial_start_entry()","initial_start_feed()","initial_start_rss()","initial_state()","initial_state()","initialize()","initialize_clone()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_copy()","initialize_dup()","initialize_have_children_elements()","initialize_http_header()","initialize_methods_etc()","initialize_pattern()","initialize_pattern()","initialize_pattern()","initialize_pattern()","initialize_query()","initialize_readline()","initialize_regexp()","initialize_regexp()","initialize_regexp()","initialize_regexp()","initialize_tracer()","initialize_variables()","initialize_variables()","inject()","inject()","inject()","inject()","inject()","inject_dependencies()","inject_into_class()","inject_into_file()","inject_into_list()","inject_into_module()","inline_html?()","inline_html?()","inline_other?()","inline_other?()","inline_other_base64?()","inline_other_base64?()","inline_other_text?()","inline_other_text?()","inline_other_xml?()","inline_other_xml?()","inline_text?()","inline_text?()","inline_xhtml?()","inline_xhtml?()","inner()","inner_product()","inner_readline()","ino()","inplace_mode()","inplace_mode=()","input()","input=()","input=()","input?()","insecure_method?()","insert()","insert()","insert()","insert_after()","insert_before()","insert_into_file()","insert_output()","insert_text()","insert_text()","inside()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect()","inspect?()","inspect_colorable?()","inspect_mode=()","inspect_raw()","inspect_sockaddr()","inspect_value()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install()","install_accessor_base()","install_acl()","install_acl()","install_alias_method()","install_all_sources()","install_class_name()","install_date_element()","install_default_bundler_gem()","install_default_gems()","install_default_specs()","install_definition()","install_dublin_core()","install_element()","install_error_message()","install_executables()","install_extend_commands()","install_extend_commands()","install_file()","install_from_gemdeps()","install_from_spec()","install_from_specs()","install_gem()","install_gem()","install_gem_user()","install_get_attribute()","install_get_text_element()","install_git()","install_have_attribute_element()","install_have_child_element()","install_have_children_element()","install_hooks()","install_id_conv()","install_id_conv()","install_if()","install_image_favicon()","install_image_item()","install_in_parallel()","install_indices()","install_into()","install_lib()","install_list()","install_local_git()","install_model()","install_must_call_validator()","install_ns()","install_path()","install_path()","install_path()","install_path()","install_rdoc()","install_rubygems()","install_serially()","install_siginfo_handler()","install_specs()","install_tasks()","install_taxo_topic()","install_taxo_topics()","install_text_element()","install_update_defaults_str()","install_with_build_args()","install_with_settings()","install_with_worker()","installable?()","installable_platform?()","installable_platform?()","installable_platform?()","installation_attempted?()","installation_parallelization()","installation_satisfies_dependency?()","installed?()","installed?()","installed?()","installed?()","installed?()","installed?()","installed?()","installed_docs()","installed_plugins()","installed_specs()","installed_specs()","installed_stubs()","instance()","instance()","instance()","instance()","instance()","instance_attributes()","instance_delegate()","instance_eval()","instance_exec()","instance_method()","instance_method_list()","instance_methods()","instance_methods()","instance_of?()","instance_variable_defined?()","instance_variable_get()","instance_variable_set()","instance_variables()","instruction()","instruction()","instruction?()","instruction_sequence()","instructions()","int()","int()","int()","int()","int_from_prime_division()","integer?()","integer?()","integer_list()","integer_writer()","intern()","intern()","intern()","intern()","internal_class_of()","internal_encoding()","internal_encoding()","internal_encoding()","internal_object_id()","internal_super_of()","interpret_loosely()","interrupt()","intersect?()","intersection()","intersection()","inv()","invalidate_memoized_attributes()","inverse()","invert()","invert()","invert()","invert()","invert()","invert()","invert!()","invkind()","invoke()","invoke()","invoke()","invoke()","invoke_from_option()","invoke_kind()","invoke_service()","invoke_service_command()","invoke_thread()","invoke_with_build_args()","invoke_with_padding()","ioctl()","ioctl()","ioflush()","ip()","ip6_arpa()","ip6_int()","ip?()","ip_address()","ip_address_list()","ip_pktinfo()","ip_pktinfo()","ip_port()","ip_unpack()","ipaddr()","ipaddr=()","ipv4?()","ipv4?()","ipv4_compat()","ipv4_compat?()","ipv4_loopback?()","ipv4_mapped()","ipv4_mapped?()","ipv4_multicast?()","ipv4_multicast_loop()","ipv4_multicast_loop()","ipv4_multicast_ttl()","ipv4_multicast_ttl()","ipv4_private?()","ipv6?()","ipv6?()","ipv6_linklocal?()","ipv6_loopback?()","ipv6_mc_global?()","ipv6_mc_linklocal?()","ipv6_mc_nodelocal?()","ipv6_mc_orglocal?()","ipv6_mc_sitelocal?()","ipv6_multicast?()","ipv6_pktinfo()","ipv6_pktinfo()","ipv6_pktinfo_addr()","ipv6_pktinfo_ifindex()","ipv6_sitelocal?()","ipv6_to_ipv4()","ipv6_unique_local?()","ipv6_unspecified?()","ipv6_v4compat?()","ipv6_v4mapped?()","ipv6only!()","irb()","irb()","irb()","irb_abort()","irb_at_exit()","irb_context()","irb_exit()","irb_exit()","irb_level()","irb_load()","irb_load()","irb_require()","isequal()","is_a?()","is_alias_for()","is_array()","is_bool()","is_num()","is_reachable_from?()","is_reachable_from?()","is_version_1_2?()","isatty()","isatty()","isdst()","iseuc()","iseuc()","iseuc()","isjis()","isjis()","isjis()","iso8601()","iso8601()","iso8601()","iso8601()","iso8601()","iso8601()","issetugid()","issjis()","issjis()","issjis()","issue()","issuer()","issuer()","issuer()","issuer()","issuer=()","issuer=()","issuer_certificate=()","issuer_key_hash()","issuer_name_hash()","issuer_of()","issues_url()","isutf8()","isutf8()","isutf8()","italy()","items()","items()","iteration!()","iterator?()","itself()","iv=()","iv_len()","iv_len=()","j()","jacobian()","java_platform?()","java_platform?()","java_platform?()","jd()","jd()","jd()","jisx0301()","jisx0301()","jisx0301()","jisx0301()","jj()","join()","join()","join()","join()","join()","join()","join()","join()","join()","join()","join()","jruby?()","json_creatable?()","json_creatable?()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","json_create()","julian()","julian?()","julian_leap?()","k()","kconv()","kconv()","kconv()","keep_alive?()","keep_alive?()","keep_alive?()","keep_back()","keep_back()","keep_clean()","keep_drop()","keep_drop()","keep_end()","keep_end()","keep_if()","keep_if()","keep_if()","keep_if()","keep_only_files_and_directories()","keep_start()","keep_start()","keep_trying?()","kernel_exec()","kernel_load()","key()","key()","key()","key()","key()","key()","key()","key=()","key=()","key?()","key?()","key?()","key?()","key?()","key?()","key?()","key?()","key?()","key?()","key?()","key_for()","key_len()","key_len=()","keys()","keys()","keys()","keys()","keys()","keys()","keys()","keys()","keys()","keys_with_inspector()","kill()","kill()","kill()","kill()","kill()","kind_of?()","known_class?()","l()","la=()","label()","label()","lambda()","lambda?()","lang()","laplace_expansion()","last()","last()","last()","last()","lastbuilddate=()","last_attempt?()","last_column()","last_error()","last_error()","last_error=()","last_line()","last_lineno()","last_match()","last_modified()","last_modified()","last_status()","last_update()","last_update=()","last_version_number()","latest_gc_info()","latest_rubygems_version()","latest_spec_for()","latest_specs()","latest_specs()","latest_version()","latest_version?()","latest_version_for()","launch()","lazy()","lazy()","lchmod()","lchmod()","lchown()","lchown()","lcm()","ld()","ldd_available?()","ldexp()","leap?()","leap?()","leave()","left()","legacy_platform()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","length()","level()","level()","level()","level()","level()","level=()","level=()","level=()","level=()","level=()","level_notifier=()","levenshtein_distance()","levenshtein_distance()","lex()","lex_state_name()","lgamma()","lib_dirs_glob()","lib_files()","liberal_parsing?()","liberal_parsing?()","library_name()","libyaml_version()","license()","license=()","licenses()","licenses()","licenses=()","limit()","line()","line()","line()","line()","line()","line()","line()","line()","line0()","line_buffer()","line_editor()","line_width()","line_width=()","lineno()","lineno()","lineno()","lineno()","lineno()","lineno()","lineno()","lineno()","lineno()","lineno()","lineno()","lineno=()","lineno=()","lineno=()","lineno=()","lines()","lines()","lines()","lines()","lines()","lines()","linger()","linger()","link()","link()","link()","link()","link()","link()","link_command()","link_entry()","link_entry()","link_entry()","link_entry()","link_file()","link_local?()","link_to()","list()","list()","list()","list()","list()","list()","list()","list()","list()","list()","list()","list_files_in_directory()","list_item_from()","listable?()","listen()","listen()","listen()","listen()","listen()","listen()","listen()","listen()","listener()","listener()","listener()","listener=()","literal_head?()","literalize()","ljust()","ln()","ln()","ln()","ln()","ln()","ln_s()","ln_s()","ln_s()","ln_s()","ln_sf()","ln_sf()","ln_sf()","ln_sf()","load()","load()","load()","load()","load()","load()","load()","load()","load()","load()","load()","load()","load()","load_all()","load_and_instantiate()","load_api_keys()","load_cache()","load_certificate()","load_class()","load_class_data()","load_config()","load_data()","load_default_cert()","load_default_key()","load_defaults()","load_env_plugins()","load_file()","load_file()","load_file()","load_from_binary()","load_from_binary_extra_data()","load_gemdeps()","load_gemspec()","load_gemspec()","load_gemspec()","load_gemspec_uncached()","load_index()","load_marshal()","load_method()","load_mime_types()","load_mime_types()","load_options()","load_page()","load_path_insert_index()","load_paths()","load_paths()","load_paths()","load_paths()","load_plugin()","load_plugin_files()","load_plugins()","load_plugins()","load_plugins()","load_private_key()","load_public_key()","load_random_file()","load_rdoc()","load_rdoc()","load_spec()","load_spec_files()","load_spec_files()","load_specs()","load_stream()","load_thorfile()","load_variable_map()","load_yaml()","load_yaml()","loaded_from()","loaded_from()","loaded_from()","loaded_gem_paths()","loaded_spec_names()","loaded_specs()","local()","local()","local?()","local?()","local_address()","local_config_file()","local_index_file()","local_method?()","local_method?()","local_name()","local_name()","local_name=()","local_override!()","local_overrides()","local_platform()","local_root()","local_search()","local_specification_path()","local_specs()","local_variable_defined?()","local_variable_get()","local_variable_get()","local_variable_set()","local_variable_set()","local_variables()","local_variables()","local_variables()","locale()","locale=()","locale_charmap()","localtime()","location()","location()","location=()","location_of_caller()","locations()","lock()","lock()","lock()","lock()","lock()","lock()","lock()","lock_sources()","locked?()","locked_bundler_version()","locked_gems()","locked_puts()","locked_requirement_named()","locked_requirement_named()","locked_requirement_possibility_set()","locked_ruby_version()","locked_ruby_version_object()","lockfile_contents()","lockfile_path()","lockfile_version()","lockfiles_equal?()","log()","log()","log()","log()","log()","log()","log10()","log2()","log_error()","log_specs()","logging()","logging()","login()","login()","logo()","logo=()","logout()","long_desc()","long_name()","look_for_directives_in()","look_for_directives_in()","lookahead()","lookup()","lookup_color()","lookup_ring()","lookup_ring_any()","lookup_server()","loop()","loopback?()","lower()","lower_triangular?()","ls()","lshift!()","lstat()","lstat()","lstat()","lstrip()","lstrip!()","lsub()","ludecomp()","lup()","lup_decomposition()","lusolve()","lutime()","maglev?()","magnitude()","magnitude()","magnitude()","magnitude()","magnitude()","magnitude()","mail()","mailfrom()","mails()","main()","main()","main()","main=()","main_irb()","main_loop()","main_thread()","main_type()","major?()","major_deprecation()","major_version()","major_version()","major_version()","make()","make()","make()","make()","make_affine!()","make_closure()","make_command()","make_command()","make_compiler()","make_delimiter()","make_destination_dirs()","make_edge()","make_edge()","make_edge()","make_edge()","make_entry()","make_expires()","make_feed()","make_feed()","make_feed()","make_feed()","make_link()","make_message()","make_methods()","make_parser()","make_passwd()","make_passwd()","make_passwd()","make_pool()","make_regexp()","make_regexp()","make_regexp()","make_regexp()","make_separator()","make_socket()","make_start_tag()","make_switch()","make_symlink()","make_temp_directories()","make_thread_list()","make_time()","make_tuple()","make_variable_map()","make_xml_stylesheets()","makedirs()","makedirs()","makedirs()","makedirs()","maker()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","maker_target()","makers()","malloc()","malloc()","malloc()","malloc()","malloc_allocated_size()","malloc_allocations()","manage_owners()","many()","many1()","map()","map()","map()","map()","map()","map()","map()","map!()","map!()","map!()","map!()","map2()","map=()","map_gems_to_specs()","mapping?()","mapping?()","mark()","mark_loaded()","mark_version()","markup()","marshal_dump()","marshal_dump()","marshal_dump()","marshal_dump()","marshal_dump()","marshal_dump()","marshal_dump()","marshal_dump_old()","marshal_load()","marshal_load()","marshal_load()","marshal_load()","marshal_load()","marshal_load()","marshal_spec_dir()","marshal_version()","mask()","mask()","mask!()","mask=()","match()","match()","match()","match()","match()","match()","match()","match()","match()","match()","match()","match()","match()","match()","match?()","match?()","match?()","match?()","match?()","match?()","match?()","match?()","match_platform()","match_platform!()","match_platform?()","match_to()","match_to_consume()","matched()","matched?()","matched_size()","matches()","matches?()","matches?()","matches?()","matches?()","matches?()","matches?()","matches?()","matches?()","matches_for_glob()","matches_for_glob()","matches_spec?()","matches_spec?()","matching_specs()","materialize()","materialized_for_all_platforms()","max()","max()","max()","max()","max=()","max_by()","max_flag_count()","max_flag_count=()","max_nesting()","max_nesting=()","max_retries=()","max_version=()","max_version=()","maxgroups()","maxgroups=()","may_quoted?()","may_req_ambiguous_char_width()","maybe_xml?()","md5_available?()","mday()","mday()","mdtm()","measure()","measure()","media_subtype()","media_subtype()","media_subtype()","media_subtype()","mem_check_start()","member?()","member?()","member?()","member?()","member?()","member?()","member?()","member?()","member?()","member?()","members()","members()","memberwise()","memsize_of()","memsize_of_all()","merge()","merge()","merge()","merge()","merge()","merge()","merge()","merge()","merge()","merge!()","merge!()","merge!()","merge!()","merge!()","merge_key()","merge_options()","merge_path()","merge_path()","message()","message()","message()","message()","message()","message()","message()","message()","message()","message()","message()","message()","message()","message()","message()","message_loop()","message_with_trees()","meta_vars()","metadata_dependencies()","metadata_dependencies()","method()","method_added()","method_added()","method_defined?()","method_file()","method_id()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_missing()","method_option()","method_options()","method_removed()","method_undefined()","method_visibility()","methods()","methods()","methods()","methods_by_type()","methods_matching()","mfa_unauthorized?()","mime_split()","mime_type()","mime_type()","min()","min()","min()","min()","min()","min()","min_by()","min_version=()","min_version=()","mingw?()","minimum_indent()","minmax()","minmax()","minmax()","minmax_by()","minor()","minor?()","minor_version()","minor_version()","minute()","minute()","minute=()","minute=()","mirror_for()","missing_extensions?()","missing_extensions?()","missing_lockfile_dependencies()","missing_specs()","missing_specs?()","missing_version_message()","mjd()","mkcol()","mkdir()","mkdir()","mkdir()","mkdir()","mkdir()","mkdir()","mkdir()","mkdir()","mkdir_p()","mkdir_p()","mkdir_p()","mkdir_p()","mkdir_p()","mkdir_p()","mkdir_p_safe()","mkfifo()","mkmapexp()","mkpath()","mkpath()","mkpath()","mkpath()","mkpath()","mktime()","mktmpdir()","mlsd()","mlst()","mod_add()","mod_exp()","mod_inverse()","mod_mul()","mod_sqr()","mod_sub()","mode()","mode()","models()","module()","module?()","module?()","module_eval()","module_exec()","module_function()","module_names()","modules()","modules_hash()","modules_hash()","modulo()","modulo()","modulo()","modulo()","mon()","mon()","mon_check_owner()","mon_check_owner()","mon_enter()","mon_enter()","mon_exit()","mon_exit()","mon_initialize()","mon_locked?()","mon_locked?()","mon_owned?()","mon_owned?()","mon_synchronize()","mon_synchronize()","mon_try_enter()","mon_try_enter()","monday?()","monday?()","monotonic_time()","month()","month()","month_days()","mount()","mount_proc()","mountpoint?()","move()","move()","move()","move()","move()","move()","move()","move_version_to_end()","mri?()","mswin64?()","mswin?()","mtime()","mtime()","mtime()","mtime()","mtime()","mtime()","mtime=()","mu_lock()","mu_locked?()","mu_pp()","mu_synchronize()","mu_try_lock()","mu_unlock()","mul()","mult()","multipart?()","multipart?()","multipart?()","multipart?()","multipart?()","multipart?()","multipart?()","multipart_form()","must_c_version()","must_call_validators()","mute()","mute?()","mv()","mv()","mv()","mv()","n_bytes()","n_indent()","n_jobs()","n_mails()","n_rrconflicts()","n_rrconflicts()","n_srconflicts()","n_srconflicts()","n_useless_nonterminals()","n_useless_rules()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name()","name=()","name=()","name=()","name=()","name=()","name_for()","name_for()","name_for()","name_for()","name_for()","name_for()","name_for_explicit_dependency_source()","name_for_explicit_dependency_source()","name_for_explicit_dependency_source()","name_for_explicit_dependency_source()","name_for_explicit_dependency_source()","name_for_locking_dependency_source()","name_for_locking_dependency_source()","name_for_locking_dependency_source()","name_for_locking_dependency_source()","name_for_locking_dependency_source()","name_for_path()","name_for_path()","name_list()","name_path()","name_pattern()","name_prefix()","name_prefix()","name_tuple()","name_tuple()","named_captures()","named_captures()","names()","names()","names()","names()","names()","names_path()","namespace()","namespace()","namespace()","namespace()","namespace()","namespace=()","namespace_context()","namespace_context=()","namespace_from_thor_class()","namespace_of()","namespace_uri()","namespaces()","namespaces()","namespaces=()","namespaces=()","namespaces_in_content()","namesplit()","nan?()","nan?()","nary()","native()","nc()","need_base64_encode?()","need_base64_encode?()","need_convert?()","need_initialize_variables()","need_initialize_variables()","need_keeper?()","need_parent?()","need_parent?()","need_source_encoding_update?()","need_static_convert?()","needs()","negative?()","negative?()","negative?()","negative?()","nest()","nesting()","netmask()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new()","new!()","new_alias_name()","new_comment()","new_cond()","new_cond()","new_default_spec()","new_internet_message_io()","new_ntoh()","new_offset()","new_platform?()","new_seed()","new_spec_satisfied?()","new_specs()","new_start()","new_toplevel()","new_value()","new_with()","new_with()","new_with_uri()","new_with_uri()","new_with_value_if_need()","newobj()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next()","next!()","next5()","next_current()","next_day()","next_element()","next_float()","next_line()","next_month()","next_sibling=()","next_sibling_node()","next_sibling_node()","next_token()","next_token()","next_token()","next_update()","next_update()","next_update=()","next_values()","next_year()","nfa()","nfa()","nil?()","nil?()","nkf()","nlink()","nlsolve()","nlst()","nmake_found?()","no?()","no?()","no?()","no_commands()","no_commands?()","no_commands_context()","no_tasks()","nobits?()","node_test()","node_type()","node_type()","node_type()","node_type()","node_type()","node_type()","node_type()","node_type()","node_type()","node_type()","noecho()","noecho()","non_aliases()","non_nil_attributes()","nonassoc()","nonblock()","nonblock=()","nonblock?()","nondevelopment_dependencies()","none?()","none?()","none?()","nonterminal?()","nonterminal_base()","nonterminals()","nonzero?()","nonzero?()","noop()","noop()","norm()","norm()","normal?()","normalize()","normalize()","normalize()","normalize()","normalize()","normalize()","normalize()","normalize()","normalize()","normalize()","normalize!()","normalize!()","normalize_comment()","normalize_compare_values()","normalize_converters()","normalize_group_options()","normalize_groups()","normalize_hash()","normalize_options()","normalize_path()","normalize_path()","normalize_path()","normalize_rss()","normalize_searching_criteria()","normalize_settings()","normalize_source()","normalize_space()","normalize_uri()","normalize_uri()","normalize_uri()","normalize_yaml_input()","normalized()","normalized_file_list()","not()","not_after()","not_after=()","not_before()","not_before=()","not_debugging?()","not_debugging?()","not_found()","not_need_to_call_setup_maker_variables()","not_need_to_call_setup_maker_variables()","not_set_name()","not_set_name()","not_set_name()","not_set_name()","not_set_name()","not_set_name()","not_set_name()","not_set_name()","not_set_name()","not_set_name()","not_set_required_variables()","not_set_required_variables()","not_set_required_variables()","not_set_required_variables()","not_set_required_variables()","not_set_required_variables()","not_set_required_variables()","not_set_required_variables()","not_set_required_variables()","notation()","notationdecl()","notationdecl()","notationdecl?()","notations()","note()","note_for()","notes()","nothing_changed?()","nothing_outdated_message()","notice()","notify()","notify()","notify()","notify?()","notify?()","notify?()","notify_event()","notify_observers()","notify_observers()","notwice()","now()","now()","nowrite()","npn_protocol()","nprocessors()","nread()","ns_declarations()","nsec()","nt_max()","nth_kday()","nth_kday()","nth_kday?()","ntop()","null()","null()","null=()","null=()","null?()","nullable?()","nullable?()","num_bits()","num_bytes()","num_waiting()","num_waiting()","number()","numerator()","numerator()","numerator()","numerator()","numerator()","object_address_group()","object_class()","object_group()","object_id()","object_nl()","object_nl=()","oct()","oct()","oct_or_256based()","odd?()","odd?()","of()","of()","off()","off_event()","offset()","offset()","offset_vtbl()","oflush()","oid()","oid()","oid()","oid=()","oid=()","ok?()","ok_to_remove?()","old_enc=()","ole_activex_initialize()","ole_classes()","ole_classes()","ole_free()","ole_free()","ole_func_methods()","ole_get_methods()","ole_instance_variable_get()","ole_instance_variable_set()","ole_method()","ole_method_help()","ole_methods()","ole_methods()","ole_methods_safely()","ole_obj_help()","ole_put_methods()","ole_query_interface()","ole_reference_count()","ole_respond_to?()","ole_show_help()","ole_type()","ole_type()","ole_type()","ole_type()","ole_type_detail()","ole_type_detail()","ole_typelib()","ole_typelib()","ole_types()","on()","on()","on_char()","on_attr_charref()","on_attr_charref_hex()","on_attr_entityref()","on_attr_value()","on_attribute()","on_backref()","on_charref()","on_charref_hex()","on_comma()","on_comment()","on_connect()","on_const()","on_curve?()","on_cvar()","on_default()","on_default()","on_entityref()","on_error()","on_error()","on_etag()","on_event()","on_event_with_outargs()","on_float()","on_gvar()","on_head()","on_heredoc_beg()","on_heredoc_end()","on_ident()","on_ignored_nl()","on_ignored_sp()","on_imaginary()","on_int()","on_ivar()","on_kw()","on_lbrace()","on_lbracket()","on_lparen()","on_nl()","on_op()","on_period()","on_rational()","on_rbrace()","on_rbracket()","on_rparen()","on_sp()","on_stag()","on_stag_end()","on_stag_end_empty()","on_symbeg()","on_tail()","on_tstring_beg()","on_tstring_end()","on_variables()","on_windows?()","on_xmldecl_encoding()","on_xmldecl_end()","on_xmldecl_standalone()","on_xmldecl_version()","once_writer()","one?()","one?()","one?()","ongoing_visibility=()","opaque=()","opaque=()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open()","open!()","open_and_lock_file()","open_editor()","open_editor()","open_gem()","open_message_stream()","open_server()","open_server()","open_server()","open_uri_or_path()","open_uri_original_open()","open_uri_original_open()","opendir()","opened?()","operating_system_defaults()","option()","option()","option()","option_is_deprecated?()","option_list()","option_list()","optional?()","options()","options()","options()","options()","options()","options()","options()","options()","options()","options()","options()","options=()","options=()","options_of()","options_of()","options_to_lock()","optname()","ord()","ord()","order()","order()","order!()","order!()","ordering=()","ordinal()","ordinal()","orig_initialize()","orig_name()","orig_name=()","original_env()","original_exec()","original_name()","original_name()","original_system()","orthogonal?()","os_code()","os_match()","other_elements()","otool_available?()","out()","out_of_line?()","out_of_line?()","out_of_space_message()","outact()","outdated()","outdated()","outdated?()","outdated_and_latest_version()","output()","output()","output()","output()","output()","output=()","output=()","output?()","output_conflict()","output_encoding=()","output_flag_file()","output_modifier_proc=()","output_name()","output_post_install_messages()","output_query_results()","output_rule()","output_state()","output_token()","output_useless()","output_versions()","output_without_groups_message()","outrrconf()","outsrconf()","override_for()","owned?()","owned?()","owned?()","owned?()","owned?()","owner()","owner()","p()","p()","pack()","pack()","pack_sockaddr_in()","pack_sockaddr_un()","package_name()","padding=()","padding=()","page()","page_file()","page_name()","pair()","pair()","paragraph()","parallel_compact_index_client()","param_list()","param_seq()","parameters()","parameters()","parameters()","parameters()","params()","params()","params()","params()","params()","params=()","params_ok?()","paranoid()","parent()","parent()","parent()","parent()","parent=()","parent=()","parent=()","parent?()","parent?()","parent_file_name()","parent_name()","parent_name()","parent_of()","parent_of()","parent_setting_for()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse()","parse!()","parse!()","parse!()","parse!()","parse_alias()","parse_arg()","parse_args()","parse_args()","parse_attr()","parse_attr_accessor()","parse_attributes()","parse_bind_options()","parse_bundled_with()","parse_call_parameters()","parse_class()","parse_column_end()","parse_column_value()","parse_comment()","parse_comment_tomdoc()","parse_config()","parse_config_lines()","parse_constant()","parse_constant_visibility()","parse_ctype()","parse_dependency()","parse_dependency()","parse_dn()","parse_dn()","parse_dot_doc_file()","parse_entries()","parse_file()","parse_file()","parse_file()","parse_file()","parse_files()","parse_files_matching()","parse_form_data()","parse_form_data()","parse_gem()","parse_header()","parse_header()","parse_headers()","parse_helper()","parse_id()","parse_id_invalid_details()","parse_int()","parse_line()","parse_line_number_from_description()","parse_make_command_line()","parse_meta_attr()","parse_meta_method()","parse_metadata()","parse_method()","parse_method_dummy()","parse_method_or_yield_parameters()","parse_method_parameters()","parse_method_params_and_body()","parse_mlsx_entry()","parse_module()","parse_name()","parse_no_quote()","parse_openssl()","parse_option_string()","parse_pasv_ipv4_host()","parse_pasv_ipv6_host()","parse_pasv_port()","parse_pi_content()","parse_platform()","parse_printf_format()","parse_query()","parse_query()","parse_query()","parse_query()","parse_quotable_loose()","parse_quotable_robust()","parse_quoted_column_value()","parse_qvalues()","parse_qvalues()","parse_range_header()","parse_range_header()","parse_require()","parse_rescue()","parse_rfc2253()","parse_row_end()","parse_ruby()","parse_set_cookie()","parse_set_cookies()","parse_signature()","parse_source()","parse_source()","parse_source()","parse_spec()","parse_statements()","parse_stream()","parse_stream()","parse_struct_signature()","parse_symbol_arg()","parse_symbol_in_arg()","parse_time()","parse_top_level_statements()","parse_unquoted_column_value()","parse_uri()","parse_user_code()","parse_visibility()","parse_yield()","parser()","parser()","parser()","parser()","parser()","parser=()","parser_class()","parser_class()","parser_class()","parser_enumerator()","parser_fields_converter()","parser_file()","parser_options()","partition()","partition()","pass()","passwd()","password()","password()","password=()","password=()","password_field()","patch()","patch_level_options()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path()","path2class()","path=()","path=()","path=()","path?()","path_ok?()","path_separator()","path_separator()","path_to?()","path_to?()","pathconf()","paths()","paths()","paths=()","pattern()","pattern()","pause()","pbkdf2_hmac()","pbkdf2_hmac()","pbkdf2_hmac_sha1()","peek()","peek()","peek()","peek()","peek()","peek_read()","peek_result()","peek_tk()","peek_values()","peep()","peer_cert()","peer_cert()","peer_cert_chain()","peeraddr()","peeraddr()","peeraddr()","peg_parse()","pem_files_in()","pending()","pending_interrupt?()","pending_interrupt?()","percent_doc()","perform_bundle_install()","perform_git_push()","permanent_link=()","permanent_link?()","permutation()","permutation?()","permute()","permute!()","permute!()","pfamily()","phase()","phase()","phase()","pick_best!()","pid()","pid()","pid()","pid()","pin_gem_source()","pinned_spec_names()","pipe()","pipe?()","pipe?()","pipe?()","pipe?()","pipeline()","pipeline()","pipeline_r()","pipeline_r()","pipeline_rw()","pipeline_rw()","pipeline_start()","pipeline_start()","pipeline_w()","pipeline_w()","pkcs5_keyivgen()","pkg_config()","plain_specs()","plain_specs=()","platform()","platform()","platform()","platform()","platform()","platform()","platform()","platform=()","platform_defaults()","platform_sort_key()","platform_specificity_match()","platform_specificity_match()","platform_string()","platform_version_match()","platforms()","platforms()","platforms()","platforms()","platforms=()","platforms_match?()","plugin()","plugin()","plugin_commands()","plugin_path()","plural_forms()","point()","point=()","point_conversion_form()","point_conversion_form=()","pointer()","pointer=()","pointer_out()","polar()","polar()","polar()","pool_available()","pool_shutdown()","pool_size()","pools_for()","pop()","pop()","pop()","pop()","pop()","pop()","pop()","pop()","pop!()","pop!()","pop_inspect_key()","pop_possibility_state()","pop_possibility_state()","pop_token()","pop_workspace()","popen()","popen()","popen2()","popen2()","popen2e()","popen2e()","popen3()","popen3()","popup_menu()","port()","port()","port=()","port=()","pos()","pos()","pos()","pos()","pos()","pos()","pos()","pos()","pos=()","pos=()","pos=()","pos=()","pos=()","position()","position()","position()","position()","position()","position()","positive?()","positive?()","positive?()","positive_integer_writer()","possibilities()","possibilities()","possibilities_for_requirement()","possibility()","possibility()","possibility()","possibility_satisfies_requirements?()","post()","post()","post2()","post_build()","post_connection_check()","post_form()","post_install()","post_install()","post_install()","post_install_message()","post_match()","post_match()","post_reset()","post_reset_hooks()","post_sort()","post_uninstall()","pow()","power()","pp()","pp()","pp()","pp()","pp()","pp()","pp_hash()","pp_object()","ppid()","ppx()","ppx()","pre_input_hook()","pre_input_hook=()","pre_input_hook=()","pre_install()","pre_install_checks()","pre_install_checks()","pre_match()","pre_match()","pre_reset()","pre_uninstall()","pread()","prec()","precedence()","precedence=()","precedence_table()","preceding()","preceding_node_of()","precs()","pred()","predecessors()","predecessors()","predicate()","predicate()","predicate()","predicate_to_string()","prefetch()","prefetch()","prefetch()","prefetch()","prefetch()","prefetch()","prefix()","prefix()","prefix()","prefix()","prefix=()","prefix_of()","prefixes()","prefixes()","prepare()","prepare()","prepare_backslash()","prepare_format()","prepare_header()","prepare_header()","prepare_line()","prepare_message()","prepare_output()","prepare_parser()","prepare_quote_character()","prepare_quoted()","prepare_separators()","prepare_skip_lines()","prepare_strip()","prepare_unquoted()","prepare_variable()","prepend()","prepend()","prepend()","prepend()","prepend()","prepend()","prepend_features()","prepend_file()","prepend_to_file()","prepended()","prerelease()","prerelease=()","prerelease=()","prerelease?()","prerelease?()","prerelease?()","prerelease?()","prerelease_specs()","preserve_paths()","pressed?()","pretty()","pretty_dep()","pretty_dependency()","pretty_generate()","pretty_inspect()","pretty_name()","pretty_name()","pretty_new_name()","pretty_old_name()","pretty_print()","pretty_print()","pretty_print()","pretty_print()","pretty_print_children()","pretty_values_for()","prev_day()","prev_float()","prev_month()","prev_year()","previous=()","previous_element()","previous_sibling=()","previous_sibling_node()","primary()","prime?()","prime?()","prime?()","prime_division()","prime_division()","prime_fasttest?()","primitive_convert()","primitive_errinfo()","print()","print()","print()","print()","print()","print()","print()","print()","print()","print()","print()","print()","print_atab()","print_command()","print_gem()","print_gem_info()","print_gem_path()","print_gems()","print_in_columns()","print_major_deprecations!()","print_mem_leaks()","print_options()","print_post_install_message()","print_tab()","print_tab_i()","print_table()","print_usage()","print_using_message()","print_wrapped()","printable_commands()","printable_commands()","printable_tasks()","printable_tasks()","printb()","printf()","printf()","printf()","printf()","printf()","printf()","printf()","printf()","printf()","printf()","printn()","printn()","prints_major_deprecations?()","priority()","priority=()","pristine()","private()","private?()","private?()","private?()","private?()","private?()","private_call?()","private_class_method()","private_constant()","private_decrypt()","private_encrypt()","private_instance_methods()","private_iv_get()","private_key()","private_key=()","private_key=()","private_key?()","private_method?()","private_method?()","private_method_defined?()","private_methods()","probe_writtable_socket()","proc()","proc()","proc?()","procdest()","process()","process()","process()","process()","process_args()","process_based_port()","process_based_port()","process_instruction()","process_queue()","process_specs()","process_title()","process_topmost_state()","process_topmost_state()","processinginstruction()","processing_instruction()","processing_instruction()","processor_count()","produce()","product()","progid()","progids()","program_name()","progress()","progress_rate()","progress_rate()","progress_reporter()","prompt_mode=()","prompt_proc=()","prompting?()","proper_subset?()","proper_superset?()","propfind()","proppatch()","protected()","protected_instance_methods()","protected_method_defined?()","protected_methods()","protected_methods()","protocol()","provide()","provides?()","provides?()","proxy=()","proxy?()","proxy_address()","proxy_basic_auth()","proxy_basic_auth()","proxy_bypass?()","proxy_class?()","proxy_for()","proxy_from_env()","proxy_from_env?()","proxy_pass()","proxy_port()","proxy_uri()","proxy_user()","proxyaddr()","proxyport()","prune()","prune()","prune_cache()","prune_gem_cache()","prune_git_and_path_cache()","pseudo_bytes()","ptr()","ptr_bug!()","pubdate()","pubdate()","pubdate=()","pubdate=()","public()","public()","public?()","public?()","public?()","public?()","public_class_method()","public_command()","public_constant()","public_decrypt()","public_encrypt()","public_instance_method()","public_instance_methods()","public_key()","public_key()","public_key()","public_key()","public_key()","public_key()","public_key()","public_key=()","public_key=()","public_key=()","public_key=()","public_key?()","public_method()","public_method_defined?()","public_methods()","public_methods()","public_send()","public_task()","pull()","pull()","pull_event()","purgeable?()","purpose=()","purpose=()","push()","push()","push()","push()","push()","push()","push()","push()","push()","push()","push()","push_action()","push_action()","push_inspect_key()","push_state_for_requirements()","push_state_for_requirements()","push_workspace()","put()","put()","put_state_transition_table()","put_string()","putback()","putbinaryfile()","putc()","putc()","putc()","putc()","putc()","puts()","puts()","puts()","puts()","puts()","puts()","puts()","puts()","puts()","puts()","puts()","puts()","puts()","puttextfile()","pwd()","pwd()","pwd()","pwd()","pwd()","pwd()","pwd()","pwd()","pwrite()","qdval()","query()","query=()","query=()","quick()","quick_gem()","quiet()","quiet=()","quiet?()","quiet?()","quit()","quit()","quo()","quo()","quo()","quo()","quo()","quote()","quote()","quote()","quote()","quote_char()","quote_character()","quote_field()","quote_string()","quoting_detection_proc()","quoting_detection_proc=()","r()","racc_accept()","racc_e_pop()","racc_next_state()","racc_print_stacks()","racc_print_states()","racc_read_token()","racc_reduce()","racc_shift()","racc_token2str()","radio_button()","radio_group()","raise()","raise()","raise()","raise()","raise_error_unless_state()","raise_for_undefined_entity?()","raise_for_undefined_entity?()","raise_for_undefined_entity?()","raised_exception()","rake_classes()","rake_namespace()","rand()","rand()","rand()","rand()","random_add()","random_bytes()","random_bytes()","random_iv()","random_key()","random_number()","random_string()","random_string()","range()","range=()","range_length()","rank()","rank_e()","rassoc()","rassoc()","rassoc()","rationalize()","rationalize()","rationalize()","rationalize()","rationalize()","raw()","raw()","raw!()","raw_cookie()","raw_cookie2()","raw_data()","raw_encoding()","raw_require_paths()","raw_spec()","rb_files_in()","rb_scan_args()","rbx?()","rcptto()","rcptto_list()","rdev()","rdev_major()","rdev_minor()","rdoc()","rdoc_installed?()","rdoc_installed?()","rdoc_options()","rdoc_options=()","rdoc_target()","rdoc_target()","rdoc_task_description()","rdoc_task_description()","rdoc_task_name()","rdoc_task_name()","re_exchange()","re_exchange()","re_exchangeable?()","re_exchangeable?()","re_sign()","re_sign_cert()","re_sign_cert()","reachable_objects_from()","reachable_objects_from_root()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read()","read_all()","read_all()","read_binary()","read_binary()","read_binary()","read_body()","read_body_0()","read_cache()","read_checksums()","read_chunk()","read_directive()","read_documentation_modifiers()","read_escaped_key()","read_file()","read_file()","read_file()","read_from_cmdline()","read_io()","read_multipart()","read_nonblock()","read_nonblock()","read_nonblock()","read_nonblock()","read_smime()","read_status_line()","read_timeout=()","read_timeout=()","read_timeout=()","read_timeout=()","read_with_substitution()","readable?()","readable?()","readable?()","readable?()","readable?()","readable_after_eof?()","readable_after_eof?()","readable_after_eof?()","readable_after_eof?()","readable_real?()","readable_real?()","readable_real?()","readable_real?()","readagain_bytes()","readbyte()","readbyte()","readbyte()","readbyte()","readchar()","readchar()","readchar()","readchar()","readchar()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readline()","readlines()","readlines()","readlines()","readlines()","readlines()","readlines()","readlines()","readlines()","readlines()","readlines()","readlink()","readlink()","readmultiline()","readpartial()","readpartial()","readpartial()","readpartial()","readpartial()","readpartial()","readpartial()","reads()","ready()","ready?()","ready_to_enqueue?()","real()","real()","real()","real?()","real?()","real?()","real_load()","realdirpath()","realdirpath()","realloc()","really_verbose()","realpath()","realpath()","realtime()","realtime()","reason()","reason()","reason_phrase()","reason_phrase()","reason_phrase()","receive()","receive_responses()","receiver()","receiver()","receiver()","receiver()","receiver()","recipients()","reconnect()","reconnect_ssl()","record_depth()","record_entity_expansion()","record_location()","record_location()","record_path()","record_requirements()","record_response()","recover()","rect()","rect()","rect()","rect()","rectangular()","rectangular()","rectangular()","rectangular()","recurse_proc()","recursive_predecessors()","recursive_predecessors()","recursive_successors()","recursive_successors()","recv()","recv_io()","recv_nonblock()","recv_response()","recvfrom()","recvfrom()","recvfrom()","recvfrom_nonblock()","recvfrom_nonblock()","recvmsg()","recvmsg_nonblock()","redefine_method()","redirect?()","redirect?()","redirect_to_directory_uri()","redisplay()","reduce()","reduce()","reduce_n()","reduce_table()","reduce_to_hessenberg()","ref()","reference()","refine()","reformatted_help_args()","refresh()","refresh_line()","refute_path_exists()","regenerate_binstubs()","regexp()","regexp()","regexp()","regexp()","regist()","regist_server()","regist_server()","register()","register()","register()","register()","register()","register()","register()","register_command()","register_default_spec()","register_empty()","register_plugin()","register_plugin()","register_uri()","registry=()","registry=()","regular?()","rehash()","rehash()","reject()","reject()","reject()","reject()","reject()","reject()","reject()","reject()","reject()","reject()","reject()","reject()","reject()","reject!()","reject!()","reject!()","reject!()","reject!()","reject!()","reject!()","relative?()","relative?()","relative?()","relative_matches()","relative_path()","relative_path_from()","relative_to_original_destination_root()","release()","release()","release?()","relevant_sources_for_vertex()","reload()","reload()","reload()","reload()","remainder()","remainder()","remainder()","remembered_flag_deprecation()","remote!()","remote!()","remote!()","remote!()","remote!()","remote=()","remote?()","remote_address()","remote_ip()","remote_specs()","remote_uri()","remote_uri()","remotes_for_spec()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove()","remove_all()","remove_argument()","remove_auth()","remove_auth()","remove_blank_lines()","remove_by_name()","remove_cache()","remove_class_option()","remove_class_variable()","remove_coding_comment()","remove_command()","remove_commented_out_lines()","remove_const()","remove_deps()","remove_dir()","remove_dir()","remove_dir()","remove_dir()","remove_dir()","remove_dir()","remove_entry()","remove_entry()","remove_entry()","remove_entry()","remove_entry_secure()","remove_entry_secure()","remove_entry_secure()","remove_entry_secure()","remove_executables()","remove_file()","remove_file()","remove_file()","remove_file()","remove_file()","remove_from_documentation?()","remove_frozen_string_literal()","remove_gems_from_dependencies()","remove_gems_from_gemfile()","remove_handler()","remove_installed!()","remove_instance_variable()","remove_invisible()","remove_invocation()","remove_magic_comment()","remove_method()","remove_modeline()","remove_nested_blocks()","remove_nodoc()","remove_nodoc_children()","remove_old_bin_files()","remove_old_lib_files()","remove_option()","remove_owners()","remove_platform()","remove_private()","remove_private_comment()","remove_response_handler()","remove_server()","remove_server()","remove_siginfo_handler()","remove_specs_unsatisfied_by()","remove_stress_to_class()","remove_task()","remove_token_listener()","remove_unparseable()","removed_method_calls()","removed_specs()","renamable?()","rename()","rename()","rename()","rename()","render_frame()","renew()","renew()","reopen()","reopen()","reopen()","reopen()","reorganize()","repeated_combination()","repeated_permutation()","replace()","replace()","replace()","replace()","replace()","replace()","replace()","replace()","replace()","replace()","replace()","replace()","replace!()","replace!()","replace_bin_path()","replace_child()","replace_entrypoints()","replace_gem()","replace_location()","replace_remotes()","replace_sources!()","replace_with()","replacement()","replacement=()","replicate()","replies?()","reply()","reply_service()","report()","report()","report()","report_attributes()","report_class_module()","report_constants()","report_methods()","report_on_exception()","report_on_exception()","report_on_exception=()","report_on_exception=()","repository_subdirectories()","represent_map()","represent_object()","represent_scalar()","represent_seq()","request()","request()","request()","request()","request()","request_body_permitted?()","request_context()","request_get()","request_head()","request_issue_report_for()","request_path()","request_post()","request_uri()","request_uri()","requested_dependencies()","requested_groups()","requested_specs()","requested_specs()","requester()","requests()","require()","require()","require()","require()","require()","require_io_console()","require_nested_dependencies_for()","require_nested_dependencies_for()","require_path()","require_path=()","require_path_or_force()","require_paths()","require_paths()","require_paths=()","require_relative()","require_thor_actions()","require_tree_for_spec()","required_arguments_for()","required_arguments_for()","required_attribute?()","required_attributes()","required_element?()","required_element?()","required_options()","required_options()","required_prefix()","required_prefix()","required_prefix()","required_prefix()","required_prefix()","required_prefix()","required_prefix()","required_prefix()","required_prefix()","required_ruby_version=()","required_rubygems_version=()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_uri()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variable_names()","required_variables_are_set?()","requirement()","requirement()","requirement()","requirement()","requirement()","requirement!()","requirement_for_existing_name()","requirement_for_existing_name()","requirement_satisfied_by?()","requirement_satisfied_by?()","requirement_satisfied_by?()","requirement_satisfied_by?()","requirement_satisfied_by?()","requirement_satisfied_by?()","requirement_tree_for()","requirement_tree_for()","requirement_trees()","requirement_trees()","requirements()","requirements()","requirements()","requirements()","requirements()","requirements=()","requirements_list()","requires()","requires_checkout?()","requires_sudo?()","requires_sudo?()","requires_sudo?()","rerdoc_task_description()","rerdoc_task_description()","rerdoc_task_name()","rerdoc_task_name()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset()","reset!()","reset!()","reset_nil_attributes_to_default()","reset_paths!()","reset_rubygems!()","resolve()","resolve()","resolve()","resolve()","resolve()","resolve()","resolve()","resolve()","resolve()","resolve()","resolve_activated_specs()","resolve_aliases()","resolve_class()","resolve_current()","resolve_if_needed()","resolve_name()","resolve_path()","resolve_remotely!()","resolve_row_separator()","resolve_rr()","resolve_sr()","resolve_with_cache!()","resources()","resources()","respond_to?()","respond_to?()","respond_to?()","respond_to?()","respond_to?()","respond_to?()","respond_to_missing?()","respond_to_missing?()","respond_to_missing?()","response_body_permitted?()","response_class()","responses()","rest()","rest()","rest?()","rest_size()","restore()","restore()","restore()","restore()","restore()","restore()","restore()","restore()","restsize()","result()","result()","result()","result()","result_with_hash()","resume()","resume()","resume()","retrbinary()","retrieve_active_spec()","retrieve_comment_body()","retrieve_heredoc_info()","retrlines()","return_headers?()","return_headers?()","return_type()","return_type_detail()","return_value()","return_vtype()","retval?()","reverse()","reverse()","reverse()","reverse!()","reverse!()","reverse_each()","reverse_each()","reverse_each()","reverse_each()","reverse_rubygems_kernel_mixin()","reversed_requirement_tree_index()","revision()","revision()","revive()","revive_hash()","revocation_reason()","revocation_time()","revoked()","revoked=()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind()","rewind_to()","rewind_to()","rewind_to()","rewind_to()","rfc1123_date()","rfc2822()","rfc2822()","rfc2822()","rfc2822()","rfc2822()","rfc3339()","rfc3339()","rfc3339()","rfc3339()","rfc822()","rfc822()","rfc822()","rfc822()","rfc822()","rg_full_gem_path()","rg_loaded_from()","ri_dir()","ri_installed?()","ri_installed?()","ri_paths()","rid()","rid()","right()","rindex()","rindex()","rjust()","rm()","rm()","rm()","rm()","rm_f()","rm_f()","rm_f()","rm_f()","rm_r()","rm_r()","rm_r()","rm_r()","rm_rf()","rm_rf()","rm_rf()","rm_rf()","rm_rf()","rmdir()","rmdir()","rmdir()","rmdir()","rmdir()","rmdir()","rmdir()","rmtree()","rmtree()","rmtree()","rmtree()","rmtree()","root()","root()","root()","root()","root()","root()","root()","root()","root()","root()","root()","root()","root?()","root?()","root_node()","root_search()","root_vertex_named()","root_vertex_named()","roots()","rotate()","rotate!()","round()","round()","round()","round()","round()","round()","round()","round()","round()","route_from()","route_from()","route_to()","route_to()","row()","row_count()","row_sep()","row_separator()","row_size()","row_vector()","row_vectors()","rows()","rpartition()","rr_conflict()","rrconflict_exist?()","rruleid()","rset()","rshift!()","rss()","rstrip()","rstrip!()","ruby()","ruby()","ruby()","ruby2_keywords()","ruby2_keywords()","ruby2_keywords_hash()","ruby2_keywords_hash?()","ruby=()","ruby?()","ruby_api_version()","ruby_code()","ruby_command()","ruby_engine()","ruby_engine()","ruby_scope()","ruby_shebang?()","ruby_version()","ruby_version()","rubybin()","rubygem_push()","rubygems()","rubygems_aggregate_class()","rubygems_aggregate_class()","rubygems_api_key()","rubygems_api_key=()","rubygems_api_request()","rubygems_dir()","rubygems_dir()","rubygems_primary_remotes()","rubygems_remotes()","rubygems_sources()","rubygems_target_version()","rubygems_version()","rule()","rule()","rule()","ruleid()","rules()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run()","run_hooks()","run_ruby_script()","running?()","runtime?()","runtime_dependencies()","runtime_source()","s3_uri_signer()","safe_delete()","safe_level()","safe_load()","safe_load()","safe_unlink()","safe_unlink()","safe_unlink()","safe_unlink()","same_attributes?()","same_feed_type?()","sample()","sanitize()","sanitize_path()","sanitize_string()","satisfied_by?()","satisfies?()","satisfies_locked_spec?()","satisfies_requirement?()","saturday?()","saturday?()","save()","save_cache()","save_class()","save_data()","save_data_with_atomic_file_rename_strategy()","save_data_with_fast_strategy()","save_exception_mode()","save_history()","save_history=()","save_index()","save_limit()","save_loaded_features()","save_method()","save_page()","save_plugins()","save_rounding_mode()","say()","say()","say()","say()","say_status()","scalar()","scalar()","scalar()","scalar()","scalar()","scalar=()","scalar?()","scalar?()","scan()","scan()","scan()","scan()","scan()","scan()","scan()","scan()","scan()","scan()","scan()","scan()","scan()","scan_action()","scan_all()","scan_error!()","scan_full()","scan_make_command_lines()","scan_quoted()","scan_token()","scan_until()","scheme=()","scheme=()","scheme_list()","scheme_list()","scope()","scope()","scope=()","scope=()","scope_options()","scroll_backward()","scroll_forward()","scrolling_list()","scrub()","scrub!()","scrypt()","search()","search()","search()","search()","search()","search_all()","search_by_dependency()","search_by_spec()","search_const()","search_convpath()","search_file()","search_for()","search_for()","search_for()","search_for()","search_for()","search_for()","search_for_dependency()","search_full()","search_internal()","search_record()","search_record()","search_record()","search_servlet()","search_up()","searcher=()","sec()","sec()","sec()","sec_fraction()","second()","second()","second=()","second=()","second_fraction()","seconds_to_components()","section()","section_contents()","sections()","sections()","sections_in_lockfile()","sections_to_ignore()","secure=()","security_level()","security_level=()","security_policies()","security_policy_keys()","see()","seed()","seed()","seed()","seed=()","seek()","seek()","seek()","seek()","seek()","segments_do_not_match()","select()","select()","select()","select()","select()","select()","select()","select()","select()","select()","select()","select()","select()","select()","select()","select!()","select!()","select!()","select!()","select_best_platform_match()","select_best_platform_match()","select_spec()","self()","self_null?()","send()","send()","send()","send()","send_command()","send_data()","send_entity()","send_gem()","send_io()","send_list_data()","send_literal()","send_mail()","send_message()","send_number_data()","send_owner_request()","send_push_request()","send_quoted_string()","send_request()","send_request_with_body()","send_request_with_body_data()","send_request_with_body_stream()","send_string_data()","send_symbol_data()","send_time_data()","sendcmd()","sender()","sendmail()","sendmsg()","sendmsg_nonblock()","separated_by()","separated_by1()","separator()","seplist()","seq()","seq=()","sequence?()","sequence?()","sequential_execution_mode!()","sequentially()","serial()","serial()","serial()","serial()","serial()","serial=()","serial=()","serial_compact_index_client()","serialize()","serialize_gemspecs_in()","serialize_integer_list_compressed()","serialize_integer_list_std()","server_error?()","server_error?()","server_name()","service()","service()","service()","service()","session()","session=()","session_add()","session_cache_mode()","session_cache_mode=()","session_cache_size()","session_cache_size=()","session_cache_stats()","session_get_cb()","session_new_cb()","session_remove()","session_reused?()","set()","set()","set()","set_accept()","set_api_key()","set_api_key()","set_attributes()","set_attributes()","set_backtrace()","set_backtrace()","set_bit!()","set_bundle_environment()","set_bundle_variables()","set_close_on_exec()","set_close_on_exec()","set_col_range()","set_color()","set_color()","set_column_vector()","set_command_option()","set_command_option_if_given()","set_component()","set_component()","set_config_file_name()","set_constant_visibility_for()","set_content_type()","set_crt_params()","set_ctypes()","set_ctypes()","set_current_section()","set_debug_output()","set_debug_output()","set_debug_output()","set_default()","set_default_paths()","set_default_values()","set_dictionary()","set_dictionary()","set_dn()","set_dn()","set_element()","set_element()","set_encoding()","set_encoding()","set_encoding()","set_encoding_by_bom()","set_encoding_by_bom()","set_end_location()","set_env()","set_eoutvar()","set_eoutvar()","set_eoutvar()","set_eoutvar()","set_error()","set_error()","set_extensions()","set_extensions()","set_factors()","set_field()","set_filter()","set_filter()","set_form()","set_form_data()","set_generator()","set_get_line_procs()","set_global()","set_headers()","set_headers()","set_host()","set_host()","set_host()","set_host()","set_installed_by_version()","set_key()","set_key()","set_key()","set_key()","set_last_thread()","set_last_value()","set_local()","set_local!()","set_location()","set_minmax_proto_version()","set_next_element()","set_non_blocking()","set_non_blocking()","set_opaque()","set_opaque()","set_option()","set_options()","set_params()","set_parent()","set_passwd()","set_passwd()","set_passwd()","set_password()","set_password()","set_password()","set_password()","set_path()","set_path()","set_path()","set_path()","set_path()","set_payload()","set_payload()","set_payload()","set_payload()","set_port()","set_port()","set_port()","set_port()","set_pqg()","set_pqg()","set_range()","set_range()","set_redirect()","set_row_and_col_range()","set_row_range()","set_rubylib()","set_rubyopt()","set_scheme()","set_scheme()","set_scope()","set_scope()","set_screen_size()","set_size()","set_socket()","set_start_location()","set_table()","set_to()","set_to()","set_to_infinity!()","set_trace()","set_trace_func()","set_trace_func()","set_typecode()","set_typecode()","set_user()","set_user()","set_user()","set_user()","set_userinfo()","set_userinfo()","set_userinfo()","set_userinfo()","set_value()","set_value()","set_visibility_for()","set_xhtml_uri_as_default_uri()","setacl()","setbyte()","setegid()","seteuid()","setgid()","setgid?()","setgid?()","setgid?()","setgid?()","setgrent()","setpgid()","setpgrp()","setpriority()","setproctitle()","setproperty()","setpwent()","setquota()","setregid()","setresgid()","setresuid()","setreuid()","setrgid()","setrlimit()","setruid()","setsid()","setsockopt()","setsockopt()","setter()","settings()","settings_flag()","settings_method()","settings_option()","setuid()","setuid?()","setuid?()","setuid?()","setuid?()","setup()","setup()","setup()","setup()","setup()","setup()","setup()","setup_base_gem()","setup_base_installer()","setup_base_spec()","setup_base_user_installer()","setup_cache_all()","setup_cache_all()","setup_certificate()","setup_elements()","setup_elements()","setup_elements()","setup_elements()","setup_generator()","setup_image()","setup_image()","setup_items()","setup_items()","setup_maker()","setup_maker()","setup_maker()","setup_maker()","setup_maker()","setup_maker()","setup_maker()","setup_maker()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_attributes()","setup_maker_element()","setup_maker_element()","setup_maker_element()","setup_maker_element()","setup_maker_element()","setup_maker_element()","setup_maker_element_writer()","setup_maker_element_writer()","setup_maker_elements()","setup_maker_elements()","setup_maker_elements()","setup_maker_elements()","setup_maker_elements()","setup_manpath()","setup_next_element()","setup_next_element_in_unknown_element()","setup_other_elements()","setup_output_dir()","setup_params()","setup_signer()","setup_ssl_context()","setup_textinput()","setup_textinput()","setup_values()","sev_threshold=()","sexp()","sexp_raw()","sh()","sh_with_input()","sh_with_status()","shallow_eql?()","shallow_eql?()","shebang()","shebang()","shebang()","shell()","shell()","shellescape()","shellescape()","shellescape()","shelljoin()","shelljoin()","shelljoin()","shellsplit()","shellsplit()","shellsplit()","shellwords()","shellwords()","shift()","shift()","shift()","shift()","shift()","shift()","shift()","shift()","shift()","shift()","shift()","shift()","shift()","shift_n()","short_name()","shortref_for_display()","shortref_for_path()","should_include?()","should_report_srconflict?()","should_terminal()","should_terminal?()","show()","show_documentation()","show_files()","show_gems()","show_help()","show_local_gems()","show_lookup_failure()","show_owners()","show_prereleases?()","show_pretty_values_for()","show_rdoc_for_pattern()","show_release_notes()","show_remote_gems()","show_version()","show_warning()","shuffle()","shuffle!()","shutdown()","shutdown()","shutdown()","shutdown()","shutdown()","shutdown()","shutdown()","shutdown()","shutdown_connections()","sid_available?()","sid_available?()","sign()","sign()","sign()","sign()","sign()","sign()","sign()","sign()","sign()","sign()","sign()","sign()","sign()","sign_in()","sign_pss()","signal()","signal()","signal()","signal_handle()","signal_status()","signaled?()","signame()","signature()","signature_algorithm()","signature_algorithm()","signature_algorithm()","signed?()","signed_time()","signers()","signo()","silence()","silence()","silent_system()","similar_word_list()","similar_words()","sin()","sin()","single?()","single?()","single_delegate()","single_version_string()","singleline_format()","singleline_pp()","singleton_class()","singleton_class?()","singleton_method()","singleton_method_added()","singleton_method_added()","singleton_method_removed()","singleton_method_undefined()","singleton_methods()","singular?()","singular?()","sinh()","site()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size()","size=()","size=()","size?()","size?()","size?()","size?()","size_opt_params()","size_params()","sizeof()","skew_symmetric?()","skip()","skip()","skip()","skip()","skip=()","skip_blanks?()","skip_blanks?()","skip_comment()","skip_during()","skip_during()","skip_during()","skip_for_variable()","skip_line?()","skip_lines()","skip_lines()","skip_method()","skip_needless_lines()","skip_optional_do_after_expression()","skip_tkspace()","skip_tkspace_comment()","skip_tkspace_without_nl()","skip_until()","sleep()","sleep()","sleep()","slice()","slice()","slice()","slice()","slice()","slice()","slice!()","slice!()","slice_after()","slice_after()","slice_before()","slice_before()","slice_body()","slice_when()","slice_when()","sn()","snake_case()","snippet()","sockaddr_in()","sockaddr_un()","socket?()","socket?()","socket?()","socket?()","socketpair()","socketpair()","socktype()","solve()","sort()","sort()","sort()","sort()","sort!()","sort!()","sort_by()","sort_by!()","sort_by!()","sort_dep_specs()","sort_dependencies()","sort_dependencies()","sort_dependencies()","sort_dependencies()","sort_dependencies()","sort_dependencies()","sort_if_need()","sort_internal()","sort_obj()","sort_obj()","sort_platforms()","sort_sections()","sort_specs()","sort_specs()","sort_versions()","sorted()","sorted()","sorted_requests()","source()","source()","source()","source()","source()","source()","source()","source()","source()","source()","source()","source=()","source?()","source?()","source?()","source_date_epoch()","source_date_epoch_string()","source_encoding()","source_encoding()","source_encoding()","source_encoding_name()","source_encoding_name()","source_file()","source_for()","source_from_lock()","source_list_for()","source_location()","source_location()","source_location()","source_location()","source_ole_types()","source_paths()","source_paths()","source_paths()","source_paths_for_search()","source_plugin()","source_requirements()","source_root()","source_root()","source_text()","sources()","sources()","sources=()","sources=()","space()","space=()","space_before()","space_before=()","spawn()","spawn()","spawn()","spec()","spec()","spec()","spec()","spec()","spec()","spec_authors()","spec_cache_dir()","spec_cache_dirs()","spec_default_gem?()","spec_dir()","spec_extension_dir()","spec_file()","spec_file()","spec_for()","spec_for()","spec_for_dependency()","spec_for_dependency()","spec_for_dependency()","spec_for_gem()","spec_from_gem()","spec_git_paths()","spec_groups()","spec_homepage()","spec_license()","spec_loaded_from()","spec_matches_for_glob()","spec_missing_extensions?()","spec_name()","spec_name()","spec_names()","spec_not_found()","spec_path()","spec_platforms()","spec_predecessors()","spec_settings()","spec_summary()","special_prefixes()","special_prefixes=()","special_prefixes=()","specific?()","specific?()","specific?()","specific_dependency()","specific_extra_args()","specific_extra_args_hash()","specific_failure_message()","specific_gem_for()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs()","specs_by_name()","specs_changed?()","specs_for()","specs_for_names()","specs_for_source_changed?()","specs_in()","specs_path()","specs_type()","specs_with_retry()","spell_checker()","spell_checker()","split()","split()","split()","split()","split()","split()","split()","split()","split()","split()","split()","split_arguments()","split_gem_path()","split_header_value()","split_header_value()","split_name()","split_path()","split_path()","split_specific_setting_for()","split_userinfo()","split_userinfo()","sprintf()","sqr()","sqrt()","sqrt()","sqrt()","sqrt()","square?()","squeeze()","squeeze!()","sr_conflict()","srand()","srand()","src_type()","srconflict_exist?()","ssl()","ssl?()","ssl?()","ssl_params()","ssl_servername_callback()","ssl_servername_callback()","ssl_socket()","ssl_timeout=()","ssl_version()","ssl_version=()","ssl_version=()","sspi_auth()","sspi_auth?()","stand_alone?()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","start()","startelement()","start_collecting_tokens()","start_doc()","start_document()","start_document()","start_document()","start_document()","start_element()","start_element?()","start_else_element()","start_get_text_element()","start_have_something_element()","start_keeper()","start_mapping()","start_mapping()","start_prefix_mapping()","start_resolution()","start_resolution()","start_row()","start_sequence()","start_sequence()","start_service()","start_service()","start_stream()","start_stream()","start_stream()","start_symbol=()","start_tls_session()","start_tls_session()","start_with?()","start_with?()","started?()","started?()","started?()","starts_with()","starttls()","starttls()","starttls?()","starttls_always?()","starttls_auto?()","stat()","stat()","stat()","stat()","stat()","stat()","stat()","state()","state()","state()","state()","state()","state_any?()","state_index_for_unwind()","state_transition_table()","state_transition_table()","state_transition_table()","states()","status()","status()","status()","status()","status()","status()","status()","status=()","status?()","status_code()","status_code()","status_line()","status_string()","status_type_char()","stderr()","stdinput()","stdout()","stdout()","stdout=()","stdoutput()","step()","step()","step()","step()","step()","sticky?()","sticky?()","sticky?()","sticky?()","stop()","stop()","stop()","stop()","stop?()","stop_doc()","stop_on_unknown_option!()","stop_pool()","stop_service()","stop_service()","stop_service()","stop_service()","stop_threads()","stopped?()","stopsig()","storbinary()","store()","store()","store()","store()","store()","store()","store()","store=()","store=()","store=()","store=()","store=()","store=()","store=()","store_connection()","store_for()","store_internal()","storlines()","stream=()","stream?()","stream?()","stream_check()","stream_end?()","streaming?()","stress()","stress=()","strftime()","strftime()","strftime()","strict?()","strict_args_position!()","strict_decode64()","strict_encode64()","strict_oct()","strike()","string()","string()","string()","string()","string()","string=()","string=()","string_length()","string_list()","string_symbol?()","string_value()","strip()","strip!()","strip_hashes()","strip_leading_spaces()","strip_newlines()","strip_quotes()","strip_stars()","strip_value()","strong()","strongly_connected_components()","strongly_connected_components()","strptime()","strptime()","strptime()","struct()","stub_rubygems()","stub_set_spec()","stubbed?()","stubbed?()","stubs()","stubs_for()","su()","su()","sub()","sub()","sub()","sub()","sub()","sub!()","sub_dependencies_to_avoid()","sub_ext()","sub_type()","subclass_files()","subclasses()","subcommand()","subcommand_classes()","subcommand_help()","subcommands()","subdomain_of?()","subject()","subject()","subject=()","subject=()","subject_certificate=()","subject_request=()","submit()","subscribe()","subsec()","subset?()","substring()","substring_after()","substring_before()","subtask()","subtask_help()","subtasks()","subtract()","succ()","succ()","succ()","succ()","succ()","succ()","succ()","succ()","succ()","succ()","succ!()","success?()","success?()","success?()","success?()","success?()","successors()","successors()","sudo()","suffix_pattern()","suffix_pattern()","suffix_regexp()","suffixes()","suggest_gems_from_name()","suggestions()","sum()","sum()","sum()","sum()","summarize()","summarize()","summarize()","summary()","summary=()","sunday?()","sunday?()","super_method()","super_method()","superclass()","superclass()","superclass()","superclass=()","superclass_method()","superset?()","supply_default_content_type()","supported?()","supported?()","suppress()","suppress_configured_credentials()","suppressed?()","suspend()","suspend_context()","suspend_input_method()","suspend_name()","suspend_workspace()","swapcase()","swapcase()","swapcase!()","switch()","switch()","switch()","switch_name()","sym()","sym()","sym()","sym_int_hash()","symbol_locations()","symbolize()","symbols()","symlink()","symlink()","symlink()","symlink()","symlink()","symlink?()","symlink?()","symlink?()","symlink?()","symlink?()","symmetric?()","sync()","sync()","sync()","sync()","sync()","sync=()","sync=()","sync=()","sync_keys!()","sync_point?()","synchronize()","synchronize()","synchronize()","synchronize()","syncmode=()","sysaccept()","sysaccept()","sysaccept()","syscall()","sysclose()","sysconf()","sysconfdir()","syslog()","syslog=()","sysopen()","sysopen()","sysread()","sysread()","sysread()","sysread()","sysread_nonblock()","sysseek()","syssign()","system()","system()","system()","system()","system_bindir()","systmpdir()","sysverify()","syswrite()","syswrite()","syswrite_nonblock()","t()","table()","tag()","tag()","tag()","tag()","tag()","tag()","tag()","tag_end()","tag_end()","tag_filter()","tag_name()","tag_name()","tag_name_with_prefix()","tag_start()","tag_start()","tag_version()","taint()","taint()","tainted?()","take()","take()","take()","take()","take()","take_while()","take_while()","take_while()","tally()","tan()","tanh()","tap()","tar_dir_header()","tar_file_header()","tar_symlink_header()","target_bin_path()","target_respond_to?()","task()","task_help()","tasks()","tcp()","tcp()","tcp_server_loop()","tcp_server_sockets()","tcp_socket()","tcp_socket()","teardown()","tell()","tell()","tell()","tell()","tell()","tell()","tell_err()","tell_me()","template()","template_dir_for()","template_files()","template_files_in()","temporary()","term=()","terminal()","terminal?()","terminal_width()","terminals()","terminate()","terminate()","terminate()","terminate()","terminate()","terminate()","terminate_interaction()","terminate_interaction()","terminate_interaction()","terminated?()","terminated?()","termsig()","test()","test_all()","test_civil()","test_commercial()","test_nth_kday()","test_ordinal()","test_unit_conv()","test_weeknum()","text()","text()","text()","text()","text()","text()","text=()","text=()","text=()","text?()","text?()","text_field()","text_type_writer()","textarea()","textinput()","texts()","then()","this()","this_update()","thor()","thor_classes_in()","thor_root()","thor_root_glob()","thread()","thread()","thread()","thread()","thread_internal()","thread_list()","thread_list_all()","thread_variable?()","thread_variable_get()","thread_variable_set()","thread_variables()","throw()","thursday?()","thursday?()","time()","time()","time()","time=()","time=()","time=()","time=()","timeout()","timeout()","timeout()","timeout()","timeout()","timeout()","timeout=()","timeouts=()","times()","times()","timestamp()","title()","title=()","tk_nl?()","tls?()","tlsconnect()","tmp()","tmp()","tmp_dh_callback()","tmp_ecdh_callback()","tmp_home_path()","tmp_key()","tmpdir()","to=()","to=()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_a()","to_array()","to_ary()","to_ary()","to_ary()","to_ary()","to_ary()","to_ary()","to_ary()","to_atom()","to_basic()","to_binary()","to_bn()","to_bn()","to_bn()","to_bool()","to_c()","to_c()","to_c()","to_c()","to_class_name()","to_csv()","to_csv()","to_d()","to_d()","to_d()","to_d()","to_d()","to_d()","to_date()","to_date()","to_date()","to_datetime()","to_datetime()","to_datetime()","to_definition()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_der()","to_digits()","to_dot()","to_dot()","to_element_methods()","to_enum()","to_enum()","to_f()","to_f()","to_f()","to_f()","to_f()","to_f()","to_f()","to_f()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed()","to_feed_for_categories()","to_fullpath()","to_gem_version_with_patchlevel()","to_gemfile()","to_h()","to_h()","to_h()","to_h()","to_h()","to_h()","to_h()","to_h()","to_h()","to_h()","to_h()","to_h()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_hash()","to_html()","to_html()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_i()","to_id()","to_id()","to_id()","to_id()","to_id()","to_int()","to_int()","to_int()","to_int()","to_int()","to_int()","to_io()","to_io()","to_io()","to_io()","to_io()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json()","to_json_raw()","to_json_raw_object()","to_lock()","to_lock()","to_lock()","to_lock()","to_lock()","to_lock()","to_lock()","to_lock()","to_mailtext()","to_mailtext()","to_matrix()","to_matrix()","to_name()","to_name()","to_obj()","to_obj()","to_obj()","to_obj()","to_obj()","to_oct()","to_octet_string()","to_path()","to_path()","to_path()","to_pem()","to_pem()","to_pem()","to_pem()","to_pem()","to_pem()","to_pem()","to_pem()","to_pem()","to_pem()","to_pem()","to_proc()","to_proc()","to_proc()","to_proc()","to_proc()","to_ptr()","to_r()","to_r()","to_r()","to_r()","to_r()","to_r()","to_r()","to_r()","to_range()","to_request_set()","to_rfc822text()","to_rfc822text()","to_rss()","to_ruby()","to_ruby()","to_ruby_for_cache()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_s()","to_set()","to_set()","to_sockaddr()","to_socket_address()","to_spec()","to_spec()","to_spec()","to_specs()","to_specs()","to_str()","to_str()","to_string()","to_string()","to_sym()","to_sym()","to_text()","to_text()","to_text()","to_text()","to_text()","to_text()","to_text()","to_text()","to_text()","to_text()","to_time()","to_time()","to_time()","to_tty?()","to_uri()","to_utf8()","to_value()","to_write_io()","to_xml()","to_yaml()","to_yaml()","to_yaml()","to_yaml_properties()","today()","toeuc()","toeuc()","toeuc()","tojis()","tojis()","tojis()","token()","token_listener()","token_stream()","token_table()","token_to_str()","token_value_table()","tokenize()","tokenize()","tokenize()","tokenize()","tokens_to_s()","tolocale()","tolocale()","tolocale()","tomdoc?()","top()","top()","top()","top()","top()","top_level()","top_level()","toplevel?()","toplevel_load()","tosjis()","tosjis()","tosjis()","total_in()","total_out()","total_time()","touch()","touch()","touch()","touch()","toutf16()","toutf16()","toutf16()","toutf32()","toutf32()","toutf32()","toutf8()","toutf8()","toutf8()","tr()","tr()","tr!()","tr_s()","tr_s!()","trace()","trace()","trace()","trace()","trace()","trace()","trace_func()","trace_object_allocations()","trace_object_allocations_clear()","trace_object_allocations_debug_start()","trace_object_allocations_start()","trace_object_allocations_stop()","trace_points()","trace_var()","transaction()","transfer()","transform()","transform_keys()","transform_keys!()","transform_values()","transform_values!()","translate()","transport_request()","transpose()","transpose()","transpose()","trap()","trap()","trap()","traverse()","traverse()","traverse()","traverse_parents()","tree()","tridiagonalize()","true()","truffleruby?()","truncate()","truncate()","truncate()","truncate()","truncate()","truncate()","truncate()","truncate()","truncate()","truncate()","truncate_text()","trust()","trust=()","trust=()","trust_cert()","trust_dir()","trusted_certificates()","try_activate()","try_const()","try_convert()","try_convert()","try_convert()","try_convert()","try_convert()","try_create()","try_enter()","try_lock()","try_mon_enter()","try_mon_enter()","try_type()","tsort()","tsort()","tsort()","tsort()","tsort_each()","tsort_each()","tsort_each_child()","tsort_each_child()","tsort_each_child()","tsort_each_child()","tsort_each_child()","tsort_each_node()","tsort_each_node()","tsort_each_node()","tsort_each_node()","tsort_each_node()","tty?()","tty?()","tty?()","tty?()","tuesday?()","tuesday?()","tv_nsec()","tv_sec()","tv_usec()","type()","type()","type()","type()","type()","type()","type()","type()","type()","type=()","type_params()","typealias()","typecode=()","typecode=()","typekind()","typelibs()","typelibs()","typename()","typo_squatting?()","u()","u()","u()","ucmp()","udp()","udp_server_loop()","udp_server_loop_on()","udp_server_recv()","udp_server_sockets()","ui()","ui()","ui()","ui()","ui=()","ui=()","ui=()","ui=()","uid()","uid()","uid=()","uid_copy()","uid_fetch()","uid_move()","uid_search()","uid_sort()","uid_store()","uid_thread()","uidl()","umask()","umount()","unadvise()","uname()","unbind()","unbundled_env()","unbundled_exec()","unbundled_system()","uncomment_lines()","unconverted_fields?()","unconverted_fields?()","undef_method()","undefine_finalizer()","undo_replacements()","undoc_params()","undump()","unescape()","unescape()","unescape()","unescape()","unescape()","unescape()","unescape()","unescape()","unescape()","unescape()","unescapeelement()","unescapehtml()","unescape_element()","unescape_form()","unescape_html()","unescape_value()","unget_tk()","ungetbyte()","ungetbyte()","ungetbyte()","ungetc()","ungetc()","ungetc()","ungetc()","unicode_normalize()","unicode_normalize!()","unicode_normalized?()","unindent_auto()","uninstall()","uninstall()","uninstall_all()","uninstall_dep()","uninstall_gem()","uninstall_gem()","uninstall_gem()","uninstall_old_gemcutter()","uninstall_specific()","union()","union()","union()","union()","uniq()","uniq()","uniq()","uniq!()","unique_classes()","unique_classes_and_modules()","unique_id()","unique_modules()","unique_separator()","unit()","unitary?()","unix()","unix()","unix?()","unix?()","unix_path()","unix_rights()","unix_rights()","unix_server_loop()","unix_server_socket()","unix_socket_abstract_name?()","unknown()","unknown()","unknown_sections_in_lockfile()","unlink()","unlink()","unlink()","unlink()","unlock()","unlock()","unlock!()","unlock!()","unlocking?()","unlocking_gem?()","unmarshalled_dep_gems()","unmet_dependency_names()","unmet_deps()","unmet_deps()","unmet_deps()","unmount()","unnode()","unnormalize()","unnormalize()","unnormalized()","unpack()","unpack()","unpack()","unpack1()","unpack_sockaddr_in()","unpack_sockaddr_un()","unprinted_warnings()","unprinted_warnings()","unregist()","unregister_command()","unresolved_deps()","unresolved_names()","unscan()","unset()","unset_api_key!()","unshift()","unshift()","unshift()","unshift()","unshift()","unsorted_search()","unsubscribe()","untaint()","untaint()","untrace_var()","untrust()","untrusted?()","unused()","unused_unwind_options()","unwind_for_conflict()","unwind_for_conflict()","unwind_options_for_requirements()","unwinding_to_primary_requirement?()","up()","up()","up()","up()","up()","up()","up()","up()","up()","up()","upcase()","upcase()","upcase!()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update()","update_a()","update_aliases()","update_and_parse_checksums!()","update_cache?()","update_checksum()","update_content()","update_content()","update_extends()","update_gem()","update_gems()","update_includes()","update_index()","update_info()","update_mirror()","update_output_dir()","update_parser_of_file()","update_present_via_semver_portions()","update_rubygems()","update_specs_index()","updated()","updated()","updated()","updated()","updated()","updated()","updated=()","updated=()","updated=()","upgrade_to_class()","upper_bound()","upper_bound=()","upper_triangular?()","upto()","upto()","upto()","uptodate?()","uptodate?()","uptodate?()","uptodate?()","urandom()","uri()","uri()","uri()","uri=()","uri_convert_attr_reader()","uri_encode()","uri_escaped_with_configured_credentials()","uri_hash()","uri_hash()","uri_option()","uri_option()","uri_parser()","uri_registered?()","url()","url_encode()","url_encode()","urlsafe_base64()","urlsafe_decode64()","urlsafe_encode64()","usage()","use()","use_api()","use_gemdeps()","use_gemdeps()","use_headers?()","use_loader()","use_loader=()","use_loader?()","use_markup()","use_path_completion?()","use_paths()","use_ssl=()","use_ssl?()","use_ssl?()","use_ssl?()","use_system_gems?()","use_tracer=()","use_ui()","use_ui()","usec()","used_modules()","useless=()","useless=()","useless?()","useless?()","useless_nonterminal_exist?()","useless_rule_exist?()","user()","user()","user=()","user=()","user_agent()","user_agent()","user_bundle_path()","user_cache()","user_dir()","user_home()","user_home()","user_home()","user_home()","userinfo()","userinfo()","userinfo=()","userinfo=()","using()","using_anon_cipher?()","utc()","utc()","utc?()","utc_offset()","util_build_gem()","util_clear_ruby_version()","util_clear_gems()","util_dir_entry()","util_entry()","util_gem()","util_gzip()","util_inst_bindir()","util_installer()","util_make_exec()","util_make_gems()","util_remove_gem()","util_restore_ruby_version()","util_set_ruby_version()","util_set_arch()","util_setup_gem()","util_setup_installer()","util_setup_spec_fetcher()","util_spec()","util_symlink_entry()","util_zip()","utime()","utime()","uuid()","v()","v_inv()","valid?()","valid?()","valid_civil?()","valid_commercial?()","valid_date?()","valid_email?()","valid_encoding?()","valid_for?()","valid_jd?()","valid_keys()","valid_mod_sequence_value?()","valid_number?()","valid_nz_number?()","valid_ordinal?()","valid_v6?()","validate()","validate()","validate()","validate()","validate()","validate!()","validate!()","validate!()","validate!()","validate_array_attribute()","validate_array_attributes()","validate_attribute()","validate_attribute_present()","validate_authors_field()","validate_bundle_path()","validate_bundler_checksum()","validate_cmd!()","validate_data()","validate_dependencies()","validate_duplicate_links()","validate_ext_name()","validate_for_stream()","validate_keys()","validate_lazy_metadata()","validate_licenses()","validate_line()","validate_metadata()","validate_metadata()","validate_name()","validate_nil_attributes()","validate_non_files()","validate_one_tag_name()","validate_options!()","validate_permissions()","validate_permissions()","validate_platform()","validate_platforms!()","validate_plugin!()","validate_require_paths()","validate_required_attributes()","validate_resolved_specs!()","validate_ruby!()","validate_rubygems_version()","validate_runtime!()","validate_scope!()","validate_self_inclusion_in_files_list()","validate_shebang_line_in()","validate_spec()","validate_spec()","validate_specification_version()","validate_uri_scheme!()","validate_values()","value()","value()","value()","value()","value()","value()","value()","value()","value()","value()","value()","value()","value()","value()","value()","value=()","value=()","value=()","value=()","value=()","value=()","value?()","value?()","value?()","value?()","value?()","value_type()","values()","values()","values()","values()","values()","values()","values()","values()","values()","values_at()","values_at()","values_at()","values_at()","values_at()","values_at()","values_at()","values_at()","values_at()","values_at()","values_at()","values_at()","variable_is_set?()","variable_is_set?()","variable_is_set?()","variable_kind()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables()","variables=()","variables=()","varkind()","vartype()","vc_windows?()","vc_windows?()","vendordir()","ver()","verbose()","verbose()","verbose()","verbose=()","verbose=()","verbose?()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify()","verify_api_key()","verify_callback=()","verify_callback=()","verify_certificate()","verify_certificate_identity()","verify_certificate_identity()","verify_certificate_message()","verify_compaction_references()","verify_depth=()","verify_entry()","verify_files()","verify_gemfile_dependencies_are_found!()","verify_group_exists()","verify_internal_consistency()","verify_mode=()","verify_pss()","verify_result()","verify_signatures()","verify_spec()","verify_transient_heap_internal_consistency()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version()","version=()","version=()","version=()","version=()","version_1_2()","version_1_2?()","version_color()","version_conflict_message()","version_dir()","version_message()","version_message()","version_message()","version_message()","version_of()","version_prefix()","version_tag()","versions()","versions()","versions()","versions_path()","versions_string()","vertex_named()","vertex_named()","vhid()","vi_editing_mode()","vi_editing_mode()","vi_editing_mode?()","vi_editing_mode?()","virtual_host()","visibility=()","visible?()","visible?()","visible?()","visible?()","visit()","visit()","visit_array()","visit_basicobject()","visit_bigdecimal()","visit_class()","visit_complex()","visit_date()","visit_datetime()","visit_delegator()","visit_encoding()","visit_enumerator()","visit_exception()","visit_falseclass()","visit_float()","visit_hash()","visit_integer()","visit_module()","visit_nameerror()","visit_nilclass()","visit_object()","visit_psych_nodes_alias()","visit_psych_nodes_alias()","visit_psych_nodes_alias()","visit_psych_nodes_alias()","visit_psych_nodes_document()","visit_psych_nodes_document()","visit_psych_nodes_document()","visit_psych_nodes_mapping()","visit_psych_nodes_mapping()","visit_psych_nodes_mapping()","visit_psych_nodes_scalar()","visit_psych_nodes_scalar()","visit_psych_nodes_scalar()","visit_psych_nodes_sequence()","visit_psych_nodes_sequence()","visit_psych_nodes_sequence()","visit_psych_nodes_stream()","visit_psych_nodes_stream()","visit_psych_nodes_stream()","visit_psych_omap()","visit_psych_set()","visit_range()","visit_rational()","visit_regexp()","visit_string()","visit_string()","visit_struct()","visit_symbol()","visit_time()","visit_trueclass()","visit_array_subclass()","visit_hash_subclass()","viz()","viz()","voidcmd()","vstack()","vstack()","w3cdtf()","w3cdtf()","wait()","wait()","wait()","wait()","wait()","wait2()","wait_for_child_process_to_exit()","wait_for_cond()","wait_for_continue()","wait_for_writtable_socket()","wait_readable()","wait_until()","wait_while()","wait_writable()","waitall()","waiting()","waitpid()","waitpid2()","wakeup()","warn()","warn()","warn()","warn()","warn()","warn()","warn()","warn()","warn()","warn()","warn()","warn!()","warn?()","warn?()","warn_ambiguous_gems()","warn_deprecated_git_source()","warn_for_outdated_bundler_version()","warn_if_root()","warn_old_tls_version_rubygems_connection()","warn_on_git_protocol()","warn_on_incompatible_bundler_deps()","warn_on_outdated_bundler()","warn_unused_scope()","warning()","wday()","wday()","weakref_alive?()","wednesday?()","wednesday?()","weeknum()","weeknum()","what_required()","when_invoked()","which()","which_to_update()","whitespace()","why_not_ok?()","win32_last_error()","win32_last_error=()","win_platform=()","win_platform?()","win_platform?()","win_platform?()","windows_stub_script()","winsize()","winsize()","winsize=()","with()","with()","with()","with_build_args()","with_clean_env()","with_clean_git_env()","with_clean_path_to_ruby()","with_config()","with_env()","with_friendly_errors()","with_index()","with_index()","with_index()","with_level()","with_no_such_dependency_error_handling()","with_no_such_dependency_error_handling()","with_object()","with_object()","with_original_env()","with_padding()","with_response()","with_source()","with_unbundled_env()","without_circular_ref()","without_groups_message()","wnum0()","wnum1()","word_wrap()","wordy()","wordy()","worker_pool()","workspaces()","world_readable?()","world_readable?()","world_readable?()","world_readable?()","world_writable?()","world_writable?()","world_writable?()","world_writable?()","wrap()","wrap()","wrap()","wrap()","wrap()","wrap()","wrap()","wrap()","writable?()","writable?()","writable?()","writable?()","writable?()","writable_real?()","writable_real?()","writable_real?()","writable_real?()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write()","write_binary()","write_build_info_file()","write_cache_file()","write_cdata()","write_cdata()","write_comment()","write_comment()","write_default_spec()","write_document()","write_document()","write_element()","write_element()","write_element()","write_file()","write_header()","write_headers?()","write_instruction()","write_log()","write_nonblock()","write_nonblock()","write_nonblock()","write_options()","write_random_file()","write_services()","write_smime()","write_spec()","write_text()","write_text()","write_text()","write_timeout=()","write_to_gemfile()","write_with_substitution()","writer()","writer_fields_converter()","writer_options()","x64_mingw?()","xhtml()","xhtml()","xhtml=()","xlist()","xml()","xml=()","xmldecl()","xml_content=()","xml_content=()","xml_decl()","xml_getter()","xml_getter()","xml_setter()","xml_setter()","xml_stylesheet_pi()","xml_type?()","xmldecl()","xmldecl()","xmldecl()","xmldecl()","xmldecl()","xmldecl()","xmldecl()","xmldecl?()","xmled_content()","xmlschema()","xmlschema()","xmlschema()","xmlschema()","xmlschema()","xmlschema()","xmp()","xpath()","xpath()","xpath()","y()","yaml()","yaml_tag()","yank_api_request()","yank_gem()","yday()","yday()","year()","year()","yes?()","yes?()","yes?()","yes_other_attr_reader()","yes_other_writer()","yield()","yield()","yield_self()","yyaccept()","yydebug()","yydebug=()","yyerrok()","yyerror()","yylex()","yylex0()","zero()","zero()","zero?()","zero?()","zero?()","zero?()","zero?()","zero?()","zero?()","zero?()","zero?()","zero?()","zip()","zip()","zip()","zip?()","zlib_version()","zone()","zone()","zone_offset()","zone_utc?()","|()","|()","|()","|()","|()","|()","|()","|()","|()","|()","~()","~()","~()","contributing","copying","copying.ja","legal","news","news-1.8.7","news-1.9.1","news-1.9.2","news-1.9.3","news-2.0.0","news-2.1.0","news-2.2.0","news-2.3.0","news-2.4.0","news-2.5.0","news-2.6.0","readme.ja","readme","bug_triaging","contributing","contributors","dtrace_probes","extension.ja","extension","globals","keywords","pre-setup","grammar.en","maintainers","marshal","regexp","security","signals","standard_library","syntax","assignment","calling_methods","comments","control_expressions","exceptions","literals","methods","miscellaneous","modules_and_classes","precedence","refinements","readme.win32"],"longSearchIndex":["acl","acl::aclentry","acl::acllist","argf","abbrev","addrinfo","ambiguouscommanderror","ambiguoustaskerror","argumenterror","array","base64","basicobject","basicsocket","benchmark","benchmark::tms","bigdecimal","bigmath","binding","bundler","bundler::apiresponsemismatcherror","bundler::buildmetadata","bundler::bundlererror","bundler::cli","bundler::cli::add","bundler::cli::binstubs","bundler::cli::cache","bundler::cli::check","bundler::cli::clean","bundler::cli::common","bundler::cli::config","bundler::cli::config::base","bundler::cli::console","bundler::cli::doctor","bundler::cli::exec","bundler::cli::gem","bundler::cli::info","bundler::cli::init","bundler::cli::inject","bundler::cli::install","bundler::cli::issue","bundler::cli::list","bundler::cli::lock","bundler::cli::open","bundler::cli::outdated","bundler::cli::package","bundler::cli::platform","bundler::cli::plugin","bundler::cli::pristine","bundler::cli::remove","bundler::cli::show","bundler::cli::update","bundler::cli::viz","bundler::compactindexclient","bundler::compactindexclient::cache","bundler::compactindexclient::error","bundler::compactindexclient::updater","bundler::compactindexclient::updater::mismatchedchecksumerror","bundler::connectionpool","bundler::connectionpool::error","bundler::connectionpool::poolshuttingdownerror","bundler::connectionpool::timedstack","bundler::connectionpool::wrapper","bundler::currentruby","bundler::cyclicdependencyerror","bundler::definition","bundler::depproxy","bundler::dependency","bundler::deployment","bundler::deprecate","bundler::deprecatederror","bundler::dsl","bundler::dsl::dslerror","bundler::endpointspecification","bundler::env","bundler::environmentpreserver","bundler::featureflag","bundler::fetcher","bundler::fetcher::authenticationrequirederror","bundler::fetcher::badauthenticationerror","bundler::fetcher::base","bundler::fetcher::certificatefailureerror","bundler::fetcher::compactindex","bundler::fetcher::dependency","bundler::fetcher::downloader","bundler::fetcher::fallbackerror","bundler::fetcher::index","bundler::fetcher::networkdownerror","bundler::fetcher::sslerror","bundler::fetcher::toomanyrequestserror","bundler::fileutils","bundler::fileutils::dryrun","bundler::fileutils::nowrite","bundler::fileutils::streamutils_","bundler::fileutils::verbose","bundler::friendlyerrors","bundler::gemhelper","bundler::gemhelpers","bundler::gemhelpers::platformmatch","bundler::geminstaller","bundler::gemnotfound","bundler::gemremotefetcher","bundler::gemrequireerror","bundler::gemversionpromoter","bundler::gemdeps","bundler::gemfileerror","bundler::gemfileevalerror","bundler::gemfilelocknotfound","bundler::gemfilenotfound","bundler::gemspecerror","bundler::genericsystemcallerror","bundler::giterror","bundler::graph","bundler::graph::graphvizclient","bundler::httperror","bundler::index","bundler::injector","bundler::installerror","bundler::installhookerror","bundler::installer","bundler::invalidoption","bundler::lazyspecification","bundler::lazyspecification::identifier","bundler::lockfileerror","bundler::lockfilegenerator","bundler::lockfileparser","bundler::marshalerror","bundler::matchplatform","bundler::mirrorsockets","bundler::molinillo","bundler::molinillo::circulardependencyerror","bundler::molinillo::compatibility","bundler::molinillo::delegates","bundler::molinillo::delegates::resolutionstate","bundler::molinillo::delegates::specificationprovider","bundler::molinillo::dependencygraph","bundler::molinillo::dependencygraph::action","bundler::molinillo::dependencygraph::addedgenocircular","bundler::molinillo::dependencygraph::deleteedge","bundler::molinillo::dependencygraph::detachvertexnamed","bundler::molinillo::dependencygraph::log","bundler::molinillo::dependencygraph::tag","bundler::molinillo::dependencygraph::vertex","bundler::molinillo::dependencystate","bundler::molinillo::nosuchdependencyerror","bundler::molinillo::possibilitystate","bundler::molinillo::resolutionstate","bundler::molinillo::resolver","bundler::molinillo::resolver::resolution","bundler::molinillo::resolver::resolution::conflict","bundler::molinillo::resolver::resolution::possibilityset","bundler::molinillo::resolver::resolution::unwinddetails","bundler::molinillo::resolvererror","bundler::molinillo::specificationprovider","bundler::molinillo::ui","bundler::molinillo::versionconflict","bundler::nospaceondeviceerror","bundler::operationnotsupportederror","bundler::parallelinstaller","bundler::parallelinstaller::specinstallation","bundler::patherror","bundler::permissionerror","bundler::persistent","bundler::persistent::net","bundler::persistent::net::http","bundler::persistent::net::http::persistent","bundler::persistent::net::http::persistent::error","bundler::persistenthttp","bundler::plugin","bundler::plugin::api","bundler::plugin::api::source","bundler::plugin::dsl","bundler::plugin::dsl::plugingemfileerror","bundler::plugin::events","bundler::plugin::index","bundler::plugin::index::commandconflict","bundler::plugin::index::sourceconflict","bundler::plugin::installer","bundler::plugin::installer::git","bundler::plugin::installer::rubygems","bundler::plugin::malformattedplugin","bundler::plugin::sourcelist","bundler::plugin::undefinedcommanderror","bundler::plugin::unknownsourceerror","bundler::pluginerror","bundler::processlock","bundler::productionerror","bundler::remotespecification","bundler::resolver","bundler::resolver::specgroup","bundler::retry","bundler::rubydsl","bundler::rubygemsgeminstaller","bundler::rubyversion","bundler::rubyversionmismatch","bundler::rubygemsintegration","bundler::rubygemsintegration::gem","bundler::runtime","bundler::securityerror","bundler::settings","bundler::settings::mirror","bundler::settings::mirrorconfig","bundler::settings::mirrors","bundler::settings::tcpsocketprobe","bundler::settings::validator","bundler::settings::validator::rule","bundler::sharedhelpers","bundler::similaritydetector","bundler::socketaddress","bundler::source","bundler::source::gemspec","bundler::source::git","bundler::source::git::gitcommanderror","bundler::source::git::gitnotallowederror","bundler::source::git::gitnotinstallederror","bundler::source::git::gitproxy","bundler::source::git::missinggitrevisionerror","bundler::source::metadata","bundler::source::path","bundler::source::path::installer","bundler::source::rubygems","bundler::source::rubygems::remote","bundler::sourcelist","bundler::specset","bundler::standalone","bundler::stubspecification","bundler::sudonotpermittederror","bundler::temporaryresourceerror","bundler::thor","bundler::thor::actions","bundler::thor::actions::capturableerb","bundler::thor::actions::classmethods","bundler::thor::base","bundler::thor::base::classmethods","bundler::thor::command","bundler::thor::coreext","bundler::thor::coreext::orderedhash","bundler::thor::dynamiccommand","bundler::thor::dynamictask","bundler::thor::group","bundler::thor::hiddencommand","bundler::thor::hiddentask","bundler::thor::invocation","bundler::thor::invocation::classmethods","bundler::thor::lineeditor","bundler::thor::lineeditor::basic","bundler::thor::lineeditor::readline","bundler::thor::lineeditor::readline::pathcompletion","bundler::thor::nestedcontext","bundler::thor::rakecompat","bundler::thor::shell","bundler::thor::shell::basic","bundler::thor::shell::color","bundler::thor::shell::html","bundler::thor::task","bundler::thor::util","bundler::threadcreationerror","bundler::ui","bundler::ui::rgproxy","bundler::ui::shell","bundler::ui::silent","bundler::uri","bundler::uri::badurierror","bundler::uri::error","bundler::uri::escape","bundler::uri::ftp","bundler::uri::file","bundler::uri::generic","bundler::uri::http","bundler::uri::https","bundler::uri::invalidcomponenterror","bundler::uri::invalidurierror","bundler::uri::ldap","bundler::uri::ldaps","bundler::uri::mailto","bundler::uri::parser","bundler::uri::regexp","bundler::uri::rfc2396_parser","bundler::uri::rfc2396_regexp","bundler::uri::rfc2396_regexp::pattern","bundler::uricredentialsfilter","bundler::versionconflict","bundler::versionranges","bundler::versionranges::reqr","bundler::virtualprotocolerror","bundler::worker","bundler::worker::wrappedexception","bundler::yamlserializer","bundler::yamllibrarysyntaxerror","bundler::yamlsyntaxerror","cgi","cgi::cookie","cgi::html3","cgi::html4","cgi::html4fr","cgi::html4tr","cgi::html5","cgi::htmlextension","cgi::invalidencoding","cgi::queryextension","cgi::session","cgi::session::filestore","cgi::session::memorystore","cgi::session::nullstore","cgi::session::pstore","cgi::util","csv","csv::deletesuffix","csv::fieldsconverter","csv::malformedcsverror","csv::matchp","csv::parser","csv::parser::inputsscanner","csv::parser::invalidencoding","csv::parser::scanner","csv::parser::unoptimizedstringio","csv::row","csv::table","csv::writer","class","closedqueueerror","comparable","complex","conditionvariable","continuation","coverage","dbm","dbmerror","debugger__","drb","drb::drbarray","drb::drbbadscheme","drb::drbbaduri","drb::drbconn","drb::drbconnerror","drb::drberror","drb::drbidconv","drb::drbidconv","drb::drbmessage","drb::drbobject","drb::drbobject","drb::drbobservable","drb::drbprotocol","drb::drbremoteerror","drb::drbsslsocket","drb::drbsslsocket::sslconfig","drb::drbserver","drb::drbserver::invokemethod18mixin","drb::drbservernotfound","drb::drbtcpsocket","drb::drbunixsocket","drb::drbundumped","drb::drbundumped","drb::drbunknown","drb::drbunknownerror","drb::extserv","drb::extservmanager","drb::gw","drb::gwidconv","drb::threadobject","drb::timeridconv","drb::timeridconv::timerholder2","drb::timeridconv::timerholder2::invalidindexerror","drb::weakidconv","drb::weakidconv::weakset","data","date","date::error","datetime","delegator","didyoumean","digest","digest::base","digest::class","digest::instance","digest::md5","digest::rmd160","digest::sha1","dir","env","eoferror","erb","erb::defmethod","erb::util","exception_type","exception_type","exception_type","exception_type","encoding","encoding::compatibilityerror","encoding::converter","encoding::converternotfounderror","encoding::invalidbytesequenceerror","encoding::undefinedconversionerror","encodingerror","english","enumerable","enumerator","enumerator::arithmeticsequence","enumerator::chain","enumerator::generator","enumerator::lazy","enumerator::producer","enumerator::yielder","errno","errno::econnaborted","errno::econnreset","errno::eproto","error","etc","exception","exceptionformatrix","exceptionformatrix::errdimensionmismatch","exceptionformatrix::errnotregular","exceptionformatrix::erroperationnotdefined","exceptionformatrix::erroperationnotimplemented","falseclass","fcntl","fiber","fibererror","fiddle","fiddle::basictypes","fiddle::cparser","fiddle::cstruct","fiddle::cstructbuilder","fiddle::cstructentity","fiddle::cunion","fiddle::cunionentity","fiddle::closure","fiddle::closure::blockcaller","fiddle::compositehandler","fiddle::dlerror","fiddle::function","fiddle::handle","fiddle::importer","fiddle::pointer","fiddle::win32types","file","file::file::constants","file::stat","filetest","fileutils","fileutils::dryrun","fileutils::nowrite","fileutils::streamutils_","fileutils::verbose","find","float","floatdomainerror","forwardable","frozenerror","gc","gc::profiler","gdbm","gdbmerror","gdbmfatalerror","gem","gem::availableset","gem::basicspecification","gem::bundlerversionfinder","gem::command","gem::commandlineerror","gem::commandmanager","gem::commands","gem::commands::buildcommand","gem::commands::certcommand","gem::commands::checkcommand","gem::commands::cleanupcommand","gem::commands::contentscommand","gem::commands::dependencycommand","gem::commands::environmentcommand","gem::commands::fetchcommand","gem::commands::generateindexcommand","gem::commands::helpcommand","gem::commands::infocommand","gem::commands::installcommand","gem::commands::listcommand","gem::commands::lockcommand","gem::commands::mirrorcommand","gem::commands::opencommand","gem::commands::outdatedcommand","gem::commands::ownercommand","gem::commands::pristinecommand","gem::commands::pushcommand","gem::commands::querycommand","gem::commands::rdoccommand","gem::commands::searchcommand","gem::commands::servercommand","gem::commands::setupcommand","gem::commands::setupcommand::makedirs","gem::commands::signincommand","gem::commands::signoutcommand","gem::commands::sourcescommand","gem::commands::specificationcommand","gem::commands::stalecommand","gem::commands::uninstallcommand","gem::commands::unpackcommand","gem::commands::updatecommand","gem::commands::whichcommand","gem::commands::yankcommand","gem::configfile","gem::conflicterror","gem::consoleui","gem::defaultuserinteraction","gem::dependency","gem::dependencyerror","gem::dependencyinstaller","gem::dependencylist","gem::dependencyremovalexception","gem::dependencyresolutionerror","gem::deprecate","gem::doctor","gem::documenterror","gem::endofyamlexception","gem::errorreason","gem::exception","gem::ext","gem::ext::builderror","gem::ext::builder","gem::ext::cmakebuilder","gem::ext::configurebuilder","gem::ext::extconfbuilder","gem::ext::rakebuilder","gem::fakefetcher","gem::filepermissionerror","gem::formatexception","gem::gemnotfoundexception","gem::gemnotinhomeexception","gem::gemrunner","gem::gemcutterutilities","gem::impossibledependencieserror","gem::indexer","gem::installerror","gem::installupdateoptions","gem::installer","gem::installer::fakepackage","gem::installertestcase","gem::invalidspecificationexception","gem::licenses","gem::list","gem::loaderror","gem::localremoteoptions","gem::missingspecerror","gem::missingspecversionerror","gem::mockgemui","gem::mockgemui::inputeoferror","gem::mockgemui::systemexitexception","gem::mockgemui::tty","gem::mockgemui::termerror","gem::nametuple","gem::noaliasyamltree","gem::operationnotsupportederror","gem::package","gem::package::digestio","gem::package::error","gem::package::formaterror","gem::package::nonseekableio","gem::package::old","gem::package::patherror","gem::package::tarheader","gem::package::tarinvaliderror","gem::package::tarreader","gem::package::tarreader::entry","gem::package::tarreader::unexpectedeof","gem::package::tartestcase","gem::package::tarwriter","gem::package::tarwriter::boundedstream","gem::package::tarwriter::fileoverflow","gem::package::tarwriter::restrictedstream","gem::package::toolongfilename","gem::packagetask","gem::pathsupport","gem::platform","gem::platformmismatch","gem::remoteerror","gem::remotefetcher","gem::remotefetcher::fetcherror","gem::remotefetcher::unknownhosterror","gem::remoteinstallationcancelled","gem::remoteinstallationskipped","gem::remotesourceexception","gem::request","gem::requestset","gem::requestset::gemdependencyapi","gem::requestset::lockfile","gem::requestset::lockfile::parseerror","gem::requestset::lockfile::parser","gem::requestset::lockfile::tokenizer","gem::requirement","gem::requirement::badrequirementerror","gem::resolver","gem::resolver::apiset","gem::resolver::apispecification","gem::resolver::activationrequest","gem::resolver::bestset","gem::resolver::composedset","gem::resolver::conflict","gem::resolver::currentset","gem::resolver::dependencyrequest","gem::resolver::gitset","gem::resolver::gitspecification","gem::resolver::indexset","gem::resolver::indexspecification","gem::resolver::installedspecification","gem::resolver::installerset","gem::resolver::localspecification","gem::resolver::lockset","gem::resolver::lockspecification","gem::resolver::molinillo","gem::resolver::molinillo::circulardependencyerror","gem::resolver::molinillo::delegates","gem::resolver::molinillo::delegates::resolutionstate","gem::resolver::molinillo::delegates::specificationprovider","gem::resolver::molinillo::dependencygraph","gem::resolver::molinillo::dependencygraph::action","gem::resolver::molinillo::dependencygraph::addedgenocircular","gem::resolver::molinillo::dependencygraph::deleteedge","gem::resolver::molinillo::dependencygraph::detachvertexnamed","gem::resolver::molinillo::dependencygraph::log","gem::resolver::molinillo::dependencygraph::tag","gem::resolver::molinillo::dependencygraph::vertex","gem::resolver::molinillo::dependencystate","gem::resolver::molinillo::nosuchdependencyerror","gem::resolver::molinillo::possibilitystate","gem::resolver::molinillo::resolutionstate","gem::resolver::molinillo::resolver","gem::resolver::molinillo::resolver::resolution","gem::resolver::molinillo::resolvererror","gem::resolver::molinillo::specificationprovider","gem::resolver::molinillo::ui","gem::resolver::molinillo::versionconflict","gem::resolver::requirementlist","gem::resolver::set","gem::resolver::sourceset","gem::resolver::specspecification","gem::resolver::specification","gem::resolver::stats","gem::resolver::vendorset","gem::resolver::vendorspecification","gem::rubyversionmismatch","gem::runtimerequirementnotmeterror","gem::s3urisigner","gem::s3urisigner::configurationerror","gem::s3urisigner::instanceprofileerror","gem::safeyaml","gem::security","gem::security::exception","gem::security::policy","gem::security::signer","gem::security::trustdir","gem::securityoption","gem::server","gem::silentui","gem::source","gem::source::git","gem::source::installed","gem::source::local","gem::source::lock","gem::source::specificfile","gem::source::vendor","gem::sourcefetchproblem","gem::sourcelist","gem::specfetcher","gem::specificgemnotfoundexception","gem::specification","gem::specificationpolicy","gem::streamui","gem::streamui::silentdownloadreporter","gem::streamui::silentprogressreporter","gem::streamui::simpleprogressreporter","gem::streamui::threadeddownloadreporter","gem::streamui::verboseprogressreporter","gem::stubspecification","gem::systemexitexception","gem::testcase","gem::testcase::specfetchersetup","gem::testcase::staticset","gem::text","gem::uninstallerror","gem::uninstaller","gem::unsatisfiabledependencyerror","gem::uriformatter","gem::uriparser","gem::uriparsing","gem::userinteraction","gem::util","gem::validator","gem::verificationerror","gem::version","gem::versionoption","getoptlong","getoptlong::ambiguousoption","getoptlong::error","getoptlong::invalidoption","getoptlong::missingargument","getoptlong::needlessargument","httpclientexception","httpgatewaytimeout","httpmovedtemporarily","httpmultiplechoice","httprequestentitytoolarge","httprequesttimeout","httprequesturitoolarge","httprequesturitoolong","httprequesturitoolong","httprequestedrangenotsatisfiable","hash","io","io::eagainwaitreadable","io::eagainwaitwritable","io::einprogresswaitreadable","io::einprogresswaitwritable","io::ewouldblockwaitreadable","io::ewouldblockwaitwritable","io::waitreadable","io::waitwritable","io::generic_readable","io::generic_writable","ioerror","ipaddr","ipaddr::addressfamilyerror","ipaddr::error","ipaddr::invalidaddresserror","ipaddr::invalidprefixerror","ipsocket","irb","irb::abort","irb::cantchangebinding","irb::cantreturntonormalmode","irb::cantshifttomultiirbmode","irb::canvas","irb::color","irb::color::symbolstate","irb::context","irb::contextextender","irb::extendcommand","irb::extendcommand::changeworkspace","irb::extendcommand::currentworkingworkspace","irb::extendcommand::foreground","irb::extendcommand::fork","irb::extendcommand::help","irb::extendcommand::info","irb::extendcommand::irbcommand","irb::extendcommand::jobs","irb::extendcommand::kill","irb::extendcommand::load","irb::extendcommand::nop","irb::extendcommand::popworkspace","irb::extendcommand::pushworkspace","irb::extendcommand::require","irb::extendcommand::source","irb::extendcommand::workspaces","irb::extendcommandbundle","irb::fileinputmethod","irb::frame","irb::frame::frameoverflow","irb::frame::frameunderflow","irb::history","irb::illegalparameter","irb::illegalrcgenerator","irb::inputmethod","irb::inspector","irb::irb","irb::irbalreadydead","irb::irbloader","irb::irbswitchedtocurrentthread","irb::jobmanager","irb::loadabort","irb::locale","irb::methodextender","irb::nosuchjob","irb::notimplementederror","irb::notifier","irb::notifier::abstractnotifier","irb::notifier::compositenotifier","irb::notifier::errundefinednotifier","irb::notifier::errunrecognizedlevel","irb::notifier::levelednotifier","irb::notifier::nomsgnotifier","irb::outputmethod","irb::outputmethod::notimplementederror","irb::readlineinputmethod","irb::reidlineinputmethod","irb::rubymodel","irb::stdioinputmethod","irb::stdiooutputmethod","irb::undefinedpromptmode","irb::unrecognizedswitch","irb::vec","irb::workspace","indexerror","integer","interrupt","invocationerror","json","json::circulardatastructure","json::ext","json::ext::generator","json::ext::generator::generatormethods","json::ext::generator::generatormethods::array","json::ext::generator::generatormethods::bignum","json::ext::generator::generatormethods::falseclass","json::ext::generator::generatormethods::fixnum","json::ext::generator::generatormethods::float","json::ext::generator::generatormethods::hash","json::ext::generator::generatormethods::integer","json::ext::generator::generatormethods::nilclass","json::ext::generator::generatormethods::object","json::ext::generator::generatormethods::string","json::ext::generator::generatormethods::string::extend","json::ext::generator::generatormethods::trueclass","json::ext::generator::state","json::ext::parser","json::generatorerror","json::genericobject","json::jsonerror","json::missingunicodesupport","json::nestingerror","json::parsererror","json::unparsererror","jacobian","kconv","kernel","keyerror","lusolve","loaderror","localjumperror","logger","makemakefile","makemakefile::logging","makemakefile::rbconfig","makemakefile::string_or_failed_format","malformattedargumenterror","marshal","matchdata","math","math::domainerror","matrix","matrix::eigenvaluedecomposition","matrix::lupdecomposition","method","module","monitor","monitormixin","monitormixin::conditionvariable","mutex","mutex_m","nkf","nameerror","net","net::apop","net::apopsession","net::ftp","net::ftp::bufferedsslsocket","net::ftp::bufferedsocket","net::ftp::mlsxentry","net::ftp::nullsocket","net::ftpconnectionerror","net::ftperror","net::ftppermerror","net::ftpprotoerror","net::ftpreplyerror","net::ftptemperror","net::http","net::http::copy","net::http::delete","net::http::get","net::http::head","net::http::lock","net::http::mkcol","net::http::move","net::http::options","net::http::patch","net::http::post","net::http::propfind","net::http::proppatch","net::http::put","net::http::trace","net::http::unlock","net::httpaccepted","net::httpalreadyreported","net::httpbadgateway","net::httpbadrequest","net::httpbadresponse","net::httpclienterror","net::httpconflict","net::httpcontinue","net::httpcreated","net::httpearlyhints","net::httperror","net::httpexceptions","net::httpexpectationfailed","net::httpfaileddependency","net::httpfatalerror","net::httpforbidden","net::httpfound","net::httpgatewaytimeout","net::httpgenericrequest","net::httpgone","net::httpheader","net::httpheadersyntaxerror","net::httpimused","net::httpinformation","net::httpinsufficientstorage","net::httpinternalservererror","net::httplengthrequired","net::httplocked","net::httploopdetected","net::httpmethodnotallowed","net::httpmisdirectedrequest","net::httpmovedpermanently","net::httpmultistatus","net::httpmultiplechoices","net::httpnetworkauthenticationrequired","net::httpnocontent","net::httpnonauthoritativeinformation","net::httpnotacceptable","net::httpnotextended","net::httpnotfound","net::httpnotimplemented","net::httpnotmodified","net::httpok","net::httppartialcontent","net::httppayloadtoolarge","net::httppaymentrequired","net::httppermanentredirect","net::httppreconditionfailed","net::httppreconditionrequired","net::httpprocessing","net::httpproxyauthenticationrequired","net::httprangenotsatisfiable","net::httpredirection","net::httprequest","net::httprequestheaderfieldstoolarge","net::httprequesttimeout","net::httpresetcontent","net::httpresponse","net::httpretriableerror","net::httpseeother","net::httpservererror","net::httpserverexception","net::httpserviceunavailable","net::httpsuccess","net::httpswitchprotocol","net::httptemporaryredirect","net::httptoomanyrequests","net::httpuritoolong","net::httpunauthorized","net::httpunavailableforlegalreasons","net::httpunknownresponse","net::httpunprocessableentity","net::httpunsupportedmediatype","net::httpupgraderequired","net::httpuseproxy","net::httpvariantalsonegotiates","net::httpversionnotsupported","net::imap","net::imap::badresponseerror","net::imap::bodytypeattachment","net::imap::bodytypebasic","net::imap::bodytypeextension","net::imap::bodytypemessage","net::imap::bodytypemultipart","net::imap::bodytypetext","net::imap::byeresponseerror","net::imap::crammd5authenticator","net::imap::dataformaterror","net::imap::digestmd5authenticator","net::imap::error","net::imap::flagcounterror","net::imap::loginauthenticator","net::imap::noresponseerror","net::imap::numvalidator","net::imap::plainauthenticator","net::imap::responseerror","net::imap::responseparseerror","net::imap::unknownresponseerror","net::opentimeout","net::pop3","net::popauthenticationerror","net::popbadresponse","net::poperror","net::popmail","net::protoautherror","net::protocommanderror","net::protofatalerror","net::protoretriableerror","net::protoservererror","net::protosyntaxerror","net::protounknownerror","net::protocretryerror","net::protocolerror","net::readtimeout","net::smtp","net::smtp::response","net::smtpauthenticationerror","net::smtperror","net::smtpfatalerror","net::smtpserverbusy","net::smtpsyntaxerror","net::smtpunknownerror","net::smtpunsupportedcommand","net::writeadapter","net::writetimeout","newton","nilclass","nomatchingpatternerror","nomemoryerror","nomethoderror","notimplementederror","numeric","oleproperty","object","object::parseerror","object::timeouterror","objectspace","objectspace::internalobjectwrapper","objectspace::weakmap","observable","open3","openssl","openssl::asn1","openssl::asn1::asn1data","openssl::asn1::asn1error","openssl::asn1::constructive","openssl::asn1::objectid","openssl::asn1::primitive","openssl::bn","openssl::bnerror","openssl::buffering","openssl::cipher","openssl::cipher::cipher","openssl::cipher::ciphererror","openssl::config","openssl::configerror","openssl::digest","openssl::digest::digesterror","openssl::engine","openssl::engine::engineerror","openssl::extconfig","openssl::hmac","openssl::hmacerror","openssl::kdf","openssl::kdf::kdferror","openssl::netscape","openssl::netscape::spki","openssl::netscape::spkierror","openssl::ocsp","openssl::ocsp::basicresponse","openssl::ocsp::certificateid","openssl::ocsp::ocsperror","openssl::ocsp::request","openssl::ocsp::response","openssl::ocsp::singleresponse","openssl::opensslerror","openssl::pkcs12","openssl::pkcs12::pkcs12error","openssl::pkcs5","openssl::pkcs7","openssl::pkcs7::pkcs7error","openssl::pkcs7::recipientinfo","openssl::pkcs7::signerinfo","openssl::pkey","openssl::pkey::dh","openssl::pkey::dherror","openssl::pkey::dsa","openssl::pkey::dsaerror","openssl::pkey::ec","openssl::pkey::ec::group","openssl::pkey::ec::group::error","openssl::pkey::ec::point","openssl::pkey::ec::point::error","openssl::pkey::ecerror","openssl::pkey::pkey","openssl::pkey::pkeyerror","openssl::pkey::rsa","openssl::pkey::rsaerror","openssl::random","openssl::random::randomerror","openssl::ssl","openssl::ssl::sslcontext","openssl::ssl::sslerror","openssl::ssl::sslerrorwaitreadable","openssl::ssl::sslerrorwaitwritable","openssl::ssl::sslserver","openssl::ssl::sslsocket","openssl::ssl::session","openssl::ssl::session::sessionerror","openssl::ssl::socketforwarder","openssl::x509","openssl::x509::attribute","openssl::x509::attributeerror","openssl::x509::crl","openssl::x509::crlerror","openssl::x509::certificate","openssl::x509::certificateerror","openssl::x509::extension","openssl::x509::extensionerror","openssl::x509::extensionfactory","openssl::x509::name","openssl::x509::name::rfc2253dn","openssl::x509::nameerror","openssl::x509::request","openssl::x509::requesterror","openssl::x509::revoked","openssl::x509::revokederror","openssl::x509::store","openssl::x509::storecontext","openssl::x509::storeerror","openstruct","openuri","openuri::httperror","openuri::httpredirect","openuri::meta","openuri::openread","optionparser","optionparser::ac","optionparser::acceptables","optionparser::ambiguousargument","optionparser::ambiguousoption","optionparser::arguable","optionparser::completinghash","optionparser::completion","optionparser::invalidargument","optionparser::invalidoption","optionparser::list","optionparser::missingargument","optionparser::needlessargument","optionparser::optionmap","optionparser::parseerror","optionparser::switch","optionparser::switch::noargument","optionparser::switch::optionalargument","optionparser::switch::placedargument","optionparser::switch::requiredargument","pp","pp::ppmethods","pstore","pstore::error","pty","pty::childexited","pathname","pool","prettyprint","prettyprint::singleline","prime","prime::eratosthenesgenerator","prime::eratosthenessieve","prime::generator23","prime::pseudoprimegenerator","prime::trialdivision","prime::trialdivisiongenerator","proc","process","process::gid","process::status","process::sys","process::uid","psych","psych::badalias","psych::classloader","psych::classloader::restricted","psych::coder","psych::disallowedclass","psych::emitter","psych::exception","psych::handler","psych::handler::dumperoptions","psych::handlers","psych::handlers::recorder","psych::json","psych::json::stream","psych::json::treebuilder","psych::nodes","psych::nodes::alias","psych::nodes::document","psych::nodes::mapping","psych::nodes::node","psych::nodes::scalar","psych::nodes::sequence","psych::nodes::stream","psych::omap","psych::parser","psych::parser::mark","psych::scalarscanner","psych::set","psych::stream","psych::streaming","psych::streaming::classmethods","psych::syntaxerror","psych::treebuilder","psych::visitors","psych::visitors::depthfirst","psych::visitors::emitter","psych::visitors::jsontree","psych::visitors::noaliasruby","psych::visitors::toruby","psych::visitors::visitor","psych::visitors::yamltree","queue","rdoc","rdoc","rdoc::alias","rdoc::anonclass","rdoc::anymethod","rdoc::attr","rdoc::classmodule","rdoc::codeobject","rdoc::comment","rdoc::constant","rdoc::context","rdoc::crossreference","rdoc::erbio","rdoc::erbpartial","rdoc::encoding","rdoc::error","rdoc::extend","rdoc::generator","rdoc::ghostmethod","rdoc::i18n","rdoc::include","rdoc::markdown","rdoc::markdown::memoentry","rdoc::markdown::parseerror","rdoc::markdown::ruleinfo","rdoc::markup","rdoc::metamethod","rdoc::methodattr","rdoc::mixin","rdoc::normalclass","rdoc::normalmodule","rdoc::options","rdoc::parser","rdoc::parser::c","rdoc::parser::changelog","rdoc::parser::markdown","rdoc::parser::rd","rdoc::parser::ripperstatelex","rdoc::parser::ripperstatelex::innerstatelex","rdoc::parser::ruby","rdoc::parser::rubytools","rdoc::parser::simple","rdoc::parser::text","rdoc::rd","rdoc::rdoc","rdoc::ri","rdoc::ri::error","rdoc::require","rdoc::rubygemshook","rdoc::servlet","rdoc::singleclass","rdoc::stats","rdoc::store","rdoc::store::error","rdoc::store::missingfileerror","rdoc::task","rdoc::text","rdoc::tokenstream","rdoc::tomdoc","rdoc::toplevel","rdoctask","rexml","rexml::attlistdecl","rexml::attribute","rexml::attributes","rexml::cdata","rexml::child","rexml::comment","rexml::dtd","rexml::dtd::attlistdecl","rexml::dtd::elementdecl","rexml::dtd::entitydecl","rexml::dtd::notationdecl","rexml::dtd::parser","rexml::declaration","rexml::doctype","rexml::document","rexml::element","rexml::elementdecl","rexml::elements","rexml::encoding","rexml::entity","rexml::entityconst","rexml::externalentity","rexml::formatters","rexml::formatters::default","rexml::formatters::pretty","rexml::formatters::transitive","rexml::functions","rexml::iosource","rexml::instruction","rexml::light","rexml::light::node","rexml::namespace","rexml::node","rexml::notationdecl","rexml::output","rexml::parent","rexml::parseexception","rexml::parsers","rexml::parsers::baseparser","rexml::parsers::lightparser","rexml::parsers::pullevent","rexml::parsers::pullparser","rexml::parsers::sax2parser","rexml::parsers::streamparser","rexml::parsers::treeparser","rexml::parsers::ultralightparser","rexml::parsers::xpathparser","rexml::quickpath","rexml::referencewriter","rexml::sax2listener","rexml::security","rexml::source","rexml::sourcefactory","rexml::streamlistener","rexml::text","rexml::undefinednamespaceexception","rexml::validation","rexml::validation::choice","rexml::validation::event","rexml::validation::interleave","rexml::validation::oneormore","rexml::validation::optional","rexml::validation::ref","rexml::validation::relaxng","rexml::validation::sequence","rexml::validation::state","rexml::validation::validationexception","rexml::validation::validator","rexml::validation::zeroormore","rexml::xmldecl","rexml::xmltokens","rexml::xpath","rexml::xpathnode","rexml::xpathparser","rss","rss::atom","rss::atom::commonmodel","rss::atom::contentmodel","rss::atom::contentmodel::classmethods","rss::atom::dateconstruct","rss::atom::duplicatelinkchecker","rss::atom::entry","rss::atom::feed","rss::atom::feed::author","rss::atom::feed::category","rss::atom::feed::contributor","rss::atom::feed::entry","rss::atom::feed::entry::content","rss::atom::feed::entry::published","rss::atom::feed::entry::source","rss::atom::feed::entry::summary","rss::atom::feed::generator","rss::atom::feed::icon","rss::atom::feed::id","rss::atom::feed::link","rss::atom::feed::logo","rss::atom::feed::rights","rss::atom::feed::subtitle","rss::atom::feed::title","rss::atom::feed::updated","rss::atom::personconstruct","rss::atom::personconstruct::email","rss::atom::personconstruct::name","rss::atom::personconstruct::uri","rss::atom::textconstruct","rss::atom::uricontentmodel","rss::basedublincoremodel","rss::baselistener","rss::basemodel","rss::baseparser","rss::basetrackbackmodel","rss::contentmodel","rss::conversionerror","rss::converter","rss::dublincoremodel","rss::dublincoremodel","rss::element","rss::error","rss::itunesbasemodel","rss::ituneschannelmodel","rss::ituneschannelmodel::itunescategory","rss::ituneschannelmodel::itunesimage","rss::ituneschannelmodel::itunesowner","rss::itunesitemmodel","rss::itunesitemmodel::itunesduration","rss::itunesmodelutils","rss::imagefaviconmodel","rss::imagefaviconmodel::imagefavicon","rss::imageitemmodel","rss::imageitemmodel::imageitem","rss::imagemodelutils","rss::invalidrsserror","rss::listenermixin","rss::maker","rss::maker::atom","rss::maker::atom::entry","rss::maker::atom::entry::channel","rss::maker::atom::entry::channel::cloud","rss::maker::atom::entry::channel::description","rss::maker::atom::entry::channel::generator","rss::maker::atom::entry::channel::skipdays","rss::maker::atom::entry::channel::skipdays::day","rss::maker::atom::entry::channel::skiphours","rss::maker::atom::entry::channel::skiphours::hour","rss::maker::atom::entry::image","rss::maker::atom::entry::items","rss::maker::atom::entry::items::item","rss::maker::atom::entry::textinput","rss::maker::atom::feed","rss::maker::atom::feed::channel","rss::maker::atom::feed::channel::categories","rss::maker::atom::feed::channel::categories::category","rss::maker::atom::feed::channel::cloud","rss::maker::atom::feed::channel::generator","rss::maker::atom::feed::channel::links","rss::maker::atom::feed::channel::links::link","rss::maker::atom::feed::channel::skipdays","rss::maker::atom::feed::channel::skipdays::day","rss::maker::atom::feed::channel::skiphours","rss::maker::atom::feed::channel::skiphours::hour","rss::maker::atom::feed::image","rss::maker::atom::feed::items","rss::maker::atom::feed::items::item","rss::maker::atom::feed::items::item::categories","rss::maker::atom::feed::items::item::categories::category","rss::maker::atom::feed::items::item::content","rss::maker::atom::feed::items::item::enclosure","rss::maker::atom::feed::items::item::guid","rss::maker::atom::feed::items::item::links","rss::maker::atom::feed::items::item::links::link","rss::maker::atom::feed::items::item::source","rss::maker::atom::feed::items::item::source::categories","rss::maker::atom::feed::items::item::source::categories::category","rss::maker::atom::feed::items::item::source::generator","rss::maker::atom::feed::items::item::source::icon","rss::maker::atom::feed::items::item::source::links","rss::maker::atom::feed::items::item::source::links::link","rss::maker::atom::feed::items::item::source::logo","rss::maker::atom::feed::textinput","rss::maker::atomcategory","rss::maker::atomgenerator","rss::maker::atomlink","rss::maker::atomlogo","rss::maker::atompersonconstructbase","rss::maker::atompersons","rss::maker::atomtextconstruct","rss::maker::atomtextconstructbase","rss::maker::atomtextconstructbase::ensurexmlcontent","rss::maker::base","rss::maker::channelbase","rss::maker::channelbase::authorsbase","rss::maker::channelbase::authorsbase::authorbase","rss::maker::channelbase::categoriesbase","rss::maker::channelbase::categoriesbase::categorybase","rss::maker::channelbase::cloudbase","rss::maker::channelbase::contributorsbase","rss::maker::channelbase::contributorsbase::contributorbase","rss::maker::channelbase::copyrightbase","rss::maker::channelbase::descriptionbase","rss::maker::channelbase::generatorbase","rss::maker::channelbase::itunescategories","rss::maker::channelbase::itunescategories::itunescategory","rss::maker::channelbase::itunesimage","rss::maker::channelbase::itunesowner","rss::maker::channelbase::linksbase","rss::maker::channelbase::linksbase::linkbase","rss::maker::channelbase::skipdaysbase","rss::maker::channelbase::skipdaysbase::daybase","rss::maker::channelbase::skiphoursbase","rss::maker::channelbase::skiphoursbase::hourbase","rss::maker::channelbase::titlebase","rss::maker::contentmodel","rss::maker::dublincoremodel","rss::maker::itunesbasemodel","rss::maker::ituneschannelmodel","rss::maker::ituneschannelmodel::itunescategoriesbase","rss::maker::ituneschannelmodel::itunescategoriesbase::itunescategorybase","rss::maker::ituneschannelmodel::itunesimagebase","rss::maker::ituneschannelmodel::itunesownerbase","rss::maker::itunesitemmodel","rss::maker::itunesitemmodel::itunesdurationbase","rss::maker::imagebase","rss::maker::imagefaviconmodel","rss::maker::imagefaviconmodel::imagefaviconbase","rss::maker::imageitemmodel","rss::maker::imageitemmodel::imageitembase","rss::maker::itemsbase","rss::maker::itemsbase::itembase","rss::maker::itemsbase::itembase::contentbase","rss::maker::itemsbase::itembase::descriptionbase","rss::maker::itemsbase::itembase::enclosurebase","rss::maker::itemsbase::itembase::guidbase","rss::maker::itemsbase::itembase::itunesduration","rss::maker::itemsbase::itembase::rightsbase","rss::maker::itemsbase::itembase::sourcebase","rss::maker::itemsbase::itembase::sourcebase::iconbase","rss::maker::itemsbase::itembase::sourcebase::logobase","rss::maker::itemsbase::itembase::sourcebase::rightsbase","rss::maker::itemsbase::itembase::sourcebase::subtitlebase","rss::maker::itemsbase::itembase::sourcebase::titlebase","rss::maker::itemsbase::itembase::titlebase","rss::maker::rss09","rss::maker::rss091","rss::maker::rss091::channel","rss::maker::rss091::image","rss::maker::rss091::items","rss::maker::rss091::items::item","rss::maker::rss091::textinput","rss::maker::rss092","rss::maker::rss092::channel","rss::maker::rss092::image","rss::maker::rss092::items","rss::maker::rss092::items::item","rss::maker::rss092::textinput","rss::maker::rss09::channel","rss::maker::rss09::channel::authors","rss::maker::rss09::channel::authors::author","rss::maker::rss09::channel::categories","rss::maker::rss09::channel::categories::category","rss::maker::rss09::channel::cloud","rss::maker::rss09::channel::contributors","rss::maker::rss09::channel::contributors::contributor","rss::maker::rss09::channel::copyright","rss::maker::rss09::channel::description","rss::maker::rss09::channel::generator","rss::maker::rss09::channel::links","rss::maker::rss09::channel::links::link","rss::maker::rss09::channel::skipdays","rss::maker::rss09::channel::skipdays::day","rss::maker::rss09::channel::skiphours","rss::maker::rss09::channel::skiphours::hour","rss::maker::rss09::channel::title","rss::maker::rss09::image","rss::maker::rss09::items","rss::maker::rss09::items::item","rss::maker::rss09::items::item::authors","rss::maker::rss09::items::item::authors::author","rss::maker::rss09::items::item::categories","rss::maker::rss09::items::item::categories::category","rss::maker::rss09::items::item::content","rss::maker::rss09::items::item::contributors","rss::maker::rss09::items::item::contributors::contributor","rss::maker::rss09::items::item::description","rss::maker::rss09::items::item::enclosure","rss::maker::rss09::items::item::guid","rss::maker::rss09::items::item::links","rss::maker::rss09::items::item::links::link","rss::maker::rss09::items::item::rights","rss::maker::rss09::items::item::source","rss::maker::rss09::items::item::source::authors","rss::maker::rss09::items::item::source::authors::author","rss::maker::rss09::items::item::source::categories","rss::maker::rss09::items::item::source::categories::category","rss::maker::rss09::items::item::source::contributors","rss::maker::rss09::items::item::source::contributors::contributor","rss::maker::rss09::items::item::source::generator","rss::maker::rss09::items::item::source::icon","rss::maker::rss09::items::item::source::links","rss::maker::rss09::items::item::source::links::link","rss::maker::rss09::items::item::source::logo","rss::maker::rss09::items::item::source::rights","rss::maker::rss09::items::item::source::subtitle","rss::maker::rss09::items::item::source::title","rss::maker::rss09::items::item::title","rss::maker::rss09::textinput","rss::maker::rss10","rss::maker::rss10::channel","rss::maker::rss10::channel::authors","rss::maker::rss10::channel::authors::author","rss::maker::rss10::channel::categories","rss::maker::rss10::channel::categories::category","rss::maker::rss10::channel::cloud","rss::maker::rss10::channel::contributors","rss::maker::rss10::channel::contributors::contributor","rss::maker::rss10::channel::copyright","rss::maker::rss10::channel::description","rss::maker::rss10::channel::generator","rss::maker::rss10::channel::links","rss::maker::rss10::channel::links::link","rss::maker::rss10::channel::skipdays","rss::maker::rss10::channel::skipdays::day","rss::maker::rss10::channel::skiphours","rss::maker::rss10::channel::skiphours::hour","rss::maker::rss10::channel::title","rss::maker::rss10::image","rss::maker::rss10::items","rss::maker::rss10::items::item","rss::maker::rss10::items::item::authors","rss::maker::rss10::items::item::authors::author","rss::maker::rss10::items::item::categories","rss::maker::rss10::items::item::categories::category","rss::maker::rss10::items::item::content","rss::maker::rss10::items::item::contributors","rss::maker::rss10::items::item::contributors::contributor","rss::maker::rss10::items::item::description","rss::maker::rss10::items::item::enclosure","rss::maker::rss10::items::item::guid","rss::maker::rss10::items::item::links","rss::maker::rss10::items::item::links::link","rss::maker::rss10::items::item::rights","rss::maker::rss10::items::item::source","rss::maker::rss10::items::item::source::authors","rss::maker::rss10::items::item::source::authors::author","rss::maker::rss10::items::item::source::categories","rss::maker::rss10::items::item::source::categories::category","rss::maker::rss10::items::item::source::contributors","rss::maker::rss10::items::item::source::contributors::contributor","rss::maker::rss10::items::item::source::generator","rss::maker::rss10::items::item::source::icon","rss::maker::rss10::items::item::source::links","rss::maker::rss10::items::item::source::links::link","rss::maker::rss10::items::item::source::logo","rss::maker::rss10::items::item::source::rights","rss::maker::rss10::items::item::source::subtitle","rss::maker::rss10::items::item::source::title","rss::maker::rss10::items::item::title","rss::maker::rss10::textinput","rss::maker::rss20","rss::maker::rss20::channel","rss::maker::rss20::channel::categories","rss::maker::rss20::channel::categories::category","rss::maker::rss20::channel::cloud","rss::maker::rss20::channel::generator","rss::maker::rss20::channel::skipdays","rss::maker::rss20::channel::skipdays::day","rss::maker::rss20::channel::skiphours","rss::maker::rss20::channel::skiphours::hour","rss::maker::rss20::image","rss::maker::rss20::items","rss::maker::rss20::items::item","rss::maker::rss20::items::item::authors","rss::maker::rss20::items::item::authors::author","rss::maker::rss20::items::item::categories","rss::maker::rss20::items::item::categories::category","rss::maker::rss20::items::item::enclosure","rss::maker::rss20::items::item::guid","rss::maker::rss20::items::item::source","rss::maker::rss20::items::item::source::links","rss::maker::rss20::items::item::source::links::link","rss::maker::rss20::textinput","rss::maker::rssbase","rss::maker::setupdefaultdate","rss::maker::setupdefaultlanguage","rss::maker::slashmodel","rss::maker::syndicationmodel","rss::maker::taxonomytopicmodel","rss::maker::taxonomytopicmodel::taxonomytopicsbase","rss::maker::taxonomytopicmodel::taxonomytopicsbase::taxonomytopicbase","rss::maker::taxonomytopicsmodel","rss::maker::taxonomytopicsmodel::taxonomytopicsbase","rss::maker::textinputbase","rss::maker::trackbackmodel","rss::maker::trackbackmodel::trackbackaboutsbase","rss::maker::trackbackmodel::trackbackaboutsbase::trackbackaboutbase","rss::maker::xmlstylesheets","rss::maker::xmlstylesheets::xmlstylesheet","rss::missingattributeerror","rss::missingtagerror","rss::nserror","rss::notavailablevalueerror","rss::notexpectedtagerror","rss::notseterror","rss::notvalidxmlparser","rss::notwellformederror","rss::overlappedprefixerror","rss::parser","rss::rdf","rss::rdf::bag","rss::rdf::bag::li","rss::rdf::channel","rss::rdf::channel::image","rss::rdf::channel::items","rss::rdf::channel::items::seq","rss::rdf::channel::textinput","rss::rdf::image","rss::rdf::item","rss::rdf::li","rss::rdf::seq","rss::rdf::seq::li","rss::rdf::textinput","rss::rexmllikexmlparser","rss::rexmllistener","rss::rexmlparser","rss::rss09","rss::rss10","rss::rootelementmixin","rss::rss","rss::rss::channel","rss::rss::channel::cloud","rss::rss::channel::image","rss::rss::channel::item","rss::rss::channel::item::category","rss::rss::channel::item::enclosure","rss::rss::channel::item::guid","rss::rss::channel::item::source","rss::rss::channel::skipdays","rss::rss::channel::skipdays::day","rss::rss::channel::skiphours","rss::rss::channel::skiphours::hour","rss::rss::channel::textinput","rss::setupmaker","rss::slashmodel","rss::syndicationmodel","rss::taxonomytopicmodel","rss::taxonomytopicmodel::taxonomytopic","rss::taxonomytopicsmodel","rss::taxonomytopicsmodel::taxonomytopics","rss::taxonomytopicsmodel::taxonomytopics::bag","rss::toomuchtagerror","rss::trackbackmodel10","rss::trackbackmodel10::trackbackabout","rss::trackbackmodel10::trackbackping","rss::trackbackmodel20","rss::trackbackmodel20::trackbackabout","rss::trackbackmodel20::trackbackping","rss::trackbackutils","rss::unknownconversionmethoderror","rss::unknowntagerror","rss::unsupportedmakerversionerror","rss::utils","rss::utils::csv","rss::utils::explicitcleanother","rss::utils::inheritedreader","rss::utils::yesother","rss::xml","rss::xml::element","rss::xmlparserlistener","rss::xmlparsernotfound","rss::xmlparserparser","rss::xmlscanlistener","rss::xmlscanparser","rss::xmlstylesheet","rss::xmlstylesheetmixin","racc","racc::accept","racc::actiontable","racc::compileerror","racc::cparseparams","racc::debugflags","racc::error","racc::goto","racc::grammar","racc::grammar::definitionenv","racc::grammar::precedencedefinitionenv","racc::grammarfileparser","racc::grammarfileparser::result","racc::grammarfilescanner","racc::iset","racc::item","racc::locationpointer","racc::logfilegenerator","racc::ormark","racc::parseerror","racc::parseerror","racc::parser","racc::parserclassgenerator","racc::parserfilegenerator","racc::parserfilegenerator::params","racc::prec","racc::rrconflict","racc::reduce","racc::rule","racc::srconflict","racc::shift","racc::sourcetext","racc::state","racc::statetransitiontable","racc::statetransitiontablegenerator","racc::states","racc::sym","racc::symboltable","racc::useraction","rake","random","random::formatter","range","rangeerror","rational","readline","regexp","regexperror","reline","reline::core","requiredargumentmissingerror","resolv","resolv::dns","resolv::dns::config","resolv::dns::config::nxdomain","resolv::dns::config::otherresolverror","resolv::dns::decodeerror","resolv::dns::encodeerror","resolv::dns::name","resolv::dns::query","resolv::dns::requester","resolv::dns::requester::requesterror","resolv::dns::resource","resolv::dns::resource::any","resolv::dns::resource::cname","resolv::dns::resource::domainname","resolv::dns::resource::generic","resolv::dns::resource::hinfo","resolv::dns::resource::in","resolv::dns::resource::in::a","resolv::dns::resource::in::aaaa","resolv::dns::resource::in::srv","resolv::dns::resource::in::wks","resolv::dns::resource::loc","resolv::dns::resource::minfo","resolv::dns::resource::mx","resolv::dns::resource::ns","resolv::dns::resource::ptr","resolv::dns::resource::soa","resolv::dns::resource::txt","resolv::hosts","resolv::ipv4","resolv::ipv6","resolv::loc","resolv::loc::alt","resolv::loc::coord","resolv::loc::size","resolv::mdns","resolv::resolverror","resolv::resolvtimeout","rinda","rinda::drbobjecttemplate","rinda::invalidhashtuplekey","rinda::notifytemplateentry","rinda::requestcancelederror","rinda::requestexpirederror","rinda::rindaerror","rinda::ringfinger","rinda::ringprovider","rinda::ringserver","rinda::simplerenewer","rinda::template","rinda::templateentry","rinda::tuple","rinda::tuplebag","rinda::tuplebag::tuplebin","rinda::tupleentry","rinda::tuplespace","rinda::tuplespaceproxy","rinda::waittemplateentry","ripper","ripper::filter","rubylex","rubylex::terminatelineinput","rubyvm","rubyvm::abstractsyntaxtree","rubyvm::abstractsyntaxtree::node","rubyvm::instructionsequence","rubyvm::mjit","runtimeerror","sdbm","sdbmerror","sockssocket","scripterror","securerandom","securityerror","set","shellwords","signal","signalexception","simpledelegator","singleforwardable","singleton","sizedqueue","socket","socket::ancillarydata","socket::constants","socket::ifaddr","socket::option","socket::udpsource","socketerror","sortedset","standarderror","stopiteration","string","stringio","stringscanner","stringscanner::error","struct","symbol","syntaxerror","syslog","syslog::constants","syslog::facility","syslog::level","syslog::logger","syslog::logger::formatter","syslog::macros","syslog::option","systemcallerror","systemexit","systemstackerror","tcpserver","tcpsocket","tsort","tsort::cyclic","tempio","tempfile","thread","thread::backtrace::location","threaderror","threadgroup","time","timeout","timeout::error","timeout::timeouterror","tracepoint","tracer","trueclass","typeerror","udpsocket","unixserver","unixsocket","uri","uri::badurierror","uri::error","uri::escape","uri::ftp","uri::file","uri::generic","uri::http","uri::https","uri::invalidcomponenterror","uri::invalidurierror","uri::ldap","uri::ldaps","uri::mailto","uri::parser","uri::regexp","uri::rfc2396_parser","uri::rfc2396_regexp","uri::rfc2396_regexp::pattern","unboundmethod","uncaughtthrowerror","undefinedcommanderror","undefinedcommanderror::spellchecker","undefinedtaskerror","unicodenormalize","unknownargumenterror","unknownargumenterror::spellchecker","vector","vector::zerovectorerror","webrick","webrick::accesslog","webrick::accesslog::accesslogerror","webrick::basiclog","webrick::cgi","webrick::config","webrick::cookie","webrick::daemon","webrick::genericserver","webrick::htmlutils","webrick::httpauth","webrick::httpauth::authenticator","webrick::httpauth::basicauth","webrick::httpauth::digestauth","webrick::httpauth::htdigest","webrick::httpauth::htgroup","webrick::httpauth::htpasswd","webrick::httpauth::proxyauthenticator","webrick::httpauth::proxybasicauth","webrick::httpauth::proxydigestauth","webrick::httpauth::userdb","webrick::httpproxyserver","webrick::httprequest","webrick::httpresponse","webrick::httpresponse::chunkedwrapper","webrick::httpresponse::invalidheader","webrick::httpserver","webrick::httpservererror","webrick::httpservlet","webrick::httpservlet::abstractservlet","webrick::httpservlet::cgihandler","webrick::httpservlet::defaultfilehandler","webrick::httpservlet::erbhandler","webrick::httpservlet::filehandler","webrick::httpservlet::httpservleterror","webrick::httpservlet::prochandler","webrick::httpstatus","webrick::httpstatus::clienterror","webrick::httpstatus::eoferror","webrick::httpstatus::error","webrick::httpstatus::info","webrick::httpstatus::redirect","webrick::httpstatus::servererror","webrick::httpstatus::status","webrick::httpstatus::success","webrick::httputils","webrick::httputils::formdata","webrick::httpversion","webrick::log","webrick::snirequest","webrick::servererror","webrick::simpleserver","webrick::utils","webrick::utils::timeouthandler","win32ole","win32ole::variant","win32olequeryinterfaceerror","win32oleruntimeerror","win32ole_event","win32ole_method","win32ole_param","win32ole_record","win32ole_type","win32ole_typelib","win32ole_variable","win32ole_variant","warning","weakref","weakref::referror","xml","xml::parser","xmlencoding_ja","xmlencoding_ja::sjishandler","xmp","xmp::stringinputmethod","yaml","yaml::dbm","yaml::store","yaml::syck","yaml::syck","zerodivisionerror","zlib","zlib::buferror","zlib::dataerror","zlib::deflate","zlib::error","zlib::gzipfile","zlib::gzipfile::crcerror","zlib::gzipfile::error","zlib::gzipfile::lengtherror","zlib::gzipfile::nofooter","zlib::gzipreader","zlib::gzipwriter","zlib::inprogresserror","zlib::inflate","zlib::memerror","zlib::needdict","zlib::streamend","zlib::streamerror","zlib::versionerror","zlib::zstream","fatal","basicobject#!()","delegator#!()","basicobject#!=()","delegator#!=()","object#!~()","bigdecimal#%()","float#%()","integer#%()","numeric#%()","openssl::bn#%()","range#%()","string#%()","array#&()","falseclass#&()","ipaddr#&()","integer#&()","nilclass#&()","process::status#&()","set#&()","trueclass#&()","array#*()","benchmark::tms#*()","bigdecimal#*()","complex#*()","float#*()","integer#*()","matrix#*()","openssl::bn#*()","rational#*()","string#*()","vector#*()","bigdecimal#**()","complex#**()","float#**()","integer#**()","matrix#**()","openssl::bn#**()","rational#**()","array#+()","benchmark::tms#+()","bigdecimal#+()","bundler::uri::generic#+()","complex#+()","date#+()","enumerator#+()","fiddle::pointer#+()","float#+()","integer#+()","matrix#+()","openssl::bn#+()","pathname#+()","rational#+()","set#+()","string#+()","time#+()","uri::generic#+()","vector#+()","bigdecimal#+@()","fiddle::pointer#+@()","matrix#+@()","numeric#+@()","openssl::bn#+@()","string#+@()","vector#+@()","array#-()","benchmark::tms#-()","bigdecimal#-()","bundler::uri::generic#-()","complex#-()","date#-()","fiddle::pointer#-()","float#-()","integer#-()","matrix#-()","openssl::bn#-()","rational#-()","set#-()","time#-()","uri::generic#-()","vector#-()","bigdecimal#-@()","complex#-@()","fiddle::pointer#-@()","float#-@()","integer#-@()","matrix#-@()","numeric#-@()","openssl::bn#-@()","rational#-@()","string#-@()","vector#-@()","benchmark::tms#/()","bigdecimal#/()","complex#/()","float#/()","integer#/()","matrix#/()","openssl::bn#/()","pathname#/()","rational#/()","vector#/()","bigdecimal#<()","comparable#<()","float#<()","hash#<()","integer#<()","module#<()","set#<()","array#<<()","bundler::connectionpool::timedstack#<<()","bundler::index#<<()","bundler::specset#<<()","csv#<<()","csv::row#<<()","csv::table#<<()","csv::writer#<<()","date#<<()","digest::base#<<()","digest::instance#<<()","gem::availableset#<<()","gem::sourcelist#<<()","io#<<()","io::generic_writable#<<()","ipaddr#<<()","integer#<<()","logger#<<()","method#<<()","net::writeadapter#<<()","openssl::bn#<<()","openssl::buffering#<<()","openssl::digest#<<()","openssl::hmac#<<()","proc#<<()","psych::visitors::yamltree#<<()","queue#<<()","rexml::attributes#<<()","rexml::document#<<()","rexml::elements#<<()","rexml::light::node#<<()","rexml::output#<<()","rexml::parent#<<()","rexml::text#<<()","rexml::validation::choice#<<()","rexml::validation::state#<<()","rss::xml::element#<<()","set#<<()","sizedqueue#<<()","string#<<()","stringscanner#<<()","webrick::basiclog#<<()","webrick::httputils::formdata#<<()","zlib::deflate#<<()","zlib::gzipwriter#<<()","zlib::inflate#<<()","bigdecimal#<=()","comparable#<=()","float#<=()","hash#<=()","integer#<=()","module#<=()","set#<=()","array#<=>()","bigdecimal#<=>()","bundler::gemhelpers::platformmatch#<=>()","bundler::lazyspecification::identifier#<=>()","bundler::molinillo::resolver::resolution::unwinddetails#<=>()","bundler::remotespecification#<=>()","bundler::versionranges::reqr#<=>()","complex#<=>()","date#<=>()","fiddle::pointer#<=>()","file::stat#<=>()","float#<=>()","gem::dependency#<=>()","gem::nametuple#<=>()","gem::source#<=>()","gem::source::git#<=>()","gem::source::installed#<=>()","gem::source::local#<=>()","gem::source::specificfile#<=>()","gem::source::vendor#<=>()","gem::version#<=>()","ipaddr#<=>()","irb::notifier::levelednotifier#<=>()","integer#<=>()","module#<=>()","numeric#<=>()","object#<=>()","openssl::bn#<=>()","openssl::x509::name#<=>()","pathname#<=>()","rdoc::alias#<=>()","rdoc::constant#<=>()","rdoc::context#<=>()","rdoc::methodattr#<=>()","rdoc::mixin#<=>()","rexml::comment#<=>()","rexml::text#<=>()","rss::maker::itemsbase::itembase#<=>()","rational#<=>()","string#<=>()","symbol#<=>()","time#<=>()","webrick::httpversion#<=>()","array#==()","basicobject#==()","bigdecimal#==()","bundler::depproxy#==()","bundler::index#==()","bundler::lazyspecification#==()","bundler::molinillo::dependencygraph#==()","bundler::molinillo::dependencygraph::vertex#==()","bundler::plugin::api::source#==()","bundler::resolver::specgroup#==()","bundler::rubyversion#==()","bundler::settings::mirror#==()","bundler::source::git#==()","bundler::source::metadata#==()","bundler::source::path#==()","bundler::source::rubygems#==()","bundler::uri::generic#==()","csv::row#==()","csv::table#==()","comparable#==()","complex#==()","delegator#==()","digest::instance#==()","encoding::converter#==()","enumerator::arithmeticsequence#==()","exception#==()","fiddle::pointer#==()","float#==()","gem::nametuple#==()","gem::platform#==()","gem::resolver::molinillo::dependencygraph#==()","gem::resolver::molinillo::dependencygraph::vertex#==()","hash#==()","ipaddr#==()","integer#==()","matchdata#==()","matrix#==()","method#==()","module#==()","openssl::bn#==()","openssl::pkey::ec::group#==()","openssl::pkey::ec::point#==()","openssl::ssl::session#==()","openssl::x509::attribute#==()","openssl::x509::crl#==()","openssl::x509::certificate#==()","openssl::x509::extension#==()","openssl::x509::request#==()","openssl::x509::revoked#==()","openstruct#==()","pathname#==()","process::status#==()","rdoc::attr#==()","rdoc::constant#==()","rdoc::toplevel#==()","rexml::attribute#==()","rexml::comment#==()","rexml::instruction#==()","rexml::validation::event#==()","rexml::xmldecl#==()","rss::xml::element#==()","racc::locationpointer#==()","racc::rule#==()","racc::state#==()","random#==()","range#==()","rational#==()","regexp#==()","set#==()","string#==()","struct#==()","symbol#==()","uri::generic#==()","unboundmethod#==()","vector#==()","bigdecimal#===()","date#===()","enumerator::arithmeticsequence#===()","falseclass#===()","float#===()","gem::dependency#===()","gem::platform#===()","gem::requirement#===()","ipaddr#===()","integer#===()","method#===()","module#===()","nilclass#===()","object#===()","openssl::bn#===()","pathname#===()","proc#===()","range#===()","regexp#===()","rinda::drbobjecttemplate#===()","rinda::template#===()","rinda::templateentry#===()","set#===()","string#===()","symbol#===()","systemcallerror::===()","trueclass#===()","gem::dependency#=~()","gem::platform#=~()","gem::requirement#=~()","nilclass#=~()","object#=~()","rexml::light::node#=~()","regexp#=~()","string#=~()","symbol#=~()","bigdecimal#>()","comparable#>()","float#>()","hash#>()","integer#>()","module#>()","set#>()","bigdecimal#>=()","comparable#>=()","float#>=()","hash#>=()","integer#>=()","module#>=()","set#>=()","date#>>()","ipaddr#>>()","integer#>>()","method#>>()","openssl::bn#>>()","proc#>>()","process::status#>>()","net::pop3::apop()","gem::package::tartestcase#asciiz()","rexml::parsers::xpathparser#additiveexpr()","rexml::parsers::xpathparser#andexpr()","kernel#array()","kernel#bigdecimal()","object#csv()","kernel#complex()","irb::currentcontext()","net::http#d()","thread::debug()","thread::debug=()","object#delegateclass()","object#digest()","openssl#digest()","openssl::digest()","bigmath#e()","rexml::parsers::xpathparser#equalityexpr()","rexml::parsers::xpathparser#filterexpr()","kernel#float()","rexml::parsers::xpathparser#functioncall()","kernel#hash()","matrix::i()","kernel#integer()","kernel#json()","irb::jobmanager()","syslog::macros#log_mask()","syslog::macros#log_upto()","rexml::parsers::xpathparser#locationpath()","rexml::parsers::xpathparser#multiplicativeexpr()","rexml::parsers::xpathparser#nodetest()","rexml::parsers::xpathparser#orexpr()","bigmath#pi()","rexml::parsers::xpathparser#pathexpr()","kernel#pathname()","rss::rss::channel::item::guid#permalink?()","rexml::parsers::xpathparser#predicate()","rexml::parsers::xpathparser#primaryexpr()","net::http::proxy()","kernel#rational()","rexml::parsers::xpathparser#relationalexpr()","rexml::parsers::xpathparser#relativelocationpath()","gem::package::tartestcase#sp()","gem::package::tartestcase#sp_z()","irb::locale#string()","kernel#string()","bundler#uri()","bundler::uri()","kernel#uri()","kernel::uri()","rexml::parsers::xpathparser#unaryexpr()","rexml::parsers::xpathparser#unionexpr()","gem::package::tartestcase#z()","array::[]()","array#[]()","bundler::index#[]()","bundler::settings#[]()","bundler::specset#[]()","cgi::queryextension#[]()","cgi::session#[]()","csv::row#[]()","csv::table#[]()","continuation#[]()","dbm#[]()","drb::drbsslsocket::sslconfig#[]()","drb::gw#[]()","dir::[]()","env::[]()","fiddle::cstructentity#[]()","fiddle::compositehandler#[]()","fiddle::handle#[]()","fiddle::handle::[]()","fiddle::importer#[]()","fiddle::pointer#[]()","fiddle::pointer::[]()","gdbm#[]()","gem::commandmanager#[]()","gem::configfile#[]()","hash#[]()","hash::[]()","irb::history#[]()","integer#[]()","json::[]()","json::ext::generator::state#[]()","json::genericobject#[]()","makemakefile::[]()","matchdata#[]()","matrix#[]()","matrix::[]()","method#[]()","net::httpheader#[]()","oleproperty#[]()","objectspace::weakmap#[]()","openssl::config#[]()","openstruct#[]()","pstore#[]()","prime::trialdivision#[]()","proc#[]()","psych::coder#[]()","rexml::attlistdecl#[]()","rexml::attributes#[]()","rexml::element#[]()","rexml::elements#[]()","rexml::light::node#[]()","rexml::parent#[]()","rexml::parsers::pullevent#[]()","rss::maker::[]()","rss::xml::element#[]()","racc::grammar#[]()","racc::iset#[]()","racc::rule#[]()","racc::states#[]()","racc::symboltable#[]()","rinda::tuple#[]()","rinda::tupleentry#[]()","sdbm#[]()","set::[]()","string#[]()","stringscanner#[]()","struct#[]()","symbol#[]()","thread#[]()","vector#[]()","vector::[]()","webrick::cgi#[]()","webrick::genericserver#[]()","webrick::httprequest#[]()","webrick::httpresponse#[]()","webrick::httpstatus::[]()","webrick::httputils::formdata#[]()","win32ole#[]()","win32ole_variant#[]()","warning::[]()","yaml::dbm#[]()","array#[]=()","bundler::specset#[]=()","bundler::thor::coreext::orderedhash#[]=()","cgi::session#[]=()","csv::row#[]=()","csv::table#[]=()","dbm#[]=()","drb::gw#[]=()","env::[]=()","fiddle::cstructentity#[]=()","fiddle::pointer#[]=()","gdbm#[]=()","gem::configfile#[]=()","hash#[]=()","json::ext::generator::state#[]=()","json::genericobject#[]=()","makemakefile::[]=()","matrix#[]=()","net::httpheader#[]=()","oleproperty#[]=()","objectspace::weakmap#[]=()","openssl::config#[]=()","openstruct#[]=()","pstore#[]=()","psych::coder#[]=()","rexml::attributes#[]=()","rexml::elements#[]=()","rexml::light::node#[]=()","rexml::parent#[]=()","rexml::xpathparser#[]=()","rss::xml::element#[]=()","racc::iset#[]=()","sdbm#[]=()","string#[]=()","struct#[]=()","thread#[]=()","vector#[]=()","webrick::httpresponse#[]=()","win32ole#[]=()","win32ole_variant#[]=()","warning::[]=()","yaml::dbm#[]=()","falseclass#^()","integer#^()","nilclass#^()","set#^()","trueclass#^()","racc::grammar::definitionenv#_()","rss::rss::channel::item::guid#_permalink?()","kernel#__callee__()","bundler::resolver::specgroup#__dependencies()","kernel#__dir__()","drb::drbobject#__drbref()","drb::drbobject#__drbref()","drb::drbobject#__drburi()","drb::drbobject#__drburi()","irb::workspace#__evaluate__()","irb::context#__exit__()","delegator#__getobj__()","simpledelegator#__getobj__()","basicobject#__id__()","bundler::lazyspecification#__materialize__()","kernel#__method__()","delegator#__raise__()","basicobject#__send__()","delegator#__setobj__()","simpledelegator#__setobj__()","bundler::endpointspecification#__swap__()","bundler::remotespecification#__swap__()","rexml::element#__to_xpath_helper()","rss::element#__validate()","optionparser::ac#_ac_arg_enable()","racc::grammar::definitionenv#_add()","racc::grammar::definitionenv#_added?()","rss::element#_attrs()","rss::rss#_attrs()","optionparser::ac#_check_ac_args()","racc::grammar#_compute_expand()","racc::grammar::definitionenv#_defmetasyntax()","racc::grammar::definitionenv#_delayed_add()","bigdecimal#_dump()","drb::drbobject#_dump()","drb::drbobject#_dump()","gem::specification#_dump()","singleton#_dump()","enumerator::lazy#_enumerable_collect()","enumerator::lazy#_enumerable_collect_concat()","enumerator::lazy#_enumerable_drop()","enumerator::lazy#_enumerable_drop_while()","enumerator::lazy#_enumerable_filter()","enumerator::lazy#_enumerable_filter_map()","enumerator::lazy#_enumerable_find_all()","enumerator::lazy#_enumerable_flat_map()","enumerator::lazy#_enumerable_grep()","enumerator::lazy#_enumerable_grep_v()","enumerator::lazy#_enumerable_map()","enumerator::lazy#_enumerable_reject()","enumerator::lazy#_enumerable_select()","enumerator::lazy#_enumerable_take()","enumerator::lazy#_enumerable_take_while()","enumerator::lazy#_enumerable_uniq()","enumerator::lazy#_enumerable_with_index()","enumerator::lazy#_enumerable_zip()","drb::threadobject#_execute()","win32ole#_getproperty()","gem::streamui#_gets_noecho()","bundler::graph#_groups()","date::_httpdate()","objectspace::_id2ref()","racc::grammar::definitionenv#_intern()","win32ole#_invoke()","ipaddr#_ipv4_compat?()","date::_iso8601()","date::_jisx0301()","bigdecimal::_load()","drb::drbobject::_load()","drb::drbobject::_load()","gem::specification::_load()","singleton::_load()","bundler::endpointspecification#_local_specification()","bundler::graph#_make_label()","cgi#_no_crlf_check()","rss::listenermixin#_ns()","date::_parse()","rss::rexmlparser#_parse()","rss::xmlparserparser#_parse()","rss::xmlscanparser#_parse()","rss::maker::setupdefaultdate#_parse_date_if_needed()","bundler::molinillo::dependencygraph::vertex#_path_to?()","bundler::graph#_populate_relations()","racc::parser#_racc_do_parse_c()","racc::parser#_racc_do_parse_rb()","racc::parser#_racc_do_reduce()","racc::parser#_racc_evalact()","racc::parser#_racc_init_sysvars()","racc::parser#_racc_setup()","racc::parser#_racc_yyparse_c()","racc::parser#_racc_yyparse_rb()","bundler::molinillo::dependencygraph::vertex#_recursive_predecessors()","bundler::molinillo::dependencygraph::vertex#_recursive_successors()","racc::grammar::definitionenv#_regist()","bundler::remotespecification#_remote_specification()","bundler::stubspecification#_remote_specification()","ipaddr#_reverse()","date::_rfc2822()","date::_rfc3339()","date::_rfc822()","gem::version#_segments()","rss::maker::atom::entry::items::item#_set_default_values()","rss::maker::atom::feed::channel#_set_default_values()","rss::maker::atom::feed::items::item#_set_default_values()","rss::maker::base#_set_default_values()","rss::maker::setupdefaultdate#_set_default_values()","rss::maker::setupdefaultlanguage#_set_default_values()","irb::context#_set_last_value()","win32ole#_setproperty()","rss::rss::channel::item#_setup_maker_element()","gem::version#_split_segments()","date::_strptime()","datetime::_strptime()","rss::element#_tags()","gem::requirement#_tilde_requirements()","ipaddr#_to_string()","rss::element#_validate()","gem::version#_version()","racc::grammar::definitionenv#_wrap()","date::_xmlschema()","kernel#`()","cgi::htmlextension#a()","abbrev::abbrev()","abbrev#abbrev()","array#abbrev()","gem::specification#abbreviate()","rexml::parsers::xpathparser#abbreviate()","kernel#abort()","net::ftp#abort()","optionparser#abort()","pstore#abort()","process::abort()","thread#abort_on_exception()","thread::abort_on_exception()","thread::abort_on_exception=()","thread#abort_on_exception=()","bundler::worker#abort_threads()","bigdecimal#abs()","complex#abs()","float#abs()","integer#abs()","matrix#abs()","numeric#abs()","rational#abs()","complex#abs2()","numeric#abs2()","bundler::uri::generic#absolute()","uri::generic#absolute()","bundler::uri::generic#absolute?()","pathname#absolute?()","resolv::dns::name#absolute?()","uri::generic#absolute?()","bundler::thor::lineeditor::readline::pathcompletion#absolute_matches()","file::absolute_path()","rubyvm::instructionsequence#absolute_path()","thread::backtrace::location#absolute_path()","file::absolute_path?()","optionparser::ac#ac_arg_disable()","optionparser::ac#ac_arg_enable()","optionparser::ac#ac_arg_with()","drb::drbsslsocket::sslconfig#accept()","openssl::ssl::sslserver#accept()","openssl::ssl::sslsocket#accept()","optionparser::accept()","optionparser#accept()","optionparser::list#accept()","psych::visitors::jsontree#accept()","psych::visitors::toruby#accept()","psych::visitors::visitor#accept()","psych::visitors::yamltree#accept()","socket#accept()","tcpserver#accept()","unixserver#accept()","racc::rule#accept?()","cgi::accept_charset()","cgi::accept_charset=()","socket::accept_loop()","openssl::ssl::sslsocket#accept_nonblock()","socket#accept_nonblock()","tcpserver#accept_nonblock()","unixserver#accept_nonblock()","gem::localremoteoptions#accept_uri_http()","webrick::httpserver#access_log()","net::ftp#acct()","math::acos()","math::acosh()","racc::statetransitiontablegenerator#act2actid()","bundler::permissionerror#action()","racc::grammar::definitionenv#action()","bundler::molinillo::dependencygraph::action::action_name()","bundler::molinillo::dependencygraph::addedgenocircular::action_name()","bundler::molinillo::dependencygraph::deleteedge::action_name()","bundler::molinillo::dependencygraph::detachvertexnamed::action_name()","bundler::molinillo::dependencygraph::tag::action_name()","gem::resolver::molinillo::dependencygraph::action::action_name()","gem::resolver::molinillo::dependencygraph::addedgenocircular::action_name()","gem::resolver::molinillo::dependencygraph::deleteedge::action_name()","gem::resolver::molinillo::dependencygraph::detachvertexnamed::action_name()","gem::resolver::molinillo::dependencygraph::tag::action_name()","racc::logfilegenerator#action_out()","racc::parserfilegenerator#actions()","gem::specification#activate()","gem::specification#activate_dependencies()","bundler::molinillo::resolver::resolution#activate_new_spec()","bundler::resolver::specgroup#activate_platform!()","gem::resolver::molinillo::resolver::resolution#activate_spec()","bundler::molinillo::delegates::resolutionstate#activated()","bundler::stubspecification#activated()","gem::resolver::molinillo::delegates::resolutionstate#activated()","bundler::stubspecification#activated=()","gem::basicspecification#activated?()","gem::activated_gem_paths()","net::http#active?()","net::pop3#active?()","gem::dependencylist#active_count()","acl::acllist#add()","benchmark::tms#add()","bigdecimal#add()","bundler::cli#add()","drb::weakidconv::weakset#add()","gem::availableset#add()","gem::dependencylist#add()","gem::resolver::requirementlist#add()","gem::testcase::staticset#add()","logger#add()","psych::coder#add()","rdoc::context#add()","rexml::attributes#add()","rexml::doctype#add()","rexml::document#add()","rexml::elements#add()","rexml::parent#add()","rexml::parsers::sax2parser#add()","racc::grammar#add()","racc::iset#add()","rinda::tuplebag::tuplebin#add()","set#add()","syslog::logger#add()","threadgroup#add()","webrick::httpauth::htgroup#add()","benchmark::tms#add!()","set#add?()","gem::requestset::lockfile#add_git()","rdoc::anymethod#add_alias()","rdoc::attr#add_alias()","rdoc::context#add_alias()","rdoc::methodattr#add_alias()","rdoc::stats#add_alias()","rdoc::toplevel#add_alias()","gem::resolver::installerset#add_always_install()","openssl::x509::request#add_attribute()","rdoc::context#add_attribute()","rdoc::stats#add_attribute()","rexml::element#add_attribute()","rexml::element#add_attributes()","net::imap::add_authenticator()","gem::specification#add_bindir()","gem::localremoteoptions#add_bulk_threshold_option()","bundler::lockfilegenerator#add_bundled_with()","rdoc::store#add_c_enclosure()","rdoc::store#add_c_variables()","openssl::x509::store#add_cert()","openssl::ocsp::request#add_certid()","openssl::pkcs7#add_certificate()","openssl::ssl::sslcontext#add_certificate()","gem::package#add_checksums()","bundler::molinillo::dependencygraph#add_child_vertex()","gem::resolver::molinillo::dependencygraph#add_child_vertex()","rdoc::context#add_class()","rdoc::stats#add_class()","rdoc::context#add_class_or_module()","gem::localremoteoptions#add_clear_sources_option()","bundler::ui::shell#add_color()","bundler::ui::silent#add_color()","bundler::plugin#add_command()","rdoc::classmodule#add_comment()","gem::command::add_common_option()","rdoc::context#add_constant()","rdoc::stats#add_constant()","rdoc::toplevel#add_constant()","csv::fieldsconverter#add_converter()","openssl::pkcs7#add_crl()","openssl::x509::store#add_crl()","bundler::definition#add_current_platform()","openssl::pkcs7#add_data()","gem::server#add_date()","bundler::lockfilegenerator#add_dependencies()","gem::specification#add_dependency()","gem::specification#add_dependency_with_type()","gem::specification#add_development_dependency()","zlib::inflate#add_dictionary()","bundler::molinillo::dependencygraph#add_edge()","gem::resolver::molinillo::dependencygraph#add_edge()","bundler::molinillo::dependencygraph#add_edge_no_circular()","bundler::molinillo::dependencygraph::log#add_edge_no_circular()","gem::resolver::molinillo::dependencygraph#add_edge_no_circular()","gem::resolver::molinillo::dependencygraph::log#add_edge_no_circular()","rexml::document#add_element()","rexml::element#add_element()","openssl::x509::name#add_entry()","rexml::validation::choice#add_event_to_arry()","rexml::validation::state#add_event_to_arry()","rdoc::context#add_extend()","openssl::x509::crl#add_extension()","openssl::x509::certificate#add_extension()","openssl::x509::revoked#add_extension()","gem::command#add_extra_args()","net::httpheader#add_field()","bundler::thor::actions#add_file()","gem::package::tarwriter#add_file()","openssl::x509::store#add_file()","rdoc::stats#add_file()","rdoc::store#add_file()","gem::package::tarwriter#add_file_digest()","gem::package::tarwriter#add_file_signed()","gem::package::tarwriter#add_file_simple()","tracer::add_filter()","rdoc::rdoc::add_generator()","bundler::plugin::sourcelist#add_git_source()","bundler::sourcelist#add_git_source()","bundler::dsl#add_git_sources()","webrick::httpservlet::filehandler::add_handler()","rss::element::add_have_children_element()","bundler::plugin#add_hook()","rdoc::markup#add_html()","rdoc::context#add_include()","rdoc::toplevel#add_include()","gem::installupdateoptions#add_install_update_options()","gem::gemcutterutilities#add_key_option()","bundler::thor::actions#add_link()","rexml::parsers::baseparser#add_listener()","rexml::parsers::lightparser#add_listener()","rexml::parsers::pullparser#add_listener()","rexml::parsers::sax2parser#add_listener()","rexml::parsers::streamparser#add_listener()","rexml::parsers::treeparser#add_listener()","rexml::parsers::ultralightparser#add_listener()","gem::resolver::installerset#add_local()","gem::localremoteoptions#add_local_remote_options()","bundler::lockfilegenerator#add_locked_ruby_version()","rss::maker::add_maker()","rdoc::context#add_method()","rdoc::stats#add_method()","rdoc::toplevel#add_method()","rdoc::context#add_module()","rdoc::stats#add_module()","rdoc::context#add_module_alias()","rdoc::context#add_module_by_normal_module()","rexml::element#add_namespace()","rss::element::add_need_initialize_variable()","rss::maker::base::add_need_initialize_variable()","openssl::ocsp::basicresponse#add_nonce()","openssl::ocsp::request#add_nonce()","observable#add_observer()","gem::command#add_option()","rss::maker::base::add_other_element()","gem::gemcutterutilities#add_otp_option()","gem::commands::ownercommand#add_owners()","gem::command#add_parser_run_info()","gem::commands::environmentcommand#add_path()","openssl::x509::store#add_path()","bundler::sourcelist#add_path_source()","bundler::definition#add_platform()","gem::platformmismatch#add_platform()","gem::versionoption#add_platform_option()","bundler::lockfilegenerator#add_platforms()","bundler::sourcelist#add_plugin_source()","rss::element::add_plural_form()","gem::versionoption#add_prerelease_option()","drb::drbprotocol#add_protocol()","drb::drbprotocol::add_protocol()","gem::localremoteoptions#add_proxy_option()","openssl::pkcs7#add_recipient()","rdoc::markup#add_regexp_handling()","bundler::source::rubygems#add_remote()","rdoc::context#add_require()","net::imap#add_response_handler()","openssl::x509::crl#add_revoked()","csv#add_row()","bundler::sourcelist#add_rubygems_remote()","bundler::plugin::sourcelist#add_rubygems_source()","bundler::sourcelist#add_rubygems_source()","racc::grammarfileparser#add_rule()","racc::grammarfileparser#add_rule_block()","gem::specification#add_runtime_dependency()","bundler::thor::actions::classmethods#add_runtime_options!()","bundler::lockfilegenerator#add_section()","rdoc::context#add_section()","gem::securityoption#add_security_option()","gem::specification#add_self_to_load_path()","openssl::pkcs7#add_signer()","bundler::index#add_source()","bundler::plugin#add_source()","gem::resolver::sourceset#add_source_gem()","gem::localremoteoptions#add_source_option()","bundler::sourcelist#add_source_to_list()","bundler::lockfilegenerator#add_sources()","gem::command::add_specific_extra_args()","bundler::lockfilegenerator#add_specs()","racc::grammar#add_start_rule()","openssl::ocsp::basicresponse#add_status()","gc::add_stress_to_class()","gem::package::tarwriter#add_symlink()","rexml::element#add_text()","rdoc::context#add_to()","rdoc::toplevel#add_to_classes_or_modules()","rss::element::add_to_element_method()","gem::testcase#add_to_fetcher()","bundler::thor::lineeditor::readline#add_to_history?()","bundler::rubygemsintegration#add_to_load_path()","gem::add_to_load_path()","rdoc::tokenstream#add_token()","rdoc::parser::rubytools#add_token_listener()","rdoc::tokenstream#add_tokens()","thread#add_trace_func()","csv::parser#add_unconverted_fields()","gem::localremoteoptions#add_update_sources_option()","racc::grammarfileparser#add_user_code()","openssl::config#add_value()","gem::versionoption#add_version_option()","bundler::molinillo::dependencygraph#add_vertex()","bundler::molinillo::dependencygraph::log#add_vertex()","gem::resolver::molinillo::dependencygraph#add_vertex()","gem::resolver::molinillo::dependencygraph::log#add_vertex()","rdoc::markup#add_word_pair()","racc::grammar#added?()","racc::statetransitiontablegenerator#addent()","bundler::definition#additional_base_requirements_for_resolve()","optionparser#additional_message()","ipsocket#addr()","openssl::ssl::socketforwarder#addr()","socket::ifaddr#addr()","unixsocket#addr()","ipaddr#addr_mask()","net::http#addr_port()","racc::states#addrel()","racc::states#addsym()","matrix#adjugate()","csv::parser#adjust_headers()","zlib::zstream#adler()","zlib::adler32()","zlib::adler32_combine()","io#advise()","addrinfo#afamily()","bundler::molinillo::ui#after_resolution()","bundler::resolver#after_resolution()","gem::resolver::molinillo::ui#after_resolution()","date#ajd()","gem::streamui#alert()","gem::userinteraction#alert()","gem::streamui#alert_error()","gem::userinteraction#alert_error()","gem::streamui#alert_warning()","gem::userinteraction#alert_warning()","psych::emitter#alias()","psych::handler#alias()","psych::treebuilder#alias()","psych::nodes::alias#alias?()","psych::nodes::node#alias?()","rdoc::parser::alias_extension()","module#alias_method()","encoding::aliases()","bundler::cli::aliases_for()","gem::validator#alien()","drb::drbserver#alive?()","drb::extserv#alive?()","drb::threadobject#alive?()","fiber#alive?()","rinda::tupleentry#alive?()","thread#alive?()","bundler::settings#all()","gem::specification::all()","net::popmail#all()","gem::specification::all=()","array#all?()","bundler::settings::mirrorconfig#all?()","enumerable#all?()","bundler::cli::all_aliases()","rdoc::store#all_classes()","rdoc::store#all_classes_and_modules()","bundler::thor::base::classmethods#all_commands()","bundler::parallelinstaller::specinstallation#all_dependencies()","bundler::bundlererror::all_errors()","rdoc::store#all_files()","rdoc::store#all_modules()","gem::specification::all_names()","bundler::molinillo::resolver::resolution::unwinddetails#all_requirements()","bundler::plugin::sourcelist#all_sources()","bundler::sourcelist#all_sources()","gem::testcase#all_spec_names()","bundler::rubygemsintegration#all_specs()","gem::availableset#all_specs()","symbol::all_symbols()","bundler::thor::base::classmethods#all_tasks()","integer#allbits?()","class#allocate()","objectspace::allocation_class_path()","objectspace::allocation_generation()","objectspace::allocation_method_id()","objectspace::allocation_sourcefile()","objectspace::allocation_sourceline()","bundler::source::git::gitproxy#allow?()","acl#allow_addr?()","bundler::source::git#allow_git_ops?()","bundler::thor::base::classmethods#allow_incompatible_default_type!()","bundler::molinillo::delegates::specificationprovider#allow_missing?()","bundler::molinillo::specificationprovider#allow_missing?()","gem::resolver#allow_missing?()","gem::resolver::molinillo::delegates::specificationprovider#allow_missing?()","gem::resolver::molinillo::specificationprovider#allow_missing?()","json::ext::generator::state#allow_nan?()","acl#allow_socket?()","bundler::settings#allow_sudo?()","bundler::source::git::gitproxy#allowed_in_path()","bundler::gemhelper#allowed_push_host()","random::formatter#alphanumeric()","openssl::ssl::sslsocket#alpn_protocol()","bundler::gemhelper#already_tagged?()","gem::security::alt_name_or_x509_entry()","rss::xmlstylesheet#alternate=()","date#amjd()","bundler::resolver#amount_constrained()","gem::resolver#amount_constrained()","bundler::molinillo::dependencygraph::vertex#ancestor?()","gem::resolver::molinillo::dependencygraph::vertex#ancestor?()","module#ancestors()","rdoc::classmodule#ancestors()","rdoc::normalclass#ancestors()","rdoc::singleclass#ancestors()","rdoc::store#ancestors()","complex#angle()","float#angle()","numeric#angle()","vector#angle_with()","bundler::thor::shell::basic#answer_match()","matrix#antisymmetric?()","array#any?()","bundler::mirrorsockets#any?()","enumerable#any?()","hash#any?()","racc::debugflags#any?()","rdoc::context#any_content()","drb::drbserver#any_to_s()","integer#anybits?()","bundler::fetcher::base#api_fetcher?()","bundler::fetcher::compactindex#api_fetcher?()","bundler::fetcher::dependency#api_fetcher?()","bundler::source::rubygems#api_fetchers()","gem::gemcutterutilities#api_key()","gem::configfile#api_keys()","net::apop#apop?()","net::apop#apop?()","net::pop3#apop?()","bundler::app_cache()","bundler::plugin::api::source#app_cache_dirname()","bundler::source::git#app_cache_dirname()","bundler::source::path#app_cache_dirname()","bundler::plugin::api::source#app_cache_path()","bundler::settings#app_cache_path()","bundler::source::path#app_cache_path()","bundler::app_config_path()","gem::installer#app_script_text()","array#append()","net::imap#append()","optionparser::list#append()","webrick::httputils::formdata#append_data()","module#append_features()","rss::atom::commonmodel::append_features()","rss::atom::contentmodel::append_features()","rss::atom::dateconstruct::append_features()","rss::atom::personconstruct::append_features()","rss::atom::textconstruct::append_features()","rss::atom::uricontentmodel::append_features()","rss::basedublincoremodel#append_features()","rss::contentmodel::append_features()","rss::ituneschannelmodel::append_features()","rss::itunesitemmodel::append_features()","rss::imagefaviconmodel::append_features()","rss::imageitemmodel::append_features()","rss::maker::atompersonconstructbase::append_features()","rss::maker::atomtextconstructbase::append_features()","rss::maker::contentmodel::append_features()","rss::maker::dublincoremodel::append_features()","rss::maker::ituneschannelmodel::append_features()","rss::maker::itunesitemmodel::append_features()","rss::maker::imagefaviconmodel::append_features()","rss::maker::imageitemmodel::append_features()","rss::maker::slashmodel::append_features()","rss::maker::syndicationmodel::append_features()","rss::maker::taxonomytopicmodel::append_features()","rss::maker::taxonomytopicsmodel::append_features()","rss::maker::trackbackmodel::append_features()","rss::rss09::append_features()","rss::rss10::append_features()","rss::slashmodel::append_features()","rss::syndicationmodel::append_features()","rss::taxonomytopicmodel::append_features()","rss::taxonomytopicsmodel::append_features()","singleton::append_features()","net::httpheader#append_field_value()","bundler::thor::actions#append_file()","bundler::env::append_formatted_table()","bundler::injector#append_to()","bundler::thor::actions#append_to_file()","net::ftp::mlsxentry#appendable?()","bundler::thor::actions#apply()","bundler::source::rubygems::remote#apply_auth()","bundler::worker#apply_func()","time::apply_offset()","gem::version#approximate_recommendation()","bundler::thor::shell::color#are_colors_disabled?()","rdoc::alias#aref()","rdoc::classmodule#aref()","rdoc::methodattr#aref()","rdoc::anymethod#aref_prefix()","rdoc::attr#aref_prefix()","rdoc::methodattr#aref_prefix()","complex#arg()","float#arg()","numeric#arg()","rdoc::anymethod#arglists()","gem::commands::querycommand#args()","nomethoderror#args()","bundler::thor::base::classmethods#argument()","bundler::thor::base::classmethods#arguments()","gem::command#arguments()","argf#argv()","process::argv0()","method#arity()","proc#arity()","unboundmethod#arity()","win32ole_variant::array()","gem::specification::array_attributes()","json::ext::generator::state#array_nl()","json::ext::generator::state#array_nl=()","bundler::settings#array_to_s()","bigdecimal#as_json()","complex#as_json()","date#as_json()","datetime#as_json()","exception#as_json()","json::genericobject#as_json()","openstruct#as_json()","range#as_json()","rational#as_json()","regexp#as_json()","set#as_json()","struct#as_json()","symbol#as_json()","time#as_json()","bundler::source::gemspec#as_path_source()","bundler::thor::shell::basic#as_unicode()","pathname#ascend()","encoding#ascii_compatible?()","json::ext::generator::state#ascii_only?()","string#ascii_only?()","encoding::converter::asciicompat_encoding()","date#asctime()","time#asctime()","math::asin()","math::asinh()","bundler::thor::shell::basic#ask()","bundler::thor::shell::html#ask()","bundler::ui::shell#ask()","bundler::ui::silent#ask()","gem::mockgemui#ask()","gem::streamui#ask()","gem::userinteraction#ask()","bundler::cli::gem#ask_and_set()","bundler::cli::gem#ask_and_set_test_framework()","bundler::thor::shell::basic#ask_filtered()","gem::streamui#ask_for_password()","gem::userinteraction#ask_for_password()","bundler::cli::common::ask_for_spec_from()","gem::testcase#ask_if_ok()","bundler::thor::shell::basic#ask_simply()","gem::streamui#ask_yes_no()","gem::userinteraction#ask_yes_no()","openssl::pkey::ec::group#asn1_flag()","openssl::pkey::ec::group#asn1_flag=()","gem::testcase#assert_activate()","gem::testcase#assert_contains_make_command()","gem::testcase#assert_directory_exists()","gem::package::tartestcase#assert_headers_equal()","gem::testcase#assert_path_exists()","rdoc::servlet#asset()","fiddle::cstructentity#assign_names()","irb::irb#assignment_expression?()","array#assoc()","env::assoc()","hash#assoc()","array#at()","bundler::rubygemsgeminstaller::at()","gem::installer::at()","time::at()","kernel#at_exit()","bigmath#atan()","math::atan()","math::atan2()","math::atanh()","file#atime()","file::atime()","file::stat#atime()","pathname#atime()","racc::grammarfilescanner#atom_symbol()","rss::atom::dateconstruct#atom_validate()","rss::atom::entry#atom_validate()","rss::atom::feed#atom_validate()","rss::atom::feed::entry#atom_validate()","rss::atom::feed::entry::content#atom_validate()","rss::atom::textconstruct#atom_validate()","bundler::retry#attempt()","bundler::molinillo::resolver::resolution#attempt_to_activate()","gem::resolver::molinillo::resolver::resolution#attempt_to_activate()","gem::resolver::molinillo::resolver::resolution#attempt_to_activate_existing_spec()","gem::resolver::molinillo::resolver::resolution#attempt_to_activate_new_spec()","bundler::molinillo::resolver::resolution#attempt_to_filter_existing_spec()","gem::resolver::molinillo::resolver::resolution#attempt_to_swap_possibility()","bundler::retry::attempts()","bundler::retry#attempts()","rexml::sax2listener#attlistdecl()","rexml::streamlistener#attlistdecl()","rexml::parsers::pullevent#attlistdecl?()","module#attr()","module#attr_accessor()","module#attr_reader()","module#attr_writer()","rexml::element#attribute()","rexml::quickpath::attribute()","gem::specification::attribute_names()","rexml::doctype#attribute_of()","bundler::uri::ldap#attributes()","openssl::x509::request#attributes()","rdoc::store#attributes()","uri::ldap#attributes()","bundler::uri::ldap#attributes=()","openssl::x509::request#attributes=()","uri::ldap#attributes=()","rexml::doctype#attributes_of()","net::smtp#auth_capable?()","net::smtp#auth_cram_md5()","openssl::cipher#auth_data=()","net::smtp#auth_login()","net::smtp#auth_method()","net::pop3::auth_only()","net::pop3#auth_only()","net::smtp#auth_plain()","openssl::cipher#auth_tag()","openssl::cipher#auth_tag=()","openssl::cipher#auth_tag_len=()","net::imap#authenticate()","net::smtp#authenticate()","webrick::httpauth::basicauth#authenticate()","webrick::httpauth::digestauth#authenticate()","openssl::cipher#authenticated?()","gem::specification#author()","gem::specification#author=()","gem::specification#authors()","gem::specification#authors=()","irb::reidlineinputmethod#auto_indent()","reline::core#auto_indent_proc=()","bundler::cli#auto_install()","io#autoclose=()","io#autoclose?()","kernel#autoload()","module#autoload()","kernel#autoload?()","module#autoload?()","zlib::zstream#avail_in()","zlib::zstream#avail_out()","zlib::zstream#avail_out=()","bundler::connectionpool#available()","bundler::fetcher::base#available?()","bundler::fetcher::compactindex#available?()","bundler::fetcher::dependency#available?()","bundler::thor::lineeditor::basic::available?()","bundler::thor::lineeditor::readline::available?()","gem::specfetcher#available_specs()","rss::baselistener::available_tags()","rexml::quickpath::axe()","string#b()","bundler::rubygemsintegration#backport_base_dir()","bundler::rubygemsintegration#backport_cache_file()","bundler::rubygemsintegration#backport_ext_builder_monitor()","bundler::rubygemsintegration#backport_spec_file()","exception#backtrace()","gem::configfile#backtrace()","gem::streamui#backtrace()","thread#backtrace()","exception#backtrace_locations()","thread#backtrace_locations()","gem::resolver::stats#backtracking!()","bundler::environmentpreserver#backup()","bundler::thor::banner()","bundler::thor::group::banner()","optionparser#banner()","bundler::cli::config#base()","cgi::htmlextension#base()","optionparser#base()","random::formatter#base64()","net::smtp#base64_encode()","gem::s3urisigner#base64_uri_escape()","digest::class::base64digest()","digest::instance#base64digest()","bundler::rubygemsgeminstaller#base64digest!()","digest::instance#base64digest!()","gem::basicspecification#base_dir()","gem::specification#base_dir()","rubyvm::instructionsequence#base_label()","thread::backtrace::location#base_label()","bundler::source::git#base_name()","rdoc::toplevel#base_name()","bundler::thor::lineeditor::readline::pathcompletion#base_path()","bundler::thor::base::classmethods#basename()","file::basename()","pathname#basename()","openssl::ocsp::response#basic()","net::httpheader#basic_auth()","webrick::httpauth#basic_auth()","net::httpheader#basic_encode()","readline::basic_quote_characters()","readline::basic_quote_characters=()","reline::core#basic_quote_characters=()","readline::basic_word_break_characters()","readline::basic_word_break_characters=()","reline::core#basic_word_break_characters=()","vector::basis()","io#beep()","racc::locationpointer#before()","bundler::molinillo::ui#before_resolution()","bundler::resolver#before_resolution()","gem::resolver::molinillo::ui#before_resolution()","rdoc::task#before_running_rdoc()","rdoc::task#before_running_rdoc()","enumerator::arithmeticsequence#begin()","matchdata#begin()","range#begin()","rdoc::stats#begin_adding()","net::http#begin_transport()","stringscanner#beginning_of_line?()","gem::command#begins?()","benchmark#benchmark()","benchmark::benchmark()","bundler::thor::lineeditor::best_available()","comparable#between?()","gem::specification#bin_dir()","gem::specification#bin_file()","gem::commands::setupcommand#bin_file_names()","rinda::tuplebag#bin_for_find()","rinda::tuplebag#bin_key()","bundler::bin_path()","bundler::rubygemsintegration#bin_path()","gem::bin_path()","net::ftp#binary=()","psych::visitors::yamltree#binary?()","rdoc::parser::binary?()","gem::binary_mode()","addrinfo#bind()","fiddle::importer#bind()","socket#bind()","udpsocket#bind()","unboundmethod#bind()","unboundmethod#bind_call()","fiddle::importer#bind_function()","kernel#binding()","proc#binding()","tracepoint#binding()","bundler::molinillo::resolver::resolution#binding_requirement_in_set?()","bundler::molinillo::resolver::resolution#binding_requirements_for_conflict()","bundler::endpointspecification#bindir()","gem::bindir()","gem::testcase#bindir()","argf#binmode()","io#binmode()","stringio#binmode()","argf#binmode?()","csv#binmode?()","io#binmode?()","io::binread()","pathname#binread()","bundler::cli#binstubs()","io::binwrite()","pathname#binwrite()","file#birthtime()","file::birthtime()","file::stat#birthtime()","pathname#birthtime()","integer#bit_length()","openssl::bn#bit_set?()","openssl::pkey::rsa#blinding_off!()","openssl::pkey::rsa#blinding_on!()","file::stat#blksize()","kernel#block_given?()","digest::base#block_length()","digest::instance#block_length()","openssl::digest#block_length()","rdoc::methodattr#block_params=()","openssl::cipher#block_size()","file::blockdev?()","file::stat#blockdev?()","filetest#blockdev?()","pathname#blockdev?()","cgi::htmlextension#blockquote()","file::stat#blocks()","benchmark#bm()","benchmark::bm()","benchmark::bmbm()","benchmark#bmbm()","net::httpresponse#body()","webrick::httprequest#body()","net::httpgenericrequest#body=()","net::httpresponse#body=()","net::httpgenericrequest#body_exist?()","net::httpresponse::body_permitted?()","webrick::httprequest#body_reader()","net::httpgenericrequest#body_stream=()","socket::option::bool()","socket::option#bool()","racc::parserfilegenerator::params::bool_attr()","rexml::functions::boolean()","rss::parser::boolean_argument()","rss::basemodel#boolean_writer()","gem::localremoteoptions#both?()","irb::frame#bottom()","irb::frame::bottom()","bundler::source::git::gitproxy#branch()","rdoc::markdown#break_on_newline()","prettyprint#break_outmost_groups()","debugger__::break_points()","prettyprint#breakable()","prettyprint::singleline#breakable()","socket::ifaddr#broadaddr()","conditionvariable#broadcast()","monitormixin::conditionvariable#broadcast()","array#bsearch()","range#bsearch()","array#bsearch_index()","digest::bubblebabble()","digest::class::bubblebabble()","digest::instance#bubblebabble()","json::ext::generator::state#buffer_initial_length()","json::ext::generator::state#buffer_initial_length=()","bundler::definition::build()","bundler::index::build()","bundler::rubygemsintegration#build()","bundler::uri::ftp::build()","bundler::uri::file::build()","bundler::uri::generic::build()","bundler::uri::http::build()","bundler::uri::ldap::build()","bundler::uri::mailto::build()","gem::commands::certcommand#build()","gem::ext::cmakebuilder::build()","gem::ext::configurebuilder::build()","gem::ext::extconfbuilder::build()","gem::ext::rakebuilder::build()","gem::package::build()","gem::package#build()","gem::requestset::lockfile::build()","matrix::build()","rexml::document#build()","uri::ftp::build()","uri::file::build()","uri::generic::build()","uri::http::build()","uri::ldap::build()","uri::mailto::build()","bundler::uri::generic::build2()","uri::generic::build2()","bundler::rubygemsintegration#build_args()","gem::command::build_args()","gem::specification#build_args()","bundler::rubygemsintegration#build_args=()","gem::command::build_args=()","bundler::endpointspecification#build_dependency()","bundler::molinillo::resolver::resolution#build_details_for_unwind()","matrix::eigenvaluedecomposition#build_eigenvectors()","psych::visitors::toruby#build_exception()","bundler::rubygemsgeminstaller#build_extensions()","gem::ext::builder#build_extensions()","gem::installer#build_extensions()","csv#build_fields_converter()","bundler::gemhelper#build_gem()","bundler::rubygemsintegration#build_gem()","gem::commands::buildcommand#build_gem()","bundler::injector#build_gem_lines()","csv#build_header_fields_converter()","rdoc::tomdoc#build_heading()","gem::indexer#build_indices()","gem::specification#build_info_dir()","gem::specification#build_info_file()","gem::indexer#build_marshal_gemspecs()","gem::missingspecerror#build_message()","gem::missingspecversionerror#build_message()","gem::indexer#build_modern_index()","gem::indexer#build_modern_indices()","gem::commands::buildcommand#build_package()","rdoc::tomdoc#build_paragraph()","csv#build_parser_fields_converter()","bundler::uri::ldap#build_path_query()","uri::ldap#build_path_query()","gem::testcase#build_rake_in()","csv::parser#build_scanner()","rdoc::tomdoc#build_verbatim()","csv#build_writer_fields_converter()","bundler::buildmetadata::built_at()","bundler::gemhelper#built_gem_path()","openssl::pkey::ec::builtin_curves()","bundler::source::rubygems#builtin_gem?()","gem::version#bump()","bundler::bundle_path()","gem::bundlerversionfinder::bundle_update_bundler_version()","bundler::fetcher::compactindex#bundle_worker()","bundler::fetcher#bundler_cert_store()","bundler::cli::gem#bundler_dependency_version()","bundler::bundler_major_version()","bundler::standalone#bundler_path()","bundler::plugin::api::source#bundler_plugin_api_source?()","bundler::sharedhelpers#bundler_ruby_lib()","gem::bundlerversionfinder::bundler_version()","gem::bundlerversionfinder::bundler_version_with_reason()","bundler::cli::doctor#bundles_for_gem()","csv::table#by_col()","csv::table#by_col!()","csv::table#by_col_or_row()","csv::table#by_col_or_row!()","openssl::engine::by_id()","csv::table#by_row()","csv::table#by_row!()","socket::option#byte()","socket::option::byte()","argf#bytes()","io#bytes()","rexml::child#bytes()","random::bytes()","random#bytes()","securerandom::bytes()","string#bytes()","stringio#bytes()","zlib::gzipreader#bytes()","gem::package::tarreader::entry#bytes_read()","string#bytesize()","string#byteslice()","bundler::persistent::net::http::persistent#ca_file=()","bundler::persistent::net::http::persistent#ca_path=()","bundler::cli#cache()","bundler::plugin#cache()","bundler::plugin::api::source#cache()","bundler::runtime#cache()","bundler::source::git#cache()","bundler::source::path#cache()","bundler::source::rubygems#cache()","bundler::plugin::api#cache_dir()","gem::source#cache_dir()","gem::specification#cache_dir()","gem::specification#cache_file()","bundler::source::rubygems#cache_globally()","bundler::fetcher::compactindex#cache_path()","bundler::plugin::installer::git#cache_path()","bundler::plugin::installer::rubygems#cache_path()","bundler::source::git#cache_path()","bundler::source::rubygems#cache_path()","rdoc::store#cache_path()","bundler::source::rubygems::remote#cache_slug()","gem::fakefetcher#cache_update_path()","gem::remotefetcher#cache_update_path()","bundler::plugin::api::source#cached!()","bundler::source::metadata#cached!()","bundler::source::path#cached!()","bundler::source::rubygems#cached!()","bundler::sourcelist#cached!()","bundler::source::git#cached?()","bundler::source::rubygems#cached_built_in_gem()","bundler::source::rubygems#cached_gem()","bundler::source::rubygems#cached_path()","bundler::source::git#cached_revision()","bundler::source::git#cached_revision_checked_out?()","bundler::source::rubygems#cached_specs()","gdbm#cachesize=()","gem::package::tartestcase#calc_checksum()","rss::element#calc_indent()","rdoc::stats#calculate()","gem::package::tarheader#calculate_checksum()","bundler::parallelinstaller#call()","bundler::parallelinstaller::call()","continuation#call()","fiddle::closure::blockcaller#call()","fiddle::function#call()","method#call()","proc#call()","syslog::logger::formatter#call()","rdoc::anymethod#call_seq=()","kernel#callcc()","tracepoint#callee_id()","kernel#caller()","kernel#caller_locations()","bundler::thor::util::camel_case()","bundler::thor::shell::basic#can_display_colors?()","bundler::thor::shell::color#can_display_colors?()","bundler::thor::shell::html#can_display_colors?()","bundler::installer#can_install_in_parallel?()","bundler::plugin::api::source#can_lock?()","bundler::source#can_lock?()","bundler::source::rubygems#can_lock?()","rdoc::parser::can_parse()","rdoc::parser::can_parse_by_name()","bundler::persistent::net::http::persistent#can_retry?()","rinda::tupleentry#cancel()","rinda::waittemplateentry#cancel()","webrick::utils::timeouthandler::cancel()","rinda::tupleentry#canceled?()","optionparser#candidate()","optionparser::completion#candidate()","optionparser::completion::candidate()","psych::emitter#canonical()","psych::emitter#canonical=()","net::httpheader#canonical_each()","racc::grammarfileparser#canonical_label()","gem::version#canonical_segments()","addrinfo#canonname()","net::smtp::response#capabilities()","net::imap#capability()","net::smtp#capable?()","net::smtp#capable_auth_types()","net::smtp#capable_cram_md5_auth?()","net::smtp#capable_login_auth?()","net::smtp#capable_plain_auth?()","net::smtp#capable_starttls?()","net::httpheader#capitalize()","string#capitalize()","symbol#capitalize()","string#capitalize!()","cgi::htmlextension#caption()","bundler::thor::actions#capture()","open3#capture2()","open3::capture2()","open3#capture2e()","open3::capture2e()","open3#capture3()","open3::capture3()","bundler::source::git::gitproxy#capture_and_filter_stderr()","bundler::source::git::gitproxy#capture_and_ignore_stderr()","matchdata#captures()","stringscanner#captures()","string#casecmp()","symbol#casecmp()","string#casecmp?()","symbol#casecmp?()","regexp#casefold?()","kernel#catch()","timeout::error::catch()","timeout::error::catch()","timeout::error::catch()","exception#cause()","math::cbrt()","makemakefile#cc_command()","bundler::fileutils#cd()","bundler::fileutils::cd()","fileutils::cd()","fileutils#cd()","rexml::sax2listener#cdata()","rexml::streamlistener#cdata()","rexml::parsers::pullevent#cdata?()","rexml::element#cdatas()","matrix::eigenvaluedecomposition#cdiv()","bigdecimal#ceil()","float#ceil()","integer#ceil()","numeric#ceil()","rational#ceil()","time#ceil()","rexml::functions::ceiling()","string#center()","openssl::ssl::sslsocket#cert()","bundler::persistent::net::http::persistent#cert=()","gem::request#cert_files()","gem::security::trustdir#cert_path()","openssl::ocsp::singleresponse#cert_status()","bundler::persistent::net::http::persistent#cert_store=()","openssl::ocsp::request#certid()","openssl::ocsp::singleresponse#certid()","bundler::persistent::net::http::persistent#certificate=()","openssl::pkcs7#certificates()","openssl::pkcs7#certificates=()","gem::commands::certcommand#certificates_matching()","net::pop3::certs()","enumerable#chain()","openssl::x509::storecontext#chain()","openssl::netscape::spki#challenge()","webrick::httpauth::basicauth#challenge()","webrick::httpauth::digestauth#challenge()","openssl::netscape::spki#challenge=()","rdoc::encoding::change_encoding()","process::gid::change_privilege()","process::uid::change_privilege()","bundler::definition#change_reason()","irb::context#change_workspace()","observable#changed()","observable#changed?()","rss::rexmllikexmlparser#character()","rexml::sax2listener#characters()","file::chardev?()","file::stat#chardev?()","filetest#chardev?()","pathname#chardev?()","stringscanner#charpos()","argf#chars()","io#chars()","string#chars()","stringio#chars()","openuri::meta#charset()","bundler::fileutils#chdir()","bundler::fileutils::chdir()","bundler::sharedhelpers#chdir()","dir::chdir()","fileutils::chdir()","fileutils#chdir()","net::ftp#chdir()","bundler::cli#check()","net::imap#check()","pty::check()","rexml::text::check()","stringscanner#check()","bundler::cli::doctor#check!()","net::smtp#check_auth_args()","net::smtp#check_auth_continue()","net::smtp#check_auth_method()","net::smtp#check_auth_response()","gem::security::policy#check_cert()","gem::security::policy#check_chain()","json::ext::generator::state#check_circular?()","gem::package::tarwriter#check_closed()","net::smtp#check_continue()","gem::configfile#check_credentials_permissions()","gem::security::policy#check_data()","bundler::thor::base::classmethods#check_default_type!()","gem::command#check_deprecated_options()","bundler::rubygemsgeminstaller#check_executable_overwrite()","rdoc::options#check_files()","bundler::runtime#check_for_activated_spec!()","bundler::parallelinstaller#check_for_corrupt_lockfile()","bundler::cli::outdated#check_for_deployment_mode!()","bundler::cli::install#check_for_group_conflicts_in_cli_options()","bundler::cli::install#check_for_options_conflicts()","gem::commands::checkcommand#check_gems()","rdoc::options#check_generator()","webrick::httpresponse#check_header()","bundler::uri::mailto#check_headers()","uri::mailto#check_headers()","bundler::cli::doctor#check_home_permissions()","bundler::uri::generic#check_host()","uri::generic#check_host()","drb::drbserver#check_insecure_method()","pp::ppmethods#check_inspect_key()","gem::commands::querycommand#check_installed_gems()","gem::commands::querycommand#check_installed_gems?()","matrix#check_int()","gem::security::policy#check_key()","openssl::pkey::ec#check_key()","racc::state#check_la()","rdoc::parser::check_modeline()","openssl::config#check_modify()","rdoc::task#check_names()","rdoc::task#check_names()","openssl::ocsp::request#check_nonce()","rss::listenermixin#check_ns()","bundler::uri::generic#check_opaque()","uri::generic#check_opaque()","bundler::uri::file#check_password()","bundler::uri::generic#check_password()","uri::file#check_password()","uri::generic#check_password()","bundler::uri::generic#check_path()","uri::generic#check_path()","bundler::uri::generic#check_port()","uri::generic#check_port()","bundler::dsl#check_primary_source_safety()","openssl::x509::certificate#check_private_key()","matrix#check_range()","net::smtp#check_response()","gem::security::policy#check_root()","gem::commands::setupcommand#check_ruby_version()","racc::grammar#check_rules_nullable()","racc::grammar#check_rules_useless()","bundler::uri::generic#check_scheme()","uri::generic#check_scheme()","makemakefile#check_signedness()","makemakefile#check_sizeof()","bundler::plugin::installer#check_sources_consistency!()","racc::grammar#check_symbols_nullable()","racc::grammar#check_symbols_useless()","racc::symboltable#check_terminals()","irb::reidlineinputmethod#check_termination()","bundler::uri::mailto#check_to()","uri::mailto#check_to()","gem::security::policy#check_trust()","bundler::cli::install#check_trust_policy()","bundler::uri::ftp#check_typecode()","uri::ftp#check_typecode()","gem::commands::sourcescommand#check_typo_squatting()","bundler::thor::check_unknown_options!()","bundler::thor::base::classmethods#check_unknown_options!()","stringscanner#check_until()","racc::states#check_useless()","bundler::uri::file#check_user()","bundler::uri::generic#check_user()","uri::file#check_user()","uri::generic#check_user()","bundler::uri::file#check_userinfo()","bundler::uri::generic#check_userinfo()","uri::file#check_userinfo()","uri::generic#check_userinfo()","openssl::ocsp::singleresponse#check_validity()","io#check_winsize_changed()","cgi::htmlextension#checkbox()","cgi::htmlextension#checkbox_group()","bundler::connectionpool#checkin()","bundler::connectionpool#checkout()","bundler::source::git::gitproxy#checkout()","bundler::compactindexclient::updater#checksum_for_file()","bundler::rubygemsgeminstaller#checksum_type()","bundler::compactindexclient::cache#checksums()","rexml::xpathparser#child()","rdoc::context#child_name()","dir::children()","dir#children()","pathname#children()","rexml::light::node#children()","rexml::parent#children()","rss::element#children()","rubyvm::abstractsyntaxtree::node#children()","bundler::fileutils::chmod()","bundler::fileutils#chmod()","bundler::thor::actions#chmod()","file::chmod()","file#chmod()","fileutils::chmod()","fileutils#chmod()","pathname#chmod()","bundler::fileutils#chmod_r()","bundler::fileutils::chmod_r()","fileutils#chmod_r()","fileutils::chmod_r()","kernel#chomp()","string#chomp()","string#chomp!()","random::formatter#choose()","gem::streamui#choose_from_list()","gem::userinteraction#choose_from_list()","kernel#chop()","string#chop()","string#chop!()","bundler::fileutils::chown()","bundler::fileutils#chown()","file::chown()","file#chown()","fileutils::chown()","fileutils#chown()","pathname#chown()","bundler::fileutils#chown_r()","bundler::fileutils::chown_r()","fileutils::chown_r()","fileutils#chown_r()","integer#chr()","string#chr()","dir::chroot()","bundler::env::chruby_version()","enumerable#chunk()","enumerator::lazy#chunk()","enumerable#chunk_while()","enumerator::lazy#chunk_while()","webrick::httpresponse#chunked=()","net::httpheader#chunked?()","webrick::httpresponse#chunked?()","openssl::engine#cipher()","openssl::ssl::sslsocket#cipher()","openssl::pkcs7#cipher=()","openssl::cipher::ciphers()","openssl::ssl::sslcontext#ciphers()","bundler::persistent::net::http::persistent#ciphers=()","openssl::ssl::sslcontext#ciphers=()","bundler::fetcher#cis()","date::civil()","datetime::civil()","comparable#clamp()","object#class()","rdoc::context#class_attributes()","module#class_eval()","module#class_exec()","rdoc::store#class_file()","rdoc::context#class_method_list()","rdoc::store#class_methods()","gem::ext::builder::class_name()","rss::baselistener::class_name()","bundler::thor::base::classmethods#class_option()","bundler::thor::base::classmethods#class_options()","rdoc::store#class_path()","module#class_variable_defined?()","module#class_variable_get()","module#class_variable_set()","module#class_variables()","rdoc::context#classes()","rdoc::context#classes_and_modules()","rdoc::context#classes_hash()","rdoc::store#classes_hash()","set#classify()","bundler::cli#clean()","bundler::runtime#clean()","syslog::logger::formatter#clean()","bundler::gemhelper#clean?()","bundler::cli::common::clean_after_install?()","bundler::clean_env()","bundler::clean_exec()","gem::commands::cleanupcommand#clean_gems()","bundler::sharedhelpers#clean_load_path()","bundler::clean_system()","gem::text#clean_text()","pathname#cleanpath()","openssl::engine::cleanup()","openssl::x509::storecontext#cleanup()","array#clear()","bundler::thor::coreext::orderedhash#clear()","dbm#clear()","env::clear()","gc::profiler::clear()","gdbm#clear()","gem::dependencylist#clear()","gem::sourcelist#clear()","hash#clear()","irb::color::clear()","queue#clear()","racc::iset#clear()","sdbm#clear()","set#clear()","sizedqueue#clear()","string#clear()","stringscanner#clear()","openssl::bn#clear_bit!()","rexml::text#clear_cache()","rdoc::classmodule#clear_comment()","openssl::config::clear_comments()","gem::clear_default_specs()","bundler::clear_gemspec_cache()","bundler::rubygemsintegration#clear_paths()","gem::clear_paths()","io#clear_screen()","bundler::cli#cli_help()","openssl::ssl::sslsocket#client_ca()","openssl::ssl::sslsocket#client_cert_cb()","webrick::httpstatus#client_error?()","webrick::httpstatus::client_error?()","bundler::fetcher::compactindex#client_fetcher()","rdoc::task#clobber_task_description()","rdoc::task#clobber_task_description()","rdoc::task#clobber_task_name()","rdoc::task#clobber_task_name()","process::clock_getres()","process::clock_gettime()","bigdecimal#clone()","method#clone()","numeric#clone()","object#clone()","rexml::attribute#clone()","rexml::cdata#clone()","rexml::comment#clone()","rexml::doctype#clone()","rexml::document#clone()","rexml::element#clone()","rexml::instruction#clone()","rexml::text#clone()","rexml::xmldecl#clone()","singleton#clone()","unboundmethod#clone()","argf#close()","cgi::session#close()","cgi::session::filestore#close()","cgi::session::memorystore#close()","cgi::session::nullstore#close()","cgi::session::pstore#close()","dbm#close()","dir#close()","fiddle::handle#close()","gdbm#close()","gem::package::tarreader#close()","gem::package::tarreader::entry#close()","gem::package::tarwriter#close()","gem::silentui#close()","gem::streamui#close()","io#close()","logger#close()","net::ftp#close()","net::imap#close()","openssl::buffering#close()","openssl::ssl::sslserver#close()","queue#close()","resolv::dns#close()","sdbm#close()","sockssocket#close()","sizedqueue#close()","stringio#close()","syslog::close()","tempfile#close()","webrick::basiclog#close()","zlib::gzipfile#close()","zlib::zstream#close()","tempfile#close!()","gem::remotefetcher#close_all()","fiddle::handle#close_enabled?()","io#close_on_exec=()","io#close_on_exec?()","basicsocket#close_read()","io#close_read()","stringio#close_read()","basicsocket#close_write()","io#close_write()","stringio#close_write()","argf#closed?()","dbm#closed?()","gdbm#closed?()","gem::package::tarreader::entry#closed?()","gem::package::tarwriter#closed?()","io#closed?()","net::ftp#closed?()","openssl::ssl::socketforwarder#closed?()","queue#closed?()","sdbm#closed?()","stringio#closed?()","zlib::gzipfile#closed?()","zlib::zstream#closed?()","stringio#closed_read?()","stringio#closed_write?()","openssl::engine#cmds()","bundler::fileutils::cmp()","bundler::fileutils#cmp()","fileutils#cmp()","fileutils::cmp()","openssl::bn#cmp()","openssl::ocsp::certificateid#cmp()","openssl::x509::name#cmp()","openssl::ocsp::certificateid#cmp_issuer()","socket::ancillarydata#cmsg_is?()","webrick::httpstatus::status#code()","irb::workspace#code_around_binding()","win32ole::codepage()","win32ole::codepage=()","argf#codepoints()","io#codepoints()","string#codepoints()","stringio#codepoints()","bigdecimal#coerce()","bundler::uri::generic#coerce()","float#coerce()","integer#coerce()","matrix#coerce()","numeric#coerce()","openssl::bn#coerce()","uri::generic#coerce()","vector#coerce()","ipaddr#coerce_other()","matrix#cofactor()","openssl::pkey::ec::group#cofactor()","matrix#cofactor_expansion()","csv#col_sep()","array#collect()","enumerable#collect()","enumerator::lazy#collect()","matrix#collect()","rexml::elements#collect()","vector#collect()","array#collect!()","matrix#collect!()","set#collect!()","vector#collect!()","vector#collect2()","rss::listenermixin#collect_attributes()","rss::element#collect_attrs()","enumerable#collect_concat()","enumerator::lazy#collect_concat()","rdoc::parser::ruby#collect_first_comment()","bundler::fileutils::collect_method()","fileutils::collect_method()","rdoc::tokenstream#collect_tokens()","irb::color::colorable?()","irb::color::colorize()","irb::color::colorize_code()","matrix#column()","ripper#column()","ripper::filter#column()","csv::parser#column_separator()","matrix::column_vector()","matrix#column_vectors()","matrix::columns()","array#combination()","matrix#combine()","matrix::combine()","bundler::sourcelist#combine_rubygems_sources()","pp::ppmethods#comma_breakable()","bundler::plugin::api::command()","drb::extservmanager::command()","drb::extservmanager::command=()","bundler::plugin#command?()","bundler::thor::command_help()","gem::commandmanager#command_names()","bundler::plugin::index#command_plugin()","bundler::fileutils::commands()","bundler::thor::base::classmethods#commands()","fileutils::commands()","rexml::sax2listener#comment()","rexml::streamlistener#comment()","zlib::gzipfile#comment()","rdoc::codeobject#comment=()","zlib::gzipwriter#comment=()","rexml::parsers::pullevent#comment?()","bundler::thor::actions#comment_lines()","rexml::element#comments()","date::commercial()","datetime::commercial()","pstore#commit()","bundler::gemhelper#committed?()","gem::testcase#common_installer_setup()","gem::testcase#common_installer_teardown()","gem::command::common_options()","array#compact()","fiddle::cparser#compact()","gc::compact()","hash#compact()","array#compact!()","hash#compact!()","bundler::fetcher::compactindex#compact_index_client()","bundler::fetcher::compactindex::compact_index_request()","gem::indexer#compact_specs()","rexml::xpathparser#compare()","hash#compare_by_identity()","set#compare_by_identity()","hash#compare_by_identity?()","set#compare_by_identity?()","bundler::fileutils#compare_file()","bundler::fileutils::compare_file()","fileutils#compare_file()","fileutils::compare_file()","rexml::functions::compare_language()","bundler::fileutils#compare_stream()","bundler::fileutils::compare_stream()","fileutils#compare_stream()","fileutils::compare_stream()","encoding::compatible?()","gem::bundlerversionfinder::compatible?()","regexp::compile()","rubyvm::instructionsequence::compile()","ripper#compile_error()","rubyvm::instructionsequence::compile_file()","rubyvm::instructionsequence::compile_option()","rubyvm::instructionsequence::compile_option=()","gem::commands::lockcommand#complain()","optionparser#complete()","optionparser::completion#complete()","optionparser::list#complete()","rdoc::classmodule#complete()","rdoc::store#complete()","readline::completer_quote_characters()","readline::completer_quote_characters=()","reline::core#completer_quote_characters=()","readline::completer_word_break_characters()","readline::completer_word_break_characters=()","reline::core#completer_word_break_characters=()","readline::completion_append_character()","readline::completion_append_character=()","reline::core#completion_append_character=()","readline::completion_case_fold()","reline::core#completion_case_fold()","readline::completion_case_fold=()","reline::core#completion_case_fold=()","bundler::thor::lineeditor::readline#completion_options()","bundler::thor::lineeditor::readline#completion_proc()","readline::completion_proc()","readline::completion_proc=()","reline::core#completion_proc=()","readline::completion_quote_character()","reline::core#completion_quote_character()","bundler::uri::generic::component()","bundler::uri::generic#component()","matrix#component()","uri::generic::component()","uri::generic#component()","vector#component()","bundler::uri::generic#component_ary()","uri::generic#component_ary()","gem::resolver::compose_sets()","gem::indexer#compress()","gem::indexer#compress_indices()","racc::states#compute_dfa()","racc::grammar#compute_expand()","racc::grammar#compute_hash()","racc::grammar#compute_heads()","openssl::pkey::dh#compute_key()","racc::grammar#compute_locate()","racc::states#compute_nfa()","racc::grammar#compute_nullable()","racc::grammar#compute_nullable_0()","prime::eratosthenessieve#compute_primes()","bundler::definition#compute_requires()","racc::grammar#compute_useless()","array#concat()","bundler::thor::actions#concat()","gem::requirement#concat()","rexml::functions::concat()","string#concat()","stringscanner#concat()","bundler::definition#concat_ruby_version_requirements()","irb::conf()","drb::config()","drb#config()","gem::config_file()","gem::configfile#config_file_name()","bundler::rubygemsintegration#configuration()","gem::configuration()","gem::configuration=()","bundler::configure()","json::ext::generator::state#configure()","gem::request::configure_connection_for_https()","bundler::configure_gem_home()","bundler::configure_gem_home_and_path()","bundler::configure_gem_path()","bundler::cli::common::configure_gem_version_promoter()","gem::command#configure_options()","bundler::configured_bundle_path()","bundler::source::git::gitproxy#configured_uri_for()","bundler::cli::config::base#confirm()","bundler::ui::shell#confirm()","bundler::ui::silent#confirm()","bundler::cli::config::base#confirm_all()","racc::state#conflict?()","bundler::molinillo::resolver::resolution#conflict_fixing_possibilities?()","gem::dependencyresolutionerror#conflicting_dependencies()","gem::resolver::conflict#conflicting_dependencies()","bundler::molinillo::delegates::resolutionstate#conflicts()","gem::resolver::molinillo::delegates::resolutionstate#conflicts()","gem::specification#conflicts()","etc::confstr()","makemakefile#conftest_source()","complex#conj()","matrix#conj()","numeric#conj()","complex#conjugate()","matrix#conjugate()","numeric#conjugate()","addrinfo#connect()","drb::drbsslsocket::sslconfig#connect()","net::ftp#connect()","net::http#connect()","openssl::ssl::sslsocket#connect()","socket#connect()","udpsocket#connect()","win32ole::connect()","basicsocket#connect_address()","addrinfo#connect_from()","addrinfo#connect_internal()","openssl::ssl::sslsocket#connect_nonblock()","socket#connect_nonblock()","addrinfo#connect_to()","bundler::fetcher#connection()","net::httpheader#connection_close?()","bundler::persistent::net::http::persistent#connection_for()","bundler::persistenthttp#connection_for()","gem::request#connection_for()","net::httpheader#connection_keep_alive?()","bundler::connectionpool::timedstack#connection_stored?()","bundler::injector#conservative_version()","gem::dependencyinstaller#consider_local?()","gem::dependencyinstaller#consider_remote?()","bundler::cli#console()","io::console()","io#console_mode()","io#console_mode=()","module#const_defined?()","module#const_get()","bundler::sharedhelpers#const_get_safely()","win32ole::const_load()","module#const_missing()","module#const_set()","module#const_source_location()","module#constants()","module::constants()","rss::itunesitemmodel::itunesduration::construct()","rexml::iosource#consume()","rexml::source#consume()","openssl::buffering#consume_rbuff()","rexml::functions::contains()","bundler::source::git::gitproxy#contains?()","gem::basicspecification#contains_requirable_file?()","rexml::xmldecl#content()","rss::itunesitemmodel::itunesduration#content=()","rss::maker::itunesitemmodel::itunesdurationbase#content=()","openuri::meta#content_encoding()","rss::element#content_is_set?()","net::httpheader#content_length()","webrick::httprequest#content_length()","webrick::httpresponse#content_length()","net::httpheader#content_length=()","webrick::httpresponse#content_length=()","net::httpheader#content_range()","rss::element::content_setup()","net::httpheader#content_type()","openuri::meta#content_type()","rss::atom::contentmodel::classmethods#content_type()","webrick::httprequest#content_type()","webrick::httpresponse#content_type()","net::httpheader#content_type=()","webrick::httpresponse#content_type=()","rss::basemodel#content_writer()","bundler::dsl::dslerror#contents()","gem::package#contents()","gem::package::old#contents()","debugger__::context()","rexml::doctype#context()","rexml::parseexception#context()","rexml::functions::context=()","net::smtp::response#continue?()","rdoc::parser::changelog#continue_entry_body()","net::http#continue_timeout=()","optionparser::switch#conv_arg()","bundler::definition#converge_dependencies()","bundler::definition#converge_locals()","bundler::definition#converge_locked_specs()","bundler::definition#converge_path_source_to_gemspec_source()","bundler::definition#converge_path_sources_to_gemspec_sources()","bundler::definition#converge_paths()","bundler::definition#converge_rubygems_sources()","bundler::definition#converge_sources()","csv#convert()","csv::fieldsconverter#convert()","encoding::converter#convert()","optionparser::completion#convert()","rdoc::markup#convert()","rss::converter#convert()","rss::element#convert()","webrick::httpversion::convert()","rss::basemodel#convert_attr_reader()","csv#convert_fields()","bundler::yamlserializer#convert_to_backward_compatible_key()","bundler::uri::rfc2396_parser#convert_to_uri()","bundler::uri::rfc2396_parser#convert_to_uri()","uri::rfc2396_parser#convert_to_uri()","uri::rfc2396_parser#convert_to_uri()","bundler::settings#converted_value()","rss::element#converter=()","csv#converters()","makemakefile#convertible_int()","encoding::converter#convpath()","io#cooked()","io#cooked!()","bundler::fileutils::copy()","bundler::fileutils#copy()","fileutils#copy()","fileutils::copy()","net::http#copy()","net::imap#copy()","openssl::bn#copy()","bundler::fileutils::copy_entry()","bundler::fileutils#copy_entry()","fileutils#copy_entry()","fileutils::copy_entry()","bundler::fileutils#copy_file()","bundler::fileutils::copy_file()","bundler::thor::actions#copy_file()","fileutils::copy_file()","fileutils#copy_file()","net::imap#copy_internal()","openssl::ocsp::basicresponse#copy_nonce()","bundler::fileutils::copy_stream()","bundler::fileutils#copy_stream()","fileutils#copy_stream()","fileutils::copy_stream()","io::copy_stream()","bundler::source::git::gitproxy#copy_to()","gem::installer::fakepackage#copy_to()","gem::package#copy_to()","reline::core()","racc::states#core_to_state()","process::status#coredump?()","gem::version::correct?()","didyoumean::correct_error()","bundler::rubygemsintegration#correct_for_windows_path()","gem::util::correct_for_windows_path()","undefinedcommanderror::spellchecker#corrections()","unknownargumenterror::spellchecker#corrections()","bigmath#cos()","math::cos()","math::cosh()","array#count()","enumerable#count()","gc::count()","rexml::functions::count()","range#count()","string#count()","objectspace::count_imemo_objects()","objectspace::count_nodes()","objectspace::count_objects()","objectspace::count_objects_size()","observable#count_observers()","objectspace::count_symbols()","objectspace::count_tdata_objects()","vector#covector()","bundler::versionranges::reqr#cover?()","range#cover?()","rdoc::stats#coverage_level=()","bundler::fileutils#cp()","bundler::fileutils::cp()","fileutils#cp()","fileutils::cp()","bundler::fileutils#cp_lr()","bundler::fileutils::cp_lr()","fileutils::cp_lr()","fileutils#cp_lr()","bundler::fileutils::cp_r()","bundler::fileutils#cp_r()","fileutils::cp_r()","fileutils#cp_r()","bundler::gemhelpers::platformmatch::cpu_match()","net::smtp::response#cram_md5_challenge()","net::smtp#cram_md5_response()","net::smtp#cram_secret()","zlib::gzipfile#crc()","zlib::crc32()","zlib::crc32_combine()","zlib::crc_table()","net::ftp::mlsxentry#creatable?()","fiddle::cstructbuilder::create()","fiddle::cstructbuilder#create()","gem::noaliasyamltree::create()","gem::requirement::create()","gem::version::create()","net::imap#create()","openssl::ocsp::response::create()","openssl::pkcs12::create()","psych::visitors::jsontree::create()","psych::visitors::toruby::create()","psych::visitors::yamltree::create()","resolv::dns::name::create()","resolv::ipv4::create()","resolv::ipv6::create()","resolv::loc::alt::create()","resolv::loc::coord::create()","resolv::loc::size::create()","tempfile::create()","bundler::installer#create_bundle_path()","gem::security::create_cert()","gem::security::create_cert_email()","gem::security::create_cert_self_signed()","bundler::molinillo::resolver::resolution#create_conflict()","gem::resolver::molinillo::resolver::resolution#create_conflict()","rdoc::parser::changelog#create_document()","rdoc::parser::changelog#create_entries()","rinda::tuplespace#create_entry()","openssl::x509::extensionfactory#create_ext()","openssl::x509::extensionfactory#create_ext_from_array()","openssl::x509::extensionfactory#create_ext_from_hash()","openssl::x509::extensionfactory#create_ext_from_string()","openssl::x509::extensionfactory#create_extension()","bundler::thor::actions#create_file()","rexml::sourcefactory::create_from()","win32ole::create_guid()","makemakefile#create_header()","rdoc::parser::changelog#create_items()","gem::security::create_key()","bundler::thor::actions#create_link()","webrick::utils::create_listeners()","webrick::utils#create_listeners()","makemakefile#create_makefile()","cgi::session#create_new_id()","gem::command#create_option_parser()","webrick::httpserver#create_request()","gem::s3urisigner#create_request_pool()","webrick::httpserver#create_response()","webrick::utils#create_self_signed_cert()","webrick::utils::create_self_signed_cert()","net::imap#create_ssl_params()","net::pop3::create_ssl_params()","bundler::worker#create_threads()","racc::states#create_tmap()","fiddle::importer#create_value()","gem::testcase::specfetchersetup#created_specs()","bundler::uricredentialsfilter#credential_filtered_string()","bundler::uricredentialsfilter#credential_filtered_uri()","bundler::settings#credentials_for()","gem::configfile#credentials_path()","bundler::source::rubygems#credless_remotes()","racc::parserfilegenerator#cref_pop()","racc::parserfilegenerator#cref_push()","net::smtp#critical()","openssl::x509::extension#critical=()","openssl::x509::extension#critical?()","openssl::x509::extensionfactory#crl=()","openssl::pkcs7#crls()","openssl::pkcs7#crls=()","irb::vec#cross()","vector#cross()","bundler::injector#cross_check_for_errors()","vector#cross_product()","string#crypt()","rdoc::markdown#css()","rss::basemodel#csv_attr_reader()","rss::basemodel#csv_integer_writer()","rss::basemodel#csv_writer()","date#ctime()","file#ctime()","file::ctime()","file::stat#ctime()","pathname#ctime()","time#ctime()","openssl::engine#ctrl_cmd()","fiber::current()","rdoc::rdoc::current()","thread::current()","rdoc::rdoc::current=()","openssl::x509::storecontext#current_cert()","bundler::cli#current_command()","bundler::thor::invocation#current_command_chain()","openssl::x509::storecontext#current_crl()","bundler::definition#current_dependencies()","bundler::gemdeps#current_dependencies()","rss::maker::base#current_element()","bundler::dependency#current_env?()","prettyprint#current_group()","rexml::iosource#current_line()","rexml::source#current_line()","bundler::dependency#current_platform?()","bundler::definition#current_platforms()","bundler::current_ruby()","rdoc::context#current_section()","drb::current_server()","drb#current_server()","method#curry()","proc#curry()","io#cursor()","io#cursor=()","io#cursor_down()","io#cursor_left()","io#cursor_right()","io#cursor_up()","openssl::pkey::ec::group#curve_name()","date#cwday()","date#cweek()","date#cwyear()","array#cycle()","enumerable#cycle()","matrix::eigenvaluedecomposition#d()","process::daemon()","net::smtp#data()","resolv::dns::resource::txt#data()","socket::ancillarydata#data()","socket::option#data()","openssl::pkcs7#data=()","zlib::zstream#data_type()","gem::datadir()","gem::basicspecification#datadir()","gem::specification#date()","gem::specification#date=()","rss::maker::channelbase#date=()","rss::maker::itemsbase::itembase#date=()","rss::maker::itemsbase::itembase::sourcebase#date=()","rss::basemodel#date_writer()","logger#datetime_format()","logger#datetime_format=()","date#day()","time#day()","date#day_fraction()","array#dclone()","float#dclone()","integer#dclone()","object#dclone()","symbol#dclone()","rexml::parsers::sax2parser#deafen()","bundler::compactindexclient::debug()","bundler::molinillo::resolver::resolution#debug()","bundler::molinillo::ui#debug()","bundler::resolver#debug()","bundler::ui::shell#debug()","bundler::ui::silent#debug()","gem::resolver::molinillo::resolver::resolution#debug()","gem::resolver::molinillo::ui#debug()","gem::streamui#debug()","logger#debug()","net::imap::debug()","openssl::debug()","syslog::logger#debug()","webrick::basiclog#debug()","logger#debug!()","net::imap::debug=()","openssl::debug=()","bundler::molinillo::ui#debug?()","bundler::resolver#debug?()","bundler::ui::shell#debug?()","bundler::ui::silent#debug?()","gem::resolver#debug?()","gem::resolver::molinillo::ui#debug?()","logger#debug?()","webrick::basiclog#debug?()","bundler::gemversionpromoter#debug_format_result()","ripper#debug_output()","net::smtp#debug_output=()","ripper#debug_output=()","debugger__::debug_thread_info()","gem::testcase::specfetchersetup::declare()","racc::grammar#declare_precedence()","bundler::uri::escape#decode()","openssl::asn1::decode()","rexml::encoding#decode()","uri::escape#decode()","base64#decode64()","openssl::asn1::decode_all()","net::imap::decode_utf7()","bundler::uri::decode_www_form()","uri::decode_www_form()","bundler::uri::decode_www_form_component()","uri::decode_www_form_component()","array#deconstruct()","struct#deconstruct()","hash#deconstruct_keys()","struct#deconstruct_keys()","racc::reduce#decref()","openssl::cipher#decrypt()","openssl::pkcs7#decrypt()","ripper#dedent_string()","ripper::dedent_string()","psych::visitors::toruby#deduplicate()","rdoc::parser::c#deduplicate_call_seq()","rexml::parent#deep_clone()","rss::maker::base::def_array_element()","rss::maker::atompersons#def_atom_persons()","rss::maker::atomtextconstruct::def_atom_text_construct()","rss::basemodel#def_children_accessor()","erb#def_class()","rss::itunesmodelutils#def_class_accessor()","rss::maker::itunesbasemodel#def_class_accessor()","rss::maker::base::def_classed_element()","rss::maker::base::def_classed_element_without_accessor()","rss::maker::base::def_classed_elements()","rss::converter#def_convert()","rss::element::def_corresponded_attr_reader()","rss::element::def_corresponded_attr_writer()","rss::maker::itunesbasemodel#def_csv_accessor()","rss::maker::base::def_csv_element()","forwardable#def_delegator()","singleforwardable#def_delegator()","forwardable#def_delegators()","singleforwardable#def_delegators()","rss::itunesmodelutils#def_element_class_accessor()","rss::itunesmodelutils#def_elements_class_accessor()","rss::maker::itunesbasemodel#def_elements_class_accessor()","rss::converter#def_else_enc()","erb::defmethod::def_erb_method()","erb::defmethod#def_erb_method()","rss::maker::itunesbasemodel#def_explicit_clean_other_accessor()","irb::contextextender::def_extend_command()","irb::extendcommandbundle::def_extend_command()","rss::baselistener::def_get_text_element()","optionparser#def_head_option()","rss::converter#def_iconv_convert()","irb::inspector::def_inspector()","forwardable#def_instance_delegator()","forwardable#def_instance_delegators()","erb#def_method()","erb#def_module()","irb::notifier::def_notifier()","irb::notifier#def_notifier()","irb::notifier::compositenotifier#def_notifier()","optionparser#def_option()","rss::maker::base::def_other_element()","rss::maker::base::def_other_element_without_accessor()","irb::methodextender#def_post_proc()","irb::methodextender#def_pre_proc()","rss::converter#def_same_enc()","singleforwardable#def_single_delegator()","singleforwardable#def_single_delegators()","optionparser#def_tail_option()","rss::converter#def_to_euc_jp_from_iso_2022_jp()","rss::converter#def_to_euc_jp_from_shift_jis()","rss::converter#def_to_euc_jp_from_utf_8()","rss::converter#def_to_iso_2022_jp_from_euc_jp()","rss::converter#def_to_iso_8859_1_from_utf_8()","rss::converter#def_to_shift_jis_from_euc_jp()","rss::converter#def_to_shift_jis_from_utf_8()","rss::converter#def_to_utf_8_from_euc_jp()","rss::converter#def_to_utf_8_from_iso_8859_1()","rss::converter#def_to_utf_8_from_shift_jis()","rss::converter#def_uconv_convert_if_can()","rss::maker::itunesbasemodel#def_yes_other_accessor()","gem::requirement::default()","hash#default()","rexml::xmldecl::default()","win32ole_param#default()","hash#default=()","drb::drbserver::default_acl()","drb::drbserver::default_argc_limit()","bundler::retry::default_attempts()","gem::default_bindir()","bundler::default_bundle_dir()","bundler::sharedhelpers#default_bundle_dir()","gem::default_cert_path()","bundler::thor::default_command()","gem::default_dir()","win32ole_type#default_event_sources()","gem::default_exec_format()","gem::default_ext_dir_for()","encoding::default_external()","encoding::default_external=()","bundler::stubspecification#default_gem()","gem::basicspecification#default_gem?()","bundler::cli::info#default_gem_spec()","bundler::default_gemfile()","bundler::sharedhelpers#default_gemfile()","drb::drbserver::default_id_conv()","net::imap::default_imap_port()","net::imap::default_imaps_port()","encoding::default_internal()","encoding::default_internal=()","gem::default_key_path()","drb::drbserver::default_load_limit()","bundler::default_lockfile()","bundler::sharedhelpers#default_lockfile()","win32ole_type#default_ole_types()","rss::parser::default_parser()","rss::parser::default_parser=()","net::ftp::default_passive()","net::ftp::default_passive=()","gem::default_path()","gem::pathsupport#default_path()","net::pop3::default_pop3_port()","net::pop3::default_pop3s_port()","bundler::uri::generic#default_port()","bundler::uri::generic::default_port()","net::http::default_port()","net::imap::default_port()","net::pop3::default_port()","net::smtp::default_port()","uri::generic::default_port()","uri::generic#default_port()","gem::requirement::default_prerelease()","hash#default_proc()","hash#default_proc=()","bundler::retry::default_retries()","gem::default_rubygems_dirs()","bundler::sourcelist#default_source()","gem::default_sources()","gem::default_spec_cache_dir()","gem::installer#default_spec_file()","gem::default_specifications_dir()","gem::basicspecification::default_specifications_dir()","irb::default_src_encoding()","net::smtp::default_ssl_context()","net::imap::default_ssl_port()","net::smtp::default_ssl_port()","bundler::rubygemsintegration#default_stubs()","gem::specification::default_stubs()","net::smtp::default_submission_port()","bundler::thor::default_task()","rdoc::options#default_title=()","net::imap::default_tls_port()","net::smtp::default_tls_port()","gem::specification#default_value()","rdoc::task#defaults()","rdoc::task#defaults()","gem::command#defaults_str()","gem::commands::infocommand#defaults_str()","bundler::plugin::events::define()","gem::packagetask#define()","optionparser#define()","rdoc::task#define()","rdoc::task#define()","racc::grammar::define()","racc::parserclassgenerator#define_actions()","optionparser#define_by_keywords()","objectspace::define_finalizer()","optionparser#define_head()","module#define_method()","object#define_singleton_method()","optionparser#define_tail()","bundler::deployment::define_task()","tracepoint#defined_class()","bundler::plugin::events::defined_event?()","rdoc::context#defined_in?()","bundler::definition()","rdoc::attr#definition()","rdoc::normalclass#definition()","rdoc::normalmodule#definition()","rdoc::singleclass#definition()","rdoc::markdown#definition_lists()","bundler::runtime::definition_method()","gem::deflate()","zlib::deflate()","zlib::deflate#deflate()","zlib::deflate::deflate()","openssl::pkey::ec::group#degree()","forwardable#delegate()","singleforwardable#delegate()","net::ftp::mlsxentry#deletable?()","array#delete()","bundler::thor::coreext::orderedhash#delete()","cgi::session#delete()","cgi::session::filestore#delete()","cgi::session::memorystore#delete()","cgi::session::nullstore#delete()","cgi::session::pstore#delete()","csv::row#delete()","csv::table#delete()","dbm#delete()","dir::delete()","env::delete()","file::delete()","gdbm#delete()","gem::sourcelist#delete()","hash#delete()","irb::jobmanager#delete()","net::ftp#delete()","net::http#delete()","net::httpheader#delete()","net::imap#delete()","net::popmail#delete()","pstore#delete()","pathname#delete()","rexml::attributes#delete()","rexml::elements#delete()","rexml::parent#delete()","racc::iset#delete()","racc::symboltable#delete()","rinda::tuplebag#delete()","rinda::tuplebag::tuplebin#delete()","sdbm#delete()","set#delete()","string#delete()","tempfile#delete()","yaml::dbm#delete()","net::popmail#delete!()","string#delete!()","set#delete?()","net::pop3#delete_all()","net::pop3::delete_all()","rexml::attributes#delete_all()","rexml::elements#delete_all()","array#delete_at()","rexml::parent#delete_at()","rexml::element#delete_attribute()","bundler::molinillo::dependencygraph#delete_edge()","bundler::molinillo::dependencygraph::log#delete_edge()","gem::resolver::molinillo::dependencygraph#delete_edge()","gem::resolver::molinillo::dependencygraph::log#delete_edge()","rexml::element#delete_element()","openstruct#delete_field()","bundler::molinillo::dependencygraph::addedgenocircular#delete_first()","gem::resolver::molinillo::dependencygraph::addedgenocircular#delete_first()","array#delete_if()","bundler::thor::coreext::orderedhash#delete_if()","csv::row#delete_if()","csv::table#delete_if()","dbm#delete_if()","env::delete_if()","gdbm#delete_if()","hash#delete_if()","rexml::parent#delete_if()","sdbm#delete_if()","set#delete_if()","yaml::dbm#delete_if()","rdoc::rubygemshook#delete_legacy_args()","rdoc::rubygemshook#delete_legacy_args()","rexml::element#delete_namespace()","observable#delete_observer()","observable#delete_observers()","webrick::httpauth::htdigest#delete_passwd()","webrick::httpauth::htpasswd#delete_passwd()","string#delete_prefix()","string#delete_prefix!()","csv::deletesuffix#delete_suffix()","string#delete_suffix()","string#delete_suffix!()","readline::delete_text()","rinda::tuplebag#delete_unless_alive()","net::popmail#deleted?()","complex#denominator()","float#denominator()","integer#denominator()","numeric#denominator()","rational#denominator()","makemakefile#depend_rules()","bundler::compactindexclient#dependencies()","bundler::compactindexclient::cache#dependencies()","bundler::gemdeps#dependencies()","bundler::parallelinstaller::specinstallation#dependencies()","bundler::remotespecification#dependencies()","gem::resolver::indexspecification#dependencies()","gem::resolver::specspecification#dependencies()","gem::specification#dependencies()","bundler::cli::install#dependencies_count_for()","bundler::index#dependencies_eql?()","bundler::molinillo::delegates::specificationprovider#dependencies_for()","bundler::molinillo::specificationprovider#dependencies_for()","bundler::resolver#dependencies_for()","gem::resolver#dependencies_for()","gem::resolver::molinillo::delegates::specificationprovider#dependencies_for()","gem::resolver::molinillo::specificationprovider#dependencies_for()","bundler::resolver::specgroup#dependencies_for_activated_platforms()","bundler::definition#dependencies_for_source_changed?()","bundler::parallelinstaller::specinstallation#dependencies_installed?()","gem::specification#dependencies_to_gemfile()","gem::impossibledependencieserror#dependency()","bundler::fetcher::dependency#dependency_api_uri()","bundler::index#dependency_names()","bundler::source#dependency_names_to_double_check()","bundler::source::rubygems#dependency_names_to_double_check()","gem::dependencylist#dependency_order()","bundler::fetcher::dependency#dependency_specs()","gem::specification#dependent_gems()","gem::specification#dependent_specs()","gem::deprecate#deprecate()","gem::deprecate::deprecate()","module#deprecate_constant()","gem::command#deprecate_option()","bundler::molinillo::delegates::resolutionstate#depth()","gem::resolver::molinillo::delegates::resolutionstate#depth()","json::ext::generator::state#depth()","json::ext::generator::state#depth=()","bundler::worker#deq()","queue#deq()","sizedqueue#deq()","webrick::httputils#dequote()","webrick::httputils::dequote()","bundler::thor::desc()","bundler::thor::group::desc()","pathname#descend()","rexml::xpathparser#descendant()","rexml::xpathparser#descendant_recursive()","bundler::molinillo::dependencygraph::vertex#descendent?()","gem::resolver::molinillo::dependencygraph::vertex#descendent?()","gem::command#description()","gem::commands::unpackcommand#description()","gem::specification#description=()","psych::visitors::toruby#deserialize()","encoding::converter#destination_encoding()","encoding::invalidbytesequenceerror#destination_encoding()","encoding::undefinedconversionerror#destination_encoding()","encoding::invalidbytesequenceerror#destination_encoding_name()","encoding::undefinedconversionerror#destination_encoding_name()","bundler::thor::actions#destination_root()","bundler::thor::actions#destination_root=()","matrix#det()","matrix::lupdecomposition#det()","matrix#det_e()","racc::parserfilegenerator#detab()","process::detach()","bundler::molinillo::dependencygraph#detach_vertex_named()","bundler::molinillo::dependencygraph::log#detach_vertex_named()","gem::resolver::molinillo::dependencygraph#detach_vertex_named()","gem::resolver::molinillo::dependencygraph::log#detach_vertex_named()","openssl::pkcs7#detached()","openssl::pkcs7#detached=()","openssl::pkcs7#detached?()","enumerable#detect()","gem::specfetcher#detect()","rdoc::encoding::detect_encoding()","rexml::source#detect_encoding()","gem::detect_gemdeps()","bundler::persistent::net::http::persistent::detect_idle_timeout()","csv::parser#detect_row_separator()","matrix#determinant()","matrix::lupdecomposition#determinant()","matrix#determinant_bareiss()","matrix#determinant_e()","csv#determine_encoding()","racc::grammar#determine_terminals()","file::stat#dev()","file::stat#dev_major()","file::stat#dev_minor()","gem::resolver::activationrequest#development?()","gem::resolver::dependencyrequest#development?()","gem::specification#development_dependencies()","racc::grammar#dfa()","racc::states#dfa()","jacobian#dfdxi()","openssl::pkey::ec#dh_compute_key()","matrix::diagonal()","matrix#diagonal?()","matrix::eigenvaluedecomposition#diagonalize()","bundler::rubyversion#diff()","array#difference()","set#difference()","array#dig()","csv::row#dig()","csv::table#dig()","hash#dig()","openstruct#dig()","struct#dig()","reline::core#dig_perfect_match_proc=()","bundler::sharedhelpers#digest()","digest::class::digest()","digest::instance#digest()","openssl::digest::digest()","openssl::engine#digest()","openssl::hmac#digest()","openssl::hmac::digest()","digest::instance#digest!()","digest::base#digest_length()","digest::instance#digest_length()","openssl::digest#digest_length()","integer#digits()","racc::states#digraph()","gem::dir()","gem::installer#dir()","net::ftp#dir()","makemakefile#dir_config()","rdoc::classmodule#direct_ancestors()","rdoc::normalclass#direct_ancestors()","bundler::thor::actions#directory()","file::directory?()","file::stat#directory?()","filetest#directory?()","gem::package::tarreader::entry#directory?()","net::ftp::mlsxentry#directory?()","pathname#directory?()","net::ftp::mlsxentry#directory_makable?()","file::dirname()","pathname#dirname()","gem::specification::dirs()","gem::specification::dirs=()","gc::disable()","gc::profiler::disable()","tracepoint#disable()","fiddle::handle#disable_close()","bundler::thor::disable_required_check!()","net::pop3::disable_ssl()","net::pop3#disable_ssl()","net::smtp#disable_ssl()","net::smtp#disable_starttls()","net::smtp#disable_tls()","rubyvm::instructionsequence#disasm()","rubyvm::instructionsequence::disasm()","rubyvm::instructionsequence#disassemble()","rubyvm::instructionsequence::disassemble()","net::imap#disconnect()","net::imap#disconnected?()","set#disjoint?()","bundler::cli::dispatch()","irb::color::dispatch_seq()","win32ole_method#dispid()","debugger__::display()","gem::resolver::stats#display()","object#display()","rdoc::codeobject#display?()","rdoc::toplevel#display?()","gem::commands::querycommand#display_header()","bundler::cli::outdated#display_nothing_outdated_message()","bigdecimal#div()","integer#div()","numeric#div()","set#divide()","bigdecimal#divmod()","float#divmod()","integer#divmod()","numeric#divmod()","fiddle::importer#dlload()","fiddle#dlopen()","fiddle::dlopen()","fiddle::dlunwrap()","fiddle::dlwrap()","bundler::uri::ldap#dn()","uri::ldap#dn()","bundler::uri::ldap#dn=()","uri::ldap#dn=()","rdoc::servlet#do_get()","webrick::httpservlet::abstractservlet#do_get()","webrick::httpservlet::erbhandler#do_get()","webrick::httpservlet::abstractservlet#do_head()","webrick::httpserver#do_options()","webrick::httpservlet::abstractservlet#do_options()","webrick::httpservlet::erbhandler#do_post()","rdoc::parser::c#do_aliases()","rdoc::parser::c#do_attrs()","rdoc::parser::c#do_boot_defclass()","rdoc::parser::c#do_classes_and_modules()","gem::gemrunner#do_configuration()","rdoc::parser::c#do_constants()","net::http#do_finish()","net::smtp#do_finish()","net::smtp#do_helo()","rdoc::parser::c#do_includes()","bundler::parallelinstaller#do_install()","rdoc::parser::c#do_methods()","rdoc::parser::c#do_missing()","basicsocket#do_not_reverse_lookup()","basicsocket::do_not_reverse_lookup()","basicsocket::do_not_reverse_lookup=()","basicsocket#do_not_reverse_lookup=()","openssl::ssl::socketforwarder#do_not_reverse_lookup=()","rinda::ringserver#do_reply()","racc::states#do_resolve_sr()","net::http#do_start()","net::smtp#do_start()","rss::baseparser#do_validate()","rss::baseparser#do_validate=()","openssl::buffering#do_write()","rinda::ringserver#do_write()","gem::specification#doc_dir()","gem::server#doc_root()","rdoc::stats#doc_stats()","bundler::cli#doctor()","bundler::cli::issue#doctor()","gem::commands::checkcommand#doctor()","gem::doctor#doctor()","rexml::attribute#doctype()","rexml::document#doctype()","rexml::sax2listener#doctype()","rexml::streamlistener#doctype()","rexml::text#doctype()","rexml::parsers::pullevent#doctype?()","rexml::streamlistener#doctype_end()","rdoc::rdoc#document()","rdoc::rubygemshook#document()","rdoc::rubygemshook#document()","rexml::child#document()","rexml::document#document()","rexml::element#document()","psych::nodes::document#document?()","psych::nodes::node#document?()","rdoc::codeobject#document_children=()","rdoc::codeobject#document_self=()","rdoc::classmodule#document_self_or_methods()","rdoc::servlet#documentation_page()","rdoc::servlet#documentation_search()","rdoc::servlet#documentation_source()","rdoc::classmodule#documented?()","rdoc::codeobject#documented?()","rdoc::constant#documented?()","rdoc::methodattr#documented?()","cgi::cookie#domain=()","gem::streamui::silentdownloadreporter#done()","gem::streamui::silentprogressreporter#done()","gem::streamui::simpleprogressreporter#done()","gem::streamui::threadeddownloadreporter#done()","gem::streamui::verboseprogressreporter#done()","rexml::validation::event#done?()","rdoc::stats#done_adding()","rdoc::codeobject#done_documenting=()","gem::done_installing()","irb::vec#dot()","vector#dot()","acl::aclentry#dot_pat()","acl::aclentry#dot_pat_str()","bundler::plugin::api::source#double_check_for()","bundler::source#double_check_for()","bundler::source::rubygems#double_check_for()","bundler::definition#double_check_for_index()","bigdecimal::double_fig()","bundler::molinillo::dependencygraph::action#down()","bundler::molinillo::dependencygraph::addedgenocircular#down()","bundler::molinillo::dependencygraph::deleteedge#down()","bundler::molinillo::dependencygraph::detachvertexnamed#down()","bundler::molinillo::dependencygraph::tag#down()","gem::resolver::molinillo::dependencygraph::action#down()","gem::resolver::molinillo::dependencygraph::addedgenocircular#down()","gem::resolver::molinillo::dependencygraph::deleteedge#down()","gem::resolver::molinillo::dependencygraph::detachvertexnamed#down()","gem::resolver::molinillo::dependencygraph::tag#down()","string#downcase()","symbol#downcase()","string#downcase!()","gem::fakefetcher#download()","gem::remotefetcher#download()","gem::resolver::activationrequest#download()","gem::resolver::specification#download()","gem::source#download()","gem::source::installed#download()","gem::testcase::specfetchersetup#download()","bundler::source::rubygems#download_cache_path()","bundler::rubygemsintegration#download_gem()","bundler::source::rubygems#download_gem()","gem::streamui#download_reporter()","gem::fakefetcher#download_to_cache()","gem::remotefetcher#download_to_cache()","bundler::fetcher#downloader()","date#downto()","integer#downto()","rexml::xmldecl#dowrite()","irb::canvas#draw()","array#drop()","enumerable#drop()","enumerator::lazy#drop()","array#drop_while()","enumerable#drop_while()","enumerator::lazy#drop_while()","openssl::pkey::ec#dsa_sign_asn1()","openssl::pkey::ec#dsa_verify_asn1()","time#dst?()","socket::ifaddr#dstaddr()","encoding#dummy?()","racc::sym#dummy?()","makemakefile#dummy_makefile()","bundler::yamlserializer#dump()","json#dump()","json::genericobject::dump()","marshal::dump()","objectspace::dump()","psych::dump()","rexml::validation::validator#dump()","string#dump()","objectspace::dump_all()","psych::visitors::yamltree#dump_coder()","psych::visitors::yamltree#dump_exception()","bundler::yamlserializer#dump_hash()","psych::visitors::yamltree#dump_ivars()","psych::visitors::yamltree#dump_list()","psych::dump_stream()","bigdecimal#dup()","numeric#dup()","object#dup()","racc::iset#dup()","singleton#dup()","bundler::cli::doctor#dylibs()","bundler::cli::doctor#dylibs_darwin()","bundler::cli::doctor#dylibs_ldd()","irb::reidlineinputmethod#dynamic_prompt()","bundler::thor::shell::basic#dynamic_width()","bundler::thor::shell::basic#dynamic_width_stty()","bundler::thor::shell::basic#dynamic_width_tput()","argf#each()","array#each()","bundler::index#each()","bundler::molinillo::dependencygraph#each()","bundler::molinillo::dependencygraph::log#each()","bundler::settings::mirrors#each()","bundler::specset#each()","bundler::thor::coreext::orderedhash#each()","csv#each()","csv::fieldsconverter#each()","csv::row#each()","csv::table#each()","dbm#each()","dir#each()","env::each()","enumerator#each()","enumerator::arithmeticsequence#each()","enumerator::chain#each()","gdbm#each()","gem::availableset#each()","gem::configfile#each()","gem::dependencylist#each()","gem::list#each()","gem::package::tarreader#each()","gem::resolver::molinillo::dependencygraph#each()","gem::resolver::molinillo::dependencygraph::log#each()","gem::sourcelist#each()","gem::specification::each()","getoptlong#each()","hash#each()","io#each()","matrix#each()","net::httpheader#each()","net::pop3#each()","objectspace::weakmap#each()","openssl::asn1::constructive#each()","openssl::buffering#each()","openssl::config#each()","prime#each()","prime::pseudoprimegenerator#each()","psych::nodes::node#each()","rexml::attlistdecl#each()","rexml::attributes#each()","rexml::elements#each()","rexml::light::node#each()","rexml::parent#each()","rexml::parsers::pullparser#each()","rexml::quickpath::each()","rexml::xpath::each()","rss::xml::element#each()","racc::grammar#each()","racc::iset#each()","racc::rule#each()","racc::states#each()","racc::symboltable#each()","range#each()","rinda::notifytemplateentry#each()","rinda::ringfinger#each()","rinda::tuple#each()","sdbm#each()","set#each()","stringio#each()","struct#each()","vector#each()","webrick::httpauth::htdigest#each()","webrick::httpauth::htpasswd#each()","webrick::httprequest#each()","webrick::httpresponse#each()","win32ole#each()","yaml::dbm#each()","zlib::gzipreader#each()","vector#each2()","resolv::each_address()","resolv#each_address()","resolv::dns#each_address()","resolv::hosts#each_address()","resolv::mdns#each_address()","rdoc::classmodule#each_ancestor()","rdoc::context#each_attribute()","rexml::attributes#each_attribute()","rubyvm::each_builtin()","argf#each_byte()","io#each_byte()","openssl::buffering#each_byte()","string#each_byte()","stringio#each_byte()","zlib::gzipreader#each_byte()","net::httpheader#each_capitalized()","net::httpheader#each_capitalized_name()","gem::security::trustdir#each_certificate()","argf#each_char()","io#each_char()","string#each_char()","stringio#each_char()","zlib::gzipreader#each_char()","dir#each_child()","dir::each_child()","pathname#each_child()","rexml::parent#each_child()","rubyvm::instructionsequence#each_child()","rdoc::context#each_classmodule()","argf#each_codepoint()","io#each_codepoint()","string#each_codepoint()","stringio#each_codepoint()","enumerable#each_cons()","optionparser::each_const()","rdoc::context#each_constant()","webrick::httputils::formdata#each_data()","rexml::element#each_element()","rexml::element#each_element_with_attribute()","rexml::element#each_element_with_text()","enumerable#each_entry()","gem::package::tarreader#each_entry()","pathname#each_entry()","rinda::tuplebag#each_entry()","rdoc::context#each_extend()","pathname#each_filename()","string#each_grapheme_cluster()","net::httpheader#each_header()","rdoc::context#each_include()","array#each_index()","rexml::parent#each_index()","racc::grammar#each_index()","racc::states#each_index()","bundler::thor::coreext::orderedhash#each_key()","dbm#each_key()","env::each_key()","gdbm#each_key()","hash#each_key()","net::httpheader#each_key()","objectspace::weakmap#each_key()","sdbm#each_key()","racc::item#each_la()","argf#each_line()","csv::parser::inputsscanner#each_line()","csv::parser::scanner#each_line()","csv::parser::unoptimizedstringio#each_line()","io#each_line()","openssl::buffering#each_line()","pathname#each_line()","string#each_line()","stringio#each_line()","zlib::gzipreader#each_line()","irb::locale#each_localized_path()","net::pop3#each_mail()","rdoc::context#each_method()","net::httpheader#each_name()","resolv#each_name()","resolv::each_name()","resolv::dns#each_name()","resolv::hosts#each_name()","racc::symboltable#each_nonterminal()","objectspace::each_object()","getoptlong#each_option()","optionparser::list#each_option()","bundler::thor::coreext::orderedhash#each_pair()","csv::row#each_pair()","dbm#each_pair()","env::each_pair()","gdbm#each_pair()","hash#each_pair()","objectspace::weakmap#each_pair()","openstruct#each_pair()","sdbm#each_pair()","struct#each_pair()","yaml::dbm#each_pair()","rdoc::codeobject#each_parent()","integer::each_prime()","rexml::node#each_recursive()","racc::actiontable#each_reduce()","resolv::dns#each_resource()","net::httpresponse::each_response_header()","racc::grammar#each_rule()","racc::rule#each_rule()","rdoc::context#each_section()","racc::actiontable#each_shift()","enumerable#each_slice()","gem::sourcelist#each_source()","gem::availableset#each_spec()","racc::states#each_state()","tsort::each_strongly_connected_component()","tsort#each_strongly_connected_component()","tsort#each_strongly_connected_component_from()","tsort::each_strongly_connected_component_from()","irb::locale#each_sublocale()","racc::states#each_t()","racc::symboltable#each_terminal()","rexml::xpathparser#each_unnode()","bundler::thor::coreext::orderedhash#each_value()","dbm#each_value()","env::each_value()","gdbm#each_value()","hash#each_value()","net::httpheader#each_value()","objectspace::weakmap#each_value()","sdbm#each_value()","yaml::dbm#each_value()","enumerable#each_with_index()","enumerator#each_with_index()","matrix#each_with_index()","racc::grammar#each_with_index()","enumerable#each_with_object()","enumerator#each_with_object()","rexml::element#each_with_something()","enumerator::lazy#eager()","bundler::source#earlier_version?()","irb::easter_egg()","gem::s3urisigner#ec2_metadata_credentials_json()","gem::s3urisigner#ec2_metadata_request()","openssl::ssl::sslcontext#ecdh_curves=()","io#echo=()","bundler::thor::lineeditor::basic#echo?()","io#echo?()","net::http#edit_path()","openssl::random::egd()","openssl::random::egd_bytes()","process::egid()","process::egid=()","net::smtp#ehlo()","process::gid::eid()","process::uid::eid()","matrix#eigen()","matrix#eigensystem()","matrix::eigenvaluedecomposition#eigenvalue_matrix()","matrix::eigenvaluedecomposition#eigenvalues()","matrix::eigenvaluedecomposition#eigenvector_matrix()","matrix::eigenvaluedecomposition#eigenvector_matrix_inv()","matrix::eigenvaluedecomposition#eigenvectors()","bundler::gemversionpromoter#either_version_older_than_locked()","matrix#element()","vector#element()","rexml::attribute#element=()","rss::utils#element_initialize_arguments?()","rexml::sax2listener#elementdecl()","rexml::streamlistener#elementdecl()","rexml::parsers::pullevent#elementdecl?()","vector::elements()","matrix#elements_to_f()","vector#elements_to_f()","matrix#elements_to_i()","vector#elements_to_i()","matrix#elements_to_r()","vector#elements_to_r()","readline::emacs_editing_mode()","reline::core#emacs_editing_mode()","readline::emacs_editing_mode?()","reline::core#emacs_editing_mode?()","gem::security::email_to_name()","racc::parserfilegenerator#embed_library()","racc::grammarfileparser#embedded_action()","psych::visitors::yamltree#emit_coder()","csv::parser#emit_row()","rdoc::markdown#emphasis()","bundler::molinillo::resolutionstate::empty()","gem::resolver::molinillo::resolutionstate::empty()","matrix::empty()","psych::handler#empty()","racc::useraction::empty()","array#empty?()","bundler::connectionpool::timedstack#empty?()","bundler::index#empty?()","bundler::specset#empty?()","bundler::versionranges::empty?()","bundler::versionranges::reqr#empty?()","csv::fieldsconverter#empty?()","dbm#empty?()","dir::empty?()","env::empty?()","file::empty?()","filetest#empty?()","gdbm#empty?()","gem::availableset#empty?()","gem::package::tarheader#empty?()","gem::requestset::lockfile::tokenizer#empty?()","gem::resolver::requirementlist#empty?()","gem::sourcelist#empty?()","hash#empty?()","matrix#empty?()","pathname#empty?()","queue#empty?()","rdoc::comment#empty?()","rexml::elements#empty?()","rexml::iosource#empty?()","rexml::parsers::baseparser#empty?()","rexml::source#empty?()","rexml::text#empty?()","racc::iset#empty?()","racc::rule#empty?()","racc::useraction#empty?()","sdbm#empty?()","set#empty?()","sizedqueue#empty?()","string#empty?()","stringscanner#empty?()","symbol#empty?()","rss::atom::feed::entry::content#empty_content?()","rss::element#empty_content?()","bundler::thor::actions#empty_directory()","pstore#empty_marshal_checksum()","pstore#empty_marshal_data()","gc::enable()","gc::profiler::enable()","tracepoint#enable()","fiddle::handle#enable_close()","makemakefile#enable_config()","openssl::ssl::sslcontext#enable_fallback_scsv()","gem::testcase#enable_shared()","net::pop3#enable_ssl()","net::pop3::enable_ssl()","net::smtp#enable_ssl()","net::smtp#enable_starttls()","net::smtp#enable_starttls_auto()","net::smtp#enable_tls()","gc::profiler::enabled?()","rubyvm::mjit::enabled?()","tracepoint#enabled?()","openssl::pkcs7::recipientinfo#enc_key()","threadgroup#enclose()","threadgroup#enclosed?()","bundler::uri::escape#encode()","rexml::encoding#encode()","string#encode()","uri::escape#encode()","rdoc::comment#encode!()","string#encode!()","base64#encode64()","rdoc::text::encode_fallback()","net::httpgenericrequest#encode_multipart_form_data()","net::imap::encode_utf7()","gem::dependency#encode_with()","bundler::uri::encode_www_form()","uri::encode_www_form()","bundler::uri::encode_www_form_component()","uri::encode_www_form_component()","irb::fileinputmethod#encoding()","irb::locale#encoding()","irb::readlineinputmethod#encoding()","irb::reidlineinputmethod#encoding()","irb::stdioinputmethod#encoding()","rexml::document#encoding()","regexp#encoding()","reline::core#encoding()","ripper#encoding()","string#encoding()","symbol#encoding()","rexml::encoding#encoding=()","rexml::source#encoding=()","rexml::xmldecl#encoding=()","reline::encoding_system_needs()","rexml::iosource#encoding_updated()","rexml::source#encoding_updated()","openssl::cipher#encrypt()","openssl::pkcs7::encrypt()","enumerator::arithmeticsequence#end()","matchdata#end()","range#end()","zlib::zstream#end()","rdoc::parser::ripperstatelex::end?()","rss::rexmllikexmlparser#endelement()","psych::emitter#end_document()","psych::handler#end_document()","psych::treebuilder#end_document()","rexml::sax2listener#end_document()","rexml::sax2listener#end_element()","rexml::parsers::pullevent#end_element?()","psych::emitter#end_mapping()","psych::handler#end_mapping()","racc::grammar#end_precedence_declaration()","rexml::sax2listener#end_prefix_mapping()","bundler::molinillo::resolver::resolution#end_resolution()","gem::resolver::molinillo::resolver::resolution#end_resolution()","ripper#end_seen?()","psych::emitter#end_sequence()","psych::handler#end_sequence()","psych::emitter#end_stream()","psych::handler#end_stream()","psych::treebuilder#end_stream()","net::http#end_transport()","string#end_with?()","symbol#end_with?()","zlib::zstream#ended?()","etc::endgrent()","etc::endpwent()","openssl::engine::engines()","date#england()","bundler::worker#enq()","queue#enq()","sizedqueue#enq()","bundler::parallelinstaller#enqueue_specs()","bundler::parallelinstaller::specinstallation#enqueued?()","bundler::cli::common::ensure_all_gems_in_lockfile!()","gem::ensure_default_gem_subdirectories()","gem::installer#ensure_dependency()","bundler::definition#ensure_equivalent_gemfile_and_lockfile()","gem::ensure_gem_subdirectories()","gem::installer#ensure_loadable_spec()","net::imap::numvalidator::ensure_mod_sequence_value()","net::imap::numvalidator::ensure_number()","net::imap::numvalidator::ensure_nz_number()","bundler::cli::gem#ensure_safe_gem_name()","bundler::sharedhelpers#ensure_same_dependencies()","bundler::installer#ensure_specs_are_compatible!()","rss::maker::atomtextconstructbase::ensurexmlcontent#ensure_xml_content()","bundler::thor::nestedcontext#enter()","monitor#enter()","rexml::xpathparser#enter()","net::ftp::mlsxentry#enterable?()","bundler::thor::nestedcontext#entered?()","net::httpresponse#entity()","rexml::doctype#entity()","rexml::parsers::baseparser#entity()","rexml::streamlistener#entity()","rss::xmlscanlistener#entity()","rexml::parsers::pullevent#entity?()","fiddle::cstruct::entity_class()","fiddle::cunion::entity_class()","rexml::document::entity_expansion_limit()","rexml::security::entity_expansion_limit()","rexml::document::entity_expansion_limit=()","rexml::security::entity_expansion_limit=()","rexml::document::entity_expansion_text_limit()","rexml::security::entity_expansion_text_limit()","rexml::document::entity_expansion_text_limit=()","rexml::security::entity_expansion_text_limit=()","rexml::sax2listener#entitydecl()","rexml::streamlistener#entitydecl()","rexml::parsers::pullevent#entitydecl?()","dir::entries()","enumerable#entries()","pathname#entries()","range#entries()","gem::commands::querycommand#entry_details()","gem::commands::querycommand#entry_versions()","matrix#entrywise_product()","enumerator::lazy#enum_for()","object#enum_for()","bundler::cli#env()","bundler::dsl#env()","gem::env_requirement()","cgi#env_table()","bundler::environment()","bundler::env::environment()","optionparser#environment()","argf#eof()","csv#eof()","io#eof()","openssl::buffering#eof()","stringio#eof()","zlib::gzipreader#eof()","argf#eof?()","csv#eof?()","csv::parser::unoptimizedstringio#eof?()","gem::package::tarreader::entry#eof?()","io#eof?()","irb::fileinputmethod#eof?()","irb::readlineinputmethod#eof?()","irb::reidlineinputmethod#eof?()","irb::stdioinputmethod#eof?()","openssl::buffering#eof?()","stringio#eof?()","xmp::stringinputmethod#eof?()","zlib::gzipreader#eof?()","csv::parser::inputsscanner#eos?()","stringscanner#eos?()","array#eql?()","bigdecimal#eql?()","bundler::depproxy#eql?()","bundler::molinillo::dependencygraph::vertex#eql?()","bundler::plugin::api::source#eql?()","bundler::resolver::specgroup#eql?()","bundler::source::git#eql?()","bundler::source::metadata#eql?()","bundler::source::path#eql?()","bundler::source::rubygems#eql?()","bundler::uri::generic#eql?()","delegator#eql?()","enumerator::arithmeticsequence#eql?()","fiddle::pointer#eql?()","float#eql?()","gem::nametuple#eql?()","gem::platform#eql?()","gem::resolver::molinillo::dependencygraph::vertex#eql?()","gem::version#eql?()","hash#eql?()","ipaddr#eql?()","matchdata#eql?()","matrix#eql?()","method#eql?()","numeric#eql?()","object#eql?()","openssl::bn#eql?()","openssl::pkey::ec::group#eql?()","openssl::pkey::ec::point#eql?()","openssl::x509::name#eql?()","openstruct#eql?()","pathname#eql?()","rdoc::toplevel#eql?()","racc::locationpointer#eql?()","racc::state#eql?()","range#eql?()","regexp#eql?()","string#eql?()","struct#eql?()","time#eql?()","uri::generic#eql?()","unboundmethod#eql?()","vector#eql?()","basicobject#equal?()","bundler::sourcelist#equal_source?()","bundler::sourcelist#equal_sources?()","rexml::xpathparser#equality_relational_compare()","bundler::source::rubygems#equivalent_remotes?()","bundler::definition#equivalent_rubygems_remotes?()","bundler::sourcelist#equivalent_rubygems_sources?()","bundler::sourcelist#equivalent_source?()","bundler::sourcelist#equivalent_sources?()","io#erase_line()","io#erase_screen()","math::erf()","math::erfc()","systemcallerror#errno()","bundler::thor::shell::basic#error()","bundler::ui::shell#error()","bundler::ui::silent#error()","gem::mockgemui#error()","logger#error()","openssl::x509::storecontext#error()","rdoc::parser::ruby#error()","rdoc::rdoc#error()","rdoc::servlet#error()","syslog::logger#error()","webrick::basiclog#error()","logger#error!()","openssl::x509::storecontext#error=()","logger#error?()","rexml::parsers::pullevent#error?()","ripper#error?()","webrick::basiclog#error?()","webrick::httpstatus::error?()","webrick::httpstatus#error?()","encoding::invalidbytesequenceerror#error_bytes()","encoding::undefinedconversionerror#error_char()","openssl::x509::storecontext#error_depth()","bundler::persistent::net::http::persistent#error_message()","getoptlong#error_message()","drb::drbserver#error_print()","openssl::x509::storecontext#error_string()","gem::resolver::composedset#errors()","gem::resolver::installerset#errors()","openssl::errors()","bundler::persistent::net::http::persistent#escape()","bundler::uri::escape#escape()","bundler::uri::rfc2396_parser#escape()","bundler::uri::rfc2396_parser#escape()","cgi::util#escape()","gem::uriformatter#escape()","regexp::escape()","shellwords::escape()","uri::escape#escape()","uri::rfc2396_parser#escape()","uri::rfc2396_parser#escape()","webrick::accesslog#escape()","webrick::htmlutils#escape()","webrick::htmlutils::escape()","webrick::httputils#escape()","webrick::httputils#escape8bit()","cgi::util#escapeelement()","cgi::util#escapehtml()","cgi::util#escape_element()","webrick::httputils#escape_form()","bundler::thor::util::escape_globs()","bundler::thor::util::escape_html()","cgi::util#escape_html()","webrick::httputils#escape_path()","bundler::uri::generic#escape_userpass()","uri::generic#escape_userpass()","bundler::compactindexclient::updater#etag_for()","process::euid()","process::euid=()","binding#eval()","kernel#eval()","rubyvm::instructionsequence#eval()","bundler::dsl#eval_gemfile()","bundler::eval_gemspec()","irb::context#eval_history=()","irb::irb#eval_input()","tracepoint#eval_script()","bundler::eval_yaml_gemspec()","bundler::dsl::evaluate()","irb::workspace#evaluate()","webrick::httpservlet::erbhandler#evaluate()","rexml::xpathparser#evaluate_predicate()","integer#even?()","tracepoint#event()","win32ole_method#event?()","win32ole_method#event_interface()","psych::handler#event_location()","psych::treebuilder#event_location()","rexml::parsers::pullevent#event_type()","bundler::rubyversion#exact?()","gem::requirement#exact?()","net::imap#examine()","drb::drbunknown#exception()","exception#exception()","exception::exception()","timeout::error#exception()","timeout::error#exception()","timeout::error#exception()","net::smtp::response#exception_class()","rdoc::options#exclude()","enumerator::arithmeticsequence#exclude_end?()","range#exclude_end?()","thread::exclusive()","bundler::cli#exec()","kernel#exec()","process::exec()","bundler::plugin#exec_command()","gem::installer::exec_format()","irb::notifier::abstractnotifier#exec_if()","gem::specification#executable()","gem::specification#executable=()","file::executable?()","file::stat#executable?()","filetest#executable?()","pathname#executable?()","file::executable_real?()","file::stat#executable_real?()","filetest#executable_real?()","pathname#executable_real?()","bundler::endpointspecification#executables()","gem::specification#executables()","gem::specification#executables=()","gem::command#execute()","gem::commands::buildcommand#execute()","gem::commands::certcommand#execute()","gem::commands::checkcommand#execute()","gem::commands::cleanupcommand#execute()","gem::commands::contentscommand#execute()","gem::commands::dependencycommand#execute()","gem::commands::environmentcommand#execute()","gem::commands::fetchcommand#execute()","gem::commands::generateindexcommand#execute()","gem::commands::helpcommand#execute()","gem::commands::installcommand#execute()","gem::commands::lockcommand#execute()","gem::commands::mirrorcommand#execute()","gem::commands::opencommand#execute()","gem::commands::outdatedcommand#execute()","gem::commands::ownercommand#execute()","gem::commands::pristinecommand#execute()","gem::commands::pushcommand#execute()","gem::commands::querycommand#execute()","gem::commands::rdoccommand#execute()","gem::commands::servercommand#execute()","gem::commands::setupcommand#execute()","gem::commands::signincommand#execute()","gem::commands::signoutcommand#execute()","gem::commands::sourcescommand#execute()","gem::commands::specificationcommand#execute()","gem::commands::stalecommand#execute()","gem::commands::uninstallcommand#execute()","gem::commands::unpackcommand#execute()","gem::commands::updatecommand#execute()","gem::commands::whichcommand#execute()","gem::commands::yankcommand#execute()","bundler::compactindexclient#execution_mode()","bundler::compactindexclient#execution_mode=()","gem::testcase#exeext()","dir::exist?()","file::exist?()","filetest#exist?()","pathname#exist?()","stringscanner#exist?()","dir::exists?()","file::exists?()","filetest#exists?()","irb::context#exit()","kernel#exit()","monitor#exit()","process::exit()","thread#exit()","thread::exit()","kernel#exit!()","process::exit!()","bundler::thor::base::classmethods#exit_on_failure?()","bundler::friendlyerrors#exit_status()","localjumperror#exit_value()","process::status#exited?()","process::status#exitstatus()","bigmath::exp()","math::exp()","bundler::source::path#expand()","gem::pathsupport#expand()","rexml::parsers::xpathparser#expand()","rexml::text::expand()","bundler::definition#expand_dependencies()","openssl::x509::name::rfc2253dn#expand_hexstring()","openssl::x509::name::rfc2253dn#expand_pair()","file::expand_path()","pathname#expand_path()","rexml::validation::state#expand_ref_in()","rdoc::text#expand_tabs()","openssl::x509::name::rfc2253dn#expand_value()","bundler::definition#expanded_dependencies()","rexml::document#expanded_name()","bundler::source::path#expanded_original_path()","bundler::source::path#expanded_path()","bundler::dependency#expanded_platforms()","io#expect()","rexml::validation::choice#expected()","rexml::validation::interleave#expected()","rexml::validation::oneormore#expected()","rexml::validation::optional#expected()","rexml::validation::state#expected()","rexml::validation::zeroormore#expected()","bundler::persistent::net::http::persistent#expired?()","rinda::tupleentry#expired?()","webrick::cookie#expires()","webrick::cookie#expires=()","gem::resolver::conflict#explain()","gem::resolver::conflict#explanation()","gem::resolver::dependencyrequest#explicit?()","rss::basemodel#explicit_clean_other_attr_reader()","rss::basemodel#explicit_clean_other_writer()","bundler::cli::config::base#explicit_scope?()","bigdecimal#exponent()","openssl::pkey::dh#export()","openssl::pkey::dsa#export()","openssl::pkey::ec#export()","openssl::pkey::rsa#export()","rexml::xpathparser#expr()","net::imap#expunge()","bundler::rubygemsintegration#ext_lock()","object#extend()","irb::extendcommandbundle::extend_object()","module#extend_object()","monitormixin::extend_object()","optionparser::arguable::extend_object()","module#extended()","rdoc::markdown::extension()","rdoc::markdown#extension()","rdoc::markdown#extension?()","bundler::source#extension_cache_path()","bundler::source#extension_cache_slug()","bundler::source::git#extension_cache_slug()","bundler::source::rubygems#extension_cache_slug()","gem::basicspecification#extension_dir()","gem::specification#extension_dir()","bundler::source::git#extension_dir_name()","bundler::endpointspecification#extensions()","bundler::uri::ldap#extensions()","gem::specification#extensions()","openssl::ocsp::singleresponse#extensions()","openssl::x509::crl#extensions()","openssl::x509::certificate#extensions()","openssl::x509::revoked#extensions()","uri::ldap#extensions()","bundler::uri::ldap#extensions=()","gem::specification#extensions=()","openssl::x509::crl#extensions=()","openssl::x509::certificate#extensions=()","openssl::x509::revoked#extensions=()","uri::ldap#extensions=()","gem::basicspecification#extensions_dir()","fiddle::importer#extern()","argf#external_encoding()","io#external_encoding()","stringio#external_encoding()","zlib::gzipreader#external_encoding()","file::extname()","pathname#extname()","gem::command::extra_args()","gem::command::extra_args=()","gem::specification#extra_rdoc_files()","gem::specification#extra_rdoc_files=()","bundler::uri::extract()","bundler::uri::rfc2396_parser#extract()","bundler::uri::rfc2396_parser#extract()","uri::extract()","uri::rfc2396_parser#extract()","uri::rfc2396_parser#extract()","gem::installer#extract_bin()","rdoc::comment#extract_call_seq()","bundler::specset#extract_circular_gems()","gem::installer#extract_files()","gem::installer::fakepackage#extract_files()","gem::package#extract_files()","gem::package::old#extract_files()","bundler::definition#extract_gem_info()","openssl::config::extract_reference()","syslog::facility()","kernel#fail()","bundler::settings::validator::rule#fail!()","bundler::retry#fail_attempt()","bundler::parallelinstaller::specinstallation#failed?()","bundler::geminstaller#failure_message()","bundler::settings::mirror#fallback_timeout=()","rexml::functions::false()","socket::ancillarydata#family()","socket::option#family()","addrinfo#family_addrinfo()","json#fast_generate()","gdbm#fastmode=()","logger#fatal()","syslog::logger#fatal()","webrick::basiclog#fatal()","logger#fatal!()","logger#fatal?()","webrick::basiclog#fatal?()","io#fcntl()","openssl::ssl::socketforwarder#fcntl()","stringio#fcntl()","io#fdatasync()","complex#fdiv()","float#fdiv()","integer#fdiv()","numeric#fdiv()","rational#fdiv()","bundler::feature_flag()","net::ftp#features()","enumerator#feed()","rss::rootelementmixin#feed_info()","array#fetch()","bundler::fetcher::downloader#fetch()","bundler::source::git#fetch()","csv::row#fetch()","dbm#fetch()","drb::weakidconv::weakset#fetch()","env::fetch()","gdbm#fetch()","gem::request#fetch()","gem::streamui::silentdownloadreporter#fetch()","gem::streamui::threadeddownloadreporter#fetch()","hash#fetch()","net::httpheader#fetch()","net::imap#fetch()","pstore#fetch()","rinda::tuple#fetch()","rinda::tupleentry#fetch()","sdbm#fetch()","thread#fetch()","yaml::dbm#fetch()","bundler::rubygemsintegration#fetch_all_remote_specs()","bundler::connectionpool::timedstack#fetch_connection()","gem::remotefetcher#fetch_file()","bundler::source::rubygems#fetch_gem()","bundler::plugin::api::source#fetch_gemspec_files()","bundler::gemremotefetcher#fetch_http()","gem::remotefetcher#fetch_http()","gem::remotefetcher#fetch_https()","net::imap#fetch_internal()","bundler::cli::show#fetch_latest_specs()","bundler::source::rubygems#fetch_names()","gem::fakefetcher#fetch_path()","gem::remotefetcher#fetch_path()","bundler::endpointspecification#fetch_platform()","bundler::remotespecification#fetch_platform()","resolv::dns#fetch_resource()","gem::remotefetcher#fetch_s3()","gem::s3urisigner#fetch_s3_config()","drb::fetch_server()","drb#fetch_server()","gem::fakefetcher#fetch_size()","gem::remotefetcher#fetch_size()","bundler::fetcher#fetch_spec()","bundler::fetcher::compactindex#fetch_spec()","bundler::fetcher::index#fetch_spec()","gem::source#fetch_spec()","gem::source::lock#fetch_spec()","bundler::rubygemsintegration#fetch_specs()","bundler::fetcher::base#fetch_uri()","bundler::settings::mirrors#fetch_valid_mirror_for()","hash#fetch_values()","gem::remotefetcher::fetcher()","gem::specfetcher::fetcher()","gem::remotefetcher::fetcher=()","bundler::fetcher#fetchers()","bundler::source::rubygems#fetchers()","csv::row#field()","csv::row#field?()","csv::row#field_row?()","csv#field_size_limit()","csv::parser#field_size_limit()","csv::row#fields()","argf#file()","digest::class::file()","digest::instance#file()","file::file?()","file::stat#file?()","filetest#file?()","gem::package::tarreader::entry#file?()","net::ftp::mlsxentry#file?()","pathname#file?()","bundler::thor::shell::basic#file_collision()","cgi::htmlextension#file_field()","irb::context#file_input?()","gem::specification#file_name()","rdoc::codeobject#file_name()","argf#filename()","ripper#filename()","ripper::filter#filename()","readline::filename_quote_characters()","readline::filename_quote_characters=()","reline::core#filename_quote_characters=()","argf#fileno()","dir#fileno()","io#fileno()","stringio#fileno()","gem::specification#files()","gem::specification#files=()","rdoc::store#files_hash()","gem::commands::contentscommand#files_in()","gem::commands::contentscommand#files_in_default_gem()","gem::commands::contentscommand#files_in_gem()","bundler::sharedhelpers#filesystem_access()","array#fill()","date#fill()","prettyprint#fill_breakable()","openssl::buffering#fill_rbuff()","array#filter()","bundler::uri::ldap#filter()","csv::filter()","env::filter()","enumerable#filter()","enumerator::lazy#filter()","hash#filter()","rexml::quickpath::filter()","struct#filter()","uri::ldap#filter()","array#filter!()","env::filter!()","gem::bundlerversionfinder::filter!()","hash#filter!()","set#filter!()","bundler::uri::ldap#filter=()","uri::ldap#filter=()","irb::workspace#filter_backtrace()","optionparser::parseerror::filter_backtrace()","bundler::gemversionpromoter#filter_dep_specs()","enumerable#filter_map()","enumerator::lazy#filter_map()","rexml::xpathparser#filter_nodeset()","bundler::molinillo::resolver::resolution#filter_possibilities_after_unwind()","bundler::molinillo::resolver::resolution#filter_possibilities_for_parent_unwind()","bundler::molinillo::resolver::resolution#filter_possibilities_for_primary_unwind()","bundler::httperror#filter_uri()","bundler::molinillo::resolver::resolution#filtered_possibility_set()","bundler::cli::list#filtered_specs_by_groups()","openssl::cipher#final()","encoding::find()","enumerable#find()","find::find()","find#find()","irb::locale#find()","pathname#find()","psych::classloader::restricted#find()","rinda::tuplebag#find()","rinda::tuplebag::tuplebin#find()","gem::specification::find_active_stub_by_path()","gem::commandmanager#find_alias_command()","rdoc::parser::c#find_alias_comment()","enumerable#find_all()","enumerator::lazy#find_all()","gem::availableset#find_all()","gem::resolver::apiset#find_all()","gem::resolver::composedset#find_all()","gem::resolver::currentset#find_all()","gem::resolver::gitset#find_all()","gem::resolver::indexset#find_all()","gem::resolver::installerset#find_all()","gem::resolver::lockset#find_all()","gem::resolver::set#find_all()","gem::resolver::vendorset#find_all()","gem::testcase::staticset#find_all()","rinda::tuplebag#find_all()","gem::specification::find_all_by_full_name()","gem::specification::find_all_by_name()","gem::specification#find_all_satisfiers()","rinda::tuplebag#find_all_template()","rdoc::classmodule#find_ancestor_local_symbol()","rdoc::parser::c#find_attr_comment()","rdoc::context#find_attribute()","rdoc::context#find_attribute_named()","rdoc::parser::c#find_body()","gem::specification::find_by_name()","bundler::specset#find_by_name_and_platform()","bundler::thor::util::find_by_namespace()","gem::specification::find_by_path()","rdoc::store#find_c_enclosure()","rdoc::parser::c#find_class()","bundler::thor::util::find_class_and_command_by_namespace()","bundler::thor::util::find_class_and_task_by_namespace()","rdoc::parser::c#find_class_comment()","rdoc::context#find_class_method_named()","rdoc::classmodule#find_class_named()","rdoc::store#find_class_named()","rdoc::store#find_class_named_from()","rdoc::store#find_class_or_module()","rdoc::toplevel#find_class_or_module()","gem::commandmanager#find_command()","bundler::thor::find_command_possibilities()","gem::commandmanager#find_command_possibilities()","rdoc::parser::c#find_const_comment()","rdoc::context#find_constant_named()","gem::fakefetcher#find_data()","bundler::sharedhelpers#find_directory()","rdoc::context#find_enclosing_module_named()","rexml::encoding#find_encoding()","makemakefile#find_executable()","rdoc::context#find_external_alias()","rdoc::context#find_external_alias_named()","bundler::sharedhelpers#find_file()","rdoc::context#find_file_named()","rdoc::store#find_file_named()","gem::find_files()","gem::validator#find_files_for_gem()","rexml::node#find_first_recursive()","gem::source::local#find_gem()","bundler::sharedhelpers#find_gemfile()","gem::commands::buildcommand#find_gemspec()","makemakefile#find_header()","gem::find_home()","gem::commands::unpackcommand#find_in_cache()","bundler::thor::actions#find_in_source_paths()","gem::specification::find_in_unresolved()","gem::specification::find_in_unresolved_tree()","gem::specification::find_inactive_by_path()","array#find_index()","enumerable#find_index()","matrix#find_index()","bundler::definition#find_indexed_specs()","rdoc::context#find_instance_method_named()","gem::find_latest_files()","makemakefile#find_library()","bundler::source::git::gitproxy#find_local_revision()","rdoc::context#find_local_symbol()","rdoc::toplevel#find_local_symbol()","rdoc::context#find_method()","rdoc::context#find_method_named()","rdoc::parser::c#find_modifiers()","rdoc::context#find_module_named()","rdoc::store#find_module_named()","rdoc::toplevel#find_module_named()","bundler::rubygemsintegration#find_name()","gem::dependencylist#find_name()","rdoc::parser::c#find_override_comment()","gem::commands::whichcommand#find_paths()","bundler::uri::generic#find_proxy()","uri::generic#find_proxy()","bundler::definition#find_resolved_spec()","openssl::ocsp::basicresponse#find_response()","gem::testcase::staticset#find_spec()","gem::dependencyinstaller#find_spec_by_name_and_version()","gem::find_spec_for_exe()","bundler::molinillo::resolver::resolution#find_state_for()","gem::resolver::molinillo::resolver::resolution#find_state_for()","rdoc::context#find_symbol()","rdoc::context#find_symbol_module()","bundler::thor::find_task_possibilities()","rdoc::store#find_text_page()","makemakefile#find_type()","rdoc::store#find_unique()","gem::find_unresolved_default_spec()","rinda::ringfinger::finger()","racc::states#fingerprint()","bundler::persistent::net::http::persistent#finish()","digest::instance#finish()","encoding::converter#finish()","net::http#finish()","net::pop3#finish()","net::smtp#finish()","openssl::digest#finish()","openssl::engine#finish()","psych::visitors::yamltree#finish()","rdoc::options#finish()","zlib::gzipfile#finish()","zlib::zstream#finish()","rdoc::options#finish_page_dir()","gem::finish_resolve()","zlib::zstream#finished?()","bundler::parallelinstaller#finished_installing?()","bigdecimal#finite?()","complex#finite?()","float#finite?()","numeric#finite?()","openssl::fips_mode()","openssl::fips_mode=()","array#first()","enumerable#first()","enumerator::arithmeticsequence#first()","gem::sourcelist#first()","rexml::quickpath::first()","rexml::xpath::first()","rexml::xpathparser#first()","range#first()","prettyprint::singleline#first?()","rubyvm::abstractsyntaxtree::node#first_column()","rubyvm::abstractsyntaxtree::node#first_lineno()","rubyvm::instructionsequence#first_lineno()","matrix#first_minor()","bigdecimal#fix()","racc::symboltable#fix()","rdoc::store#fix_basic_object_inheritance()","racc::grammar#fix_ident()","racc::symboltable#fix_ident()","stringscanner#fixed_anchor?()","regexp#fixed_encoding?()","gem::resolver::molinillo::resolver::resolution#fixup_swapped_children()","socket::ifaddr#flags()","openssl::x509::store#flags=()","openssl::x509::storecontext#flags=()","bundler::molinillo::compatibility#flat_map()","enumerable#flat_map()","enumerator::lazy#flat_map()","array#flatten()","hash#flatten()","set#flatten()","array#flatten!()","set#flatten!()","csv#flock()","file#flock()","bigdecimal#floor()","float#floor()","integer#floor()","numeric#floor()","rexml::functions::floor()","rational#floor()","time#floor()","gem::package::tarwriter#flush()","io#flush()","openssl::buffering#flush()","prettyprint#flush()","stringio#flush()","webrick::httpauth::htdigest#flush()","webrick::httpauth::htgroup#flush()","webrick::httpauth::htpasswd#flush()","zlib::deflate#flush()","zlib::gzipwriter#flush()","net::httpgenericrequest#flush_buffer()","racc::grammar::definitionenv#flush_delayed()","rdoc::text#flush_left()","zlib::zstream#flush_next_in()","zlib::zstream#flush_next_out()","openssl::ssl::sslcontext#flush_sessions()","file::fnmatch()","pathname#fnmatch()","file::fnmatch?()","pathname#fnmatch?()","rexml::xpathparser#following()","rexml::xpathparser#following_node_of()","racc::parserfilegenerator#footer()","bundler::settings::mirrors#for()","bundler::specset#for()","bundler::versionranges::for()","rdoc::parser::for()","bundler::resolver::specgroup#for?()","gem::specification#for_cache()","gem::resolver::for_current_gems()","basicsocket::for_fd()","io::for_fd()","bundler::versionranges::for_many()","gem::installer::for_spec()","gem::resolver::conflict#for_spec?()","enumerator::lazy#force()","rdoc::codeobject#force_documentation=()","string#force_encoding()","csv#force_quotes?()","time::force_zone!()","addrinfo::foreach()","csv::foreach()","dir::foreach()","io::foreach()","net::pop3::foreach()","kernel#fork()","process::fork()","thread::fork()","cgi::htmlextension#form()","net::httpheader#form_data=()","benchmark::tms#format()","irb::locale#format()","kernel#format()","prettyprint::format()","webrick::accesslog#format()","webrick::basiclog#format()","rdoc::comment#format=()","net::imap::format_date()","net::imap::format_datetime()","logger#format_message()","logger#format_severity()","gem::text#format_text()","gem::noaliasyamltree#format_time()","psych::visitors::yamltree#format_time()","gem::installer#formatted_program_filename()","bundler::thor::command#formatted_usage()","bundler::thor::command#formatted_usage()","bundler::resolver#formatted_versions_with_platforms()","didyoumean::formatter()","didyoumean::formatter=()","bigdecimal#frac()","bundler::uri::generic#fragment=()","uri::generic#fragment=()","fiddle::free()","fiddle::pointer#free()","fiddle::pointer#free=()","delegator#freeze()","env::freeze()","gem::version#freeze()","matrix#freeze()","module#freeze()","object#freeze()","openssl::ssl::sslcontext#freeze()","openstruct#freeze()","pathname#freeze()","string#freeze()","vector#freeze()","math::frexp()","date#friday?()","time#friday?()","rdoc::store#friendly_path()","gem::package::tarheader::from()","gem::sourcelist::from()","gem::requestset::lockfile::tokenizer::from_file()","json::genericobject::from_hash()","gem::nametuple::from_list()","bundler::source::git::from_lock()","bundler::source::path::from_lock()","bundler::source::rubygems::from_lock()","rdoc::classmodule::from_module()","process::gid::from_name()","process::uid::from_name()","integer::from_prime_division()","gem::dependencylist::from_specs()","json::ext::generator::state::from_state()","bundler::rubyversion::from_string()","bundler::stubspecification::from_stub()","bundler::thor::base::classmethods#from_superclass()","gem::specification::from_yaml()","drb#front()","drb::front()","drb::extserv#front()","object#frozen?()","bundler::frozen_bundle?()","io#fsync()","stringio#fsync()","file::ftype()","file::stat#ftype()","pathname#ftype()","bundler::fileutils::streamutils_#fu_blksize()","fileutils::streamutils_#fu_blksize()","bundler::fileutils::streamutils_#fu_default_blksize()","fileutils::streamutils_#fu_default_blksize()","bundler::fileutils::streamutils_#fu_stream_blksize()","fileutils::streamutils_#fu_stream_blksize()","bundler::fileutils::streamutils_#fu_windows?()","fileutils::streamutils_#fu_windows?()","bundler::stubspecification#full_gem_path()","gem::basicspecification#full_gem_path()","gem::specification#full_gem_path()","exception#full_message()","bundler::lazyspecification#full_name()","bundler::remotespecification#full_name()","gem::basicspecification#full_name()","gem::nametuple#full_name()","gem::package::tarreader::entry#full_name()","gem::resolver::activationrequest#full_name()","gem::resolver::specspecification#full_name()","gem::resolver::specification#full_name()","gem::specification#full_name()","rdoc::classmodule#full_name()","rdoc::constant#full_name()","rdoc::context#full_name()","rdoc::methodattr#full_name()","rdoc::mixin#full_name()","rdoc::toplevel#full_name()","rss::element#full_name()","rss::ituneschannelmodel::itunescategory#full_name()","rss::ituneschannelmodel::itunesimage#full_name()","rss::ituneschannelmodel::itunesowner#full_name()","rss::itunesitemmodel::itunesduration#full_name()","rss::imagefaviconmodel::imagefavicon#full_name()","rss::imageitemmodel::imageitem#full_name()","rss::rdf#full_name()","rss::rdf::bag#full_name()","rss::rdf::bag#full_name()","rss::rdf::li#full_name()","rss::rdf::li#full_name()","rss::rdf::li#full_name()","rss::rdf::seq#full_name()","rss::rdf::seq#full_name()","rss::taxonomytopicmodel::taxonomytopic#full_name()","rss::taxonomytopicsmodel::taxonomytopics#full_name()","rss::xml::element#full_name()","rdoc::codeobject#full_name=()","rdoc::alias#full_old_name()","bundler::stubspecification#full_require_paths()","gem::basicspecification#full_require_paths()","gem::resolver::activationrequest#full_spec()","bundler::source::git::gitproxy#full_version()","rdoc::context#fully_documented?()","rdoc::stats#fully_documented?()","rexml::namespace#fully_expanded_name()","rexml::quickpath::function()","bundler::graph::graphvizclient#g()","math::gamma()","gc#garbage_collect()","objectspace#garbage_collect()","objectspace::garbage_collect()","rdoc::rdoc#gather_files()","integer#gcd()","openssl::bn#gcd()","integer#gcdlcm()","bundler::cli#gem()","bundler::dsl#gem()","gem::requestset#gem()","gem::requestset::gemdependencyapi#gem()","gem::testcase::specfetchersetup#gem()","kernel#gem()","bundler::rubygemsintegration#gem_bindir()","bundler::rubygemsintegration#gem_cache()","bundler::gemhelper#gem_command()","gem::commands::contentscommand#gem_contents()","bundler::rubygemsintegration#gem_dir()","gem::basicspecification#gem_dir()","gem::installer#gem_dir()","gem::specification#gem_dir()","gem::indexer#gem_file_list()","bundler::rubygemsintegration#gem_from_path()","bundler::plugin::api::source#gem_install_dir()","gem::commands::contentscommand#gem_install_dir()","bundler::geminstaller#gem_install_message()","bundler::gemhelper#gem_key()","bundler::settings#gem_mirrors()","gem::commands::querycommand#gem_name?()","bundler::cli::common::gem_not_found_message()","kernel#gem_original_require()","bundler::rubygemsintegration#gem_path()","bundler::standalone#gem_path()","bundler::dependency#gem_platforms()","bundler::gemhelper#gem_push?()","bundler::gemhelper#gem_push_host()","bundler::rubygemsintegration#gem_remote_fetcher()","gem::doctor#gem_repository?()","bundler::definition#gem_version_promoter()","bundler::cli::init#gemfile()","object#gemfile()","bundler::plugin#gemfile_install()","bundler::sharedhelpers#gemfile_names()","bundler::dsl#gemfile_root()","gem::basicspecification#gems_dir()","gem::specification#gems_dir()","bundler::cli::install#gems_installed_for()","bundler::dsl#gemspec()","bundler::gemhelper::gemspec()","gem::requestset::gemdependencyapi#gemspec()","bundler::fetcher#gemspec_cached_path()","bundler::fetcher::index#gemspec_cached_path()","gem::specification::gemspec_stubs_in()","racc::statetransitiontablegenerator#gen_action_tables()","rdoc::parser::c#gen_body_table()","rdoc::parser::c#gen_const_table()","racc::statetransitiontablegenerator#gen_goto_tables()","random::formatter#gen_random()","securerandom::gen_random()","securerandom::gen_random_openssl()","securerandom::gen_random_urandom()","bundler::lockfilegenerator::generate()","bundler::standalone#generate()","csv::generate()","json#generate()","json::ext::generator::state#generate()","openssl::pkey::dh::generate()","openssl::pkey::dsa::generate()","openssl::pkey::ec::generate()","openssl::pkey::rsa::generate()","rdoc::rdoc#generate()","rdoc::rubygemshook#generate()","rdoc::rubygemshook#generate()","racc::parserclassgenerator#generate()","racc::statetransitiontable::generate()","racc::statetransitiontablegenerator#generate()","bundler::lockfilegenerator#generate!()","bundler::plugin::installer::git#generate_bin()","bundler::source::path#generate_bin()","bundler::source::path::installer#generate_bin()","gem::installer#generate_bin_script()","gem::installer#generate_bin_symlink()","bundler::installer#generate_bundler_executable_stubs()","gem::s3urisigner#generate_canonical_query_params()","gem::s3urisigner#generate_canonical_request()","gem::commands::setupcommand#generate_default_dirs()","rexml::validation::state#generate_event()","bundler::geminstaller#generate_executable_stubs()","gem::indexer#generate_index()","openssl::pkey::ec#generate_key()","openssl::pkey::dh#generate_key!()","openssl::pkey::ec#generate_key!()","csv::generate_line()","racc::parserfilegenerator#generate_parser()","racc::parserfilegenerator#generate_parser_file()","openssl::bn::generate_prime()","gem::s3urisigner#generate_signature()","bundler::installer#generate_standalone_bundler_executable_stubs()","racc::states#generate_states()","gem::s3urisigner#generate_string_to_sign()","net::imap#generate_tag()","gem::installer#generate_windows_script()","rdoc::rubygemshook::generation_hook()","rdoc::rubygemshook::generation_hook()","openssl::pkey::ec::group#generator()","rdoc::options#generator_descriptions()","rdoc::servlet#generator_for()","bundler::gemhelpers#generic()","bundler::gemhelpers::generic()","bundler::gemhelpers#generic_local_platform()","bundler::gemhelpers::generic_local_platform()","bundler::cli::config#get()","bundler::sourcelist#get()","bundler::thor::actions#get()","getoptlong#get()","net::ftp#get()","net::http::get()","net::http#get()","net::http#get2()","gem::command#get_all_gem_names()","gem::command#get_all_gem_names_and_versions()","rexml::attributes#get_attribute()","rexml::attributes#get_attribute_ns()","rss::element::get_attributes()","rdoc::parser::ruby#get_bool()","stringscanner#get_byte()","gem::commands::cleanupcommand#get_candidate_gems()","optionparser::list#get_candidates()","gem::request::get_cert_files()","rdoc::parser::ruby#get_class_or_module()","rdoc::parser::ruby#get_class_specification()","bundler::cli::console#get_console()","bundler::cli::console#get_constant()","rdoc::parser::ruby#get_constant()","openssl::config::get_definition()","rexml::element#get_elements()","rdoc::parser::ripperstatelex#get_embdoc_tk()","gem::commands::opencommand#get_env_editor()","net::httpheader#get_fields()","rss::utils#get_file_and_line_from_caller()","rexml::xpathparser#get_first()","bundler::fetcher::dependency#get_formatted_specs_and_deps()","gem::commands::cleanupcommand#get_gems_to_cleanup()","rexml::parsers::xpathparser#get_group()","rdoc::parser::ripperstatelex#get_heredoc_tk()","gem::commands::pushcommand#get_hosts_for()","rdoc::parser::ruby#get_included_module_with_optional_parens()","bundler::thor::lineeditor::basic#get_input()","webrick::httpservlet::abstractservlet::get_instance()","openssl::config#get_key_string()","openssl::config::get_line()","rexml::parsers::sax2parser#get_listeners()","rexml::functions::get_namespace()","rexml::parsers::sax2parser#get_namespace()","rexml::xpathparser#get_namespace()","prime::eratosthenessieve#get_nth_prime()","gem::command#get_one_gem_name()","gem::command#get_one_optional_argument()","rdoc::parser::ripperstatelex#get_op_tk()","getoptlong#get_option()","gem::gemcutterutilities#get_otp()","webrick::httpauth::htdigest#get_passwd()","webrick::httpauth::htpasswd#get_passwd()","webrick::httpauth::userdb#get_passwd()","gem::commands::unpackcommand#get_path()","gem::commands::yankcommand#get_platform_from_requirements()","gem::commands::cleanupcommand#get_primary_gems()","net::http::get_print()","rexml::parsers::sax2parser#get_procs()","gem::request::get_proxy_from_env()","racc::grammarfilescanner#get_quoted_re()","rdoc::parser::ripperstatelex#get_regexp_tk()","gem::ext::extconfbuilder::get_relative_path()","rinda::tupleentry#get_renewer()","net::http::get_response()","net::imap#get_response()","net::smtp#get_response()","readline::get_screen_size()","reline::core#get_screen_size()","gem::resolver::sourceset#get_set()","rdoc::parser::ripperstatelex#get_squashed_tk()","rdoc::parser::ripperstatelex#get_string_tk()","rdoc::parser::ruby#get_symbol_or_name()","rdoc::parser::ripperstatelex#get_symbol_tk()","net::imap#get_tagged_response()","rexml::element#get_text()","debugger__::get_thread()","bundler::connectionpool#get_time()","rdoc::parser::rubytools#get_tk()","rdoc::parser::rubytools#get_tk_until()","rdoc::parser::rubytools#get_tkread()","openssl::config#get_value()","gem::commands::yankcommand#get_version_from_requirements()","bundler::cli::outdated#get_version_semver_portion_value()","rdoc::parser::ripperstatelex#get_words_tk()","net::imap#getacl()","ipsocket::getaddress()","resolv#getaddress()","resolv::getaddress()","resolv::dns#getaddress()","resolv::hosts#getaddress()","ipsocket::getaddress_orig()","resolv#getaddresses()","resolv::getaddresses()","resolv::dns#getaddresses()","resolv::hosts#getaddresses()","addrinfo::getaddrinfo()","socket::getaddrinfo()","net::ftp#getbinaryfile()","argf#getbyte()","io#getbyte()","string#getbyte()","stringio#getbyte()","stringscanner#getbyte()","zlib::gzipreader#getbyte()","argf#getc()","gem::package::tarreader::entry#getc()","io#getc()","openssl::buffering#getc()","stringio#getc()","zlib::gzipreader#getc()","io#getch()","io::generic_readable#getch()","stringscanner#getch()","net::ftp#getdir()","process::sys::getegid()","process::sys::geteuid()","process::sys::getgid()","time#getgm()","etc::getgrent()","etc::getgrgid()","etc::getgrnam()","socket::gethostbyaddr()","socket::gethostbyname()","tcpsocket::gethostbyname()","socket::gethostname()","socket::getifaddrs()","time#getlocal()","etc::getlogin()","resolv::getname()","resolv#getname()","resolv::dns#getname()","resolv::hosts#getname()","addrinfo#getnameinfo()","socket::getnameinfo()","resolv#getnames()","resolv::getnames()","resolv::dns#getnames()","resolv::hosts#getnames()","net::smtp#getok()","optionparser#getopts()","optionparser::getopts()","optionparser::arguable#getopts()","io#getpass()","io::generic_readable#getpass()","basicsocket#getpeereid()","basicsocket#getpeername()","process::getpgid()","process::getpgrp()","process::getpriority()","pty::getpty()","etc::getpwent()","etc::getpwnam()","etc::getpwuid()","net::imap#getquota()","net::imap#getquotaroot()","resolv::dns#getresource()","resolv::dns#getresources()","process::getrlimit()","argf#gets()","csv#gets()","csv::parser::unoptimizedstringio#gets()","io#gets()","irb::fileinputmethod#gets()","irb::inputmethod#gets()","irb::locale#gets()","irb::readlineinputmethod#gets()","irb::reidlineinputmethod#gets()","irb::stdioinputmethod#gets()","kernel#gets()","openssl::buffering#gets()","stringio#gets()","xmp::stringinputmethod#gets()","zlib::gzipreader#gets()","socket::getservbyname()","socket::getservbyport()","webrick::utils#getservername()","webrick::utils::getservername()","process::getsid()","basicsocket#getsockname()","basicsocket#getsockopt()","openssl::ssl::socketforwarder#getsockopt()","rss::baselistener::getter()","net::ftp#gettextfile()","process::sys::getuid()","time#getutc()","bundler::fileutils::getwd()","bundler::fileutils#getwd()","dir::getwd()","fileutils::getwd()","fileutils#getwd()","pathname::getwd()","file::stat#gid()","process::gid()","process::gid=()","bundler::dsl#git()","bundler::source::git::gitproxy#git()","gem::requestset::gemdependencyapi#git()","bundler::buildmetadata::git_commit_sha()","gem::testcase#git_gem()","bundler::source::git::gitproxy#git_null()","gem::commands::environmentcommand#git_path()","bundler::git_present?()","bundler::source::git#git_proxy()","bundler::gemhelper#git_push()","bundler::source::git::gitproxy#git_retry()","bundler::source::git#git_scope()","bundler::dsl#git_source()","gem::requestset::gemdependencyapi#git_source()","bundler::env::git_version()","bundler::lazyspecification#git_version()","bundler::remotespecification#git_version()","gem::specification#git_version()","bundler::dsl#github()","rdoc::markdown#github()","dir::glob()","pathname#glob()","pathname::glob()","gem::util::glob_files_in_dir()","bundler::thor::lineeditor::readline::pathcompletion#glob_pattern()","bundler::settings#global_config_file()","bundler::plugin::index#global_index_file()","bundler::plugin#global_root()","bundler::sourcelist#global_rubygems_source=()","kernel#global_variables()","bundler::thor::util::globs_for()","time::gm()","time#gmt?()","time#gmt_offset()","time#gmtime()","time#gmtoff()","io#goto()","io#goto_column()","racc::shift#goto_id()","racc::grammar::definitionenv#grammar()","process::gid::grant_privilege()","process::uid::grant_privilege()","string#grapheme_clusters()","rdoc::stats#great_job()","date#gregorian()","date#gregorian?()","date::gregorian_leap?()","enumerable#grep()","enumerator::lazy#grep()","enumerable#grep_v()","enumerator::lazy#grep_v()","bundler::dsl#group()","bundler::thor::base::classmethods#group()","etc::group()","gem::requestset::gemdependencyapi#group()","openssl::pkey::ec#group()","prettyprint#group()","prettyprint::singleline#group()","thread#group()","openssl::pkey::ec#group=()","enumerable#group_by()","rdoc::parser::changelog#group_entries()","bundler::molinillo::resolver::resolution#group_possibilities()","prettyprint#group_sub()","bundler::definition#groups()","gem::specification#groups()","process::groups()","process::groups=()","bundler::cli::outdated#groups_text()","file::grpowned?()","file::stat#grpowned?()","filetest#grpowned?()","pathname#grpowned?()","kernel#gsub()","string#gsub()","string#gsub!()","bundler::thor::actions#gsub_file()","bundler::gemhelper#guard_clean()","pp::ppmethods#guard_inspect_key()","kconv#guess()","kconv::guess()","nkf::guess()","optionparser::switch::guess()","rss::xmlstylesheet#guess_type()","rss::maker::xmlstylesheets::xmlstylesheet#guess_type_if_need()","win32ole_type#guid()","win32ole_typelib#guid()","gem::gunzip()","gem::util::gunzip()","zlib::gunzip()","gem::gzip()","gem::indexer#gzip()","gem::util::gzip()","zlib::gzip()","gem::package#gzip_to()","cgi::util#h()","erb::util::h()","erb::util#h()","rss::utils#h()","matrix#hadamard_product()","rexml::parsers::sax2parser#handle()","bundler::thor::command#handle_argument_error?()","bundler::thor::command#handle_argument_error?()","gem::configfile#handle_arguments()","rdoc::parser::c#handle_attr()","rdoc::parser::c#handle_class_module()","rdoc::parser::c#handle_constants()","rexml::parsers::sax2parser#handle_entitydecl()","bundler::parallelinstaller#handle_error()","irb::irb#handle_exception()","rdoc::parser::c#handle_ifdefs_in()","thread::handle_interrupt()","rdoc::parser::c#handle_method()","bundler::molinillo::resolver::resolution#handle_missing_or_push_dependency_state()","gem::resolver::molinillo::resolver::resolution#handle_missing_or_push_dependency_state()","bundler::cli::handle_no_command_error()","bundler::thor::command#handle_no_method_error?()","bundler::thor::command#handle_no_method_error?()","gem::command#handle_options()","rdoc::rdoc#handle_pipe()","rdoc::parser::c#handle_singleton()","rdoc::parser::c#handle_tab_width()","fiddle::importer#handler()","win32ole_event#handler()","win32ole_event#handler=()","fiddle::compositehandler#handlers()","gem::command#handles?()","bundler::source::git#has_app_cache?()","bundler::source::path#has_app_cache?()","rexml::element#has_attributes?()","gem::specification#has_conflicts?()","rexml::element#has_elements?()","rinda::tuplebag#has_expires?()","cgi::queryextension#has_key?()","csv::row#has_key?()","dbm#has_key?()","env::has_key?()","gdbm#has_key?()","hash#has_key?()","sdbm#has_key?()","bundler::definition#has_local_dependencies?()","rexml::light::node#has_name?()","rexml::namespace#has_name?()","rexml::parsers::baseparser#has_next?()","bundler::parallelinstaller::specinstallation#has_post_install_message?()","bundler::source::git::gitproxy#has_revision_cached?()","bundler::definition#has_rubygems_remotes?()","rexml::element#has_text?()","dbm#has_value?()","env::has_value?()","gdbm#has_value?()","hash#has_value?()","sdbm#has_value?()","yaml::dbm#has_value?()","array#hash()","bigdecimal#hash()","bundler::depproxy#hash()","bundler::molinillo::dependencygraph::vertex#hash()","bundler::plugin::api::source#hash()","bundler::resolver::specgroup#hash()","bundler::source::git#hash()","bundler::source::metadata#hash()","bundler::source::path#hash()","bundler::source::rubygems#hash()","bundler::uri::generic#hash()","enumerator::arithmeticsequence#hash()","float#hash()","gem::nametuple#hash()","gem::platform#hash()","gem::resolver::molinillo::dependencygraph::vertex#hash()","hash#hash()","ipaddr#hash()","matchdata#hash()","matrix#hash()","method#hash()","object#hash()","openssl::bn#hash()","openssl::x509::name#hash()","openstruct#hash()","proc#hash()","rdoc::toplevel#hash()","rexml::attribute#hash()","range#hash()","regexp#hash()","string#hash()","struct#hash()","time#hash()","uri::generic#hash()","unboundmethod#hash()","vector#hash()","racc::rule#hash=()","rinda::tuple#hash?()","openssl::ocsp::certificateid#hash_algorithm()","openssl::x509::name#hash_old()","rss::atom::entry#have_author?()","rss::atom::feed#have_author?()","rss::atom::feed::entry#have_author?()","rss::atom::feed::entry::source#have_author?()","rss::element::have_children_elements()","makemakefile#have_const()","rss::element::have_content?()","makemakefile#have_devel?()","gem::basicspecification#have_extensions?()","gem::basicspecification#have_file?()","makemakefile#have_framework()","makemakefile#have_func()","gem::testcase#have_git?()","makemakefile#have_header()","makemakefile#have_library()","makemakefile#have_macro()","bundler::fileutils::have_option?()","fileutils::have_option?()","gem::server#have_rdoc_4_plus?()","rss::atom::entry#have_required_elements?()","rss::atom::feed#have_required_elements?()","rss::atom::feed::entry#have_required_elements?()","rss::element#have_required_elements?()","rss::maker::atom::feed::channel#have_required_values?()","rss::maker::atom::feed::items::item#have_required_values?()","rss::maker::base#have_required_values?()","rss::maker::ituneschannelmodel::itunescategoriesbase::itunescategorybase#have_required_values?()","rss::maker::imagefaviconmodel::imagefaviconbase#have_required_values?()","rss::maker::imageitemmodel::imageitembase#have_required_values?()","rss::maker::rss10::image#have_required_values?()","rss::maker::rss10::textinput#have_required_values?()","rss::maker::taxonomytopicmodel::taxonomytopicsbase::taxonomytopicbase#have_required_values?()","rss::maker::trackbackmodel::trackbackaboutsbase::trackbackaboutbase#have_required_values?()","makemakefile#have_struct_member()","makemakefile#have_type()","makemakefile#have_var()","rss::atom::feed::entry::content#have_xml_content?()","rss::atom::textconstruct#have_xml_content?()","rss::element#have_xml_content?()","net::http#head()","net::http#head2()","racc::locationpointer#head?()","cgi#header()","gem::package::tarheader#header()","gem::package::tartestcase#header()","net::popmail#header()","racc::parserfilegenerator#header()","csv::row#header?()","csv#header_convert()","csv#header_converters()","csv#header_fields_converter()","bundler::cli::outdated#header_group_message()","bundler::cli::outdated#header_outdated_message()","csv#header_row?()","csv::parser#header_row?()","csv::row#header_row?()","csv#headers()","csv::parser#headers()","csv::row#headers()","csv::table#headers()","bundler::uri::mailto#headers=()","uri::mailto#headers=()","net::smtp#helo()","bundler::cli#help()","bundler::thor::help()","bundler::thor#help()","bundler::thor::group::help()","net::ftp#help()","optionparser#help()","win32ole_method#helpcontext()","win32ole_type#helpcontext()","win32ole_method#helpfile()","win32ole_type#helpfile()","win32ole_method#helpstring()","win32ole_type#helpstring()","drb#here?()","drb::here?()","drb::drbserver#here?()","rdoc::parser::ripperstatelex#heredoc_end?()","matrix#hermitian?()","matrix::eigenvaluedecomposition#hessenberg_to_real_schur()","random::formatter#hex()","string#hex()","digest::class::hexdigest()","digest::instance#hexdigest()","openssl::hmac::hexdigest()","openssl::hmac#hexdigest()","bundler::rubygemsgeminstaller#hexdigest!()","digest::instance#hexdigest!()","digest::hexencode()","cgi::htmlextension#hidden()","bundler::thor::command#hidden?()","bundler::thor::command#hidden?()","bundler::thor::hiddencommand#hidden?()","bundler::thor::hiddencommand#hidden?()","bundler::uri::generic#hierarchical?()","bundler::uri::ldap#hierarchical?()","uri::generic#hierarchical?()","uri::ldap#hierarchical?()","racc::grammar::precedencedefinitionenv#higher()","irb::context#history_file()","irb::context#history_file=()","openssl::kdf::hkdf()","net::imap::crammd5authenticator#hmac_md5()","bundler::home()","dir::home()","irb::context#home_workspace()","bundler::plugin#hook()","bundler::plugin::api::hook()","bundler::plugin::index#hook_plugins()","bundler::rubyversion#host()","gem::host()","gem::gemcutterutilities#host()","webrick::httprequest#host()","bundler::uri::generic#host=()","gem::host=()","uri::generic#host=()","bundler::uri::generic#hostname()","uri::generic#hostname()","bundler::uri::generic#hostname=()","openssl::ssl::sslsocket#hostname=()","uri::generic#hostname=()","date#hour()","datetime#hour()","time#hour()","rss::itunesitemmodel::itunesduration#hour=()","rss::maker::itunesitemmodel::itunesdurationbase#hour=()","rss::xmlstylesheet#href=()","matrix::hstack()","matrix#hstack()","cgi::htmlextension#html()","rdoc::markdown#html()","erb::util::html_escape()","erb::util#html_escape()","rss::utils#html_escape()","rdoc::alias#html_name()","rdoc::methodattr#html_name()","ipaddr#hton()","net::http::http_default_port()","cgi#http_header()","bundler::fetcher#http_proxy()","rdoc::context#http_url()","rdoc::toplevel#http_url()","bundler::persistent::net::http::persistent#http_version()","date::httpdate()","date#httpdate()","datetime::httpdate()","time::httpdate()","time#httpdate()","cgi::cookie#httponly=()","gem::remotefetcher#https?()","net::http::https_default_port()","math::hypot()","numeric#i()","racc::parserfilegenerator#i_i_sym_list()","rss::maker::channelbase#icon()","rss::maker::channelbase#icon=()","json::iconv()","openssl::engine#id()","openssl::ssl::session#id()","rexml::functions::id()","symbol#id2name()","bundler::persistent::net::http::persistent#idempotent?()","syslog::ident()","bundler::fileutils#identical?()","bundler::fileutils::identical?()","file::identical?()","filetest#identical?()","fileutils::identical?()","fileutils#identical?()","bundler::lazyspecification#identifier()","gem::dependency#identity()","matrix::identity()","net::imap#idle()","net::imap#idle_done()","rdoc::servlet#if_modified_since()","socket::ifaddr#ifindex()","io#iflush()","bundler::parallelinstaller::specinstallation#ignorable_dependency?()","rdoc::codeobject#ignore()","csv::parser#ignore_broken_line()","bundler::settings#ignore_config?()","rss::baseparser#ignore_unknown_element()","rss::baseparser#ignore_unknown_element=()","rexml::element#ignore_whitespace_nodes()","rdoc::codeobject#ignored?()","complex#imag()","matrix#imag()","numeric#imag()","rss::rss#image()","cgi::htmlextension#image_button()","rss::imagefaviconmodel::imagefavicon#image_size=()","complex#imaginary()","matrix#imaginary()","numeric#imaginary()","cgi::htmlextension#img()","win32ole_type#implemented_ole_types()","gem::resolver::dependencyrequest#implicit?()","gem::requestset#import()","fiddle::importer#import_function()","fiddle::importer#import_symbol()","fiddle::importer#import_value()","ipaddr#in6_addr()","ipaddr#in_addr()","bundler::sharedhelpers#in_bundle?()","bundler::definition#in_locked_deps?()","bundler::source::git::gitproxy#in_path()","bundler::thor::actions#in_root()","pstore#in_transaction()","pstore#in_transaction_wr()","optionparser::inc()","optionparser#inc()","module#include()","array#include?()","bundler::plugin::api::source#include?()","bundler::source#include?()","bundler::source::rubygems#include?()","cgi::queryextension#include?()","csv::row#include?()","dbm#include?()","env::include?()","enumerable#include?()","gdbm#include?()","gem::sourcelist#include?()","hash#include?()","ipaddr#include?()","module#include?()","objectspace::weakmap#include?()","rexml::attlistdecl#include?()","racc::iset#include?()","range#include?()","sdbm#include?()","set#include?()","string#include?()","bundler::thor::rakecompat::included()","json::ext::generator::generatormethods::string::included()","module#included()","rss::maker::atomtextconstructbase::ensurexmlcontent::included()","singleton::included()","syslog::constants::included()","syslog::macros::included()","module#included_modules()","optionparser::switch::incompatible_argument_styles()","optionparser::switch::noargument::incompatible_argument_styles()","encoding::invalidbytesequenceerror#incomplete_input?()","racc::reduce#incref()","racc::locationpointer#increment()","bundler::thor::shell::basic#indent()","json::ext::generator::state#indent()","rexml::node#indent()","racc::parserfilegenerator#indent()","json::ext::generator::state#indent=()","racc::parserfilegenerator#indent_re()","rexml::formatters::pretty#indent_text()","rexml::text#indent_text()","psych::emitter#indentation()","psych::emitter#indentation=()","vector::independent?()","vector#independent?()","array#index()","bundler::definition#index()","bundler::plugin#index()","csv::row#index()","env::index()","matrix#index()","rexml::elements#index()","rexml::parent#index()","string#index()","yaml::dbm#index()","bundler::plugin::index#index_file()","bundler::resolver#index_for()","rexml::node#index_in_parent()","bundler::molinillo::resolver::resolution#indicate_progress()","bundler::molinillo::ui#indicate_progress()","bundler::resolver#indicate_progress()","gem::resolver::molinillo::resolver::resolution#indicate_progress()","gem::resolver::molinillo::ui#indicate_progress()","bigdecimal#infinite?()","complex#infinite?()","float#infinite?()","numeric#infinite?()","openssl::pkey::ec::point#infinity?()","bundler::rubygemsintegration#inflate()","gem::inflate()","gem::util::inflate()","zlib::inflate()","zlib::inflate#inflate()","zlib::inflate::inflate()","bundler::cli#info()","bundler::ui::shell#info()","bundler::ui::silent#info()","logger#info()","syslog::logger#info()","webrick::basiclog#info()","logger#info!()","logger#info?()","webrick::basiclog#info?()","webrick::httpstatus#info?()","webrick::httpstatus::info?()","bundler::compactindexclient::cache#info_path()","bundler::compactindexclient::cache#info_roots()","rss::basemodel#inherit_convert_attr_reader()","bundler::thor::base::classmethods#inherited()","class#inherited()","rss::element::inherited()","rss::maker::base::inherited()","rss::utils::inheritedreader#inherited_array_reader()","rss::element::inherited_base()","rss::maker::base::inherited_base()","rss::utils::inheritedreader#inherited_hash_reader()","rss::utils::inheritedreader#inherited_reader()","bundler::cli#init()","gem::packagetask#init()","irb::inspector#init()","racc::actiontable#init()","racc::grammar#init()","racc::parserfilegenerator#init_line_conversion_system()","irb::rubymodel#init_ruby_model()","psych::visitors::toruby#init_with()","rinda::tuple#init_with_ary()","rinda::tuple#init_with_hash()","process::initgroups()","rss::listenermixin#initial_start_rdf()","rss::listenermixin#initial_start_entry()","rss::listenermixin#initial_start_feed()","rss::listenermixin#initial_start_rss()","bundler::molinillo::resolver::resolution#initial_state()","gem::resolver::molinillo::resolver::resolution#initial_state()","gem::package#initialize()","set#initialize_clone()","array#initialize_copy()","bundler::index#initialize_copy()","bundler::molinillo::dependencygraph#initialize_copy()","bundler::thor::coreext::orderedhash#initialize_copy()","csv::row#initialize_copy()","gem::resolver::molinillo::dependencygraph#initialize_copy()","gem::specification#initialize_copy()","hash#initialize_copy()","json::ext::generator::state#initialize_copy()","matrix#initialize_copy()","openssl::bn#initialize_copy()","openssl::cipher#initialize_copy()","openssl::config#initialize_copy()","openssl::digest#initialize_copy()","openssl::hmac#initialize_copy()","openssl::ocsp::basicresponse#initialize_copy()","openssl::ocsp::certificateid#initialize_copy()","openssl::ocsp::request#initialize_copy()","openssl::ocsp::response#initialize_copy()","openssl::ocsp::singleresponse#initialize_copy()","openssl::pkcs12#initialize_copy()","openssl::pkcs7#initialize_copy()","openssl::pkey::dh#initialize_copy()","openssl::pkey::dsa#initialize_copy()","openssl::pkey::ec#initialize_copy()","openssl::pkey::ec::group#initialize_copy()","openssl::pkey::ec::point#initialize_copy()","openssl::pkey::rsa#initialize_copy()","openssl::ssl::session#initialize_copy()","openssl::x509::attribute#initialize_copy()","openssl::x509::crl#initialize_copy()","openssl::x509::certificate#initialize_copy()","openssl::x509::extension#initialize_copy()","openssl::x509::name#initialize_copy()","openssl::x509::request#initialize_copy()","openssl::x509::revoked#initialize_copy()","string#initialize_copy()","stringscanner#initialize_copy()","vector#initialize_copy()","zlib::deflate#initialize_copy()","set#initialize_dup()","rss::element#initialize_have_children_elements()","net::httpheader#initialize_http_header()","rdoc::context#initialize_methods_etc()","bundler::uri::rfc2396_parser#initialize_pattern()","bundler::uri::rfc2396_parser#initialize_pattern()","uri::rfc2396_parser#initialize_pattern()","uri::rfc2396_parser#initialize_pattern()","cgi::queryextension#initialize_query()","irb::readlineinputmethod::initialize_readline()","bundler::uri::rfc2396_parser#initialize_regexp()","bundler::uri::rfc2396_parser#initialize_regexp()","uri::rfc2396_parser#initialize_regexp()","uri::rfc2396_parser#initialize_regexp()","irb::initialize_tracer()","rss::element#initialize_variables()","rss::maker::base#initialize_variables()","bundler::cli#inject()","bundler::injector::inject()","bundler::injector#inject()","enumerable#inject()","rexml::elements#inject()","bundler::cli::add#inject_dependencies()","bundler::thor::actions#inject_into_class()","bundler::thor::actions#inject_into_file()","gem::availableset#inject_into_list()","bundler::thor::actions#inject_into_module()","rss::atom::feed::entry::content#inline_html?()","rss::maker::itemsbase::itembase::contentbase#inline_html?()","rss::atom::feed::entry::content#inline_other?()","rss::maker::itemsbase::itembase::contentbase#inline_other?()","rss::atom::feed::entry::content#inline_other_base64?()","rss::maker::itemsbase::itembase::contentbase#inline_other_base64?()","rss::atom::feed::entry::content#inline_other_text?()","rss::maker::itemsbase::itembase::contentbase#inline_other_text?()","rss::atom::feed::entry::content#inline_other_xml?()","rss::maker::itemsbase::itembase::contentbase#inline_other_xml?()","rss::atom::feed::entry::content#inline_text?()","rss::maker::itemsbase::itembase::contentbase#inline_text?()","rss::atom::feed::entry::content#inline_xhtml?()","rss::maker::itemsbase::itembase::contentbase#inline_xhtml?()","racc::parserfilegenerator#inner()","vector#inner_product()","reline::core#inner_readline()","file::stat#ino()","argf#inplace_mode()","argf#inplace_mode=()","gem::mockgemui#input()","readline::input=()","reline::core#input=()","win32ole_param#input?()","drb::drbserver#insecure_method?()","array#insert()","irb::jobmanager#insert()","string#insert()","rexml::parent#insert_after()","rexml::parent#insert_before()","bundler::thor::actions#insert_into_file()","encoding::converter#insert_output()","readline::insert_text()","reline::insert_text()","bundler::thor::actions#inside()","argf#inspect()","addrinfo#inspect()","array#inspect()","bigdecimal#inspect()","bundler::fetcher#inspect()","bundler::index#inspect()","bundler::molinillo::dependencygraph#inspect()","bundler::molinillo::dependencygraph::vertex#inspect()","bundler::source#inspect()","bundler::thor::coreext::orderedhash#inspect()","bundler::uri::generic#inspect()","bundler::uri::rfc2396_parser#inspect()","bundler::uri::rfc2396_parser#inspect()","cgi::cookie#inspect()","csv#inspect()","csv::row#inspect()","csv::table#inspect()","complex#inspect()","date#inspect()","digest::instance#inspect()","dir#inspect()","env::inspect()","encoding#inspect()","encoding::converter#inspect()","enumerator#inspect()","enumerator::arithmeticsequence#inspect()","enumerator::chain#inspect()","exception#inspect()","falseclass#inspect()","fiber#inspect()","fiddle::pointer#inspect()","file::stat#inspect()","float#inspect()","gem::platform#inspect()","gem::resolver::molinillo::dependencygraph#inspect()","gem::resolver::molinillo::dependencygraph::vertex#inspect()","hash#inspect()","io#inspect()","ipaddr#inspect()","ipsocket#inspect()","irb::fileinputmethod#inspect()","irb::inputmethod#inspect()","irb::irb#inspect()","irb::jobmanager#inspect()","irb::readlineinputmethod#inspect()","irb::reidlineinputmethod#inspect()","irb::stdioinputmethod#inspect()","integer#inspect()","matchdata#inspect()","matrix#inspect()","method#inspect()","module#inspect()","net::http#inspect()","net::httpgenericrequest#inspect()","net::httpresponse#inspect()","net::pop3#inspect()","net::popmail#inspect()","net::smtp#inspect()","net::writeadapter#inspect()","nilclass#inspect()","object#inspect()","objectspace::internalobjectwrapper#inspect()","objectspace::weakmap#inspect()","openssl::config#inspect()","openssl::engine#inspect()","openssl::hmac#inspect()","openssl::x509::certificate#inspect()","openstruct#inspect()","optionparser::parseerror#inspect()","proc#inspect()","process::status#inspect()","rexml::attribute#inspect()","rexml::element#inspect()","rexml::instruction#inspect()","rexml::parsers::pullevent#inspect()","rexml::text#inspect()","rexml::validation::choice#inspect()","rexml::validation::event#inspect()","rexml::validation::interleave#inspect()","rexml::validation::ref#inspect()","rexml::validation::state#inspect()","rexml::xmldecl#inspect()","racc::accept#inspect()","racc::error#inspect()","racc::goto#inspect()","racc::iset#inspect()","racc::locationpointer#inspect()","racc::ormark#inspect()","racc::prec#inspect()","racc::reduce#inspect()","racc::rule#inspect()","racc::shift#inspect()","racc::state#inspect()","racc::states#inspect()","racc::sym#inspect()","racc::useraction#inspect()","range#inspect()","rational#inspect()","regexp#inspect()","rubyvm::abstractsyntaxtree::node#inspect()","rubyvm::instructionsequence#inspect()","set#inspect()","socket::ancillarydata#inspect()","socket::ifaddr#inspect()","socket::option#inspect()","string#inspect()","stringscanner#inspect()","struct#inspect()","symbol#inspect()","syslog::inspect()","thread#inspect()","thread::backtrace::location#inspect()","time#inspect()","tracepoint#inspect()","trueclass#inspect()","uri::generic#inspect()","uri::rfc2396_parser#inspect()","uri::rfc2396_parser#inspect()","unboundmethod#inspect()","vector#inspect()","win32ole_method#inspect()","win32ole_param#inspect()","win32ole_record#inspect()","win32ole_type#inspect()","win32ole_typelib#inspect()","win32ole_variable#inspect()","zlib::gzipfile::error#inspect()","irb::context#inspect?()","irb::color::inspect_colorable?()","irb::context#inspect_mode=()","date#inspect_raw()","addrinfo#inspect_sockaddr()","irb::inspector#inspect_value()","bundler::cli#install()","bundler::cli::cache#install()","bundler::cli::package#install()","bundler::cli::plugin#install()","bundler::fileutils#install()","bundler::fileutils::install()","bundler::gemhelper#install()","bundler::geminstaller#install()","bundler::installer::install()","bundler::installer#install()","bundler::plugin#install()","bundler::plugin::api::source#install()","bundler::plugin::installer#install()","bundler::source::git#install()","bundler::source::metadata#install()","bundler::source::path#install()","bundler::source::rubygems#install()","fileutils#install()","fileutils::install()","gem::install()","gem::dependencyinstaller#install()","gem::installer#install()","gem::requestset#install()","gem::resolver::gitspecification#install()","gem::resolver::installedspecification#install()","gem::resolver::lockspecification#install()","gem::resolver::specification#install()","gem::resolver::vendorspecification#install()","rss::baselistener::install_accessor_base()","drb#install_acl()","drb::install_acl()","irb::extendcommandbundle#install_alias_method()","bundler::plugin::installer#install_all_sources()","rss::baselistener::install_class_name()","rss::basemodel#install_date_element()","gem::commands::setupcommand#install_default_bundler_gem()","gem::testcase#install_default_gems()","gem::testcase#install_default_specs()","bundler::plugin::installer#install_definition()","rss::maker::dublincoremodel::install_dublin_core()","rss::basemodel#install_element()","bundler::geminstaller#install_error_message()","gem::commands::setupcommand#install_executables()","irb::contextextender::install_extend_commands()","irb::extendcommandbundle::install_extend_commands()","gem::commands::setupcommand#install_file()","gem::requestset#install_from_gemdeps()","bundler::geminstaller#install_from_spec()","bundler::plugin::installer#install_from_specs()","bundler::gemhelper#install_gem()","gem::testcase#install_gem()","gem::testcase#install_gem_user()","rss::element::install_get_attribute()","rss::baselistener::install_get_text_element()","bundler::plugin::installer#install_git()","rss::basemodel#install_have_attribute_element()","rss::basemodel#install_have_child_element()","rss::basemodel#install_have_children_element()","gem::requestset#install_hooks()","drb::install_id_conv()","drb#install_id_conv()","bundler::dsl#install_if()","rss::maker::imagefaviconmodel::install_image_favicon()","rss::maker::imageitemmodel::install_image_item()","bundler::installer#install_in_parallel()","gem::indexer#install_indices()","gem::requestset#install_into()","gem::commands::setupcommand#install_lib()","acl#install_list()","bundler::plugin::installer#install_local_git()","rss::element::install_model()","rss::element::install_must_call_validator()","rss::element::install_ns()","bundler::install_path()","bundler::plugin::api::source#install_path()","bundler::plugin::installer::git#install_path()","bundler::source::git#install_path()","gem::commands::setupcommand#install_rdoc()","bundler::plugin::installer#install_rubygems()","bundler::parallelinstaller#install_serially()","rdoc::rdoc#install_siginfo_handler()","gem::testcase#install_specs()","bundler::gemhelper::install_tasks()","rss::maker::taxonomytopicmodel::install_taxo_topic()","rss::maker::taxonomytopicsmodel::install_taxo_topics()","rss::basemodel#install_text_element()","gem::installupdateoptions#install_update_defaults_str()","bundler::rubygemsintegration#install_with_build_args()","bundler::geminstaller#install_with_settings()","bundler::parallelinstaller#install_with_worker()","gem::platform::installable?()","gem::resolver::installedspecification#installable_platform?()","gem::resolver::localspecification#installable_platform?()","gem::resolver::specification#installable_platform?()","bundler::parallelinstaller::specinstallation#installation_attempted?()","bundler::installer#installation_parallelization()","gem::installer#installation_satisfies_dependency?()","bundler::parallelinstaller::specinstallation#installed?()","bundler::plugin#installed?()","bundler::plugin::api::source#installed?()","bundler::plugin::index#installed?()","bundler::source::rubygems#installed?()","gem::commands::querycommand#installed?()","gem::resolver::activationrequest#installed?()","rdoc::servlet#installed_docs()","bundler::plugin::index#installed_plugins()","bundler::source::rubygems#installed_specs()","gem::installer#installed_specs()","gem::specification::installed_stubs()","csv::instance()","gem::commandmanager#instance()","gem::commandmanager::instance()","singleton::instance()","syslog::instance()","rdoc::context#instance_attributes()","forwardable#instance_delegate()","basicobject#instance_eval()","basicobject#instance_exec()","module#instance_method()","rdoc::context#instance_method_list()","module#instance_methods()","rdoc::store#instance_methods()","object#instance_of?()","object#instance_variable_defined?()","object#instance_variable_get()","object#instance_variable_set()","object#instance_variables()","rexml::streamlistener#instruction()","rss::listenermixin#instruction()","rexml::parsers::pullevent#instruction?()","tracepoint#instruction_sequence()","rexml::element#instructions()","socket::ancillarydata#int()","socket::ancillarydata::int()","socket::option::int()","socket::option#int()","prime#int_from_prime_division()","integer#integer?()","numeric#integer?()","racc::parserfilegenerator#integer_list()","rss::basemodel#integer_writer()","racc::grammar#intern()","racc::symboltable#intern()","string#intern()","symbol#intern()","objectspace::internal_class_of()","argf#internal_encoding()","io#internal_encoding()","stringio#internal_encoding()","objectspace::internalobjectwrapper#internal_object_id()","objectspace::internal_super_of()","bigdecimal::interpret_loosely()","debugger__::interrupt()","set#intersect?()","array#intersection()","set#intersection()","matrix#inv()","gem::specification#invalidate_memoized_attributes()","matrix#inverse()","dbm#invert()","env::invert()","gdbm#invert()","hash#invert()","sdbm#invert()","yaml::dbm#invert()","openssl::pkey::ec::point#invert!()","win32ole_method#invkind()","bundler::thor::group::invoke()","bundler::thor::invocation#invoke()","gem::command#invoke()","win32ole#invoke()","bundler::thor::group::invoke_from_option()","win32ole_method#invoke_kind()","drb::extservmanager#invoke_service()","drb::extservmanager#invoke_service_command()","drb::extservmanager#invoke_thread()","gem::command#invoke_with_build_args()","bundler::thor::invocation#invoke_with_padding()","csv#ioctl()","io#ioctl()","io#ioflush()","addrinfo::ip()","ipaddr#ip6_arpa()","ipaddr#ip6_int()","addrinfo#ip?()","addrinfo#ip_address()","socket::ip_address_list()","socket::ancillarydata#ip_pktinfo()","socket::ancillarydata::ip_pktinfo()","addrinfo#ip_port()","addrinfo#ip_unpack()","net::http#ipaddr()","net::http#ipaddr=()","addrinfo#ipv4?()","ipaddr#ipv4?()","ipaddr#ipv4_compat()","ipaddr#ipv4_compat?()","addrinfo#ipv4_loopback?()","ipaddr#ipv4_mapped()","ipaddr#ipv4_mapped?()","addrinfo#ipv4_multicast?()","socket::option::ipv4_multicast_loop()","socket::option#ipv4_multicast_loop()","socket::option#ipv4_multicast_ttl()","socket::option::ipv4_multicast_ttl()","addrinfo#ipv4_private?()","addrinfo#ipv6?()","ipaddr#ipv6?()","addrinfo#ipv6_linklocal?()","addrinfo#ipv6_loopback?()","addrinfo#ipv6_mc_global?()","addrinfo#ipv6_mc_linklocal?()","addrinfo#ipv6_mc_nodelocal?()","addrinfo#ipv6_mc_orglocal?()","addrinfo#ipv6_mc_sitelocal?()","addrinfo#ipv6_multicast?()","socket::ancillarydata::ipv6_pktinfo()","socket::ancillarydata#ipv6_pktinfo()","socket::ancillarydata#ipv6_pktinfo_addr()","socket::ancillarydata#ipv6_pktinfo_ifindex()","addrinfo#ipv6_sitelocal?()","addrinfo#ipv6_to_ipv4()","addrinfo#ipv6_unique_local?()","addrinfo#ipv6_unspecified?()","addrinfo#ipv6_v4compat?()","addrinfo#ipv6_v4mapped?()","socket#ipv6only!()","binding#irb()","irb::irb()","irb::jobmanager#irb()","irb::irb_abort()","irb::irb_at_exit()","irb::extendcommandbundle#irb_context()","irb::irb_exit()","irb::extendcommandbundle#irb_exit()","irb::context#irb_level()","irb::extendcommandbundle#irb_load()","irb::irbloader#irb_load()","irb::extendcommandbundle#irb_require()","jacobian#isequal()","object#is_a?()","rdoc::constant#is_alias_for()","bundler::settings#is_array()","bundler::settings#is_bool()","bundler::settings#is_num()","bundler::molinillo::dependencygraph::vertex#is_reachable_from?()","gem::resolver::molinillo::dependencygraph::vertex#is_reachable_from?()","net::http::is_version_1_2?()","io#isatty()","stringio#isatty()","time#isdst()","kconv::iseuc()","kconv#iseuc()","string#iseuc()","kconv#isjis()","kconv::isjis()","string#isjis()","date#iso8601()","date::iso8601()","datetime#iso8601()","datetime::iso8601()","time#iso8601()","time::iso8601()","process::sys::issetugid()","kconv::issjis()","kconv#issjis()","string#issjis()","bundler::cli#issue()","openssl::pkcs7::recipientinfo#issuer()","openssl::pkcs7::signerinfo#issuer()","openssl::x509::crl#issuer()","openssl::x509::certificate#issuer()","openssl::x509::crl#issuer=()","openssl::x509::certificate#issuer=()","openssl::x509::extensionfactory#issuer_certificate=()","openssl::ocsp::certificateid#issuer_key_hash()","openssl::ocsp::certificateid#issuer_name_hash()","gem::security::trustdir#issuer_of()","bundler::friendlyerrors#issues_url()","kconv::isutf8()","kconv#isutf8()","string#isutf8()","date#italy()","rss::atom::entry#items()","rss::rss#items()","gem::resolver::stats#iteration!()","kernel#iterator?()","object#itself()","openssl::cipher#iv=()","openssl::cipher#iv_len()","openssl::cipher#iv_len=()","kernel#j()","jacobian#jacobian()","gem::java_platform?()","gem::testcase#java_platform?()","gem::testcase::java_platform?()","date::jd()","date#jd()","datetime::jd()","date#jisx0301()","date::jisx0301()","datetime::jisx0301()","datetime#jisx0301()","kernel#jj()","array#join()","bundler::uri::join()","bundler::uri::rfc2396_parser#join()","bundler::uri::rfc2396_parser#join()","file::join()","pathname#join()","shellwords::join()","thread#join()","uri::join()","uri::rfc2396_parser#join()","uri::rfc2396_parser#join()","bundler::currentruby#jruby?()","class#json_creatable?()","json::genericobject::json_creatable?()","bigdecimal::json_create()","complex::json_create()","date::json_create()","datetime::json_create()","exception::json_create()","json::ext::generator::generatormethods::string::extend#json_create()","json::genericobject::json_create()","openstruct::json_create()","range::json_create()","rational::json_create()","regexp::json_create()","set::json_create()","struct::json_create()","symbol::json_create()","time::json_create()","date#julian()","date#julian?()","date::julian_leap?()","bundler::settings::validator::rule#k()","kconv#kconv()","kconv::kconv()","string#kconv()","net::http#keep_alive?()","webrick::httprequest#keep_alive?()","webrick::httpresponse#keep_alive?()","csv::parser::inputsscanner#keep_back()","csv::parser::scanner#keep_back()","rinda::tuplespace#keep_clean()","csv::parser::inputsscanner#keep_drop()","csv::parser::scanner#keep_drop()","csv::parser::inputsscanner#keep_end()","csv::parser::scanner#keep_end()","array#keep_if()","env::keep_if()","hash#keep_if()","set#keep_if()","gem::specification#keep_only_files_and_directories()","csv::parser::inputsscanner#keep_start()","csv::parser::scanner#keep_start()","bundler::retry#keep_trying?()","bundler::cli::exec#kernel_exec()","bundler::cli::exec#kernel_load()","dbm#key()","env::key()","gdbm#key()","hash#key()","keyerror#key()","sdbm#key()","yaml::dbm#key()","bundler::persistent::net::http::persistent#key=()","openssl::cipher#key=()","cgi::queryextension#key?()","csv::row#key?()","dbm#key?()","env::key?()","gdbm#key?()","hash#key?()","net::httpheader#key?()","objectspace::weakmap#key?()","racc::iset#key?()","sdbm#key?()","thread#key?()","bundler::settings#key_for()","openssl::cipher#key_len()","openssl::cipher#key_len=()","bundler::thor::coreext::orderedhash#keys()","cgi::queryextension#keys()","dbm#keys()","env::keys()","gdbm#keys()","hash#keys()","objectspace::weakmap#keys()","sdbm#keys()","thread#keys()","irb::inspector::keys_with_inspector()","drb::threadobject#kill()","irb::jobmanager#kill()","process::kill()","thread#kill()","thread::kill()","object#kind_of?()","rss::listenermixin#known_class?()","matrix::lupdecomposition#l()","racc::state#la=()","rubyvm::instructionsequence#label()","thread::backtrace::location#label()","kernel#lambda()","proc#lambda?()","rexml::functions::lang()","matrix#laplace_expansion()","array#last()","enumerator::arithmeticsequence#last()","rexml::functions::last()","range#last()","rss::maker::channelbase#lastbuilddate=()","bundler::retry#last_attempt?()","rubyvm::abstractsyntaxtree::node#last_column()","encoding::converter#last_error()","fiddle::last_error()","fiddle::last_error=()","csv::parser#last_line()","rubyvm::abstractsyntaxtree::node#last_lineno()","regexp::last_match()","openuri::meta#last_modified()","rdoc::toplevel#last_modified()","process::last_status()","openssl::x509::crl#last_update()","openssl::x509::crl#last_update=()","bundler::cli::inject#last_version_number()","gc::latest_gc_info()","gem::latest_rubygems_version()","gem::latest_spec_for()","gem::server#latest_specs()","gem::specification::latest_specs()","bundler::molinillo::resolver::resolution::possibilityset#latest_version()","gem::dependency#latest_version?()","gem::latest_version_for()","gem::server#launch()","enumerable#lazy()","enumerator::lazy#lazy()","file::lchmod()","pathname#lchmod()","file::lchown()","pathname#lchown()","integer#lcm()","date#ld()","bundler::cli::doctor#ldd_available?()","math::ldexp()","date#leap?()","date::leap?()","rexml::xpathparser#leave()","racc::grammar::precedencedefinitionenv#left()","gem::testcase::specfetchersetup#legacy_platform()","array#length()","bundler::connectionpool::timedstack#length()","bundler::specset#length()","dbm#length()","digest::instance#length()","env::length()","gdbm#length()","gem::package::tarreader::entry#length()","hash#length()","matchdata#length()","objectspace::weakmap#length()","queue#length()","rexml::attributes#length()","rexml::parent#length()","sdbm#length()","set#length()","sizedqueue#length()","string#length()","stringio#length()","struct#length()","symbol#length()","tempfile#length()","bundler::ui::shell#level()","bundler::ui::silent#level()","socket::ancillarydata#level()","socket::option#level()","zlib::gzipfile#level()","bundler::gemversionpromoter#level=()","bundler::ui::shell#level=()","bundler::ui::silent#level=()","irb::notifier::compositenotifier#level=()","logger#level=()","irb::notifier::compositenotifier#level_notifier=()","bundler::similaritydetector#levenshtein_distance()","gem::text#levenshtein_distance()","ripper::lex()","ripper::lex_state_name()","math::lgamma()","gem::basicspecification#lib_dirs_glob()","gem::specification#lib_files()","csv#liberal_parsing?()","csv::parser#liberal_parsing?()","win32ole_typelib#library_name()","psych::libyaml_version()","gem::specification#license()","gem::specification#license=()","bundler::cli#licenses()","gem::specification#licenses()","gem::specification#licenses=()","bigdecimal::limit()","csv#line()","csv::parser#line()","irb::canvas#line()","irb::readlineinputmethod#line()","irb::reidlineinputmethod#line()","irb::stdioinputmethod#line()","rexml::parseexception#line()","racc::parserfilegenerator#line()","irb::canvas#line0()","readline::line_buffer()","reline::line_editor()","psych::emitter#line_width()","psych::emitter#line_width=()","argf#lineno()","csv#lineno()","csv::parser#lineno()","io#lineno()","racc::grammarfilescanner#lineno()","ripper#lineno()","ripper::filter#lineno()","stringio#lineno()","thread::backtrace::location#lineno()","tracepoint#lineno()","zlib::gzipreader#lineno()","argf#lineno=()","io#lineno=()","stringio#lineno=()","zlib::gzipreader#lineno=()","argf#lines()","bundler::compactindexclient::cache#lines()","io#lines()","string#lines()","stringio#lines()","zlib::gzipreader#lines()","socket::option#linger()","socket::option::linger()","bundler::fileutils#link()","bundler::fileutils::link()","file::link()","fileutils::link()","fileutils#link()","rss::maker::imagebase#link()","makemakefile#link_command()","bundler::fileutils#link_entry()","bundler::fileutils::link_entry()","fileutils::link_entry()","fileutils#link_entry()","bundler::thor::actions#link_file()","ipaddr#link_local?()","rdoc::markdown#link_to()","bundler::cli#list()","bundler::cli::config#list()","bundler::cli::plugin#list()","bundler::plugin#list()","encoding::list()","net::ftp#list()","net::imap#list()","signal::list()","thread::list()","threadgroup#list()","webrick::httputils::formdata#list()","rdoc::rdoc#list_files_in_directory()","rdoc::markdown#list_item_from()","net::ftp::mlsxentry#listable?()","addrinfo#listen()","gem::server#listen()","openssl::ssl::sslserver#listen()","rexml::parsers::sax2parser#listen()","socket#listen()","tcpserver#listen()","unixserver#listen()","webrick::genericserver#listen()","rss::rexmlparser::listener()","rss::xmlparserparser::listener()","rss::xmlscanparser::listener()","rss::rexmllikexmlparser#listener=()","racc::grammarfilescanner#literal_head?()","rexml::elements#literalize()","string#ljust()","bundler::fileutils#ln()","bundler::fileutils::ln()","fileutils::ln()","fileutils#ln()","openssl::asn1::objectid#ln()","bundler::fileutils#ln_s()","bundler::fileutils::ln_s()","fileutils::ln_s()","fileutils#ln_s()","bundler::fileutils#ln_sf()","bundler::fileutils::ln_sf()","fileutils::ln_sf()","fileutils#ln_sf()","bundler::load()","bundler::yamlserializer#load()","gem::requestset::gemdependencyapi#load()","gem::safeyaml::load()","gem::specification::load()","irb::locale#load()","json#load()","json::genericobject::load()","kernel#load()","marshal::load()","openssl::engine::load()","optionparser#load()","psych::load()","rdoc::store#load_all()","gem::commandmanager#load_and_instantiate()","gem::configfile#load_api_keys()","rdoc::store#load_cache()","gem::security::trustdir#load_certificate()","rdoc::store#load_class()","rdoc::store#load_class_data()","bundler::settings#load_config()","pstore#load_data()","gem::commands::certcommand#load_default_cert()","gem::commands::certcommand#load_default_key()","gem::specification::load_defaults()","gem::load_env_plugins()","gem::configfile#load_file()","irb::irbloader#load_file()","psych::load_file()","rubyvm::instructionsequence::load_from_binary()","rubyvm::instructionsequence::load_from_binary_extra_data()","gem::requestset#load_gemdeps()","bundler::load_gemspec()","bundler::source::git#load_gemspec()","bundler::source::path#load_gemspec()","bundler::load_gemspec_uncached()","bundler::plugin::index#load_index()","bundler::load_marshal()","rdoc::store#load_method()","webrick::httputils::load_mime_types()","webrick::httputils#load_mime_types()","rdoc::rdoc#load_options()","rdoc::store#load_page()","gem::load_path_insert_index()","bundler::endpointspecification#load_paths()","bundler::plugin::index#load_paths()","bundler::stubspecification#load_paths()","gem::specification#load_paths()","bundler::plugin#load_plugin()","bundler::rubygemsintegration#load_plugin_files()","bundler::installer#load_plugins()","bundler::rubygemsintegration#load_plugins()","gem::load_plugins()","openssl::engine#load_private_key()","openssl::engine#load_public_key()","openssl::random::load_random_file()","rdoc::rubygemshook::load_rdoc()","rdoc::rubygemshook::load_rdoc()","gem::testcase::staticset#load_spec()","bundler::source::git#load_spec_files()","bundler::source::path#load_spec_files()","gem::source#load_specs()","psych::load_stream()","bundler::thor::util::load_thorfile()","rdoc::parser::c#load_variable_map()","gem::load_yaml()","rdoc::load_yaml()","bundler::source::rubygems#loaded_from()","bundler::stubspecification#loaded_from()","gem::specification#loaded_from()","bundler::rubygemsintegration#loaded_gem_paths()","gem::testcase#loaded_spec_names()","bundler::rubygemsintegration#loaded_specs()","gem::platform::local()","time::local()","bundler::source::git#local?()","gem::localremoteoptions#local?()","basicsocket#local_address()","bundler::settings#local_config_file()","bundler::plugin::index#local_index_file()","bundler::thor::command#local_method?()","bundler::thor::command#local_method?()","rexml::functions::local_name()","rexml::light::node#local_name()","rexml::light::node#local_name=()","bundler::source::git#local_override!()","bundler::settings#local_overrides()","bundler::local_platform()","bundler::plugin#local_root()","bundler::index#local_search()","bundler::endpointspecification#local_specification_path()","bundler::source::path#local_specs()","binding#local_variable_defined?()","binding#local_variable_get()","irb::workspace#local_variable_get()","binding#local_variable_set()","irb::workspace#local_variable_set()","binding#local_variables()","kernel#local_variables()","nameerror#local_variables()","win32ole::locale()","win32ole::locale=()","encoding::locale_charmap()","time#localtime()","racc::grammarfileparser#location()","racc::sourcetext#location()","erb#location=()","gem::location_of_caller()","bundler::settings#locations()","bundler::cli#lock()","bundler::definition#lock()","bundler::installer#lock()","bundler::processlock::lock()","bundler::runtime#lock()","mutex#lock()","net::http#lock()","bundler::sourcelist#lock_sources()","mutex#locked?()","bundler::definition#locked_bundler_version()","bundler::locked_gems()","gem::streamui::threadeddownloadreporter#locked_puts()","bundler::molinillo::resolver::resolution#locked_requirement_named()","gem::resolver::molinillo::resolver::resolution#locked_requirement_named()","bundler::molinillo::resolver::resolution#locked_requirement_possibility_set()","bundler::definition#locked_ruby_version()","bundler::definition#locked_ruby_version_object()","gem::bundlerversionfinder::lockfile_contents()","bundler::source::path#lockfile_path()","gem::bundlerversionfinder::lockfile_version()","bundler::definition#lockfiles_equal?()","bigmath::log()","logger#log()","math::log()","syslog::log()","webrick::basiclog#log()","webrick::log#log()","math::log10()","math::log2()","bundler::friendlyerrors#log_error()","bundler::fetcher::base#log_specs()","net::pop3#logging()","net::smtp#logging()","net::ftp#login()","net::imap#login()","rss::maker::channelbase#logo()","rss::maker::channelbase#logo=()","net::imap#logout()","bundler::thor::long_desc()","openssl::asn1::objectid#long_name()","rdoc::parser::c#look_for_directives_in()","rdoc::parser::ruby#look_for_directives_in()","racc::states#lookahead()","bundler::specset#lookup()","bundler::thor::shell::basic#lookup_color()","rinda::ringfinger#lookup_ring()","rinda::ringfinger#lookup_ring_any()","webrick::httpserver#lookup_server()","kernel#loop()","ipaddr#loopback?()","racc::grammar::precedencedefinitionenv#lower()","matrix#lower_triangular?()","net::ftp#ls()","openssl::bn#lshift!()","file#lstat()","file::lstat()","pathname#lstat()","string#lstrip()","string#lstrip!()","net::imap#lsub()","lusolve#ludecomp()","matrix#lup()","matrix#lup_decomposition()","lusolve#lusolve()","file::lutime()","bundler::currentruby#maglev?()","complex#magnitude()","float#magnitude()","integer#magnitude()","numeric#magnitude()","rational#magnitude()","vector#magnitude()","net::popmail#mail()","net::smtp#mailfrom()","net::pop3#mails()","irb::context#main()","rdoc::store#main()","thread::main()","rdoc::store#main=()","irb::jobmanager#main_irb()","drb::drbserver#main_loop()","irb::jobmanager#main_thread()","net::httpheader#main_type()","bundler::gemversionpromoter#major?()","bundler::sharedhelpers#major_deprecation()","bundler::featureflag#major_version()","win32ole_type#major_version()","win32ole_typelib#major_version()","gem::ext::builder::make()","rss::maker::make()","rss::maker::rssbase::make()","rss::maker::rssbase#make()","openssl::pkey::ec::point#make_affine!()","racc::state#make_closure()","gem::testcase::make_command()","gem::testcase#make_command()","erb#make_compiler()","racc::parserfilegenerator#make_delimiter()","gem::commands::setupcommand#make_destination_dirs()","bundler::molinillo::dependencygraph::addedgenocircular#make_edge()","bundler::molinillo::dependencygraph::deleteedge#make_edge()","gem::resolver::molinillo::dependencygraph::addedgenocircular#make_edge()","gem::resolver::molinillo::dependencygraph::deleteedge#make_edge()","gem::commands::querycommand#make_entry()","rinda::tupleentry#make_expires()","rss::maker::atom::entry#make_feed()","rss::maker::atom::feed#make_feed()","rss::maker::rss09#make_feed()","rss::maker::rss10#make_feed()","pathname#make_link()","rdoc::parser::ruby#make_message()","syslog::logger::make_methods()","gem::requestset::lockfile::tokenizer#make_parser()","webrick::httpauth::basicauth::make_passwd()","webrick::httpauth::digestauth::make_passwd()","webrick::httpauth::userdb#make_passwd()","drb::drbconn::make_pool()","bundler::uri::rfc2396_parser#make_regexp()","bundler::uri::rfc2396_parser#make_regexp()","uri::rfc2396_parser#make_regexp()","uri::rfc2396_parser#make_regexp()","racc::parserfilegenerator#make_separator()","rinda::ringserver#make_socket()","rss::element#make_start_tag()","optionparser#make_switch()","pathname#make_symlink()","gem::indexer#make_temp_directories()","debugger__::make_thread_list()","time::make_time()","rinda::tupleentry#make_tuple()","rdoc::store#make_variable_map()","rss::maker::rssbase#make_xml_stylesheets()","bundler::fileutils#makedirs()","bundler::fileutils::makedirs()","fileutils#makedirs()","fileutils::makedirs()","rss::maker::maker()","rss::atom::contentmodel#maker_target()","rss::atom::entry#maker_target()","rss::atom::feed#maker_target()","rss::atom::feed::category#maker_target()","rss::atom::feed::entry#maker_target()","rss::atom::feed::link#maker_target()","rss::atom::feed::logo#maker_target()","rss::atom::personconstruct#maker_target()","rss::atom::textconstruct#maker_target()","rss::ituneschannelmodel::itunescategory#maker_target()","rss::ituneschannelmodel::itunesimage#maker_target()","rss::ituneschannelmodel::itunesowner#maker_target()","rss::itunesitemmodel::itunesduration#maker_target()","rss::imagefaviconmodel::imagefavicon#maker_target()","rss::imageitemmodel::imageitem#maker_target()","rss::rdf::channel#maker_target()","rss::rdf::image#maker_target()","rss::rdf::item#maker_target()","rss::rdf::textinput#maker_target()","rss::rootelementmixin#maker_target()","rss::rss::channel#maker_target()","rss::rss::channel::image#maker_target()","rss::rss::channel::item#maker_target()","rss::rss::channel::item::category#maker_target()","rss::rss::channel::item::enclosure#maker_target()","rss::rss::channel::item::guid#maker_target()","rss::rss::channel::item::source#maker_target()","rss::rss::channel::textinput#maker_target()","rss::setupmaker#maker_target()","rss::taxonomytopicmodel::taxonomytopic#maker_target()","rss::taxonomytopicsmodel::taxonomytopics#maker_target()","rss::maker::makers()","fiddle::malloc()","fiddle::cstructentity::malloc()","fiddle::cunionentity::malloc()","fiddle::pointer::malloc()","gc::malloc_allocated_size()","gc::malloc_allocations()","gem::commands::ownercommand#manage_owners()","racc::grammar::definitionenv#many()","racc::grammar::definitionenv#many1()","array#map()","bundler::thor::map()","enumerable#map()","enumerator::lazy#map()","matrix#map()","psych::coder#map()","vector#map()","array#map!()","matrix#map!()","set#map!()","vector#map!()","vector#map2()","psych::coder#map=()","gem::indexer#map_gems_to_specs()","psych::nodes::mapping#mapping?()","psych::nodes::node#mapping?()","psych::parser#mark()","bundler::rubygemsintegration#mark_loaded()","gem::specification#mark_version()","rdoc::text#markup()","delegator#marshal_dump()","gem::version#marshal_dump()","openstruct#marshal_dump()","rdoc::anymethod#marshal_dump()","rdoc::attr#marshal_dump()","rdoc::constant#marshal_dump()","rdoc::toplevel#marshal_dump()","date#marshal_dump_old()","delegator#marshal_load()","gem::version#marshal_load()","openstruct#marshal_load()","rdoc::anymethod#marshal_load()","rdoc::attr#marshal_load()","rdoc::constant#marshal_load()","bundler::rubygemsintegration#marshal_spec_dir()","gem::marshal_version()","ipaddr#mask()","syslog::mask()","ipaddr#mask!()","syslog::mask=()","acl::aclentry#match()","acl::acllist#match()","gem::platform::match()","optionparser::completinghash#match()","rexml::iosource#match()","rexml::quickpath::match()","rexml::source#match()","rexml::xpath::match()","rexml::xpathparser#match()","regexp#match()","rinda::template#match()","rinda::templateentry#match()","string#match()","symbol#match()","csv::matchp#match?()","gem::dependency#match?()","gem::licenses::match?()","gem::resolver::dependencyrequest#match?()","regexp#match?()","string#match?()","stringscanner#match?()","symbol#match?()","bundler::matchplatform#match_platform()","gem::availableset#match_platform!()","gem::nametuple#match_platform?()","rexml::source#match_to()","rexml::source#match_to_consume()","stringscanner#matched()","stringscanner#matched?()","stringscanner#matched_size()","bundler::thor::lineeditor::readline::pathcompletion#matches()","bundler::rubyversion#matches?()","rexml::entity::matches?()","rexml::validation::choice#matches?()","rexml::validation::event#matches?()","rexml::validation::interleave#matches?()","rexml::validation::oneormore#matches?()","rexml::validation::optional#matches?()","rexml::validation::sequence#matches?()","bundler::stubspecification#matches_for_glob()","gem::basicspecification#matches_for_glob()","gem::dependency#matches_spec?()","gem::resolver::dependencyrequest#matches_spec?()","gem::dependency#matching_specs()","bundler::specset#materialize()","bundler::specset#materialized_for_all_platforms()","array#max()","enumerable#max()","range#max()","sizedqueue#max()","sizedqueue#max=()","enumerable#max_by()","net::imap::max_flag_count()","net::imap::max_flag_count=()","json::ext::generator::state#max_nesting()","json::ext::generator::state#max_nesting=()","net::http#max_retries=()","bundler::persistent::net::http::persistent#max_version=()","openssl::ssl::sslcontext#max_version=()","process::maxgroups()","process::maxgroups=()","csv::parser#may_quoted?()","reline::core#may_req_ambiguous_char_width()","rss::parser#maybe_xml?()","bundler::sharedhelpers#md5_available?()","date#mday()","time#mday()","net::ftp#mdtm()","benchmark#measure()","benchmark::measure()","net::imap::bodytypebasic#media_subtype()","net::imap::bodytypemessage#media_subtype()","net::imap::bodytypemultipart#media_subtype()","net::imap::bodytypetext#media_subtype()","openssl::mem_check_start()","csv::row#member?()","dbm#member?()","env::member?()","enumerable#member?()","gdbm#member?()","hash#member?()","objectspace::weakmap#member?()","range#member?()","sdbm#member?()","set#member?()","struct#members()","webrick::httpauth::htgroup#members()","benchmark::tms#memberwise()","objectspace::memsize_of()","objectspace::memsize_of_all()","bundler::specset#merge()","bundler::thor::coreext::orderedhash#merge()","bundler::uri::generic#merge()","gem::dependency#merge()","hash#merge()","json::ext::generator::state#merge()","rdoc::classmodule#merge()","set#merge()","uri::generic#merge()","bundler::thor::coreext::orderedhash#merge!()","bundler::uri::generic#merge!()","env::merge!()","hash#merge!()","uri::generic#merge!()","psych::visitors::toruby#merge_key()","gem::command#merge_options()","bundler::uri::generic#merge_path()","uri::generic#merge_path()","bundler::cli::config::base#message()","bundler::compactindexclient::updater::mismatchedchecksumerror#message()","bundler::molinillo::nosuchdependencyerror#message()","bundler::nospaceondeviceerror#message()","bundler::operationnotsupportederror#message()","bundler::permissionerror#message()","bundler::temporaryresourceerror#message()","bundler::virtualprotocolerror#message()","exception#message()","gem::resolver::molinillo::nosuchdependencyerror#message()","gem::runtimerequirementnotmeterror#message()","net::readtimeout#message()","net::smtp::response#message()","net::writetimeout#message()","optionparser::parseerror#message()","win32ole_event::message_loop()","bundler::molinillo::versionconflict#message_with_trees()","webrick::httprequest#meta_vars()","bundler::definition#metadata_dependencies()","bundler::resolver::specgroup#metadata_dependencies()","object#method()","bundler::thor::base::classmethods#method_added()","module#method_added()","module#method_defined?()","rdoc::store#method_file()","tracepoint#method_id()","basicobject#method_missing()","bundler::connectionpool::wrapper#method_missing()","bundler::depproxy#method_missing()","bundler::dsl#method_missing()","bundler::lazyspecification#method_missing()","bundler::plugin::api#method_missing()","bundler::plugin::dsl#method_missing()","bundler::remotespecification#method_missing()","drb::drbobject#method_missing()","drb::drbobject#method_missing()","drb::threadobject#method_missing()","delegator#method_missing()","rexml::quickpath::method_missing()","racc::grammar::definitionenv#method_missing()","win32ole#method_missing()","win32ole_record#method_missing()","bundler::thor::method_option()","bundler::thor::method_options()","module#method_removed()","module#method_undefined()","bundler::rubygemsintegration#method_visibility()","delegator#methods()","object#methods()","win32ole#methods()","rdoc::context#methods_by_type()","rdoc::context#methods_matching()","gem::gemcutterutilities#mfa_unauthorized?()","rss::atom::feed::entry::content#mime_split()","webrick::httputils::mime_type()","webrick::httputils#mime_type()","array#min()","date#min()","datetime#min()","enumerable#min()","range#min()","time#min()","enumerable#min_by()","bundler::persistent::net::http::persistent#min_version=()","openssl::ssl::sslcontext#min_version=()","bundler::currentruby#mingw?()","racc::parserfilegenerator#minimum_indent()","array#minmax()","enumerable#minmax()","range#minmax()","enumerable#minmax_by()","matrix#minor()","bundler::gemversionpromoter#minor?()","win32ole_type#minor_version()","win32ole_typelib#minor_version()","date#minute()","datetime#minute()","rss::itunesitemmodel::itunesduration#minute=()","rss::maker::itunesitemmodel::itunesdurationbase#minute=()","bundler::settings#mirror_for()","bundler::stubspecification#missing_extensions?()","gem::specification#missing_extensions?()","bundler::parallelinstaller::specinstallation#missing_lockfile_dependencies()","bundler::definition#missing_specs()","bundler::definition#missing_specs?()","gem::bundlerversionfinder::missing_version_message()","date#mjd()","net::http#mkcol()","bundler::fileutils::mkdir()","bundler::fileutils#mkdir()","dir::mkdir()","fileutils::mkdir()","fileutils#mkdir()","gem::package::tarwriter#mkdir()","net::ftp#mkdir()","pathname#mkdir()","bundler::mkdir_p()","bundler::fileutils::mkdir_p()","bundler::fileutils#mkdir_p()","fileutils::mkdir_p()","fileutils#mkdir_p()","gem::commands::setupcommand::makedirs#mkdir_p()","gem::package#mkdir_p_safe()","file::mkfifo()","racc::statetransitiontablegenerator#mkmapexp()","bundler::fileutils#mkpath()","bundler::fileutils::mkpath()","fileutils#mkpath()","fileutils::mkpath()","pathname#mkpath()","time::mktime()","dir::mktmpdir()","net::ftp#mlsd()","net::ftp#mlst()","openssl::bn#mod_add()","openssl::bn#mod_exp()","openssl::bn#mod_inverse()","openssl::bn#mod_mul()","openssl::bn#mod_sqr()","openssl::bn#mod_sub()","bigdecimal::mode()","file::stat#mode()","rss::element::models()","rdoc::mixin#module()","rdoc::classmodule#module?()","rdoc::normalmodule#module?()","module#module_eval()","module#module_exec()","module#module_function()","rdoc::store#module_names()","rdoc::context#modules()","rdoc::context#modules_hash()","rdoc::store#modules_hash()","bigdecimal#modulo()","float#modulo()","integer#modulo()","numeric#modulo()","date#mon()","time#mon()","monitor#mon_check_owner()","monitormixin#mon_check_owner()","monitor#mon_enter()","monitormixin#mon_enter()","monitor#mon_exit()","monitormixin#mon_exit()","monitormixin#mon_initialize()","monitor#mon_locked?()","monitormixin#mon_locked?()","monitor#mon_owned?()","monitormixin#mon_owned?()","monitor#mon_synchronize()","monitormixin#mon_synchronize()","monitor#mon_try_enter()","monitormixin#mon_try_enter()","date#monday?()","time#monday?()","bundler::connectionpool::monotonic_time()","date#month()","time#month()","time::month_days()","webrick::httpserver#mount()","webrick::httpserver#mount_proc()","pathname#mountpoint?()","bundler::fileutils::move()","bundler::fileutils#move()","fileutils::move()","fileutils#move()","net::http#move()","net::imap#move()","rinda::tuplespace#move()","bundler::gemversionpromoter#move_version_to_end()","bundler::currentruby#mri?()","bundler::currentruby#mswin64?()","bundler::currentruby#mswin?()","file::mtime()","file#mtime()","file::stat#mtime()","net::ftp#mtime()","pathname#mtime()","zlib::gzipfile#mtime()","zlib::gzipwriter#mtime=()","mutex_m#mu_lock()","mutex_m#mu_locked?()","gem::testcase#mu_pp()","mutex_m#mu_synchronize()","mutex_m#mu_try_lock()","mutex_m#mu_unlock()","openssl::pkey::ec::point#mul()","bigdecimal#mult()","cgi::queryextension#multipart?()","net::imap::bodytypeattachment#multipart?()","net::imap::bodytypebasic#multipart?()","net::imap::bodytypeextension#multipart?()","net::imap::bodytypemessage#multipart?()","net::imap::bodytypemultipart#multipart?()","net::imap::bodytypetext#multipart?()","cgi::htmlextension#multipart_form()","stringscanner::must_c_version()","rss::element::must_call_validators()","bundler::thor::shell::basic#mute()","bundler::thor::shell::basic#mute?()","bundler::fileutils::mv()","bundler::fileutils#mv()","fileutils#mv()","fileutils::mv()","net::pop3#n_bytes()","racc::parserfilegenerator#n_indent()","irb::jobmanager#n_jobs()","net::pop3#n_mails()","racc::state#n_rrconflicts()","racc::states#n_rrconflicts()","racc::state#n_srconflicts()","racc::states#n_srconflicts()","racc::grammar#n_useless_nonterminals()","racc::grammar#n_useless_rules()","bundler::depproxy#name()","bundler::gemhelper#name()","bundler::molinillo::delegates::resolutionstate#name()","bundler::source::git#name()","bundler::source::path#name()","bundler::source::rubygems#name()","encoding#name()","gem::basicspecification#name()","gem::resolver::activationrequest#name()","gem::resolver::dependencyrequest#name()","gem::resolver::molinillo::delegates::resolutionstate#name()","gem::resolver::specspecification#name()","gem::unsatisfiabledependencyerror#name()","method#name()","module#name()","nameerror#name()","openssl::cipher#name()","openssl::digest#name()","openssl::engine#name()","openssl::pkcs7::signerinfo#name()","rdoc::anymethod#name()","rexml::document#name()","rexml::functions::name()","rexml::light::node#name()","rexml::notationdecl#name()","rexml::quickpath::name()","racc::ormark#name()","racc::prec#name()","racc::useraction#name()","socket::ifaddr#name()","thread#name()","unboundmethod#name()","win32ole_method#name()","win32ole_param#name()","win32ole_type#name()","win32ole_typelib#name()","win32ole_variable#name()","cgi::cookie#name=()","rdoc::classmodule#name=()","rexml::light::node#name=()","rexml::namespace#name=()","thread#name=()","bundler::molinillo::delegates::specificationprovider#name_for()","bundler::molinillo::specificationprovider#name_for()","bundler::resolver#name_for()","gem::resolver#name_for()","gem::resolver::molinillo::delegates::specificationprovider#name_for()","gem::resolver::molinillo::specificationprovider#name_for()","bundler::molinillo::delegates::specificationprovider#name_for_explicit_dependency_source()","bundler::molinillo::specificationprovider#name_for_explicit_dependency_source()","bundler::resolver#name_for_explicit_dependency_source()","gem::resolver::molinillo::delegates::specificationprovider#name_for_explicit_dependency_source()","gem::resolver::molinillo::specificationprovider#name_for_explicit_dependency_source()","bundler::molinillo::delegates::specificationprovider#name_for_locking_dependency_source()","bundler::molinillo::specificationprovider#name_for_locking_dependency_source()","bundler::resolver#name_for_locking_dependency_source()","gem::resolver::molinillo::delegates::specificationprovider#name_for_locking_dependency_source()","gem::resolver::molinillo::specificationprovider#name_for_locking_dependency_source()","rdoc::classmodule#name_for_path()","rdoc::context#name_for_path()","encoding::name_list()","gem::security::trustdir#name_path()","gem::commands::dependencycommand#name_pattern()","rdoc::alias#name_prefix()","rdoc::methodattr#name_prefix()","gem::resolver::activationrequest#name_tuple()","gem::specification#name_tuple()","matchdata#named_captures()","regexp#named_captures()","bundler::compactindexclient#names()","bundler::compactindexclient::cache#names()","encoding#names()","matchdata#names()","regexp#names()","bundler::compactindexclient::cache#names_path()","bundler::thor::base::classmethods#namespace()","object#namespace()","rexml::attribute#namespace()","rexml::element#namespace()","rexml::light::node#namespace()","rexml::light::node#namespace=()","rexml::functions::namespace_context()","rexml::functions::namespace_context=()","bundler::thor::util::namespace_from_thor_class()","rexml::light::node#namespace_of()","rexml::functions::namespace_uri()","rexml::attributes#namespaces()","rexml::element#namespaces()","rexml::parsers::xpathparser#namespaces=()","rexml::xpathparser#namespaces=()","bundler::thor::util::namespaces_in_content()","rexml::light::node#namesplit()","bigdecimal#nan?()","float#nan?()","psych::visitors::depthfirst#nary()","ipaddr#native()","net::imap::digestmd5authenticator#nc()","rss::atom::feed::entry::content#need_base64_encode?()","rss::element#need_base64_encode?()","csv::fieldsconverter#need_convert?()","rss::element::need_initialize_variables()","rss::maker::base::need_initialize_variables()","rinda::tuplespace#need_keeper?()","rss::atom::commonmodel::need_parent?()","rss::element::need_parent?()","rexml::parsers::baseparser#need_source_encoding_update?()","csv::fieldsconverter#need_static_convert?()","gem::needs()","float#negative?()","numeric#negative?()","openssl::bn#negative?()","rational#negative?()","prettyprint#nest()","module::nesting()","socket::ifaddr#netmask()","acl::new()","acl::aclentry::new()","acl::acllist::new()","addrinfo::new()","array::new()","basicobject::new()","benchmark::tms::new()","bundler::cli::new()","bundler::cli::add::new()","bundler::cli::binstubs::new()","bundler::cli::cache::new()","bundler::cli::check::new()","bundler::cli::clean::new()","bundler::cli::config::base::new()","bundler::cli::console::new()","bundler::cli::doctor::new()","bundler::cli::exec::new()","bundler::cli::gem::new()","bundler::cli::info::new()","bundler::cli::init::new()","bundler::cli::inject::new()","bundler::cli::install::new()","bundler::cli::list::new()","bundler::cli::lock::new()","bundler::cli::open::new()","bundler::cli::outdated::new()","bundler::cli::package::new()","bundler::cli::platform::new()","bundler::cli::pristine::new()","bundler::cli::remove::new()","bundler::cli::show::new()","bundler::cli::update::new()","bundler::cli::viz::new()","bundler::compactindexclient::new()","bundler::compactindexclient::cache::new()","bundler::compactindexclient::updater::new()","bundler::compactindexclient::updater::mismatchedchecksumerror::new()","bundler::connectionpool::new()","bundler::connectionpool::timedstack::new()","bundler::connectionpool::wrapper::new()","bundler::definition::new()","bundler::depproxy::new()","bundler::dependency::new()","bundler::dsl::new()","bundler::dsl::dslerror::new()","bundler::endpointspecification::new()","bundler::environmentpreserver::new()","bundler::featureflag::new()","bundler::fetcher::new()","bundler::fetcher::authenticationrequirederror::new()","bundler::fetcher::badauthenticationerror::new()","bundler::fetcher::base::new()","bundler::fetcher::certificatefailureerror::new()","bundler::fetcher::downloader::new()","bundler::fetcher::sslerror::new()","bundler::gemhelper::new()","bundler::geminstaller::new()","bundler::gemrequireerror::new()","bundler::gemversionpromoter::new()","bundler::gemdeps::new()","bundler::genericsystemcallerror::new()","bundler::graph::new()","bundler::graph::graphvizclient::new()","bundler::index::new()","bundler::injector::new()","bundler::installer::new()","bundler::lazyspecification::new()","bundler::lockfilegenerator::new()","bundler::lockfileparser::new()","bundler::mirrorsockets::new()","bundler::molinillo::circulardependencyerror::new()","bundler::molinillo::dependencygraph::new()","bundler::molinillo::dependencygraph::addedgenocircular::new()","bundler::molinillo::dependencygraph::deleteedge::new()","bundler::molinillo::dependencygraph::detachvertexnamed::new()","bundler::molinillo::dependencygraph::log::new()","bundler::molinillo::dependencygraph::tag::new()","bundler::molinillo::dependencygraph::vertex::new()","bundler::molinillo::nosuchdependencyerror::new()","bundler::molinillo::resolver::new()","bundler::molinillo::resolver::resolution::new()","bundler::molinillo::versionconflict::new()","bundler::parallelinstaller::new()","bundler::parallelinstaller::specinstallation::new()","bundler::permissionerror::new()","bundler::persistent::net::http::persistent::new()","bundler::plugin::api::source::new()","bundler::plugin::dsl::new()","bundler::plugin::index::new()","bundler::plugin::index::commandconflict::new()","bundler::plugin::index::sourceconflict::new()","bundler::remotespecification::new()","bundler::resolver::new()","bundler::resolver::specgroup::new()","bundler::retry::new()","bundler::rubyversion::new()","bundler::rubygemsintegration::new()","bundler::runtime::new()","bundler::settings::new()","bundler::settings::mirror::new()","bundler::settings::mirrorconfig::new()","bundler::settings::mirrors::new()","bundler::settings::validator::rule::new()","bundler::similaritydetector::new()","bundler::socketaddress::new()","bundler::source::gemspec::new()","bundler::source::git::new()","bundler::source::git::gitcommanderror::new()","bundler::source::git::gitnotallowederror::new()","bundler::source::git::gitnotinstallederror::new()","bundler::source::git::gitproxy::new()","bundler::source::git::missinggitrevisionerror::new()","bundler::source::path::new()","bundler::source::path::installer::new()","bundler::source::rubygems::new()","bundler::source::rubygems::remote::new()","bundler::sourcelist::new()","bundler::specset::new()","bundler::standalone::new()","bundler::thor::actions::new()","bundler::thor::base::new()","bundler::thor::command::new()","bundler::thor::command::new()","bundler::thor::coreext::orderedhash::new()","bundler::thor::dynamiccommand::new()","bundler::thor::dynamiccommand::new()","bundler::thor::lineeditor::basic::new()","bundler::thor::lineeditor::readline::pathcompletion::new()","bundler::thor::nestedcontext::new()","bundler::thor::shell::new()","bundler::ui::rgproxy::new()","bundler::ui::shell::new()","bundler::ui::silent::new()","bundler::uri::ftp::new()","bundler::uri::generic::new()","bundler::uri::ldap::new()","bundler::uri::mailto::new()","bundler::uri::rfc2396_parser::new()","bundler::uri::rfc2396_parser::new()","bundler::versionconflict::new()","bundler::worker::new()","bundler::worker::wrappedexception::new()","bundler::yamlsyntaxerror::new()","cgi::new()","cgi::cookie::new()","cgi::session::new()","cgi::session::filestore::new()","cgi::session::memorystore::new()","cgi::session::nullstore::new()","cgi::session::pstore::new()","csv::new()","csv::fieldsconverter::new()","csv::malformedcsverror::new()","csv::parser::new()","csv::parser::inputsscanner::new()","csv::parser::scanner::new()","csv::parser::unoptimizedstringio::new()","csv::row::new()","csv::table::new()","csv::writer::new()","class::new()","class#new()","conditionvariable::new()","dbm::new()","drb::drbarray::new()","drb::drbobject::new()","drb::drbobject::new()","drb::drbremoteerror::new()","drb::drbsslsocket::new()","drb::drbsslsocket::sslconfig::new()","drb::drbserver::new()","drb::drbunknown::new()","drb::drbunknownerror::new()","drb::extserv::new()","drb::extservmanager::new()","drb::gw::new()","drb::threadobject::new()","drb::timeridconv::new()","drb::weakidconv::new()","drb::weakidconv::weakset::new()","date::new()","datetime::new()","delegator::new()","digest::instance#new()","dir::new()","erb::new()","encoding::converter::new()","enumerator::new()","enumerator::chain::new()","enumerator::lazy::new()","exception::new()","exceptionformatrix::errdimensionmismatch::new()","exceptionformatrix::errnotregular::new()","exceptionformatrix::erroperationnotdefined::new()","exceptionformatrix::erroperationnotimplemented::new()","fiddle::cstructentity::new()","fiddle::closure::new()","fiddle::closure::blockcaller::new()","fiddle::compositehandler::new()","fiddle::function::new()","fiddle::handle::new()","fiddle::pointer::new()","file::new()","file::stat::new()","frozenerror::new()","gdbm::new()","gem::availableset::new()","gem::basicspecification::new()","gem::command::new()","gem::commandmanager::new()","gem::commands::buildcommand::new()","gem::commands::certcommand::new()","gem::commands::checkcommand::new()","gem::commands::cleanupcommand::new()","gem::commands::contentscommand::new()","gem::commands::dependencycommand::new()","gem::commands::environmentcommand::new()","gem::commands::fetchcommand::new()","gem::commands::generateindexcommand::new()","gem::commands::helpcommand::new()","gem::commands::infocommand::new()","gem::commands::installcommand::new()","gem::commands::listcommand::new()","gem::commands::lockcommand::new()","gem::commands::mirrorcommand::new()","gem::commands::opencommand::new()","gem::commands::outdatedcommand::new()","gem::commands::ownercommand::new()","gem::commands::pristinecommand::new()","gem::commands::pushcommand::new()","gem::commands::querycommand::new()","gem::commands::rdoccommand::new()","gem::commands::searchcommand::new()","gem::commands::servercommand::new()","gem::commands::setupcommand::new()","gem::commands::signincommand::new()","gem::commands::signoutcommand::new()","gem::commands::sourcescommand::new()","gem::commands::specificationcommand::new()","gem::commands::stalecommand::new()","gem::commands::uninstallcommand::new()","gem::commands::unpackcommand::new()","gem::commands::updatecommand::new()","gem::commands::whichcommand::new()","gem::commands::yankcommand::new()","gem::configfile::new()","gem::conflicterror::new()","gem::consoleui::new()","gem::dependency::new()","gem::dependencyinstaller::new()","gem::dependencylist::new()","gem::dependencyresolutionerror::new()","gem::doctor::new()","gem::ext::builder::new()","gem::fakefetcher::new()","gem::filepermissionerror::new()","gem::gemrunner::new()","gem::impossibledependencieserror::new()","gem::indexer::new()","gem::installer::new()","gem::installer::fakepackage::new()","gem::list::new()","gem::missingspecerror::new()","gem::missingspecversionerror::new()","gem::mockgemui::new()","gem::mockgemui::inputeoferror::new()","gem::mockgemui::termerror::new()","gem::nametuple::new()","gem::package::new()","gem::package::digestio::new()","gem::package::formaterror::new()","gem::package::old::new()","gem::package::patherror::new()","gem::package::tarheader::new()","gem::package::tarreader::new()","gem::package::tarreader::new()","gem::package::tarreader::entry::new()","gem::package::tarwriter::new()","gem::package::tarwriter::new()","gem::package::tarwriter::boundedstream::new()","gem::package::tarwriter::restrictedstream::new()","gem::packagetask::new()","gem::pathsupport::new()","gem::platform::new()","gem::platformmismatch::new()","gem::remotefetcher::new()","gem::remotefetcher::fetcherror::new()","gem::request::new()","gem::requestset::new()","gem::requestset::gemdependencyapi::new()","gem::requestset::lockfile::new()","gem::requestset::lockfile::parseerror::new()","gem::requestset::lockfile::parser::new()","gem::requestset::lockfile::tokenizer::new()","gem::requirement::new()","gem::resolver::new()","gem::resolver::apiset::new()","gem::resolver::apispecification::new()","gem::resolver::activationrequest::new()","gem::resolver::bestset::new()","gem::resolver::composedset::new()","gem::resolver::conflict::new()","gem::resolver::dependencyrequest::new()","gem::resolver::indexspecification::new()","gem::resolver::installerset::new()","gem::resolver::lockset::new()","gem::resolver::lockspecification::new()","gem::resolver::molinillo::circulardependencyerror::new()","gem::resolver::molinillo::dependencygraph::new()","gem::resolver::molinillo::dependencygraph::addedgenocircular::new()","gem::resolver::molinillo::dependencygraph::deleteedge::new()","gem::resolver::molinillo::dependencygraph::detachvertexnamed::new()","gem::resolver::molinillo::dependencygraph::log::new()","gem::resolver::molinillo::dependencygraph::tag::new()","gem::resolver::molinillo::dependencygraph::vertex::new()","gem::resolver::molinillo::nosuchdependencyerror::new()","gem::resolver::molinillo::resolver::new()","gem::resolver::molinillo::resolver::resolution::new()","gem::resolver::molinillo::versionconflict::new()","gem::resolver::requirementlist::new()","gem::resolver::sourceset::new()","gem::resolver::specspecification::new()","gem::resolver::specification::new()","gem::resolver::stats::new()","gem::s3urisigner::new()","gem::s3urisigner::configurationerror::new()","gem::s3urisigner::instanceprofileerror::new()","gem::security::policy::new()","gem::security::signer::new()","gem::security::trustdir::new()","gem::server::new()","gem::silentui::new()","gem::source::new()","gem::source::git::new()","gem::source::lock::new()","gem::source::specificfile::new()","gem::source::vendor::new()","gem::sourcefetchproblem::new()","gem::sourcelist::new()","gem::specfetcher::new()","gem::specificgemnotfoundexception::new()","gem::specification::new()","gem::specificationpolicy::new()","gem::streamui::new()","gem::streamui::silentdownloadreporter::new()","gem::streamui::silentprogressreporter::new()","gem::streamui::simpleprogressreporter::new()","gem::streamui::threadeddownloadreporter::new()","gem::streamui::verboseprogressreporter::new()","gem::systemexitexception::new()","gem::testcase::staticset::new()","gem::uninstaller::new()","gem::unsatisfiabledependencyerror::new()","gem::uriformatter::new()","gem::version::new()","getoptlong::new()","hash::new()","io::new()","ipaddr::new()","irb::canvas::new()","irb::color::symbolstate::new()","irb::context::new()","irb::fileinputmethod::new()","irb::frame::new()","irb::frame::frameoverflow::new()","irb::frame::frameunderflow::new()","irb::inputmethod::new()","irb::inspector::new()","irb::irb::new()","irb::jobmanager::new()","irb::locale::new()","irb::notifier::abstractnotifier::new()","irb::notifier::compositenotifier::new()","irb::notifier::errundefinednotifier::new()","irb::notifier::errunrecognizedlevel::new()","irb::notifier::levelednotifier::new()","irb::notifier::nomsgnotifier::new()","irb::outputmethod::notimplementederror::new()","irb::readlineinputmethod::new()","irb::reidlineinputmethod::new()","irb::rubymodel::new()","irb::stdioinputmethod::new()","irb::vec::new()","irb::workspace::new()","json::ext::generator::state::new()","json::ext::parser::new()","keyerror::new()","logger::new()","matrix::new()","matrix::eigenvaluedecomposition::new()","matrix::lupdecomposition::new()","module::new()","monitormixin::new()","monitormixin::conditionvariable::new()","mutex::new()","nameerror::new()","net::ftp::new()","net::ftp::mlsxentry::new()","net::http::new()","net::http::new()","net::httpgenericrequest::new()","net::httprequest::new()","net::imap::new()","net::imap::crammd5authenticator::new()","net::imap::digestmd5authenticator::new()","net::imap::loginauthenticator::new()","net::imap::plainauthenticator::new()","net::imap::responseerror::new()","net::pop3::new()","net::readtimeout::new()","net::smtp::new()","net::smtp::response::new()","net::writeadapter::new()","net::writetimeout::new()","nomethoderror::new()","oleproperty::new()","openssl::asn1::asn1data::new()","openssl::asn1::constructive::new()","openssl::asn1::primitive::new()","openssl::bn::new()","openssl::buffering::new()","openssl::cipher::new()","openssl::config::new()","openssl::digest::new()","openssl::hmac::new()","openssl::netscape::spki::new()","openssl::ocsp::basicresponse::new()","openssl::ocsp::certificateid::new()","openssl::ocsp::request::new()","openssl::ocsp::response::new()","openssl::ocsp::singleresponse::new()","openssl::pkcs12::new()","openssl::pkcs7::new()","openssl::pkcs7::recipientinfo::new()","openssl::pkcs7::signerinfo::new()","openssl::pkey::dh::new()","openssl::pkey::dsa::new()","openssl::pkey::ec::new()","openssl::pkey::ec::group::new()","openssl::pkey::ec::point::new()","openssl::pkey::pkey::new()","openssl::pkey::rsa::new()","openssl::ssl::sslcontext::new()","openssl::ssl::sslserver::new()","openssl::ssl::sslsocket::new()","openssl::ssl::session::new()","openssl::x509::attribute::new()","openssl::x509::crl::new()","openssl::x509::certificate::new()","openssl::x509::extension::new()","openssl::x509::extensionfactory::new()","openssl::x509::name::new()","openssl::x509::request::new()","openssl::x509::revoked::new()","openssl::x509::store::new()","openssl::x509::storecontext::new()","openstruct::new()","openuri::httperror::new()","openuri::httpredirect::new()","optionparser#new()","optionparser::new()","optionparser::arguable::new()","optionparser::list::new()","optionparser::parseerror::new()","optionparser::switch::new()","pstore::new()","pathname::new()","pool::new()","prettyprint::new()","prettyprint::singleline::new()","prime::eratosthenesgenerator::new()","prime::eratosthenessieve::new()","prime::generator23::new()","prime::pseudoprimegenerator::new()","prime::trialdivisiongenerator::new()","proc::new()","psych::classloader::restricted::new()","psych::coder::new()","psych::disallowedclass::new()","psych::emitter::new()","psych::handler::dumperoptions::new()","psych::handlers::recorder::new()","psych::nodes::alias::new()","psych::nodes::document::new()","psych::nodes::mapping::new()","psych::nodes::node::new()","psych::nodes::scalar::new()","psych::nodes::sequence::new()","psych::nodes::stream::new()","psych::parser::new()","psych::scalarscanner::new()","psych::streaming::classmethods#new()","psych::syntaxerror::new()","psych::syntaxerror::new()","psych::treebuilder::new()","psych::visitors::depthfirst::new()","psych::visitors::emitter::new()","psych::visitors::toruby::new()","psych::visitors::yamltree::new()","queue::new()","rdoc::alias::new()","rdoc::anymethod::new()","rdoc::attr::new()","rdoc::classmodule::new()","rdoc::codeobject::new()","rdoc::comment::new()","rdoc::constant::new()","rdoc::context::new()","rdoc::crossreference::new()","rdoc::erbio::new()","rdoc::markdown::new()","rdoc::markup::new()","rdoc::methodattr::new()","rdoc::mixin::new()","rdoc::parser::new()","rdoc::parser::c::new()","rdoc::parser::ripperstatelex::new()","rdoc::parser::ripperstatelex::innerstatelex::new()","rdoc::parser::ruby::new()","rdoc::parser::simple::new()","rdoc::rdoc::new()","rdoc::require::new()","rdoc::rubygemshook::new()","rdoc::rubygemshook::new()","rdoc::servlet::new()","rdoc::stats::new()","rdoc::store::new()","rdoc::store::missingfileerror::new()","rdoc::task::new()","rdoc::task::new()","rdoc::tomdoc::new()","rdoc::toplevel::new()","rexml::attlistdecl::new()","rexml::attribute::new()","rexml::attributes::new()","rexml::cdata::new()","rexml::child::new()","rexml::comment::new()","rexml::dtd::elementdecl::new()","rexml::dtd::entitydecl::new()","rexml::dtd::notationdecl::new()","rexml::declaration::new()","rexml::doctype::new()","rexml::document::new()","rexml::element::new()","rexml::elementdecl::new()","rexml::elements::new()","rexml::entity::new()","rexml::externalentity::new()","rexml::formatters::default::new()","rexml::formatters::pretty::new()","rexml::formatters::transitive::new()","rexml::iosource::new()","rexml::instruction::new()","rexml::light::node::new()","rexml::notationdecl::new()","rexml::output::new()","rexml::parent::new()","rexml::parseexception::new()","rexml::parsers::baseparser::new()","rexml::parsers::lightparser::new()","rexml::parsers::pullevent::new()","rexml::parsers::pullparser::new()","rexml::parsers::sax2parser::new()","rexml::parsers::streamparser::new()","rexml::parsers::treeparser::new()","rexml::parsers::ultralightparser::new()","rexml::referencewriter::new()","rexml::source::new()","rexml::text::new()","rexml::undefinednamespaceexception::new()","rexml::validation::choice::new()","rexml::validation::event::new()","rexml::validation::interleave::new()","rexml::validation::oneormore::new()","rexml::validation::ref::new()","rexml::validation::relaxng::new()","rexml::validation::state::new()","rexml::validation::validationexception::new()","rexml::xmldecl::new()","rexml::xpathnode::new()","rexml::xpathparser::new()","rss::atom::entry::new()","rss::atom::feed::new()","rss::baseparser::new()","rss::conversionerror::new()","rss::converter::new()","rss::element::new()","rss::ituneschannelmodel::itunescategory::new()","rss::ituneschannelmodel::itunesimage::new()","rss::ituneschannelmodel::itunesowner::new()","rss::itunesitemmodel::itunesduration::new()","rss::imagefaviconmodel::imagefavicon::new()","rss::imageitemmodel::imageitem::new()","rss::listenermixin::new()","rss::maker::atom::entry::new()","rss::maker::atom::feed::new()","rss::maker::base::new()","rss::maker::itemsbase::new()","rss::maker::rss09::new()","rss::maker::rss091::new()","rss::maker::rss092::new()","rss::maker::rss10::new()","rss::maker::rss20::new()","rss::maker::rssbase::new()","rss::missingattributeerror::new()","rss::missingtagerror::new()","rss::nserror::new()","rss::notavailablevalueerror::new()","rss::notexpectedtagerror::new()","rss::notseterror::new()","rss::notvalidxmlparser::new()","rss::notwellformederror::new()","rss::overlappedprefixerror::new()","rss::parser::new()","rss::rdf::new()","rss::rdf::bag::new()","rss::rdf::bag::new()","rss::rdf::channel::new()","rss::rdf::channel::image::new()","rss::rdf::channel::items::new()","rss::rdf::channel::textinput::new()","rss::rdf::image::new()","rss::rdf::item::new()","rss::rdf::li::new()","rss::rdf::li::new()","rss::rdf::li::new()","rss::rdf::seq::new()","rss::rdf::seq::new()","rss::rdf::textinput::new()","rss::rootelementmixin::new()","rss::rss::new()","rss::rss::channel::cloud::new()","rss::rss::channel::image::new()","rss::rss::channel::item::category::new()","rss::rss::channel::item::enclosure::new()","rss::rss::channel::item::guid::new()","rss::rss::channel::item::source::new()","rss::rss::channel::skipdays::day::new()","rss::rss::channel::skiphours::hour::new()","rss::rss::channel::textinput::new()","rss::taxonomytopicmodel::taxonomytopic::new()","rss::taxonomytopicsmodel::taxonomytopics::new()","rss::toomuchtagerror::new()","rss::unknownconversionmethoderror::new()","rss::unknowntagerror::new()","rss::unsupportedmakerversionerror::new()","rss::xml::element::new()","rss::xmlparsernotfound::new()","rss::xmlstylesheet::new()","rss::xmlstylesheetmixin::new()","racc::actiontable::new()","racc::debugflags::new()","racc::goto::new()","racc::grammar::new()","racc::grammar::definitionenv::new()","racc::grammar::precedencedefinitionenv::new()","racc::grammarfileparser::new()","racc::grammarfileparser::result::new()","racc::grammarfilescanner::new()","racc::iset::new()","racc::item::new()","racc::locationpointer::new()","racc::logfilegenerator::new()","racc::ormark::new()","racc::parserclassgenerator::new()","racc::parserfilegenerator::new()","racc::parserfilegenerator::params::new()","racc::prec::new()","racc::rrconflict::new()","racc::reduce::new()","racc::rule::new()","racc::srconflict::new()","racc::shift::new()","racc::sourcetext::new()","racc::state::new()","racc::statetransitiontable::new()","racc::statetransitiontablegenerator::new()","racc::states::new()","racc::sym::new()","racc::symboltable::new()","racc::useraction::new()","random::new()","range::new()","regexp::new()","reline::core::new()","resolv::new()","resolv::dns::new()","resolv::dns::resource::domainname::new()","resolv::dns::resource::generic::new()","resolv::dns::resource::hinfo::new()","resolv::dns::resource::in::a::new()","resolv::dns::resource::in::aaaa::new()","resolv::dns::resource::in::srv::new()","resolv::dns::resource::in::wks::new()","resolv::dns::resource::loc::new()","resolv::dns::resource::minfo::new()","resolv::dns::resource::mx::new()","resolv::dns::resource::soa::new()","resolv::dns::resource::txt::new()","resolv::hosts::new()","resolv::loc::alt::new()","resolv::loc::coord::new()","resolv::loc::size::new()","resolv::mdns::new()","rinda::drbobjecttemplate::new()","rinda::notifytemplateentry::new()","rinda::ringfinger::new()","rinda::ringprovider::new()","rinda::ringserver::new()","rinda::simplerenewer::new()","rinda::tuple::new()","rinda::tuplebag::tuplebin::new()","rinda::tupleentry::new()","rinda::tuplespace::new()","rinda::tuplespaceproxy::new()","rinda::waittemplateentry::new()","ripper::new()","ripper::filter::new()","rubyvm::instructionsequence::new()","sdbm::new()","sockssocket::new()","sockssocket::new()","set::new()","signalexception::new()","sizedqueue::new()","socket::new()","socket::ancillarydata::new()","socket::option::new()","socket::udpsource::new()","string::new()","stringio::new()","stringscanner::new()","struct::new()","syntaxerror::new()","syslog::logger::new()","systemcallerror::new()","systemexit::new()","tcpserver::new()","tcpsocket::new()","tcpsocket::new()","tempio::new()","tempfile::new()","thread::new()","time::new()","tracepoint::new()","udpsocket::new()","unixserver::new()","unixsocket::new()","uri::ftp::new()","uri::generic::new()","uri::ldap::new()","uri::mailto::new()","uri::rfc2396_parser::new()","uri::rfc2396_parser::new()","uncaughtthrowerror::new()","undefinedcommanderror::new()","undefinedcommanderror::new()","undefinedcommanderror::spellchecker::new()","unknownargumenterror::new()","unknownargumenterror::spellchecker::new()","vector::new()","webrick::basiclog::new()","webrick::cgi::new()","webrick::cookie::new()","webrick::genericserver::new()","webrick::httpauth::basicauth::new()","webrick::httpauth::digestauth::new()","webrick::httpauth::htdigest::new()","webrick::httpauth::htgroup::new()","webrick::httpauth::htpasswd::new()","webrick::httpproxyserver::new()","webrick::httprequest::new()","webrick::httpresponse::new()","webrick::httpserver::new()","webrick::httpservlet::abstractservlet::new()","webrick::httpservlet::cgihandler::new()","webrick::httpservlet::defaultfilehandler::new()","webrick::httpservlet::erbhandler::new()","webrick::httpservlet::filehandler::new()","webrick::httputils::formdata::new()","webrick::httpversion::new()","webrick::log::new()","webrick::snirequest::new()","webrick::utils::timeouthandler::new()","win32ole::new()","win32ole_event::new()","win32ole_method::new()","win32ole_param::new()","win32ole_record::new()","win32ole_type::new()","win32ole_typelib::new()","win32ole_variant::new()","weakref::new()","xmp::new()","xmp::stringinputmethod::new()","yaml::store::new()","zlib::deflate::new()","zlib::gzipreader::new()","zlib::gzipwriter::new()","zlib::inflate::new()","date::new!()","irb::methodextender#new_alias_name()","rdoc::parser::ruby#new_comment()","monitor#new_cond()","monitormixin#new_cond()","gem::testcase#new_default_spec()","net::smtp#new_internet_message_io()","ipaddr::new_ntoh()","datetime#new_offset()","bundler::definition#new_platform?()","random::new_seed()","gem::resolver::molinillo::resolver::resolution#new_spec_satisfied?()","bundler::definition#new_specs()","date#new_start()","erb#new_toplevel()","bundler::cli::config::base#new_value()","drb::drbobject::new_with()","drb::drbobject::new_with()","drb::drbobject::new_with_uri()","drb::drbobject::new_with_uri()","rss::utils#new_with_value_if_need()","net::http::newobj()","date#next()","enumerator#next()","integer#next()","prime::eratosthenesgenerator#next()","prime::generator23#next()","prime::pseudoprimegenerator#next()","prime::trialdivisiongenerator#next()","rexml::validation::choice#next()","rexml::validation::interleave#next()","rexml::validation::oneormore#next()","rexml::validation::optional#next()","rexml::validation::state#next()","rexml::validation::zeroormore#next()","racc::locationpointer#next()","string#next()","symbol#next()","string#next!()","gem::resolver::requirementlist#next5()","rexml::validation::interleave#next_current()","date#next_day()","rexml::element#next_element()","float#next_float()","racc::grammarfilescanner#next_line()","date#next_month()","rexml::child#next_sibling=()","rexml::node#next_sibling_node()","rexml::xpathparser#next_sibling_node()","gem::requestset::lockfile::tokenizer#next_token()","racc::grammarfileparser#next_token()","racc::parser#next_token()","openssl::ocsp::singleresponse#next_update()","openssl::x509::crl#next_update()","openssl::x509::crl#next_update=()","enumerator#next_values()","date#next_year()","racc::grammar#nfa()","racc::states#nfa()","nilclass#nil?()","object#nil?()","nkf::nkf()","file::stat#nlink()","newton#nlsolve()","net::ftp#nlst()","gem::testcase#nmake_found?()","bundler::thor::shell::basic#no?()","bundler::ui::shell#no?()","bundler::ui::silent#no?()","bundler::thor::base::classmethods#no_commands()","bundler::thor::base::classmethods#no_commands?()","bundler::thor::base::classmethods#no_commands_context()","bundler::thor::base::classmethods#no_tasks()","integer#nobits?()","rexml::xpathparser#node_test()","rexml::attlistdecl#node_type()","rexml::attribute#node_type()","rexml::comment#node_type()","rexml::doctype#node_type()","rexml::document#node_type()","rexml::element#node_type()","rexml::instruction#node_type()","rexml::light::node#node_type()","rexml::text#node_type()","rexml::xmldecl#node_type()","gem::mockgemui::tty#noecho()","io#noecho()","rdoc::classmodule#non_aliases()","gem::specification::non_nil_attributes()","racc::grammar::precedencedefinitionenv#nonassoc()","io#nonblock()","io#nonblock=()","io#nonblock?()","gem::specification#nondevelopment_dependencies()","array#none?()","enumerable#none?()","gem::requirement#none?()","racc::sym#nonterminal?()","racc::grammar#nonterminal_base()","racc::symboltable#nonterminals()","bigdecimal#nonzero?()","numeric#nonzero?()","net::ftp#noop()","net::imap#noop()","rexml::xpathparser#norm()","vector#norm()","matrix#normal?()","bundler::uri::generic#normalize()","gem::specification#normalize()","gem::uriformatter#normalize()","irb::vec#normalize()","rdoc::comment#normalize()","rexml::parsers::baseparser#normalize()","rexml::text::normalize()","rss::maker::itemsbase#normalize()","uri::generic#normalize()","vector#normalize()","bundler::uri::generic#normalize!()","uri::generic#normalize!()","rdoc::text#normalize_comment()","rexml::xpathparser#normalize_compare_values()","csv#normalize_converters()","bundler::dsl#normalize_group_options()","bundler::cli::install#normalize_groups()","bundler::dsl#normalize_hash()","bundler::dsl#normalize_options()","gem::package#normalize_path()","webrick::httputils::normalize_path()","webrick::httputils#normalize_path()","rss::parser#normalize_rss()","net::imap#normalize_searching_criteria()","bundler::cli::install#normalize_settings()","bundler::dsl#normalize_source()","rexml::functions::normalize_space()","bundler::persistent::net::http::persistent#normalize_uri()","bundler::settings::normalize_uri()","bundler::source::rubygems#normalize_uri()","gem::specification::normalize_yaml_input()","rexml::entity#normalized()","rdoc::rdoc#normalized_file_list()","rexml::functions::not()","openssl::x509::certificate#not_after()","openssl::x509::certificate#not_after=()","openssl::x509::certificate#not_before()","openssl::x509::certificate#not_before=()","bundler::thor::command#not_debugging?()","bundler::thor::command#not_debugging?()","rdoc::servlet#not_found()","rss::rss::channel#not_need_to_call_setup_maker_variables()","rss::setupmaker#not_need_to_call_setup_maker_variables()","rss::maker::atom::entry::channel::generator::not_set_name()","rss::maker::atom::feed::channel::categories::category::not_set_name()","rss::maker::atom::feed::channel::generator::not_set_name()","rss::maker::atom::feed::channel::links::link::not_set_name()","rss::maker::atom::feed::items::item::categories::category::not_set_name()","rss::maker::atom::feed::items::item::links::link::not_set_name()","rss::maker::atom::feed::items::item::source::categories::category::not_set_name()","rss::maker::atom::feed::items::item::source::generator::not_set_name()","rss::maker::atom::feed::items::item::source::links::link::not_set_name()","rss::maker::atom::feed::items::item::source::logo::not_set_name()","rss::maker::atom::entry::items::item#not_set_required_variables()","rss::maker::atom::feed::channel#not_set_required_variables()","rss::maker::atom::feed::items::item#not_set_required_variables()","rss::maker::base#not_set_required_variables()","rss::maker::rss09::channel#not_set_required_variables()","rss::maker::rss09::items::item#not_set_required_variables()","rss::maker::rss10::channel#not_set_required_variables()","rss::maker::rss10::items::item#not_set_required_variables()","rss::maker::rss20::items::item#not_set_required_variables()","rexml::doctype#notation()","rexml::sax2listener#notationdecl()","rexml::streamlistener#notationdecl()","rexml::parsers::pullevent#notationdecl?()","rexml::doctype#notations()","rdoc::markdown#note()","rdoc::markdown#note_for()","rdoc::markdown#notes()","bundler::definition#nothing_changed?()","bundler::cli::outdated#nothing_outdated_message()","racc::parserfilegenerator#notice()","rinda::notifytemplateentry#notify()","rinda::tuplespace#notify()","rinda::tuplespaceproxy#notify()","irb::notifier::abstractnotifier#notify?()","irb::notifier::levelednotifier#notify?()","irb::notifier::nomsgnotifier#notify?()","rinda::tuplespace#notify_event()","drb::drbobservable#notify_observers()","observable#notify_observers()","optionparser#notwice()","datetime::now()","time::now()","rexml::xmldecl#nowrite()","openssl::ssl::sslsocket#npn_protocol()","etc::nprocessors()","io#nread()","rss::rootelementmixin#ns_declarations()","time#nsec()","racc::symboltable#nt_max()","date::nth_kday()","datetime::nth_kday()","date#nth_kday?()","ipaddr::ntop()","gem::nametuple::null()","racc::grammar::definitionenv#null()","racc::rule#null=()","racc::sym#null=()","fiddle::pointer#null?()","racc::rule#nullable?()","racc::sym#nullable?()","openssl::bn#num_bits()","openssl::bn#num_bytes()","queue#num_waiting()","sizedqueue#num_waiting()","rexml::functions::number()","complex#numerator()","float#numerator()","integer#numerator()","numeric#numerator()","rational#numerator()","pp::ppmethods#object_address_group()","rdoc::toplevel#object_class()","pp::ppmethods#object_group()","object#object_id()","json::ext::generator::state#object_nl()","json::ext::generator::state#object_nl=()","gem::package::tarheader#oct()","string#oct()","gem::package::tarheader::oct_or_256based()","integer#odd?()","openssl::bn#odd?()","rubyvm::abstractsyntaxtree::of()","rubyvm::instructionsequence::of()","tracer::off()","win32ole_event#off_event()","datetime#offset()","matchdata#offset()","win32ole_method#offset_vtbl()","io#oflush()","openssl::asn1::objectid#oid()","openssl::x509::attribute#oid()","openssl::x509::extension#oid()","openssl::x509::attribute#oid=()","openssl::x509::extension#oid=()","gem::dependencylist#ok?()","gem::dependencylist#ok_to_remove?()","rexml::xmldecl#old_enc=()","win32ole#ole_activex_initialize()","win32ole_type::ole_classes()","win32ole_typelib#ole_classes()","win32ole#ole_free()","win32ole::ole_free()","win32ole#ole_func_methods()","win32ole#ole_get_methods()","win32ole_record#ole_instance_variable_get()","win32ole_record#ole_instance_variable_set()","win32ole#ole_method()","win32ole#ole_method_help()","win32ole#ole_methods()","win32ole_type#ole_methods()","win32ole#ole_methods_safely()","win32ole#ole_obj_help()","win32ole#ole_put_methods()","win32ole#ole_query_interface()","win32ole::ole_reference_count()","win32ole#ole_respond_to?()","win32ole::ole_show_help()","win32ole#ole_type()","win32ole_param#ole_type()","win32ole_type#ole_type()","win32ole_variable#ole_type()","win32ole_param#ole_type_detail()","win32ole_variable#ole_type_detail()","win32ole#ole_typelib()","win32ole_type#ole_typelib()","win32ole_typelib#ole_types()","optionparser#on()","tracer::on()","rdoc::parser::ripperstatelex::innerstatelex#on_char()","rss::xmlscanlistener#on_attr_charref()","rss::xmlscanlistener#on_attr_charref_hex()","rss::xmlscanlistener#on_attr_entityref()","rss::xmlscanlistener#on_attr_value()","rss::xmlscanlistener#on_attribute()","rdoc::parser::ripperstatelex::innerstatelex#on_backref()","rss::xmlscanlistener#on_charref()","rss::xmlscanlistener#on_charref_hex()","rdoc::parser::ripperstatelex::innerstatelex#on_comma()","rdoc::parser::ripperstatelex::innerstatelex#on_comment()","net::http#on_connect()","rdoc::parser::ripperstatelex::innerstatelex#on_const()","openssl::pkey::ec::point#on_curve?()","rdoc::parser::ripperstatelex::innerstatelex#on_cvar()","rdoc::parser::ripperstatelex::innerstatelex#on_default()","ripper::filter#on_default()","rss::xmlscanlistener#on_entityref()","racc::grammarfileparser#on_error()","racc::parser#on_error()","rss::xmlscanlistener#on_etag()","win32ole_event#on_event()","win32ole_event#on_event_with_outargs()","rdoc::parser::ripperstatelex::innerstatelex#on_float()","rdoc::parser::ripperstatelex::innerstatelex#on_gvar()","optionparser#on_head()","rdoc::parser::ripperstatelex::innerstatelex#on_heredoc_beg()","rdoc::parser::ripperstatelex::innerstatelex#on_heredoc_end()","rdoc::parser::ripperstatelex::innerstatelex#on_ident()","rdoc::parser::ripperstatelex::innerstatelex#on_ignored_nl()","rdoc::parser::ripperstatelex::innerstatelex#on_ignored_sp()","rdoc::parser::ripperstatelex::innerstatelex#on_imaginary()","rdoc::parser::ripperstatelex::innerstatelex#on_int()","rdoc::parser::ripperstatelex::innerstatelex#on_ivar()","rdoc::parser::ripperstatelex::innerstatelex#on_kw()","rdoc::parser::ripperstatelex::innerstatelex#on_lbrace()","rdoc::parser::ripperstatelex::innerstatelex#on_lbracket()","rdoc::parser::ripperstatelex::innerstatelex#on_lparen()","rdoc::parser::ripperstatelex::innerstatelex#on_nl()","rdoc::parser::ripperstatelex::innerstatelex#on_op()","rdoc::parser::ripperstatelex::innerstatelex#on_period()","rdoc::parser::ripperstatelex::innerstatelex#on_rational()","rdoc::parser::ripperstatelex::innerstatelex#on_rbrace()","rdoc::parser::ripperstatelex::innerstatelex#on_rbracket()","rdoc::parser::ripperstatelex::innerstatelex#on_rparen()","rdoc::parser::ripperstatelex::innerstatelex#on_sp()","rss::xmlscanlistener#on_stag()","rss::xmlscanlistener#on_stag_end()","rss::xmlscanlistener#on_stag_end_empty()","rdoc::parser::ripperstatelex::innerstatelex#on_symbeg()","optionparser#on_tail()","rdoc::parser::ripperstatelex::innerstatelex#on_tstring_beg()","rdoc::parser::ripperstatelex::innerstatelex#on_tstring_end()","rdoc::parser::ripperstatelex::innerstatelex#on_variables()","pstore#on_windows?()","rss::xmlscanlistener#on_xmldecl_encoding()","rss::xmlscanlistener#on_xmldecl_end()","rss::xmlscanlistener#on_xmldecl_standalone()","rss::xmlscanlistener#on_xmldecl_version()","racc::sym::once_writer()","array#one?()","enumerable#one?()","openssl::bn#one?()","rdoc::context#ongoing_visibility=()","bundler::uri::generic#opaque=()","uri::generic#opaque=()","bundler::cli#open()","csv::open()","dbm::open()","drb::drbprotocol#open()","drb::drbprotocol::open()","drb::drbsslsocket::open()","dir::open()","file::open()","gdbm::open()","io::open()","kernel::open()","kernel#open()","net::ftp::open()","openuri::openread#open()","pty::open()","pathname#open()","resolv::dns::open()","sdbm::open()","stringio::open()","syslog::open()","tempfile#open()","tempfile::open()","uri::open()","zlib::gzipreader::open()","zlib::gzipwriter::open()","syslog::open!()","pstore#open_and_lock_file()","bundler::cli::gem#open_editor()","gem::commands::opencommand#open_editor()","gem::commands::opencommand#open_gem()","net::smtp#open_message_stream()","drb::drbprotocol::open_server()","drb::drbprotocol#open_server()","drb::drbsslsocket::open_server()","gem::fakefetcher#open_uri_or_path()","kernel#open_uri_original_open()","kernel::open_uri_original_open()","pathname#opendir()","syslog::opened?()","gem::operating_system_defaults()","bundler::thor::option()","net::ftp#option()","racc::grammar::definitionenv#option()","gem::command#option_is_deprecated?()","rdoc::task#option_list()","rdoc::task#option_list()","win32ole_param#optional?()","bundler::fileutils::options()","bundler::source::metadata#options()","bundler::source::rubygems#options()","bundler::thor::options()","fileutils::options()","net::http#options()","openssl::ssl::sslcontext#options()","optionparser::arguable#options()","rdoc::codeobject#options()","regexp#options()","syslog::options()","openssl::ssl::sslcontext#options=()","optionparser::arguable#options=()","bundler::fileutils::options_of()","fileutils::options_of()","bundler::plugin::api::source#options_to_lock()","socket::option#optname()","integer#ord()","string#ord()","openssl::pkey::ec::group#order()","optionparser#order()","optionparser#order!()","optionparser::arguable#order!()","getoptlong#ordering=()","date::ordinal()","datetime::ordinal()","rdoc::markdown#orig_initialize()","zlib::gzipfile#orig_name()","zlib::gzipwriter#orig_name=()","bundler::original_env()","bundler::original_exec()","method#original_name()","unboundmethod#original_name()","bundler::original_system()","matrix#orthogonal?()","zlib::gzipfile#os_code()","bundler::gemhelpers::platformmatch::os_match()","rss::maker::base::other_elements()","bundler::cli::doctor#otool_available?()","cgi#out()","rss::atom::feed::entry::content#out_of_line?()","rss::maker::itemsbase::itembase::contentbase#out_of_line?()","bundler::geminstaller#out_of_space_message()","racc::logfilegenerator#outact()","bundler::cli#outdated()","gem::specification::outdated()","bundler::cli::show#outdated?()","gem::specification::outdated_and_latest_version()","bundler::molinillo::ui#output()","gem::mockgemui#output()","gem::resolver#output()","gem::resolver::molinillo::ui#output()","racc::logfilegenerator#output()","readline::output=()","reline::core#output=()","win32ole_param#output?()","racc::logfilegenerator#output_conflict()","rss::rootelementmixin#output_encoding=()","rdoc::rdoc#output_flag_file()","reline::core#output_modifier_proc=()","rdoc::methodattr#output_name()","bundler::cli::common::output_post_install_messages()","gem::commands::querycommand#output_query_results()","racc::logfilegenerator#output_rule()","racc::logfilegenerator#output_state()","racc::logfilegenerator#output_token()","racc::logfilegenerator#output_useless()","gem::commands::querycommand#output_versions()","bundler::cli::common::output_without_groups_message()","racc::logfilegenerator#outrrconf()","racc::logfilegenerator#outsrconf()","bundler::source::git#override_for()","file::owned?()","file::stat#owned?()","filetest#owned?()","mutex#owned?()","pathname#owned?()","method#owner()","unboundmethod#owner()","kernel#p()","matrix::lupdecomposition#p()","array#pack()","racc::states#pack()","socket::pack_sockaddr_in()","socket::pack_sockaddr_un()","bundler::thor::package_name()","bundler::thor::shell::basic#padding=()","openssl::cipher#padding=()","rdoc::store#page()","rdoc::store#page_file()","rdoc::toplevel#page_name()","socket::pair()","unixsocket::pair()","rdoc::markdown#paragraph()","bundler::fetcher::compactindex#parallel_compact_index_client()","rdoc::anymethod#param_list()","rdoc::anymethod#param_seq()","method#parameters()","proc#parameters()","tracepoint#parameters()","unboundmethod#parameters()","openssl::pkey::dh#params()","openssl::pkey::dsa#params()","openssl::pkey::rsa#params()","win32ole_method#params()","zlib::deflate#params()","cgi::queryextension#params=()","openssl::pkey::dh#params_ok?()","gem::indexer#paranoid()","gem::resolver::activationrequest#parent()","pathname#parent()","rdoc::codeobject#parent()","rexml::light::node#parent()","rexml::child#parent=()","rexml::light::node#parent=()","rexml::text#parent=()","rexml::node#parent?()","rexml::parent#parent?()","rdoc::codeobject#parent_file_name()","rdoc::codeobject#parent_name()","rdoc::methodattr#parent_name()","bundler::molinillo::resolver::resolution#parent_of()","gem::resolver::molinillo::resolver::resolution#parent_of()","bundler::settings#parent_setting_for()","bundler::settings::mirrors#parse()","bundler::uri::parse()","bundler::uri::rfc2396_parser#parse()","bundler::uri::rfc2396_parser#parse()","cgi::parse()","cgi::cookie::parse()","csv::parse()","csv::parser#parse()","date::parse()","datetime::parse()","gem::requestset::lockfile::parser#parse()","gem::requirement::parse()","gem::uriparser#parse()","json#parse()","json::ext::parser#parse()","net::smtp::response::parse()","openssl::config::parse()","openssl::x509::name::parse()","optionparser#parse()","optionparser::switch::noargument#parse()","optionparser::switch::optionalargument#parse()","optionparser::switch::placedargument#parse()","optionparser::switch::requiredargument#parse()","psych::parse()","psych::parser#parse()","rdoc::classmodule#parse()","rdoc::comment#parse()","rdoc::markdown::parse()","rdoc::markdown#parse()","rdoc::markup::parse()","rdoc::options#parse()","rdoc::parser::ripperstatelex::parse()","rdoc::rd::parse()","rdoc::text#parse()","rdoc::tomdoc::parse()","rexml::dtd::parser::parse()","rexml::parsers::lightparser#parse()","rexml::parsers::sax2parser#parse()","rexml::parsers::streamparser#parse()","rexml::parsers::treeparser#parse()","rexml::parsers::ultralightparser#parse()","rexml::parsers::xpathparser#parse()","rexml::xpathparser#parse()","rss::baseparser#parse()","rss::itunesitemmodel::itunesduration::parse()","rss::parser::parse()","rss::utils::csv#parse()","rss::utils::explicitcleanother#parse()","rss::utils::yesother#parse()","racc::grammarfileparser::parse()","racc::grammarfileparser#parse()","ripper::parse()","ripper#parse()","ripper::filter#parse()","rubyvm::abstractsyntaxtree::parse()","time::parse()","uri::parse()","uri::rfc2396_parser#parse()","uri::rfc2396_parser#parse()","webrick::cookie::parse()","webrick::httprequest#parse()","gem::uriparser#parse!()","json#parse!()","optionparser#parse!()","optionparser::arguable#parse!()","rdoc::parser::ruby#parse_alias()","optionparser::switch#parse_arg()","rexml::parsers::xpathparser#parse_args()","rexml::quickpath::parse_args()","rdoc::parser::ruby#parse_attr()","rdoc::parser::ruby#parse_attr_accessor()","rexml::parsers::baseparser#parse_attributes()","fiddle::importer#parse_bind_options()","bundler::lockfileparser#parse_bundled_with()","rdoc::parser::ruby#parse_call_parameters()","rdoc::parser::ruby#parse_class()","csv::parser#parse_column_end()","csv::parser#parse_column_value()","rdoc::parser::ruby#parse_comment()","rdoc::parser::ruby#parse_comment_tomdoc()","openssl::config::parse_config()","openssl::config::parse_config_lines()","rdoc::parser::ruby#parse_constant()","rdoc::parser::ruby#parse_constant_visibility()","fiddle::cparser#parse_ctype()","bundler::compactindexclient::cache#parse_dependency()","bundler::lockfileparser#parse_dependency()","bundler::uri::ldap#parse_dn()","uri::ldap#parse_dn()","rdoc::rdoc#parse_dot_doc_file()","rdoc::parser::changelog#parse_entries()","psych::parse_file()","rdoc::rdoc#parse_file()","racc::grammarfileparser::parse_file()","rubyvm::abstractsyntaxtree::parse_file()","rdoc::rdoc#parse_files()","rdoc::parser::parse_files_matching()","webrick::httputils::parse_form_data()","webrick::httputils#parse_form_data()","bundler::compactindexclient::cache#parse_gem()","webrick::httputils#parse_header()","webrick::httputils::parse_header()","csv::parser#parse_headers()","rexml::dtd::parser::parse_helper()","rexml::parsers::baseparser#parse_id()","rexml::parsers::baseparser#parse_id_invalid_details()","psych::scalarscanner#parse_int()","csv::parse_line()","bundler::dsl::dslerror#parse_line_number_from_description()","gem::testcase#parse_make_command_line()","rdoc::parser::ruby#parse_meta_attr()","rdoc::parser::ruby#parse_meta_method()","bundler::endpointspecification#parse_metadata()","rdoc::parser::ruby#parse_method()","rdoc::parser::ruby#parse_method_dummy()","rdoc::parser::ruby#parse_method_or_yield_parameters()","rdoc::parser::ruby#parse_method_parameters()","rdoc::parser::ruby#parse_method_params_and_body()","net::ftp#parse_mlsx_entry()","rdoc::parser::ruby#parse_module()","rexml::parsers::baseparser#parse_name()","csv::parser#parse_no_quote()","openssl::x509::name::parse_openssl()","racc::debugflags::parse_option_string()","net::ftp#parse_pasv_ipv4_host()","net::ftp#parse_pasv_ipv6_host()","net::ftp#parse_pasv_port()","rss::listenermixin#parse_pi_content()","bundler::lockfileparser#parse_platform()","irb::outputmethod#parse_printf_format()","bundler::uri::ldap#parse_query()","uri::ldap#parse_query()","webrick::httputils::parse_query()","webrick::httputils#parse_query()","csv::parser#parse_quotable_loose()","csv::parser#parse_quotable_robust()","csv::parser#parse_quoted_column_value()","webrick::httputils::parse_qvalues()","webrick::httputils#parse_qvalues()","webrick::httputils#parse_range_header()","webrick::httputils::parse_range_header()","rdoc::parser::ruby#parse_require()","rdoc::parser::ruby#parse_rescue()","openssl::x509::name::parse_rfc2253()","csv::parser#parse_row_end()","bundler::lockfileparser#parse_ruby()","webrick::cookie::parse_set_cookie()","webrick::cookie::parse_set_cookies()","fiddle::cparser#parse_signature()","bundler::lockfileparser#parse_source()","rexml::dtd::entitydecl::parse_source()","rexml::dtd::notationdecl::parse_source()","bundler::lockfileparser#parse_spec()","rdoc::parser::ruby#parse_statements()","psych::parse_stream()","rexml::document::parse_stream()","fiddle::cparser#parse_struct_signature()","rdoc::parser::ruby#parse_symbol_arg()","rdoc::parser::ruby#parse_symbol_in_arg()","psych::scalarscanner#parse_time()","rdoc::parser::ruby#parse_top_level_statements()","csv::parser#parse_unquoted_column_value()","gem::uriparsing#parse_uri()","racc::grammarfileparser#parse_user_code()","rdoc::parser::ruby#parse_visibility()","rdoc::parser::ruby#parse_yield()","bundler::uri::generic#parser()","csv#parser()","gem::command#parser()","psych::parser()","uri::generic#parser()","rdoc::toplevel#parser=()","racc::grammar#parser_class()","racc::parserfilegenerator#parser_class()","racc::statetransitiontable#parser_class()","csv#parser_enumerator()","csv#parser_fields_converter()","racc::parserfilegenerator#parser_file()","csv#parser_options()","enumerable#partition()","string#partition()","thread::pass()","etc::passwd()","bundler::uri::generic#password()","uri::generic#password()","bundler::uri::generic#password=()","uri::generic#password=()","cgi::htmlextension#password_field()","net::http#patch()","bundler::cli::common::patch_level_options()","argf#path()","bundler::dsl#path()","bundler::rubygemsintegration#path()","bundler::settings#path()","bundler::source::git#path()","bundler::uri::ftp#path()","csv#path()","dir#path()","file::path()","file#path()","gem::path()","pstore#path()","rdoc::classmodule#path()","rdoc::constant#path()","rdoc::methodattr#path()","rdoc::toplevel#path()","rubyvm::instructionsequence#path()","tempfile#path()","thread::backtrace::location#path()","tracepoint#path()","unixsocket#path()","uri::ftp#path()","win32ole_typelib#path()","psych::classloader#path2class()","bundler::uri::generic#path=()","cgi::cookie#path=()","uri::generic#path=()","bundler::source#path?()","gem::uninstaller#path_ok?()","bundler::rubygemsintegration#path_separator()","gem::path_separator()","bundler::molinillo::dependencygraph::vertex#path_to?()","gem::resolver::molinillo::dependencygraph::vertex#path_to?()","io#pathconf()","bundler::standalone#paths()","gem::paths()","gem::paths=()","optionparser::switch::pattern()","optionparser::switch::noargument::pattern()","rubyvm::mjit::pause()","openssl::kdf::pbkdf2_hmac()","openssl::pkcs5#pbkdf2_hmac()","openssl::pkcs5#pbkdf2_hmac_sha1()","enumerator#peek()","gem::requestset::lockfile::tokenizer#peek()","rexml::parsers::baseparser#peek()","rexml::parsers::pullparser#peek()","stringscanner#peek()","rdoc::parser::rubytools#peek_read()","coverage::peek_result()","rdoc::parser::rubytools#peek_tk()","enumerator#peek_values()","stringscanner#peep()","net::http#peer_cert()","openssl::ssl::sslsocket#peer_cert()","openssl::ssl::sslsocket#peer_cert_chain()","ipsocket#peeraddr()","openssl::ssl::socketforwarder#peeraddr()","unixsocket#peeraddr()","rdoc::markdown#peg_parse()","gem::commands::setupcommand#pem_files_in()","openssl::ssl::sslsocket#pending()","thread::pending_interrupt?()","thread#pending_interrupt?()","rdoc::stats#percent_doc()","bundler::cli::add#perform_bundle_install()","bundler::gemhelper#perform_git_push()","rss::maker::itemsbase::itembase::guidbase#permanent_link=()","rss::maker::itemsbase::itembase::guidbase#permanent_link?()","array#permutation()","matrix#permutation?()","optionparser#permute()","optionparser#permute!()","optionparser::arguable#permute!()","addrinfo#pfamily()","complex#phase()","float#phase()","numeric#phase()","gem::availableset#pick_best!()","io#pid()","process::pid()","process::status#pid()","stringio#pid()","gem::requestset::gemdependencyapi#pin_gem_source()","bundler::definition#pinned_spec_names()","io::pipe()","file::pipe?()","file::stat#pipe?()","filetest#pipe?()","pathname#pipe?()","open3::pipeline()","open3#pipeline()","open3::pipeline_r()","open3#pipeline_r()","open3#pipeline_rw()","open3::pipeline_rw()","open3#pipeline_start()","open3::pipeline_start()","open3#pipeline_w()","open3::pipeline_w()","openssl::cipher#pkcs5_keyivgen()","makemakefile#pkg_config()","bundler::rubygemsintegration#plain_specs()","bundler::rubygemsintegration#plain_specs=()","bundler::cli#platform()","bundler::dsl#platform()","gem::basicspecification#platform()","gem::requestset::gemdependencyapi#platform()","gem::resolver::activationrequest#platform()","gem::resolver::specspecification#platform()","gem::specification#platform()","gem::specification#platform=()","gem::platform_defaults()","bundler::resolver::platform_sort_key()","bundler::gemhelpers#platform_specificity_match()","bundler::gemhelpers::platform_specificity_match()","bundler::lazyspecification::identifier#platform_string()","bundler::gemhelpers::platformmatch::platform_version_match()","bundler::dsl#platforms()","bundler::rubygemsintegration#platforms()","gem::platforms()","gem::requestset::gemdependencyapi#platforms()","gem::platforms=()","bundler::matchplatform::platforms_match?()","bundler::dsl#plugin()","bundler::plugin::dsl#plugin()","bundler::plugin::index#plugin_commands()","bundler::plugin::index#plugin_path()","rss::element::plural_forms()","readline::point()","readline::point=()","openssl::pkey::ec::group#point_conversion_form()","openssl::pkey::ec::group#point_conversion_form=()","stringscanner#pointer()","stringscanner#pointer=()","racc::logfilegenerator#pointer_out()","complex::polar()","complex#polar()","numeric#polar()","bundler::connectionpool::wrapper#pool_available()","bundler::connectionpool::wrapper#pool_shutdown()","bundler::connectionpool::wrapper#pool_size()","gem::remotefetcher#pools_for()","array#pop()","bundler::connectionpool::timedstack#pop()","bundler::thor::nestedcontext#pop()","net::popmail#pop()","psych::treebuilder#pop()","queue#pop()","rinda::notifytemplateentry#pop()","sizedqueue#pop()","bundler::molinillo::dependencygraph::log#pop!()","gem::resolver::molinillo::dependencygraph::log#pop!()","pp::ppmethods#pop_inspect_key()","bundler::molinillo::dependencystate#pop_possibility_state()","gem::resolver::molinillo::dependencystate#pop_possibility_state()","rdoc::tokenstream#pop_token()","irb::context#pop_workspace()","gem::util::popen()","io::popen()","open3#popen2()","open3::popen2()","open3#popen2e()","open3::popen2e()","open3::popen3()","open3#popen3()","cgi::htmlextension#popup_menu()","net::pop3#port()","webrick::httprequest#port()","bundler::uri::generic#port=()","uri::generic#port=()","argf#pos()","dir#pos()","gem::package::tarreader::entry#pos()","io#pos()","stringio#pos()","stringscanner#pos()","zlib::gzipreader#pos()","zlib::gzipwriter#pos()","argf#pos=()","dir#pos=()","io#pos=()","stringio#pos=()","stringscanner#pos=()","rexml::functions::position()","rexml::iosource#position()","rexml::parseexception#position()","rexml::parsers::baseparser#position()","rexml::source#position()","rexml::xpathnode#position()","float#positive?()","numeric#positive?()","rational#positive?()","rss::basemodel#positive_integer_writer()","bundler::molinillo::delegates::resolutionstate#possibilities()","gem::resolver::molinillo::delegates::resolutionstate#possibilities()","bundler::molinillo::resolver::resolution#possibilities_for_requirement()","bundler::molinillo::resolver::resolution#possibility()","bundler::molinillo::resolver::resolution::conflict#possibility()","gem::resolver::molinillo::resolver::resolution#possibility()","bundler::molinillo::resolver::resolution#possibility_satisfies_requirements?()","net::http::post()","net::http#post()","net::http#post2()","gem::post_build()","openssl::ssl::sslsocket#post_connection_check()","net::http::post_form()","bundler::plugin::api::source#post_install()","bundler::source::path::installer#post_install()","gem::post_install()","bundler::endpointspecification#post_install_message()","matchdata#post_match()","stringscanner#post_match()","gem::post_reset()","bundler::rubygemsintegration#post_reset_hooks()","bundler::gemversionpromoter#post_sort()","gem::post_uninstall()","integer#pow()","bigdecimal#power()","irb::notifier::abstractnotifier#pp()","irb::outputmethod#pp()","kernel#pp()","kernel::pp()","pp::pp()","pp::ppmethods#pp()","pp::ppmethods#pp_hash()","pp::ppmethods#pp_object()","process::ppid()","irb::notifier::abstractnotifier#ppx()","irb::outputmethod#ppx()","readline::pre_input_hook()","readline::pre_input_hook=()","reline::core#pre_input_hook=()","gem::pre_install()","bundler::rubygemsgeminstaller#pre_install_checks()","gem::installer#pre_install_checks()","matchdata#pre_match()","stringscanner#pre_match()","gem::pre_reset()","gem::pre_uninstall()","io#pread()","racc::rule#prec()","racc::rule#precedence()","racc::rule#precedence=()","racc::grammar::definitionenv#precedence_table()","rexml::xpathparser#preceding()","rexml::xpathparser#preceding_node_of()","bigdecimal#precs()","integer#pred()","bundler::molinillo::dependencygraph::vertex#predecessors()","gem::resolver::molinillo::dependencygraph::vertex#predecessors()","rexml::parsers::xpathparser#predicate()","rexml::quickpath::predicate()","rexml::xpathparser#predicate()","rexml::parsers::xpathparser#predicate_to_string()","gem::availableset#prefetch()","gem::resolver::apiset#prefetch()","gem::resolver::composedset#prefetch()","gem::resolver::gitset#prefetch()","gem::resolver::installerset#prefetch()","gem::resolver::set#prefetch()","gem::prefix()","ipaddr#prefix()","rexml::attribute#prefix()","rexml::light::node#prefix()","ipaddr#prefix=()","rexml::light::node#prefix_of()","rexml::attributes#prefixes()","rexml::element#prefixes()","csv::parser#prepare()","csv::writer#prepare()","csv::parser#prepare_backslash()","csv::writer#prepare_format()","csv::parser#prepare_header()","csv::writer#prepare_header()","csv::parser#prepare_line()","bundler::thor::shell::basic#prepare_message()","csv::writer#prepare_output()","csv::parser#prepare_parser()","csv::parser#prepare_quote_character()","csv::parser#prepare_quoted()","csv::parser#prepare_separators()","csv::parser#prepare_skip_lines()","csv::parser#prepare_strip()","csv::parser#prepare_unquoted()","csv::parser#prepare_variable()","array#prepend()","gem::list#prepend()","gem::list::prepend()","module#prepend()","optionparser::list#prepend()","string#prepend()","module#prepend_features()","bundler::thor::actions#prepend_file()","bundler::thor::actions#prepend_to_file()","module#prepended()","gem::commands::querycommand#prerelease()","gem::resolver::composedset#prerelease=()","gem::resolver::installerset#prerelease=()","gem::dependency#prerelease?()","gem::nametuple#prerelease?()","gem::requirement#prerelease?()","gem::version#prerelease?()","gem::server#prerelease_specs()","bundler::rubygemsintegration#preserve_paths()","io#pressed?()","cgi::util#pretty()","bundler::definition#pretty_dep()","bundler::sharedhelpers#pretty_dependency()","json#pretty_generate()","kernel#pretty_inspect()","rdoc::alias#pretty_name()","rdoc::methodattr#pretty_name()","rdoc::alias#pretty_new_name()","rdoc::alias#pretty_old_name()","openssl::bn#pretty_print()","openssl::x509::certificate#pretty_print()","openssl::x509::name#pretty_print()","rubyvm::abstractsyntaxtree::node#pretty_print()","rubyvm::abstractsyntaxtree::node#pretty_print_children()","bundler::settings#pretty_values_for()","date#prev_day()","float#prev_float()","date#prev_month()","date#prev_year()","rexml::validation::state#previous=()","rexml::element#previous_element()","rexml::child#previous_sibling=()","rexml::node#previous_sibling_node()","rinda::ringfinger::primary()","integer#prime?()","openssl::bn#prime?()","prime#prime?()","integer#prime_division()","prime#prime_division()","openssl::bn#prime_fasttest?()","encoding::converter#primitive_convert()","encoding::converter#primitive_errinfo()","argf#print()","cgi#print()","io#print()","io::generic_writable#print()","irb::locale#print()","irb::notifier::abstractnotifier#print()","irb::outputmethod#print()","irb::stdiooutputmethod#print()","kernel#print()","net::writeadapter#print()","openssl::buffering#print()","zlib::gzipwriter#print()","racc::states#print_atab()","bundler::cli#print_command()","bundler::cli::outdated#print_gem()","bundler::cli::info#print_gem_info()","bundler::cli::info#print_gem_path()","bundler::cli::outdated#print_gems()","bundler::thor::shell::basic#print_in_columns()","bundler::sharedhelpers#print_major_deprecations!()","openssl::print_mem_leaks()","bundler::thor::base::classmethods#print_options()","bundler::cli::common::print_post_install_message()","racc::states#print_tab()","racc::states#print_tab_i()","bundler::thor::shell::basic#print_table()","irb::print_usage()","bundler::source#print_using_message()","bundler::thor::shell::basic#print_wrapped()","bundler::thor::printable_commands()","bundler::thor::group::printable_commands()","bundler::thor::printable_tasks()","bundler::thor::group::printable_tasks()","racc::states#printb()","argf#printf()","io#printf()","io::generic_writable#printf()","irb::locale#printf()","irb::notifier::abstractnotifier#printf()","irb::outputmethod#printf()","kernel#printf()","net::writeadapter#printf()","openssl::buffering#printf()","zlib::gzipwriter#printf()","irb::notifier::abstractnotifier#printn()","irb::outputmethod#printn()","bundler::sharedhelpers#prints_major_deprecations?()","thread#priority()","thread#priority=()","bundler::cli#pristine()","module#private()","ipaddr#private?()","openssl::pkey::dh#private?()","openssl::pkey::dsa#private?()","openssl::pkey::ec#private?()","openssl::pkey::rsa#private?()","nomethoderror#private_call?()","module#private_class_method()","module#private_constant()","openssl::pkey::rsa#private_decrypt()","openssl::pkey::rsa#private_encrypt()","module#private_instance_methods()","psych::visitors::yamltree#private_iv_get()","openssl::pkey::ec#private_key()","bundler::persistent::net::http::persistent#private_key=()","openssl::pkey::ec#private_key=()","openssl::pkey::ec#private_key?()","bundler::thor::command#private_method?()","bundler::thor::command#private_method?()","module#private_method_defined?()","object#private_methods()","bundler::settings::tcpsocketprobe#probe_writtable_socket()","kernel#proc()","racc::useraction::proc()","racc::useraction#proc?()","net::httpresponse#procdest()","net::imap::crammd5authenticator#process()","net::imap::digestmd5authenticator#process()","net::imap::loginauthenticator#process()","net::imap::plainauthenticator#process()","gem::commandmanager#process_args()","gem::testcase::process_based_port()","gem::testcase#process_based_port()","rexml::parsers::baseparser#process_instruction()","bundler::worker#process_queue()","bundler::parallelinstaller#process_specs()","bundler::cli::exec#process_title()","bundler::molinillo::resolver::resolution#process_topmost_state()","gem::resolver::molinillo::resolver::resolution#process_topmost_state()","rss::rexmllikexmlparser#processinginstruction()","rexml::functions::processing_instruction()","rexml::sax2listener#processing_instruction()","bundler::installer#processor_count()","enumerator::produce()","array#product()","win32ole_type#progid()","win32ole_type::progids()","optionparser#program_name()","rexml::sax2listener#progress()","bundler::molinillo::ui#progress_rate()","gem::resolver::molinillo::ui#progress_rate()","gem::streamui#progress_reporter()","irb::context#prompt_mode=()","reline::core#prompt_proc=()","irb::context#prompting?()","set#proper_subset?()","set#proper_superset?()","net::http#propfind()","net::http#proppatch()","module#protected()","module#protected_instance_methods()","module#protected_method_defined?()","delegator#protected_methods()","object#protected_methods()","addrinfo#protocol()","rinda::ringprovider#provide()","bundler::rubygemsintegration#provides?()","bundler::rubygemsintegration::provides?()","bundler::persistent::net::http::persistent#proxy=()","net::http#proxy?()","net::http#proxy_address()","net::httpheader#proxy_basic_auth()","webrick::httpauth#proxy_basic_auth()","bundler::persistent::net::http::persistent#proxy_bypass?()","net::http::proxy_class?()","gem::remotefetcher#proxy_for()","bundler::persistent::net::http::persistent#proxy_from_env()","net::http#proxy_from_env?()","net::http#proxy_pass()","net::http#proxy_port()","gem::request#proxy_uri()","net::http#proxy_user()","net::http#proxyaddr()","net::http#proxyport()","find::prune()","find#prune()","bundler::runtime#prune_cache()","bundler::runtime#prune_gem_cache()","bundler::runtime#prune_git_and_path_cache()","openssl::random::pseudo_bytes()","fiddle::pointer#ptr()","racc::locationpointer#ptr_bug!()","rss::maker::channelbase#pubdate()","rss::maker::itemsbase::itembase#pubdate()","rss::maker::channelbase#pubdate=()","rss::maker::itemsbase::itembase#pubdate=()","module#public()","rexml::doctype#public()","openssl::pkey::dh#public?()","openssl::pkey::dsa#public?()","openssl::pkey::ec#public?()","openssl::pkey::rsa#public?()","module#public_class_method()","bundler::thor::base::classmethods#public_command()","module#public_constant()","openssl::pkey::rsa#public_decrypt()","openssl::pkey::rsa#public_encrypt()","module#public_instance_method()","module#public_instance_methods()","openssl::netscape::spki#public_key()","openssl::pkey::dh#public_key()","openssl::pkey::dsa#public_key()","openssl::pkey::ec#public_key()","openssl::pkey::rsa#public_key()","openssl::x509::certificate#public_key()","openssl::x509::request#public_key()","openssl::netscape::spki#public_key=()","openssl::pkey::ec#public_key=()","openssl::x509::certificate#public_key=()","openssl::x509::request#public_key=()","openssl::pkey::ec#public_key?()","object#public_method()","module#public_method_defined?()","delegator#public_methods()","object#public_methods()","object#public_send()","bundler::thor::base::classmethods#public_task()","rexml::parsers::baseparser#pull()","rexml::parsers::pullparser#pull()","rexml::parsers::baseparser#pull_event()","net::ftp::mlsxentry#purgeable?()","openssl::x509::store#purpose=()","openssl::x509::storecontext#purpose=()","array#push()","bundler::connectionpool::timedstack#push()","bundler::thor::nestedcontext#push()","csv::row#push()","csv::table#push()","psych::treebuilder#push()","psych::visitors::yamltree#push()","queue#push()","rexml::parent#push()","rinda::tuplebag#push()","sizedqueue#push()","bundler::molinillo::dependencygraph::log#push_action()","gem::resolver::molinillo::dependencygraph::log#push_action()","pp::ppmethods#push_inspect_key()","bundler::molinillo::resolver::resolution#push_state_for_requirements()","gem::resolver::molinillo::resolver::resolution#push_state_for_requirements()","irb::context#push_workspace()","net::ftp#put()","racc::parserfilegenerator#put()","racc::parserfilegenerator#put_state_transition_table()","net::imap#put_string()","encoding::converter#putback()","net::ftp#putbinaryfile()","argf#putc()","io#putc()","kernel#putc()","stringio#putc()","zlib::gzipwriter#putc()","argf#puts()","csv#puts()","io#puts()","io::generic_writable#puts()","irb::locale#puts()","irb::notifier::abstractnotifier#puts()","irb::outputmethod#puts()","kernel#puts()","net::writeadapter#puts()","openssl::buffering#puts()","xmp#puts()","xmp::stringinputmethod#puts()","zlib::gzipwriter#puts()","net::ftp#puttextfile()","bundler::fileutils#pwd()","bundler::fileutils::pwd()","bundler::sharedhelpers#pwd()","dir::pwd()","fileutils::pwd()","fileutils#pwd()","net::ftp#pwd()","pathname::pwd()","io#pwrite()","net::imap::digestmd5authenticator#qdval()","webrick::httprequest#query()","bundler::uri::generic#query=()","uri::generic#query=()","gem::server#quick()","gem::testcase#quick_gem()","rdoc::options#quiet()","rdoc::options#quiet=()","bundler::ui::shell#quiet?()","bundler::ui::silent#quiet?()","net::ftp#quit()","net::smtp#quit()","bigdecimal#quo()","complex#quo()","float#quo()","numeric#quo()","rational#quo()","csv::writer#quote()","regexp::quote()","webrick::httputils#quote()","webrick::httputils::quote()","csv#quote_char()","csv::parser#quote_character()","csv::writer#quote_field()","net::httpgenericrequest#quote_string()","readline::quoting_detection_proc()","readline::quoting_detection_proc=()","vector#r()","racc::parser#racc_accept()","racc::parser#racc_e_pop()","racc::parser#racc_next_state()","racc::parser#racc_print_stacks()","racc::parser#racc_print_states()","racc::parser#racc_read_token()","racc::parser#racc_reduce()","racc::parser#racc_shift()","racc::parser#racc_token2str()","cgi::htmlextension#radio_button()","cgi::htmlextension#radio_group()","delegator#raise()","fiber#raise()","kernel#raise()","thread#raise()","bundler::molinillo::resolver::resolution#raise_error_unless_state()","rss::baselistener::raise_for_undefined_entity?()","rss::baseparser::raise_for_undefined_entity?()","rss::rexmllistener::raise_for_undefined_entity?()","tracepoint#raised_exception()","bundler::thor::rakecompat::rake_classes()","object#rake_namespace()","kernel#rand()","random::rand()","random#rand()","random::formatter#rand()","openssl::random::random_add()","openssl::random::random_bytes()","random::formatter#random_bytes()","openssl::cipher#random_iv()","openssl::cipher#random_key()","random::formatter#random_number()","webrick::utils::random_string()","webrick::utils#random_string()","net::httpheader#range()","net::httpheader#range=()","net::httpheader#range_length()","matrix#rank()","matrix#rank_e()","array#rassoc()","env::rassoc()","hash#rassoc()","complex#rationalize()","float#rationalize()","integer#rationalize()","nilclass#rationalize()","rational#rationalize()","io#raw()","rexml::element#raw()","io#raw!()","cgi::queryextension#raw_cookie()","cgi::queryextension#raw_cookie2()","gc::profiler::raw_data()","csv#raw_encoding()","bundler::stubspecification#raw_require_paths()","gem::package::raw_spec()","gem::commands::setupcommand#rb_files_in()","rdoc::parser::c#rb_scan_args()","bundler::currentruby#rbx?()","net::smtp#rcptto()","net::smtp#rcptto_list()","file::stat#rdev()","file::stat#rdev_major()","file::stat#rdev_minor()","gem::server#rdoc()","rdoc::rubygemshook#rdoc_installed?()","rdoc::rubygemshook#rdoc_installed?()","gem::specification#rdoc_options()","gem::specification#rdoc_options=()","rdoc::task#rdoc_target()","rdoc::task#rdoc_target()","rdoc::task#rdoc_task_description()","rdoc::task#rdoc_task_description()","rdoc::task#rdoc_task_name()","rdoc::task#rdoc_task_name()","process::gid::re_exchange()","process::uid::re_exchange()","process::gid::re_exchangeable?()","process::uid::re_exchangeable?()","gem::security::re_sign()","gem::commands::certcommand#re_sign_cert()","gem::security::signer::re_sign_cert()","objectspace::reachable_objects_from()","objectspace::reachable_objects_from_root()","argf#read()","csv#read()","csv::read()","dir#read()","gem::package::tarreader::entry#read()","io::read()","io#read()","openssl::buffering#read()","openssl::pkey::read()","openuri::openread#read()","pathname#read()","rexml::iosource#read()","rexml::source#read()","racc::grammarfilescanner#read()","rinda::tuplespace#read()","rinda::tuplespaceproxy#read()","rinda::waittemplateentry#read()","stringio#read()","zlib::gzipreader#read()","rinda::tuplespace#read_all()","rinda::tuplespaceproxy#read_all()","bundler::rubygemsintegration#read_binary()","gem::read_binary()","gem::testcase#read_binary()","net::httpresponse#read_body()","net::httpresponse#read_body_0()","gem::testcase#read_cache()","gem::package#read_checksums()","csv::parser::inputsscanner#read_chunk()","rdoc::parser::ruby#read_directive()","rdoc::parser::ruby#read_documentation_modifiers()","reline::core#read_escaped_key()","bundler::read_file()","bundler::env::read_file()","rdoc::encoding::read_file()","cgi::queryextension#read_from_cmdline()","reline::core#read_io()","cgi::queryextension#read_multipart()","argf#read_nonblock()","io#read_nonblock()","io::generic_readable#read_nonblock()","openssl::buffering#read_nonblock()","openssl::pkcs7::read_smime()","net::httpresponse::read_status_line()","net::ftp#read_timeout=()","net::http#read_timeout=()","net::pop3#read_timeout=()","net::smtp#read_timeout=()","rexml::text::read_with_substitution()","file::readable?()","file::stat#readable?()","filetest#readable?()","net::ftp::mlsxentry#readable?()","pathname#readable?()","irb::inputmethod#readable_after_eof?()","irb::readlineinputmethod#readable_after_eof?()","irb::reidlineinputmethod#readable_after_eof?()","irb::stdioinputmethod#readable_after_eof?()","file::readable_real?()","file::stat#readable_real?()","filetest#readable_real?()","pathname#readable_real?()","encoding::invalidbytesequenceerror#readagain_bytes()","argf#readbyte()","io#readbyte()","io::generic_readable#readbyte()","zlib::gzipreader#readbyte()","argf#readchar()","io#readchar()","io::generic_readable#readchar()","openssl::buffering#readchar()","zlib::gzipreader#readchar()","argf#readline()","bundler::thor::lineeditor::readline()","bundler::thor::lineeditor::basic#readline()","bundler::thor::lineeditor::readline#readline()","csv#readline()","io#readline()","io::generic_readable#readline()","irb::locale#readline()","kernel#readline()","openssl::buffering#readline()","rexml::iosource#readline()","readline::readline()","reline::core#readline()","zlib::gzipreader#readline()","argf#readlines()","csv#readlines()","csv::readlines()","io::readlines()","io#readlines()","kernel#readlines()","openssl::buffering#readlines()","pathname#readlines()","stringio#readlines()","zlib::gzipreader#readlines()","file::readlink()","pathname#readlink()","reline::core#readmultiline()","argf#readpartial()","gem::package::tarreader::entry#readpartial()","io#readpartial()","io::generic_readable#readpartial()","openssl::buffering#readpartial()","webrick::httprequest#readpartial()","zlib::gzipreader#readpartial()","racc::grammarfilescanner#reads()","net::smtp#ready()","io#ready?()","bundler::parallelinstaller::specinstallation#ready_to_enqueue?()","complex#real()","matrix#real()","numeric#real()","complex#real?()","matrix#real?()","numeric#real?()","irb::locale#real_load()","file::realdirpath()","pathname#realdirpath()","fiddle::realloc()","gem::configfile#really_verbose()","file::realpath()","pathname#realpath()","benchmark::realtime()","benchmark#realtime()","localjumperror#reason()","optionparser::parseerror#reason()","webrick::httpstatus#reason_phrase()","webrick::httpstatus::reason_phrase()","webrick::httpstatus::status#reason_phrase()","rexml::validation::relaxng#receive()","net::imap#receive_responses()","binding#receiver()","frozenerror#receiver()","keyerror#receiver()","method#receiver()","nameerror#receiver()","openssl::pkcs7#recipients()","bundler::persistent::net::http::persistent#reconnect()","bundler::persistent::net::http::persistent#reconnect_ssl()","gem::resolver::stats#record_depth()","rexml::document#record_entity_expansion()","rdoc::codeobject#record_location()","rdoc::context#record_location()","racc::states#record_path()","gem::resolver::stats#record_requirements()","net::imap#record_response()","optionparser::parseerror#recover()","complex#rect()","complex::rect()","matrix#rect()","numeric#rect()","complex#rectangular()","complex::rectangular()","matrix#rectangular()","numeric#rectangular()","json#recurse_proc()","bundler::molinillo::dependencygraph::vertex#recursive_predecessors()","gem::resolver::molinillo::dependencygraph::vertex#recursive_predecessors()","bundler::molinillo::dependencygraph::vertex#recursive_successors()","gem::resolver::molinillo::dependencygraph::vertex#recursive_successors()","basicsocket#recv()","unixsocket#recv_io()","basicsocket#recv_nonblock()","net::smtp#recv_response()","ipsocket#recvfrom()","socket#recvfrom()","unixsocket#recvfrom()","socket#recvfrom_nonblock()","udpsocket#recvfrom_nonblock()","basicsocket#recvmsg()","basicsocket#recvmsg_nonblock()","bundler::rubygemsintegration#redefine_method()","webrick::httpstatus#redirect?()","webrick::httpstatus::redirect?()","webrick::httpservlet::abstractservlet#redirect_to_directory_uri()","readline::redisplay()","enumerable#reduce()","racc::actiontable#reduce()","racc::actiontable#reduce_n()","racc::statetransitiontablegenerator#reduce_table()","matrix::eigenvaluedecomposition#reduce_to_hessenberg()","fiddle::pointer#ref()","rdoc::markdown#reference()","module#refine()","bundler::cli::reformatted_help_args()","gem::refresh()","readline::refresh_line()","gem::testcase#refute_path_exists()","gem::commands::setupcommand#regenerate_binstubs()","bundler::uri::regexp()","matchdata#regexp()","optionparser::completion::regexp()","uri::regexp()","drb::extservmanager#regist()","drb::regist_server()","drb#regist_server()","bundler::thor::register()","gem::noaliasyamltree#register()","openssl::asn1::objectid::register()","psych::streaming#register()","psych::visitors::toruby#register()","psych::visitors::yamltree#register()","webrick::utils::timeouthandler::register()","gem::commandmanager#register_command()","gem::register_default_spec()","psych::visitors::toruby#register_empty()","bundler::plugin#register_plugin()","bundler::plugin::index#register_plugin()","rss::baselistener::register_uri()","bundler::uri::generic#registry=()","uri::generic#registry=()","matrix#regular?()","env::rehash()","hash#rehash()","array#reject()","bundler::thor::coreext::orderedhash#reject()","dbm#reject()","env::reject()","enumerable#reject()","enumerator::lazy#reject()","gdbm#reject()","hash#reject()","optionparser#reject()","optionparser::reject()","optionparser::list#reject()","sdbm#reject()","yaml::dbm#reject()","array#reject!()","dbm#reject!()","env::reject!()","gdbm#reject!()","hash#reject!()","sdbm#reject!()","set#reject!()","bundler::uri::generic#relative?()","pathname#relative?()","uri::generic#relative?()","bundler::thor::lineeditor::readline::pathcompletion#relative_matches()","bundler::source::path#relative_path()","pathname#relative_path_from()","bundler::thor::actions#relative_to_original_destination_root()","gem::version#release()","optionparser#release()","bundler::buildmetadata::release?()","bundler::resolver#relevant_sources_for_vertex()","drb::drbunknown#reload()","webrick::httpauth::htdigest#reload()","webrick::httpauth::htgroup#reload()","webrick::httpauth::htpasswd#reload()","bigdecimal#remainder()","integer#remainder()","numeric#remainder()","bundler::cli#remembered_flag_deprecation()","bundler::plugin::api::source#remote!()","bundler::source::metadata#remote!()","bundler::source::path#remote!()","bundler::source::rubygems#remote!()","bundler::sourcelist#remote!()","gem::resolver::composedset#remote=()","gem::localremoteoptions#remote?()","basicsocket#remote_address()","webrick::httprequest#remote_ip()","bundler::source::rubygems#remote_specs()","bundler::fetcher#remote_uri()","bundler::fetcher::base#remote_uri()","bundler::source::rubygems#remotes_for_spec()","bundler::cli#remove()","bundler::fileutils::remove()","bundler::fileutils#remove()","bundler::injector::remove()","bundler::injector#remove()","fileutils::remove()","fileutils#remove()","gem::resolver::requirementlist#remove()","gem::uninstaller#remove()","optionparser#remove()","rdoc::rubygemshook#remove()","rdoc::rubygemshook#remove()","rexml::attribute#remove()","rexml::child#remove()","gem::uninstaller#remove_all()","bundler::thor::base::classmethods#remove_argument()","bundler::source::rubygems#remove_auth()","bundler::source::rubygems::remote#remove_auth()","racc::parserfilegenerator#remove_blank_lines()","gem::dependencylist#remove_by_name()","bundler::source::git::gitproxy#remove_cache()","bundler::thor::base::classmethods#remove_class_option()","module#remove_class_variable()","rdoc::parser::simple#remove_coding_comment()","bundler::thor::base::classmethods#remove_command()","rdoc::parser::c#remove_commented_out_lines()","module#remove_const()","bundler::injector#remove_deps()","bundler::fileutils::remove_dir()","bundler::fileutils#remove_dir()","bundler::runtime#remove_dir()","bundler::thor::actions#remove_dir()","fileutils::remove_dir()","fileutils#remove_dir()","bundler::fileutils#remove_entry()","bundler::fileutils::remove_entry()","fileutils::remove_entry()","fileutils#remove_entry()","bundler::fileutils#remove_entry_secure()","bundler::fileutils::remove_entry_secure()","fileutils::remove_entry_secure()","fileutils#remove_entry_secure()","gem::uninstaller#remove_executables()","bundler::fileutils::remove_file()","bundler::fileutils#remove_file()","bundler::thor::actions#remove_file()","fileutils#remove_file()","fileutils::remove_file()","rdoc::context#remove_from_documentation?()","rdoc::encoding::remove_frozen_string_literal()","bundler::injector#remove_gems_from_dependencies()","bundler::injector#remove_gems_from_gemfile()","webrick::httpservlet::filehandler::remove_handler()","gem::availableset#remove_installed!()","object#remove_instance_variable()","rdoc::context#remove_invisible()","bundler::thor::group::remove_invocation()","rdoc::encoding::remove_magic_comment()","module#remove_method()","rdoc::parser::remove_modeline()","bundler::injector#remove_nested_blocks()","rdoc::store#remove_nodoc()","rdoc::classmodule#remove_nodoc_children()","gem::commands::setupcommand#remove_old_bin_files()","gem::commands::setupcommand#remove_old_lib_files()","gem::command#remove_option()","gem::commands::ownercommand#remove_owners()","bundler::definition#remove_platform()","rdoc::comment#remove_private()","rdoc::parser::simple#remove_private_comment()","net::imap#remove_response_handler()","drb#remove_server()","drb::remove_server()","rdoc::rdoc#remove_siginfo_handler()","gem::dependencylist#remove_specs_unsatisfied_by()","gc::remove_stress_to_class()","bundler::thor::base::classmethods#remove_task()","rdoc::parser::rubytools#remove_token_listener()","rdoc::rdoc#remove_unparseable()","gem::specification#removed_method_calls()","bundler::definition#removed_specs()","net::ftp::mlsxentry#renamable?()","file::rename()","net::ftp#rename()","net::imap#rename()","pathname#rename()","irb::rubymodel#render_frame()","rinda::simplerenewer#renew()","rinda::tupleentry#renew()","io#reopen()","logger#reopen()","stringio#reopen()","syslog::reopen()","gdbm#reorganize()","array#repeated_combination()","array#repeated_permutation()","array#replace()","bundler::thor::coreext::orderedhash#replace()","dbm#replace()","env::replace()","gdbm#replace()","gem::sourcelist#replace()","hash#replace()","racc::rule#replace()","sdbm#replace()","set#replace()","string#replace()","yaml::dbm#replace()","bundler::uri::generic#replace!()","uri::generic#replace!()","bundler::rubygemsintegration#replace_bin_path()","rexml::parent#replace_child()","bundler::rubygemsintegration#replace_entrypoints()","bundler::rubygemsintegration#replace_gem()","racc::parserfilegenerator#replace_location()","bundler::source::rubygems#replace_remotes()","bundler::sourcelist#replace_sources!()","rexml::child#replace_with()","encoding::converter#replacement()","encoding::converter#replacement=()","encoding#replicate()","bundler::settings::tcpsocketprobe#replies?()","socket::udpsource#reply()","rinda::ringserver#reply_service()","bundler::env::report()","gc::profiler::report()","rdoc::stats#report()","rdoc::stats#report_attributes()","rdoc::stats#report_class_module()","rdoc::stats#report_constants()","rdoc::stats#report_methods()","thread#report_on_exception()","thread::report_on_exception()","thread#report_on_exception=()","thread::report_on_exception=()","bundler::rubygemsintegration#repository_subdirectories()","psych::coder#represent_map()","psych::coder#represent_object()","psych::coder#represent_scalar()","psych::coder#represent_seq()","bundler::fetcher::downloader#request()","bundler::persistent::net::http::persistent#request()","gem::fakefetcher#request()","gem::remotefetcher#request()","net::http#request()","net::httpgenericrequest#request_body_permitted?()","gem::resolver::dependencyrequest#request_context()","net::http#request_get()","net::http#request_head()","bundler::friendlyerrors#request_issue_report_for()","gem::resolver::conflict#request_path()","net::http#request_post()","bundler::uri::http#request_uri()","uri::http#request_uri()","bundler::definition#requested_dependencies()","bundler::definition#requested_groups()","bundler::definition#requested_specs()","bundler::gemdeps#requested_specs()","gem::resolver::conflict#requester()","gem::requestset::lockfile#requests()","bundler::require()","bundler::runtime#require()","irb::locale#require()","kernel#require()","racc::parserfilegenerator#require()","gem::streamui#require_io_console()","bundler::molinillo::resolver::resolution#require_nested_dependencies_for()","gem::resolver::molinillo::resolver::resolution#require_nested_dependencies_for()","gem::specification#require_path()","gem::specification#require_path=()","bundler::cli::clean#require_path_or_force()","bundler::endpointspecification#require_paths()","gem::basicspecification#require_paths()","gem::specification#require_paths=()","kernel#require_relative()","bundler::require_thor_actions()","bundler::parallelinstaller#require_tree_for_spec()","bundler::thor::command#required_arguments_for()","bundler::thor::command#required_arguments_for()","gem::specification::required_attribute?()","gem::specification::required_attributes()","rss::maker::rss09::image#required_element?()","rss::maker::rss20::image#required_element?()","bundler::thor::command#required_options()","bundler::thor::command#required_options()","rss::element::required_prefix()","rss::ituneschannelmodel::itunescategory::required_prefix()","rss::ituneschannelmodel::itunesimage::required_prefix()","rss::ituneschannelmodel::itunesowner::required_prefix()","rss::itunesitemmodel::itunesduration::required_prefix()","rss::imagefaviconmodel::imagefavicon::required_prefix()","rss::imageitemmodel::imageitem::required_prefix()","rss::taxonomytopicmodel::taxonomytopic::required_prefix()","rss::taxonomytopicsmodel::taxonomytopics::required_prefix()","gem::specification#required_ruby_version=()","gem::specification#required_rubygems_version=()","rss::atom::commonmodel::required_uri()","rss::element::required_uri()","rss::ituneschannelmodel::itunescategory::required_uri()","rss::ituneschannelmodel::itunesimage::required_uri()","rss::ituneschannelmodel::itunesowner::required_uri()","rss::itunesitemmodel::itunesduration::required_uri()","rss::imagefaviconmodel::imagefavicon::required_uri()","rss::imageitemmodel::imageitem::required_uri()","rss::rdf::required_uri()","rss::rdf::bag::required_uri()","rss::rdf::bag::required_uri()","rss::rdf::channel::required_uri()","rss::rdf::channel::image::required_uri()","rss::rdf::channel::items::required_uri()","rss::rdf::channel::textinput::required_uri()","rss::rdf::image::required_uri()","rss::rdf::item::required_uri()","rss::rdf::li::required_uri()","rss::rdf::li::required_uri()","rss::rdf::li::required_uri()","rss::rdf::seq::required_uri()","rss::rdf::seq::required_uri()","rss::rdf::textinput::required_uri()","rss::taxonomytopicmodel::taxonomytopic::required_uri()","rss::taxonomytopicsmodel::taxonomytopics::required_uri()","rss::maker::atom::entry::items::item#required_variable_names()","rss::maker::atom::feed::channel#required_variable_names()","rss::maker::atom::feed::image#required_variable_names()","rss::maker::atom::feed::items::item#required_variable_names()","rss::maker::atom::feed::items::item::content#required_variable_names()","rss::maker::atom::feed::items::item::source#required_variable_names()","rss::maker::atom::feed::items::item::source::icon#required_variable_names()","rss::maker::atomcategory#required_variable_names()","rss::maker::atomgenerator#required_variable_names()","rss::maker::atomlink#required_variable_names()","rss::maker::atomlogo#required_variable_names()","rss::maker::atomtextconstruct#required_variable_names()","rss::maker::ituneschannelmodel::itunesownerbase#required_variable_names()","rss::maker::rss09::channel#required_variable_names()","rss::maker::rss09::channel::copyright#required_variable_names()","rss::maker::rss09::channel::description#required_variable_names()","rss::maker::rss09::channel::links::link#required_variable_names()","rss::maker::rss09::channel::skipdays::day#required_variable_names()","rss::maker::rss09::channel::skiphours::hour#required_variable_names()","rss::maker::rss09::channel::title#required_variable_names()","rss::maker::rss09::image#required_variable_names()","rss::maker::rss09::items::item#required_variable_names()","rss::maker::rss09::items::item::description#required_variable_names()","rss::maker::rss09::items::item::links::link#required_variable_names()","rss::maker::rss09::items::item::title#required_variable_names()","rss::maker::rss09::textinput#required_variable_names()","rss::maker::rss10::channel#required_variable_names()","rss::maker::rss10::channel::description#required_variable_names()","rss::maker::rss10::channel::links::link#required_variable_names()","rss::maker::rss10::channel::title#required_variable_names()","rss::maker::rss10::image#required_variable_names()","rss::maker::rss10::items::item#required_variable_names()","rss::maker::rss10::items::item::description#required_variable_names()","rss::maker::rss10::items::item::title#required_variable_names()","rss::maker::rss10::textinput#required_variable_names()","rss::maker::rss20::channel#required_variable_names()","rss::maker::rss20::channel::categories::category#required_variable_names()","rss::maker::rss20::channel::cloud#required_variable_names()","rss::maker::rss20::channel::generator#required_variable_names()","rss::maker::rss20::items::item#required_variable_names()","rss::maker::rss20::items::item::categories::category#required_variable_names()","rss::maker::rss20::items::item::enclosure#required_variable_names()","rss::maker::rss20::items::item::guid#required_variable_names()","rss::maker::rss20::items::item::source#required_variable_names()","rss::maker::xmlstylesheets::xmlstylesheet#required_variable_names()","rss::maker::base#required_variables_are_set?()","bundler::depproxy#requirement()","bundler::molinillo::delegates::resolutionstate#requirement()","gem::dependency#requirement()","gem::resolver::dependencyrequest#requirement()","gem::resolver::molinillo::delegates::resolutionstate#requirement()","gem::resolver::stats#requirement!()","bundler::molinillo::resolver::resolution#requirement_for_existing_name()","gem::resolver::molinillo::resolver::resolution#requirement_for_existing_name()","bundler::molinillo::delegates::specificationprovider#requirement_satisfied_by?()","bundler::molinillo::specificationprovider#requirement_satisfied_by?()","bundler::resolver#requirement_satisfied_by?()","gem::resolver#requirement_satisfied_by?()","gem::resolver::molinillo::delegates::specificationprovider#requirement_satisfied_by?()","gem::resolver::molinillo::specificationprovider#requirement_satisfied_by?()","bundler::molinillo::resolver::resolution#requirement_tree_for()","gem::resolver::molinillo::resolver::resolution#requirement_tree_for()","bundler::molinillo::resolver::resolution#requirement_trees()","gem::resolver::molinillo::resolver::resolution#requirement_trees()","bundler::molinillo::delegates::resolutionstate#requirements()","bundler::molinillo::dependencygraph::vertex#requirements()","gem::resolver::molinillo::delegates::resolutionstate#requirements()","gem::resolver::molinillo::dependencygraph::vertex#requirements()","gem::specification#requirements()","gem::specification#requirements=()","gem::dependency#requirements_list()","bundler::gemdeps#requires()","bundler::source::git#requires_checkout?()","bundler::requires_sudo?()","bundler::plugin::installer::rubygems#requires_sudo?()","bundler::source::rubygems#requires_sudo?()","rdoc::task#rerdoc_task_description()","rdoc::task#rerdoc_task_description()","rdoc::task#rerdoc_task_name()","rdoc::task#rerdoc_task_name()","bundler::persistent::net::http::persistent#reset()","bundler::plugin::events::reset()","bundler::rubygemsintegration#reset()","cgi::htmlextension#reset()","digest::base#reset()","digest::instance#reset()","gem::commandmanager::reset()","gem::request#reset()","gem::security::reset()","gem::specification::reset()","net::pop3#reset()","openssl::cipher#reset()","openssl::digest#reset()","openssl::hmac#reset()","rdoc::parser::ripperstatelex::innerstatelex#reset()","rdoc::parser::rubytools#reset()","rexml::validation::choice#reset()","rexml::validation::interleave#reset()","rexml::validation::oneormore#reset()","rexml::validation::state#reset()","rexml::validation::validator#reset()","set#reset()","stringscanner#reset()","zlib::zstream#reset()","bundler::reset!()","bundler::plugin#reset!()","gem::specification#reset_nil_attributes_to_default()","bundler::reset_paths!()","bundler::reset_rubygems!()","bundler::definition#resolve()","bundler::molinillo::resolver#resolve()","bundler::molinillo::resolver::resolution#resolve()","bundler::resolver::resolve()","gem::requestset#resolve()","gem::resolver#resolve()","gem::resolver::molinillo::resolver#resolve()","gem::resolver::molinillo::resolver::resolution#resolve()","rdoc::crossreference#resolve()","racc::states#resolve()","bundler::molinillo::resolver::resolution#resolve_activated_specs()","rdoc::context#resolve_aliases()","psych::visitors::toruby#resolve_class()","gem::requestset#resolve_current()","bundler::installer#resolve_if_needed()","bundler::cli::gem#resolve_name()","bundler::sharedhelpers#resolve_path()","bundler::definition#resolve_remotely!()","csv::parser#resolve_row_separator()","racc::states#resolve_rr()","racc::states#resolve_sr()","bundler::definition#resolve_with_cache!()","rss::rdf::channel::items#resources()","rss::taxonomytopicsmodel::taxonomytopics#resources()","bundler::connectionpool::wrapper#respond_to?()","bundler::lazyspecification#respond_to?()","bundler::remotespecification#respond_to?()","drb::drbobject#respond_to?()","drb::drbobject#respond_to?()","object#respond_to?()","bundler::plugin::api#respond_to_missing?()","delegator#respond_to_missing?()","object#respond_to_missing?()","net::httpgenericrequest#response_body_permitted?()","net::httpresponse::response_class()","openssl::ocsp::basicresponse#responses()","csv::parser::inputsscanner#rest()","stringscanner#rest()","stringscanner#rest?()","stringscanner#rest_size()","bundler::environmentpreserver#restore()","cgi::session::filestore#restore()","cgi::session::memorystore#restore()","cgi::session::nullstore#restore()","cgi::session::pstore#restore()","json::restore()","json#restore()","marshal::restore()","stringscanner#restsize()","coverage::result()","erb#result()","gc::profiler::result()","stopiteration#result()","erb#result_with_hash()","debugger__::resume()","fiber#resume()","rubyvm::mjit::resume()","net::ftp#retrbinary()","bundler::cli::outdated#retrieve_active_spec()","rdoc::parser::ruby#retrieve_comment_body()","rdoc::parser::ripperstatelex#retrieve_heredoc_info()","net::ftp#retrlines()","csv#return_headers?()","csv::parser#return_headers?()","win32ole_method#return_type()","win32ole_method#return_type_detail()","tracepoint#return_value()","win32ole_method#return_vtype()","win32ole_param#retval?()","array#reverse()","ipaddr#reverse()","string#reverse()","array#reverse!()","string#reverse!()","array#reverse_each()","bundler::molinillo::dependencygraph::log#reverse_each()","enumerable#reverse_each()","gem::resolver::molinillo::dependencygraph::log#reverse_each()","bundler::rubygemsintegration#reverse_rubygems_kernel_mixin()","bundler::molinillo::resolver::resolution::unwinddetails#reversed_requirement_tree_index()","bundler::source::git#revision()","bundler::source::git::gitproxy#revision()","psych::visitors::toruby#revive()","psych::visitors::toruby#revive_hash()","openssl::ocsp::singleresponse#revocation_reason()","openssl::ocsp::singleresponse#revocation_time()","openssl::x509::crl#revoked()","openssl::x509::crl#revoked=()","argf#rewind()","csv#rewind()","csv::writer#rewind()","dir#rewind()","enumerator#rewind()","enumerator::chain#rewind()","gem::package::tarreader#rewind()","gem::package::tarreader::entry#rewind()","io#rewind()","prime::eratosthenesgenerator#rewind()","prime::generator23#rewind()","prime::pseudoprimegenerator#rewind()","prime::trialdivisiongenerator#rewind()","rexml::parsers::lightparser#rewind()","rexml::parsers::ultralightparser#rewind()","stringio#rewind()","zlib::gzipreader#rewind()","bundler::molinillo::dependencygraph#rewind_to()","bundler::molinillo::dependencygraph::log#rewind_to()","gem::resolver::molinillo::dependencygraph#rewind_to()","gem::resolver::molinillo::dependencygraph::log#rewind_to()","cgi::util#rfc1123_date()","date::rfc2822()","date#rfc2822()","datetime::rfc2822()","time::rfc2822()","time#rfc2822()","date::rfc3339()","date#rfc3339()","datetime#rfc3339()","datetime::rfc3339()","date#rfc822()","date::rfc822()","datetime::rfc822()","time::rfc822()","time#rfc822()","gem::specification#rg_full_gem_path()","gem::specification#rg_loaded_from()","gem::specification#ri_dir()","rdoc::rubygemshook#ri_installed?()","rdoc::rubygemshook#ri_installed?()","rdoc::servlet#ri_paths()","process::gid::rid()","process::uid::rid()","racc::grammar::precedencedefinitionenv#right()","array#rindex()","string#rindex()","string#rjust()","bundler::fileutils#rm()","bundler::fileutils::rm()","fileutils::rm()","fileutils#rm()","bundler::fileutils::rm_f()","bundler::fileutils#rm_f()","fileutils#rm_f()","fileutils::rm_f()","bundler::fileutils#rm_r()","bundler::fileutils::rm_r()","fileutils#rm_r()","fileutils::rm_r()","bundler::rm_rf()","bundler::fileutils::rm_rf()","bundler::fileutils#rm_rf()","fileutils::rm_rf()","fileutils#rm_rf()","bundler::fileutils::rmdir()","bundler::fileutils#rmdir()","dir::rmdir()","fileutils::rmdir()","fileutils#rmdir()","net::ftp#rmdir()","pathname#rmdir()","bundler::fileutils#rmtree()","bundler::fileutils::rmtree()","fileutils#rmtree()","fileutils::rmtree()","pathname#rmtree()","bundler::root()","bundler::plugin#root()","bundler::plugin::api::source#root()","bundler::plugin::installer::git#root()","bundler::sharedhelpers#root()","bundler::source::path#root()","gem::server#root()","psych::nodes::document#root()","rdoc::servlet#root()","rexml::document#root()","rexml::element#root()","rexml::light::node#root()","pstore#root?()","pathname#root?()","rexml::element#root_node()","rdoc::servlet#root_search()","bundler::molinillo::dependencygraph#root_vertex_named()","gem::resolver::molinillo::dependencygraph#root_vertex_named()","pstore#roots()","array#rotate()","array#rotate!()","bigdecimal#round()","float#round()","integer#round()","matrix#round()","numeric#round()","rexml::functions::round()","rational#round()","time#round()","vector#round()","bundler::uri::generic#route_from()","uri::generic#route_from()","bundler::uri::generic#route_to()","uri::generic#route_to()","matrix#row()","matrix#row_count()","csv#row_sep()","csv::parser#row_separator()","matrix#row_size()","matrix::row_vector()","matrix#row_vectors()","matrix::rows()","string#rpartition()","racc::state#rr_conflict()","racc::states#rrconflict_exist?()","racc::state#rruleid()","net::smtp#rset()","openssl::bn#rshift!()","rss::baseparser#rss()","string#rstrip()","string#rstrip!()","bundler::rubydsl#ruby()","gem::ruby()","gem::requestset::gemdependencyapi#ruby()","module#ruby2_keywords()","proc#ruby2_keywords()","hash::ruby2_keywords_hash()","hash::ruby2_keywords_hash?()","gem::ruby=()","bundler::currentruby#ruby?()","gem::ruby_api_version()","gem::specification#ruby_code()","bundler::thor::util::ruby_command()","bundler::rubygemsintegration#ruby_engine()","gem::ruby_engine()","bundler::ruby_scope()","bundler::cli::exec#ruby_shebang?()","bundler::env::ruby_version()","gem::ruby_version()","gem::testcase::rubybin()","bundler::gemhelper#rubygem_push()","bundler::rubygems()","bundler::plugin::sourcelist#rubygems_aggregate_class()","bundler::sourcelist#rubygems_aggregate_class()","gem::configfile#rubygems_api_key()","gem::configfile#rubygems_api_key=()","gem::gemcutterutilities#rubygems_api_request()","bundler::plugin::installer::rubygems#rubygems_dir()","bundler::source::rubygems#rubygems_dir()","bundler::sourcelist#rubygems_primary_remotes()","bundler::sourcelist#rubygems_remotes()","bundler::sourcelist#rubygems_sources()","gem::commands::updatecommand#rubygems_target_version()","gem::rubygems_version()","bundler::settings::validator::rule()","racc::rule#rule()","racc::sym#rule()","racc::reduce#ruleid()","bundler::settings::validator::rules()","bundler::cli::add#run()","bundler::cli::binstubs#run()","bundler::cli::cache#run()","bundler::cli::check#run()","bundler::cli::clean#run()","bundler::cli::config::base#run()","bundler::cli::console#run()","bundler::cli::doctor#run()","bundler::cli::exec#run()","bundler::cli::gem#run()","bundler::cli::info#run()","bundler::cli::init#run()","bundler::cli::inject#run()","bundler::cli::install#run()","bundler::cli::issue#run()","bundler::cli::list#run()","bundler::cli::lock#run()","bundler::cli::open#run()","bundler::cli::outdated#run()","bundler::cli::package#run()","bundler::cli::platform#run()","bundler::cli::pristine#run()","bundler::cli::remove#run()","bundler::cli::show#run()","bundler::cli::update#run()","bundler::cli::viz#run()","bundler::graph::graphvizclient#run()","bundler::installer#run()","bundler::retry#run()","bundler::thor::actions#run()","bundler::thor::command#run()","bundler::thor::command#run()","bundler::thor::dynamiccommand#run()","bundler::thor::dynamiccommand#run()","drb::drbserver#run()","erb#run()","gem::commandmanager#run()","gem::ext::builder::run()","gem::gemrunner#run()","gem::server::run()","gem::server#run()","irb::irb#run()","thread#run()","webrick::genericserver#run()","webrick::httpserver#run()","bundler::source::path::installer#run_hooks()","bundler::thor::actions#run_ruby_script()","coverage::running?()","gem::dependency#runtime?()","gem::specification#runtime_dependencies()","racc::parserfilegenerator#runtime_source()","gem::remotefetcher#s3_uri_signer()","gem::uninstaller#safe_delete()","thread#safe_level()","gem::safeyaml::safe_load()","psych::safe_load()","bundler::fileutils::safe_unlink()","bundler::fileutils#safe_unlink()","fileutils::safe_unlink()","fileutils#safe_unlink()","gem::specification#same_attributes?()","rss::rootelementmixin#same_feed_type?()","array#sample()","gem::specification#sanitize()","rdoc::options#sanitize_path()","gem::specification#sanitize_string()","gem::requirement#satisfied_by?()","bundler::lazyspecification#satisfies?()","bundler::definition#satisfies_locked_spec?()","gem::specification#satisfies_requirement?()","date#saturday?()","time#saturday?()","rdoc::store#save()","rdoc::store#save_cache()","rdoc::store#save_class()","pstore#save_data()","pstore#save_data_with_atomic_file_rename_strategy()","pstore#save_data_with_fast_strategy()","bigdecimal::save_exception_mode()","irb::context#save_history()","irb::context#save_history=()","bundler::plugin::index#save_index()","bigdecimal::save_limit()","gem::testcase#save_loaded_features()","rdoc::store#save_method()","rdoc::store#save_page()","bundler::plugin#save_plugins()","bigdecimal::save_rounding_mode()","bundler::thor::shell::basic#say()","bundler::ui::rgproxy#say()","gem::streamui#say()","gem::userinteraction#say()","bundler::thor::shell::basic#say_status()","matrix::scalar()","psych::coder#scalar()","psych::emitter#scalar()","psych::handler#scalar()","psych::treebuilder#scalar()","psych::coder#scalar=()","psych::nodes::node#scalar?()","psych::nodes::scalar#scalar?()","csv::parser::inputsscanner#scan()","irb::color::scan()","openssl::x509::name::rfc2253dn#scan()","rdoc::parser::c#scan()","rdoc::parser::changelog#scan()","rdoc::parser::markdown#scan()","rdoc::parser::rd#scan()","rdoc::parser::ruby#scan()","rdoc::parser::simple#scan()","rexml::iosource#scan()","rexml::source#scan()","string#scan()","stringscanner#scan()","racc::grammarfilescanner#scan_action()","csv::parser::inputsscanner#scan_all()","racc::grammarfilescanner#scan_error!()","stringscanner#scan_full()","gem::testcase#scan_make_command_lines()","racc::grammarfilescanner#scan_quoted()","irb::color::symbolstate#scan_token()","stringscanner#scan_until()","bundler::uri::generic#scheme=()","uri::generic#scheme=()","bundler::uri::scheme_list()","uri::scheme_list()","bundler::uri::ldap#scope()","uri::ldap#scope()","bundler::uri::ldap#scope=()","uri::ldap#scope=()","bundler::cli::config::scope_options()","io#scroll_backward()","io#scroll_forward()","cgi::htmlextension#scrolling_list()","string#scrub()","string#scrub!()","openssl::kdf::scrypt()","bundler::index#search()","irb::jobmanager#search()","net::imap#search()","optionparser#search()","optionparser::list#search()","bundler::index#search_all()","bundler::index#search_by_dependency()","bundler::index#search_by_spec()","optionparser::search_const()","encoding::converter::search_convpath()","irb::locale#search_file()","bundler::molinillo::delegates::specificationprovider#search_for()","bundler::molinillo::specificationprovider#search_for()","bundler::resolver#search_for()","gem::resolver#search_for()","gem::resolver::molinillo::delegates::specificationprovider#search_for()","gem::resolver::molinillo::specificationprovider#search_for()","gem::specfetcher#search_for_dependency()","stringscanner#search_full()","net::imap#search_internal()","rdoc::classmodule#search_record()","rdoc::methodattr#search_record()","rdoc::toplevel#search_record()","webrick::httpserver#search_servlet()","bundler::sharedhelpers#search_up()","gem::searcher=()","date#sec()","datetime#sec()","time#sec()","datetime#sec_fraction()","date#second()","datetime#second()","rss::itunesitemmodel::itunesduration#second=()","rss::maker::itunesitemmodel::itunesdurationbase#second=()","datetime#second_fraction()","rss::itunesitemmodel::itunesduration::seconds_to_components()","rdoc::codeobject#section()","rdoc::context#section_contents()","openssl::config#sections()","rdoc::context#sections()","bundler::lockfileparser::sections_in_lockfile()","bundler::lockfileparser::sections_to_ignore()","cgi::cookie#secure=()","openssl::ssl::sslcontext#security_level()","openssl::ssl::sslcontext#security_level=()","bundler::rubygemsintegration#security_policies()","bundler::rubygemsintegration#security_policy_keys()","rdoc::methodattr#see()","openssl::pkey::ec::group#seed()","openssl::random::seed()","random#seed()","openssl::pkey::ec::group#seed=()","argf#seek()","dir#seek()","gem::package::tarreader#seek()","io#seek()","stringio#seek()","bundler::gemversionpromoter#segments_do_not_match()","array#select()","bundler::uri::generic#select()","dbm#select()","env::select()","enumerable#select()","enumerator::lazy#select()","gdbm#select()","hash#select()","io::select()","kernel#select()","net::imap#select()","sdbm#select()","struct#select()","uri::generic#select()","yaml::dbm#select()","array#select!()","env::select!()","hash#select!()","set#select!()","bundler::gemhelpers#select_best_platform_match()","bundler::gemhelpers::select_best_platform_match()","bundler::cli::common::select_spec()","tracepoint#self()","racc::sym#self_null?()","basicsocket#send()","object#send()","rexml::functions::send()","udpsocket#send()","net::imap#send_command()","net::imap#send_data()","net::http#send_entity()","gem::commands::pushcommand#send_gem()","unixsocket#send_io()","net::imap#send_list_data()","net::imap#send_literal()","net::smtp#send_mail()","net::smtp#send_message()","net::imap#send_number_data()","gem::commands::ownercommand#send_owner_request()","gem::commands::pushcommand#send_push_request()","net::imap#send_quoted_string()","net::http#send_request()","net::httpgenericrequest#send_request_with_body()","net::httpgenericrequest#send_request_with_body_data()","net::httpgenericrequest#send_request_with_body_stream()","net::imap#send_string_data()","net::imap#send_symbol_data()","net::imap#send_time_data()","net::ftp#sendcmd()","irb::frame::sender()","net::smtp#sendmail()","basicsocket#sendmsg()","basicsocket#sendmsg_nonblock()","racc::grammar::definitionenv#separated_by()","racc::grammar::definitionenv#separated_by1()","optionparser#separator()","pp::ppmethods#seplist()","racc::grammar::definitionenv#seq()","psych::coder#seq=()","psych::nodes::node#sequence?()","psych::nodes::sequence#sequence?()","bundler::compactindexclient#sequential_execution_mode!()","bundler::compactindexclient#sequentially()","openssl::ocsp::certificateid#serial()","openssl::pkcs7::recipientinfo#serial()","openssl::pkcs7::signerinfo#serial()","openssl::x509::certificate#serial()","openssl::x509::revoked#serial()","openssl::x509::certificate#serial=()","openssl::x509::revoked#serial=()","bundler::fetcher::compactindex#serial_compact_index_client()","racc::sym#serialize()","bundler::source::git#serialize_gemspecs_in()","racc::parserfilegenerator#serialize_integer_list_compressed()","racc::parserfilegenerator#serialize_integer_list_std()","webrick::httpstatus#server_error?()","webrick::httpstatus::server_error?()","webrick::httprequest#server_name()","drb::extservmanager#service()","webrick::cgi#service()","webrick::httpserver#service()","webrick::httpservlet::abstractservlet#service()","openssl::ssl::sslsocket#session()","openssl::ssl::sslsocket#session=()","openssl::ssl::sslcontext#session_add()","openssl::ssl::sslcontext#session_cache_mode()","openssl::ssl::sslcontext#session_cache_mode=()","openssl::ssl::sslcontext#session_cache_size()","openssl::ssl::sslcontext#session_cache_size=()","openssl::ssl::sslcontext#session_cache_stats()","openssl::ssl::sslsocket#session_get_cb()","openssl::ssl::sslsocket#session_new_cb()","openssl::ssl::sslcontext#session_remove()","openssl::ssl::sslsocket#session_reused?()","bundler::cli::config#set()","bundler::settings::validator::rule#set()","ipaddr#set()","racc::states#set_accept()","gem::configfile#set_api_key()","gem::gemcutterutilities#set_api_key()","bundler::uri::ldap#set_attributes()","uri::ldap#set_attributes()","exception#set_backtrace()","optionparser::parseerror#set_backtrace()","openssl::bn#set_bit!()","bundler::sharedhelpers#set_bundle_environment()","bundler::sharedhelpers#set_bundle_variables()","webrick::utils::set_close_on_exec()","webrick::utils#set_close_on_exec()","matrix#set_col_range()","bundler::thor::shell::color#set_color()","bundler::thor::shell::html#set_color()","matrix#set_column_vector()","bundler::settings#set_command_option()","bundler::settings#set_command_option_if_given()","matrix#set_component()","vector#set_component()","gem::configfile#set_config_file_name()","rdoc::context#set_constant_visibility_for()","net::httpheader#set_content_type()","openssl::pkey::rsa#set_crt_params()","fiddle::cstructentity#set_ctypes()","fiddle::cunionentity#set_ctypes()","rdoc::context#set_current_section()","net::http#set_debug_output()","net::pop3#set_debug_output()","net::smtp#set_debug_output()","openssl::engine#set_default()","openssl::x509::store#set_default_paths()","rss::maker::base#set_default_values()","zlib::deflate#set_dictionary()","zlib::inflate#set_dictionary()","bundler::uri::ldap#set_dn()","uri::ldap#set_dn()","matrix#set_element()","vector#set_element()","argf#set_encoding()","io#set_encoding()","stringio#set_encoding()","io#set_encoding_by_bom()","stringio#set_encoding_by_bom()","psych::treebuilder#set_end_location()","bundler::sharedhelpers#set_env()","bundler::thor::actions::capturableerb#set_eoutvar()","erb#set_eoutvar()","rdoc::erbio#set_eoutvar()","rdoc::erbpartial#set_eoutvar()","getoptlong#set_error()","webrick::httpresponse#set_error()","bundler::uri::ldap#set_extensions()","uri::ldap#set_extensions()","openssl::pkey::rsa#set_factors()","net::httpheader#set_field()","bundler::uri::ldap#set_filter()","uri::ldap#set_filter()","net::httpheader#set_form()","net::httpheader#set_form_data()","openssl::pkey::ec::group#set_generator()","tracer::set_get_line_procs()","bundler::settings#set_global()","bundler::uri::mailto#set_headers()","uri::mailto#set_headers()","bundler::uri::file#set_host()","bundler::uri::generic#set_host()","uri::file#set_host()","uri::generic#set_host()","bundler::rubygemsintegration#set_installed_by_version()","bundler::settings#set_key()","openssl::pkey::dh#set_key()","openssl::pkey::dsa#set_key()","openssl::pkey::rsa#set_key()","debugger__::set_last_thread()","irb::context#set_last_value()","bundler::settings#set_local()","bundler::source::git#set_local!()","psych::treebuilder#set_location()","openssl::ssl::sslcontext#set_minmax_proto_version()","rss::element#set_next_element()","webrick::utils::set_non_blocking()","webrick::utils#set_non_blocking()","bundler::uri::generic#set_opaque()","uri::generic#set_opaque()","optionparser::parseerror#set_option()","getoptlong#set_options()","openssl::ssl::sslcontext#set_params()","rss::maker::base#set_parent()","webrick::httpauth::htdigest#set_passwd()","webrick::httpauth::htpasswd#set_passwd()","webrick::httpauth::userdb#set_passwd()","bundler::uri::file#set_password()","bundler::uri::generic#set_password()","uri::file#set_password()","uri::generic#set_password()","bundler::sharedhelpers#set_path()","bundler::uri::ftp#set_path()","bundler::uri::generic#set_path()","uri::ftp#set_path()","uri::generic#set_path()","bundler::molinillo::dependencygraph#set_payload()","bundler::molinillo::dependencygraph::log#set_payload()","gem::resolver::molinillo::dependencygraph#set_payload()","gem::resolver::molinillo::dependencygraph::log#set_payload()","bundler::uri::file#set_port()","bundler::uri::generic#set_port()","uri::file#set_port()","uri::generic#set_port()","openssl::pkey::dh#set_pqg()","openssl::pkey::dsa#set_pqg()","net::httpheader#set_range()","vector#set_range()","webrick::httpresponse#set_redirect()","matrix#set_row_and_col_range()","matrix#set_row_range()","bundler::sharedhelpers#set_rubylib()","bundler::sharedhelpers#set_rubyopt()","bundler::uri::generic#set_scheme()","uri::generic#set_scheme()","bundler::uri::ldap#set_scope()","uri::ldap#set_scope()","readline::set_screen_size()","rss::imagefaviconmodel::imagefavicon#set_size()","net::ftp#set_socket()","psych::treebuilder#set_start_location()","racc::statetransitiontablegenerator#set_table()","bundler::uri::mailto#set_to()","uri::mailto#set_to()","openssl::pkey::ec::point#set_to_infinity!()","debugger__::set_trace()","kernel#set_trace_func()","thread#set_trace_func()","bundler::uri::ftp#set_typecode()","uri::ftp#set_typecode()","bundler::uri::file#set_user()","bundler::uri::generic#set_user()","uri::file#set_user()","uri::generic#set_user()","bundler::uri::file#set_userinfo()","bundler::uri::generic#set_userinfo()","uri::file#set_userinfo()","uri::generic#set_userinfo()","matrix#set_value()","vector#set_value()","rdoc::context#set_visibility_for()","rss::maker::atomtextconstructbase::ensurexmlcontent#set_xhtml_uri_as_default_uri()","net::imap#setacl()","string#setbyte()","process::sys::setegid()","process::sys::seteuid()","process::sys::setgid()","file::setgid?()","file::stat#setgid?()","filetest#setgid?()","pathname#setgid?()","etc::setgrent()","process::setpgid()","process::setpgrp()","process::setpriority()","process::setproctitle()","win32ole#setproperty()","etc::setpwent()","net::imap#setquota()","process::sys::setregid()","process::sys::setresgid()","process::sys::setresuid()","process::sys::setreuid()","process::sys::setrgid()","process::setrlimit()","process::sys::setruid()","process::setsid()","basicsocket#setsockopt()","openssl::ssl::socketforwarder#setsockopt()","rss::baselistener::setter()","bundler::settings()","bundler::featureflag::settings_flag()","bundler::featureflag::settings_method()","bundler::featureflag::settings_option()","process::sys::setuid()","file::setuid?()","file::stat#setuid?()","filetest#setuid?()","pathname#setuid?()","bundler::setup()","bundler::runtime#setup()","gem::installertestcase#setup()","gem::testcase#setup()","openssl::ssl::sslcontext#setup()","rdoc::rubygemshook#setup()","rdoc::rubygemshook#setup()","gem::installertestcase#setup_base_gem()","gem::installertestcase#setup_base_installer()","gem::installertestcase#setup_base_spec()","gem::installertestcase#setup_base_user_installer()","bundler::cli::cache#setup_cache_all()","bundler::cli::package#setup_cache_all()","drb::drbsslsocket::sslconfig#setup_certificate()","rss::maker::atom::entry#setup_elements()","rss::maker::atom::feed#setup_elements()","rss::maker::rss09#setup_elements()","rss::maker::rss10#setup_elements()","rdoc::options#setup_generator()","rss::maker::rss09::channel#setup_image()","rss::maker::rss10::channel#setup_image()","rss::maker::rss09::channel#setup_items()","rss::maker::rss10::channel#setup_items()","rss::atom::entry#setup_maker()","rss::rdf::bag#setup_maker()","rss::rdf::bag#setup_maker()","rss::rdf::seq#setup_maker()","rss::rdf::seq#setup_maker()","rss::rootelementmixin#setup_maker()","rss::setupmaker#setup_maker()","rss::xmlstylesheet#setup_maker()","rss::atom::feed::generator#setup_maker_attributes()","rss::atom::textconstruct#setup_maker_attributes()","rss::ituneschannelmodel::itunescategory#setup_maker_attributes()","rss::ituneschannelmodel::itunesimage#setup_maker_attributes()","rss::imagefaviconmodel::imagefavicon#setup_maker_attributes()","rss::imageitemmodel::imageitem#setup_maker_attributes()","rss::rdf::channel#setup_maker_attributes()","rss::rss::channel::item::category#setup_maker_attributes()","rss::rss::channel::item::enclosure#setup_maker_attributes()","rss::rss::channel::item::guid#setup_maker_attributes()","rss::rss::channel::item::source#setup_maker_attributes()","rss::setupmaker#setup_maker_attributes()","rss::atom::contentmodel#setup_maker_element()","rss::atom::feed#setup_maker_element()","rss::ituneschannelmodel::itunesowner#setup_maker_element()","rss::itunesitemmodel::itunesduration#setup_maker_element()","rss::rss::channel::item#setup_maker_element()","rss::setupmaker#setup_maker_element()","rss::atom::contentmodel#setup_maker_element_writer()","rss::atom::feed::logo#setup_maker_element_writer()","rss::atom::feed#setup_maker_elements()","rss::ituneschannelmodel::itunescategory#setup_maker_elements()","rss::rss#setup_maker_elements()","rss::rss::channel#setup_maker_elements()","rss::setupmaker#setup_maker_elements()","bundler::runtime#setup_manpath()","rss::listenermixin#setup_next_element()","rss::listenermixin#setup_next_element_in_unknown_element()","rss::maker::base#setup_other_elements()","rdoc::rdoc#setup_output_dir()","webrick::accesslog#setup_params()","gem::package#setup_signer()","drb::drbsslsocket::sslconfig#setup_ssl_context()","rss::maker::rss09::channel#setup_textinput()","rss::maker::rss10::channel#setup_textinput()","rss::maker::base#setup_values()","logger#sev_threshold=()","ripper::sexp()","ripper::sexp_raw()","bundler::gemhelper#sh()","bundler::gemhelper#sh_with_input()","bundler::gemhelper#sh_with_status()","bundler::molinillo::dependencygraph::vertex#shallow_eql?()","gem::resolver::molinillo::dependencygraph::vertex#shallow_eql?()","gem::commands::setupcommand#shebang()","gem::installer#shebang()","racc::parserfilegenerator#shebang()","bundler::thor::base::shell()","bundler::thor::shell#shell()","shellwords::shellescape()","shellwords#shellescape()","string#shellescape()","array#shelljoin()","shellwords::shelljoin()","shellwords#shelljoin()","shellwords#shellsplit()","shellwords::shellsplit()","string#shellsplit()","shellwords#shellwords()","shellwords::shellwords()","array#shift()","bundler::thor::coreext::orderedhash#shift()","csv#shift()","dbm#shift()","env::shift()","gdbm#shift()","gem::requestset::lockfile::tokenizer#shift()","hash#shift()","queue#shift()","racc::actiontable#shift()","sdbm#shift()","sizedqueue#shift()","yaml::dbm#shift()","racc::actiontable#shift_n()","openssl::asn1::objectid#short_name()","bundler::source::git#shortref_for_display()","bundler::source::git#shortref_for_path()","bundler::dependency#should_include?()","racc::states#should_report_srconflict?()","racc::sym#should_terminal()","racc::sym#should_terminal?()","bundler::cli#show()","rdoc::servlet#show_documentation()","gem::commands::contentscommand#show_files()","gem::commands::querycommand#show_gems()","gem::command#show_help()","gem::commands::querycommand#show_local_gems()","gem::command#show_lookup_failure()","gem::commands::ownercommand#show_owners()","gem::commands::querycommand#show_prereleases?()","bundler::cli::config::base#show_pretty_values_for()","gem::server#show_rdoc_for_pattern()","gem::commands::setupcommand#show_release_notes()","gem::commands::querycommand#show_remote_gems()","optionparser::show_version()","bundler::injector#show_warning()","array#shuffle()","array#shuffle!()","basicsocket#shutdown()","bundler::connectionpool#shutdown()","bundler::connectionpool::timedstack#shutdown()","bundler::persistent::net::http::persistent#shutdown()","drb::drbserver#shutdown()","openssl::ssl::sslserver#shutdown()","rinda::ringserver#shutdown()","webrick::genericserver#shutdown()","bundler::connectionpool::timedstack#shutdown_connections()","process::gid::sid_available?()","process::uid::sid_available?()","bigdecimal#sign()","gem::commands::certcommand#sign()","gem::s3urisigner#sign()","gem::security::sign()","gem::security::signer#sign()","openssl::netscape::spki#sign()","openssl::ocsp::basicresponse#sign()","openssl::ocsp::request#sign()","openssl::pkcs7::sign()","openssl::pkey::pkey#sign()","openssl::x509::crl#sign()","openssl::x509::certificate#sign()","openssl::x509::request#sign()","gem::gemcutterutilities#sign_in()","openssl::pkey::rsa#sign_pss()","conditionvariable#signal()","monitormixin::conditionvariable#signal()","rinda::waittemplateentry#signal()","irb::irb#signal_handle()","irb::irb#signal_status()","process::status#signaled?()","signal::signame()","rdoc::tomdoc::signature()","openssl::x509::crl#signature_algorithm()","openssl::x509::certificate#signature_algorithm()","openssl::x509::request#signature_algorithm()","openssl::ocsp::request#signed?()","openssl::pkcs7::signerinfo#signed_time()","openssl::pkcs7#signers()","signalexception#signo()","bundler::ui::shell#silence()","bundler::ui::silent#silence()","gem::util::silent_system()","bundler::similaritydetector#similar_word_list()","bundler::similaritydetector#similar_words()","bigmath#sin()","math::sin()","bundler::versionranges::reqr#single?()","rexml::validation::event#single?()","singleforwardable#single_delegate()","bundler::rubyversion#single_version_string()","prettyprint::singleline_format()","pp::singleline_pp()","object#singleton_class()","module#singleton_class?()","object#singleton_method()","basicobject#singleton_method_added()","rexml::functions::singleton_method_added()","basicobject#singleton_method_removed()","basicobject#singleton_method_undefined()","object#singleton_methods()","matrix#singular?()","matrix::lupdecomposition#singular?()","math::sinh()","net::ftp#site()","array#size()","bundler::connectionpool#size()","bundler::index#size()","bundler::specset#size()","dbm#size()","digest::instance#size()","env::size()","enumerator#size()","enumerator::arithmeticsequence#size()","enumerator::chain#size()","fiddle::cstructentity::size()","fiddle::cunionentity::size()","fiddle::pointer#size()","file#size()","file::size()","file::stat#size()","filetest#size()","gdbm#size()","gem::availableset#size()","gem::package::tarreader::entry#size()","gem::resolver::requirementlist#size()","hash#size()","integer#size()","matchdata#size()","net::ftp#size()","objectspace::weakmap#size()","pathname#size()","prime::pseudoprimegenerator#size()","queue#size()","rexml::attributes#size()","rexml::elements#size()","rexml::light::node#size()","rexml::parent#size()","racc::grammar#size()","racc::iset#size()","racc::rule#size()","racc::states#size()","range#size()","rinda::tuple#size()","rinda::tupleentry#size()","sdbm#size()","set#size()","sizedqueue#size()","string#size()","stringio#size()","stringscanner#size()","struct#size()","symbol#size()","tempfile#size()","vector#size()","fiddle::pointer#size=()","rss::imagefaviconmodel::imagefavicon#size=()","file::size?()","file::stat#size?()","filetest#size?()","pathname#size?()","win32ole_method#size_opt_params()","win32ole_method#size_params()","fiddle::importer#sizeof()","matrix#skew_symmetric?()","argf#skip()","bundler::deprecate::skip()","gem::requestset::lockfile::tokenizer#skip()","stringscanner#skip()","bundler::deprecate::skip=()","csv#skip_blanks?()","csv::parser#skip_blanks?()","racc::grammarfilescanner#skip_comment()","bundler::deprecate::skip_during()","gem::deprecate::skip_during()","gem::deprecate#skip_during()","rdoc::parser::ruby#skip_for_variable()","csv::parser#skip_line?()","csv#skip_lines()","csv::parser#skip_lines()","rdoc::parser::ruby#skip_method()","csv::parser#skip_needless_lines()","rdoc::parser::ruby#skip_optional_do_after_expression()","rdoc::parser::rubytools#skip_tkspace()","rdoc::parser::ruby#skip_tkspace_comment()","rdoc::parser::rubytools#skip_tkspace_without_nl()","stringscanner#skip_until()","kernel#sleep()","mutex#sleep()","mutex_m#sleep()","array#slice()","env::slice()","hash#slice()","ripper::slice()","string#slice()","symbol#slice()","array#slice!()","string#slice!()","enumerable#slice_after()","enumerator::lazy#slice_after()","enumerable#slice_before()","enumerator::lazy#slice_before()","bundler::compactindexclient::updater#slice_body()","enumerable#slice_when()","enumerator::lazy#slice_when()","openssl::asn1::objectid#sn()","bundler::thor::util::snake_case()","rdoc::text#snippet()","socket::sockaddr_in()","socket::sockaddr_un()","file::socket?()","file::stat#socket?()","filetest#socket?()","pathname#socket?()","socket::socketpair()","unixsocket::socketpair()","addrinfo#socktype()","matrix::lupdecomposition#solve()","array#sort()","enumerable#sort()","net::imap#sort()","rexml::xpathparser#sort()","array#sort!()","bundler::specset#sort!()","enumerable#sort_by()","array#sort_by!()","gem::specification::sort_by!()","bundler::gemversionpromoter#sort_dep_specs()","bundler::molinillo::delegates::specificationprovider#sort_dependencies()","bundler::molinillo::specificationprovider#sort_dependencies()","bundler::resolver#sort_dependencies()","gem::resolver#sort_dependencies()","gem::resolver::molinillo::delegates::specificationprovider#sort_dependencies()","gem::resolver::molinillo::specificationprovider#sort_dependencies()","rss::maker::itemsbase#sort_if_need()","net::imap#sort_internal()","bundler::remotespecification#sort_obj()","gem::specification#sort_obj()","bundler::resolver::sort_platforms()","rdoc::context#sort_sections()","bundler::index#sort_specs()","bundler::index::sort_specs()","bundler::gemversionpromoter#sort_versions()","bundler::specset#sorted()","gem::availableset#sorted()","gem::requestset#sorted_requests()","bundler::dsl#source()","bundler::plugin#source()","bundler::plugin::api::source()","bundler::plugin::dsl#source()","gem::requestset::gemdependencyapi#source()","gem::resolver::installedspecification#source()","gem::specification#source()","json::ext::parser#source()","rdoc::store#source()","rexml::parsers::sax2parser#source()","regexp#source()","bundler::stubspecification#source=()","bundler::plugin#source?()","bundler::plugin::index#source?()","racc::useraction#source?()","gem::source_date_epoch()","gem::source_date_epoch_string()","encoding::converter#source_encoding()","encoding::invalidbytesequenceerror#source_encoding()","encoding::undefinedconversionerror#source_encoding()","encoding::invalidbytesequenceerror#source_encoding_name()","encoding::undefinedconversionerror#source_encoding_name()","irb::irbloader#source_file()","gem::availableset#source_for()","bundler::plugin#source_from_lock()","bundler::sourcelist#source_list_for()","binding#source_location()","method#source_location()","proc#source_location()","unboundmethod#source_location()","win32ole_type#source_ole_types()","bundler::thor::actions#source_paths()","bundler::thor::actions::classmethods#source_paths()","gem::basicspecification#source_paths()","bundler::thor::actions::classmethods#source_paths_for_search()","bundler::plugin::index#source_plugin()","bundler::definition#source_requirements()","bundler::cli::source_root()","bundler::thor::actions::classmethods#source_root()","racc::useraction::source_text()","bundler::rubygemsintegration#sources()","gem::sources()","bundler::rubygemsintegration#sources=()","gem::sources=()","json::ext::generator::state#space()","json::ext::generator::state#space=()","json::ext::generator::state#space_before()","json::ext::generator::state#space_before=()","kernel#spawn()","pty::spawn()","process::spawn()","bundler::compactindexclient#spec()","gem::installer#spec()","gem::package#spec()","gem::package::old#spec()","gem::resolver::lockspecification#spec()","gem::testcase::specfetchersetup#spec()","gem::commands::querycommand#spec_authors()","gem::spec_cache_dir()","bundler::rubygemsintegration#spec_cache_dirs()","bundler::rubygemsintegration#spec_default_gem?()","gem::specification#spec_dir()","bundler::rubygemsintegration#spec_extension_dir()","gem::installer#spec_file()","gem::specification#spec_file()","gem::commands::contentscommand#spec_for()","gem::commands::opencommand#spec_for()","bundler::graph#spec_for_dependency()","bundler::specset#spec_for_dependency()","gem::specfetcher#spec_for_dependency()","bundler::cli::info#spec_for_gem()","bundler::rubygemsintegration#spec_from_gem()","bundler::definition#spec_git_paths()","gem::requestset::lockfile#spec_groups()","gem::commands::querycommand#spec_homepage()","gem::commands::querycommand#spec_license()","gem::commands::querycommand#spec_loaded_from()","bundler::rubygemsintegration#spec_matches_for_glob()","bundler::rubygemsintegration#spec_missing_extensions?()","gem::nametuple#spec_name()","gem::specification#spec_name()","bundler::index#spec_names()","bundler::cli::info#spec_not_found()","gem::commands::lockcommand#spec_path()","gem::commands::querycommand#spec_platforms()","gem::dependencylist#spec_predecessors()","bundler::geminstaller#spec_settings()","gem::commands::querycommand#spec_summary()","readline::special_prefixes()","readline::special_prefixes=()","reline::core#special_prefixes=()","bundler::dependency#specific?()","gem::dependency#specific?()","gem::requirement#specific?()","bundler::compactindexclient::cache#specific_dependency()","gem::command::specific_extra_args()","gem::command::specific_extra_args_hash()","bundler::geminstaller#specific_failure_message()","bundler::settings#specific_gem_for()","bundler::definition#specs()","bundler::fetcher#specs()","bundler::fetcher::compactindex#specs()","bundler::fetcher::dependency#specs()","bundler::fetcher::index#specs()","bundler::gemdeps#specs()","bundler::plugin::api::source#specs()","bundler::source::git#specs()","bundler::source::metadata#specs()","bundler::source::path#specs()","bundler::source::rubygems#specs()","gem::requestset#specs()","gem::server#specs()","gem::source::git#specs()","bundler::index#specs_by_name()","bundler::definition#specs_changed?()","bundler::definition#specs_for()","bundler::fetcher::compactindex#specs_for_names()","bundler::definition#specs_for_source_changed?()","gem::requestset#specs_in()","bundler::specs_path()","gem::commands::querycommand#specs_type()","bundler::fetcher#specs_with_retry()","undefinedcommanderror::spellchecker#spell_checker()","unknownargumenterror::spellchecker#spell_checker()","bigdecimal#split()","bundler::uri::split()","bundler::uri::rfc2396_parser#split()","bundler::uri::rfc2396_parser#split()","file::split()","pathname#split()","shellwords::split()","string#split()","uri::split()","uri::rfc2396_parser#split()","uri::rfc2396_parser#split()","fiddle::cparser#split_arguments()","gem::pathsupport#split_gem_path()","webrick::httputils#split_header_value()","webrick::httputils::split_header_value()","rss::listenermixin#split_name()","bundler::uri::generic#split_path()","uri::generic#split_path()","bundler::settings#split_specific_setting_for()","bundler::uri::generic#split_userinfo()","uri::generic#split_userinfo()","kernel#sprintf()","openssl::bn#sqr()","bigdecimal#sqrt()","bigmath#sqrt()","integer::sqrt()","math::sqrt()","matrix#square?()","string#squeeze()","string#squeeze!()","racc::state#sr_conflict()","kernel#srand()","random::srand()","win32ole_type#src_type()","racc::states#srconflict_exist?()","bundler::persistent::net::http::persistent#ssl()","net::smtp#ssl?()","webrick::httprequest#ssl?()","net::pop3::ssl_params()","webrick::genericserver#ssl_servername_callback()","webrick::httpserver#ssl_servername_callback()","net::smtp#ssl_socket()","bundler::persistent::net::http::persistent#ssl_timeout=()","openssl::ssl::sslsocket#ssl_version()","bundler::persistent::net::http::persistent#ssl_version=()","openssl::ssl::sslcontext#ssl_version=()","net::http#sspi_auth()","net::http#sspi_auth?()","rexml::document#stand_alone?()","bundler::cli::start()","bundler::persistent::net::http::persistent#start()","bundler::resolver#start()","bundler::thor::base::classmethods#start()","coverage::start()","date#start()","gc::start()","irb::start()","net::http::start()","net::http#start()","net::pop3::start()","net::pop3#start()","net::smtp::start()","net::smtp#start()","psych::streaming#start()","psych::visitors::yamltree#start()","thread::start()","webrick::cgi#start()","webrick::daemon::start()","webrick::genericserver#start()","webrick::simpleserver::start()","rss::rexmllikexmlparser#startelement()","rdoc::tokenstream#start_collecting_tokens()","rdoc::codeobject#start_doc()","psych::emitter#start_document()","psych::handler#start_document()","psych::treebuilder#start_document()","rexml::sax2listener#start_document()","rexml::sax2listener#start_element()","rexml::parsers::pullevent#start_element?()","rss::listenermixin#start_else_element()","rss::listenermixin#start_get_text_element()","rss::listenermixin#start_have_something_element()","rinda::tuplespace#start_keeper()","psych::emitter#start_mapping()","psych::handler#start_mapping()","rexml::sax2listener#start_prefix_mapping()","bundler::molinillo::resolver::resolution#start_resolution()","gem::resolver::molinillo::resolver::resolution#start_resolution()","csv::parser#start_row()","psych::emitter#start_sequence()","psych::handler#start_sequence()","drb#start_service()","drb::start_service()","psych::emitter#start_stream()","psych::handler#start_stream()","psych::treebuilder#start_stream()","racc::grammar#start_symbol=()","net::ftp#start_tls_session()","net::imap#start_tls_session()","string#start_with?()","symbol#start_with?()","net::http#started?()","net::pop3#started?()","net::smtp#started?()","rexml::functions::starts_with()","net::imap#starttls()","net::smtp#starttls()","net::smtp#starttls?()","net::smtp#starttls_always?()","net::smtp#starttls_auto?()","csv#stat()","file::stat()","gc::stat()","io#stat()","pathname#stat()","rubyvm::stat()","tracepoint::stat()","bundler::molinillo::resolver::resolution#state()","gem::resolver::molinillo::resolver::resolution#state()","openssl::ssl::sslsocket#state()","ripper#state()","ripper::filter#state()","gem::resolver::molinillo::resolver::resolution#state_any?()","gem::resolver::molinillo::resolver::resolution#state_index_for_unwind()","racc::grammar#state_transition_table()","racc::parserfilegenerator#state_transition_table()","racc::states#state_transition_table()","racc::grammar#states()","net::ftp#status()","net::imap#status()","openssl::ocsp::basicresponse#status()","openssl::ocsp::response#status()","pty::childexited#status()","systemexit#status()","thread#status()","webrick::httpresponse#status=()","openssl::random::status?()","bundler::bundlererror::status_code()","bundler::dsl::dslerror#status_code()","webrick::httpresponse#status_line()","openssl::ocsp::response#status_string()","net::smtp::response#status_type_char()","bundler::thor::shell::basic#stderr()","cgi#stdinput()","bundler::thor::shell::basic#stdout()","debugger__::stdout()","debugger__::stdout=()","cgi#stdoutput()","date#step()","enumerator::arithmeticsequence#step()","numeric#step()","rexml::xpathparser#step()","range#step()","file::sticky?()","file::stat#sticky?()","filetest#sticky?()","pathname#sticky?()","bundler::worker#stop()","openssl::ssl::sslsocket#stop()","thread::stop()","webrick::genericserver#stop()","thread#stop?()","rdoc::codeobject#stop_doc()","bundler::thor::stop_on_unknown_option!()","drb::drbconn::stop_pool()","drb#stop_service()","drb::stop_service()","drb::drbserver#stop_service()","drb::extserv#stop_service()","bundler::worker#stop_threads()","process::status#stopped?()","process::status#stopsig()","net::ftp#storbinary()","dbm#store()","env::store()","gdbm#store()","hash#store()","net::imap#store()","sdbm#store()","yaml::dbm#store()","rdoc::anymethod#store=()","rdoc::classmodule#store=()","rdoc::codeobject#store=()","rdoc::constant#store=()","rdoc::methodattr#store=()","rdoc::mixin#store=()","rdoc::rdoc#store=()","bundler::connectionpool::timedstack#store_connection()","rdoc::servlet#store_for()","net::imap#store_internal()","net::ftp#storlines()","rexml::parsers::baseparser#stream=()","psych::nodes::node#stream?()","psych::nodes::stream#stream?()","net::httpresponse#stream_check()","zlib::zstream#stream_end?()","psych::handler#streaming?()","gc::stress()","gc::stress=()","date#strftime()","datetime#strftime()","time#strftime()","rexml::xpathparser#strict?()","bundler::thor::base::classmethods#strict_args_position!()","base64#strict_decode64()","base64#strict_encode64()","gem::package::tarheader::strict_oct()","rdoc::markdown#strike()","matchdata#string()","rexml::functions::string()","stringio#string()","stringscanner#string()","tempio#string()","stringio#string=()","stringscanner#string=()","rexml::functions::string_length()","racc::parserfilegenerator#string_list()","racc::sym#string_symbol?()","rexml::functions::string_value()","string#strip()","string#strip!()","rdoc::text#strip_hashes()","bundler::ui::shell#strip_leading_spaces()","rdoc::text#strip_newlines()","rexml::doctype#strip_quotes()","rdoc::text#strip_stars()","csv::parser#strip_value()","rdoc::markdown#strong()","tsort::strongly_connected_components()","tsort#strongly_connected_components()","date::strptime()","datetime::strptime()","time::strptime()","fiddle::importer#struct()","bundler::rubygemsintegration#stub_rubygems()","bundler::rubygemsintegration#stub_set_spec()","gem::basicspecification#stubbed?()","gem::specification#stubbed?()","gem::specification::stubs()","gem::specification::stubs_for()","webrick::utils::su()","webrick::utils#su()","bigdecimal#sub()","irb::vec#sub()","kernel#sub()","pathname#sub()","string#sub()","string#sub!()","bundler::molinillo::resolver::resolution::unwinddetails#sub_dependencies_to_avoid()","pathname#sub_ext()","net::httpheader#sub_type()","bundler::thor::base::subclass_files()","bundler::thor::base::subclasses()","bundler::thor::subcommand()","bundler::thor::subcommand_classes()","bundler::thor::subcommand_help()","bundler::thor::subcommands()","resolv::dns::name#subdomain_of?()","openssl::x509::certificate#subject()","openssl::x509::request#subject()","openssl::x509::certificate#subject=()","openssl::x509::request#subject=()","openssl::x509::extensionfactory#subject_certificate=()","openssl::x509::extensionfactory#subject_request=()","cgi::htmlextension#submit()","net::imap#subscribe()","time#subsec()","set#subset?()","rexml::functions::substring()","rexml::functions::substring_after()","rexml::functions::substring_before()","bundler::thor::subtask()","bundler::thor::subtask_help()","bundler::thor::subtasks()","set#subtract()","date#succ()","ipaddr#succ()","integer#succ()","prime::eratosthenesgenerator#succ()","prime::generator23#succ()","prime::pseudoprimegenerator#succ()","prime::trialdivisiongenerator#succ()","string#succ()","symbol#succ()","time#succ()","string#succ!()","net::smtp::response#success?()","process::status#success?()","systemexit#success?()","webrick::httpstatus::success?()","webrick::httpstatus#success?()","bundler::molinillo::dependencygraph::vertex#successors()","gem::resolver::molinillo::dependencygraph::vertex#successors()","bundler::sudo()","bundler::rubygemsintegration#suffix_pattern()","gem::suffix_pattern()","gem::suffix_regexp()","gem::suffixes()","gem::specfetcher#suggest_gems_from_name()","gem::licenses::suggestions()","array#sum()","enumerable#sum()","rexml::functions::sum()","string#sum()","optionparser#summarize()","optionparser::list#summarize()","optionparser::switch#summarize()","rdoc::stats#summary()","gem::specification#summary=()","date#sunday?()","time#sunday?()","method#super_method()","unboundmethod#super_method()","class#superclass()","rdoc::classmodule#superclass()","rdoc::normalmodule#superclass()","rdoc::classmodule#superclass=()","rdoc::anymethod#superclass_method()","set#superset?()","net::httpgenericrequest#supply_default_content_type()","irb::color::supported?()","rss::maker::supported?()","rdoc::codeobject#suppress()","bundler::source::rubygems#suppress_configured_credentials()","rdoc::codeobject#suppressed?()","debugger__::suspend()","irb::irb#suspend_context()","irb::irb#suspend_input_method()","irb::irb#suspend_name()","irb::irb#suspend_workspace()","string#swapcase()","symbol#swapcase()","string#swapcase!()","irb::jobmanager#switch()","process::gid::switch()","process::uid::switch()","optionparser::switch#switch_name()","fiddle::compositehandler#sym()","fiddle::handle::sym()","fiddle::handle#sym()","racc::parserfilegenerator#sym_int_hash()","racc::logfilegenerator#symbol_locations()","psych::classloader::restricted#symbolize()","racc::grammar#symbols()","bundler::fileutils::symlink()","bundler::fileutils#symlink()","file::symlink()","fileutils::symlink()","fileutils#symlink()","file::symlink?()","file::stat#symlink?()","filetest#symlink?()","gem::package::tarreader::entry#symlink?()","pathname#symlink?()","matrix#symmetric?()","gdbm#sync()","io#sync()","stringio#sync()","zlib::gzipfile#sync()","zlib::inflate#sync()","io#sync=()","stringio#sync=()","zlib::gzipfile#sync=()","bundler::thor::coreext::orderedhash#sync_keys!()","zlib::inflate#sync_point?()","bundler::compactindexclient#synchronize()","monitor#synchronize()","monitormixin#synchronize()","mutex#synchronize()","gdbm#syncmode=()","socket#sysaccept()","tcpserver#sysaccept()","unixserver#sysaccept()","kernel#syscall()","openssl::ssl::sslsocket#sysclose()","etc::sysconf()","etc::sysconfdir()","syslog::logger::syslog()","syslog::logger::syslog=()","io::sysopen()","pathname#sysopen()","io#sysread()","io::generic_readable#sysread()","object#sysread()","openssl::ssl::sslsocket#sysread()","openssl::ssl::sslsocket#sysread_nonblock()","io#sysseek()","openssl::pkey::dsa#syssign()","bundler::rubyversion::system()","kernel#system()","net::ftp#system()","rexml::doctype#system()","bundler::system_bindir()","etc::systmpdir()","openssl::pkey::dsa#sysverify()","io#syswrite()","openssl::ssl::sslsocket#syswrite()","openssl::ssl::sslsocket#syswrite_nonblock()","matrix#t()","csv::table()","bundler::molinillo::dependencygraph#tag()","bundler::molinillo::dependencygraph::log#tag()","gem::resolver::molinillo::dependencygraph#tag()","gem::resolver::molinillo::dependencygraph::log#tag()","rss::element#tag()","rss::rootelementmixin#tag()","uncaughtthrowerror#tag()","rexml::streamlistener#tag_end()","rss::listenermixin#tag_end()","rss::element#tag_filter()","rss::element#tag_name()","rss::element::tag_name()","rss::element#tag_name_with_prefix()","rexml::streamlistener#tag_start()","rss::listenermixin#tag_start()","bundler::gemhelper#tag_version()","object#taint()","pathname#taint()","object#tainted?()","array#take()","enumerable#take()","enumerator::lazy#take()","rinda::tuplespace#take()","rinda::tuplespaceproxy#take()","array#take_while()","enumerable#take_while()","enumerator::lazy#take_while()","enumerable#tally()","math::tan()","math::tanh()","object#tap()","gem::package::tartestcase#tar_dir_header()","gem::package::tartestcase#tar_file_header()","gem::package::tartestcase#tar_symlink_header()","gem::commands::setupcommand#target_bin_path()","delegator#target_respond_to?()","object#task()","bundler::thor::task_help()","bundler::thor::base::classmethods#tasks()","addrinfo::tcp()","socket::tcp()","socket::tcp_server_loop()","socket::tcp_server_sockets()","net::imap#tcp_socket()","net::smtp#tcp_socket()","gem::testcase#teardown()","argf#tell()","dir#tell()","io#tell()","stringio#tell()","zlib::gzipreader#tell()","zlib::gzipwriter#tell()","bundler::ui::shell#tell_err()","bundler::ui::shell#tell_me()","bundler::thor::actions#template()","rdoc::options#template_dir_for()","gem::commands::setupcommand#template_files()","gem::commands::setupcommand#template_files_in()","bundler::settings#temporary()","racc::sym#term=()","psych::visitors::depthfirst#terminal()","racc::sym#terminal?()","bundler::thor::shell::basic#terminal_width()","racc::symboltable#terminals()","getoptlong#terminate()","optionparser#terminate()","optionparser::terminate()","stringscanner#terminate()","thread#terminate()","webrick::utils::timeouthandler::terminate()","gem::mockgemui#terminate_interaction()","gem::streamui#terminate_interaction()","gem::userinteraction#terminate_interaction()","gem::mockgemui#terminated?()","getoptlong#terminated?()","process::status#termsig()","kernel#test()","date::test_all()","date::test_civil()","date::test_commercial()","date::test_nth_kday()","date::test_ordinal()","date::test_unit_conv()","date::test_weeknum()","prettyprint#text()","prettyprint::singleline#text()","rexml::element#text()","rexml::functions::text()","rexml::streamlistener#text()","rss::listenermixin#text()","rdoc::comment#text=()","rexml::element#text=()","rexml::light::node#text=()","rdoc::toplevel#text?()","rexml::parsers::pullevent#text?()","cgi::htmlextension#text_field()","rss::basemodel#text_type_writer()","cgi::htmlextension#textarea()","rss::rss#textinput()","rexml::element#texts()","object#then()","gem::basicspecification#this()","openssl::ocsp::singleresponse#this_update()","bundler::thor::actions#thor()","bundler::thor::util::thor_classes_in()","bundler::thor::util::thor_root()","bundler::thor::util::thor_root_glob()","drb::thread()","drb#thread()","irb::jobmanager#thread()","net::imap#thread()","net::imap#thread_internal()","debugger__::thread_list()","debugger__::thread_list_all()","thread#thread_variable?()","thread#thread_variable_get()","thread#thread_variable_set()","thread#thread_variables()","kernel#throw()","date#thursday?()","time#thursday?()","gem::time()","openssl::ssl::session#time()","openssl::x509::revoked#time()","openssl::ssl::session#time=()","openssl::x509::revoked#time=()","openssl::x509::store#time=()","openssl::x509::storecontext#time=()","object#timeout()","openssl::ssl::session#timeout()","timeout#timeout()","timeout::timeout()","webrick::utils::timeout()","webrick::utils#timeout()","openssl::ssl::session#timeout=()","resolv::dns#timeouts=()","integer#times()","process::times()","socket::ancillarydata#timestamp()","rdoc::store#title()","rdoc::store#title=()","rdoc::parser::ruby#tk_nl?()","net::smtp#tls?()","net::smtp#tlsconnect()","bundler::tmp()","bundler::plugin::api#tmp()","openssl::ssl::sslsocket#tmp_dh_callback()","openssl::ssl::sslsocket#tmp_ecdh_callback()","bundler::tmp_home_path()","openssl::ssl::sslsocket#tmp_key()","dir::tmpdir()","bundler::uri::mailto#to=()","uri::mailto#to=()","argf#to_a()","array#to_a()","benchmark::tms#to_a()","bundler::specset#to_a()","bundler::thor::coreext::orderedhash#to_a()","csv::table#to_a()","dbm#to_a()","env::to_a()","enumerable#to_a()","enumerator::lazy#to_a()","gdbm#to_a()","gem::list#to_a()","gem::nametuple#to_a()","gem::platform#to_a()","gem::requestset::lockfile::tokenizer#to_a()","gem::sourcelist#to_a()","hash#to_a()","matchdata#to_a()","matrix#to_a()","matrix::eigenvaluedecomposition#to_a()","matrix::lupdecomposition#to_a()","nilclass#to_a()","openssl::x509::extension#to_a()","openssl::x509::name#to_a()","optionparser#to_a()","rexml::attributes#to_a()","rexml::elements#to_a()","rexml::parent#to_a()","racc::iset#to_a()","range#to_a()","rinda::ringfinger#to_a()","rinda::ringfinger::to_a()","rubyvm::instructionsequence#to_a()","sdbm#to_a()","set#to_a()","struct#to_a()","time#to_a()","vector#to_a()","yaml::dbm#to_a()","bundler::settings#to_array()","array#to_ary()","bundler::lazyspecification#to_ary()","bundler::remotespecification#to_ary()","gem::sourcelist#to_ary()","matrix::eigenvaluedecomposition#to_ary()","matrix::lupdecomposition#to_ary()","webrick::httputils::formdata#to_ary()","rss::rootelementmixin#to_atom()","gem::nametuple::to_basic()","rubyvm::instructionsequence#to_binary()","integer#to_bn()","openssl::bn#to_bn()","openssl::pkey::ec::point#to_bn()","bundler::settings#to_bool()","complex#to_c()","nilclass#to_c()","numeric#to_c()","string#to_c()","rss::utils#to_class_name()","csv::row#to_csv()","csv::table#to_csv()","bigdecimal#to_d()","float#to_d()","integer#to_d()","nilclass#to_d()","rational#to_d()","string#to_d()","date#to_date()","datetime#to_date()","time#to_date()","date#to_datetime()","datetime#to_datetime()","time#to_datetime()","bundler::dsl#to_definition()","openssl::asn1::asn1data#to_der()","openssl::asn1::constructive#to_der()","openssl::asn1::primitive#to_der()","openssl::netscape::spki#to_der()","openssl::ocsp::basicresponse#to_der()","openssl::ocsp::certificateid#to_der()","openssl::ocsp::request#to_der()","openssl::ocsp::response#to_der()","openssl::ocsp::singleresponse#to_der()","openssl::pkcs12#to_der()","openssl::pkcs7#to_der()","openssl::pkey::dh#to_der()","openssl::pkey::dsa#to_der()","openssl::pkey::ec#to_der()","openssl::pkey::ec::group#to_der()","openssl::pkey::rsa#to_der()","openssl::ssl::session#to_der()","openssl::x509::attribute#to_der()","openssl::x509::crl#to_der()","openssl::x509::certificate#to_der()","openssl::x509::extension#to_der()","openssl::x509::name#to_der()","openssl::x509::request#to_der()","openssl::x509::revoked#to_der()","bigdecimal#to_digits()","bundler::molinillo::dependencygraph#to_dot()","gem::resolver::molinillo::dependencygraph#to_dot()","rss::element::to_element_methods()","enumerator::lazy#to_enum()","object#to_enum()","bigdecimal#to_f()","complex#to_f()","float#to_f()","integer#to_f()","nilclass#to_f()","rational#to_f()","string#to_f()","time#to_f()","rss::maker::atom::entry::items#to_feed()","rss::maker::atom::entry::items::item#to_feed()","rss::maker::atom::feed::channel#to_feed()","rss::maker::atom::feed::channel::cloud#to_feed()","rss::maker::atom::feed::channel::skipdays#to_feed()","rss::maker::atom::feed::channel::skiphours#to_feed()","rss::maker::atom::feed::image#to_feed()","rss::maker::atom::feed::items#to_feed()","rss::maker::atom::feed::items::item#to_feed()","rss::maker::atom::feed::items::item::content#to_feed()","rss::maker::atom::feed::items::item::enclosure#to_feed()","rss::maker::atom::feed::items::item::guid#to_feed()","rss::maker::atom::feed::items::item::source#to_feed()","rss::maker::atom::feed::items::item::source::icon#to_feed()","rss::maker::atomcategory#to_feed()","rss::maker::atomgenerator#to_feed()","rss::maker::atomlink#to_feed()","rss::maker::atomlogo#to_feed()","rss::maker::ituneschannelmodel::itunescategoriesbase::itunescategorybase#to_feed()","rss::maker::ituneschannelmodel::itunesimagebase#to_feed()","rss::maker::ituneschannelmodel::itunesownerbase#to_feed()","rss::maker::itunesitemmodel::itunesdurationbase#to_feed()","rss::maker::imagefaviconmodel::imagefaviconbase#to_feed()","rss::maker::imageitemmodel::imageitembase#to_feed()","rss::maker::rss09::channel#to_feed()","rss::maker::rss09::channel::authors#to_feed()","rss::maker::rss09::channel::authors::author#to_feed()","rss::maker::rss09::channel::categories#to_feed()","rss::maker::rss09::channel::cloud#to_feed()","rss::maker::rss09::channel::contributors#to_feed()","rss::maker::rss09::channel::copyright#to_feed()","rss::maker::rss09::channel::description#to_feed()","rss::maker::rss09::channel::generator#to_feed()","rss::maker::rss09::channel::links#to_feed()","rss::maker::rss09::channel::links::link#to_feed()","rss::maker::rss09::channel::skipdays#to_feed()","rss::maker::rss09::channel::skipdays::day#to_feed()","rss::maker::rss09::channel::skiphours#to_feed()","rss::maker::rss09::channel::skiphours::hour#to_feed()","rss::maker::rss09::channel::title#to_feed()","rss::maker::rss09::image#to_feed()","rss::maker::rss09::items#to_feed()","rss::maker::rss09::items::item#to_feed()","rss::maker::rss09::items::item::authors#to_feed()","rss::maker::rss09::items::item::categories#to_feed()","rss::maker::rss09::items::item::content#to_feed()","rss::maker::rss09::items::item::contributors#to_feed()","rss::maker::rss09::items::item::description#to_feed()","rss::maker::rss09::items::item::enclosure#to_feed()","rss::maker::rss09::items::item::guid#to_feed()","rss::maker::rss09::items::item::links#to_feed()","rss::maker::rss09::items::item::links::link#to_feed()","rss::maker::rss09::items::item::rights#to_feed()","rss::maker::rss09::items::item::source#to_feed()","rss::maker::rss09::items::item::source::authors#to_feed()","rss::maker::rss09::items::item::source::categories#to_feed()","rss::maker::rss09::items::item::source::contributors#to_feed()","rss::maker::rss09::items::item::source::generator#to_feed()","rss::maker::rss09::items::item::source::icon#to_feed()","rss::maker::rss09::items::item::source::links#to_feed()","rss::maker::rss09::items::item::source::logo#to_feed()","rss::maker::rss09::items::item::source::rights#to_feed()","rss::maker::rss09::items::item::source::subtitle#to_feed()","rss::maker::rss09::items::item::source::title#to_feed()","rss::maker::rss09::items::item::title#to_feed()","rss::maker::rss09::textinput#to_feed()","rss::maker::rss10::channel#to_feed()","rss::maker::rss10::channel::authors#to_feed()","rss::maker::rss10::channel::authors::author#to_feed()","rss::maker::rss10::channel::categories#to_feed()","rss::maker::rss10::channel::cloud#to_feed()","rss::maker::rss10::channel::contributors#to_feed()","rss::maker::rss10::channel::copyright#to_feed()","rss::maker::rss10::channel::description#to_feed()","rss::maker::rss10::channel::generator#to_feed()","rss::maker::rss10::channel::links#to_feed()","rss::maker::rss10::channel::links::link#to_feed()","rss::maker::rss10::channel::skipdays#to_feed()","rss::maker::rss10::channel::skiphours#to_feed()","rss::maker::rss10::channel::title#to_feed()","rss::maker::rss10::image#to_feed()","rss::maker::rss10::items#to_feed()","rss::maker::rss10::items::item#to_feed()","rss::maker::rss10::items::item::authors#to_feed()","rss::maker::rss10::items::item::categories#to_feed()","rss::maker::rss10::items::item::content#to_feed()","rss::maker::rss10::items::item::contributors#to_feed()","rss::maker::rss10::items::item::description#to_feed()","rss::maker::rss10::items::item::enclosure#to_feed()","rss::maker::rss10::items::item::guid#to_feed()","rss::maker::rss10::items::item::links#to_feed()","rss::maker::rss10::items::item::rights#to_feed()","rss::maker::rss10::items::item::source#to_feed()","rss::maker::rss10::items::item::source::authors#to_feed()","rss::maker::rss10::items::item::source::categories#to_feed()","rss::maker::rss10::items::item::source::contributors#to_feed()","rss::maker::rss10::items::item::source::generator#to_feed()","rss::maker::rss10::items::item::source::icon#to_feed()","rss::maker::rss10::items::item::source::links#to_feed()","rss::maker::rss10::items::item::source::logo#to_feed()","rss::maker::rss10::items::item::source::rights#to_feed()","rss::maker::rss10::items::item::source::subtitle#to_feed()","rss::maker::rss10::items::item::source::title#to_feed()","rss::maker::rss10::items::item::title#to_feed()","rss::maker::rss10::textinput#to_feed()","rss::maker::rss20::channel::categories#to_feed()","rss::maker::rss20::channel::categories::category#to_feed()","rss::maker::rss20::channel::cloud#to_feed()","rss::maker::rss20::channel::generator#to_feed()","rss::maker::rss20::items::item::authors#to_feed()","rss::maker::rss20::items::item::authors::author#to_feed()","rss::maker::rss20::items::item::categories#to_feed()","rss::maker::rss20::items::item::categories::category#to_feed()","rss::maker::rss20::items::item::enclosure#to_feed()","rss::maker::rss20::items::item::guid#to_feed()","rss::maker::rss20::items::item::source#to_feed()","rss::maker::rss20::items::item::source::links#to_feed()","rss::maker::rss20::items::item::source::links::link#to_feed()","rss::maker::rssbase#to_feed()","rss::maker::trackbackmodel::trackbackaboutsbase::trackbackaboutbase#to_feed()","rss::maker::xmlstylesheets::xmlstylesheet#to_feed()","rss::rootelementmixin#to_feed()","rss::maker::ituneschannelmodel::itunescategoriesbase::itunescategorybase#to_feed_for_categories()","gem::basicspecification#to_fullpath()","bundler::rubyversion#to_gem_version_with_patchlevel()","gem::specification#to_gemfile()","array#to_h()","bundler::buildmetadata::to_h()","csv::row#to_h()","env::to_h()","enumerable#to_h()","hash#to_h()","json::ext::generator::state#to_h()","nilclass#to_h()","openssl::x509::extension#to_h()","openstruct#to_h()","struct#to_h()","win32ole_record#to_h()","bundler::specset#to_hash()","bundler::thor::coreext::orderedhash#to_hash()","csv::row#to_hash()","dbm#to_hash()","env::to_hash()","gdbm#to_hash()","hash#to_hash()","json::ext::generator::state#to_hash()","json::genericobject#to_hash()","net::httpheader#to_hash()","sdbm#to_hash()","yaml::dbm#to_hash()","rdoc::text#to_html()","rdoc::tokenstream::to_html()","argf#to_i()","bigdecimal#to_i()","csv#to_i()","complex#to_i()","fiddle::closure#to_i()","fiddle::function#to_i()","fiddle::handle#to_i()","fiddle::pointer#to_i()","float#to_i()","io#to_i()","ipaddr#to_i()","integer#to_i()","nilclass#to_i()","openssl::bn#to_i()","process::status#to_i()","rational#to_i()","string#to_i()","time#to_i()","webrick::httpstatus::status#to_i()","drb::to_id()","drb#to_id()","drb::drbidconv#to_id()","drb::drbidconv#to_id()","drb::drbserver#to_id()","bigdecimal#to_int()","fiddle::pointer#to_int()","float#to_int()","integer#to_int()","numeric#to_int()","openssl::bn#to_int()","argf#to_io()","csv#to_io()","io#to_io()","openssl::ssl::sslserver#to_io()","zlib::gzipfile#to_io()","bigdecimal#to_json()","complex#to_json()","date#to_json()","datetime#to_json()","exception#to_json()","json::ext::generator::generatormethods::array#to_json()","json::ext::generator::generatormethods::bignum#to_json()","json::ext::generator::generatormethods::falseclass#to_json()","json::ext::generator::generatormethods::fixnum#to_json()","json::ext::generator::generatormethods::float#to_json()","json::ext::generator::generatormethods::hash#to_json()","json::ext::generator::generatormethods::integer#to_json()","json::ext::generator::generatormethods::nilclass#to_json()","json::ext::generator::generatormethods::object#to_json()","json::ext::generator::generatormethods::string#to_json()","json::ext::generator::generatormethods::trueclass#to_json()","json::genericobject#to_json()","openstruct#to_json()","psych::to_json()","range#to_json()","rational#to_json()","regexp#to_json()","set#to_json()","struct#to_json()","symbol#to_json()","time#to_json()","json::ext::generator::generatormethods::string#to_json_raw()","json::ext::generator::generatormethods::string#to_json_raw_object()","bundler::definition#to_lock()","bundler::dependency#to_lock()","bundler::lazyspecification#to_lock()","bundler::plugin::api::source#to_lock()","bundler::source::git#to_lock()","bundler::source::path#to_lock()","bundler::source::rubygems#to_lock()","gem::dependency#to_lock()","bundler::uri::mailto#to_mailtext()","uri::mailto#to_mailtext()","matrix#to_matrix()","vector#to_matrix()","resolv::ipv4#to_name()","resolv::ipv6#to_name()","drb::to_obj()","drb#to_obj()","drb::drbidconv#to_obj()","drb::drbidconv#to_obj()","drb::drbserver#to_obj()","gem::package::tartestcase#to_oct()","openssl::pkey::ec::point#to_octet_string()","dir#to_path()","file#to_path()","pathname#to_path()","openssl::netscape::spki#to_pem()","openssl::pkcs7#to_pem()","openssl::pkey::dh#to_pem()","openssl::pkey::dsa#to_pem()","openssl::pkey::ec#to_pem()","openssl::pkey::ec::group#to_pem()","openssl::pkey::rsa#to_pem()","openssl::ssl::session#to_pem()","openssl::x509::crl#to_pem()","openssl::x509::certificate#to_pem()","openssl::x509::request#to_pem()","enumerator::yielder#to_proc()","hash#to_proc()","method#to_proc()","proc#to_proc()","symbol#to_proc()","fiddle::pointer::to_ptr()","bigdecimal#to_r()","complex#to_r()","float#to_r()","integer#to_r()","nilclass#to_r()","rational#to_r()","string#to_r()","time#to_r()","ipaddr#to_range()","gem::availableset#to_request_set()","bundler::uri::mailto#to_rfc822text()","uri::mailto#to_rfc822text()","rss::rootelementmixin#to_rss()","gem::specification#to_ruby()","psych::nodes::node#to_ruby()","gem::specification#to_ruby_for_cache()","argf#to_s()","addrinfo#to_s()","array#to_s()","benchmark::tms#to_s()","bigdecimal#to_s()","bundler::depproxy#to_s()","bundler::dsl::dslerror#to_s()","bundler::lazyspecification#to_s()","bundler::molinillo::resolver::resolution::possibilityset#to_s()","bundler::parallelinstaller::specinstallation#to_s()","bundler::plugin::api::source#to_s()","bundler::remotespecification#to_s()","bundler::resolver::specgroup#to_s()","bundler::rubyversion#to_s()","bundler::source::git#to_s()","bundler::source::metadata#to_s()","bundler::source::path#to_s()","bundler::source::rubygems#to_s()","bundler::source::rubygems::remote#to_s()","bundler::uri::ftp#to_s()","bundler::uri::generic#to_s()","bundler::uri::mailto#to_s()","bundler::versionranges::reqr#to_s()","cgi::cookie#to_s()","csv::row#to_s()","csv::table#to_s()","complex#to_s()","date#to_s()","datetime#to_s()","digest::instance#to_s()","env::to_s()","encoding#to_s()","exception#to_s()","falseclass#to_s()","fiber#to_s()","fiddle::pointer#to_s()","float#to_s()","gem::platform#to_s()","gem::requestset::lockfile#to_s()","gem::resolver::activationrequest#to_s()","gem::version#to_s()","hash#to_s()","ipaddr#to_s()","integer#to_s()","matchdata#to_s()","matrix#to_s()","method#to_s()","module#to_s()","nilclass#to_s()","object#to_s()","openssl::bn#to_s()","openssl::config#to_s()","openssl::hmac#to_s()","openssl::netscape::spki#to_s()","openssl::pkcs7#to_s()","openssl::pkey::dh#to_s()","openssl::pkey::dsa#to_s()","openssl::pkey::rsa#to_s()","openssl::x509::crl#to_s()","openssl::x509::certificate#to_s()","openssl::x509::extension#to_s()","openssl::x509::name#to_s()","openssl::x509::request#to_s()","openstruct#to_s()","optionparser#to_s()","optionparser::parseerror#to_s()","pathname#to_s()","proc#to_s()","process::status#to_s()","rexml::attribute#to_s()","rexml::cdata#to_s()","rexml::dtd::entitydecl#to_s()","rexml::dtd::notationdecl#to_s()","rexml::declaration#to_s()","rexml::entity#to_s()","rexml::externalentity#to_s()","rexml::light::node#to_s()","rexml::node#to_s()","rexml::notationdecl#to_s()","rexml::output#to_s()","rexml::parseexception#to_s()","rexml::text#to_s()","rexml::validation::event#to_s()","rexml::validation::ref#to_s()","rexml::validation::state#to_s()","rss::element#to_s()","rss::xml::element#to_s()","rss::xmlstylesheet#to_s()","racc::grammar#to_s()","racc::iset#to_s()","racc::locationpointer#to_s()","racc::rrconflict#to_s()","racc::rule#to_s()","racc::srconflict#to_s()","racc::sourcetext#to_s()","racc::state#to_s()","racc::states#to_s()","racc::sym#to_s()","range#to_s()","rational#to_s()","regexp#to_s()","resolv::dns::name#to_s()","set#to_s()","socket::option#to_s()","string#to_s()","struct#to_s()","symbol#to_s()","thread#to_s()","thread::backtrace::location#to_s()","time#to_s()","trueclass#to_s()","uri::ftp#to_s()","uri::generic#to_s()","uri::mailto#to_s()","unboundmethod#to_s()","uncaughtthrowerror#to_s()","vector#to_s()","webrick::cookie#to_s()","webrick::httputils::formdata#to_s()","webrick::httpversion#to_s()","win32ole_method#to_s()","win32ole_param#to_s()","win32ole_type#to_s()","win32ole_typelib#to_s()","win32ole_variable#to_s()","enumerable#to_set()","set#to_set()","addrinfo#to_sockaddr()","bundler::socketaddress#to_socket_address()","gem::basicspecification#to_spec()","gem::dependency#to_spec()","gem::specification#to_spec()","bundler::resolver::specgroup#to_specs()","gem::dependency#to_specs()","fiddle::pointer#to_str()","string#to_str()","ipaddr#to_string()","rexml::attribute#to_string()","string#to_sym()","symbol#to_sym()","openssl::netscape::spki#to_text()","openssl::pkey::dh#to_text()","openssl::pkey::dsa#to_text()","openssl::pkey::ec#to_text()","openssl::pkey::ec::group#to_text()","openssl::pkey::rsa#to_text()","openssl::ssl::session#to_text()","openssl::x509::crl#to_text()","openssl::x509::certificate#to_text()","openssl::x509::request#to_text()","date#to_time()","datetime#to_time()","time#to_time()","exception::to_tty?()","rss::parser#to_uri()","openssl::x509::name#to_utf8()","fiddle::pointer#to_value()","argf#to_write_io()","rss::rootelementmixin#to_xml()","bundler::stubspecification#to_yaml()","object#to_yaml()","psych::nodes::node#to_yaml()","gem::dependency#to_yaml_properties()","date::today()","kconv#toeuc()","kconv::toeuc()","string#toeuc()","kconv::tojis()","kconv#tojis()","string#tojis()","ripper#token()","rdoc::parser::rubytools#token_listener()","rdoc::tokenstream#token_stream()","racc::statetransitiontablegenerator#token_table()","racc::parser#token_to_str()","racc::statetransitiontable#token_value_table()","gem::requestset::lockfile::tokenizer#tokenize()","psych::scalarscanner#tokenize()","rdoc::tomdoc#tokenize()","ripper::tokenize()","rdoc::tokenstream#tokens_to_s()","kconv#tolocale()","kconv::tolocale()","string#tolocale()","rdoc::comment#tomdoc?()","irb::frame#top()","irb::frame::top()","net::popmail#top()","optionparser#top()","optionparser::top()","rdoc::context#top_level()","rdoc::require#top_level()","racc::parserfilegenerator#toplevel?()","irb::locale#toplevel_load()","kconv::tosjis()","kconv#tosjis()","string#tosjis()","zlib::zstream#total_in()","zlib::zstream#total_out()","gc::profiler::total_time()","bundler::fileutils::touch()","bundler::fileutils#touch()","fileutils::touch()","fileutils#touch()","kconv#toutf16()","kconv::toutf16()","string#toutf16()","kconv#toutf32()","kconv::toutf32()","string#toutf32()","kconv#toutf8()","kconv::toutf8()","string#toutf8()","matrix#tr()","string#tr()","string#tr!()","string#tr_s()","string#tr_s!()","bundler::ui::shell#trace()","bundler::ui::silent#trace()","matrix#trace()","net::http#trace()","rexml::xpathparser#trace()","tracepoint::trace()","irb::frame#trace_func()","objectspace::trace_object_allocations()","objectspace::trace_object_allocations_clear()","objectspace::trace_object_allocations_debug_start()","objectspace::trace_object_allocations_start()","objectspace::trace_object_allocations_stop()","rubyvm::instructionsequence#trace_points()","kernel#trace_var()","pstore#transaction()","fiber#transfer()","psych::nodes::node#transform()","hash#transform_keys()","hash#transform_keys!()","hash#transform_values()","hash#transform_values!()","rexml::functions::translate()","net::http#transport_request()","array#transpose()","matrix#transpose()","racc::states#transpose()","bundler::sharedhelpers#trap()","kernel#trap()","signal::trap()","gem::specification#traverse()","openssl::asn1::traverse()","racc::states#traverse()","gem::util::traverse_parents()","psych::visitors::yamltree#tree()","matrix::eigenvaluedecomposition#tridiagonalize()","rexml::functions::true()","bundler::currentruby#truffleruby?()","bigdecimal#truncate()","bundler::thor::shell::basic#truncate()","file#truncate()","file::truncate()","float#truncate()","integer#truncate()","numeric#truncate()","pathname#truncate()","rational#truncate()","stringio#truncate()","gem::text#truncate_text()","object#trust()","openssl::x509::store#trust=()","openssl::x509::storecontext#trust=()","gem::security::trustdir#trust_cert()","gem::security::trust_dir()","gem::security::trusted_certificates()","gem::try_activate()","makemakefile#try_const()","array::try_convert()","hash::try_convert()","io::try_convert()","regexp::try_convert()","string::try_convert()","bundler::connectionpool::timedstack#try_create()","monitor#try_enter()","mutex#try_lock()","monitor#try_mon_enter()","monitormixin#try_mon_enter()","makemakefile#try_type()","bundler::molinillo::dependencygraph::tsort()","gem::resolver::molinillo::dependencygraph::tsort()","tsort#tsort()","tsort::tsort()","tsort#tsort_each()","tsort::tsort_each()","bundler::molinillo::dependencygraph#tsort_each_child()","bundler::specset#tsort_each_child()","gem::dependencylist#tsort_each_child()","gem::resolver::molinillo::dependencygraph#tsort_each_child()","tsort#tsort_each_child()","bundler::molinillo::dependencygraph#tsort_each_node()","bundler::specset#tsort_each_node()","gem::dependencylist#tsort_each_node()","gem::resolver::molinillo::dependencygraph#tsort_each_node()","tsort#tsort_each_node()","gem::mockgemui::tty#tty?()","gem::streamui#tty?()","io#tty?()","stringio#tty?()","date#tuesday?()","time#tuesday?()","time#tv_nsec()","time#tv_sec()","time#tv_usec()","bundler::depproxy#type()","gem::dependency#type()","gem::resolver::dependencyrequest#type()","objectspace::internalobjectwrapper#type()","openssl::pkcs7#type()","rdoc::classmodule#type()","rdoc::methodattr#type()","rubyvm::abstractsyntaxtree::node#type()","socket::ancillarydata#type()","openssl::pkcs7#type=()","net::httpheader#type_params()","fiddle::importer#typealias()","bundler::uri::ftp#typecode=()","uri::ftp#typecode=()","win32ole_type#typekind()","win32ole_type::typelibs()","win32ole_typelib::typelibs()","win32ole_record#typename()","gem::source#typo_squatting?()","erb::util#u()","erb::util::u()","matrix::lupdecomposition#u()","openssl::bn#ucmp()","addrinfo::udp()","socket::udp_server_loop()","socket::udp_server_loop_on()","socket::udp_server_recv()","socket::udp_server_sockets()","bundler::ui()","gem::ui()","gem::defaultuserinteraction::ui()","gem::defaultuserinteraction#ui()","bundler::ui=()","bundler::rubygemsintegration#ui=()","gem::defaultuserinteraction#ui=()","gem::defaultuserinteraction::ui=()","file::stat#uid()","process::uid()","process::uid=()","net::imap#uid_copy()","net::imap#uid_fetch()","net::imap#uid_move()","net::imap#uid_search()","net::imap#uid_sort()","net::imap#uid_store()","net::imap#uid_thread()","net::popmail#uidl()","file::umask()","webrick::httpserver#umount()","win32ole_event#unadvise()","etc::uname()","method#unbind()","bundler::unbundled_env()","bundler::unbundled_exec()","bundler::unbundled_system()","bundler::thor::actions#uncomment_lines()","csv#unconverted_fields?()","csv::parser#unconverted_fields?()","module#undef_method()","objectspace::undefine_finalizer()","bundler::rubygemsintegration#undo_replacements()","rdoc::stats#undoc_params()","string#undump()","bundler::persistent::net::http::persistent#unescape()","bundler::uri::escape#unescape()","bundler::uri::rfc2396_parser#unescape()","bundler::uri::rfc2396_parser#unescape()","cgi::util#unescape()","gem::uriformatter#unescape()","uri::escape#unescape()","uri::rfc2396_parser#unescape()","uri::rfc2396_parser#unescape()","webrick::httputils#unescape()","cgi::util#unescapeelement()","cgi::util#unescapehtml()","cgi::util#unescape_element()","webrick::httputils#unescape_form()","cgi::util#unescape_html()","openssl::config::unescape_value()","rdoc::parser::rubytools#unget_tk()","io#ungetbyte()","stringio#ungetbyte()","zlib::gzipreader#ungetbyte()","io#ungetc()","openssl::buffering#ungetc()","stringio#ungetc()","zlib::gzipreader#ungetc()","string#unicode_normalize()","string#unicode_normalize!()","string#unicode_normalized?()","racc::parserfilegenerator#unindent_auto()","gem::commands::uninstallcommand#uninstall()","gem::uninstaller#uninstall()","gem::commands::uninstallcommand#uninstall_all()","gem::commands::cleanupcommand#uninstall_dep()","gem::commands::uninstallcommand#uninstall_gem()","gem::testcase#uninstall_gem()","gem::uninstaller#uninstall_gem()","gem::commands::setupcommand#uninstall_old_gemcutter()","gem::commands::uninstallcommand#uninstall_specific()","array#union()","fiddle::importer#union()","regexp::union()","set#union()","array#uniq()","enumerable#uniq()","enumerator::lazy#uniq()","array#uniq!()","rdoc::store#unique_classes()","rdoc::store#unique_classes_and_modules()","net::popmail#unique_id()","rdoc::store#unique_modules()","racc::parserfilegenerator#unique_separator()","matrix::unit()","matrix#unitary?()","addrinfo::unix()","socket::unix()","addrinfo#unix?()","bundler::thor::shell::basic#unix?()","addrinfo#unix_path()","socket::ancillarydata::unix_rights()","socket::ancillarydata#unix_rights()","socket::unix_server_loop()","socket::unix_server_socket()","socket::unix_socket_abstract_name?()","logger#unknown()","syslog::logger#unknown()","bundler::lockfileparser::unknown_sections_in_lockfile()","dir::unlink()","file::unlink()","pathname#unlink()","tempfile#unlink()","mutex#unlock()","net::http#unlock()","bundler::plugin::api::source#unlock!()","bundler::source::git#unlock!()","bundler::definition#unlocking?()","bundler::gemversionpromoter#unlocking_gem?()","bundler::fetcher::dependency#unmarshalled_dep_gems()","bundler::index#unmet_dependency_names()","bundler::plugin::api::source#unmet_deps()","bundler::source#unmet_deps()","bundler::source::rubygems#unmet_deps()","webrick::httpserver#unmount()","rexml::xpathparser#unnode()","rexml::parsers::baseparser#unnormalize()","rexml::text::unnormalize()","rexml::entity#unnormalized()","gem::installer#unpack()","socket::option#unpack()","string#unpack()","string#unpack1()","socket::unpack_sockaddr_in()","socket::unpack_sockaddr_un()","bundler::ui::shell#unprinted_warnings()","bundler::ui::silent#unprinted_warnings()","drb::extservmanager#unregist()","gem::commandmanager#unregister_command()","gem::specification::unresolved_deps()","gem::testcase#unresolved_names()","stringscanner#unscan()","bundler::cli::config#unset()","gem::configfile#unset_api_key!()","array#unshift()","gem::requestset::lockfile::tokenizer#unshift()","rexml::parent#unshift()","rexml::parsers::baseparser#unshift()","rexml::parsers::pullparser#unshift()","bundler::index#unsorted_search()","net::imap#unsubscribe()","object#untaint()","pathname#untaint()","kernel#untrace_var()","object#untrust()","object#untrusted?()","zlib::gzipreader#unused()","bundler::molinillo::delegates::resolutionstate#unused_unwind_options()","bundler::molinillo::resolver::resolution#unwind_for_conflict()","gem::resolver::molinillo::resolver::resolution#unwind_for_conflict()","bundler::molinillo::resolver::resolution#unwind_options_for_requirements()","bundler::molinillo::resolver::resolution::unwinddetails#unwinding_to_primary_requirement?()","bundler::molinillo::dependencygraph::action#up()","bundler::molinillo::dependencygraph::addedgenocircular#up()","bundler::molinillo::dependencygraph::deleteedge#up()","bundler::molinillo::dependencygraph::detachvertexnamed#up()","bundler::molinillo::dependencygraph::tag#up()","gem::resolver::molinillo::dependencygraph::action#up()","gem::resolver::molinillo::dependencygraph::addedgenocircular#up()","gem::resolver::molinillo::dependencygraph::deleteedge#up()","gem::resolver::molinillo::dependencygraph::detachvertexnamed#up()","gem::resolver::molinillo::dependencygraph::tag#up()","string#upcase()","symbol#upcase()","string#upcase!()","bundler::cli#update()","bundler::compactindexclient#update()","bundler::compactindexclient::updater#update()","cgi::session#update()","cgi::session::filestore#update()","cgi::session::memorystore#update()","cgi::session::nullstore#update()","cgi::session::pstore#update()","dbm#update()","digest::base#update()","digest::instance#update()","env::update()","gdbm#update()","gem::streamui::silentdownloadreporter#update()","gem::streamui::threadeddownloadreporter#update()","hash#update()","openssl::cipher#update()","openssl::digest#update()","openssl::hmac#update()","optionparser::list#update()","racc::iset#update()","sdbm#update()","yaml::dbm#update()","racc::iset#update_a()","rdoc::classmodule#update_aliases()","bundler::compactindexclient#update_and_parse_checksums!()","gem::source#update_cache?()","gem::package::tarheader#update_checksum()","rss::itunesitemmodel::itunesduration#update_content()","rss::maker::itunesitemmodel::itunesdurationbase#update_content()","rdoc::classmodule#update_extends()","gem::commands::updatecommand#update_gem()","gem::commands::updatecommand#update_gems()","rdoc::classmodule#update_includes()","gem::indexer#update_index()","bundler::compactindexclient#update_info()","bundler::settings::mirrorconfig#update_mirror()","rdoc::rdoc#update_output_dir()","rdoc::store#update_parser_of_file()","bundler::cli::outdated#update_present_via_semver_portions()","gem::commands::updatecommand#update_rubygems()","gem::indexer#update_specs_index()","gem::streamui::silentprogressreporter#updated()","gem::streamui::simpleprogressreporter#updated()","gem::streamui::verboseprogressreporter#updated()","rss::maker::channelbase#updated()","rss::maker::itemsbase::itembase#updated()","rss::maker::itemsbase::itembase::sourcebase#updated()","rss::maker::channelbase#updated=()","rss::maker::itemsbase::itembase#updated=()","rss::maker::itemsbase::itembase::sourcebase#updated=()","rdoc::context#upgrade_to_class()","prime::pseudoprimegenerator#upper_bound()","prime::pseudoprimegenerator#upper_bound=()","matrix#upper_triangular?()","date#upto()","integer#upto()","string#upto()","bundler::fileutils#uptodate?()","bundler::fileutils::uptodate?()","fileutils::uptodate?()","fileutils#uptodate?()","random::urandom()","bundler::fetcher#uri()","drb::uri()","drb#uri()","bundler::settings::mirror#uri=()","rss::basemodel#uri_convert_attr_reader()","gem::server#uri_encode()","bundler::source::git::gitproxy#uri_escaped_with_configured_credentials()","bundler::plugin::api::source#uri_hash()","bundler::source::git#uri_hash()","drb::drbprotocol#uri_option()","drb::drbprotocol::uri_option()","gem::uriparsing#uri_parser()","rss::baselistener::uri_registered?()","bundler::compactindexclient#url()","erb::util#url_encode()","erb::util::url_encode()","random::formatter#urlsafe_base64()","base64#urlsafe_decode64()","base64#urlsafe_encode64()","gem::command#usage()","bundler::index#use()","bundler::fetcher#use_api()","bundler::rubygemsintegration#use_gemdeps()","gem::use_gemdeps()","csv::parser#use_headers?()","irb::context#use_loader()","irb::context#use_loader=()","irb::context#use_loader?()","rdoc::parser::use_markup()","bundler::thor::lineeditor::readline#use_path_completion?()","gem::use_paths()","net::http#use_ssl=()","net::http#use_ssl?()","net::pop3#use_ssl?()","net::pop3::use_ssl?()","bundler::use_system_gems?()","irb::context#use_tracer=()","gem::defaultuserinteraction::use_ui()","gem::defaultuserinteraction#use_ui()","time#usec()","module::used_modules()","racc::rule#useless=()","racc::sym#useless=()","racc::rule#useless?()","racc::sym#useless?()","racc::grammar#useless_nonterminal_exist?()","racc::grammar#useless_rule_exist?()","bundler::uri::generic#user()","uri::generic#user()","bundler::uri::generic#user=()","uri::generic#user=()","bundler::fetcher#user_agent()","gem::request#user_agent()","bundler::user_bundle_path()","bundler::user_cache()","gem::user_dir()","bundler::user_home()","bundler::rubygemsintegration#user_home()","bundler::thor::util::user_home()","gem::user_home()","bundler::uri::generic#userinfo()","uri::generic#userinfo()","bundler::uri::generic#userinfo=()","uri::generic#userinfo=()","module#using()","openssl::ssl::sslsocket#using_anon_cipher?()","time::utc()","time#utc()","time#utc?()","time#utc_offset()","gem::testcase#util_build_gem()","gem::testcase#util_clear_ruby_version()","gem::testcase#util_clear_gems()","gem::package::tartestcase#util_dir_entry()","gem::package::tartestcase#util_entry()","gem::testcase#util_gem()","gem::testcase#util_gzip()","gem::installertestcase#util_inst_bindir()","gem::installertestcase#util_installer()","gem::installertestcase#util_make_exec()","gem::testcase#util_make_gems()","gem::testcase#util_remove_gem()","gem::testcase#util_restore_ruby_version()","gem::testcase#util_set_ruby_version()","gem::testcase#util_set_arch()","gem::installertestcase#util_setup_gem()","gem::installertestcase#util_setup_installer()","gem::testcase#util_setup_spec_fetcher()","gem::testcase#util_spec()","gem::package::tartestcase#util_symlink_entry()","gem::testcase#util_zip()","file::utime()","pathname#utime()","random::formatter#uuid()","matrix::eigenvaluedecomposition#v()","matrix::eigenvaluedecomposition#v_inv()","bundler::settings::mirror#valid?()","rss::element#valid?()","date::valid_civil?()","date::valid_commercial?()","date::valid_date?()","gem::commands::certcommand#valid_email?()","string#valid_encoding?()","bundler::specset#valid_for?()","date::valid_jd?()","bundler::dsl#valid_keys()","net::imap::numvalidator::valid_mod_sequence_value?()","net::imap::numvalidator::valid_number?()","net::imap::numvalidator::valid_nz_number?()","date::valid_ordinal?()","ipsocket::valid_v6?()","bundler::rubygemsintegration#validate()","gem::specification#validate()","gem::specificationpolicy#validate()","rexml::validation::validator#validate()","rss::element#validate()","bundler::settings#validate!()","bundler::settings::mirror#validate!()","bundler::settings::validator::validate!()","bundler::settings::validator::rule#validate!()","gem::specificationpolicy#validate_array_attribute()","gem::specificationpolicy#validate_array_attributes()","rss::element#validate_attribute()","gem::specificationpolicy#validate_attribute_present()","gem::specificationpolicy#validate_authors_field()","bundler::sharedhelpers#validate_bundle_path()","bundler::rubygemsgeminstaller#validate_bundler_checksum()","bundler::cli::exec#validate_cmd!()","net::imap#validate_data()","gem::specification#validate_dependencies()","rss::atom::duplicatelinkchecker#validate_duplicate_links()","bundler::cli::gem#validate_ext_name()","rss::element#validate_for_stream()","bundler::dsl#validate_keys()","gem::specificationpolicy#validate_lazy_metadata()","gem::specificationpolicy#validate_licenses()","net::smtp#validate_line()","gem::specification#validate_metadata()","gem::specificationpolicy#validate_metadata()","gem::specificationpolicy#validate_name()","gem::specificationpolicy#validate_nil_attributes()","gem::specificationpolicy#validate_non_files()","rss::imagemodelutils#validate_one_tag_name()","bundler::cli::add#validate_options!()","gem::specification#validate_permissions()","gem::specificationpolicy#validate_permissions()","gem::specificationpolicy#validate_platform()","bundler::definition#validate_platforms!()","bundler::plugin#validate_plugin!()","gem::specificationpolicy#validate_require_paths()","gem::specificationpolicy#validate_required_attributes()","bundler::resolver#validate_resolved_specs!()","bundler::definition#validate_ruby!()","gem::specificationpolicy#validate_rubygems_version()","bundler::definition#validate_runtime!()","bundler::cli::config::base#validate_scope!()","gem::specificationpolicy#validate_self_inclusion_in_files_list()","gem::specificationpolicy#validate_shebang_line_in()","bundler::source::git#validate_spec()","bundler::source::path#validate_spec()","gem::specificationpolicy#validate_specification_version()","bundler::fetcher::downloader#validate_uri_scheme!()","gem::specificationpolicy#validate_values()","cgi::cookie#value()","fiddle::importer#value()","net::httpresponse#value()","openssl::x509::attribute#value()","openssl::x509::extension#value()","rexml::attribute#value()","rexml::cdata#value()","rexml::entity#value()","rexml::text#value()","rinda::tuple#value()","rinda::tupleentry#value()","thread#value()","uncaughtthrowerror#value()","win32ole_variable#value()","win32ole_variant#value()","cgi::cookie#value=()","openssl::x509::attribute#value=()","openssl::x509::extension#value=()","rexml::text#value=()","rss::itunesitemmodel::itunesduration#value=()","win32ole_variant#value=()","dbm#value?()","env::value?()","gdbm#value?()","hash#value?()","sdbm#value?()","rexml::xpathparser#value_type()","bundler::thor::coreext::orderedhash#values()","dbm#values()","env::values()","gdbm#values()","hash#values()","objectspace::weakmap#values()","sdbm#values()","struct#values()","yaml::dbm#values()","array#values_at()","csv::row#values_at()","csv::table#values_at()","dbm#values_at()","env::values_at()","gdbm#values_at()","hash#values_at()","matchdata#values_at()","sdbm#values_at()","stringscanner#values_at()","struct#values_at()","yaml::dbm#values_at()","rss::maker::atom::entry::items::item#variable_is_set?()","rss::maker::atom::feed::channel#variable_is_set?()","rss::maker::base#variable_is_set?()","win32ole_variable#variable_kind()","rexml::functions::variables()","rss::maker::atom::entry::items::item#variables()","rss::maker::atom::feed::channel#variables()","rss::maker::atom::feed::items::item#variables()","rss::maker::atom::feed::items::item::content#variables()","rss::maker::atom::feed::items::item::source#variables()","rss::maker::atomcategory#variables()","rss::maker::atomtextconstruct#variables()","rss::maker::base#variables()","rss::maker::rss09::channel#variables()","rss::maker::rss10::image#variables()","rss::maker::rss10::items::item#variables()","rss::maker::rss20::items::item#variables()","win32ole_type#variables()","rexml::functions::variables=()","rexml::xpathparser#variables=()","win32ole_variable#varkind()","win32ole_variant#vartype()","gem::testcase::vc_windows?()","gem::testcase#vc_windows?()","gem::testcase#vendordir()","optionparser#ver()","drb::drbserver#verbose()","drb::drbserver::verbose()","gem::userinteraction#verbose()","drb::drbserver::verbose=()","drb::drbserver#verbose=()","irb::context#verbose?()","gem::package#verify()","gem::package::old#verify()","gem::security::policy#verify()","gem::security::trustdir#verify()","net::pop3::verify()","openssl::netscape::spki#verify()","openssl::ocsp::basicresponse#verify()","openssl::ocsp::request#verify()","openssl::pkcs7#verify()","openssl::pkey::pkey#verify()","openssl::x509::crl#verify()","openssl::x509::certificate#verify()","openssl::x509::request#verify()","openssl::x509::store#verify()","openssl::x509::storecontext#verify()","gem::gemcutterutilities#verify_api_key()","bundler::persistent::net::http::persistent#verify_callback=()","openssl::x509::store#verify_callback=()","gem::request::verify_certificate()","openssl::ssl#verify_certificate_identity()","openssl::ssl::verify_certificate_identity()","gem::request::verify_certificate_message()","gc::verify_compaction_references()","bundler::persistent::net::http::persistent#verify_depth=()","gem::package#verify_entry()","gem::package#verify_files()","bundler::resolver#verify_gemfile_dependencies_are_found!()","bundler::cli::list#verify_group_exists()","gc::verify_internal_consistency()","bundler::persistent::net::http::persistent#verify_mode=()","openssl::pkey::rsa#verify_pss()","openssl::ssl::sslsocket#verify_result()","gem::security::policy#verify_signatures()","gem::installer#verify_spec()","gc::verify_transient_heap_internal_consistency()","bundler::cli#version()","bundler::gemhelper#version()","bundler::rubygemsintegration::version()","bundler::rubygemsintegration#version()","bundler::source::git::gitproxy#version()","erb::version()","gem::basicspecification#version()","gem::resolver::activationrequest#version()","gem::resolver::specspecification#version()","gem::unsatisfiabledependencyerror#version()","gem::version#version()","irb::version()","openssl::x509::crl#version()","openssl::x509::certificate#version()","openssl::x509::request#version()","optionparser#version()","rexml::document#version()","win32ole_typelib#version()","gem::specification#version=()","openssl::x509::crl#version=()","openssl::x509::certificate#version=()","openssl::x509::request#version=()","net::http::version_1_2()","net::http::version_1_2?()","bundler::source#version_color()","bundler::resolver#version_conflict_message()","bundler::standalone#version_dir()","bundler::plugin::installer::git#version_message()","bundler::plugin::installer::rubygems#version_message()","bundler::source#version_message()","bundler::source::metadata#version_message()","bundler::env::version_of()","bundler::injector#version_prefix()","bundler::gemhelper#version_tag()","bundler::compactindexclient#versions()","bundler::compactindexclient::cache#versions()","rss::maker::versions()","bundler::compactindexclient::cache#versions_path()","bundler::rubyversion#versions_string()","bundler::molinillo::dependencygraph#vertex_named()","gem::resolver::molinillo::dependencygraph#vertex_named()","socket::ifaddr#vhid()","readline::vi_editing_mode()","reline::core#vi_editing_mode()","readline::vi_editing_mode?()","reline::core#vi_editing_mode?()","webrick::httpserver#virtual_host()","rdoc::options#visibility=()","win32ole_method#visible?()","win32ole_type#visible?()","win32ole_typelib#visible?()","win32ole_variable#visible?()","optionparser#visit()","psych::visitors::visitor#visit()","psych::visitors::yamltree#visit_array()","psych::visitors::yamltree#visit_basicobject()","psych::visitors::yamltree#visit_bigdecimal()","psych::visitors::yamltree#visit_class()","psych::visitors::yamltree#visit_complex()","psych::visitors::yamltree#visit_date()","psych::visitors::yamltree#visit_datetime()","psych::visitors::yamltree#visit_delegator()","psych::visitors::yamltree#visit_encoding()","psych::visitors::yamltree#visit_enumerator()","psych::visitors::yamltree#visit_exception()","psych::visitors::yamltree#visit_falseclass()","psych::visitors::yamltree#visit_float()","psych::visitors::yamltree#visit_hash()","psych::visitors::yamltree#visit_integer()","psych::visitors::yamltree#visit_module()","psych::visitors::yamltree#visit_nameerror()","psych::visitors::yamltree#visit_nilclass()","psych::visitors::yamltree#visit_object()","psych::visitors::depthfirst#visit_psych_nodes_alias()","psych::visitors::emitter#visit_psych_nodes_alias()","psych::visitors::noaliasruby#visit_psych_nodes_alias()","psych::visitors::toruby#visit_psych_nodes_alias()","psych::visitors::depthfirst#visit_psych_nodes_document()","psych::visitors::emitter#visit_psych_nodes_document()","psych::visitors::toruby#visit_psych_nodes_document()","psych::visitors::depthfirst#visit_psych_nodes_mapping()","psych::visitors::emitter#visit_psych_nodes_mapping()","psych::visitors::toruby#visit_psych_nodes_mapping()","psych::visitors::depthfirst#visit_psych_nodes_scalar()","psych::visitors::emitter#visit_psych_nodes_scalar()","psych::visitors::toruby#visit_psych_nodes_scalar()","psych::visitors::depthfirst#visit_psych_nodes_sequence()","psych::visitors::emitter#visit_psych_nodes_sequence()","psych::visitors::toruby#visit_psych_nodes_sequence()","psych::visitors::depthfirst#visit_psych_nodes_stream()","psych::visitors::emitter#visit_psych_nodes_stream()","psych::visitors::toruby#visit_psych_nodes_stream()","psych::visitors::yamltree#visit_psych_omap()","psych::visitors::yamltree#visit_psych_set()","psych::visitors::yamltree#visit_range()","psych::visitors::yamltree#visit_rational()","psych::visitors::yamltree#visit_regexp()","gem::noaliasyamltree#visit_string()","psych::visitors::yamltree#visit_string()","psych::visitors::yamltree#visit_struct()","psych::visitors::yamltree#visit_symbol()","psych::visitors::yamltree#visit_time()","psych::visitors::yamltree#visit_trueclass()","psych::visitors::yamltree#visit_array_subclass()","psych::visitors::yamltree#visit_hash_subclass()","bundler::cli#viz()","bundler::graph#viz()","net::ftp#voidcmd()","matrix::vstack()","matrix#vstack()","time#w3cdtf()","time::w3cdtf()","conditionvariable#wait()","io#wait()","monitormixin::conditionvariable#wait()","process::wait()","rinda::waittemplateentry#wait()","process::wait2()","gem::testcase#wait_for_child_process_to_exit()","monitor#wait_for_cond()","net::httpgenericrequest#wait_for_continue()","bundler::settings::tcpsocketprobe#wait_for_writtable_socket()","io#wait_readable()","monitormixin::conditionvariable#wait_until()","monitormixin::conditionvariable#wait_while()","io#wait_writable()","process::waitall()","debugger__::waiting()","process::waitpid()","process::waitpid2()","thread#wakeup()","bundler::ui::shell#warn()","bundler::ui::silent#warn()","kernel#warn()","logger#warn()","optionparser#warn()","rdoc::options#warn()","rdoc::parser::ruby#warn()","ripper#warn()","syslog::logger#warn()","webrick::basiclog#warn()","warning#warn()","logger#warn!()","logger#warn?()","webrick::basiclog#warn?()","bundler::cli::install#warn_ambiguous_gems()","bundler::dsl#warn_deprecated_git_source()","bundler::lockfileparser#warn_for_outdated_bundler_version()","bundler::cli::install#warn_if_root()","bundler::persistenthttp#warn_old_tls_version_rubygems_connection()","bundler::sourcelist#warn_on_git_protocol()","bundler::installer#warn_on_incompatible_bundler_deps()","bundler::cli#warn_on_outdated_bundler()","bundler::cli::config::base#warn_unused_scope()","ripper#warning()","date#wday()","time#wday()","weakref#weakref_alive?()","date#wednesday?()","time#wednesday?()","date::weeknum()","datetime::weeknum()","bundler::specset#what_required()","gem::command#when_invoked()","bundler::which()","gem::commands::updatecommand#which_to_update()","rexml::element#whitespace()","gem::dependencylist#why_not_ok?()","fiddle::win32_last_error()","fiddle::win32_last_error=()","gem::win_platform=()","gem::win_platform?()","gem::testcase#win_platform?()","gem::testcase::win_platform?()","gem::installer#windows_stub_script()","io#winsize()","irb::inputmethod#winsize()","io#winsize=()","bundler::connectionpool#with()","bundler::connectionpool::wrapper#with()","optionparser::with()","bundler::rubygemsintegration#with_build_args()","bundler::with_clean_env()","bundler::sharedhelpers#with_clean_git_env()","gem::testcase#with_clean_path_to_ruby()","makemakefile#with_config()","bundler::with_env()","bundler::with_friendly_errors()","enumerator#with_index()","enumerator::lazy#with_index()","prime::pseudoprimegenerator#with_index()","bundler::ui::shell#with_level()","bundler::molinillo::delegates::specificationprovider#with_no_such_dependency_error_handling()","gem::resolver::molinillo::delegates::specificationprovider#with_no_such_dependency_error_handling()","enumerator#with_object()","prime::pseudoprimegenerator#with_object()","bundler::with_original_env()","bundler::thor::shell#with_padding()","gem::gemcutterutilities#with_response()","bundler::dsl#with_source()","bundler::with_unbundled_env()","irb::color::without_circular_ref()","bundler::cli::common::without_groups_message()","date#wnum0()","date#wnum1()","bundler::ui::shell#word_wrap()","gem::platformmismatch#wordy()","gem::sourcefetchproblem#wordy()","bundler::parallelinstaller#worker_pool()","irb::context#workspaces()","file::world_readable?()","file::stat#world_readable?()","filetest#world_readable?()","pathname#world_readable?()","file::world_writable?()","file::stat#world_writable?()","filetest#world_writable?()","pathname#world_writable?()","bundler::connectionpool::wrap()","gem::command#wrap()","gem::package::digestio::wrap()","json::jsonerror::wrap()","rdoc::text#wrap()","rexml::formatters::pretty#wrap()","rexml::text#wrap()","zlib::gzipfile::wrap()","file::writable?()","file::stat#writable?()","filetest#writable?()","net::ftp::mlsxentry#writable?()","pathname#writable?()","file::writable_real?()","file::stat#writable_real?()","filetest#writable_real?()","pathname#writable_real?()","argf#write()","bundler::env::write()","gem::configfile#write()","gem::package::digestio#write()","gem::package::tarwriter::boundedstream#write()","gem::package::tarwriter::restrictedstream#write()","gem::requestset::lockfile#write()","gem::security::write()","io::write()","io#write()","net::writeadapter#write()","openssl::buffering#write()","pathname#write()","rexml::attlistdecl#write()","rexml::attribute#write()","rexml::cdata#write()","rexml::comment#write()","rexml::dtd::entitydecl#write()","rexml::dtd::notationdecl#write()","rexml::declaration#write()","rexml::doctype#write()","rexml::document#write()","rexml::element#write()","rexml::entity#write()","rexml::externalentity#write()","rexml::formatters::default#write()","rexml::instruction#write()","rexml::notationdecl#write()","rexml::referencewriter#write()","rexml::text#write()","rexml::xmldecl#write()","rinda::tuplespace#write()","rinda::tuplespaceproxy#write()","stringio#write()","zlib::gzipwriter#write()","gem::write_binary()","gem::installer#write_build_info_file()","gem::installer#write_cache_file()","rexml::formatters::default#write_cdata()","rexml::formatters::pretty#write_cdata()","rexml::formatters::default#write_comment()","rexml::formatters::pretty#write_comment()","gem::installer#write_default_spec()","rexml::formatters::default#write_document()","rexml::formatters::pretty#write_document()","rexml::formatters::default#write_element()","rexml::formatters::pretty#write_element()","rexml::formatters::transitive#write_element()","gem::testcase#write_file()","net::httpgenericrequest#write_header()","csv#write_headers?()","rexml::formatters::default#write_instruction()","racc::grammar#write_log()","io#write_nonblock()","io::generic_writable#write_nonblock()","openssl::buffering#write_nonblock()","rdoc::options#write_options()","openssl::random::write_random_file()","rinda::ringserver#write_services()","openssl::pkcs7::write_smime()","gem::installer#write_spec()","rexml::formatters::default#write_text()","rexml::formatters::pretty#write_text()","rexml::formatters::transitive#write_text()","net::http#write_timeout=()","bundler::sharedhelpers#write_to_gemfile()","rexml::text#write_with_substitution()","csv#writer()","csv#writer_fields_converter()","csv#writer_options()","bundler::currentruby#x64_mingw?()","rss::atom::feed::entry::content#xhtml()","rss::atom::textconstruct#xhtml()","rss::maker::atomtextconstructbase::ensurexmlcontent#xhtml=()","net::imap#xlist()","rss::atom::feed::entry::content#xml()","rss::maker::itemsbase::itembase::contentbase#xml=()","rss::rexmllikexmlparser#xmldecl()","rss::maker::atomtextconstructbase::ensurexmlcontent#xml_content=()","rss::maker::itemsbase::itembase::contentbase#xml_content=()","rexml::document#xml_decl()","rss::atom::feed::entry::content::xml_getter()","rss::atom::textconstruct::xml_getter()","rss::atom::feed::entry::content::xml_setter()","rss::atom::textconstruct::xml_setter()","rss::xmlstylesheetmixin#xml_stylesheet_pi()","rss::maker::atom::feed::items::item::content#xml_type?()","rexml::sax2listener#xmldecl()","rexml::streamlistener#xmldecl()","rexml::xmldecl#xmldecl()","rss::listenermixin#xmldecl()","rss::rexmllistener#xmldecl()","rss::rootelementmixin#xmldecl()","rss::xmlparserlistener#xmldecl()","rexml::parsers::pullevent#xmldecl?()","rss::element#xmled_content()","date#xmlschema()","date::xmlschema()","datetime::xmlschema()","datetime#xmlschema()","time::xmlschema()","time#xmlschema()","object#xmp()","rexml::attribute#xpath()","rexml::element#xpath()","rexml::text#xpath()","kernel#y()","psych::nodes::node#yaml()","object::yaml_tag()","gem::commands::yankcommand#yank_api_request()","gem::commands::yankcommand#yank_gem()","date#yday()","time#yday()","date#year()","time#year()","bundler::thor::shell::basic#yes?()","bundler::ui::shell#yes?()","bundler::ui::silent#yes?()","rss::basemodel#yes_other_attr_reader()","rss::basemodel#yes_other_writer()","fiber::yield()","proc#yield()","object#yield_self()","racc::parser#yyaccept()","ripper#yydebug()","ripper#yydebug=()","racc::parser#yyerrok()","racc::parser#yyerror()","racc::grammarfilescanner#yylex()","racc::grammarfilescanner#yylex0()","matrix::zero()","vector::zero()","bigdecimal#zero?()","file::zero?()","file::stat#zero?()","filetest#zero?()","float#zero?()","matrix#zero?()","numeric#zero?()","openssl::bn#zero?()","pathname#zero?()","vector#zero?()","array#zip()","enumerable#zip()","enumerator::lazy#zip()","rdoc::parser::zip?()","zlib::zlib_version()","datetime#zone()","time#zone()","time::zone_offset()","time::zone_utc?()","array#|()","falseclass#|()","ipaddr#|()","integer#|()","json::genericobject#|()","nilclass#|()","racc::rule#|()","racc::sym#|()","set#|()","trueclass#|()","ipaddr#~()","integer#~()","regexp#~()","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"info":[["ACL","","ACL.html","","<p>Simple Access Control Lists.\n<p>Access control lists are composed of “allow” and “deny” …\n"],["ACL::ACLEntry","","ACL/ACLEntry.html","","<p>An entry in an ACL\n"],["ACL::ACLList","","ACL/ACLList.html","","<p>A list of ACLEntry objects.  Used to implement the allow and deny halves of an ACL\n"],["ARGF","","ARGF.html","","<p><code>ARGF</code> is a stream designed for use in scripts that process files given as command-line arguments or passed …\n"],["Abbrev","","Abbrev.html","","<p>Calculates the set of unambiguous abbreviations for a given set of strings.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;abbrev&#39;</span>\n<span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;pp&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Addrinfo","","Addrinfo.html","",""],["AmbiguousCommandError","","AmbiguousCommandError.html","",""],["AmbiguousTaskError","","AmbiguousTaskError.html","",""],["ArgumentError","","ArgumentError.html","","<p>Raised when the arguments are wrong and there isn&#39;t a more specific Exception class.\n<p>Ex: passing the …\n"],["Array","","Array.html","","<p>Arrays are ordered, integer-indexed collections of any object.\n<p>Array indexing starts at 0, as in C or …\n"],["Base64","","Base64.html","","<p>The Base64 module provides for the encoding (#encode64, #strict_encode64, #urlsafe_encode64) and decoding …\n"],["BasicObject","","BasicObject.html","","<p>BasicObject is the parent class of all classes in Ruby.  It&#39;s an explicit blank class.\n<p>BasicObject …\n"],["BasicSocket","","BasicSocket.html","","<p>BasicSocket is the super class for all the Socket classes.\n"],["Benchmark","","Benchmark.html","","<p>The Benchmark module provides methods to measure and report the time used to execute Ruby code.\n<p>Measure …\n"],["Benchmark::Tms","","Benchmark/Tms.html","","<p>A data object, representing the times associated with a benchmark measurement.\n"],["BigDecimal","","BigDecimal.html","","<p>BigDecimal provides arbitrary-precision floating point decimal arithmetic.\n<p>Introduction\n<p>Ruby provides built-in …\n"],["BigMath","","BigMath.html","","<p>Provides mathematical functions.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&quot;bigdecimal/math&quot;</span>\n\n<span class=\"ruby-identifier\">include</span> <span class=\"ruby-constant\">BigMath</span>\n\n<span class=\"ruby-identifier\">a</span> = <span class=\"ruby-constant\">BigDecimal</span>((<span class=\"ruby-constant\">PI</span>(<span class=\"ruby-value\">100</span>)<span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">to_s</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Binding","","Binding.html","","<p>Objects of class Binding encapsulate the execution context at some particular place in the code and retain …\n"],["Bundler","","Bundler.html","","<p>Bundler provides a consistent environment for Ruby projects by tracking and installing the exact gems …\n"],["Bundler::APIResponseMismatchError","","Bundler/APIResponseMismatchError.html","",""],["Bundler::BuildMetadata","","Bundler/BuildMetadata.html","","<p>Represents metadata from when the Bundler gem was built.\n"],["Bundler::BundlerError","","Bundler/BundlerError.html","",""],["Bundler::CLI","","Bundler/CLI.html","",""],["Bundler::CLI::Add","","Bundler/CLI/Add.html","",""],["Bundler::CLI::Binstubs","","Bundler/CLI/Binstubs.html","",""],["Bundler::CLI::Cache","","Bundler/CLI/Cache.html","",""],["Bundler::CLI::Check","","Bundler/CLI/Check.html","",""],["Bundler::CLI::Clean","","Bundler/CLI/Clean.html","",""],["Bundler::CLI::Common","","Bundler/CLI/Common.html","",""],["Bundler::CLI::Config","","Bundler/CLI/Config.html","",""],["Bundler::CLI::Config::Base","","Bundler/CLI/Config/Base.html","",""],["Bundler::CLI::Console","","Bundler/CLI/Console.html","",""],["Bundler::CLI::Doctor","","Bundler/CLI/Doctor.html","",""],["Bundler::CLI::Exec","","Bundler/CLI/Exec.html","",""],["Bundler::CLI::Gem","","Bundler/CLI/Gem.html","",""],["Bundler::CLI::Info","","Bundler/CLI/Info.html","",""],["Bundler::CLI::Init","","Bundler/CLI/Init.html","",""],["Bundler::CLI::Inject","","Bundler/CLI/Inject.html","",""],["Bundler::CLI::Install","","Bundler/CLI/Install.html","",""],["Bundler::CLI::Issue","","Bundler/CLI/Issue.html","",""],["Bundler::CLI::List","","Bundler/CLI/List.html","",""],["Bundler::CLI::Lock","","Bundler/CLI/Lock.html","",""],["Bundler::CLI::Open","","Bundler/CLI/Open.html","",""],["Bundler::CLI::Outdated","","Bundler/CLI/Outdated.html","",""],["Bundler::CLI::Package","","Bundler/CLI/Package.html","",""],["Bundler::CLI::Platform","","Bundler/CLI/Platform.html","",""],["Bundler::CLI::Plugin","","Bundler/CLI/Plugin.html","",""],["Bundler::CLI::Pristine","","Bundler/CLI/Pristine.html","",""],["Bundler::CLI::Remove","","Bundler/CLI/Remove.html","",""],["Bundler::CLI::Show","","Bundler/CLI/Show.html","",""],["Bundler::CLI::Update","","Bundler/CLI/Update.html","",""],["Bundler::CLI::Viz","","Bundler/CLI/Viz.html","",""],["Bundler::CompactIndexClient","","Bundler/CompactIndexClient.html","",""],["Bundler::CompactIndexClient::Cache","","Bundler/CompactIndexClient/Cache.html","",""],["Bundler::CompactIndexClient::Error","","Bundler/CompactIndexClient/Error.html","",""],["Bundler::CompactIndexClient::Updater","","Bundler/CompactIndexClient/Updater.html","",""],["Bundler::CompactIndexClient::Updater::MisMatchedChecksumError","","Bundler/CompactIndexClient/Updater/MisMatchedChecksumError.html","",""],["Bundler::ConnectionPool","","Bundler/ConnectionPool.html","","<p>Generic connection pool class for e.g. sharing a limited number of network connections among many threads. …\n"],["Bundler::ConnectionPool::Error","","Bundler/ConnectionPool/Error.html","",""],["Bundler::ConnectionPool::PoolShuttingDownError","","Bundler/ConnectionPool/PoolShuttingDownError.html","","<p>Raised when you attempt to retrieve a connection from a pool that has been shut down.\n"],["Bundler::ConnectionPool::TimedStack","","Bundler/ConnectionPool/TimedStack.html","","<p>Examples:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ts</span> = <span class=\"ruby-constant\">TimedStack</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">1</span>) { <span class=\"ruby-constant\">MyConnection</span>.<span class=\"ruby-identifier\">new</span> }\n\n<span class=\"ruby-comment\"># fetch a connection</span>\n<span class=\"ruby-identifier\">conn</span> = <span class=\"ruby-identifier\">ts</span>.<span class=\"ruby-identifier\">pop</span>\n\n<span class=\"ruby-comment\"># return a ...</span>\n</pre>\n"],["Bundler::ConnectionPool::Wrapper","","Bundler/ConnectionPool/Wrapper.html","",""],["Bundler::CurrentRuby","","Bundler/CurrentRuby.html","",""],["Bundler::CyclicDependencyError","","Bundler/CyclicDependencyError.html","",""],["Bundler::Definition","","Bundler/Definition.html","",""],["Bundler::DepProxy","","Bundler/DepProxy.html","",""],["Bundler::Dependency","","Bundler/Dependency.html","",""],["Bundler::Deployment","","Bundler/Deployment.html","",""],["Bundler::Deprecate","","Bundler/Deprecate.html","",""],["Bundler::DeprecatedError","","Bundler/DeprecatedError.html","",""],["Bundler::Dsl","","Bundler/Dsl.html","",""],["Bundler::Dsl::DSLError","","Bundler/Dsl/DSLError.html","",""],["Bundler::EndpointSpecification","","Bundler/EndpointSpecification.html","","<p>used for Creating Specifications from the Gemcutter Endpoint\n"],["Bundler::Env","","Bundler/Env.html","",""],["Bundler::EnvironmentPreserver","","Bundler/EnvironmentPreserver.html","",""],["Bundler::FeatureFlag","","Bundler/FeatureFlag.html","",""],["Bundler::Fetcher","","Bundler/Fetcher.html","","<p>Handles all the fetching with the rubygems server\n"],["Bundler::Fetcher::AuthenticationRequiredError","","Bundler/Fetcher/AuthenticationRequiredError.html","","<p>This error is raised if HTTP authentication is required, but not provided.\n"],["Bundler::Fetcher::BadAuthenticationError","","Bundler/Fetcher/BadAuthenticationError.html","","<p>This error is raised if HTTP authentication is provided, but incorrect.\n"],["Bundler::Fetcher::Base","","Bundler/Fetcher/Base.html","",""],["Bundler::Fetcher::CertificateFailureError","","Bundler/Fetcher/CertificateFailureError.html","","<p>This is the error raised if OpenSSL fails the cert verification\n"],["Bundler::Fetcher::CompactIndex","","Bundler/Fetcher/CompactIndex.html","",""],["Bundler::Fetcher::Dependency","","Bundler/Fetcher/Dependency.html","",""],["Bundler::Fetcher::Downloader","","Bundler/Fetcher/Downloader.html","",""],["Bundler::Fetcher::FallbackError","","Bundler/Fetcher/FallbackError.html","","<p>This error is raised if the API returns a 413 (only printed in verbose)\n"],["Bundler::Fetcher::Index","","Bundler/Fetcher/Index.html","",""],["Bundler::Fetcher::NetworkDownError","","Bundler/Fetcher/NetworkDownError.html","","<p>This error is raised when it looks like the network is down\n"],["Bundler::Fetcher::SSLError","","Bundler/Fetcher/SSLError.html","","<p>This is the error raised when a source is HTTPS and OpenSSL didn&#39;t load\n"],["Bundler::Fetcher::TooManyRequestsError","","Bundler/Fetcher/TooManyRequestsError.html","","<p>This error is raised if we should rate limit our requests to the API\n"],["Bundler::FileUtils","","Bundler/FileUtils.html","","<p>fileutils.rb\n<p>Copyright © 2000-2007 Minero Aoki\n<p>This program is free software. You can distribute/modify …\n"],["Bundler::FileUtils::DryRun","","Bundler/FileUtils/DryRun.html","","<p>This module has all methods of Bundler::FileUtils module, but never changes files/directories, with printing …\n"],["Bundler::FileUtils::NoWrite","","Bundler/FileUtils/NoWrite.html","","<p>This module has all methods of Bundler::FileUtils module, but never changes files/directories.  This …\n"],["Bundler::FileUtils::StreamUtils_","","Bundler/FileUtils/StreamUtils_.html","",""],["Bundler::FileUtils::Verbose","","Bundler/FileUtils/Verbose.html","","<p>This module has all methods of Bundler::FileUtils module, but it outputs messages before acting.  This …\n"],["Bundler::FriendlyErrors","","Bundler/FriendlyErrors.html","",""],["Bundler::GemHelper","","Bundler/GemHelper.html","",""],["Bundler::GemHelpers","","Bundler/GemHelpers.html","",""],["Bundler::GemHelpers::PlatformMatch","","Bundler/GemHelpers/PlatformMatch.html","",""],["Bundler::GemInstaller","","Bundler/GemInstaller.html","",""],["Bundler::GemNotFound","","Bundler/GemNotFound.html","",""],["Bundler::GemRemoteFetcher","","Bundler/GemRemoteFetcher.html","","<p>Adds support for setting custom HTTP headers when fetching gems from the server.\n<p>TODO: Get rid of this …\n"],["Bundler::GemRequireError","","Bundler/GemRequireError.html","",""],["Bundler::GemVersionPromoter","","Bundler/GemVersionPromoter.html","","<p>This class contains all of the logic for determining the next version of a Gem to update to based on …\n"],["Bundler::Gemdeps","","Bundler/Gemdeps.html","",""],["Bundler::GemfileError","","Bundler/GemfileError.html","",""],["Bundler::GemfileEvalError","","Bundler/GemfileEvalError.html","",""],["Bundler::GemfileLockNotFound","","Bundler/GemfileLockNotFound.html","",""],["Bundler::GemfileNotFound","","Bundler/GemfileNotFound.html","",""],["Bundler::GemspecError","","Bundler/GemspecError.html","",""],["Bundler::GenericSystemCallError","","Bundler/GenericSystemCallError.html","",""],["Bundler::GitError","","Bundler/GitError.html","",""],["Bundler::Graph","","Bundler/Graph.html","",""],["Bundler::Graph::GraphVizClient","","Bundler/Graph/GraphVizClient.html","",""],["Bundler::HTTPError","","Bundler/HTTPError.html","",""],["Bundler::Index","","Bundler/Index.html","",""],["Bundler::Injector","","Bundler/Injector.html","",""],["Bundler::InstallError","","Bundler/InstallError.html","",""],["Bundler::InstallHookError","","Bundler/InstallHookError.html","",""],["Bundler::Installer","","Bundler/Installer.html","",""],["Bundler::InvalidOption","","Bundler/InvalidOption.html","",""],["Bundler::LazySpecification","","Bundler/LazySpecification.html","",""],["Bundler::LazySpecification::Identifier","","Bundler/LazySpecification/Identifier.html","",""],["Bundler::LockfileError","","Bundler/LockfileError.html","",""],["Bundler::LockfileGenerator","","Bundler/LockfileGenerator.html","",""],["Bundler::LockfileParser","","Bundler/LockfileParser.html","",""],["Bundler::MarshalError","","Bundler/MarshalError.html","",""],["Bundler::MatchPlatform","","Bundler/MatchPlatform.html","",""],["Bundler::MirrorSockets","","Bundler/MirrorSockets.html","","<p>Class used to build the list of sockets that correspond to\n\n<pre>a given mirror.</pre>\n<p>One mirror may correspond to …\n"],["Bundler::Molinillo","","Bundler/Molinillo.html","","<p>Bundler::Molinillo is a generic dependency resolution algorithm.\n"],["Bundler::Molinillo::CircularDependencyError","","Bundler/Molinillo/CircularDependencyError.html","","<p>An error caused by attempting to fulfil a dependency that was circular\n<p>@note This exception will be thrown …\n"],["Bundler::Molinillo::Compatibility","","Bundler/Molinillo/Compatibility.html","","<p>Hacks needed for old Ruby versions.\n"],["Bundler::Molinillo::Delegates","","Bundler/Molinillo/Delegates.html","","<p>@!visibility private\n"],["Bundler::Molinillo::Delegates::ResolutionState","","Bundler/Molinillo/Delegates/ResolutionState.html","","<p>Delegates all {Bundler::Molinillo::ResolutionState} methods to a `#state` property.\n"],["Bundler::Molinillo::Delegates::SpecificationProvider","","Bundler/Molinillo/Delegates/SpecificationProvider.html","","<p>Delegates all {Bundler::Molinillo::SpecificationProvider} methods to a `#specification_provider` property. …\n"],["Bundler::Molinillo::DependencyGraph","","Bundler/Molinillo/DependencyGraph.html","","<p>A directed acyclic graph that is tuned to hold named dependencies\n"],["Bundler::Molinillo::DependencyGraph::Action","","Bundler/Molinillo/DependencyGraph/Action.html","","<p>An action that modifies a {DependencyGraph} that is reversible. @abstract\n"],["Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular","","Bundler/Molinillo/DependencyGraph/AddEdgeNoCircular.html","","<p>@!visibility private (see DependencyGraph#add_edge_no_circular)\n"],["Bundler::Molinillo::DependencyGraph::DeleteEdge","","Bundler/Molinillo/DependencyGraph/DeleteEdge.html","","<p>@!visibility private (see DependencyGraph#delete_edge)\n"],["Bundler::Molinillo::DependencyGraph::DetachVertexNamed","","Bundler/Molinillo/DependencyGraph/DetachVertexNamed.html","","<p>@!visibility private @see DependencyGraph#detach_vertex_named\n"],["Bundler::Molinillo::DependencyGraph::Log","","Bundler/Molinillo/DependencyGraph/Log.html","","<p>A log for dependency graph actions\n"],["Bundler::Molinillo::DependencyGraph::Tag","","Bundler/Molinillo/DependencyGraph/Tag.html","","<p>@!visibility private @see DependencyGraph#tag\n"],["Bundler::Molinillo::DependencyGraph::Vertex","","Bundler/Molinillo/DependencyGraph/Vertex.html","","<p>A vertex in a {DependencyGraph} that encapsulates a {#name} and a {#payload}\n"],["Bundler::Molinillo::DependencyState","","Bundler/Molinillo/DependencyState.html","","<p>A state that encapsulates a set of {#requirements} with an {Array} of possibilities\n"],["Bundler::Molinillo::NoSuchDependencyError","","Bundler/Molinillo/NoSuchDependencyError.html","","<p>An error caused by searching for a dependency that is completely unknown, i.e. has no versions available …\n"],["Bundler::Molinillo::PossibilityState","","Bundler/Molinillo/PossibilityState.html","","<p>A state that encapsulates a single possibility to fulfill the given {#requirement}\n"],["Bundler::Molinillo::ResolutionState","","Bundler/Molinillo/ResolutionState.html","",""],["Bundler::Molinillo::Resolver","","Bundler/Molinillo/Resolver.html","","<p>This class encapsulates a dependency resolver. The resolver is responsible for determining which set …\n"],["Bundler::Molinillo::Resolver::Resolution","","Bundler/Molinillo/Resolver/Resolution.html","","<p>A specific resolution from a given {Resolver}\n"],["Bundler::Molinillo::Resolver::Resolution::Conflict","","Bundler/Molinillo/Resolver/Resolution/Conflict.html","",""],["Bundler::Molinillo::Resolver::Resolution::PossibilitySet","","Bundler/Molinillo/Resolver/Resolution/PossibilitySet.html","",""],["Bundler::Molinillo::Resolver::Resolution::UnwindDetails","","Bundler/Molinillo/Resolver/Resolution/UnwindDetails.html","",""],["Bundler::Molinillo::ResolverError","","Bundler/Molinillo/ResolverError.html","","<p>An error that occurred during the resolution process\n"],["Bundler::Molinillo::SpecificationProvider","","Bundler/Molinillo/SpecificationProvider.html","","<p>Provides information about specifcations and dependencies to the resolver, allowing the {Resolver} class …\n"],["Bundler::Molinillo::UI","","Bundler/Molinillo/UI.html","","<p>Conveys information about the resolution process to a user.\n"],["Bundler::Molinillo::VersionConflict","","Bundler/Molinillo/VersionConflict.html","","<p>An error caused by conflicts in version\n"],["Bundler::NoSpaceOnDeviceError","","Bundler/NoSpaceOnDeviceError.html","",""],["Bundler::OperationNotSupportedError","","Bundler/OperationNotSupportedError.html","",""],["Bundler::ParallelInstaller","","Bundler/ParallelInstaller.html","",""],["Bundler::ParallelInstaller::SpecInstallation","","Bundler/ParallelInstaller/SpecInstallation.html","",""],["Bundler::PathError","","Bundler/PathError.html","",""],["Bundler::PermissionError","","Bundler/PermissionError.html","",""],["Bundler::Persistent","","Bundler/Persistent.html","",""],["Bundler::Persistent::Net","","Bundler/Persistent/Net.html","",""],["Bundler::Persistent::Net::HTTP","","Bundler/Persistent/Net/HTTP.html","",""],["Bundler::Persistent::Net::HTTP::Persistent","","Bundler/Persistent/Net/HTTP/Persistent.html","","<p>Persistent connections for Net::HTTP\n<p>Bundler::Persistent::Net::HTTP::Persistent maintains persistent connections …\n"],["Bundler::Persistent::Net::HTTP::Persistent::Error","","Bundler/Persistent/Net/HTTP/Persistent/Error.html","","<p>Error class for errors raised by Bundler::Persistent::Net::HTTP::Persistent.  Various SystemCallErrors …\n"],["Bundler::PersistentHTTP","","Bundler/PersistentHTTP.html","",""],["Bundler::Plugin","","Bundler/Plugin.html","","<p>This is the interfacing class represents the API that we intend to provide the plugins to use.\n<p>For plugins …\n"],["Bundler::Plugin::API","","Bundler/Plugin/API.html","",""],["Bundler::Plugin::API::Source","","Bundler/Plugin/API/Source.html","","<p>This class provides the base to build source plugins All the method here are required to build a source …\n"],["Bundler::Plugin::DSL","","Bundler/Plugin/DSL.html","","<p>Dsl to parse the Gemfile looking for plugins to install\n"],["Bundler::Plugin::DSL::PluginGemfileError","","Bundler/Plugin/DSL/PluginGemfileError.html","",""],["Bundler::Plugin::Events","","Bundler/Plugin/Events.html","",""],["Bundler::Plugin::Index","","Bundler/Plugin/Index.html","",""],["Bundler::Plugin::Index::CommandConflict","","Bundler/Plugin/Index/CommandConflict.html","",""],["Bundler::Plugin::Index::SourceConflict","","Bundler/Plugin/Index/SourceConflict.html","",""],["Bundler::Plugin::Installer","","Bundler/Plugin/Installer.html","",""],["Bundler::Plugin::Installer::Git","","Bundler/Plugin/Installer/Git.html","",""],["Bundler::Plugin::Installer::Rubygems","","Bundler/Plugin/Installer/Rubygems.html","",""],["Bundler::Plugin::MalformattedPlugin","","Bundler/Plugin/MalformattedPlugin.html","",""],["Bundler::Plugin::SourceList","","Bundler/Plugin/SourceList.html","",""],["Bundler::Plugin::UndefinedCommandError","","Bundler/Plugin/UndefinedCommandError.html","",""],["Bundler::Plugin::UnknownSourceError","","Bundler/Plugin/UnknownSourceError.html","",""],["Bundler::PluginError","","Bundler/PluginError.html","",""],["Bundler::ProcessLock","","Bundler/ProcessLock.html","",""],["Bundler::ProductionError","","Bundler/ProductionError.html","",""],["Bundler::RemoteSpecification","","Bundler/RemoteSpecification.html","","<p>Represents a lazily loaded gem specification, where the full specification is on the source server in …\n"],["Bundler::Resolver","","Bundler/Resolver.html","",""],["Bundler::Resolver::SpecGroup","","Bundler/Resolver/SpecGroup.html","",""],["Bundler::Retry","","Bundler/Retry.html","","<p>General purpose class for retrying code that may fail\n"],["Bundler::RubyDsl","","Bundler/RubyDsl.html","",""],["Bundler::RubyGemsGemInstaller","","Bundler/RubyGemsGemInstaller.html","",""],["Bundler::RubyVersion","","Bundler/RubyVersion.html","",""],["Bundler::RubyVersionMismatch","","Bundler/RubyVersionMismatch.html","",""],["Bundler::RubygemsIntegration","","Bundler/RubygemsIntegration.html","",""],["Bundler::RubygemsIntegration::Gem","","Bundler/RubygemsIntegration/Gem.html","",""],["Bundler::Runtime","","Bundler/Runtime.html","",""],["Bundler::SecurityError","","Bundler/SecurityError.html","",""],["Bundler::Settings","","Bundler/Settings.html","",""],["Bundler::Settings::Mirror","","Bundler/Settings/Mirror.html","","<p>A mirror\n<p>Contains both the uri that should be used as a mirror and the\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">fallback</span> <span class=\"ruby-identifier\">timeout</span> <span class=\"ruby-identifier\">which</span> <span class=\"ruby-identifier\">will</span> <span class=\"ruby-identifier\">be</span> <span class=\"ruby-identifier\">used</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Bundler::Settings::MirrorConfig","","Bundler/Settings/MirrorConfig.html","","<p>Class used to parse one configuration line\n<p>Gets the configuration line and the value.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">This</span> <span class=\"ruby-identifier\">object</span> <span class=\"ruby-identifier\">provides</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Bundler::Settings::Mirrors","","Bundler/Settings/Mirrors.html","","<p>Class used to build the mirror set and then find a mirror for a given URI\n<p>@param prober [Prober object, …\n"],["Bundler::Settings::TCPSocketProbe","","Bundler/Settings/TCPSocketProbe.html","","<p>Class used for probing TCP availability for a given mirror.\n"],["Bundler::Settings::Validator","","Bundler/Settings/Validator.html","",""],["Bundler::Settings::Validator::Rule","","Bundler/Settings/Validator/Rule.html","",""],["Bundler::SharedHelpers","","Bundler/SharedHelpers.html","",""],["Bundler::SimilarityDetector","","Bundler/SimilarityDetector.html","",""],["Bundler::SocketAddress","","Bundler/SocketAddress.html","","<p>Socket address builder.\n<p>Given a socket type, a host and a port,\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">provides</span> <span class=\"ruby-identifier\">a</span> <span class=\"ruby-identifier\">method</span> <span class=\"ruby-identifier\">to</span> <span class=\"ruby-identifier\">build</span> <span class=\"ruby-identifier\">sockaddr</span> <span class=\"ruby-identifier\">string</span>\n</pre>\n"],["Bundler::Source","","Bundler/Source.html","",""],["Bundler::Source::Gemspec","","Bundler/Source/Gemspec.html","",""],["Bundler::Source::Git","","Bundler/Source/Git.html","",""],["Bundler::Source::Git::GitCommandError","","Bundler/Source/Git/GitCommandError.html","",""],["Bundler::Source::Git::GitNotAllowedError","","Bundler/Source/Git/GitNotAllowedError.html","",""],["Bundler::Source::Git::GitNotInstalledError","","Bundler/Source/Git/GitNotInstalledError.html","",""],["Bundler::Source::Git::GitProxy","","Bundler/Source/Git/GitProxy.html","","<p>The GitProxy is responsible to interact with git repositories. All actions required by the Git source …\n"],["Bundler::Source::Git::MissingGitRevisionError","","Bundler/Source/Git/MissingGitRevisionError.html","",""],["Bundler::Source::Metadata","","Bundler/Source/Metadata.html","",""],["Bundler::Source::Path","","Bundler/Source/Path.html","",""],["Bundler::Source::Path::Installer","","Bundler/Source/Path/Installer.html","",""],["Bundler::Source::Rubygems","","Bundler/Source/Rubygems.html","",""],["Bundler::Source::Rubygems::Remote","","Bundler/Source/Rubygems/Remote.html","",""],["Bundler::SourceList","","Bundler/SourceList.html","",""],["Bundler::SpecSet","","Bundler/SpecSet.html","",""],["Bundler::Standalone","","Bundler/Standalone.html","",""],["Bundler::StubSpecification","","Bundler/StubSpecification.html","",""],["Bundler::SudoNotPermittedError","","Bundler/SudoNotPermittedError.html","",""],["Bundler::TemporaryResourceError","","Bundler/TemporaryResourceError.html","",""],["Bundler::Thor","","Bundler/Thor.html","",""],["Bundler::Thor::Actions","","Bundler/Thor/Actions.html","",""],["Bundler::Thor::Actions::CapturableERB","","Bundler/Thor/Actions/CapturableERB.html","","<p>Bundler::Thor::Actions#capture depends on what kind of buffer is used in ERB. Thus CapturableERB fixes …\n"],["Bundler::Thor::Actions::ClassMethods","","Bundler/Thor/Actions/ClassMethods.html","",""],["Bundler::Thor::Base","","Bundler/Thor/Base.html","",""],["Bundler::Thor::Base::ClassMethods","","Bundler/Thor/Base/ClassMethods.html","",""],["Bundler::Thor::Command","","Bundler/Thor/Command.html","",""],["Bundler::Thor::CoreExt","","Bundler/Thor/CoreExt.html","",""],["Bundler::Thor::CoreExt::OrderedHash","","Bundler/Thor/CoreExt/OrderedHash.html","",""],["Bundler::Thor::DynamicCommand","","Bundler/Thor/DynamicCommand.html","","<p>A dynamic command that handles method missing scenarios.\n"],["Bundler::Thor::DynamicTask","","Bundler/Thor/DynamicCommand.html","","<p>A dynamic command that handles method missing scenarios.\n"],["Bundler::Thor::Group","","Bundler/Thor/Group.html","","<p>Bundler::Thor has a special class called Bundler::Thor::Group. The main difference to Bundler::Thor class …\n"],["Bundler::Thor::HiddenCommand","","Bundler/Thor/HiddenCommand.html","","<p>A command that is hidden in help messages but still invocable.\n"],["Bundler::Thor::HiddenTask","","Bundler/Thor/HiddenCommand.html","","<p>A command that is hidden in help messages but still invocable.\n"],["Bundler::Thor::Invocation","","Bundler/Thor/Invocation.html","",""],["Bundler::Thor::Invocation::ClassMethods","","Bundler/Thor/Invocation/ClassMethods.html","",""],["Bundler::Thor::LineEditor","","Bundler/Thor/LineEditor.html","",""],["Bundler::Thor::LineEditor::Basic","","Bundler/Thor/LineEditor/Basic.html","",""],["Bundler::Thor::LineEditor::Readline","","Bundler/Thor/LineEditor/Readline.html","",""],["Bundler::Thor::LineEditor::Readline::PathCompletion","","Bundler/Thor/LineEditor/Readline/PathCompletion.html","",""],["Bundler::Thor::NestedContext","","Bundler/Thor/NestedContext.html","",""],["Bundler::Thor::RakeCompat","","Bundler/Thor/RakeCompat.html","","<p>Adds a compatibility layer to your Bundler::Thor classes which allows you to use rake package tasks. …\n"],["Bundler::Thor::Shell","","Bundler/Thor/Shell.html","",""],["Bundler::Thor::Shell::Basic","","Bundler/Thor/Shell/Basic.html","",""],["Bundler::Thor::Shell::Color","","Bundler/Thor/Shell/Color.html","","<p>Inherit from Bundler::Thor::Shell::Basic and add set_color behavior. Check Bundler::Thor::Shell::Basic …\n"],["Bundler::Thor::Shell::HTML","","Bundler/Thor/Shell/HTML.html","","<p>Inherit from Bundler::Thor::Shell::Basic and add set_color behavior. Check Bundler::Thor::Shell::Basic …\n"],["Bundler::Thor::Task","","Bundler/Thor/Command.html","",""],["Bundler::Thor::Util","","Bundler/Thor/Util.html","","<p>This module holds several utilities:\n<p>1) Methods to convert thor namespaces to constants and vice-versa. …\n"],["Bundler::ThreadCreationError","","Bundler/ThreadCreationError.html","",""],["Bundler::UI","","Bundler/UI.html","",""],["Bundler::UI::RGProxy","","Bundler/UI/RGProxy.html","",""],["Bundler::UI::Shell","","Bundler/UI/Shell.html","",""],["Bundler::UI::Silent","","Bundler/UI/Silent.html","",""],["Bundler::URI","","Bundler/URI.html","","<p>Bundler::URI is a module providing classes to handle Uniform Resource Identifiers (RFC2396).\n<p>Features …\n"],["Bundler::URI::BadURIError","","Bundler/URI/BadURIError.html","","<p>Bundler::URI is valid, bad usage is not.\n"],["Bundler::URI::Error","","Bundler/URI/Error.html","","<p>Base class for all Bundler::URI exceptions.\n"],["Bundler::URI::Escape","","Bundler/URI/Escape.html","","<p>Module for escaping unsafe characters with codes.\n"],["Bundler::URI::FTP","","Bundler/URI/FTP.html","","<p>FTP Bundler::URI syntax is defined by RFC1738 section 3.2.\n<p>This class will be redesigned because of difference …\n"],["Bundler::URI::File","","Bundler/URI/File.html","","<p>The “file” Bundler::URI is defined by RFC8089.\n"],["Bundler::URI::Generic","","Bundler/URI/Generic.html","","<p>Base class for all Bundler::URI classes. Implements generic Bundler::URI syntax as per RFC 2396.\n"],["Bundler::URI::HTTP","","Bundler/URI/HTTP.html","","<p>The syntax of HTTP URIs is defined in RFC1738 section 3.3.\n<p>Note that the Ruby Bundler::URI library allows …\n"],["Bundler::URI::HTTPS","","Bundler/URI/HTTPS.html","","<p>The default port for HTTPS URIs is 443, and the scheme is &#39;https:&#39; rather than &#39;http:&#39;. …\n"],["Bundler::URI::InvalidComponentError","","Bundler/URI/InvalidComponentError.html","","<p>Not a Bundler::URI component.\n"],["Bundler::URI::InvalidURIError","","Bundler/URI/InvalidURIError.html","","<p>Not a Bundler::URI.\n"],["Bundler::URI::LDAP","","Bundler/URI/LDAP.html","","<p>LDAP Bundler::URI SCHEMA (described in RFC2255).\n"],["Bundler::URI::LDAPS","","Bundler/URI/LDAPS.html","","<p>The default port for LDAPS URIs is 636, and the scheme is &#39;ldaps:&#39; rather than &#39;ldap:&#39;. …\n"],["Bundler::URI::MailTo","","Bundler/URI/MailTo.html","","<p>RFC6068, the mailto URL scheme.\n"],["Bundler::URI::Parser","","Bundler/URI/RFC2396_Parser.html","","<p>Class that parses String&#39;s into Bundler::URI&#39;s.\n<p>It contains a Hash set of patterns and Regexp&#39;s …\n"],["Bundler::URI::REGEXP","","Bundler/URI/RFC2396_REGEXP.html","","<p>Includes Bundler::URI::REGEXP::PATTERN\n"],["Bundler::URI::RFC2396_Parser","","Bundler/URI/RFC2396_Parser.html","","<p>Class that parses String&#39;s into Bundler::URI&#39;s.\n<p>It contains a Hash set of patterns and Regexp&#39;s …\n"],["Bundler::URI::RFC2396_REGEXP","","Bundler/URI/RFC2396_REGEXP.html","","<p>Includes Bundler::URI::REGEXP::PATTERN\n"],["Bundler::URI::RFC2396_REGEXP::PATTERN","","Bundler/URI/RFC2396_REGEXP/PATTERN.html","","<p>Patterns used to parse Bundler::URI&#39;s\n"],["Bundler::URICredentialsFilter","","Bundler/URICredentialsFilter.html","",""],["Bundler::VersionConflict","","Bundler/VersionConflict.html","","<p>Internal error, should be rescued\n"],["Bundler::VersionRanges","","Bundler/VersionRanges.html","",""],["Bundler::VersionRanges::ReqR","","Bundler/VersionRanges/ReqR.html","",""],["Bundler::VirtualProtocolError","","Bundler/VirtualProtocolError.html","",""],["Bundler::Worker","","Bundler/Worker.html","",""],["Bundler::Worker::WrappedException","","Bundler/Worker/WrappedException.html","",""],["Bundler::YAMLSerializer","","Bundler/YAMLSerializer.html","","<p>A stub yaml serializer that can handle only hashes and strings (as of now).\n"],["Bundler::YamlLibrarySyntaxError","","Psych/SyntaxError.html","",""],["Bundler::YamlSyntaxError","","Bundler/YamlSyntaxError.html","",""],["CGI","","CGI.html","","<p>Overview\n<p>The Common Gateway Interface (CGI) is a simple protocol for passing an HTTP request from a web …\n"],["CGI::Cookie","","CGI/Cookie.html","","<p>Class representing an HTTP cookie.\n<p>In addition to its specific fields and methods, a Cookie instance is …\n"],["CGI::HTML3","","CGI/HTML3.html","",""],["CGI::HTML4","","CGI/HTML4.html","",""],["CGI::HTML4Fr","","CGI/HTML4Fr.html","",""],["CGI::HTML4Tr","","CGI/HTML4Tr.html","",""],["CGI::HTML5","","CGI/HTML5.html","",""],["CGI::HtmlExtension","","CGI/HtmlExtension.html","","<p>Mixin module providing HTML generation methods.\n<p>For example,\n\n<pre>cgi.a(&quot;http://www.example.com&quot;) { &quot;Example&quot; ...</pre>\n"],["CGI::InvalidEncoding","","CGI/InvalidEncoding.html","","<p>Exception raised when there is an invalid encoding detected\n"],["CGI::QueryExtension","","CGI/QueryExtension.html","","<p>Mixin module that provides the following:\n<p>Access to the CGI environment variables as methods.  See documentation …\n"],["CGI::Session","","CGI/Session.html","","<p>Overview\n<p>This file provides the CGI::Session class, which provides session support for CGI scripts.   …\n"],["CGI::Session::FileStore","","CGI/Session/FileStore.html","","<p>File-based session storage class.\n<p>Implements session storage as a flat file of &#39;key=value&#39; values. …\n"],["CGI::Session::MemoryStore","","CGI/Session/MemoryStore.html","","<p>In-memory session storage class.\n<p>Implements session storage as a global in-memory hash.  Session data …\n"],["CGI::Session::NullStore","","CGI/Session/NullStore.html","","<p>Dummy session storage class.\n<p>Implements session storage place holder.  No actual storage will be done. …\n"],["CGI::Session::PStore","","CGI/Session/PStore.html","","<p>PStore-based session storage class.\n<p>This builds upon the top-level PStore class provided by the library …\n"],["CGI::Util","","CGI/Util.html","",""],["CSV","","CSV.html","","<p>This class provides a complete interface to CSV files and data. It offers tools to enable you to read …\n"],["CSV::DeleteSuffix","","CSV/DeleteSuffix.html","",""],["CSV::FieldsConverter","","CSV/FieldsConverter.html","","<p>Note: Don&#39;t use this class directly. This is an internal class.\n"],["CSV::MalformedCSVError","","CSV/MalformedCSVError.html","","<p>The error thrown when the parser encounters illegal CSV formatting.\n"],["CSV::MatchP","","CSV/MatchP.html","",""],["CSV::Parser","","CSV/Parser.html","","<p>Note: Don&#39;t use this class directly. This is an internal class.\n"],["CSV::Parser::InputsScanner","","CSV/Parser/InputsScanner.html","","<p>CSV::InputsScanner receives IO inputs, encoding and the chunk_size. It also controls the life cycle of …\n"],["CSV::Parser::InvalidEncoding","","CSV/Parser/InvalidEncoding.html","","<p>Raised when encoding is invalid.\n"],["CSV::Parser::Scanner","","CSV/Parser/Scanner.html","","<p>CSV::Scanner receives a CSV output, scans it and return the content. It also controls the life cycle …\n"],["CSV::Parser::UnoptimizedStringIO","","CSV/Parser/UnoptimizedStringIO.html","",""],["CSV::Row","","CSV/Row.html","","<p>A CSV::Row is part Array and part Hash. It retains an order for the fields and allows duplicates just …\n"],["CSV::Table","","CSV/Table.html","","<p>A CSV::Table is a two-dimensional data structure for representing CSV documents. Tables allow you to …\n"],["CSV::Writer","","CSV/Writer.html","","<p>Note: Don&#39;t use this class directly. This is an internal class.\n"],["Class","","Class.html","","<p>Extends any Class to include <em>json_creatable?</em> method.\n<p>Classes in Ruby are first-class objects—each is …\n"],["ClosedQueueError","","ClosedQueueError.html","","<p>The exception class which will be raised when pushing into a closed Queue.  See Queue#close and SizedQueue#close …\n"],["Comparable","","Comparable.html","","<p>The Comparable mixin is used by classes whose objects may be ordered. The class must define the <code>&lt;=&gt;</code> …\n"],["Complex","","Complex.html","","<p>A complex number can be represented as a paired real number with imaginary unit; a+bi.  Where a is real …\n"],["ConditionVariable","","ConditionVariable.html","","<p>ConditionVariable objects augment class Mutex. Using condition variables, it is possible to suspend while …\n"],["Continuation","","Continuation.html","","<p>Continuation objects are generated by Kernel#callcc, after having +require+d <em>continuation</em>. They hold …\n"],["Coverage","","Coverage.html","","<p>Coverage provides coverage measurement feature for Ruby. This feature is experimental, so these APIs …\n"],["DBM","","DBM.html","","<p>Introduction\n<p>The DBM class provides a wrapper to a Unix-style dbm or Database Manager library.\n<p>Dbm databases …\n"],["DBMError","","DBMError.html","","<p>Exception class used to return errors from the dbm library.\n"],["DEBUGGER__","","DEBUGGER__.html","","<p>This library provides debugging functionality to Ruby.\n<p>To add a debugger to your code, start by requiring …\n"],["DRb","","DRb.html","","<p>Overview\n<p>dRuby is a distributed object system for Ruby.  It is written in pure Ruby and uses its own protocol. …\n"],["DRb::DRbArray","","DRb/DRbArray.html","","<p>An Array wrapper that can be sent to another server via DRb.\n<p>All entries in the array will be dumped or …\n"],["DRb::DRbBadScheme","","DRb/DRbBadScheme.html","","<p>Error raised by a dRuby protocol when it doesn&#39;t support the scheme specified in a URI.  See DRb::DRbProtocol …\n"],["DRb::DRbBadURI","","DRb/DRbBadURI.html","","<p>Error raised by the DRbProtocol module when it cannot find any protocol implementation support the scheme …\n"],["DRb::DRbConn","","DRb/DRbConn.html","","<p>Class handling the connection between a DRbObject and the server the real object lives on.\n<p>This class …\n"],["DRb::DRbConnError","","DRb/DRbConnError.html","","<p>Error raised when an error occurs on the underlying communication protocol.\n"],["DRb::DRbError","","DRb/DRbError.html","","<p>Superclass of all errors raised in the DRb module.\n"],["DRb::DRbIdConv","","DRb/DRbIdConv.html","","<p>Class responsible for converting between an object and its id.\n<p>This, the default implementation, uses …\n"],["DRb::DRbIdConv","","DRb/DRbIdConv.html","","<p>Class responsible for converting between an object and its id.\n<p>This, the default implementation, uses …\n"],["DRb::DRbMessage","","DRb/DRbMessage.html","","<p>Handler for sending and receiving drb messages.\n<p>This takes care of the low-level marshalling and unmarshalling …\n"],["DRb::DRbObject","","DRb/DRbObject.html","","<p>Object wrapping a reference to a remote drb object.\n<p>Method calls on this object are relayed to the remote …\n"],["DRb::DRbObject","","DRb/DRbObject.html","","<p>Object wrapping a reference to a remote drb object.\n<p>Method calls on this object are relayed to the remote …\n"],["DRb::DRbObservable","","DRb/DRbObservable.html","","<p>The Observable module extended to DRb.  See Observable for details.\n"],["DRb::DRbProtocol","","DRb/DRbProtocol.html","","<p>Module managing the underlying network protocol(s) used by drb.\n<p>By default, drb uses the DRbTCPSocket …\n"],["DRb::DRbRemoteError","","DRb/DRbRemoteError.html","","<p>An exception wrapping an error object\n"],["DRb::DRbSSLSocket","","DRb/DRbSSLSocket.html","","<p>The protocol for DRb over an SSL socket\n<p>The URI for a DRb socket over SSL is: <code>drbssl://&lt;host&gt;:&lt;port&gt;?&lt;option&gt;</code> …\n"],["DRb::DRbSSLSocket::SSLConfig","","DRb/DRbSSLSocket/SSLConfig.html","","<p>SSLConfig handles the needed SSL information for establishing a DRbSSLSocket connection, including generating …\n"],["DRb::DRbServer","","DRb/DRbServer.html","","<p>Class representing a drb server instance.\n<p>A DRbServer must be running in the local process before any …\n"],["DRb::DRbServer::InvokeMethod18Mixin","","DRb/DRbServer/InvokeMethod18Mixin.html","",""],["DRb::DRbServerNotFound","","DRb/DRbServerNotFound.html","","<p>Error raised by the DRb module when an attempt is made to refer to the context&#39;s current drb server …\n"],["DRb::DRbTCPSocket","","DRb/DRbTCPSocket.html","","<p>The default drb protocol which communicates over a TCP socket.\n<p>The DRb TCP protocol URI looks like: <code>druby://&lt;host&gt;:&lt;port&gt;?&lt;option&gt;</code> …\n"],["DRb::DRbUNIXSocket","","DRb/DRbUNIXSocket.html","","<p>Implements DRb over a UNIX socket\n<p>DRb UNIX socket URIs look like <code>drbunix:&lt;path&gt;?&lt;option&gt;</code>. …\n"],["DRb::DRbUndumped","","DRb/DRbUndumped.html","","<p>Mixin module making an object undumpable or unmarshallable.\n<p>If an object which includes this module is …\n"],["DRb::DRbUndumped","","DRb/DRbUndumped.html","","<p>Mixin module making an object undumpable or unmarshallable.\n<p>If an object which includes this module is …\n"],["DRb::DRbUnknown","","DRb/DRbUnknown.html","","<p>Class wrapping a marshalled object whose type is unknown locally.\n<p>If an object is returned by a method …\n"],["DRb::DRbUnknownError","","DRb/DRbUnknownError.html","","<p>An exception wrapping a DRb::DRbUnknown object\n"],["DRb::ExtServ","","DRb/ExtServ.html","",""],["DRb::ExtServManager","","DRb/ExtServManager.html","",""],["DRb::GW","","DRb/GW.html","","<p>The GW provides a synchronized store for participants in the gateway to communicate.\n"],["DRb::GWIdConv","","DRb/GWIdConv.html","","<p>Gateway id conversion forms a gateway between different DRb protocols or networks.\n<p>The gateway needs to …\n"],["DRb::ThreadObject","","DRb/ThreadObject.html","",""],["DRb::TimerIdConv","","DRb/TimerIdConv.html","","<p>Timer id conversion keeps objects alive for a certain amount of time after their last access.  The default …\n"],["DRb::TimerIdConv::TimerHolder2","","DRb/TimerIdConv/TimerHolder2.html","",""],["DRb::TimerIdConv::TimerHolder2::InvalidIndexError","","DRb/TimerIdConv/TimerHolder2/InvalidIndexError.html","",""],["DRb::WeakIdConv","","DRb/WeakIdConv.html","","<p>To use WeakIdConv:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DRb</span>.<span class=\"ruby-identifier\">start_service</span>(<span class=\"ruby-keyword\">nil</span>, <span class=\"ruby-keyword\">nil</span>, {<span class=\"ruby-value\">:idconv</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-constant\">DRb</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">WeakIdConv</span>.<span class=\"ruby-identifier\">new</span>})\n</pre>\n"],["DRb::WeakIdConv::WeakSet","","DRb/WeakIdConv/WeakSet.html","",""],["Data","","Data.html","","<p>This is a deprecated class, base class for C extensions using Data_Make_Struct or Data_Wrap_Struct.\n"],["Date","","Date.html","","<p>date and datetime class - Tadayoshi Funaba 1998-2011\n<p>&#39;date&#39; provides two classes: Date and DateTime …\n"],["Date::Error","","Date/Error.html","",""],["DateTime","","DateTime.html","","<p>DateTime\n<p>A subclass of Date that easily handles date, hour, minute, second, and offset.\n<p>DateTime does not …\n"],["Delegator","","Delegator.html","","<p>This library provides three different ways to delegate method calls to an object.  The easiest to use …\n"],["DidYouMean","","DidYouMean.html","","<p>The <code>DidYouMean</code> gem adds functionality to suggest possible method/class names upon errors such as <code>NameError</code> …\n"],["Digest","","Digest.html","","<p>This module provides a framework for message digest libraries.\n<p>You may want to look at OpenSSL::Digest …\n"],["Digest::Base","","Digest/Base.html","","<p>This abstract class provides a common interface to message digest implementation classes written in  …\n"],["Digest::Class","","Digest/Class.html","","<p>This module stands as a base class for digest implementation classes.\n"],["Digest::Instance","","Digest/Instance.html","","<p>This module provides instance methods for a digest implementation object to calculate message digest …\n"],["Digest::MD5","","Digest/MD5.html","","<p>A class for calculating message digests using the MD5 Message-Digest Algorithm by RSA Data Security, …\n"],["Digest::RMD160","","Digest/RMD160.html","","<p>A class for calculating message digests using RIPEMD-160 cryptographic hash function, designed by Hans …\n"],["Digest::SHA1","","Digest/SHA1.html","","<p>A class for calculating message digests using the SHA-1 Secure Hash Algorithm by NIST (the US&#39; National …\n"],["Dir","","Dir.html","","<p>Objects of class Dir are directory streams representing directories in the underlying file system. They …\n"],["ENV","","ENV.html","","<p>ENV is a hash-like accessor for environment variables.\n<p>Interaction with the Operating System\n<p>The ENV object …\n"],["EOFError","","EOFError.html","","<p>Raised by some IO operations when reaching the end of file. Many IO methods exist in two forms,\n<p>one that …\n"],["ERB","","ERB.html","","<p>ERB – Ruby Templating\n<p>Introduction\n<p>ERB provides an easy to use but powerful templating system for Ruby …\n"],["ERB::DefMethod","","ERB/DefMethod.html","","<p>Utility module to define eRuby script as instance method.\n<p>Example\n<p>example.rhtml:\n"],["ERB::Util","","ERB/Util.html","","<p>A utility module for conversion routines, often handy in HTML generation.\n"],["EXCEPTION_TYPE","","EXCEPTION_TYPE.html","",""],["EXCEPTION_TYPE","","EXCEPTION_TYPE.html","",""],["EXCEPTION_TYPE","","EXCEPTION_TYPE.html","",""],["EXCEPTION_TYPE","","EXCEPTION_TYPE.html","",""],["Encoding","","Encoding.html","","<p>An Encoding instance represents a character encoding usable in Ruby. It is defined as a constant under …\n"],["Encoding::CompatibilityError","","Encoding/CompatibilityError.html","","<p>Raised by Encoding and String methods when the source encoding is incompatible with the target encoding. …\n"],["Encoding::Converter","","Encoding/Converter.html","","<p>Encoding conversion class.\n"],["Encoding::ConverterNotFoundError","","Encoding/ConverterNotFoundError.html","","<p>Raised by transcoding methods when a named encoding does not correspond with a known converter.\n"],["Encoding::InvalidByteSequenceError","","Encoding/InvalidByteSequenceError.html","","<p>Raised by Encoding and String methods when the string being transcoded contains a byte invalid for the …\n"],["Encoding::UndefinedConversionError","","Encoding/UndefinedConversionError.html","","<p>Raised by Encoding and String methods when a transcoding operation fails.\n"],["EncodingError","","EncodingError.html","","<p>EncodingError is the base class for encoding errors.\n"],["English","","English.html","","<p>Include the English library file in a Ruby script, and you can reference the global variables such as …\n"],["Enumerable","","Enumerable.html","","<p>The Enumerable mixin provides collection classes with several traversal and searching methods, and with …\n"],["Enumerator","","Enumerator.html","","<p>A class which allows both internal and external iteration.\n<p>An Enumerator can be created by the following …\n"],["Enumerator::ArithmeticSequence","","Enumerator/ArithmeticSequence.html","","<p>Enumerator::ArithmeticSequence is a subclass of Enumerator, that is a representation of sequences of …\n"],["Enumerator::Chain","","Enumerator/Chain.html","","<p>Enumerator::Chain is a subclass of Enumerator, which represents a chain of enumerables that works as …\n"],["Enumerator::Generator","","Enumerator/Generator.html","","<p>Generator\n"],["Enumerator::Lazy","","Enumerator/Lazy.html","","<p>Enumerator::Lazy is a special type of Enumerator, that allows constructing chains of operations without …\n"],["Enumerator::Producer","","Enumerator/Producer.html","","<p>Producer\n"],["Enumerator::Yielder","","Enumerator/Yielder.html","","<p>Yielder\n"],["Errno","","Errno.html","","<p>Ruby exception objects are subclasses of Exception.  However, operating systems typically report errors …\n"],["Errno::ECONNABORTED","","Errno/ECONNABORTED.html","","<p>Client sent TCP reset (RST) before server has accepted the connection requested by client.\n"],["Errno::ECONNRESET","","Errno/ECONNRESET.html","","<p>Remote host reset the connection request.\n"],["Errno::EPROTO","","Errno/EPROTO.html","","<p>Protocol error.\n"],["Error","","Error.html","","<p>Bundler::Thor::Error is raised when it&#39;s caused by wrong usage of thor classes. Those errors have …\n"],["Etc","","Etc.html","","<p>The Etc module provides access to information typically stored in files in the /etc directory on Unix …\n"],["Exception","","Exception.html","","<p>Class Exception and its subclasses are used to communicate between Kernel#raise and <code>rescue</code> statements …\n"],["ExceptionForMatrix","","ExceptionForMatrix.html","",""],["ExceptionForMatrix::ErrDimensionMismatch","","ExceptionForMatrix/ErrDimensionMismatch.html","",""],["ExceptionForMatrix::ErrNotRegular","","ExceptionForMatrix/ErrNotRegular.html","",""],["ExceptionForMatrix::ErrOperationNotDefined","","ExceptionForMatrix/ErrOperationNotDefined.html","",""],["ExceptionForMatrix::ErrOperationNotImplemented","","ExceptionForMatrix/ErrOperationNotImplemented.html","",""],["FalseClass","","FalseClass.html","","<p>The global value <code>false</code> is the only instance of class FalseClass and represents a logically false value …\n"],["Fcntl","","Fcntl.html","","<p>Fcntl loads the constants defined in the system&#39;s &lt;fcntl.h&gt; C header file, and used with both …\n"],["Fiber","","Fiber.html","","<p>Fibers are primitives for implementing light weight cooperative concurrency in Ruby. Basically they are …\n"],["FiberError","","FiberError.html","","<p>Raised when an invalid operation is attempted on a Fiber, in particular when attempting to call/resume …\n"],["Fiddle","","Fiddle.html","","<p>A libffi wrapper for Ruby.\n<p>Description\n<p>Fiddle is an extension to translate a foreign function interface …\n"],["Fiddle::BasicTypes","","Fiddle/BasicTypes.html","","<p>Adds basic type aliases to the including class for use with Fiddle::Importer.\n<p>The aliases added are <code>uint</code> …\n"],["Fiddle::CParser","","Fiddle/CParser.html","","<p>A mixin that provides methods for parsing C struct and prototype signatures.\n<p>Example\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;fiddle/import&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Fiddle::CStruct","","Fiddle/CStruct.html","","<p>C struct shell\n"],["Fiddle::CStructBuilder","","Fiddle/CStructBuilder.html","","<p>Used to construct C classes (CUnion, CStruct, etc)\n<p>Fiddle::Importer#struct and Fiddle::Importer#union …\n"],["Fiddle::CStructEntity","","Fiddle/CStructEntity.html","","<p>A C struct wrapper\n"],["Fiddle::CUnion","","Fiddle/CUnion.html","","<p>C union shell\n"],["Fiddle::CUnionEntity","","Fiddle/CUnionEntity.html","","<p>A C union wrapper\n"],["Fiddle::Closure","","Fiddle/Closure.html","","<p>Description\n<p>An FFI closure wrapper, for handling callbacks.\n<p>Example\n"],["Fiddle::Closure::BlockCaller","","Fiddle/Closure/BlockCaller.html","","<p>Extends Fiddle::Closure to allow for building the closure in a block\n"],["Fiddle::CompositeHandler","","Fiddle/CompositeHandler.html","","<p>Used internally by Fiddle::Importer\n"],["Fiddle::DLError","","Fiddle/DLError.html","","<p>standard dynamic load exception\n"],["Fiddle::Function","","Fiddle/Function.html","","<p>Description\n<p>A representation of a C function\n<p>Examples\n"],["Fiddle::Handle","","Fiddle/Handle.html","","<p>The Fiddle::Handle is the manner to access the dynamic library\n<p>Example\n<p>Setup\n"],["Fiddle::Importer","","Fiddle/Importer.html","","<p>A DSL that provides the means to dynamically load libraries and build modules around them including calling …\n"],["Fiddle::Pointer","","Fiddle/Pointer.html","","<p>Fiddle::Pointer is a class to handle C pointers\n"],["Fiddle::Win32Types","","Fiddle/Win32Types.html","","<p>Adds Windows type aliases to the including class for use with Fiddle::Importer.\n<p>The aliases added are: …\n"],["File","","File.html","","<p>A File is an abstraction of any file object accessible by the program and is closely associated with …\n"],["File::File::Constants","","File/File/Constants.html","","<p>Document-module: File::Constants\n<p>File::Constants provides file-related constants.  All possible file constants …\n"],["File::Stat","","File/Stat.html","","<p>Objects of class File::Stat encapsulate common status information for File objects. The information is …\n"],["FileTest","","FileTest.html","","<p>FileTest implements file test operations similar to those used in File::Stat. It exists as a standalone …\n"],["FileUtils","","FileUtils.html","","<p>fileutils.rb\n<p>Copyright © 2000-2007 Minero Aoki\n<p>This program is free software. You can distribute/modify …\n"],["FileUtils::DryRun","","FileUtils/DryRun.html","","<p>This module has all methods of FileUtils module, but never changes files/directories, with printing message …\n"],["FileUtils::NoWrite","","FileUtils/NoWrite.html","","<p>This module has all methods of FileUtils module, but never changes files/directories.  This equates to …\n"],["FileUtils::StreamUtils_","","FileUtils/StreamUtils_.html","",""],["FileUtils::Verbose","","FileUtils/Verbose.html","","<p>This module has all methods of FileUtils module, but it outputs messages before acting.  This equates …\n"],["Find","","Find.html","","<p>The <code>Find</code> module supports the top-down traversal of a set of file paths.\n<p>For example, to total the size …\n"],["Float","","Float.html","","<p>Float objects represent inexact real numbers using the native architecture&#39;s double-precision floating …\n"],["FloatDomainError","","FloatDomainError.html","","<p>Raised when attempting to convert special float values (in particular <code>Infinity</code> or <code>NaN</code>) to numerical classes …\n"],["Forwardable","","Forwardable.html","","<p>The Forwardable module provides delegation of specified methods to a designated object, using the methods …\n"],["FrozenError","","FrozenError.html","","<p>Raised when there is an attempt to modify a frozen object.\n\n<pre class=\"ruby\">[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>].<span class=\"ruby-identifier\">freeze</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value\">4</span>\n</pre>\n<p><em>raises the exception:</em> …\n"],["GC","","GC.html","","<p>The GC module provides an interface to Ruby&#39;s mark and sweep garbage collection mechanism.\n<p>Some of …\n"],["GC::Profiler","","GC/Profiler.html","","<p>The GC profiler provides access to information on GC runs including time, length and object space size. …\n"],["GDBM","","GDBM.html","","<p>Summary\n<p>Ruby extension for GNU dbm (gdbm) – a simple database engine for storing key-value pairs on disk. …\n"],["GDBMError","","GDBMError.html","",""],["GDBMFatalError","","GDBMFatalError.html","",""],["Gem","","Gem.html","","<p>RubyGems is the Ruby standard for publishing and managing third party libraries.\n<p>For user documentation, …\n"],["Gem::AvailableSet","","Gem/AvailableSet.html","",""],["Gem::BasicSpecification","","Gem/BasicSpecification.html","","<p>BasicSpecification is an abstract class which implements some common code used by both Specification …\n"],["Gem::BundlerVersionFinder","","Gem/BundlerVersionFinder.html","",""],["Gem::Command","","Gem/Command.html","","<p>Base class for all Gem commands.  When creating a new gem command, define #initialize, #execute, #arguments …\n"],["Gem::CommandLineError","","Gem/CommandLineError.html","",""],["Gem::CommandManager","","Gem/CommandManager.html","","<p>The command manager registers and installs all the individual sub-commands supported by the gem command. …\n"],["Gem::Commands","","Gem/Commands.html","","<p>Commands will be placed in this namespace\n"],["Gem::Commands::BuildCommand","","Gem/Commands/BuildCommand.html","",""],["Gem::Commands::CertCommand","","Gem/Commands/CertCommand.html","",""],["Gem::Commands::CheckCommand","","Gem/Commands/CheckCommand.html","",""],["Gem::Commands::CleanupCommand","","Gem/Commands/CleanupCommand.html","",""],["Gem::Commands::ContentsCommand","","Gem/Commands/ContentsCommand.html","",""],["Gem::Commands::DependencyCommand","","Gem/Commands/DependencyCommand.html","",""],["Gem::Commands::EnvironmentCommand","","Gem/Commands/EnvironmentCommand.html","",""],["Gem::Commands::FetchCommand","","Gem/Commands/FetchCommand.html","",""],["Gem::Commands::GenerateIndexCommand","","Gem/Commands/GenerateIndexCommand.html","","<p>Generates a index files for use as a gem server.\n<p>See `gem help generate_index`\n"],["Gem::Commands::HelpCommand","","Gem/Commands/HelpCommand.html","",""],["Gem::Commands::InfoCommand","","Gem/Commands/InfoCommand.html","",""],["Gem::Commands::InstallCommand","","Gem/Commands/InstallCommand.html","","<p>Gem installer command line tool\n<p>See `gem help install`\n"],["Gem::Commands::ListCommand","","Gem/Commands/ListCommand.html","","<p>An alternate to Gem::Commands::QueryCommand that searches for gems starting with the supplied argument. …\n"],["Gem::Commands::LockCommand","","Gem/Commands/LockCommand.html","",""],["Gem::Commands::MirrorCommand","","Gem/Commands/MirrorCommand.html","",""],["Gem::Commands::OpenCommand","","Gem/Commands/OpenCommand.html","",""],["Gem::Commands::OutdatedCommand","","Gem/Commands/OutdatedCommand.html","",""],["Gem::Commands::OwnerCommand","","Gem/Commands/OwnerCommand.html","",""],["Gem::Commands::PristineCommand","","Gem/Commands/PristineCommand.html","",""],["Gem::Commands::PushCommand","","Gem/Commands/PushCommand.html","",""],["Gem::Commands::QueryCommand","","Gem/Commands/QueryCommand.html","",""],["Gem::Commands::RdocCommand","","Gem/Commands/RdocCommand.html","",""],["Gem::Commands::SearchCommand","","Gem/Commands/SearchCommand.html","",""],["Gem::Commands::ServerCommand","","Gem/Commands/ServerCommand.html","",""],["Gem::Commands::SetupCommand","","Gem/Commands/SetupCommand.html","","<p>Installs RubyGems itself.  This command is ordinarily only available from a RubyGems checkout or tarball. …\n"],["Gem::Commands::SetupCommand::MakeDirs","","Gem/Commands/SetupCommand/MakeDirs.html","",""],["Gem::Commands::SigninCommand","","Gem/Commands/SigninCommand.html","",""],["Gem::Commands::SignoutCommand","","Gem/Commands/SignoutCommand.html","",""],["Gem::Commands::SourcesCommand","","Gem/Commands/SourcesCommand.html","",""],["Gem::Commands::SpecificationCommand","","Gem/Commands/SpecificationCommand.html","",""],["Gem::Commands::StaleCommand","","Gem/Commands/StaleCommand.html","",""],["Gem::Commands::UninstallCommand","","Gem/Commands/UninstallCommand.html","","<p>Gem uninstaller command line tool\n<p>See `gem help uninstall`\n"],["Gem::Commands::UnpackCommand","","Gem/Commands/UnpackCommand.html","",""],["Gem::Commands::UpdateCommand","","Gem/Commands/UpdateCommand.html","",""],["Gem::Commands::WhichCommand","","Gem/Commands/WhichCommand.html","",""],["Gem::Commands::YankCommand","","Gem/Commands/YankCommand.html","",""],["Gem::ConfigFile","","Gem/ConfigFile.html","","<p>Gem::ConfigFile RubyGems options and gem command options from gemrc.\n<p>gemrc is a YAML file that uses strings …\n"],["Gem::ConflictError","","Gem/ConflictError.html","","<p>Raised when there are conflicting gem specs loaded\n"],["Gem::ConsoleUI","","Gem/ConsoleUI.html","","<p>Subclass of StreamUI that instantiates the user interaction using STDIN, STDOUT, and STDERR.\n"],["Gem::DefaultUserInteraction","","Gem/DefaultUserInteraction.html","","<p>When rubygems/test_case is required the default user interaction is a MockGemUi.\n<p>Module that defines the …\n"],["Gem::Dependency","","Gem/Dependency.html","",""],["Gem::DependencyError","","Gem/DependencyError.html","",""],["Gem::DependencyInstaller","","Gem/DependencyInstaller.html","","<p>Installs a gem along with all its dependencies from local and remote gems.\n"],["Gem::DependencyList","","Gem/DependencyList.html","","<p>Gem::DependencyList is used for installing and uninstalling gems in the correct order to avoid conflicts. …\n"],["Gem::DependencyRemovalException","","Gem/DependencyRemovalException.html","",""],["Gem::DependencyResolutionError","","Gem/DependencyResolutionError.html","","<p>Raised by Gem::Resolver when a Gem::Dependency::Conflict reaches the toplevel.  Indicates which dependencies …\n"],["Gem::Deprecate","","Gem/Deprecate.html","","<p>Provides a single method <code>deprecate</code> to be used to declare when something is going away.\n\n<pre>class Legacy\n  ...</pre>\n"],["Gem::Doctor","","Gem/Doctor.html","","<p>Cleans up after a partially-failed uninstall or for an invalid Gem::Specification.\n<p>If a specification …\n"],["Gem::DocumentError","","Gem/DocumentError.html","",""],["Gem::EndOfYAMLException","","Gem/EndOfYAMLException.html","","<p>Potentially raised when a specification is validated.\n"],["Gem::ErrorReason","","Gem/ErrorReason.html","",""],["Gem::Exception","","Gem/Exception.html","","<p>Base exception class for RubyGems.  All exception raised by RubyGems are a subclass of this one.\n"],["Gem::Ext","","Gem/Ext.html","","<p>Classes for building C extensions live here.\n"],["Gem::Ext::BuildError","","Gem/Ext/BuildError.html","","<p>Raised when there is an error while building extensions.\n"],["Gem::Ext::Builder","","Gem/Ext/Builder.html","",""],["Gem::Ext::CmakeBuilder","","Gem/Ext/CmakeBuilder.html","",""],["Gem::Ext::ConfigureBuilder","","Gem/Ext/ConfigureBuilder.html","",""],["Gem::Ext::ExtConfBuilder","","Gem/Ext/ExtConfBuilder.html","",""],["Gem::Ext::RakeBuilder","","Gem/Ext/RakeBuilder.html","",""],["Gem::FakeFetcher","","Gem/FakeFetcher.html","","<p>A fake Gem::RemoteFetcher for use in tests or to avoid real live HTTP requests when testing code that …\n"],["Gem::FilePermissionError","","Gem/FilePermissionError.html","","<p>Signals that a file permission error is preventing the user from operating on the given directory.\n"],["Gem::FormatException","","Gem/FormatException.html","","<p>Used to raise parsing and loading errors\n"],["Gem::GemNotFoundException","","Gem/GemNotFoundException.html","",""],["Gem::GemNotInHomeException","","Gem/GemNotInHomeException.html","","<p>Raised when attempting to uninstall a gem that isn&#39;t in GEM_HOME.\n"],["Gem::GemRunner","","Gem/GemRunner.html","","<p>Run an instance of the gem program.\n<p>Gem::GemRunner is only intended for internal use by RubyGems itself. …\n"],["Gem::GemcutterUtilities","","Gem/GemcutterUtilities.html","","<p>Utility methods for using the RubyGems API.\n"],["Gem::ImpossibleDependenciesError","","Gem/ImpossibleDependenciesError.html","","<p>Raised by Gem::Resolver when dependencies conflict and create the inability to find a valid possible …\n"],["Gem::Indexer","","Gem/Indexer.html","","<p>Top level class for building the gem repository index.\n"],["Gem::InstallError","","Gem/InstallError.html","",""],["Gem::InstallUpdateOptions","","Gem/InstallUpdateOptions.html","","<p>Mixin methods for install and update options for Gem::Commands\n"],["Gem::Installer","","Gem/Installer.html","","<p>The installer installs the files contained in the .gem into the Gem.home.\n<p>Gem::Installer does the work …\n"],["Gem::Installer::FakePackage","","Gem/Installer/FakePackage.html","",""],["Gem::InstallerTestCase","","Gem/InstallerTestCase.html","","<p>A test case for Gem::Installer.\n"],["Gem::InvalidSpecificationException","","Gem/InvalidSpecificationException.html","","<p>Potentially raised when a specification is validated.\n"],["Gem::Licenses","","Gem/Licenses.html","",""],["Gem::List","","Gem/List.html","",""],["Gem::LoadError","","Gem/LoadError.html","","<p>Raised when RubyGems is unable to load or activate a gem.  Contains the name and version requirements …\n"],["Gem::LocalRemoteOptions","","Gem/LocalRemoteOptions.html","","<p>Mixin methods for local and remote Gem::Command options.\n"],["Gem::MissingSpecError","","Gem/MissingSpecError.html","","<p>Raised when trying to activate a gem, and that gem does not exist on the system.  Instead of rescuing …\n"],["Gem::MissingSpecVersionError","","Gem/MissingSpecVersionError.html","","<p>Raised when trying to activate a gem, and the gem exists on the system, but not the requested version. …\n"],["Gem::MockGemUi","","Gem/MockGemUi.html","","<p>This Gem::StreamUI subclass records input and output to StringIO for retrieval during tests.\n"],["Gem::MockGemUi::InputEOFError","","Gem/MockGemUi/InputEOFError.html","","<p>Raised when you haven&#39;t provided enough input to your MockGemUi\n"],["Gem::MockGemUi::SystemExitException","","Gem/MockGemUi/SystemExitException.html","",""],["Gem::MockGemUi::TTY","","Gem/MockGemUi/TTY.html","",""],["Gem::MockGemUi::TermError","","Gem/MockGemUi/TermError.html","",""],["Gem::NameTuple","","Gem/NameTuple.html","",""],["Gem::NoAliasYAMLTree","","Gem/NoAliasYAMLTree.html","",""],["Gem::OperationNotSupportedError","","Gem/OperationNotSupportedError.html","",""],["Gem::Package","","Gem/Package.html","",""],["Gem::Package::DigestIO","","Gem/Package/DigestIO.html","","<p>IO wrapper that creates digests of contents written to the IO it wraps.\n"],["Gem::Package::Error","","Gem/Package/Error.html","",""],["Gem::Package::FormatError","","Gem/Package/FormatError.html","",""],["Gem::Package::NonSeekableIO","","Gem/Package/NonSeekableIO.html","",""],["Gem::Package::Old","","Gem/Package/Old.html","","<p>The format class knows the guts of the ancient .gem file format and provides the capability to read such …\n"],["Gem::Package::PathError","","Gem/Package/PathError.html","",""],["Gem::Package::TarHeader","","Gem/Package/TarHeader.html","","<p>A header for a tar file\n"],["Gem::Package::TarInvalidError","","Gem/Package/TarInvalidError.html","","<p>Raised when a tar file is corrupt\n"],["Gem::Package::TarReader","","Gem/Package/TarReader.html","","<p>TarReader reads tar files and allows iteration over their items\n"],["Gem::Package::TarReader::Entry","","Gem/Package/TarReader/Entry.html","","<p>Class for reading entries out of a tar file\n"],["Gem::Package::TarReader::UnexpectedEOF","","Gem/Package/TarReader/UnexpectedEOF.html","","<p>Raised if the tar IO is not seekable\n"],["Gem::Package::TarTestCase","","Gem/Package/TarTestCase.html","","<p>A test case for Gem::Package::Tar* classes\n"],["Gem::Package::TarWriter","","Gem/Package/TarWriter.html","","<p>Allows writing of tar files\n"],["Gem::Package::TarWriter::BoundedStream","","Gem/Package/TarWriter/BoundedStream.html","","<p>IO wrapper that allows writing a limited amount of data\n"],["Gem::Package::TarWriter::FileOverflow","","Gem/Package/TarWriter/FileOverflow.html","",""],["Gem::Package::TarWriter::RestrictedStream","","Gem/Package/TarWriter/RestrictedStream.html","","<p>IO wrapper that provides only #write\n"],["Gem::Package::TooLongFileName","","Gem/Package/TooLongFileName.html","",""],["Gem::PackageTask","","Gem/PackageTask.html","","<p>Create a package based upon a Gem::Specification.  Gem packages, as well as zip files and tar/gzipped …\n"],["Gem::PathSupport","","Gem/PathSupport.html","","<p>Gem::PathSupport facilitates the GEM_HOME and GEM_PATH environment settings to the rest of RubyGems. …\n"],["Gem::Platform","","Gem/Platform.html","","<p>Available list of platforms for targeting Gem installations.\n<p>See `gem help platform` for information on …\n"],["Gem::PlatformMismatch","","Gem/PlatformMismatch.html","","<p>Generated when trying to lookup a gem to indicate that the gem was found, but that it isn&#39;t usable …\n"],["Gem::RemoteError","","Gem/RemoteError.html","","<p>Signals that a remote operation cannot be conducted, probably due to not being connected (or just not …\n"],["Gem::RemoteFetcher","","Gem/RemoteFetcher.html","","<p>RemoteFetcher handles the details of fetching gems and gem information from a remote source.\n"],["Gem::RemoteFetcher::FetchError","","Gem/RemoteFetcher/FetchError.html","","<p>A FetchError exception wraps up the various possible IO and HTTP failures that could happen while downloading …\n"],["Gem::RemoteFetcher::UnknownHostError","","Gem/RemoteFetcher/UnknownHostError.html","","<p>A FetchError that indicates that the reason for not being able to fetch data was that the host could …\n"],["Gem::RemoteInstallationCancelled","","Gem/RemoteInstallationCancelled.html","",""],["Gem::RemoteInstallationSkipped","","Gem/RemoteInstallationSkipped.html","",""],["Gem::RemoteSourceException","","Gem/RemoteSourceException.html","","<p>Represents an error communicating via HTTP.\n"],["Gem::Request","","Gem/Request.html","",""],["Gem::RequestSet","","Gem/RequestSet.html","","<p>A RequestSet groups a request to activate a set of dependencies.\n\n<pre>nokogiri = Gem::Dependency.new &#39;nokogiri&#39;, ...</pre>\n"],["Gem::RequestSet::GemDependencyAPI","","Gem/RequestSet/GemDependencyAPI.html","","<p>A semi-compatible DSL for the Bundler Gemfile and Isolate gem dependencies files.\n<p>To work with both the …\n"],["Gem::RequestSet::Lockfile","","Gem/RequestSet/Lockfile.html","","<p>Parses a gem.deps.rb.lock file and constructs a LockSet containing the dependencies found inside.  If …\n"],["Gem::RequestSet::Lockfile::ParseError","","Gem/RequestSet/Lockfile/ParseError.html","","<p>Raised when a lockfile cannot be parsed\n"],["Gem::RequestSet::Lockfile::Parser","","Gem/RequestSet/Lockfile/Parser.html","",""],["Gem::RequestSet::Lockfile::Tokenizer","","Gem/RequestSet/Lockfile/Tokenizer.html","",""],["Gem::Requirement","","Gem/Requirement.html","","<p>A Requirement is a set of one or more version restrictions. It supports a few (<code>=, !=, &gt;, &lt;, &gt;=,</code> …\n"],["Gem::Requirement::BadRequirementError","","Gem/Requirement/BadRequirementError.html","","<p>Raised when a bad requirement is encountered\n"],["Gem::Resolver","","Gem/Resolver.html","","<p>Given a set of Gem::Dependency objects as <code>needed</code> and a way to query the set of available specs via <code>set</code> …\n"],["Gem::Resolver::APISet","","Gem/Resolver/APISet.html","","<p>The global rubygems pool, available via the rubygems.org API. Returns instances of APISpecification. …\n"],["Gem::Resolver::APISpecification","","Gem/Resolver/APISpecification.html","","<p>Represents a specification retrieved via the rubygems.org API.\n<p>This is used to avoid loading the full …\n"],["Gem::Resolver::ActivationRequest","","Gem/Resolver/ActivationRequest.html","","<p>Specifies a Specification object that should be activated.  Also contains a dependency that was used …\n"],["Gem::Resolver::BestSet","","Gem/Resolver/BestSet.html","","<p>The BestSet chooses the best available method to query a remote index.\n<p>It combines IndexSet and APISet …\n"],["Gem::Resolver::ComposedSet","","Gem/Resolver/ComposedSet.html","","<p>A ComposedSet allows multiple sets to be queried like a single set.\n<p>To create a composed set with any …\n"],["Gem::Resolver::Conflict","","Gem/Resolver/Conflict.html","","<p>Used internally to indicate that a dependency conflicted with a spec that would be activated.\n"],["Gem::Resolver::CurrentSet","","Gem/Resolver/CurrentSet.html","","<p>A set which represents the installed gems. Respects all the normal settings that control where to look …\n"],["Gem::Resolver::DependencyRequest","","Gem/Resolver/DependencyRequest.html","","<p>Used Internally. Wraps a Dependency object to also track which spec contained the Dependency.\n"],["Gem::Resolver::GitSet","","Gem/Resolver/GitSet.html","","<p>A GitSet represents gems that are sourced from git repositories.\n<p>This is used for gem dependency file …\n"],["Gem::Resolver::GitSpecification","","Gem/Resolver/GitSpecification.html","","<p>A GitSpecification represents a gem that is sourced from a git repository and is being loaded through …\n"],["Gem::Resolver::IndexSet","","Gem/Resolver/IndexSet.html","","<p>The global rubygems pool represented via the traditional source index.\n"],["Gem::Resolver::IndexSpecification","","Gem/Resolver/IndexSpecification.html","","<p>Represents a possible Specification object returned from IndexSet.  Used to delay needed to download …\n"],["Gem::Resolver::InstalledSpecification","","Gem/Resolver/InstalledSpecification.html","","<p>An InstalledSpecification represents a gem that is already installed locally.\n"],["Gem::Resolver::InstallerSet","","Gem/Resolver/InstallerSet.html","","<p>A set of gems for installation sourced from remote sources and local .gem files\n"],["Gem::Resolver::LocalSpecification","","Gem/Resolver/LocalSpecification.html","","<p>A LocalSpecification comes from a .gem file on the local filesystem.\n"],["Gem::Resolver::LockSet","","Gem/Resolver/LockSet.html","","<p>A set of gems from a gem dependencies lockfile.\n"],["Gem::Resolver::LockSpecification","","Gem/Resolver/LockSpecification.html","","<p>The LockSpecification comes from a lockfile (Gem::RequestSet::Lockfile).\n<p>A LockSpecification&#39;s dependency …\n"],["Gem::Resolver::Molinillo","","Gem/Resolver/Molinillo.html","","<p>Gem::Resolver::Molinillo is a generic dependency resolution algorithm.\n"],["Gem::Resolver::Molinillo::CircularDependencyError","","Gem/Resolver/Molinillo/CircularDependencyError.html","","<p>An error caused by attempting to fulfil a dependency that was circular\n<p>@note This exception will be thrown …\n"],["Gem::Resolver::Molinillo::Delegates","","Gem/Resolver/Molinillo/Delegates.html","","<p>@!visibility private\n"],["Gem::Resolver::Molinillo::Delegates::ResolutionState","","Gem/Resolver/Molinillo/Delegates/ResolutionState.html","","<p>Delegates all {Gem::Resolver::Molinillo::ResolutionState} methods to a `#state` property.\n"],["Gem::Resolver::Molinillo::Delegates::SpecificationProvider","","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html","","<p>Delegates all {Gem::Resolver::Molinillo::SpecificationProvider} methods to a `#specification_provider` …\n"],["Gem::Resolver::Molinillo::DependencyGraph","","Gem/Resolver/Molinillo/DependencyGraph.html","","<p>A directed acyclic graph that is tuned to hold named dependencies\n"],["Gem::Resolver::Molinillo::DependencyGraph::Action","","Gem/Resolver/Molinillo/DependencyGraph/Action.html","","<p>An action that modifies a {DependencyGraph} that is reversible. @abstract\n"],["Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular","","Gem/Resolver/Molinillo/DependencyGraph/AddEdgeNoCircular.html","","<p>@!visibility private (see DependencyGraph#add_edge_no_circular)\n"],["Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge","","Gem/Resolver/Molinillo/DependencyGraph/DeleteEdge.html","","<p>@!visibility private (see DependencyGraph#delete_edge)\n"],["Gem::Resolver::Molinillo::DependencyGraph::DetachVertexNamed","","Gem/Resolver/Molinillo/DependencyGraph/DetachVertexNamed.html","","<p>@!visibility private @see DependencyGraph#detach_vertex_named\n"],["Gem::Resolver::Molinillo::DependencyGraph::Log","","Gem/Resolver/Molinillo/DependencyGraph/Log.html","","<p>A log for dependency graph actions\n"],["Gem::Resolver::Molinillo::DependencyGraph::Tag","","Gem/Resolver/Molinillo/DependencyGraph/Tag.html","","<p>@!visibility private @see DependencyGraph#tag\n"],["Gem::Resolver::Molinillo::DependencyGraph::Vertex","","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html","","<p>A vertex in a {DependencyGraph} that encapsulates a {#name} and a {#payload}\n"],["Gem::Resolver::Molinillo::DependencyState","","Gem/Resolver/Molinillo/DependencyState.html","","<p>A state that encapsulates a set of {#requirements} with an {Array} of possibilities\n"],["Gem::Resolver::Molinillo::NoSuchDependencyError","","Gem/Resolver/Molinillo/NoSuchDependencyError.html","","<p>An error caused by searching for a dependency that is completely unknown, i.e. has no versions available …\n"],["Gem::Resolver::Molinillo::PossibilityState","","Gem/Resolver/Molinillo/PossibilityState.html","","<p>A state that encapsulates a single possibility to fulfill the given {#requirement}\n"],["Gem::Resolver::Molinillo::ResolutionState","","Gem/Resolver/Molinillo/ResolutionState.html","",""],["Gem::Resolver::Molinillo::Resolver","","Gem/Resolver/Molinillo/Resolver.html","","<p>This class encapsulates a dependency resolver. The resolver is responsible for determining which set …\n"],["Gem::Resolver::Molinillo::Resolver::Resolution","","Gem/Resolver/Molinillo/Resolver/Resolution.html","","<p>A specific resolution from a given {Resolver}\n"],["Gem::Resolver::Molinillo::ResolverError","","Gem/Resolver/Molinillo/ResolverError.html","","<p>An error that occurred during the resolution process\n"],["Gem::Resolver::Molinillo::SpecificationProvider","","Gem/Resolver/Molinillo/SpecificationProvider.html","","<p>Provides information about specifcations and dependencies to the resolver, allowing the {Resolver} class …\n"],["Gem::Resolver::Molinillo::UI","","Gem/Resolver/Molinillo/UI.html","","<p>Conveys information about the resolution process to a user.\n"],["Gem::Resolver::Molinillo::VersionConflict","","Gem/Resolver/Molinillo/VersionConflict.html","","<p>An error caused by conflicts in version\n"],["Gem::Resolver::RequirementList","","Gem/Resolver/RequirementList.html","","<p>The RequirementList is used to hold the requirements being considered while resolving a set of gems. …\n"],["Gem::Resolver::Set","","Gem/Resolver/Set.html","","<p>Resolver sets are used to look up specifications (and their dependencies) used in resolution.  This set …\n"],["Gem::Resolver::SourceSet","","Gem/Resolver/SourceSet.html","","<p>The SourceSet chooses the best available method to query a remote index.\n<p>Kind off like BestSet but filters …\n"],["Gem::Resolver::SpecSpecification","","Gem/Resolver/SpecSpecification.html","","<p>The Resolver::SpecSpecification contains common functionality for Resolver specifications that are backed …\n"],["Gem::Resolver::Specification","","Gem/Resolver/Specification.html","","<p>A Resolver::Specification contains a subset of the information contained in a Gem::Specification.  Only …\n"],["Gem::Resolver::Stats","","Gem/Resolver/Stats.html","",""],["Gem::Resolver::VendorSet","","Gem/Resolver/VendorSet.html","","<p>A VendorSet represents gems that have been unpacked into a specific directory that contains a gemspec. …\n"],["Gem::Resolver::VendorSpecification","","Gem/Resolver/VendorSpecification.html","","<p>A VendorSpecification represents a gem that has been unpacked into a project and is being loaded through …\n"],["Gem::RubyVersionMismatch","","Gem/RubyVersionMismatch.html","","<p>Raised when a gem dependencies file specifies a ruby version that does not match the current version. …\n"],["Gem::RuntimeRequirementNotMetError","","Gem/RuntimeRequirementNotMetError.html","",""],["Gem::S3URISigner","","Gem/S3URISigner.html","","<p>S3URISigner implements AWS SigV4 for S3 Source to avoid a dependency on the aws-sdk-* gems More on AWS …\n"],["Gem::S3URISigner::ConfigurationError","","Gem/S3URISigner/ConfigurationError.html","",""],["Gem::S3URISigner::InstanceProfileError","","Gem/S3URISigner/InstanceProfileError.html","",""],["Gem::SafeYAML","","Gem/SafeYAML.html","","<p>This module is used for safely loading YAML specs from a gem.  The `safe_load` method defined on this …\n"],["Gem::Security","","Gem/Security.html","","<p>Signing gems\n<p>The Gem::Security implements cryptographic signatures for gems.  The section below is a step-by-step …\n"],["Gem::Security::Exception","","Gem/Security/Exception.html","","<p>Gem::Security default exception type\n"],["Gem::Security::Policy","","Gem/Security/Policy.html","","<p>A Gem::Security::Policy object encapsulates the settings for verifying signed gem files.  This is the …\n"],["Gem::Security::Signer","","Gem/Security/Signer.html","",""],["Gem::Security::TrustDir","","Gem/Security/TrustDir.html","","<p>The TrustDir manages the trusted certificates for gem signature verification.\n"],["Gem::SecurityOption","","Gem/SecurityOption.html","","<p>Mixin methods for security option for Gem::Commands\n"],["Gem::Server","","Gem/Server.html","","<p>Gem::Server and allows users to serve gems for consumption by `gem –remote-install`.\n<p>gem_server starts …\n"],["Gem::SilentUI","","Gem/SilentUI.html","","<p>SilentUI is a UI choice that is absolutely silent.\n"],["Gem::Source","","Gem/Source.html","","<p>A Source knows how to list and fetch gems from a RubyGems marshal index.\n<p>There are other Source subclasses …\n"],["Gem::Source::Git","","Gem/Source/Git.html","","<p>A git gem for use in a gem dependencies file.\n<p>Example:\n\n<pre>source =\n  Gem::Source::Git.new &#39;rake&#39;, &#39;git@example:rake.git&#39;, ...</pre>\n"],["Gem::Source::Installed","","Gem/Source/Installed.html","","<p>Represents an installed gem.  This is used for dependency resolution.\n"],["Gem::Source::Local","","Gem/Source/Local.html","","<p>The local source finds gems in the current directory for fulfilling dependencies.\n"],["Gem::Source::Lock","","Gem/Source/Lock.html","","<p>A Lock source wraps an installed gem&#39;s source and sorts before other sources during dependency resolution. …\n"],["Gem::Source::SpecificFile","","Gem/Source/SpecificFile.html","","<p>A source representing a single .gem file.  This is used for installation of local gems.\n"],["Gem::Source::Vendor","","Gem/Source/Vendor.html","","<p>This represents a vendored source that is similar to an installed gem.\n"],["Gem::SourceFetchProblem","","Gem/SourceFetchProblem.html","","<p>An error that indicates we weren&#39;t able to fetch some data from a source\n"],["Gem::SourceList","","Gem/SourceList.html","","<p>The SourceList represents the sources rubygems has been configured to use. A source may be created from …\n"],["Gem::SpecFetcher","","Gem/SpecFetcher.html","","<p>SpecFetcher handles metadata updates from remote gem repositories.\n"],["Gem::SpecificGemNotFoundException","","Gem/SpecificGemNotFoundException.html","","<p>Raised by the DependencyInstaller when a specific gem cannot be found\n"],["Gem::Specification","","Gem/Specification.html","","<p>The Specification class contains the information for a gem.  Typically defined in a .gemspec file or …\n"],["Gem::SpecificationPolicy","","Gem/SpecificationPolicy.html","",""],["Gem::StreamUI","","Gem/StreamUI.html","","<p>Gem::StreamUI implements a simple stream based user interface.\n"],["Gem::StreamUI::SilentDownloadReporter","","Gem/StreamUI/SilentDownloadReporter.html","","<p>An absolutely silent download reporter.\n"],["Gem::StreamUI::SilentProgressReporter","","Gem/StreamUI/SilentProgressReporter.html","","<p>An absolutely silent progress reporter.\n"],["Gem::StreamUI::SimpleProgressReporter","","Gem/StreamUI/SimpleProgressReporter.html","","<p>A basic dotted progress reporter.\n"],["Gem::StreamUI::ThreadedDownloadReporter","","Gem/StreamUI/ThreadedDownloadReporter.html","","<p>A progress reporter that behaves nicely with threaded downloading.\n"],["Gem::StreamUI::VerboseProgressReporter","","Gem/StreamUI/VerboseProgressReporter.html","","<p>A progress reporter that prints out messages about the current progress.\n"],["Gem::StubSpecification","","Gem/StubSpecification.html","","<p>Gem::StubSpecification reads the stub: line from the gemspec.  This prevents us having to eval the entire …\n"],["Gem::SystemExitException","","Gem/SystemExitException.html","","<p>Raised to indicate that a system exit should occur with the specified exit_code\n"],["Gem::TestCase","","Gem/TestCase.html","","<p>RubyGemTestCase provides a variety of methods for testing rubygems and gem-related behavior in a sandbox. …\n"],["Gem::TestCase::SpecFetcherSetup","","Gem/TestCase/SpecFetcherSetup.html","","<p>The SpecFetcherSetup allows easy setup of a remote source in RubyGems tests:\n\n<pre>spec_fetcher do |f|\n  f.gem ...</pre>\n"],["Gem::TestCase::StaticSet","","Gem/TestCase/StaticSet.html","","<p>The StaticSet is a static set of gem specifications used for testing only. It is available by requiring …\n"],["Gem::Text","","Gem/Text.html","","<p>A collection of text-wrangling methods\n"],["Gem::UninstallError","","Gem/UninstallError.html","","<p>Raised when removing a gem with the uninstall command fails\n"],["Gem::Uninstaller","","Gem/Uninstaller.html","","<p>An Uninstaller.\n<p>The uninstaller fires pre and post uninstall hooks.  Hooks can be added either through …\n"],["Gem::UnsatisfiableDependencyError","","Gem/UnsatisfiableDependencyError.html","","<p>Raised by Resolver when a dependency requests a gem for which there is no spec.\n"],["Gem::UriFormatter","","Gem/UriFormatter.html","","<p>The UriFormatter handles URIs from user-input and escaping.\n\n<pre>uf = Gem::UriFormatter.new &#39;example.com&#39;\n ...</pre>\n"],["Gem::UriParser","","Gem/UriParser.html","","<p>The UriParser handles parsing URIs.\n"],["Gem::UriParsing","","Gem/UriParsing.html","",""],["Gem::UserInteraction","","Gem/UserInteraction.html","","<p>UserInteraction allows RubyGems to interact with the user through standard methods that can be replaced …\n"],["Gem::Util","","Gem/Util.html","","<p>This module contains various utility methods as module methods.\n"],["Gem::Validator","","Gem/Validator.html","","<p>Validator performs various gem file and gem database validation\n"],["Gem::VerificationError","","Gem/VerificationError.html","","<p>Raised by Gem::Validator when something is not right in a gem.\n"],["Gem::Version","","Gem/Version.html","","<p>The Version class processes string versions into comparable values. A version string should normally …\n"],["Gem::VersionOption","","Gem/VersionOption.html","","<p>Mixin methods for –version and –platform Gem::Command options.\n"],["GetoptLong","","GetoptLong.html","","<p>The GetoptLong class allows you to parse command line options similarly to the GNU getopt_long() C library …\n"],["GetoptLong::AmbiguousOption","","GetoptLong/AmbiguousOption.html","",""],["GetoptLong::Error","","GetoptLong/Error.html","","<p>Error types.\n"],["GetoptLong::InvalidOption","","GetoptLong/InvalidOption.html","",""],["GetoptLong::MissingArgument","","GetoptLong/MissingArgument.html","",""],["GetoptLong::NeedlessArgument","","GetoptLong/NeedlessArgument.html","",""],["HTTPClientException","","HTTPClientException.html","",""],["HTTPGatewayTimeOut","","HTTPGatewayTimeOut.html","",""],["HTTPMovedTemporarily","","HTTPMovedTemporarily.html","",""],["HTTPMultipleChoice","","HTTPMultipleChoice.html","",""],["HTTPRequestEntityTooLarge","","HTTPRequestEntityTooLarge.html","",""],["HTTPRequestTimeOut","","HTTPRequestTimeOut.html","",""],["HTTPRequestURITooLarge","","HTTPRequestURITooLarge.html","",""],["HTTPRequestURITooLong","","HTTPRequestURITooLong.html","",""],["HTTPRequestURITooLong","","HTTPRequestURITooLong.html","",""],["HTTPRequestedRangeNotSatisfiable","","HTTPRequestedRangeNotSatisfiable.html","",""],["Hash","","Hash.html","","<p>A Hash is a dictionary-like collection of unique keys and their values. Also called associative arrays, …\n"],["IO","","IO.html","","<p>Expect library adds the IO instance method #expect, which does similar act to tcl&#39;s expect extension. …\n"],["IO::EAGAINWaitReadable","","IO/EAGAINWaitReadable.html","","<p>exception to wait for reading by EAGAIN. see IO.select.\n"],["IO::EAGAINWaitWritable","","IO/EAGAINWaitWritable.html","","<p>exception to wait for writing by EAGAIN. see IO.select.\n"],["IO::EINPROGRESSWaitReadable","","IO/EINPROGRESSWaitReadable.html","","<p>exception to wait for reading by EINPROGRESS. see IO.select.\n"],["IO::EINPROGRESSWaitWritable","","IO/EINPROGRESSWaitWritable.html","","<p>exception to wait for writing by EINPROGRESS. see IO.select.\n"],["IO::EWOULDBLOCKWaitReadable","","IO/EWOULDBLOCKWaitReadable.html","","<p>exception to wait for reading by EWOULDBLOCK. see IO.select.\n"],["IO::EWOULDBLOCKWaitWritable","","IO/EWOULDBLOCKWaitWritable.html","","<p>exception to wait for writing by EWOULDBLOCK. see IO.select.\n"],["IO::WaitReadable","","IO/WaitReadable.html","","<p>exception to wait for reading. see IO.select.\n"],["IO::WaitWritable","","IO/WaitWritable.html","","<p>exception to wait for writing. see IO.select.\n"],["IO::generic_readable","","IO/generic_readable.html","",""],["IO::generic_writable","","IO/generic_writable.html","",""],["IOError","","IOError.html","","<p>Raised when an IO operation fails.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;/etc/hosts&quot;</span>) {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">f</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">f</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-string\">&quot;example&quot;</span>}\n  <span class=\"ruby-comment\">#=&gt; IOError: not opened ...</span>\n</pre>\n"],["IPAddr","","IPAddr.html","","<p>IPAddr provides a set of methods to manipulate an IP address.  Both IPv4 and IPv6 are supported.\n<p>Example …\n"],["IPAddr::AddressFamilyError","","IPAddr/AddressFamilyError.html","","<p>Raised when the address family is invalid such as an address with an unsupported family, an address with …\n"],["IPAddr::Error","","IPAddr/Error.html","","<p>Generic IPAddr related error. Exceptions raised in this class should inherit from Error.\n"],["IPAddr::InvalidAddressError","","IPAddr/InvalidAddressError.html","","<p>Raised when the provided IP address is an invalid address.\n"],["IPAddr::InvalidPrefixError","","IPAddr/InvalidPrefixError.html","","<p>Raised when the address is an invalid length.\n"],["IPSocket","","IPSocket.html","","<p>IPSocket is the super class of TCPSocket and UDPSocket.\n"],["IRB","","IRB.html","","<p>IRB stands for “interactive Ruby” and is a tool to interactively execute Ruby expressions read …\n"],["IRB::Abort","","IRB/Abort.html","","<p>An exception raised by IRB.irb_abort\n"],["IRB::CantChangeBinding","","IRB/CantChangeBinding.html","",""],["IRB::CantReturnToNormalMode","","IRB/CantReturnToNormalMode.html","",""],["IRB::CantShiftToMultiIrbMode","","IRB/CantShiftToMultiIrbMode.html","",""],["IRB::Canvas","","IRB/Canvas.html","",""],["IRB::Color","","IRB/Color.html","",""],["IRB::Color::SymbolState","","IRB/Color/SymbolState.html","","<p>A class to manage a state to know whether the current token is for Symbol or not.\n"],["IRB::Context","","IRB/Context.html","","<p>A class that wraps the current state of the irb session, including the configuration of IRB.conf.\n"],["IRB::ContextExtender","","IRB/ContextExtender.html","","<p>Extends methods for the Context module\n"],["IRB::ExtendCommand","","IRB/ExtendCommand.html","",""],["IRB::ExtendCommand::ChangeWorkspace","","IRB/ExtendCommand/ChangeWorkspace.html","",""],["IRB::ExtendCommand::CurrentWorkingWorkspace","","IRB/ExtendCommand/CurrentWorkingWorkspace.html","",""],["IRB::ExtendCommand::Foreground","","IRB/ExtendCommand/Foreground.html","",""],["IRB::ExtendCommand::Fork","","IRB/ExtendCommand/Fork.html","",""],["IRB::ExtendCommand::Help","","IRB/ExtendCommand/Help.html","",""],["IRB::ExtendCommand::Info","","IRB/ExtendCommand/Info.html","",""],["IRB::ExtendCommand::IrbCommand","","IRB/ExtendCommand/IrbCommand.html","",""],["IRB::ExtendCommand::Jobs","","IRB/ExtendCommand/Jobs.html","",""],["IRB::ExtendCommand::Kill","","IRB/ExtendCommand/Kill.html","",""],["IRB::ExtendCommand::Load","","IRB/ExtendCommand/Load.html","",""],["IRB::ExtendCommand::Nop","","IRB/ExtendCommand/Nop.html","",""],["IRB::ExtendCommand::PopWorkspace","","IRB/ExtendCommand/PopWorkspace.html","",""],["IRB::ExtendCommand::PushWorkspace","","IRB/ExtendCommand/PushWorkspace.html","",""],["IRB::ExtendCommand::Require","","IRB/ExtendCommand/Require.html","",""],["IRB::ExtendCommand::Source","","IRB/ExtendCommand/Source.html","",""],["IRB::ExtendCommand::Workspaces","","IRB/ExtendCommand/Workspaces.html","",""],["IRB::ExtendCommandBundle","","IRB/ExtendCommandBundle.html","","<p>Installs the default irb extensions command bundle.\n"],["IRB::FileInputMethod","","IRB/FileInputMethod.html","","<p>Use a File for IO with irb, see InputMethod\n"],["IRB::Frame","","IRB/Frame.html","",""],["IRB::Frame::FrameOverflow","","IRB/Frame/FrameOverflow.html","",""],["IRB::Frame::FrameUnderflow","","IRB/Frame/FrameUnderflow.html","",""],["IRB::History","","IRB/History.html","","<p>Represents history of results of previously evaluated commands.\n<p>Available via <code>__</code> variable, only if <code>IRB.conf[:EVAL_HISTORY]</code> …\n"],["IRB::IllegalParameter","","IRB/IllegalParameter.html","",""],["IRB::IllegalRCGenerator","","IRB/IllegalRCGenerator.html","",""],["IRB::InputMethod","","IRB/InputMethod.html","",""],["IRB::Inspector","","IRB/Inspector.html","","<p>An irb inspector\n<p>In order to create your own custom inspector there are two things you should be aware …\n"],["IRB::Irb","","IRB/Irb.html","",""],["IRB::IrbAlreadyDead","","IRB/IrbAlreadyDead.html","",""],["IRB::IrbLoader","","IRB/IrbLoader.html","","<p>Provides a few commands for loading files within an irb session.\n<p>See ExtendCommandBundle for more information. …\n"],["IRB::IrbSwitchedToCurrentThread","","IRB/IrbSwitchedToCurrentThread.html","",""],["IRB::JobManager","","IRB/JobManager.html","",""],["IRB::LoadAbort","","IRB/LoadAbort.html","","<p>Raised in the event of an exception in a file loaded from an Irb session\n"],["IRB::Locale","","IRB/Locale.html","",""],["IRB::MethodExtender","","IRB/MethodExtender.html","","<p>A convenience module for extending Ruby methods.\n"],["IRB::NoSuchJob","","IRB/NoSuchJob.html","",""],["IRB::NotImplementedError","","IRB/NotImplementedError.html","",""],["IRB::Notifier","","IRB/Notifier.html","","<p>An output formatter used internally by the lexer.\n"],["IRB::Notifier::AbstractNotifier","","IRB/Notifier/AbstractNotifier.html","","<p>An abstract class, or superclass, for CompositeNotifier and LeveledNotifier to inherit. It provides several …\n"],["IRB::Notifier::CompositeNotifier","","IRB/Notifier/CompositeNotifier.html","","<p>A class that can be used to create a group of notifier objects with the intent of representing a leveled …\n"],["IRB::Notifier::ErrUndefinedNotifier","","IRB/Notifier/ErrUndefinedNotifier.html","",""],["IRB::Notifier::ErrUnrecognizedLevel","","IRB/Notifier/ErrUnrecognizedLevel.html","",""],["IRB::Notifier::LeveledNotifier","","IRB/Notifier/LeveledNotifier.html","","<p>A leveled notifier is comparable to the composite group from CompositeNotifier#notifiers.\n"],["IRB::Notifier::NoMsgNotifier","","IRB/Notifier/NoMsgNotifier.html","","<p>NoMsgNotifier is a LeveledNotifier that&#39;s used as the default notifier when creating a new CompositeNotifier …\n"],["IRB::OutputMethod","","IRB/OutputMethod.html","","<p>An abstract output class for IO in irb. This is mainly used internally by IRB::Notifier. You can define …\n"],["IRB::OutputMethod::NotImplementedError","","IRB/OutputMethod/NotImplementedError.html","",""],["IRB::ReadlineInputMethod","","IRB/ReadlineInputMethod.html","",""],["IRB::ReidlineInputMethod","","IRB/ReidlineInputMethod.html","",""],["IRB::RubyModel","","IRB/RubyModel.html","",""],["IRB::StdioInputMethod","","IRB/StdioInputMethod.html","",""],["IRB::StdioOutputMethod","","IRB/StdioOutputMethod.html","","<p>A standard output printer\n"],["IRB::UndefinedPromptMode","","IRB/UndefinedPromptMode.html","",""],["IRB::UnrecognizedSwitch","","IRB/UnrecognizedSwitch.html","",""],["IRB::Vec","","IRB/Vec.html","",""],["IRB::WorkSpace","","IRB/WorkSpace.html","",""],["IndexError","","IndexError.html","","<p>Raised when the given index is invalid.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [<span class=\"ruby-value\">:foo</span>, <span class=\"ruby-value\">:bar</span>]\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">fetch</span>(<span class=\"ruby-value\">0</span>)   <span class=\"ruby-comment\">#=&gt; :foo</span>\n<span class=\"ruby-identifier\">a</span>[<span class=\"ruby-value\">4</span>]         <span class=\"ruby-comment\">#=&gt; nil</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">fetch</span>(<span class=\"ruby-value\">4</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Integer","","Integer.html","","<p>Holds Integer values.  You cannot add a singleton method to an Integer object, any attempt to do so will …\n"],["Interrupt","","Interrupt.html","","<p>Raised when the interrupt signal is received, typically because the user has pressed Control-C (on most …\n"],["InvocationError","","InvocationError.html","","<p>Raised when a command was found, but not invoked properly.\n"],["JSON","","JSON.html","","<p>JavaScript Object Notation (JSON)\n<p>JSON is a lightweight data-interchange format. It is easy for us humans …\n"],["JSON::CircularDatastructure","","JSON/CircularDatastructure.html","",""],["JSON::Ext","","JSON/Ext.html","","<p>This module holds all the modules/classes that implement JSON&#39;s functionality as C extensions.\n"],["JSON::Ext::Generator","","JSON/Ext/Generator.html","","<p>This is the JSON generator implemented as a C extension. It can be configured to be used by setting\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">JSON</span>.<span class=\"ruby-identifier\">generator</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["JSON::Ext::Generator::GeneratorMethods","","JSON/Ext/Generator/GeneratorMethods.html","",""],["JSON::Ext::Generator::GeneratorMethods::Array","","JSON/Ext/Generator/GeneratorMethods/Array.html","",""],["JSON::Ext::Generator::GeneratorMethods::Bignum","","JSON/Ext/Generator/GeneratorMethods/Bignum.html","",""],["JSON::Ext::Generator::GeneratorMethods::FalseClass","","JSON/Ext/Generator/GeneratorMethods/FalseClass.html","",""],["JSON::Ext::Generator::GeneratorMethods::Fixnum","","JSON/Ext/Generator/GeneratorMethods/Fixnum.html","",""],["JSON::Ext::Generator::GeneratorMethods::Float","","JSON/Ext/Generator/GeneratorMethods/Float.html","",""],["JSON::Ext::Generator::GeneratorMethods::Hash","","JSON/Ext/Generator/GeneratorMethods/Hash.html","",""],["JSON::Ext::Generator::GeneratorMethods::Integer","","JSON/Ext/Generator/GeneratorMethods/Integer.html","",""],["JSON::Ext::Generator::GeneratorMethods::NilClass","","JSON/Ext/Generator/GeneratorMethods/NilClass.html","",""],["JSON::Ext::Generator::GeneratorMethods::Object","","JSON/Ext/Generator/GeneratorMethods/Object.html","",""],["JSON::Ext::Generator::GeneratorMethods::String","","JSON/Ext/Generator/GeneratorMethods/String.html","",""],["JSON::Ext::Generator::GeneratorMethods::String::Extend","","JSON/Ext/Generator/GeneratorMethods/String/Extend.html","",""],["JSON::Ext::Generator::GeneratorMethods::TrueClass","","JSON/Ext/Generator/GeneratorMethods/TrueClass.html","",""],["JSON::Ext::Generator::State","","JSON/Ext/Generator/State.html","",""],["JSON::Ext::Parser","","JSON/Ext/Parser.html","","<p>This is the JSON parser implemented as a C extension. It can be configured to be used by setting\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">JSON</span>.<span class=\"ruby-identifier\">parser</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["JSON::GeneratorError","","JSON/GeneratorError.html","","<p>This exception is raised if a generator or unparser error occurs.\n"],["JSON::GenericObject","","JSON/GenericObject.html","",""],["JSON::JSONError","","JSON/JSONError.html","","<p>The base exception for JSON errors.\n"],["JSON::MissingUnicodeSupport","","JSON/MissingUnicodeSupport.html","","<p>This exception is raised if the required unicode support is missing on the system. Usually this means …\n"],["JSON::NestingError","","JSON/NestingError.html","","<p>This exception is raised if the nesting of parsed data structures is too deep.\n"],["JSON::ParserError","","JSON/ParserError.html","","<p>This exception is raised if a parser error occurs.\n"],["JSON::UnparserError","","JSON/GeneratorError.html","","<p>This exception is raised if a generator or unparser error occurs.\n"],["Jacobian","","Jacobian.html","","<p>require &#39;bigdecimal/jacobian&#39;\n<p>Provides methods to compute the Jacobian matrix of a set of equations …\n"],["Kconv","","Kconv.html","","<p>Kanji Converter for Ruby.\n"],["Kernel","","Kernel.html","","<p>RubyGems adds the #gem method to allow activation of specific gem versions and overrides the #require …\n"],["KeyError","","KeyError.html","","<p>Raised when the specified key is not found. It is a subclass of IndexError.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = {<span class=\"ruby-string\">&quot;foo&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">:bar</span>}\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">fetch</span>(<span class=\"ruby-string\">&quot;foo&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["LUSolve","","LUSolve.html","","<p>Solves a*x = b for x, using LU decomposition.\n"],["LoadError","","LoadError.html","","<p>Raised when a file required (a Ruby script, extension library, …) fails to load.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;this/file/does/not/exist&#39;</span>\n</pre>\n"],["LocalJumpError","","LocalJumpError.html","","<p>Raised when Ruby can&#39;t yield as requested.\n<p>A typical scenario is attempting to yield when no block …\n"],["Logger","","Logger.html","","<p>Description\n<p>The Logger class provides a simple but sophisticated logging utility that you can use to output …\n"],["MakeMakefile","","MakeMakefile.html","","<p>mkmf.rb is used by Ruby C extensions to generate a Makefile which will correctly compile and link the …\n"],["MakeMakefile::Logging","","MakeMakefile/Logging.html","",""],["MakeMakefile::RbConfig","","MakeMakefile/RbConfig.html","",""],["MakeMakefile::STRING_OR_FAILED_FORMAT","","MakeMakefile/STRING_OR_FAILED_FORMAT.html","",""],["MalformattedArgumentError","","MalformattedArgumentError.html","",""],["Marshal","","Marshal.html","","<p>The marshaling library converts collections of Ruby objects into a byte stream, allowing them to be stored …\n"],["MatchData","","MatchData.html","","<p>MatchData encapsulates the result of matching a Regexp against string. It is returned by Regexp#match …\n"],["Math","","Math.html","","<p>The Math module contains module functions for basic trigonometric and transcendental functions. See class …\n"],["Math::DomainError","","Math/DomainError.html","","<p>Raised when a mathematical function is evaluated outside of its domain of definition.\n<p>For example, since …\n"],["Matrix","","Matrix.html","","<p>The <code>Matrix</code> class represents a mathematical matrix. It provides methods for creating matrices, operating …\n"],["Matrix::EigenvalueDecomposition","","Matrix/EigenvalueDecomposition.html","","<p>Eigenvalues and eigenvectors of a real matrix.\n<p>Computes the eigenvalues and eigenvectors of a matrix  …\n"],["Matrix::LUPDecomposition","","Matrix/LUPDecomposition.html","","<p>For an m-by-n matrix A with m &gt;= n, the LU decomposition is an m-by-n unit lower triangular matrix …\n"],["Method","","Method.html","","<p>Method objects are created by Object#method, and are associated with a particular object (not just with …\n"],["Module","","Module.html","","<p>A Module is a collection of methods and constants. The methods in a module may be instance methods or …\n"],["Monitor","","Monitor.html","","<p>Use the Monitor class when you want to have a lock object for blocks with mutual exclusion.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;monitor&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["MonitorMixin","","MonitorMixin.html","",""],["MonitorMixin::ConditionVariable","","MonitorMixin/ConditionVariable.html","","<p>FIXME: This isn&#39;t documented in Nutshell.\n<p>Since MonitorMixin.new_cond returns a ConditionVariable …\n"],["Mutex","","Mutex.html","","<p>Mutex implements a simple semaphore that can be used to coordinate access to shared data from multiple …\n"],["Mutex_m","","Mutex_m.html","","<p>mutex_m.rb\n<p>When &#39;mutex_m&#39; is required, any object that extends or includes Mutex_m will be treated …\n"],["NKF","","NKF.html","","<p>NKF - Ruby extension for Network Kanji Filter\n<p>Description\n<p>This is a Ruby Extension version of nkf (Network …\n"],["NameError","","NameError.html","","<p>Raised when a given name is invalid or undefined.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">puts</span> <span class=\"ruby-identifier\">foo</span>\n</pre>\n<p><em>raises the exception:</em>\n"],["Net","","Net.html","",""],["Net::APOP","","Net/APOP.html","","<p>This class is equivalent to POP3, except that it uses APOP authentication.\n"],["Net::APOPSession","","Net/APOP.html","","<p>This class is equivalent to POP3, except that it uses APOP authentication.\n"],["Net::FTP","","Net/FTP.html","","<p>This class implements the File Transfer Protocol.  If you have used a command-line FTP program, and are …\n"],["Net::FTP::BufferedSSLSocket","","Net/FTP/BufferedSSLSocket.html","",""],["Net::FTP::BufferedSocket","","Net/FTP/BufferedSocket.html","",""],["Net::FTP::MLSxEntry","","Net/FTP/MLSxEntry.html","","<p>MLSxEntry represents an entry in responses of MLST/MLSD. Each entry has the facts (e.g., size, last modification …\n"],["Net::FTP::NullSocket","","Net/FTP/NullSocket.html","",""],["Net::FTPConnectionError","","Net/FTPConnectionError.html","",""],["Net::FTPError","","Net/FTPError.html","",""],["Net::FTPPermError","","Net/FTPPermError.html","",""],["Net::FTPProtoError","","Net/FTPProtoError.html","",""],["Net::FTPReplyError","","Net/FTPReplyError.html","",""],["Net::FTPTempError","","Net/FTPTempError.html","",""],["Net::HTTP","","Net/HTTP.html","","<p>An HTTP client API for Ruby.\n<p>Net::HTTP provides a rich library which can be used to build HTTP user-agents. …\n"],["Net::HTTP::Copy","","Net/HTTP/Copy.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Delete","","Net/HTTP/Delete.html","","<p>See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for usage examples.\n"],["Net::HTTP::Get","","Net/HTTP/Get.html","","<p>See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for usage examples.\n"],["Net::HTTP::Head","","Net/HTTP/Head.html","","<p>See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for usage examples.\n"],["Net::HTTP::Lock","","Net/HTTP/Lock.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Mkcol","","Net/HTTP/Mkcol.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Move","","Net/HTTP/Move.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Options","","Net/HTTP/Options.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Patch","","Net/HTTP/Patch.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Post","","Net/HTTP/Post.html","","<p>See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for usage examples.\n"],["Net::HTTP::Propfind","","Net/HTTP/Propfind.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Proppatch","","Net/HTTP/Proppatch.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Put","","Net/HTTP/Put.html","","<p>See Net::HTTPGenericRequest for attributes and methods. See Net::HTTP for usage examples.\n"],["Net::HTTP::Trace","","Net/HTTP/Trace.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTP::Unlock","","Net/HTTP/Unlock.html","","<p>See Net::HTTPGenericRequest for attributes and methods.\n"],["Net::HTTPAccepted","","Net/HTTPAccepted.html","",""],["Net::HTTPAlreadyReported","","Net/HTTPAlreadyReported.html","",""],["Net::HTTPBadGateway","","Net/HTTPBadGateway.html","",""],["Net::HTTPBadRequest","","Net/HTTPBadRequest.html","",""],["Net::HTTPBadResponse","","Net/HTTPBadResponse.html","",""],["Net::HTTPClientError","","Net/HTTPClientError.html","",""],["Net::HTTPConflict","","Net/HTTPConflict.html","",""],["Net::HTTPContinue","","Net/HTTPContinue.html","",""],["Net::HTTPCreated","","Net/HTTPCreated.html","",""],["Net::HTTPEarlyHints","","Net/HTTPEarlyHints.html","",""],["Net::HTTPError","","Net/HTTPError.html","",""],["Net::HTTPExceptions","","Net/HTTPExceptions.html","","<p>Net::HTTP exception class. You cannot use Net::HTTPExceptions directly; instead, you must use its subclasses. …\n"],["Net::HTTPExpectationFailed","","Net/HTTPExpectationFailed.html","",""],["Net::HTTPFailedDependency","","Net/HTTPFailedDependency.html","",""],["Net::HTTPFatalError","","Net/HTTPFatalError.html","",""],["Net::HTTPForbidden","","Net/HTTPForbidden.html","",""],["Net::HTTPFound","","Net/HTTPFound.html","",""],["Net::HTTPGatewayTimeout","","Net/HTTPGatewayTimeout.html","",""],["Net::HTTPGenericRequest","","Net/HTTPGenericRequest.html","","<p>HTTPGenericRequest is the parent of the Net::HTTPRequest class. Do not use this directly; use a subclass …\n"],["Net::HTTPGone","","Net/HTTPGone.html","",""],["Net::HTTPHeader","","Net/HTTPHeader.html","","<p>The HTTPHeader module defines methods for reading and writing HTTP headers.\n<p>It is used as a mixin by other …\n"],["Net::HTTPHeaderSyntaxError","","Net/HTTPHeaderSyntaxError.html","",""],["Net::HTTPIMUsed","","Net/HTTPIMUsed.html","",""],["Net::HTTPInformation","","Net/HTTPInformation.html","",""],["Net::HTTPInsufficientStorage","","Net/HTTPInsufficientStorage.html","",""],["Net::HTTPInternalServerError","","Net/HTTPInternalServerError.html","","<p>444 No Response - Nginx 449 Retry With - Microsoft 450 Blocked by Windows Parental Controls - Microsoft …\n"],["Net::HTTPLengthRequired","","Net/HTTPLengthRequired.html","",""],["Net::HTTPLocked","","Net/HTTPLocked.html","",""],["Net::HTTPLoopDetected","","Net/HTTPLoopDetected.html","",""],["Net::HTTPMethodNotAllowed","","Net/HTTPMethodNotAllowed.html","",""],["Net::HTTPMisdirectedRequest","","Net/HTTPMisdirectedRequest.html","","<p>418 I&#39;m a teapot - RFC 2324; a joke RFC 420 Enhance Your Calm - Twitter\n"],["Net::HTTPMovedPermanently","","Net/HTTPMovedPermanently.html","",""],["Net::HTTPMultiStatus","","Net/HTTPMultiStatus.html","",""],["Net::HTTPMultipleChoices","","Net/HTTPMultipleChoices.html","",""],["Net::HTTPNetworkAuthenticationRequired","","Net/HTTPNetworkAuthenticationRequired.html","",""],["Net::HTTPNoContent","","Net/HTTPNoContent.html","",""],["Net::HTTPNonAuthoritativeInformation","","Net/HTTPNonAuthoritativeInformation.html","",""],["Net::HTTPNotAcceptable","","Net/HTTPNotAcceptable.html","",""],["Net::HTTPNotExtended","","Net/HTTPNotExtended.html","","<p>509 Bandwidth Limit Exceeded - Apache bw/limited extension\n"],["Net::HTTPNotFound","","Net/HTTPNotFound.html","",""],["Net::HTTPNotImplemented","","Net/HTTPNotImplemented.html","",""],["Net::HTTPNotModified","","Net/HTTPNotModified.html","",""],["Net::HTTPOK","","Net/HTTPOK.html","",""],["Net::HTTPPartialContent","","Net/HTTPPartialContent.html","",""],["Net::HTTPPayloadTooLarge","","Net/HTTPPayloadTooLarge.html","",""],["Net::HTTPPaymentRequired","","Net/HTTPPaymentRequired.html","",""],["Net::HTTPPermanentRedirect","","Net/HTTPPermanentRedirect.html","",""],["Net::HTTPPreconditionFailed","","Net/HTTPPreconditionFailed.html","",""],["Net::HTTPPreconditionRequired","","Net/HTTPPreconditionRequired.html","",""],["Net::HTTPProcessing","","Net/HTTPProcessing.html","",""],["Net::HTTPProxyAuthenticationRequired","","Net/HTTPProxyAuthenticationRequired.html","",""],["Net::HTTPRangeNotSatisfiable","","Net/HTTPRangeNotSatisfiable.html","",""],["Net::HTTPRedirection","","Net/HTTPRedirection.html","",""],["Net::HTTPRequest","","Net/HTTPRequest.html","","<p>HTTP request class. This class wraps together the request header and the request path. You cannot use …\n"],["Net::HTTPRequestHeaderFieldsTooLarge","","Net/HTTPRequestHeaderFieldsTooLarge.html","",""],["Net::HTTPRequestTimeout","","Net/HTTPRequestTimeout.html","",""],["Net::HTTPResetContent","","Net/HTTPResetContent.html","",""],["Net::HTTPResponse","","Net/HTTPResponse.html","","<p>HTTP response class.\n<p>This class wraps together the response header and the response body (the entity requested). …\n"],["Net::HTTPRetriableError","","Net/HTTPRetriableError.html","",""],["Net::HTTPSeeOther","","Net/HTTPSeeOther.html","",""],["Net::HTTPServerError","","Net/HTTPServerError.html","",""],["Net::HTTPServerException","","Net/HTTPServerException.html","",""],["Net::HTTPServiceUnavailable","","Net/HTTPServiceUnavailable.html","",""],["Net::HTTPSuccess","","Net/HTTPSuccess.html","",""],["Net::HTTPSwitchProtocol","","Net/HTTPSwitchProtocol.html","",""],["Net::HTTPTemporaryRedirect","","Net/HTTPTemporaryRedirect.html","","<p>306 Switch Proxy - no longer unused\n"],["Net::HTTPTooManyRequests","","Net/HTTPTooManyRequests.html","",""],["Net::HTTPURITooLong","","Net/HTTPURITooLong.html","",""],["Net::HTTPUnauthorized","","Net/HTTPUnauthorized.html","",""],["Net::HTTPUnavailableForLegalReasons","","Net/HTTPUnavailableForLegalReasons.html","",""],["Net::HTTPUnknownResponse","","Net/HTTPUnknownResponse.html","","<p>www.iana.org/assignments/http-status-codes/http-status-codes.xhtml\n"],["Net::HTTPUnprocessableEntity","","Net/HTTPUnprocessableEntity.html","",""],["Net::HTTPUnsupportedMediaType","","Net/HTTPUnsupportedMediaType.html","",""],["Net::HTTPUpgradeRequired","","Net/HTTPUpgradeRequired.html","","<p>425 Unordered Collection - existed only in draft\n"],["Net::HTTPUseProxy","","Net/HTTPUseProxy.html","",""],["Net::HTTPVariantAlsoNegotiates","","Net/HTTPVariantAlsoNegotiates.html","",""],["Net::HTTPVersionNotSupported","","Net/HTTPVersionNotSupported.html","",""],["Net::IMAP","","Net/IMAP.html","","<p>Net::IMAP implements Internet Message Access Protocol (IMAP) client functionality.  The protocol is described …\n"],["Net::IMAP::BadResponseError","","Net/IMAP/BadResponseError.html","","<p>Error raised upon a “BAD” response from the server, indicating that the client command violated …\n"],["Net::IMAP::BodyTypeAttachment","","Net/IMAP/BodyTypeAttachment.html","","<p>Net::IMAP::BodyTypeAttachment represents attachment body structures of messages.\n<p>Fields:\n<p>media_type &mdash; Returns …\n"],["Net::IMAP::BodyTypeBasic","","Net/IMAP/BodyTypeBasic.html","","<p>Net::IMAP::BodyTypeBasic represents basic body structures of messages.\n<p>Fields:\n<p>media_type &mdash; Returns the content …\n"],["Net::IMAP::BodyTypeExtension","","Net/IMAP/BodyTypeExtension.html","",""],["Net::IMAP::BodyTypeMessage","","Net/IMAP/BodyTypeMessage.html","","<p>Net::IMAP::BodyTypeMessage represents MESSAGE/RFC822 body structures of messages.\n<p>Fields:\n<p>envelope &mdash; Returns …\n"],["Net::IMAP::BodyTypeMultipart","","Net/IMAP/BodyTypeMultipart.html","","<p>Net::IMAP::BodyTypeMultipart represents multipart body structures of messages.\n<p>Fields:\n<p>media_type &mdash; Returns …\n"],["Net::IMAP::BodyTypeText","","Net/IMAP/BodyTypeText.html","","<p>Net::IMAP::BodyTypeText represents TEXT body structures of messages.\n<p>Fields:\n<p>lines &mdash; Returns the size of …\n"],["Net::IMAP::ByeResponseError","","Net/IMAP/ByeResponseError.html","","<p>Error raised upon a “BYE” response from the server, indicating that the client is not being …\n"],["Net::IMAP::CramMD5Authenticator","","Net/IMAP/CramMD5Authenticator.html","","<p>Authenticator for the “CRAM-MD5” authentication type.  See #authenticate().\n"],["Net::IMAP::DataFormatError","","Net/IMAP/DataFormatError.html","","<p>Error raised when data is in the incorrect format.\n"],["Net::IMAP::DigestMD5Authenticator","","Net/IMAP/DigestMD5Authenticator.html","","<p>Authenticator for the “DIGEST-MD5” authentication type.  See #authenticate().\n"],["Net::IMAP::Error","","Net/IMAP/Error.html","","<p>Superclass of IMAP errors.\n"],["Net::IMAP::FlagCountError","","Net/IMAP/FlagCountError.html","","<p>Error raised when too many flags are interned to symbols.\n"],["Net::IMAP::LoginAuthenticator","","Net/IMAP/LoginAuthenticator.html","","<p>Authenticator for the “LOGIN” authentication type.  See #authenticate().\n"],["Net::IMAP::NoResponseError","","Net/IMAP/NoResponseError.html","","<p>Error raised upon a “NO” response from the server, indicating that the client command could …\n"],["Net::IMAP::NumValidator","","Net/IMAP/NumValidator.html","","<p>Common validators of number and nz_number types\n"],["Net::IMAP::PlainAuthenticator","","Net/IMAP/PlainAuthenticator.html","","<p>Authenticator for the “PLAIN” authentication type.  See #authenticate().\n"],["Net::IMAP::ResponseError","","Net/IMAP/ResponseError.html","","<p>Superclass of all errors used to encapsulate “fail” responses from the server.\n"],["Net::IMAP::ResponseParseError","","Net/IMAP/ResponseParseError.html","","<p>Error raised when a response from the server is non-parseable.\n"],["Net::IMAP::UnknownResponseError","","Net/IMAP/UnknownResponseError.html","","<p>Error raised upon an unknown response from the server.\n"],["Net::OpenTimeout","","Net/OpenTimeout.html","","<p>OpenTimeout, a subclass of Timeout::Error, is raised if a connection cannot be created within the open_timeout. …\n"],["Net::POP3","","Net/POP3.html","","<p>What is This Library?\n<p>This library provides functionality for retrieving email via POP3, the Post Office …\n"],["Net::POPAuthenticationError","","Net/POPAuthenticationError.html","","<p>POP3 authentication error.\n"],["Net::POPBadResponse","","Net/POPBadResponse.html","","<p>Unexpected response from the server.\n"],["Net::POPError","","Net/POPError.html","","<p>Non-authentication POP3 protocol error (reply code “-ERR”, except authentication).\n"],["Net::POPMail","","Net/POPMail.html","","<p>This class represents a message which exists on the POP server. Instances of this class are created by …\n"],["Net::ProtoAuthError","","Net/ProtoAuthError.html","",""],["Net::ProtoCommandError","","Net/ProtoCommandError.html","",""],["Net::ProtoFatalError","","Net/ProtoFatalError.html","",""],["Net::ProtoRetriableError","","Net/ProtoRetriableError.html","",""],["Net::ProtoServerError","","Net/ProtoServerError.html","",""],["Net::ProtoSyntaxError","","Net/ProtoSyntaxError.html","",""],["Net::ProtoUnknownError","","Net/ProtoUnknownError.html","",""],["Net::ProtocRetryError","","Net/ProtocRetryError.html","",""],["Net::ProtocolError","","Net/ProtocolError.html","",""],["Net::ReadTimeout","","Net/ReadTimeout.html","","<p>ReadTimeout, a subclass of Timeout::Error, is raised if a chunk of the response cannot be read within …\n"],["Net::SMTP","","Net/SMTP.html","","<p>What is This Library?\n<p>This library provides functionality to send internet mail via SMTP, the Simple  …\n"],["Net::SMTP::Response","","Net/SMTP/Response.html","","<p>This class represents a response received by the SMTP server. Instances of this class are created by …\n"],["Net::SMTPAuthenticationError","","Net/SMTPAuthenticationError.html","","<p>Represents an SMTP authentication error.\n"],["Net::SMTPError","","Net/SMTPError.html","","<p>Module mixed in to all SMTP error classes\n"],["Net::SMTPFatalError","","Net/SMTPFatalError.html","","<p>Represents a fatal SMTP error (error code 5xx, except for 500)\n"],["Net::SMTPServerBusy","","Net/SMTPServerBusy.html","","<p>Represents SMTP error code 4xx, a temporary error.\n"],["Net::SMTPSyntaxError","","Net/SMTPSyntaxError.html","","<p>Represents an SMTP command syntax error (error code 500)\n"],["Net::SMTPUnknownError","","Net/SMTPUnknownError.html","","<p>Unexpected reply code returned from server.\n"],["Net::SMTPUnsupportedCommand","","Net/SMTPUnsupportedCommand.html","","<p>Command is not supported on server.\n"],["Net::WriteAdapter","","Net/WriteAdapter.html","","<p>The writer adapter class\n"],["Net::WriteTimeout","","Net/WriteTimeout.html","","<p>WriteTimeout, a subclass of Timeout::Error, is raised if a chunk of the response cannot be written within …\n"],["Newton","","Newton.html","","<p>newton.rb\n<p>Solves the nonlinear algebraic equation system f = 0 by Newton&#39;s method. This program is …\n"],["NilClass","","NilClass.html","","<p>The class of the singleton object <code>nil</code>.\n"],["NoMatchingPatternError","","NoMatchingPatternError.html","",""],["NoMemoryError","","NoMemoryError.html","","<p>Raised when memory allocation fails.\n"],["NoMethodError","","NoMethodError.html","","<p>Raised when a method is called on a receiver which doesn&#39;t have it defined and also fails to respond …\n"],["NotImplementedError","","NotImplementedError.html","","<p>Raised when a feature is not implemented on the current platform. For example, methods depending on the …\n"],["Numeric","","Numeric.html","","<p>Numeric is the class from which all higher-level numeric classes should inherit.\n<p>Numeric allows instantiation …\n"],["OLEProperty","","OLEProperty.html","","<p>OLEProperty helper class of Property with arguments.\n"],["Object","","Object.html","","<p>Object is the default root of all Ruby objects.  Object inherits from BasicObject which allows creating …\n"],["Object::ParseError","","Racc/ParseError.html","",""],["Object::TimeoutError","","Timeout/Error.html","","<p>Raised by Timeout.timeout when the block times out.\n"],["ObjectSpace","","ObjectSpace.html","","<p>The objspace library extends the ObjectSpace module and adds several methods to get internal statistic …\n"],["ObjectSpace::InternalObjectWrapper","","ObjectSpace/InternalObjectWrapper.html","","<p>This class is used as a return value from ObjectSpace::reachable_objects_from.\n<p>When ObjectSpace::reachable_objects_from …\n"],["ObjectSpace::WeakMap","","ObjectSpace/WeakMap.html","","<p>An ObjectSpace::WeakMap object holds references to any objects, but those objects can get garbage collected. …\n"],["Observable","","Observable.html","","<p>The Observer pattern (also known as publish/subscribe) provides a simple mechanism for one object to …\n"],["Open3","","Open3.html","","<p>Open3 grants you access to stdin, stdout, stderr and a thread to wait for the child process when running …\n"],["OpenSSL","","OpenSSL.html","","<p>OpenSSL provides SSL, TLS and general purpose cryptography.  It wraps the OpenSSL library.\n<p>Examples\n<p>All …\n"],["OpenSSL::ASN1","","OpenSSL/ASN1.html","","<p>Abstract Syntax Notation One (or ASN.1) is a notation syntax to describe data structures and is defined …\n"],["OpenSSL::ASN1::ASN1Data","","OpenSSL/ASN1/ASN1Data.html","","<p>The top-level class representing any ASN.1 object. When parsed by ASN1.decode, tagged values are always …\n"],["OpenSSL::ASN1::ASN1Error","","OpenSSL/ASN1/ASN1Error.html","","<p>Generic error class for all errors raised in ASN1 and any of the classes defined in it.\n"],["OpenSSL::ASN1::Constructive","","OpenSSL/ASN1/Constructive.html","","<p>The parent class for all constructed encodings. The <em>value</em> attribute of a Constructive is always an Array …\n"],["OpenSSL::ASN1::ObjectId","","OpenSSL/ASN1/ObjectId.html","","<p>Represents the primitive object id for OpenSSL::ASN1\n"],["OpenSSL::ASN1::Primitive","","OpenSSL/ASN1/Primitive.html","","<p>The parent class for all primitive encodings. Attributes are the same as for ASN1Data, with the addition …\n"],["OpenSSL::BN","","OpenSSL/BN.html","",""],["OpenSSL::BNError","","OpenSSL/BNError.html","","<p>Generic Error for all of OpenSSL::BN (big num)\n"],["OpenSSL::Buffering","","OpenSSL/Buffering.html","","<p>OpenSSL IO buffering mix-in module.\n<p>This module allows an OpenSSL::SSL::SSLSocket to behave like an IO …\n"],["OpenSSL::Cipher","","OpenSSL/Cipher.html","","<p>Provides symmetric algorithms for encryption and decryption. The algorithms that are available depend …\n"],["OpenSSL::Cipher::Cipher","","OpenSSL/Cipher/Cipher.html","","<p>Deprecated.\n<p>This class is only provided for backwards compatibility. Use OpenSSL::Cipher.\n"],["OpenSSL::Cipher::CipherError","","OpenSSL/Cipher/CipherError.html","",""],["OpenSSL::Config","","OpenSSL/Config.html","","<p>OpenSSL::Config\n<p>Configuration for the openssl library.\n<p>Many system&#39;s installation of openssl library …\n"],["OpenSSL::ConfigError","","OpenSSL/ConfigError.html","","<p>General error for openssl library configuration files. Including formatting, parsing errors, etc.\n"],["OpenSSL::Digest","","OpenSSL/Digest.html","","<p>OpenSSL::Digest allows you to compute message digests (sometimes interchangeably called “hashes”) …\n"],["OpenSSL::Digest::DigestError","","OpenSSL/Digest/DigestError.html","","<p>Generic Exception class that is raised if an error occurs during a Digest operation.\n"],["OpenSSL::Engine","","OpenSSL/Engine.html","","<p>This class is the access to openssl&#39;s ENGINE cryptographic module implementation.\n<p>See also, www.openssl.org/docs/crypto/engine.html …\n"],["OpenSSL::Engine::EngineError","","OpenSSL/Engine/EngineError.html","","<p>This is the generic exception for OpenSSL::Engine related errors\n"],["OpenSSL::ExtConfig","","OpenSSL/ExtConfig.html","","<p>This module contains configuration information about the SSL extension, for example if socket support …\n"],["OpenSSL::HMAC","","OpenSSL/HMAC.html","","<p>OpenSSL::HMAC allows computing Hash-based Message Authentication Code (HMAC). It is a type of message …\n"],["OpenSSL::HMACError","","OpenSSL/HMACError.html","","<p>Document-class: OpenSSL::HMAC\n<p>OpenSSL::HMAC allows computing Hash-based Message Authentication Code ( …\n"],["OpenSSL::KDF","","OpenSSL/KDF.html","","<p>Provides functionality of various KDFs (key derivation function).\n<p>KDF is typically used for securely deriving …\n"],["OpenSSL::KDF::KDFError","","OpenSSL/KDF/KDFError.html","","<p>Generic exception class raised if an error occurs in OpenSSL::KDF module.\n"],["OpenSSL::Netscape","","OpenSSL/Netscape.html","","<p>OpenSSL::Netscape is a namespace for SPKI (Simple Public Key Infrastructure) which implements Signed …\n"],["OpenSSL::Netscape::SPKI","","OpenSSL/Netscape/SPKI.html","","<p>A Simple Public Key Infrastructure implementation (pronounced “spooky”). The structure is defined …\n"],["OpenSSL::Netscape::SPKIError","","OpenSSL/Netscape/SPKIError.html","","<p>Generic Exception class that is raised if an error occurs during an operation on an instance of OpenSSL::Netscape::SPKI …\n"],["OpenSSL::OCSP","","OpenSSL/OCSP.html","","<p>OpenSSL::OCSP implements Online Certificate Status Protocol requests and responses.\n<p>Creating and sending …\n"],["OpenSSL::OCSP::BasicResponse","","OpenSSL/OCSP/BasicResponse.html","","<p>An OpenSSL::OCSP::BasicResponse contains the status of a certificate check which is created from an  …\n"],["OpenSSL::OCSP::CertificateId","","OpenSSL/OCSP/CertificateId.html","","<p>An OpenSSL::OCSP::CertificateId identifies a certificate to the CA so that a status check can be performed. …\n"],["OpenSSL::OCSP::OCSPError","","OpenSSL/OCSP/OCSPError.html","","<p>OCSP error class.\n"],["OpenSSL::OCSP::Request","","OpenSSL/OCSP/Request.html","","<p>An OpenSSL::OCSP::Request contains the certificate information for determining if a certificate has been …\n"],["OpenSSL::OCSP::Response","","OpenSSL/OCSP/Response.html","","<p>An OpenSSL::OCSP::Response contains the status of a certificate check which is created from an OpenSSL::OCSP::Request …\n"],["OpenSSL::OCSP::SingleResponse","","OpenSSL/OCSP/SingleResponse.html","","<p>An OpenSSL::OCSP::SingleResponse represents an OCSP SingleResponse structure, which contains the basic …\n"],["OpenSSL::OpenSSLError","","OpenSSL/OpenSSLError.html","","<p>Generic error, common for all classes under OpenSSL module\n"],["OpenSSL::PKCS12","","OpenSSL/PKCS12.html","","<p>Defines a file format commonly used to store private keys with accompanying public key certificates, …\n"],["OpenSSL::PKCS12::PKCS12Error","","OpenSSL/PKCS12/PKCS12Error.html","",""],["OpenSSL::PKCS5","","OpenSSL/PKCS5.html","",""],["OpenSSL::PKCS7","","OpenSSL/PKCS7.html","",""],["OpenSSL::PKCS7::PKCS7Error","","OpenSSL/PKCS7/PKCS7Error.html","",""],["OpenSSL::PKCS7::RecipientInfo","","OpenSSL/PKCS7/RecipientInfo.html","",""],["OpenSSL::PKCS7::SignerInfo","","OpenSSL/PKCS7/SignerInfo.html","",""],["OpenSSL::PKey","","OpenSSL/PKey.html","","<p>Asymmetric Public Key Algorithms\n<p>Asymmetric public key algorithms solve the problem of establishing and …\n"],["OpenSSL::PKey::DH","","OpenSSL/PKey/DH.html","","<p>An implementation of the Diffie-Hellman key exchange protocol based on discrete logarithms in finite …\n"],["OpenSSL::PKey::DHError","","OpenSSL/PKey/DHError.html","","<p>Generic exception that is raised if an operation on a DH PKey fails unexpectedly or in case an instantiation …\n"],["OpenSSL::PKey::DSA","","OpenSSL/PKey/DSA.html","","<p>DSA, the Digital Signature Algorithm, is specified in NIST&#39;s FIPS 186-3. It is an asymmetric public …\n"],["OpenSSL::PKey::DSAError","","OpenSSL/PKey/DSAError.html","","<p>Generic exception that is raised if an operation on a DSA PKey fails unexpectedly or in case an instantiation …\n"],["OpenSSL::PKey::EC","","OpenSSL/PKey/EC.html","","<p>OpenSSL::PKey::EC provides access to Elliptic Curve Digital Signature Algorithm (ECDSA) and Elliptic …\n"],["OpenSSL::PKey::EC::Group","","OpenSSL/PKey/EC/Group.html","",""],["OpenSSL::PKey::EC::Group::Error","","OpenSSL/PKey/EC/Group/Error.html","",""],["OpenSSL::PKey::EC::Point","","OpenSSL/PKey/EC/Point.html","",""],["OpenSSL::PKey::EC::Point::Error","","OpenSSL/PKey/EC/Point/Error.html","",""],["OpenSSL::PKey::ECError","","OpenSSL/PKey/ECError.html","",""],["OpenSSL::PKey::PKey","","OpenSSL/PKey/PKey.html","","<p>An abstract class that bundles signature creation (PKey#sign) and validation (PKey#verify) that is common …\n"],["OpenSSL::PKey::PKeyError","","OpenSSL/PKey/PKeyError.html","","<p>Raised when errors occur during PKey#sign or PKey#verify.\n"],["OpenSSL::PKey::RSA","","OpenSSL/PKey/RSA.html","","<p>RSA is an asymmetric public key algorithm that has been formalized in RFC 3447. It is in widespread use …\n"],["OpenSSL::PKey::RSAError","","OpenSSL/PKey/RSAError.html","","<p>Generic exception that is raised if an operation on an RSA PKey fails unexpectedly or in case an instantiation …\n"],["OpenSSL::Random","","OpenSSL/Random.html","",""],["OpenSSL::Random::RandomError","","OpenSSL/Random/RandomError.html","",""],["OpenSSL::SSL","","OpenSSL/SSL.html","","<p>Use SSLContext to set up the parameters for a TLS (former SSL) connection. Both client and server TLS …\n"],["OpenSSL::SSL::SSLContext","","OpenSSL/SSL/SSLContext.html","","<p>An SSLContext is used to set various options regarding certificates, algorithms, verification, session …\n"],["OpenSSL::SSL::SSLError","","OpenSSL/SSL/SSLError.html","","<p>Generic error class raised by SSLSocket and SSLContext.\n"],["OpenSSL::SSL::SSLErrorWaitReadable","","OpenSSL/SSL/SSLErrorWaitReadable.html","",""],["OpenSSL::SSL::SSLErrorWaitWritable","","OpenSSL/SSL/SSLErrorWaitWritable.html","",""],["OpenSSL::SSL::SSLServer","","OpenSSL/SSL/SSLServer.html","","<p>SSLServer represents a TCP/IP server socket with Secure Sockets Layer.\n"],["OpenSSL::SSL::SSLSocket","","OpenSSL/SSL/SSLSocket.html","",""],["OpenSSL::SSL::Session","","OpenSSL/SSL/Session.html","",""],["OpenSSL::SSL::Session::SessionError","","OpenSSL/SSL/Session/SessionError.html","",""],["OpenSSL::SSL::SocketForwarder","","OpenSSL/SSL/SocketForwarder.html","",""],["OpenSSL::X509","","OpenSSL/X509.html","",""],["OpenSSL::X509::Attribute","","OpenSSL/X509/Attribute.html","",""],["OpenSSL::X509::AttributeError","","OpenSSL/X509/AttributeError.html","",""],["OpenSSL::X509::CRL","","OpenSSL/X509/CRL.html","",""],["OpenSSL::X509::CRLError","","OpenSSL/X509/CRLError.html","",""],["OpenSSL::X509::Certificate","","OpenSSL/X509/Certificate.html","","<p>Implementation of an X.509 certificate as specified in RFC 5280. Provides access to a certificate&#39;s …\n"],["OpenSSL::X509::CertificateError","","OpenSSL/X509/CertificateError.html","",""],["OpenSSL::X509::Extension","","OpenSSL/X509/Extension.html","",""],["OpenSSL::X509::ExtensionError","","OpenSSL/X509/ExtensionError.html","",""],["OpenSSL::X509::ExtensionFactory","","OpenSSL/X509/ExtensionFactory.html","",""],["OpenSSL::X509::Name","","OpenSSL/X509/Name.html","","<p>An X.509 name represents a hostname, email address or other entity associated with a public key.\n<p>You can …\n"],["OpenSSL::X509::Name::RFC2253DN","","OpenSSL/X509/Name/RFC2253DN.html","",""],["OpenSSL::X509::NameError","","OpenSSL/X509/NameError.html","",""],["OpenSSL::X509::Request","","OpenSSL/X509/Request.html","",""],["OpenSSL::X509::RequestError","","OpenSSL/X509/RequestError.html","",""],["OpenSSL::X509::Revoked","","OpenSSL/X509/Revoked.html","",""],["OpenSSL::X509::RevokedError","","OpenSSL/X509/RevokedError.html","",""],["OpenSSL::X509::Store","","OpenSSL/X509/Store.html","","<p>The X509 certificate store holds trusted CA certificates used to verify peer certificates.\n<p>The easiest …\n"],["OpenSSL::X509::StoreContext","","OpenSSL/X509/StoreContext.html","","<p>A StoreContext is used while validating a single certificate and holds the status involved.\n"],["OpenSSL::X509::StoreError","","OpenSSL/X509/StoreError.html","",""],["OpenStruct","","OpenStruct.html","",""],["OpenURI","","OpenURI.html","","<p>OpenURI is an easy-to-use wrapper for Net::HTTP, Net::HTTPS and Net::FTP.\n<p>Example\n<p>It is possible to open …\n"],["OpenURI::HTTPError","","OpenURI/HTTPError.html","",""],["OpenURI::HTTPRedirect","","OpenURI/HTTPRedirect.html","","<p>Raised on redirection, only occurs when <code>redirect</code> option for HTTP is <code>false</code>.\n"],["OpenURI::Meta","","OpenURI/Meta.html","","<p>Mixin for holding meta-information.\n"],["OpenURI::OpenRead","","OpenURI/OpenRead.html","","<p>Mixin for HTTP and FTP URIs.\n"],["OptionParser","","OptionParser.html","","<p>OptionParser\n<p>Introduction\n<p>OptionParser is a class for command-line option analysis.  It is much more advanced, …\n"],["OptionParser::AC","","OptionParser/AC.html","",""],["OptionParser::Acceptables","","OptionParser/Acceptables.html","","<p>Acceptable argument classes. Now contains DecimalInteger, OctalInteger and DecimalNumeric. See Acceptable …\n"],["OptionParser::AmbiguousArgument","","OptionParser/AmbiguousArgument.html","","<p>Raises when the given argument word can&#39;t be completed uniquely.\n"],["OptionParser::AmbiguousOption","","OptionParser/AmbiguousOption.html","","<p>Raises when ambiguously completable string is encountered.\n"],["OptionParser::Arguable","","OptionParser/Arguable.html","","<p>Extends command line arguments array (ARGV) to parse itself.\n"],["OptionParser::CompletingHash","","OptionParser/CompletingHash.html","","<p>Hash with completion search feature. See OptionParser::Completion.\n"],["OptionParser::Completion","","OptionParser/Completion.html","","<p>Keyword completion module.  This allows partial arguments to be specified and resolved against a list …\n"],["OptionParser::InvalidArgument","","OptionParser/InvalidArgument.html","","<p>Raises when the given argument does not match required format.\n"],["OptionParser::InvalidOption","","OptionParser/InvalidOption.html","","<p>Raises when switch is undefined.\n"],["OptionParser::List","","OptionParser/List.html","","<p>Simple option list providing mapping from short and/or long option string to OptionParser::Switch and …\n"],["OptionParser::MissingArgument","","OptionParser/MissingArgument.html","","<p>Raises when a switch with mandatory argument has no argument.\n"],["OptionParser::NeedlessArgument","","OptionParser/NeedlessArgument.html","","<p>Raises when there is an argument for a switch which takes no argument.\n"],["OptionParser::OptionMap","","OptionParser/OptionMap.html","","<p>Map from option/keyword string to object with completion.\n"],["OptionParser::ParseError","","OptionParser/ParseError.html","","<p>Base class of exceptions from OptionParser.\n"],["OptionParser::Switch","","OptionParser/Switch.html","","<p>Individual switch class.  Not important to the user.\n<p>Defined within Switch are several Switch-derived …\n"],["OptionParser::Switch::NoArgument","","OptionParser/Switch/NoArgument.html","","<p>Switch that takes no arguments.\n"],["OptionParser::Switch::OptionalArgument","","OptionParser/Switch/OptionalArgument.html","","<p>Switch that can omit argument.\n"],["OptionParser::Switch::PlacedArgument","","OptionParser/Switch/PlacedArgument.html","","<p>Switch that takes an argument, which does not begin with &#39;-&#39;.\n"],["OptionParser::Switch::RequiredArgument","","OptionParser/Switch/RequiredArgument.html","","<p>Switch that takes an argument.\n"],["PP","","PP.html","","<p>A pretty-printer for Ruby objects.\n<p>What PP Does\n<p>Standard output by #p returns this:\n"],["PP::PPMethods","","PP/PPMethods.html","",""],["PStore","","PStore.html","","<p>PStore implements a file based persistence mechanism based on a Hash.  User code can store hierarchies …\n"],["PStore::Error","","PStore/Error.html","","<p>The error type thrown by all PStore methods.\n"],["PTY","","PTY.html","","<p>Creates and manages pseudo terminals (PTYs).  See also en.wikipedia.org/wiki/Pseudo_terminal\n<p>PTY allows …\n"],["PTY::ChildExited","","PTY/ChildExited.html","","<p>Thrown when PTY::check is called for a pid that represents a process that has exited.\n"],["Pathname","","Pathname.html","","<p>Pathname represents the name of a file or directory on the filesystem, but not the file itself.\n<p>The pathname …\n"],["Pool","","Pool.html","",""],["PrettyPrint","","PrettyPrint.html","","<p>This class implements a pretty printing algorithm. It finds line breaks and nice indentations for grouped …\n"],["PrettyPrint::SingleLine","","PrettyPrint/SingleLine.html","","<p>PrettyPrint::SingleLine is used by PrettyPrint.singleline_format\n<p>It is passed to be similar to a PrettyPrint …\n"],["Prime","","Prime.html","","<p>The set of all prime numbers.\n<p>Example\n\n<pre>Prime.each(100) do |prime|\n  p prime  #=&gt; 2, 3, 5, 7, 11, ...., 97 ...</pre>\n"],["Prime::EratosthenesGenerator","","Prime/EratosthenesGenerator.html","","<p>An implementation of <code>PseudoPrimeGenerator</code>.\n<p>Uses <code>EratosthenesSieve</code>.\n"],["Prime::EratosthenesSieve","","Prime/EratosthenesSieve.html","","<p>Internal use. An implementation of Eratosthenes&#39; sieve\n"],["Prime::Generator23","","Prime/Generator23.html","","<p>Generates all integers which are greater than 2 and are not divisible by either 2 or 3.\n<p>This is a pseudo-prime …\n"],["Prime::PseudoPrimeGenerator","","Prime/PseudoPrimeGenerator.html","","<p>An abstract class for enumerating pseudo-prime numbers.\n<p>Concrete subclasses should override succ, next, …\n"],["Prime::TrialDivision","","Prime/TrialDivision.html","","<p>Internal use. An implementation of prime table by trial division method.\n"],["Prime::TrialDivisionGenerator","","Prime/TrialDivisionGenerator.html","","<p>An implementation of <code>PseudoPrimeGenerator</code> which uses a prime table generated by trial division.\n"],["Proc","","Proc.html","","<p>A <code>Proc</code> object is an encapsulation of a block of code, which can be stored in a local variable, passed …\n"],["Process","","Process.html","","<p>The module contains several groups of functionality for handling OS processes:\n<p>Low-level property introspection …\n"],["Process::GID","","Process/GID.html","","<p>The Process::GID module contains a collection of module functions which can be used to portably get, …\n"],["Process::Status","","Process/Status.html","","<p>Process::Status encapsulates the information on the status of a running or terminated system process. …\n"],["Process::Sys","","Process/Sys.html","","<p>The Process::Sys module contains UID and GID functions which provide direct bindings to the system calls …\n"],["Process::UID","","Process/UID.html","","<p>The Process::UID module contains a collection of module functions which can be used to portably get, …\n"],["Psych","","Psych.html","","<p>Overview\n<p>Psych is a YAML parser and emitter. Psych leverages libyaml [Home page: pyyaml.org/wiki/LibYAML …\n"],["Psych::BadAlias","","Psych/BadAlias.html","",""],["Psych::ClassLoader","","Psych/ClassLoader.html","",""],["Psych::ClassLoader::Restricted","","Psych/ClassLoader/Restricted.html","",""],["Psych::Coder","","Psych/Coder.html","","<p>If an object defines <code>encode_with</code>, then an instance of Psych::Coder will be passed to the method when …\n"],["Psych::DisallowedClass","","Psych/DisallowedClass.html","",""],["Psych::Emitter","","Psych/Emitter.html","",""],["Psych::Exception","","Psych/Exception.html","",""],["Psych::Handler","","Psych/Handler.html","","<p>Psych::Handler is an abstract base class that defines the events used when dealing with Psych::Parser …\n"],["Psych::Handler::DumperOptions","","Psych/Handler/DumperOptions.html","","<p>Configuration options for dumping YAML.\n"],["Psych::Handlers","","Psych/Handlers.html","",""],["Psych::Handlers::Recorder","","Psych/Handlers/Recorder.html","","<p>This handler will capture an event and record the event.  Recorder events are available vial Psych::Handlers::Recorder#events …\n"],["Psych::JSON","","Psych/JSON.html","",""],["Psych::JSON::Stream","","Psych/JSON/Stream.html","",""],["Psych::JSON::TreeBuilder","","Psych/JSON/TreeBuilder.html","","<p>Psych::JSON::TreeBuilder is an event based AST builder.  Events are sent to an instance of Psych::JSON::TreeBuilder …\n"],["Psych::Nodes","","Psych/Nodes.html","","<p>Overview\n<p>When using Psych.load to deserialize a YAML document, the document is translated to an intermediary …\n"],["Psych::Nodes::Alias","","Psych/Nodes/Alias.html","","<p>This class represents a YAML Alias. It points to an <code>anchor</code>.\n<p>A Psych::Nodes::Alias is a terminal node and …\n"],["Psych::Nodes::Document","","Psych/Nodes/Document.html","","<p>This represents a YAML Document.  This node must be a child of Psych::Nodes::Stream.  A Psych::Nodes::Document …\n"],["Psych::Nodes::Mapping","","Psych/Nodes/Mapping.html","","<p>This class represents a YAML Mapping.\n<p>A Psych::Nodes::Mapping node may have 0 or more children, but must …\n"],["Psych::Nodes::Node","","Psych/Nodes/Node.html","","<p>The base class for any Node in a YAML parse tree.  This class should never be instantiated.\n"],["Psych::Nodes::Scalar","","Psych/Nodes/Scalar.html","","<p>This class represents a YAML Scalar.\n<p>This node type is a terminal node and should not have any children. …\n"],["Psych::Nodes::Sequence","","Psych/Nodes/Sequence.html","","<p>This class represents a YAML sequence.\n<p>A YAML sequence is basically a list, and looks like this:\n\n<pre>%YAML ...</pre>\n"],["Psych::Nodes::Stream","","Psych/Nodes/Stream.html","","<p>Represents a YAML stream.  This is the root node for any YAML parse tree.  This node must have one or …\n"],["Psych::Omap","","Psych/Omap.html","",""],["Psych::Parser","","Psych/Parser.html","","<p>YAML event parser class.  This class parses a YAML document and calls events on the handler that is passed …\n"],["Psych::Parser::Mark","","Psych/Parser/Mark.html","",""],["Psych::ScalarScanner","","Psych/ScalarScanner.html","","<p>Scan scalars for built in types\n"],["Psych::Set","","Psych/Set.html","",""],["Psych::Stream","","Psych/Stream.html","","<p>Psych::Stream is a streaming YAML emitter.  It will not buffer your YAML, but send it straight to an …\n"],["Psych::Streaming","","Psych/Streaming.html","",""],["Psych::Streaming::ClassMethods","","Psych/Streaming/ClassMethods.html","",""],["Psych::SyntaxError","","Psych/SyntaxError.html","",""],["Psych::TreeBuilder","","Psych/TreeBuilder.html","","<p>This class works in conjunction with Psych::Parser to build an in-memory parse tree that represents a …\n"],["Psych::Visitors","","Psych/Visitors.html","",""],["Psych::Visitors::DepthFirst","","Psych/Visitors/DepthFirst.html","",""],["Psych::Visitors::Emitter","","Psych/Visitors/Emitter.html","",""],["Psych::Visitors::JSONTree","","Psych/Visitors/JSONTree.html","",""],["Psych::Visitors::NoAliasRuby","","Psych/Visitors/NoAliasRuby.html","",""],["Psych::Visitors::ToRuby","","Psych/Visitors/ToRuby.html","","<p>This class walks a YAML AST, converting each node to Ruby\n"],["Psych::Visitors::Visitor","","Psych/Visitors/Visitor.html","",""],["Psych::Visitors::YAMLTree","","Psych/Visitors/YAMLTree.html","","<p>YAMLTree builds a YAML ast given a Ruby object.  For example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">builder</span> = <span class=\"ruby-constant\">Psych</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Visitors</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">YAMLTree</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Queue","","Queue.html","","<p>The Queue class implements multi-producer, multi-consumer queues. It is especially useful in threaded …\n"],["RDoc","","RDoc.html","","<p>Gem::RDoc provides methods to generate RDoc and ri data for installed gems upon gem installation.\n<p>This …\n"],["RDoc","","RDoc.html","","<p>RDoc produces documentation for Ruby source files by parsing the source and extracting the definition …\n"],["RDoc::Alias","","RDoc/Alias.html","","<p>Represent an alias, which is an old_name/new_name pair associated with a particular context\n"],["RDoc::AnonClass","","RDoc/AnonClass.html","","<p>An anonymous class like:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-constant\">Class</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-keyword\">do</span> <span class=\"ruby-keyword\">end</span>\n</pre>\n<p>AnonClass is currently not used.\n"],["RDoc::AnyMethod","","RDoc/AnyMethod.html","","<p>AnyMethod is the base class for objects representing methods\n"],["RDoc::Attr","","RDoc/Attr.html","","<p>An attribute created by #attr, #attr_reader, #attr_writer or #attr_accessor\n"],["RDoc::ClassModule","","RDoc/ClassModule.html","","<p>ClassModule is the base class for objects representing either a class or a module.\n"],["RDoc::CodeObject","","RDoc/CodeObject.html","","<p>Base class for the RDoc code tree.\n<p>We contain the common stuff for contexts (which are containers) and …\n"],["RDoc::Comment","","RDoc/Comment.html","","<p>A comment holds the text comment for a RDoc::CodeObject and provides a unified way of cleaning it up …\n"],["RDoc::Constant","","RDoc/Constant.html","","<p>A constant\n"],["RDoc::Context","","RDoc/Context.html","","<p>A Context is something that can hold modules, classes, methods, attributes, aliases, requires, and includes. …\n"],["RDoc::CrossReference","","RDoc/CrossReference.html","","<p>RDoc::CrossReference is a reusable way to create cross references for names.\n"],["RDoc::ERBIO","","RDoc/ERBIO.html","","<p>A subclass of ERB that writes directly to an IO.  Credit to Aaron Patterson and Masatoshi SEKI.\n<p>To use: …\n"],["RDoc::ERBPartial","","RDoc/ERBPartial.html","","<p>Allows an ERB template to be rendered in the context (binding) of an existing ERB template evaluation. …\n"],["RDoc::Encoding","","RDoc/Encoding.html","","<p>This class is a wrapper around File IO and Encoding that helps RDoc load files and convert them to the …\n"],["RDoc::Error","","RDoc/Error.html","","<p>Exception thrown by any rdoc error.\n"],["RDoc::Extend","","RDoc/Extend.html","","<p>A Module extension to a class with #extend\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">RDoc</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Extend</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-string\">&#39;Enumerable&#39;</span>, <span class=\"ruby-string\">&#39;comment ...&#39;</span>\n</pre>\n"],["RDoc::Generator","","RDoc/Generator.html","","<p>RDoc uses generators to turn parsed source code in the form of an RDoc::CodeObject tree into some form …\n"],["RDoc::GhostMethod","","RDoc/GhostMethod.html","","<p>GhostMethod represents a method referenced only by a comment\n"],["RDoc::I18n","","RDoc/I18n.html","","<p>This module provides i18n related features.\n"],["RDoc::Include","","RDoc/Include.html","","<p>A Module included in a class with #include\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">RDoc</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Include</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-string\">&#39;Enumerable&#39;</span>, <span class=\"ruby-string\">&#39;comment ...&#39;</span>\n</pre>\n"],["RDoc::Markdown","","RDoc/Markdown.html","","<p>RDoc::Markdown as described by the markdown syntax.\n<p>To choose Markdown as your only default format see …\n"],["RDoc::Markdown::MemoEntry","","RDoc/Markdown/MemoEntry.html","",""],["RDoc::Markdown::ParseError","","RDoc/Markdown/ParseError.html","",""],["RDoc::Markdown::RuleInfo","","RDoc/Markdown/RuleInfo.html","",""],["RDoc::Markup","","RDoc/Markup.html","","<p>RDoc::Markup parses plain text documents and attempts to decompose them into their constituent parts. …\n"],["RDoc::MetaMethod","","RDoc/MetaMethod.html","","<p>MetaMethod represents a meta-programmed method\n"],["RDoc::MethodAttr","","RDoc/MethodAttr.html","","<p>Abstract class representing either a method or an attribute.\n"],["RDoc::Mixin","","RDoc/Mixin.html","","<p>A Mixin adds features from a module into another context.  RDoc::Include and RDoc::Extend are both mixins. …\n"],["RDoc::NormalClass","","RDoc/NormalClass.html","","<p>A normal class, neither singleton nor anonymous\n"],["RDoc::NormalModule","","RDoc/NormalModule.html","","<p>A normal module, like NormalClass\n"],["RDoc::Options","","RDoc/Options.html","","<p>RDoc::Options handles the parsing and storage of options\n<p>Saved Options\n<p>You can save some options like the …\n"],["RDoc::Parser","","RDoc/Parser.html","","<p>A parser is simple a class that subclasses RDoc::Parser and implements #scan to fill in an RDoc::TopLevel …\n"],["RDoc::Parser::C","","RDoc/Parser/C.html","","<p>RDoc::Parser::C attempts to parse C extension files.  It looks for the standard patterns that you find …\n"],["RDoc::Parser::ChangeLog","","RDoc/Parser/ChangeLog.html","","<p>A ChangeLog file parser.\n<p>This parser converts a ChangeLog into an RDoc::Markup::Document.  When viewed …\n"],["RDoc::Parser::Markdown","","RDoc/Parser/Markdown.html","","<p>Parse a Markdown format file.  The parsed RDoc::Markup::Document is attached as a file comment.\n"],["RDoc::Parser::RD","","RDoc/Parser/RD.html","","<p>Parse a RD format file.  The parsed RDoc::Markup::Document is attached as a file comment.\n"],["RDoc::Parser::RipperStateLex","","RDoc/Parser/RipperStateLex.html","",""],["RDoc::Parser::RipperStateLex::InnerStateLex","","RDoc/Parser/RipperStateLex/InnerStateLex.html","",""],["RDoc::Parser::Ruby","","RDoc/Parser/Ruby.html","",""],["RDoc::Parser::RubyTools","","RDoc/Parser/RubyTools.html","","<p>Collection of methods for writing parsers\n"],["RDoc::Parser::Simple","","RDoc/Parser/Simple.html","","<p>Parse a non-source file. We basically take the whole thing as one big comment.\n"],["RDoc::Parser::Text","","RDoc/Parser/Text.html","","<p>Indicates this parser is text and doesn&#39;t contain code constructs.\n<p>Include this module in a RDoc::Parser …\n"],["RDoc::RD","","RDoc/RD.html","","<p>RDoc::RD implements the RD format from the rdtool gem.\n<p>To choose RD as your only default format see RDoc::Options@Saved+Options …\n"],["RDoc::RDoc","","RDoc/RDoc.html","","<p>This is the driver for generating RDoc output.  It handles file parsing and generation of output.\n<p>To use …\n"],["RDoc::RI","","RDoc/RI.html","","<p>Namespace for the ri command line tool&#39;s implementation.\n<p>See <code>ri --help</code> for details.\n"],["RDoc::RI::Error","","RDoc/RI/Error.html","","<p>Base RI error class\n"],["RDoc::Require","","RDoc/Require.html","","<p>A file loaded by #require\n"],["RDoc::RubygemsHook","","RDoc/RubygemsHook.html","","<p>Gem::RDoc provides methods to generate RDoc and ri data for installed gems upon gem installation.\n<p>This …\n"],["RDoc::Servlet","","RDoc/Servlet.html","","<p>This is a WEBrick servlet that allows you to browse ri documentation.\n<p>You can show documentation through …\n"],["RDoc::SingleClass","","RDoc/SingleClass.html","","<p>A singleton class\n"],["RDoc::Stats","","RDoc/Stats.html","","<p>RDoc statistics collector which prints a summary and report of a project&#39;s documentation totals. …\n"],["RDoc::Store","","RDoc/Store.html","","<p>A set of rdoc data for a single project (gem, path, etc.).\n<p>The store manages reading and writing ri data …\n"],["RDoc::Store::Error","","RDoc/Store/Error.html","","<p>Errors raised from loading or saving the store\n"],["RDoc::Store::MissingFileError","","RDoc/Store/MissingFileError.html","","<p>Raised when a stored file for a class, module, page or method is missing.\n"],["RDoc::Task","","RDoc/Task.html","","<p>RDoc::Task creates the following rake tasks to generate and clean up RDoc output:\n<p>rdoc &mdash; Main task for this …\n"],["RDoc::Text","","RDoc/Text.html","","<p>Methods for manipulating comment text\n"],["RDoc::TokenStream","","RDoc/TokenStream.html","","<p>A TokenStream is a list of tokens, gathered during the parse of some entity (say a method). Entities …\n"],["RDoc::TomDoc","","RDoc/TomDoc.html","","<p>A parser for TomDoc based on TomDoc 1.0.0-rc1 (02adef9b5a)\n<p>The TomDoc specification can be found at:\n<p>tomdoc.org …\n"],["RDoc::TopLevel","","RDoc/TopLevel.html","","<p>A TopLevel context is a representation of the contents of a single file\n"],["RDocTask","","RDocTask.html","","<p>RDoc::Task creates the following rake tasks to generate and clean up RDoc output:\n<p>rdoc &mdash; Main task for this …\n"],["REXML","","REXML.html","","<p> :element, parent, name, attributes, children*  &mdash; a = Node.new a &lt;&lt; “B”            # =&gt; …\n\n"],["REXML::AttlistDecl","","REXML/AttlistDecl.html","","<p>This class needs:\n<p>Documentation\n<p>Work!  Not all types of attlists are intelligently parsed, so we just\n"],["REXML::Attribute","","REXML/Attribute.html","","<p>Defines an Element Attribute; IE, a attribute=value pair, as in: &lt;element attribute=“value”/&gt;. …\n"],["REXML::Attributes","","REXML/Attributes.html","","<p>A class that defines the set of Attributes of an Element and provides operations for accessing elements …\n"],["REXML::CData","","REXML/CData.html","",""],["REXML::Child","","REXML/Child.html","","<p>A Child object is something contained by a parent, and this class contains methods to support that.  …\n"],["REXML::Comment","","REXML/Comment.html","","<p>Represents an XML comment; that is, text between &lt;!– … –&gt;\n"],["REXML::DTD","","REXML/DTD.html","",""],["REXML::DTD::AttlistDecl","","REXML/DTD/AttlistDecl.html","",""],["REXML::DTD::ElementDecl","","REXML/DTD/ElementDecl.html","",""],["REXML::DTD::EntityDecl","","REXML/DTD/EntityDecl.html","",""],["REXML::DTD::NotationDecl","","REXML/DTD/NotationDecl.html","",""],["REXML::DTD::Parser","","REXML/DTD/Parser.html","",""],["REXML::Declaration","","REXML/Declaration.html","","<p>This is an abstract class.  You never use this directly; it serves as a parent class for the specific …\n"],["REXML::DocType","","REXML/DocType.html","","<p>Represents an XML DOCTYPE declaration; that is, the contents of &lt;!DOCTYPE … &gt;.  DOCTYPES can …\n"],["REXML::Document","","REXML/Document.html","","<p>Represents a full XML document, including PIs, a doctype, etc.  A Document has a single child that can …\n"],["REXML::Element","","REXML/Element.html","","<p>Represents a tagged XML element.  Elements are characterized by having children, attributes, and names, …\n"],["REXML::ElementDecl","","REXML/ElementDecl.html","",""],["REXML::Elements","","REXML/Elements.html","","<p>A class which provides filtering of children for Elements, and XPath search support.  You are expected …\n"],["REXML::Encoding","","REXML/Encoding.html","",""],["REXML::Entity","","REXML/Entity.html","",""],["REXML::EntityConst","","REXML/EntityConst.html","","<p>This is a set of entity constants – the ones defined in the XML specification.  These are <code>gt</code>, <code>lt</code>, <code>amp</code> …\n"],["REXML::ExternalEntity","","REXML/ExternalEntity.html","",""],["REXML::Formatters","","REXML/Formatters.html","",""],["REXML::Formatters::Default","","REXML/Formatters/Default.html","",""],["REXML::Formatters::Pretty","","REXML/Formatters/Pretty.html","","<p>Pretty-prints an XML document.  This destroys whitespace in text nodes and will insert carriage returns …\n"],["REXML::Formatters::Transitive","","REXML/Formatters/Transitive.html","","<p>The Transitive formatter writes an XML document that parses to an identical document as the source document. …\n"],["REXML::Functions","","REXML/Functions.html","","<p>If you add a method, keep in mind two things: (1) the first argument will always be a list of nodes from …\n"],["REXML::IOSource","","REXML/IOSource.html","","<p>A Source that wraps an IO.  See the Source class for method documentation\n"],["REXML::Instruction","","REXML/Instruction.html","","<p>Represents an XML Instruction; IE, &lt;? … ?&gt; TODO: Add parent arg (3rd arg) to constructor\n"],["REXML::Light","","REXML/Light.html","",""],["REXML::Light::Node","","REXML/Light/Node.html","","<p>Represents a tagged XML element.  Elements are characterized by having children, attributes, and names, …\n"],["REXML::Namespace","","REXML/Namespace.html","","<p>Adds named attributes to an object.\n"],["REXML::Node","","REXML/Node.html","","<p>Represents a node in the tree.  Nodes are never encountered except as superclasses of other objects. …\n"],["REXML::NotationDecl","","REXML/NotationDecl.html","",""],["REXML::Output","","REXML/Output.html","",""],["REXML::Parent","","REXML/Parent.html","","<p>A parent has children, and has methods for accessing them.  The Parent class is never encountered except …\n"],["REXML::ParseException","","REXML/ParseException.html","",""],["REXML::Parsers","","REXML/Parsers.html","",""],["REXML::Parsers::BaseParser","","REXML/Parsers/BaseParser.html","","<p>Using the Pull Parser\n<p><em>This API is experimental, and subject to change.</em>\n\n<pre>parser = PullParser.new( &quot;&lt;a&gt;text&lt;b ...</pre>\n"],["REXML::Parsers::LightParser","","REXML/Parsers/LightParser.html","",""],["REXML::Parsers::PullEvent","","REXML/Parsers/PullEvent.html","","<p>A parsing event.  The contents of the event are accessed as an +Array?, and the type is given either …\n"],["REXML::Parsers::PullParser","","REXML/Parsers/PullParser.html","","<p>Using the Pull Parser\n<p><em>This API is experimental, and subject to change.</em>\n\n<pre>parser = PullParser.new( &quot;&lt;a&gt;text&lt;b ...</pre>\n"],["REXML::Parsers::SAX2Parser","","REXML/Parsers/SAX2Parser.html","","<p>SAX2Parser\n"],["REXML::Parsers::StreamParser","","REXML/Parsers/StreamParser.html","",""],["REXML::Parsers::TreeParser","","REXML/Parsers/TreeParser.html","",""],["REXML::Parsers::UltraLightParser","","REXML/Parsers/UltraLightParser.html","",""],["REXML::Parsers::XPathParser","","REXML/Parsers/XPathParser.html","","<p>You don&#39;t want to use this class.  Really.  Use XPath, which is a wrapper for this class.  Believe …\n"],["REXML::QuickPath","","REXML/QuickPath.html","",""],["REXML::ReferenceWriter","","REXML/ReferenceWriter.html","",""],["REXML::SAX2Listener","","REXML/SAX2Listener.html","","<p>A template for stream parser listeners. Note that the declarations (attlistdecl, elementdecl, etc) are …\n"],["REXML::Security","","REXML/Security.html","",""],["REXML::Source","","REXML/Source.html","","<p>A Source can be searched for patterns, and wraps buffers and other objects and provides consumption of …\n"],["REXML::SourceFactory","","REXML/SourceFactory.html","","<p>Generates Source-s.  USE THIS CLASS.\n"],["REXML::StreamListener","","REXML/StreamListener.html","","<p>A template for stream parser listeners. Note that the declarations (attlistdecl, elementdecl, etc) are …\n"],["REXML::Text","","REXML/Text.html","","<p>Represents text nodes in an XML document\n"],["REXML::UndefinedNamespaceException","","REXML/UndefinedNamespaceException.html","",""],["REXML::Validation","","REXML/Validation.html","",""],["REXML::Validation::Choice","","REXML/Validation/Choice.html","",""],["REXML::Validation::Event","","REXML/Validation/Event.html","",""],["REXML::Validation::Interleave","","REXML/Validation/Interleave.html","",""],["REXML::Validation::OneOrMore","","REXML/Validation/OneOrMore.html","",""],["REXML::Validation::Optional","","REXML/Validation/Optional.html","",""],["REXML::Validation::Ref","","REXML/Validation/Ref.html","",""],["REXML::Validation::RelaxNG","","REXML/Validation/RelaxNG.html","","<p>Implemented:\n<p>empty\n<p>element\n"],["REXML::Validation::Sequence","","REXML/Validation/Sequence.html","",""],["REXML::Validation::State","","REXML/Validation/State.html","",""],["REXML::Validation::ValidationException","","REXML/Validation/ValidationException.html","",""],["REXML::Validation::Validator","","REXML/Validation/Validator.html","",""],["REXML::Validation::ZeroOrMore","","REXML/Validation/ZeroOrMore.html","",""],["REXML::XMLDecl","","REXML/XMLDecl.html","","<p>NEEDS DOCUMENTATION\n"],["REXML::XMLTokens","","REXML/XMLTokens.html","","<p>Defines a number of tokens used for parsing XML.  Not for general consumption.\n"],["REXML::XPath","","REXML/XPath.html","","<p>Wrapper class.  Use this class to access the XPath functions.\n"],["REXML::XPathNode","","REXML/XPathNode.html","","<p>@private\n"],["REXML::XPathParser","","REXML/XPathParser.html","","<p>You don&#39;t want to use this class.  Really.  Use XPath, which is a wrapper for this class.  Believe …\n"],["RSS","","RSS.html","","<p>RSS reading and writing\n<p>Really Simple Syndication (RSS) is a family of formats that describe &#39;feeds,&#39; …\n"],["RSS::Atom","","RSS/Atom.html","","<p>Atom is an XML-based document format that is used to describe &#39;feeds&#39; of related information. …\n"],["RSS::Atom::CommonModel","","RSS/Atom/CommonModel.html","",""],["RSS::Atom::ContentModel","","RSS/Atom/ContentModel.html","",""],["RSS::Atom::ContentModel::ClassMethods","","RSS/Atom/ContentModel/ClassMethods.html","",""],["RSS::Atom::DateConstruct","","RSS/Atom/DateConstruct.html","","<p>Element used to describe an Atom date and time in the ISO 8601 format\n<p>Examples:\n<p>2013-03-04T15:30:02Z\n"],["RSS::Atom::DuplicateLinkChecker","","RSS/Atom/DuplicateLinkChecker.html","",""],["RSS::Atom::Entry","","RSS/Atom/Entry.html","","<p>Defines a top-level Atom Entry element, used as the document element of a stand-alone Atom Entry Document …\n"],["RSS::Atom::Feed","","RSS/Atom/Feed.html","","<p>Defines the top-level element of an Atom Feed Document. It consists of a number of children Entry elements, …\n"],["RSS::Atom::Feed::Author","","RSS/Atom/Feed/Author.html","","<p>PersonConstruct that contains information regarding the author of a Feed or Entry.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.author …\n"],["RSS::Atom::Feed::Category","","RSS/Atom/Feed/Category.html","","<p>Contains information about a category associated with a Feed or Entry. It has the following attributes: …\n"],["RSS::Atom::Feed::Contributor","","RSS/Atom/Feed/Contributor.html","","<p>PersonConstruct that contains information regarding the contributors of a Feed or Entry.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.contributor …\n"],["RSS::Atom::Feed::Entry","","RSS/Atom/Feed/Entry.html","","<p>Defines a child Atom Entry element of an Atom Feed element. It has the following attributes:\n<p>author\n<p>category …\n"],["RSS::Atom::Feed::Entry::Content","","RSS/Atom/Feed/Entry/Content.html","","<p>Contains or links to the content of the Entry. It has the following attributes:\n<p>type\n<p>src\n"],["RSS::Atom::Feed::Entry::Published","","RSS/Atom/Feed/Entry/Published.html","","<p>DateConstruct that usually indicates the time of the initial creation of an Entry.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.published …\n"],["RSS::Atom::Feed::Entry::Source","","RSS/Atom/Feed/Entry/Source.html","","<p>Defines a Atom Source element. It has the following attributes:\n<p>author\n<p>category\n"],["RSS::Atom::Feed::Entry::Summary","","RSS/Atom/Feed/Entry/Summary.html","","<p>TextConstruct that describes a summary of the Entry.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.summary …\n"],["RSS::Atom::Feed::Generator","","RSS/Atom/Feed/Generator.html","","<p>Contains information on the agent used to generate the feed.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.generator …\n"],["RSS::Atom::Feed::Icon","","RSS/Atom/Feed/Icon.html","","<p>Defines an image that provides a visual identification for a eed. The image should have an aspect ratio …\n"],["RSS::Atom::Feed::Id","","RSS/Atom/Feed/Id.html","","<p>Defines the Universally Unique Identifier (UUID) for a Feed or Entry.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.id …\n"],["RSS::Atom::Feed::Link","","RSS/Atom/Feed/Link.html","","<p>Defines a reference to a Web resource. It has the following attributes:\n<p>href\n<p>rel\n"],["RSS::Atom::Feed::Logo","","RSS/Atom/Feed/Logo.html","","<p>Defines an image that provides a visual identification for the Feed. The image should have an aspect …\n"],["RSS::Atom::Feed::Rights","","RSS/Atom/Feed/Rights.html","","<p>TextConstruct that contains copyright information regarding the content in an Entry or Feed. It should …\n"],["RSS::Atom::Feed::Subtitle","","RSS/Atom/Feed/Subtitle.html","","<p>TextConstruct that conveys a description or subtitle for a Feed.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.subtitle …\n"],["RSS::Atom::Feed::Title","","RSS/Atom/Feed/Title.html","","<p>TextConstruct that conveys a description or title for a Feed or Entry.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.title …\n"],["RSS::Atom::Feed::Updated","","RSS/Atom/Feed/Updated.html","","<p>DateConstruct indicating the most recent time when a Feed or Entry was modified in a way the publisher …\n"],["RSS::Atom::PersonConstruct","","RSS/Atom/PersonConstruct.html","","<p>The PersonConstruct module is used to define a person Atom element that can be used to describe a person, …\n"],["RSS::Atom::PersonConstruct::Email","","RSS/Atom/PersonConstruct/Email.html","","<p>The email of the person or entity.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.email\n"],["RSS::Atom::PersonConstruct::Name","","RSS/Atom/PersonConstruct/Name.html","","<p>The name of the person or entity.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.name\n"],["RSS::Atom::PersonConstruct::Uri","","RSS/Atom/PersonConstruct/Uri.html","","<p>The URI of the person or entity.\n<p>Reference: validator.w3.org/feed/docs/rfc4287.html#element.uri\n"],["RSS::Atom::TextConstruct","","RSS/Atom/TextConstruct.html","","<p>The TextConstruct module is used to define a Text construct Atom element, which is used to store small …\n"],["RSS::Atom::URIContentModel","","RSS/Atom/URIContentModel.html","",""],["RSS::BaseDublinCoreModel","","RSS/BaseDublinCoreModel.html","",""],["RSS::BaseListener","","RSS/BaseListener.html","",""],["RSS::BaseModel","","RSS/BaseModel.html","",""],["RSS::BaseParser","","RSS/BaseParser.html","",""],["RSS::BaseTrackBackModel","","RSS/BaseTrackBackModel.html","",""],["RSS::ContentModel","","RSS/ContentModel.html","",""],["RSS::ConversionError","","RSS/ConversionError.html","","<p>Raised when a conversion failure occurs.\n"],["RSS::Converter","","RSS/Converter.html","",""],["RSS::DublinCoreModel","","RSS/DublinCoreModel.html","",""],["RSS::DublincoreModel","","RSS/DublinCoreModel.html","",""],["RSS::Element","","RSS/Element.html","",""],["RSS::Error","","RSS/Error.html","","<p>The basic error all other RSS errors stem from. Rescue this error if you want to handle any given RSS …\n"],["RSS::ITunesBaseModel","","RSS/ITunesBaseModel.html","",""],["RSS::ITunesChannelModel","","RSS/ITunesChannelModel.html","",""],["RSS::ITunesChannelModel::ITunesCategory","","RSS/ITunesChannelModel/ITunesCategory.html","",""],["RSS::ITunesChannelModel::ITunesImage","","RSS/ITunesChannelModel/ITunesImage.html","",""],["RSS::ITunesChannelModel::ITunesOwner","","RSS/ITunesChannelModel/ITunesOwner.html","",""],["RSS::ITunesItemModel","","RSS/ITunesItemModel.html","",""],["RSS::ITunesItemModel::ITunesDuration","","RSS/ITunesItemModel/ITunesDuration.html","",""],["RSS::ITunesModelUtils","","RSS/ITunesModelUtils.html","",""],["RSS::ImageFaviconModel","","RSS/ImageFaviconModel.html","",""],["RSS::ImageFaviconModel::ImageFavicon","","RSS/ImageFaviconModel/ImageFavicon.html","",""],["RSS::ImageItemModel","","RSS/ImageItemModel.html","",""],["RSS::ImageItemModel::ImageItem","","RSS/ImageItemModel/ImageItem.html","",""],["RSS::ImageModelUtils","","RSS/ImageModelUtils.html","",""],["RSS::InvalidRSSError","","RSS/InvalidRSSError.html","","<p>The InvalidRSSError error is the base class for a variety of errors related to a poorly-formed RSS feed. …\n"],["RSS::ListenerMixin","","RSS/ListenerMixin.html","",""],["RSS::Maker","","RSS/Maker.html","","<p>Provides a set of builders for various RSS objects\n<p>Feeds\n<p>RSS 0.91\n"],["RSS::Maker::Atom","","RSS/Maker/Atom.html","",""],["RSS::Maker::Atom::Entry","","RSS/Maker/Atom/Entry.html","",""],["RSS::Maker::Atom::Entry::Channel","","RSS/Maker/Atom/Entry/Channel.html","",""],["RSS::Maker::Atom::Entry::Channel::Cloud","","RSS/Maker/Atom/Entry/Channel/Cloud.html","",""],["RSS::Maker::Atom::Entry::Channel::Description","","RSS/Maker/Atom/Entry/Channel/Description.html","",""],["RSS::Maker::Atom::Entry::Channel::Generator","","RSS/Maker/Atom/Entry/Channel/Generator.html","",""],["RSS::Maker::Atom::Entry::Channel::SkipDays","","RSS/Maker/Atom/Entry/Channel/SkipDays.html","",""],["RSS::Maker::Atom::Entry::Channel::SkipDays::Day","","RSS/Maker/Atom/Entry/Channel/SkipDays/Day.html","",""],["RSS::Maker::Atom::Entry::Channel::SkipHours","","RSS/Maker/Atom/Entry/Channel/SkipHours.html","",""],["RSS::Maker::Atom::Entry::Channel::SkipHours::Hour","","RSS/Maker/Atom/Entry/Channel/SkipHours/Hour.html","",""],["RSS::Maker::Atom::Entry::Image","","RSS/Maker/Atom/Entry/Image.html","",""],["RSS::Maker::Atom::Entry::Items","","RSS/Maker/Atom/Entry/Items.html","",""],["RSS::Maker::Atom::Entry::Items::Item","","RSS/Maker/Atom/Entry/Items/Item.html","",""],["RSS::Maker::Atom::Entry::Textinput","","RSS/Maker/Atom/Entry/Textinput.html","",""],["RSS::Maker::Atom::Feed","","RSS/Maker/Atom/Feed.html","",""],["RSS::Maker::Atom::Feed::Channel","","RSS/Maker/Atom/Feed/Channel.html","",""],["RSS::Maker::Atom::Feed::Channel::Categories","","RSS/Maker/Atom/Feed/Channel/Categories.html","",""],["RSS::Maker::Atom::Feed::Channel::Categories::Category","","RSS/Maker/Atom/Feed/Channel/Categories/Category.html","",""],["RSS::Maker::Atom::Feed::Channel::Cloud","","RSS/Maker/Atom/Feed/Channel/Cloud.html","",""],["RSS::Maker::Atom::Feed::Channel::Generator","","RSS/Maker/Atom/Feed/Channel/Generator.html","",""],["RSS::Maker::Atom::Feed::Channel::Links","","RSS/Maker/Atom/Feed/Channel/Links.html","",""],["RSS::Maker::Atom::Feed::Channel::Links::Link","","RSS/Maker/Atom/Feed/Channel/Links/Link.html","",""],["RSS::Maker::Atom::Feed::Channel::SkipDays","","RSS/Maker/Atom/Feed/Channel/SkipDays.html","",""],["RSS::Maker::Atom::Feed::Channel::SkipDays::Day","","RSS/Maker/Atom/Feed/Channel/SkipDays/Day.html","",""],["RSS::Maker::Atom::Feed::Channel::SkipHours","","RSS/Maker/Atom/Feed/Channel/SkipHours.html","",""],["RSS::Maker::Atom::Feed::Channel::SkipHours::Hour","","RSS/Maker/Atom/Feed/Channel/SkipHours/Hour.html","",""],["RSS::Maker::Atom::Feed::Image","","RSS/Maker/Atom/Feed/Image.html","",""],["RSS::Maker::Atom::Feed::Items","","RSS/Maker/Atom/Feed/Items.html","",""],["RSS::Maker::Atom::Feed::Items::Item","","RSS/Maker/Atom/Feed/Items/Item.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Categories","","RSS/Maker/Atom/Feed/Items/Item/Categories.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Categories::Category","","RSS/Maker/Atom/Feed/Items/Item/Categories/Category.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Content","","RSS/Maker/Atom/Feed/Items/Item/Content.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Enclosure","","RSS/Maker/Atom/Feed/Items/Item/Enclosure.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Guid","","RSS/Maker/Atom/Feed/Items/Item/Guid.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Links","","RSS/Maker/Atom/Feed/Items/Item/Links.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Links::Link","","RSS/Maker/Atom/Feed/Items/Item/Links/Link.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source","","RSS/Maker/Atom/Feed/Items/Item/Source.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source::Categories","","RSS/Maker/Atom/Feed/Items/Item/Source/Categories.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source::Categories::Category","","RSS/Maker/Atom/Feed/Items/Item/Source/Categories/Category.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source::Generator","","RSS/Maker/Atom/Feed/Items/Item/Source/Generator.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source::Icon","","RSS/Maker/Atom/Feed/Items/Item/Source/Icon.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source::Links","","RSS/Maker/Atom/Feed/Items/Item/Source/Links.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source::Links::Link","","RSS/Maker/Atom/Feed/Items/Item/Source/Links/Link.html","",""],["RSS::Maker::Atom::Feed::Items::Item::Source::Logo","","RSS/Maker/Atom/Feed/Items/Item/Source/Logo.html","",""],["RSS::Maker::Atom::Feed::Textinput","","RSS/Maker/Atom/Feed/Textinput.html","",""],["RSS::Maker::AtomCategory","","RSS/Maker/AtomCategory.html","",""],["RSS::Maker::AtomGenerator","","RSS/Maker/AtomGenerator.html","",""],["RSS::Maker::AtomLink","","RSS/Maker/AtomLink.html","",""],["RSS::Maker::AtomLogo","","RSS/Maker/AtomLogo.html","",""],["RSS::Maker::AtomPersonConstructBase","","RSS/Maker/AtomPersonConstructBase.html","",""],["RSS::Maker::AtomPersons","","RSS/Maker/AtomPersons.html","",""],["RSS::Maker::AtomTextConstruct","","RSS/Maker/AtomTextConstruct.html","",""],["RSS::Maker::AtomTextConstructBase","","RSS/Maker/AtomTextConstructBase.html","",""],["RSS::Maker::AtomTextConstructBase::EnsureXMLContent","","RSS/Maker/AtomTextConstructBase/EnsureXMLContent.html","",""],["RSS::Maker::Base","","RSS/Maker/Base.html","",""],["RSS::Maker::ChannelBase","","RSS/Maker/ChannelBase.html","",""],["RSS::Maker::ChannelBase::AuthorsBase","","RSS/Maker/ChannelBase/AuthorsBase.html","",""],["RSS::Maker::ChannelBase::AuthorsBase::AuthorBase","","RSS/Maker/ChannelBase/AuthorsBase/AuthorBase.html","",""],["RSS::Maker::ChannelBase::CategoriesBase","","RSS/Maker/ChannelBase/CategoriesBase.html","",""],["RSS::Maker::ChannelBase::CategoriesBase::CategoryBase","","RSS/Maker/ChannelBase/CategoriesBase/CategoryBase.html","",""],["RSS::Maker::ChannelBase::CloudBase","","RSS/Maker/ChannelBase/CloudBase.html","",""],["RSS::Maker::ChannelBase::ContributorsBase","","RSS/Maker/ChannelBase/ContributorsBase.html","",""],["RSS::Maker::ChannelBase::ContributorsBase::ContributorBase","","RSS/Maker/ChannelBase/ContributorsBase/ContributorBase.html","",""],["RSS::Maker::ChannelBase::CopyrightBase","","RSS/Maker/ChannelBase/CopyrightBase.html","",""],["RSS::Maker::ChannelBase::DescriptionBase","","RSS/Maker/ChannelBase/DescriptionBase.html","",""],["RSS::Maker::ChannelBase::GeneratorBase","","RSS/Maker/ChannelBase/GeneratorBase.html","",""],["RSS::Maker::ChannelBase::ITunesCategories","","RSS/Maker/ChannelBase/ITunesCategories.html","",""],["RSS::Maker::ChannelBase::ITunesCategories::ITunesCategory","","RSS/Maker/ChannelBase/ITunesCategories/ITunesCategory.html","",""],["RSS::Maker::ChannelBase::ITunesImage","","RSS/Maker/ChannelBase/ITunesImage.html","",""],["RSS::Maker::ChannelBase::ITunesOwner","","RSS/Maker/ChannelBase/ITunesOwner.html","",""],["RSS::Maker::ChannelBase::LinksBase","","RSS/Maker/ChannelBase/LinksBase.html","",""],["RSS::Maker::ChannelBase::LinksBase::LinkBase","","RSS/Maker/ChannelBase/LinksBase/LinkBase.html","",""],["RSS::Maker::ChannelBase::SkipDaysBase","","RSS/Maker/ChannelBase/SkipDaysBase.html","",""],["RSS::Maker::ChannelBase::SkipDaysBase::DayBase","","RSS/Maker/ChannelBase/SkipDaysBase/DayBase.html","",""],["RSS::Maker::ChannelBase::SkipHoursBase","","RSS/Maker/ChannelBase/SkipHoursBase.html","",""],["RSS::Maker::ChannelBase::SkipHoursBase::HourBase","","RSS/Maker/ChannelBase/SkipHoursBase/HourBase.html","",""],["RSS::Maker::ChannelBase::TitleBase","","RSS/Maker/ChannelBase/TitleBase.html","",""],["RSS::Maker::ContentModel","","RSS/Maker/ContentModel.html","",""],["RSS::Maker::DublinCoreModel","","RSS/Maker/DublinCoreModel.html","",""],["RSS::Maker::ITunesBaseModel","","RSS/Maker/ITunesBaseModel.html","",""],["RSS::Maker::ITunesChannelModel","","RSS/Maker/ITunesChannelModel.html","",""],["RSS::Maker::ITunesChannelModel::ITunesCategoriesBase","","RSS/Maker/ITunesChannelModel/ITunesCategoriesBase.html","",""],["RSS::Maker::ITunesChannelModel::ITunesCategoriesBase::ITunesCategoryBase","","RSS/Maker/ITunesChannelModel/ITunesCategoriesBase/ITunesCategoryBase.html","",""],["RSS::Maker::ITunesChannelModel::ITunesImageBase","","RSS/Maker/ITunesChannelModel/ITunesImageBase.html","",""],["RSS::Maker::ITunesChannelModel::ITunesOwnerBase","","RSS/Maker/ITunesChannelModel/ITunesOwnerBase.html","",""],["RSS::Maker::ITunesItemModel","","RSS/Maker/ITunesItemModel.html","",""],["RSS::Maker::ITunesItemModel::ITunesDurationBase","","RSS/Maker/ITunesItemModel/ITunesDurationBase.html","",""],["RSS::Maker::ImageBase","","RSS/Maker/ImageBase.html","",""],["RSS::Maker::ImageFaviconModel","","RSS/Maker/ImageFaviconModel.html","",""],["RSS::Maker::ImageFaviconModel::ImageFaviconBase","","RSS/Maker/ImageFaviconModel/ImageFaviconBase.html","",""],["RSS::Maker::ImageItemModel","","RSS/Maker/ImageItemModel.html","",""],["RSS::Maker::ImageItemModel::ImageItemBase","","RSS/Maker/ImageItemModel/ImageItemBase.html","",""],["RSS::Maker::ItemsBase","","RSS/Maker/ItemsBase.html","",""],["RSS::Maker::ItemsBase::ItemBase","","RSS/Maker/ItemsBase/ItemBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::ContentBase","","RSS/Maker/ItemsBase/ItemBase/ContentBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::DescriptionBase","","RSS/Maker/ItemsBase/ItemBase/DescriptionBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::EnclosureBase","","RSS/Maker/ItemsBase/ItemBase/EnclosureBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::GuidBase","","RSS/Maker/ItemsBase/ItemBase/GuidBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::ITunesDuration","","RSS/Maker/ItemsBase/ItemBase/ITunesDuration.html","",""],["RSS::Maker::ItemsBase::ItemBase::RightsBase","","RSS/Maker/ItemsBase/ItemBase/RightsBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::SourceBase","","RSS/Maker/ItemsBase/ItemBase/SourceBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::SourceBase::IconBase","","RSS/Maker/ItemsBase/ItemBase/SourceBase/IconBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::SourceBase::LogoBase","","RSS/Maker/ItemsBase/ItemBase/SourceBase/LogoBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::SourceBase::RightsBase","","RSS/Maker/ItemsBase/ItemBase/SourceBase/RightsBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::SourceBase::SubtitleBase","","RSS/Maker/ItemsBase/ItemBase/SourceBase/SubtitleBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::SourceBase::TitleBase","","RSS/Maker/ItemsBase/ItemBase/SourceBase/TitleBase.html","",""],["RSS::Maker::ItemsBase::ItemBase::TitleBase","","RSS/Maker/ItemsBase/ItemBase/TitleBase.html","",""],["RSS::Maker::RSS09","","RSS/Maker/RSS09.html","",""],["RSS::Maker::RSS091","","RSS/Maker/RSS091.html","",""],["RSS::Maker::RSS091::Channel","","RSS/Maker/RSS091/Channel.html","",""],["RSS::Maker::RSS091::Image","","RSS/Maker/RSS091/Image.html","",""],["RSS::Maker::RSS091::Items","","RSS/Maker/RSS091/Items.html","",""],["RSS::Maker::RSS091::Items::Item","","RSS/Maker/RSS091/Items/Item.html","",""],["RSS::Maker::RSS091::Textinput","","RSS/Maker/RSS091/Textinput.html","",""],["RSS::Maker::RSS092","","RSS/Maker/RSS092.html","",""],["RSS::Maker::RSS092::Channel","","RSS/Maker/RSS092/Channel.html","",""],["RSS::Maker::RSS092::Image","","RSS/Maker/RSS092/Image.html","",""],["RSS::Maker::RSS092::Items","","RSS/Maker/RSS092/Items.html","",""],["RSS::Maker::RSS092::Items::Item","","RSS/Maker/RSS092/Items/Item.html","",""],["RSS::Maker::RSS092::Textinput","","RSS/Maker/RSS092/Textinput.html","",""],["RSS::Maker::RSS09::Channel","","RSS/Maker/RSS09/Channel.html","",""],["RSS::Maker::RSS09::Channel::Authors","","RSS/Maker/RSS09/Channel/Authors.html","",""],["RSS::Maker::RSS09::Channel::Authors::Author","","RSS/Maker/RSS09/Channel/Authors/Author.html","",""],["RSS::Maker::RSS09::Channel::Categories","","RSS/Maker/RSS09/Channel/Categories.html","",""],["RSS::Maker::RSS09::Channel::Categories::Category","","RSS/Maker/RSS09/Channel/Categories/Category.html","",""],["RSS::Maker::RSS09::Channel::Cloud","","RSS/Maker/RSS09/Channel/Cloud.html","",""],["RSS::Maker::RSS09::Channel::Contributors","","RSS/Maker/RSS09/Channel/Contributors.html","",""],["RSS::Maker::RSS09::Channel::Contributors::Contributor","","RSS/Maker/RSS09/Channel/Contributors/Contributor.html","",""],["RSS::Maker::RSS09::Channel::Copyright","","RSS/Maker/RSS09/Channel/Copyright.html","",""],["RSS::Maker::RSS09::Channel::Description","","RSS/Maker/RSS09/Channel/Description.html","",""],["RSS::Maker::RSS09::Channel::Generator","","RSS/Maker/RSS09/Channel/Generator.html","",""],["RSS::Maker::RSS09::Channel::Links","","RSS/Maker/RSS09/Channel/Links.html","",""],["RSS::Maker::RSS09::Channel::Links::Link","","RSS/Maker/RSS09/Channel/Links/Link.html","",""],["RSS::Maker::RSS09::Channel::SkipDays","","RSS/Maker/RSS09/Channel/SkipDays.html","",""],["RSS::Maker::RSS09::Channel::SkipDays::Day","","RSS/Maker/RSS09/Channel/SkipDays/Day.html","",""],["RSS::Maker::RSS09::Channel::SkipHours","","RSS/Maker/RSS09/Channel/SkipHours.html","",""],["RSS::Maker::RSS09::Channel::SkipHours::Hour","","RSS/Maker/RSS09/Channel/SkipHours/Hour.html","",""],["RSS::Maker::RSS09::Channel::Title","","RSS/Maker/RSS09/Channel/Title.html","",""],["RSS::Maker::RSS09::Image","","RSS/Maker/RSS09/Image.html","",""],["RSS::Maker::RSS09::Items","","RSS/Maker/RSS09/Items.html","",""],["RSS::Maker::RSS09::Items::Item","","RSS/Maker/RSS09/Items/Item.html","",""],["RSS::Maker::RSS09::Items::Item::Authors","","RSS/Maker/RSS09/Items/Item/Authors.html","",""],["RSS::Maker::RSS09::Items::Item::Authors::Author","","RSS/Maker/RSS09/Items/Item/Authors/Author.html","",""],["RSS::Maker::RSS09::Items::Item::Categories","","RSS/Maker/RSS09/Items/Item/Categories.html","",""],["RSS::Maker::RSS09::Items::Item::Categories::Category","","RSS/Maker/RSS09/Items/Item/Categories/Category.html","",""],["RSS::Maker::RSS09::Items::Item::Content","","RSS/Maker/RSS09/Items/Item/Content.html","",""],["RSS::Maker::RSS09::Items::Item::Contributors","","RSS/Maker/RSS09/Items/Item/Contributors.html","",""],["RSS::Maker::RSS09::Items::Item::Contributors::Contributor","","RSS/Maker/RSS09/Items/Item/Contributors/Contributor.html","",""],["RSS::Maker::RSS09::Items::Item::Description","","RSS/Maker/RSS09/Items/Item/Description.html","",""],["RSS::Maker::RSS09::Items::Item::Enclosure","","RSS/Maker/RSS09/Items/Item/Enclosure.html","",""],["RSS::Maker::RSS09::Items::Item::Guid","","RSS/Maker/RSS09/Items/Item/Guid.html","",""],["RSS::Maker::RSS09::Items::Item::Links","","RSS/Maker/RSS09/Items/Item/Links.html","",""],["RSS::Maker::RSS09::Items::Item::Links::Link","","RSS/Maker/RSS09/Items/Item/Links/Link.html","",""],["RSS::Maker::RSS09::Items::Item::Rights","","RSS/Maker/RSS09/Items/Item/Rights.html","",""],["RSS::Maker::RSS09::Items::Item::Source","","RSS/Maker/RSS09/Items/Item/Source.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Authors","","RSS/Maker/RSS09/Items/Item/Source/Authors.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Authors::Author","","RSS/Maker/RSS09/Items/Item/Source/Authors/Author.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Categories","","RSS/Maker/RSS09/Items/Item/Source/Categories.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Categories::Category","","RSS/Maker/RSS09/Items/Item/Source/Categories/Category.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Contributors","","RSS/Maker/RSS09/Items/Item/Source/Contributors.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Contributors::Contributor","","RSS/Maker/RSS09/Items/Item/Source/Contributors/Contributor.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Generator","","RSS/Maker/RSS09/Items/Item/Source/Generator.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Icon","","RSS/Maker/RSS09/Items/Item/Source/Icon.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Links","","RSS/Maker/RSS09/Items/Item/Source/Links.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Links::Link","","RSS/Maker/RSS09/Items/Item/Source/Links/Link.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Logo","","RSS/Maker/RSS09/Items/Item/Source/Logo.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Rights","","RSS/Maker/RSS09/Items/Item/Source/Rights.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Subtitle","","RSS/Maker/RSS09/Items/Item/Source/Subtitle.html","",""],["RSS::Maker::RSS09::Items::Item::Source::Title","","RSS/Maker/RSS09/Items/Item/Source/Title.html","",""],["RSS::Maker::RSS09::Items::Item::Title","","RSS/Maker/RSS09/Items/Item/Title.html","",""],["RSS::Maker::RSS09::Textinput","","RSS/Maker/RSS09/Textinput.html","",""],["RSS::Maker::RSS10","","RSS/Maker/RSS10.html","",""],["RSS::Maker::RSS10::Channel","","RSS/Maker/RSS10/Channel.html","",""],["RSS::Maker::RSS10::Channel::Authors","","RSS/Maker/RSS10/Channel/Authors.html","",""],["RSS::Maker::RSS10::Channel::Authors::Author","","RSS/Maker/RSS10/Channel/Authors/Author.html","",""],["RSS::Maker::RSS10::Channel::Categories","","RSS/Maker/RSS10/Channel/Categories.html","",""],["RSS::Maker::RSS10::Channel::Categories::Category","","RSS/Maker/RSS10/Channel/Categories/Category.html","",""],["RSS::Maker::RSS10::Channel::Cloud","","RSS/Maker/RSS10/Channel/Cloud.html","",""],["RSS::Maker::RSS10::Channel::Contributors","","RSS/Maker/RSS10/Channel/Contributors.html","",""],["RSS::Maker::RSS10::Channel::Contributors::Contributor","","RSS/Maker/RSS10/Channel/Contributors/Contributor.html","",""],["RSS::Maker::RSS10::Channel::Copyright","","RSS/Maker/RSS10/Channel/Copyright.html","",""],["RSS::Maker::RSS10::Channel::Description","","RSS/Maker/RSS10/Channel/Description.html","",""],["RSS::Maker::RSS10::Channel::Generator","","RSS/Maker/RSS10/Channel/Generator.html","",""],["RSS::Maker::RSS10::Channel::Links","","RSS/Maker/RSS10/Channel/Links.html","",""],["RSS::Maker::RSS10::Channel::Links::Link","","RSS/Maker/RSS10/Channel/Links/Link.html","",""],["RSS::Maker::RSS10::Channel::SkipDays","","RSS/Maker/RSS10/Channel/SkipDays.html","",""],["RSS::Maker::RSS10::Channel::SkipDays::Day","","RSS/Maker/RSS10/Channel/SkipDays/Day.html","",""],["RSS::Maker::RSS10::Channel::SkipHours","","RSS/Maker/RSS10/Channel/SkipHours.html","",""],["RSS::Maker::RSS10::Channel::SkipHours::Hour","","RSS/Maker/RSS10/Channel/SkipHours/Hour.html","",""],["RSS::Maker::RSS10::Channel::Title","","RSS/Maker/RSS10/Channel/Title.html","",""],["RSS::Maker::RSS10::Image","","RSS/Maker/RSS10/Image.html","",""],["RSS::Maker::RSS10::Items","","RSS/Maker/RSS10/Items.html","",""],["RSS::Maker::RSS10::Items::Item","","RSS/Maker/RSS10/Items/Item.html","",""],["RSS::Maker::RSS10::Items::Item::Authors","","RSS/Maker/RSS10/Items/Item/Authors.html","",""],["RSS::Maker::RSS10::Items::Item::Authors::Author","","RSS/Maker/RSS10/Items/Item/Authors/Author.html","",""],["RSS::Maker::RSS10::Items::Item::Categories","","RSS/Maker/RSS10/Items/Item/Categories.html","",""],["RSS::Maker::RSS10::Items::Item::Categories::Category","","RSS/Maker/RSS10/Items/Item/Categories/Category.html","",""],["RSS::Maker::RSS10::Items::Item::Content","","RSS/Maker/RSS10/Items/Item/Content.html","",""],["RSS::Maker::RSS10::Items::Item::Contributors","","RSS/Maker/RSS10/Items/Item/Contributors.html","",""],["RSS::Maker::RSS10::Items::Item::Contributors::Contributor","","RSS/Maker/RSS10/Items/Item/Contributors/Contributor.html","",""],["RSS::Maker::RSS10::Items::Item::Description","","RSS/Maker/RSS10/Items/Item/Description.html","",""],["RSS::Maker::RSS10::Items::Item::Enclosure","","RSS/Maker/RSS10/Items/Item/Enclosure.html","",""],["RSS::Maker::RSS10::Items::Item::Guid","","RSS/Maker/RSS10/Items/Item/Guid.html","",""],["RSS::Maker::RSS10::Items::Item::Links","","RSS/Maker/RSS10/Items/Item/Links.html","",""],["RSS::Maker::RSS10::Items::Item::Links::Link","","RSS/Maker/RSS10/Items/Item/Links/Link.html","",""],["RSS::Maker::RSS10::Items::Item::Rights","","RSS/Maker/RSS10/Items/Item/Rights.html","",""],["RSS::Maker::RSS10::Items::Item::Source","","RSS/Maker/RSS10/Items/Item/Source.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Authors","","RSS/Maker/RSS10/Items/Item/Source/Authors.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Authors::Author","","RSS/Maker/RSS10/Items/Item/Source/Authors/Author.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Categories","","RSS/Maker/RSS10/Items/Item/Source/Categories.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Categories::Category","","RSS/Maker/RSS10/Items/Item/Source/Categories/Category.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Contributors","","RSS/Maker/RSS10/Items/Item/Source/Contributors.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Contributors::Contributor","","RSS/Maker/RSS10/Items/Item/Source/Contributors/Contributor.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Generator","","RSS/Maker/RSS10/Items/Item/Source/Generator.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Icon","","RSS/Maker/RSS10/Items/Item/Source/Icon.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Links","","RSS/Maker/RSS10/Items/Item/Source/Links.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Links::Link","","RSS/Maker/RSS10/Items/Item/Source/Links/Link.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Logo","","RSS/Maker/RSS10/Items/Item/Source/Logo.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Rights","","RSS/Maker/RSS10/Items/Item/Source/Rights.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Subtitle","","RSS/Maker/RSS10/Items/Item/Source/Subtitle.html","",""],["RSS::Maker::RSS10::Items::Item::Source::Title","","RSS/Maker/RSS10/Items/Item/Source/Title.html","",""],["RSS::Maker::RSS10::Items::Item::Title","","RSS/Maker/RSS10/Items/Item/Title.html","",""],["RSS::Maker::RSS10::Textinput","","RSS/Maker/RSS10/Textinput.html","",""],["RSS::Maker::RSS20","","RSS/Maker/RSS20.html","",""],["RSS::Maker::RSS20::Channel","","RSS/Maker/RSS20/Channel.html","",""],["RSS::Maker::RSS20::Channel::Categories","","RSS/Maker/RSS20/Channel/Categories.html","",""],["RSS::Maker::RSS20::Channel::Categories::Category","","RSS/Maker/RSS20/Channel/Categories/Category.html","",""],["RSS::Maker::RSS20::Channel::Cloud","","RSS/Maker/RSS20/Channel/Cloud.html","",""],["RSS::Maker::RSS20::Channel::Generator","","RSS/Maker/RSS20/Channel/Generator.html","",""],["RSS::Maker::RSS20::Channel::SkipDays","","RSS/Maker/RSS20/Channel/SkipDays.html","",""],["RSS::Maker::RSS20::Channel::SkipDays::Day","","RSS/Maker/RSS20/Channel/SkipDays/Day.html","",""],["RSS::Maker::RSS20::Channel::SkipHours","","RSS/Maker/RSS20/Channel/SkipHours.html","",""],["RSS::Maker::RSS20::Channel::SkipHours::Hour","","RSS/Maker/RSS20/Channel/SkipHours/Hour.html","",""],["RSS::Maker::RSS20::Image","","RSS/Maker/RSS20/Image.html","",""],["RSS::Maker::RSS20::Items","","RSS/Maker/RSS20/Items.html","",""],["RSS::Maker::RSS20::Items::Item","","RSS/Maker/RSS20/Items/Item.html","",""],["RSS::Maker::RSS20::Items::Item::Authors","","RSS/Maker/RSS20/Items/Item/Authors.html","",""],["RSS::Maker::RSS20::Items::Item::Authors::Author","","RSS/Maker/RSS20/Items/Item/Authors/Author.html","",""],["RSS::Maker::RSS20::Items::Item::Categories","","RSS/Maker/RSS20/Items/Item/Categories.html","",""],["RSS::Maker::RSS20::Items::Item::Categories::Category","","RSS/Maker/RSS20/Items/Item/Categories/Category.html","",""],["RSS::Maker::RSS20::Items::Item::Enclosure","","RSS/Maker/RSS20/Items/Item/Enclosure.html","",""],["RSS::Maker::RSS20::Items::Item::Guid","","RSS/Maker/RSS20/Items/Item/Guid.html","",""],["RSS::Maker::RSS20::Items::Item::Source","","RSS/Maker/RSS20/Items/Item/Source.html","",""],["RSS::Maker::RSS20::Items::Item::Source::Links","","RSS/Maker/RSS20/Items/Item/Source/Links.html","",""],["RSS::Maker::RSS20::Items::Item::Source::Links::Link","","RSS/Maker/RSS20/Items/Item/Source/Links/Link.html","",""],["RSS::Maker::RSS20::Textinput","","RSS/Maker/RSS20/Textinput.html","",""],["RSS::Maker::RSSBase","","RSS/Maker/RSSBase.html","",""],["RSS::Maker::SetupDefaultDate","","RSS/Maker/SetupDefaultDate.html","",""],["RSS::Maker::SetupDefaultLanguage","","RSS/Maker/SetupDefaultLanguage.html","",""],["RSS::Maker::SlashModel","","RSS/Maker/SlashModel.html","",""],["RSS::Maker::SyndicationModel","","RSS/Maker/SyndicationModel.html","",""],["RSS::Maker::TaxonomyTopicModel","","RSS/Maker/TaxonomyTopicModel.html","",""],["RSS::Maker::TaxonomyTopicModel::TaxonomyTopicsBase","","RSS/Maker/TaxonomyTopicModel/TaxonomyTopicsBase.html","",""],["RSS::Maker::TaxonomyTopicModel::TaxonomyTopicsBase::TaxonomyTopicBase","","RSS/Maker/TaxonomyTopicModel/TaxonomyTopicsBase/TaxonomyTopicBase.html","",""],["RSS::Maker::TaxonomyTopicsModel","","RSS/Maker/TaxonomyTopicsModel.html","",""],["RSS::Maker::TaxonomyTopicsModel::TaxonomyTopicsBase","","RSS/Maker/TaxonomyTopicsModel/TaxonomyTopicsBase.html","",""],["RSS::Maker::TextinputBase","","RSS/Maker/TextinputBase.html","",""],["RSS::Maker::TrackBackModel","","RSS/Maker/TrackBackModel.html","",""],["RSS::Maker::TrackBackModel::TrackBackAboutsBase","","RSS/Maker/TrackBackModel/TrackBackAboutsBase.html","",""],["RSS::Maker::TrackBackModel::TrackBackAboutsBase::TrackBackAboutBase","","RSS/Maker/TrackBackModel/TrackBackAboutsBase/TrackBackAboutBase.html","",""],["RSS::Maker::XMLStyleSheets","","RSS/Maker/XMLStyleSheets.html","",""],["RSS::Maker::XMLStyleSheets::XMLStyleSheet","","RSS/Maker/XMLStyleSheets/XMLStyleSheet.html","",""],["RSS::MissingAttributeError","","RSS/MissingAttributeError.html","","<p>Certain attributes are required on specific tags in an RSS feed. If a feed is missing one of these attributes, …\n"],["RSS::MissingTagError","","RSS/MissingTagError.html","","<p>Since RSS is based on XML, it must have opening and closing tags that match. If they don&#39;t, a MissingTagError …\n"],["RSS::NSError","","RSS/NSError.html","",""],["RSS::NotAvailableValueError","","RSS/NotAvailableValueError.html","","<p>Attributes are in key-value form, and if there&#39;s no value provided for an attribute, a NotAvailableValueError …\n"],["RSS::NotExpectedTagError","","RSS/NotExpectedTagError.html","","<p>Raised when an unexpected tag is encountered.\n"],["RSS::NotSetError","","RSS/NotSetError.html","","<p>Raised when a required variable is not set.\n"],["RSS::NotValidXMLParser","","RSS/NotValidXMLParser.html","",""],["RSS::NotWellFormedError","","RSS/NotWellFormedError.html","",""],["RSS::OverlappedPrefixError","","RSS/OverlappedPrefixError.html","","<p>RSS, being an XML-based format, has namespace support. If two namespaces are declared with the same name, …\n"],["RSS::Parser","","RSS/Parser.html","",""],["RSS::RDF","","RSS/RDF.html","",""],["RSS::RDF::Bag","","RSS/RDF/Bag.html","",""],["RSS::RDF::Bag::Li","","RSS/RDF/Li.html","",""],["RSS::RDF::Channel","","RSS/RDF/Channel.html","",""],["RSS::RDF::Channel::Image","","RSS/RDF/Channel/Image.html","",""],["RSS::RDF::Channel::Items","","RSS/RDF/Channel/Items.html","",""],["RSS::RDF::Channel::Items::Seq","","RSS/RDF/Seq.html","",""],["RSS::RDF::Channel::Textinput","","RSS/RDF/Channel/Textinput.html","",""],["RSS::RDF::Image","","RSS/RDF/Image.html","",""],["RSS::RDF::Item","","RSS/RDF/Item.html","",""],["RSS::RDF::Li","","RSS/RDF/Li.html","",""],["RSS::RDF::Seq","","RSS/RDF/Seq.html","",""],["RSS::RDF::Seq::Li","","RSS/RDF/Li.html","",""],["RSS::RDF::Textinput","","RSS/RDF/Textinput.html","",""],["RSS::REXMLLikeXMLParser","","RSS/REXMLLikeXMLParser.html","",""],["RSS::REXMLListener","","RSS/REXMLListener.html","",""],["RSS::REXMLParser","","RSS/REXMLParser.html","",""],["RSS::RSS09","","RSS/RSS09.html","","<p>RSS 0.9 support\n<p>RSS has three different versions. This module contains support for version 0.9.1.\n<p>Producing …\n"],["RSS::RSS10","","RSS/RSS10.html","","<p>RSS 1.0 support\n<p>RSS has three different versions. This module contains support for version 1.0\n<p>Producing …\n"],["RSS::RootElementMixin","","RSS/RootElementMixin.html","",""],["RSS::Rss","","RSS/Rss.html","","<p>RSS 2.0 support\n<p>RSS has three different versions. This module contains support for version 2.0\n<p>Producing …\n"],["RSS::Rss::Channel","","RSS/Rss/Channel.html","",""],["RSS::Rss::Channel::Cloud","","RSS/Rss/Channel/Cloud.html","",""],["RSS::Rss::Channel::Image","","RSS/Rss/Channel/Image.html","",""],["RSS::Rss::Channel::Item","","RSS/Rss/Channel/Item.html","",""],["RSS::Rss::Channel::Item::Category","","RSS/Rss/Channel/Item/Category.html","",""],["RSS::Rss::Channel::Item::Enclosure","","RSS/Rss/Channel/Item/Enclosure.html","",""],["RSS::Rss::Channel::Item::Guid","","RSS/Rss/Channel/Item/Guid.html","",""],["RSS::Rss::Channel::Item::Source","","RSS/Rss/Channel/Item/Source.html","",""],["RSS::Rss::Channel::SkipDays","","RSS/Rss/Channel/SkipDays.html","",""],["RSS::Rss::Channel::SkipDays::Day","","RSS/Rss/Channel/SkipDays/Day.html","",""],["RSS::Rss::Channel::SkipHours","","RSS/Rss/Channel/SkipHours.html","",""],["RSS::Rss::Channel::SkipHours::Hour","","RSS/Rss/Channel/SkipHours/Hour.html","",""],["RSS::Rss::Channel::TextInput","","RSS/Rss/Channel/TextInput.html","",""],["RSS::SetupMaker","","RSS/SetupMaker.html","",""],["RSS::SlashModel","","RSS/SlashModel.html","",""],["RSS::SyndicationModel","","RSS/SyndicationModel.html","",""],["RSS::TaxonomyTopicModel","","RSS/TaxonomyTopicModel.html","",""],["RSS::TaxonomyTopicModel::TaxonomyTopic","","RSS/TaxonomyTopicModel/TaxonomyTopic.html","",""],["RSS::TaxonomyTopicsModel","","RSS/TaxonomyTopicsModel.html","",""],["RSS::TaxonomyTopicsModel::TaxonomyTopics","","RSS/TaxonomyTopicsModel/TaxonomyTopics.html","",""],["RSS::TaxonomyTopicsModel::TaxonomyTopics::Bag","","RSS/RDF/Bag.html","",""],["RSS::TooMuchTagError","","RSS/TooMuchTagError.html","","<p>Some tags must only exist a specific number of times in a given RSS feed. If a feed has too many occurrences …\n"],["RSS::TrackBackModel10","","RSS/TrackBackModel10.html","",""],["RSS::TrackBackModel10::TrackBackAbout","","RSS/TrackBackModel10/TrackBackAbout.html","",""],["RSS::TrackBackModel10::TrackBackPing","","RSS/TrackBackModel10/TrackBackPing.html","",""],["RSS::TrackBackModel20","","RSS/TrackBackModel20.html","",""],["RSS::TrackBackModel20::TrackBackAbout","","RSS/TrackBackModel20/TrackBackAbout.html","",""],["RSS::TrackBackModel20::TrackBackPing","","RSS/TrackBackModel20/TrackBackPing.html","",""],["RSS::TrackBackUtils","","RSS/TrackBackUtils.html","",""],["RSS::UnknownConversionMethodError","","RSS/UnknownConversionMethodError.html","","<p>Raised when an unknown conversion error occurs.\n"],["RSS::UnknownTagError","","RSS/UnknownTagError.html","","<p>RSS does not allow for free-form tag names, so if an RSS feed contains a tag that we don&#39;t know about, …\n"],["RSS::UnsupportedMakerVersionError","","RSS/UnsupportedMakerVersionError.html","","<p>Raised when a RSS::Maker attempts to use an unknown maker.\n"],["RSS::Utils","","RSS/Utils.html","","<p>RSS::Utils is a module that holds various utility functions that are used across many parts of the rest …\n"],["RSS::Utils::CSV","","RSS/Utils/CSV.html","",""],["RSS::Utils::ExplicitCleanOther","","RSS/Utils/ExplicitCleanOther.html","",""],["RSS::Utils::InheritedReader","","RSS/Utils/InheritedReader.html","",""],["RSS::Utils::YesOther","","RSS/Utils/YesOther.html","",""],["RSS::XML","","RSS/XML.html","",""],["RSS::XML::Element","","RSS/XML/Element.html","",""],["RSS::XMLParserListener","","RSS/XMLParserListener.html","",""],["RSS::XMLParserNotFound","","RSS/XMLParserNotFound.html","",""],["RSS::XMLParserParser","","RSS/XMLParserParser.html","",""],["RSS::XMLScanListener","","RSS/XMLScanListener.html","",""],["RSS::XMLScanParser","","RSS/XMLScanParser.html","",""],["RSS::XMLStyleSheet","","RSS/XMLStyleSheet.html","",""],["RSS::XMLStyleSheetMixin","","RSS/XMLStyleSheetMixin.html","",""],["Racc","","Racc.html","","<p>$Id: 74ff4369ce53c7f45cfc2644ce907785104ebf6e $\n<p>Copyright © 1999-2006 Minero Aoki\n<p>This program is free …\n"],["Racc::Accept","","Racc/Accept.html","",""],["Racc::ActionTable","","Racc/ActionTable.html","","<p>The table of LALR actions. Actions are either of Shift, Reduce, Accept and Error.\n"],["Racc::CompileError","","Racc/CompileError.html","",""],["Racc::CparseParams","","Racc/CparseParams.html","",""],["Racc::DebugFlags","","Racc/DebugFlags.html","",""],["Racc::Error","","Racc/Error.html","",""],["Racc::Goto","","Racc/Goto.html","","<p>Represents a transition on the grammar. “Real goto” means a transition by nonterminal, but …\n"],["Racc::Grammar","","Racc/Grammar.html","",""],["Racc::Grammar::DefinitionEnv","","Racc/Grammar/DefinitionEnv.html","",""],["Racc::Grammar::PrecedenceDefinitionEnv","","Racc/Grammar/PrecedenceDefinitionEnv.html","",""],["Racc::GrammarFileParser","","Racc/GrammarFileParser.html","",""],["Racc::GrammarFileParser::Result","","Racc/GrammarFileParser/Result.html","",""],["Racc::GrammarFileScanner","","Racc/GrammarFileScanner.html","",""],["Racc::ISet","","Racc/ISet.html","","<p>An “indexed” set.  All items must respond to :ident.\n"],["Racc::Item","","Racc/Item.html","","<p>LALR item.  A set of rule and its lookahead tokens.\n"],["Racc::LocationPointer","","Racc/LocationPointer.html","","<p>A set of rule and position in it&#39;s RHS. Note that the number of pointers is more than rule&#39;s …\n"],["Racc::LogFileGenerator","","Racc/LogFileGenerator.html","",""],["Racc::OrMark","","Racc/OrMark.html","",""],["Racc::ParseError","","Racc/ParseError.html","",""],["Racc::ParseError","","Racc/ParseError.html","",""],["Racc::Parser","","Racc/Parser.html","",""],["Racc::ParserClassGenerator","","Racc/ParserClassGenerator.html","",""],["Racc::ParserFileGenerator","","Racc/ParserFileGenerator.html","",""],["Racc::ParserFileGenerator::Params","","Racc/ParserFileGenerator/Params.html","",""],["Racc::Prec","","Racc/Prec.html","",""],["Racc::RRconflict","","Racc/RRconflict.html","",""],["Racc::Reduce","","Racc/Reduce.html","",""],["Racc::Rule","","Racc/Rule.html","",""],["Racc::SRconflict","","Racc/SRconflict.html","",""],["Racc::Shift","","Racc/Shift.html","",""],["Racc::SourceText","","Racc/SourceText.html","",""],["Racc::State","","Racc/State.html","","<p>A LALR state.\n"],["Racc::StateTransitionTable","","Racc/StateTransitionTable.html","",""],["Racc::StateTransitionTableGenerator","","Racc/StateTransitionTableGenerator.html","",""],["Racc::States","","Racc/States.html","","<p>A table of LALR states.\n"],["Racc::Sym","","Racc/Sym.html","","<p>Stands terminal and nonterminal symbols.\n"],["Racc::SymbolTable","","Racc/SymbolTable.html","",""],["Racc::UserAction","","Racc/UserAction.html","",""],["Rake","","Rake.html","",""],["Random","","Random.html","","<p>Random provides an interface to Ruby&#39;s pseudo-random number generator, or PRNG.  The PRNG produces …\n"],["Random::Formatter","","Random/Formatter.html","","<p>Format raw random number as Random does\n"],["Range","","Range.html","","<p>A Range represents an interval—a set of values with a beginning and an end. Ranges may be constructed …\n"],["RangeError","","RangeError.html","","<p>Raised when a given numerical value is out of range.\n\n<pre class=\"ruby\">[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>].<span class=\"ruby-identifier\">drop</span>(<span class=\"ruby-value\">1</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-value\">100</span>)\n</pre>\n<p><em>raises the exception:</em>\n"],["Rational","","Rational.html","","<p>A rational number can be represented as a pair of integer numbers: a/b (b&gt;0), where a is the numerator …\n"],["Readline","","Readline.html","","<p>The Readline module provides interface for GNU Readline. This module defines a number of methods to facilitate …\n"],["Regexp","","Regexp.html","","<p>A Regexp holds a regular expression, used to match a pattern against strings. Regexps are created using …\n"],["RegexpError","","RegexpError.html","","<p>Raised when given an invalid regexp expression.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Regexp</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;?&quot;</span>)\n</pre>\n<p><em>raises the exception:</em>\n"],["Reline","","Reline.html","",""],["Reline::Core","","Reline/Core.html","",""],["RequiredArgumentMissingError","","RequiredArgumentMissingError.html","",""],["Resolv","","Resolv.html","","<p>Resolv is a thread-aware DNS resolver library written in Ruby.  Resolv can handle multiple DNS requests …\n"],["Resolv::DNS","","Resolv/DNS.html","","<p>Resolv::DNS is a DNS stub resolver.\n<p>Information taken from the following places:\n<p>STD0013\n"],["Resolv::DNS::Config","","Resolv/DNS/Config.html","",""],["Resolv::DNS::Config::NXDomain","","Resolv/DNS/Config/NXDomain.html","","<p>Indicates no such domain was found.\n"],["Resolv::DNS::Config::OtherResolvError","","Resolv/DNS/Config/OtherResolvError.html","","<p>Indicates some other unhandled resolver error was encountered.\n"],["Resolv::DNS::DecodeError","","Resolv/DNS/DecodeError.html","","<p>Indicates that the DNS response was unable to be decoded.\n"],["Resolv::DNS::EncodeError","","Resolv/DNS/EncodeError.html","","<p>Indicates that the DNS request was unable to be encoded.\n"],["Resolv::DNS::Name","","Resolv/DNS/Name.html","","<p>A representation of a DNS name.\n"],["Resolv::DNS::Query","","Resolv/DNS/Query.html","","<p>A DNS query abstract class.\n"],["Resolv::DNS::Requester","","Resolv/DNS/Requester.html","",""],["Resolv::DNS::Requester::RequestError","","Resolv/DNS/Requester/RequestError.html","","<p>Indicates a problem with the DNS request.\n"],["Resolv::DNS::Resource","","Resolv/DNS/Resource.html","","<p>A DNS resource abstract class.\n"],["Resolv::DNS::Resource::ANY","","Resolv/DNS/Resource/ANY.html","","<p>A Query type requesting any RR.\n"],["Resolv::DNS::Resource::CNAME","","Resolv/DNS/Resource/CNAME.html","","<p>The canonical name for an alias.\n"],["Resolv::DNS::Resource::DomainName","","Resolv/DNS/Resource/DomainName.html","","<p>Domain Name resource abstract class.\n"],["Resolv::DNS::Resource::Generic","","Resolv/DNS/Resource/Generic.html","","<p>A generic resource abstract class.\n"],["Resolv::DNS::Resource::HINFO","","Resolv/DNS/Resource/HINFO.html","","<p>Host Information resource.\n"],["Resolv::DNS::Resource::IN","","Resolv/DNS/Resource/IN.html","","<p>module IN contains ARPA Internet specific RRs.\n"],["Resolv::DNS::Resource::IN::A","","Resolv/DNS/Resource/IN/A.html","","<p>IPv4 Address resource\n"],["Resolv::DNS::Resource::IN::AAAA","","Resolv/DNS/Resource/IN/AAAA.html","","<p>An IPv6 address record.\n"],["Resolv::DNS::Resource::IN::SRV","","Resolv/DNS/Resource/IN/SRV.html","","<p>SRV resource record defined in RFC 2782\n<p>These records identify the hostname and port that a service is …\n"],["Resolv::DNS::Resource::IN::WKS","","Resolv/DNS/Resource/IN/WKS.html","","<p>Well Known Service resource.\n"],["Resolv::DNS::Resource::LOC","","Resolv/DNS/Resource/LOC.html","","<p>Location resource\n"],["Resolv::DNS::Resource::MINFO","","Resolv/DNS/Resource/MINFO.html","","<p>Mailing list or mailbox information.\n"],["Resolv::DNS::Resource::MX","","Resolv/DNS/Resource/MX.html","","<p>Mail Exchanger resource.\n"],["Resolv::DNS::Resource::NS","","Resolv/DNS/Resource/NS.html","","<p>An authoritative name server.\n"],["Resolv::DNS::Resource::PTR","","Resolv/DNS/Resource/PTR.html","","<p>A Pointer to another DNS name.\n"],["Resolv::DNS::Resource::SOA","","Resolv/DNS/Resource/SOA.html","","<p>Start Of Authority resource.\n"],["Resolv::DNS::Resource::TXT","","Resolv/DNS/Resource/TXT.html","","<p>Unstructured text resource.\n"],["Resolv::Hosts","","Resolv/Hosts.html","","<p>Resolv::Hosts is a hostname resolver that uses the system hosts file.\n"],["Resolv::IPv4","","Resolv/IPv4.html","","<p>A Resolv::DNS IPv4 address.\n"],["Resolv::IPv6","","Resolv/IPv6.html","","<p>A Resolv::DNS IPv6 address.\n"],["Resolv::LOC","","Resolv/LOC.html","",""],["Resolv::LOC::Alt","","Resolv/LOC/Alt.html","","<p>A Resolv::LOC::Alt\n"],["Resolv::LOC::Coord","","Resolv/LOC/Coord.html","","<p>A Resolv::LOC::Coord\n"],["Resolv::LOC::Size","","Resolv/LOC/Size.html","","<p>A Resolv::LOC::Size\n"],["Resolv::MDNS","","Resolv/MDNS.html","","<p>Resolv::MDNS is a one-shot Multicast DNS (mDNS) resolver.  It blindly makes queries to the mDNS addresses …\n"],["Resolv::ResolvError","","Resolv/ResolvError.html","","<p>Indicates a failure to resolve a name or address.\n"],["Resolv::ResolvTimeout","","Resolv/ResolvTimeout.html","","<p>Indicates a timeout resolving a name or address.\n"],["Rinda","","Rinda.html","","<p>A module to implement the Linda distributed computing paradigm in Ruby.\n<p>Rinda is part of DRb (dRuby). …\n"],["Rinda::DRbObjectTemplate","","Rinda/DRbObjectTemplate.html","","<p><em>Documentation?</em>\n"],["Rinda::InvalidHashTupleKey","","Rinda/InvalidHashTupleKey.html","","<p>Raised when a hash-based tuple has an invalid key.\n"],["Rinda::NotifyTemplateEntry","","Rinda/NotifyTemplateEntry.html","","<p>A NotifyTemplateEntry is returned by TupleSpace#notify and is notified of TupleSpace changes.  You may …\n"],["Rinda::RequestCanceledError","","Rinda/RequestCanceledError.html","","<p>Raised when trying to use a canceled tuple.\n"],["Rinda::RequestExpiredError","","Rinda/RequestExpiredError.html","","<p>Raised when trying to use an expired tuple.\n"],["Rinda::RindaError","","Rinda/RindaError.html","","<p>Rinda error base class\n"],["Rinda::RingFinger","","Rinda/RingFinger.html","","<p>RingFinger is used by RingServer clients to discover the RingServer&#39;s TupleSpace.  Typically, all …\n"],["Rinda::RingProvider","","Rinda/RingProvider.html","","<p>RingProvider uses a RingServer advertised TupleSpace as a name service. TupleSpace clients can register …\n"],["Rinda::RingServer","","Rinda/RingServer.html","","<p>A RingServer allows a Rinda::TupleSpace to be located via UDP broadcasts. Default service location uses …\n"],["Rinda::SimpleRenewer","","Rinda/SimpleRenewer.html","","<p>An SimpleRenewer allows a TupleSpace to check if a TupleEntry is still alive.\n"],["Rinda::Template","","Rinda/Template.html","","<p>Templates are used to match tuples in Rinda.\n"],["Rinda::TemplateEntry","","Rinda/TemplateEntry.html","","<p>A TemplateEntry is a Template together with expiry and cancellation data.\n"],["Rinda::Tuple","","Rinda/Tuple.html","","<p>A tuple is the elementary object in Rinda programming. Tuples may be matched against templates if the …\n"],["Rinda::TupleBag","","Rinda/TupleBag.html","","<p>TupleBag is an unordered collection of tuples. It is the basis of Tuplespace.\n"],["Rinda::TupleBag::TupleBin","","Rinda/TupleBag/TupleBin.html","",""],["Rinda::TupleEntry","","Rinda/TupleEntry.html","","<p>A TupleEntry is a Tuple (i.e. a possible entry in some Tuplespace) together with expiry and cancellation …\n"],["Rinda::TupleSpace","","Rinda/TupleSpace.html","","<p>The Tuplespace manages access to the tuples it contains, ensuring mutual exclusion requirements are met. …\n"],["Rinda::TupleSpaceProxy","","Rinda/TupleSpaceProxy.html","","<p>TupleSpaceProxy allows a remote Tuplespace to appear as local.\n"],["Rinda::WaitTemplateEntry","","Rinda/WaitTemplateEntry.html","","<p><em>Documentation?</em>\n"],["Ripper","","Ripper.html","","<p>Ripper is a Ruby script parser.\n<p>You can get information from the parser with event-based style. Information …\n"],["Ripper::Filter","","Ripper/Filter.html","","<p>This class handles only scanner events, which are dispatched in the &#39;right&#39; order (same with …\n"],["RubyLex","","RubyLex.html","",""],["RubyLex::TerminateLineInput","","RubyLex/TerminateLineInput.html","",""],["RubyVM","","RubyVM.html","","<p>for ast.c\n<p>The RubyVM module only exists on MRI. <code>RubyVM</code> is not defined in other Ruby implementations such …\n"],["RubyVM::AbstractSyntaxTree","","RubyVM/AbstractSyntaxTree.html","","<p>AbstractSyntaxTree provides methods to parse Ruby code into abstract syntax trees. The nodes in the tree …\n"],["RubyVM::AbstractSyntaxTree::Node","","RubyVM/AbstractSyntaxTree/Node.html","","<p>RubyVM::AbstractSyntaxTree::Node instances are created by parse methods in RubyVM::AbstractSyntaxTree …\n"],["RubyVM::InstructionSequence","","RubyVM/InstructionSequence.html","","<p>The InstructionSequence class represents a compiled sequence of instructions for the Virtual Machine …\n"],["RubyVM::MJIT","","RubyVM/MJIT.html","","<p>::RubyVM::MJIT\n\n<pre>Provides access to the Method JIT compiler of MRI.\nOf course, this module is MRI specific.</pre>\n"],["RuntimeError","","RuntimeError.html","","<p>A generic error class raised when an invalid operation is attempted. Kernel#raise will raise a RuntimeError …\n"],["SDBM","","SDBM.html","","<p>SDBM provides a simple file-based key-value store, which can only store String keys and values.\n<p>Note that …\n"],["SDBMError","","SDBMError.html","","<p>Exception class used to return errors from the sdbm library.\n"],["SOCKSSocket","","SOCKSSocket.html","","<p>SOCKS is an Internet protocol that routes packets between a client and a server through a proxy server. …\n"],["ScriptError","","ScriptError.html","","<p>ScriptError is the superclass for errors raised when a script can not be executed because of a <code>LoadError</code> …\n"],["SecureRandom","","SecureRandom.html","","<p>Secure random number generator interface.\n<p>This library is an interface to secure random number generators …\n"],["SecurityError","","SecurityError.html","","<p>No longer used by internal code.\n"],["Set","","Set.html","","<p>Set implements a collection of unordered values with no duplicates. This is a hybrid of Array&#39;s intuitive …\n"],["Shellwords","","Shellwords.html","","<p>Manipulates strings like the UNIX Bourne shell\n<p>This module manipulates strings according to the word parsing …\n"],["Signal","","Signal.html","","<p>Many operating systems allow signals to be sent to running processes. Some signals have a defined effect …\n"],["SignalException","","SignalException.html","","<p>Raised when a signal is received.\n\n<pre>begin\n  Process.kill(&#39;HUP&#39;,Process.pid)\n  sleep # wait for receiver ...</pre>\n"],["SimpleDelegator","","SimpleDelegator.html","","<p>A concrete implementation of Delegator, this class provides the means to delegate all supported method …\n"],["SingleForwardable","","SingleForwardable.html","","<p>SingleForwardable can be used to setup delegation at the object level as well.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">printer</span> = <span class=\"ruby-constant\">String</span>.<span class=\"ruby-identifier\">new</span>\n<span class=\"ruby-identifier\">printer</span>.<span class=\"ruby-identifier\">extend</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Singleton","","Singleton.html","","<p>The Singleton module implements the Singleton pattern.\n<p>Usage\n<p>To use Singleton, include the module in your …\n"],["SizedQueue","","SizedQueue.html","","<p>This class represents queues of specified size capacity.  The push operation may be blocked if the capacity …\n"],["Socket","","Socket.html","","<p>Class <code>Socket</code> provides access to the underlying operating system socket implementations.  It can be used …\n"],["Socket::AncillaryData","","Socket/AncillaryData.html","","<p>Socket::AncillaryData represents the ancillary data (control information) used by sendmsg and recvmsg …\n"],["Socket::Constants","","Socket/Constants.html","","<p>Socket::Constants provides socket-related constants.  All possible socket constants are listed in the …\n"],["Socket::Ifaddr","","Socket/Ifaddr.html","","<p>Socket::Ifaddr represents a result of getifaddrs() function.\n"],["Socket::Option","","Socket/Option.html","","<p>Socket::Option represents a socket option used by BasicSocket#getsockopt and BasicSocket#setsockopt. …\n"],["Socket::UDPSource","","Socket/UDPSource.html","","<p>UDP/IP address information used by Socket.udp_server_loop.\n"],["SocketError","","SocketError.html","","<p>SocketError is the error class for socket.\n"],["SortedSet","","SortedSet.html","","<p>SortedSet implements a Set that guarantees that its elements are yielded in sorted order (according to …\n"],["StandardError","","StandardError.html","","<p>The most standard error types are subclasses of StandardError. A rescue clause without an explicit Exception …\n"],["StopIteration","","StopIteration.html","","<p>Raised to stop the iteration, in particular by Enumerator#next. It is rescued by Kernel#loop.\n\n<pre>loop do ...</pre>\n"],["String","","String.html","","<p>A String object holds and manipulates an arbitrary sequence of bytes, typically representing characters. …\n"],["StringIO","","StringIO.html","","<p>Pseudo I/O on String object, with interface corresponding to IO.\n<p>Commonly used to simulate <code>$stdio</code> or  …\n"],["StringScanner","","StringScanner.html","","<p>StringScanner provides for lexical scanning operations on a String.  Here is an example of its usage: …\n"],["StringScanner::Error","","StringScanner/Error.html","",""],["Struct","","Struct.html","","<p>A Struct is a convenient way to bundle a number of attributes together, using accessor methods, without …\n"],["Symbol","","Symbol.html","","<p>Symbol objects represent names inside the Ruby interpreter. They are generated using the <code>:name</code> and <code>:&quot;string&quot;</code> …\n"],["SyntaxError","","SyntaxError.html","","<p>Raised when encountering Ruby code with an invalid syntax.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">eval</span>(<span class=\"ruby-string\">&quot;1+1=2&quot;</span>)\n</pre>\n<p><em>raises the exception:</em>\n"],["Syslog","","Syslog.html","","<p>The syslog package provides a Ruby interface to the POSIX system logging facility.\n<p>Syslog messages are …\n"],["Syslog::Constants","","Syslog/Constants.html","",""],["Syslog::Facility","","Syslog/Facility.html","",""],["Syslog::Level","","Syslog/Level.html","",""],["Syslog::Logger","","Syslog/Logger.html","","<p>Syslog::Logger is a Logger work-alike that logs via syslog instead of to a file.  You can use Syslog::Logger …\n"],["Syslog::Logger::Formatter","","Syslog/Logger/Formatter.html","","<p>Default formatter for log messages.\n"],["Syslog::Macros","","Syslog/Macros.html","",""],["Syslog::Option","","Syslog/Option.html","",""],["SystemCallError","","SystemCallError.html","","<p>SystemCallError is the base class for all low-level platform-dependent errors.\n<p>The errors available on …\n"],["SystemExit","","SystemExit.html","","<p>Raised by <code>exit</code> to initiate the termination of the script.\n"],["SystemStackError","","SystemStackError.html","","<p>Raised in case of a stack overflow.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">me_myself_and_i</span>\n  <span class=\"ruby-identifier\">me_myself_and_i</span>\n<span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-identifier\">me_myself_and_i</span>\n</pre>\n<p><em>raises the</em> …\n"],["TCPServer","","TCPServer.html","","<p>TCPServer represents a TCP/IP server socket.\n<p>A simple TCP server may look like:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;socket&#39;</span>\n\n<span class=\"ruby-identifier\">server</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["TCPSocket","","TCPSocket.html","","<p>TCPSocket represents a TCP/IP client socket.\n<p>A simple client may look like:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;socket&#39;</span>\n\n<span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">TCPSocket</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["TSort","","TSort.html","","<p>TSort implements topological sorting using Tarjan&#39;s algorithm for strongly connected components. …\n"],["TSort::Cyclic","","TSort/Cyclic.html","",""],["TempIO","","TempIO.html","","<p>A StringIO duck-typed class that uses Tempfile instead of String as the backing store.\n<p>This is available …\n"],["Tempfile","","Tempfile.html","","<p>A utility class for managing temporary files. When you create a Tempfile object, it will create a temporary …\n"],["Thread","","Thread.html","","<p>Threads are the Ruby implementation for a concurrent programming model.\n<p>Programs that require multiple …\n"],["Thread::Backtrace::Location","","Thread/Backtrace/Location.html","","<p>An object representation of a stack frame, initialized by Kernel#caller_locations.\n<p>For example:\n\n<pre class=\"ruby\"><span class=\"ruby-comment\"># caller_locations.rb ...</span>\n</pre>\n"],["ThreadError","","ThreadError.html","","<p>Raised when an invalid operation is attempted on a thread.\n<p>For example, when no other thread has been …\n"],["ThreadGroup","","ThreadGroup.html","","<p>ThreadGroup provides a means of keeping track of a number of threads as a group.\n<p>A given Thread object …\n"],["Time","","Time.html","","<p>Time is an abstraction of dates and times. Time is stored internally as the number of seconds with fraction …\n"],["Timeout","","Timeout.html","","<p>Timeout long-running blocks\n<p>Synopsis\n\n<pre>require &#39;timeout&#39;\nstatus = Timeout::timeout(5) {\n  # Something that ...</pre>\n"],["Timeout::Error","","Timeout/Error.html","","<p>Raised by Timeout.timeout when the block times out.\n"],["Timeout::TimeoutError","","Timeout/TimeoutError.html","","<p>Raised by Timeout.timeout when the block times out.\n"],["TracePoint","","TracePoint.html","","<p>Document-class: TracePoint\n<p>A class that provides the functionality of Kernel#set_trace_func in a nice …\n"],["Tracer","","Tracer.html","","<p>Outputs a source level execution trace of a Ruby program.\n<p>It does this by registering an event handler …\n"],["TrueClass","","TrueClass.html","","<p>The global value <code>true</code> is the only instance of class TrueClass and represents a logically true value in …\n"],["TypeError","","TypeError.html","","<p>Raised when encountering an object that is not of the expected type.\n\n<pre class=\"ruby\">[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>].<span class=\"ruby-identifier\">first</span>(<span class=\"ruby-string\">&quot;two&quot;</span>)\n</pre>\n<p><em>raises the</em> …\n"],["UDPSocket","","UDPSocket.html","","<p>UDPSocket represents a UDP/IP socket.\n"],["UNIXServer","","UNIXServer.html","","<p>UNIXServer represents a UNIX domain stream server socket.\n"],["UNIXSocket","","UNIXSocket.html","","<p>UNIXSocket represents a UNIX domain stream client socket.\n"],["URI","","URI.html","","<p>URI is a module providing classes to handle Uniform Resource Identifiers (RFC2396).\n<p>Features\n<p>Uniform way …\n"],["URI::BadURIError","","URI/BadURIError.html","","<p>URI is valid, bad usage is not.\n"],["URI::Error","","URI/Error.html","","<p>Base class for all URI exceptions.\n"],["URI::Escape","","URI/Escape.html","","<p>Module for escaping unsafe characters with codes.\n"],["URI::FTP","","URI/FTP.html","","<p>FTP URI syntax is defined by RFC1738 section 3.2.\n<p>This class will be redesigned because of difference …\n"],["URI::File","","URI/File.html","","<p>The “file” URI is defined by RFC8089.\n"],["URI::Generic","","URI/Generic.html","","<p>Base class for all URI classes. Implements generic URI syntax as per RFC 2396.\n"],["URI::HTTP","","URI/HTTP.html","","<p>The syntax of HTTP URIs is defined in RFC1738 section 3.3.\n<p>Note that the Ruby URI library allows HTTP …\n"],["URI::HTTPS","","URI/HTTPS.html","","<p>The default port for HTTPS URIs is 443, and the scheme is &#39;https:&#39; rather than &#39;http:&#39;. …\n"],["URI::InvalidComponentError","","URI/InvalidComponentError.html","","<p>Not a URI component.\n"],["URI::InvalidURIError","","URI/InvalidURIError.html","","<p>Not a URI.\n"],["URI::LDAP","","URI/LDAP.html","","<p>LDAP URI SCHEMA (described in RFC2255).\n"],["URI::LDAPS","","URI/LDAPS.html","","<p>The default port for LDAPS URIs is 636, and the scheme is &#39;ldaps:&#39; rather than &#39;ldap:&#39;. …\n"],["URI::MailTo","","URI/MailTo.html","","<p>RFC6068, the mailto URL scheme.\n"],["URI::Parser","","URI/RFC2396_Parser.html","","<p>Class that parses String&#39;s into URI&#39;s.\n<p>It contains a Hash set of patterns and Regexp&#39;s that …\n"],["URI::REGEXP","","URI/RFC2396_REGEXP.html","","<p>Includes URI::REGEXP::PATTERN\n"],["URI::RFC2396_Parser","","URI/RFC2396_Parser.html","","<p>Class that parses String&#39;s into URI&#39;s.\n<p>It contains a Hash set of patterns and Regexp&#39;s that …\n"],["URI::RFC2396_REGEXP","","URI/RFC2396_REGEXP.html","","<p>Includes URI::REGEXP::PATTERN\n"],["URI::RFC2396_REGEXP::PATTERN","","URI/RFC2396_REGEXP/PATTERN.html","","<p>Patterns used to parse URI&#39;s\n"],["UnboundMethod","","UnboundMethod.html","","<p>Ruby supports two forms of objectified methods. Class Method is used to represent methods that are associated …\n"],["UncaughtThrowError","","UncaughtThrowError.html","","<p>Raised when <code>throw</code> is called with a <em>tag</em> which does not have corresponding <code>catch</code> block.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">throw</span> <span class=\"ruby-string\">&quot;foo&quot;</span>, <span class=\"ruby-string\">&quot;bar&quot;</span>\n</pre>\n"],["UndefinedCommandError","","UndefinedCommandError.html","","<p>Raised when a command was not found.\n"],["UndefinedCommandError::SpellChecker","","UndefinedCommandError/SpellChecker.html","",""],["UndefinedTaskError","","UndefinedTaskError.html","","<p>Raised when a command was not found.\n"],["UnicodeNormalize","","UnicodeNormalize.html","","<p>define UnicodeNormalize module here so that we don&#39;t have to look it up\n"],["UnknownArgumentError","","UnknownArgumentError.html","",""],["UnknownArgumentError::SpellChecker","","UnknownArgumentError/SpellChecker.html","",""],["Vector","","Vector.html","","<p>The <code>Vector</code> class represents a mathematical vector, which is useful in its own right, and also constitutes …\n"],["Vector::ZeroVectorError","","Vector/ZeroVectorError.html","",""],["WEBrick","","WEBrick.html","","<p>WEB server toolkit.\n<p>WEBrick is an HTTP server toolkit that can be configured as an HTTPS server, a proxy …\n"],["WEBrick::AccessLog","","WEBrick/AccessLog.html","","<p>AccessLog provides logging to various files in various formats.\n<p>Multiple logs may be written to at the …\n"],["WEBrick::AccessLog::AccessLogError","","WEBrick/AccessLog/AccessLogError.html","","<p>Raised if a parameter such as %e, %i, %o or %n is used without fetching a specific field.\n"],["WEBrick::BasicLog","","WEBrick/BasicLog.html","","<p>A generic logging class\n"],["WEBrick::CGI","","WEBrick/CGI.html","","<p>A CGI library using WEBrick requests and responses.\n<p>Example:\n\n<pre>class MyCGI &lt; WEBrick::CGI\n  def do_GET req, ...</pre>\n"],["WEBrick::Config","","WEBrick/Config.html","",""],["WEBrick::Cookie","","WEBrick/Cookie.html","","<p>Processes HTTP cookies\n"],["WEBrick::Daemon","","WEBrick/Daemon.html","","<p>A generic module for daemonizing a process\n"],["WEBrick::GenericServer","","WEBrick/GenericServer.html","","<p>Base TCP server class.  You must subclass GenericServer and provide a #run method.\n"],["WEBrick::HTMLUtils","","WEBrick/HTMLUtils.html","",""],["WEBrick::HTTPAuth","","WEBrick/HTTPAuth.html","","<p>HTTPAuth provides both basic and digest authentication.\n<p>To enable authentication for requests in WEBrick …\n"],["WEBrick::HTTPAuth::Authenticator","","WEBrick/HTTPAuth/Authenticator.html","","<p>Module providing generic support for both Digest and Basic authentication schemes.\n"],["WEBrick::HTTPAuth::BasicAuth","","WEBrick/HTTPAuth/BasicAuth.html","","<p>Basic Authentication for WEBrick\n<p>Use this class to add basic authentication to a WEBrick servlet.\n<p>Here …\n"],["WEBrick::HTTPAuth::DigestAuth","","WEBrick/HTTPAuth/DigestAuth.html","","<p>RFC 2617 Digest Access Authentication for WEBrick\n<p>Use this class to add digest authentication to a WEBrick …\n"],["WEBrick::HTTPAuth::Htdigest","","WEBrick/HTTPAuth/Htdigest.html","","<p>Htdigest accesses apache-compatible digest password files.  Passwords are matched to a realm where they …\n"],["WEBrick::HTTPAuth::Htgroup","","WEBrick/HTTPAuth/Htgroup.html","","<p>Htgroup accesses apache-compatible group files.  Htgroup can be used to provide group-based authentication …\n"],["WEBrick::HTTPAuth::Htpasswd","","WEBrick/HTTPAuth/Htpasswd.html","","<p>Htpasswd accesses apache-compatible password files.  Passwords are matched to a realm where they are …\n"],["WEBrick::HTTPAuth::ProxyAuthenticator","","WEBrick/HTTPAuth/ProxyAuthenticator.html","","<p>Module providing generic support for both Digest and Basic authentication schemes for proxies.\n"],["WEBrick::HTTPAuth::ProxyBasicAuth","","WEBrick/HTTPAuth/ProxyBasicAuth.html","","<p>Basic authentication for proxy servers.  See BasicAuth for details.\n"],["WEBrick::HTTPAuth::ProxyDigestAuth","","WEBrick/HTTPAuth/ProxyDigestAuth.html","","<p>Digest authentication for proxy servers.  See DigestAuth for details.\n"],["WEBrick::HTTPAuth::UserDB","","WEBrick/HTTPAuth/UserDB.html","","<p>User database mixin for HTTPAuth.  This mixin dispatches user record access to the underlying auth_type …\n"],["WEBrick::HTTPProxyServer","","WEBrick/HTTPProxyServer.html","","<p>An HTTP Proxy server which proxies GET, HEAD and POST requests.\n<p>To create a simple proxy server:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["WEBrick::HTTPRequest","","WEBrick/HTTPRequest.html","","<p>An HTTP request.  This is consumed by service and do_* methods in WEBrick servlets\n"],["WEBrick::HTTPResponse","","WEBrick/HTTPResponse.html","","<p>An HTTP response.  This is filled in by the service or do_* methods of a WEBrick HTTP Servlet.\n"],["WEBrick::HTTPResponse::ChunkedWrapper","","WEBrick/HTTPResponse/ChunkedWrapper.html","",""],["WEBrick::HTTPResponse::InvalidHeader","","WEBrick/HTTPResponse/InvalidHeader.html","",""],["WEBrick::HTTPServer","","WEBrick/HTTPServer.html","","<p>An HTTP Server\n"],["WEBrick::HTTPServerError","","WEBrick/HTTPServerError.html","",""],["WEBrick::HTTPServlet","","WEBrick/HTTPServlet.html","",""],["WEBrick::HTTPServlet::AbstractServlet","","WEBrick/HTTPServlet/AbstractServlet.html","","<p>AbstractServlet allows HTTP server modules to be reused across multiple servers and allows encapsulation …\n"],["WEBrick::HTTPServlet::CGIHandler","","WEBrick/HTTPServlet/CGIHandler.html","","<p>Servlet for handling CGI scripts\n<p>Example:\n\n<pre>server.mount(&#39;/cgi/my_script&#39;, WEBrick::HTTPServlet::CGIHandler, ...</pre>\n"],["WEBrick::HTTPServlet::DefaultFileHandler","","WEBrick/HTTPServlet/DefaultFileHandler.html","","<p>Servlet for serving a single file.  You probably want to use the FileHandler servlet instead as it handles …\n"],["WEBrick::HTTPServlet::ERBHandler","","WEBrick/HTTPServlet/ERBHandler.html","","<p>ERBHandler evaluates an ERB file and returns the result.  This handler is automatically used if there …\n"],["WEBrick::HTTPServlet::FileHandler","","WEBrick/HTTPServlet/FileHandler.html","","<p>Serves a directory including fancy indexing and a variety of other options.\n<p>Example:\n\n<pre>server.mount(&#39;/assets&#39;, ...</pre>\n"],["WEBrick::HTTPServlet::HTTPServletError","","WEBrick/HTTPServlet/HTTPServletError.html","",""],["WEBrick::HTTPServlet::ProcHandler","","WEBrick/HTTPServlet/ProcHandler.html","","<p>Mounts a proc at a path that accepts a request and response.\n<p>Instead of mounting this servlet with WEBrick::HTTPServer#mount …\n"],["WEBrick::HTTPStatus","","WEBrick/HTTPStatus.html","","<p>This module is used to manager HTTP status codes.\n<p>See www.w3.org/Protocols/rfc2616/rfc2616-sec10.html …\n"],["WEBrick::HTTPStatus::ClientError","","WEBrick/HTTPStatus/ClientError.html","","<p>Root of the HTTP client error statuses\n"],["WEBrick::HTTPStatus::EOFError","","WEBrick/HTTPStatus/EOFError.html","",""],["WEBrick::HTTPStatus::Error","","WEBrick/HTTPStatus/Error.html","","<p>Root of the HTTP error statuses\n"],["WEBrick::HTTPStatus::Info","","WEBrick/HTTPStatus/Info.html","","<p>Root of the HTTP info statuses\n"],["WEBrick::HTTPStatus::Redirect","","WEBrick/HTTPStatus/Redirect.html","","<p>Root of the HTTP redirect statuses\n"],["WEBrick::HTTPStatus::ServerError","","WEBrick/HTTPStatus/ServerError.html","","<p>Root of the HTTP server error statuses\n"],["WEBrick::HTTPStatus::Status","","WEBrick/HTTPStatus/Status.html","","<p>Root of the HTTP status class hierarchy\n"],["WEBrick::HTTPStatus::Success","","WEBrick/HTTPStatus/Success.html","","<p>Root of the HTTP success statuses\n"],["WEBrick::HTTPUtils","","WEBrick/HTTPUtils.html","","<p>HTTPUtils provides utility methods for working with the HTTP protocol.\n<p>This module is generally used internally …\n"],["WEBrick::HTTPUtils::FormData","","WEBrick/HTTPUtils/FormData.html","","<p>Stores multipart form data.  FormData objects are created when WEBrick::HTTPUtils.parse_form_data is …\n"],["WEBrick::HTTPVersion","","WEBrick/HTTPVersion.html","","<p>Represents an HTTP protocol version\n"],["WEBrick::Log","","WEBrick/Log.html","","<p>A logging class that prepends a timestamp to each message.\n"],["WEBrick::SNIRequest","","WEBrick/SNIRequest.html","",""],["WEBrick::ServerError","","WEBrick/ServerError.html","","<p>Server error exception\n"],["WEBrick::SimpleServer","","WEBrick/SimpleServer.html","","<p>Base server class\n"],["WEBrick::Utils","","WEBrick/Utils.html","",""],["WEBrick::Utils::TimeoutHandler","","WEBrick/Utils/TimeoutHandler.html","","<p>Class used to manage timeout handlers across multiple threads.\n<p>Timeout handlers should be managed by using …\n"],["WIN32OLE","","WIN32OLE.html","","<p>WIN32OLE\n<p><code>WIN32OLE</code> objects represent OLE Automation object in Ruby.\n<p>By using WIN32OLE, you can access OLE …\n"],["WIN32OLE::VARIANT","","WIN32OLE/VARIANT.html","","<p>The WIN32OLE::VARIANT module includes constants of VARIANT type constants. The constants is used when …\n"],["WIN32OLEQueryInterfaceError","","WIN32OLEQueryInterfaceError.html","",""],["WIN32OLERuntimeError","","WIN32OLERuntimeError.html","","<p>Raised when OLE processing failed.\n<p>EX:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">obj</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;NonExistProgID&quot;</span>)\n</pre>\n"],["WIN32OLE_EVENT","","WIN32OLE_EVENT.html","","<p><code>WIN32OLE_EVENT</code> objects controls OLE event.\n"],["WIN32OLE_METHOD","","WIN32OLE_METHOD.html","","<p><code>WIN32OLE_METHOD</code> objects represent OLE method information.\n"],["WIN32OLE_PARAM","","WIN32OLE_PARAM.html","","<p><code>WIN32OLE_PARAM</code> objects represent param information of the OLE method.\n"],["WIN32OLE_RECORD","","WIN32OLE_RECORD.html","","<p><code>WIN32OLE_RECORD</code> objects represents VT_RECORD OLE variant. Win32OLE returns WIN32OLE_RECORD object if …\n"],["WIN32OLE_TYPE","","WIN32OLE_TYPE.html","","<p><code>WIN32OLE_TYPE</code> objects represent OLE type libarary information.\n"],["WIN32OLE_TYPELIB","","WIN32OLE_TYPELIB.html","","<p><code>WIN32OLE_TYPELIB</code> objects represent OLE tyblib information.\n"],["WIN32OLE_VARIABLE","","WIN32OLE_VARIABLE.html","","<p><code>WIN32OLE_VARIABLE</code> objects represent OLE variable information.\n"],["WIN32OLE_VARIANT","","WIN32OLE_VARIANT.html","","<p><code>WIN32OLE_VARIANT</code> objects represents OLE variant.\n<p>Win32OLE converts Ruby object into OLE variant automatically …\n"],["Warning","","Warning.html","","<p>The Warning module contains a single method named #warn, and the module extends itself, making Warning.warn …\n"],["WeakRef","","WeakRef.html","","<p>Weak Reference class that allows a referenced object to be garbage-collected.\n<p>A WeakRef may be used exactly …\n"],["WeakRef::RefError","","WeakRef/RefError.html","","<p>RefError is raised when a referenced object has been recycled by the garbage collector\n"],["XML","","XML.html","",""],["XML::Parser","","XML/Parser.html","",""],["XMLEncoding_ja","","XMLEncoding_ja.html","",""],["XMLEncoding_ja::SJISHandler","","XMLEncoding_ja/SJISHandler.html","",""],["XMP","","XMP.html","","<p>An example printer for irb.\n<p>It&#39;s much like the standard library PrettyPrint, that shows the value …\n"],["XMP::StringInputMethod","","XMP/StringInputMethod.html","","<p>A custom InputMethod class used by XMP for evaluating string io.\n"],["YAML","","YAML.html","","<p>YAML Ain&#39;t Markup Language\n<p>This module provides a Ruby interface for data serialization in YAML format. …\n"],["YAML::DBM","","YAML/DBM.html","","<p>YAML + DBM = YDBM\n<p>YAML::DBM provides the same interface as ::DBM.\n<p>However, while DBM only allows strings …\n"],["YAML::Store","","YAML/Store.html","","<p>YAML::Store provides the same functionality as PStore, except it uses YAML to dump objects instead of …\n"],["YAML::Syck","","YAML/Syck.html","","<p>Now that we&#39;ve got something that is always here, define #to_s so when code tries to use this, it …\n"],["YAML::Syck","","YAML/Syck.html","","<p>Now that we&#39;ve got something that is always here, define #to_s so when code tries to use this, it …\n"],["ZeroDivisionError","","ZeroDivisionError.html","","<p>Raised when attempting to divide an integer by 0.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">42</span> <span class=\"ruby-operator\">/</span> <span class=\"ruby-value\">0</span>   <span class=\"ruby-comment\">#=&gt; ZeroDivisionError: divided by 0</span>\n</pre>\n<p>Note that …\n"],["Zlib","","Zlib.html","","<p>This module provides access to the zlib library. Zlib is designed to be a portable, free, general-purpose, …\n"],["Zlib::BufError","","Zlib/BufError.html","","<p>Subclass of Zlib::Error when zlib returns a Z_BUF_ERROR.\n<p>Usually if no progress is possible.\n"],["Zlib::DataError","","Zlib/DataError.html","","<p>Subclass of Zlib::Error when zlib returns a Z_DATA_ERROR.\n<p>Usually if a stream was prematurely freed.\n"],["Zlib::Deflate","","Zlib/Deflate.html","","<p>Zlib::Deflate is the class for compressing data.  See Zlib::ZStream for more information.\n"],["Zlib::Error","","Zlib/Error.html","","<p>The superclass for all exceptions raised by Ruby/zlib.\n<p>The following exceptions are defined as subclasses …\n"],["Zlib::GzipFile","","Zlib/GzipFile.html","","<p>Zlib::GzipFile is an abstract class for handling a gzip formatted compressed file. The operations are …\n"],["Zlib::GzipFile::CRCError","","Zlib/GzipFile/CRCError.html","","<p>Raised when the CRC checksum recorded in gzip file footer is not equivalent to the CRC checksum of the …\n"],["Zlib::GzipFile::Error","","Zlib/GzipFile/Error.html","","<p>Base class of errors that occur when processing GZIP files.\n"],["Zlib::GzipFile::LengthError","","Zlib/GzipFile/LengthError.html","","<p>Raised when the data length recorded in the gzip file footer is not equivalent to the length of the actual …\n"],["Zlib::GzipFile::NoFooter","","Zlib/GzipFile/NoFooter.html","","<p>Raised when gzip file footer is not found.\n"],["Zlib::GzipReader","","Zlib/GzipReader.html","","<p>Zlib::GzipReader is the class for reading a gzipped file.  GzipReader should be used as an IO, or -IO-like, …\n"],["Zlib::GzipWriter","","Zlib/GzipWriter.html","","<p>Zlib::GzipWriter is a class for writing gzipped files.  GzipWriter should be used with an instance of …\n"],["Zlib::InProgressError","","Zlib/InProgressError.html","","<p>Subclass of Zlib::Error. This error is raised when the zlib stream is currently in progress.\n<p>For example: …\n"],["Zlib::Inflate","","Zlib/Inflate.html","","<p>Zlib:Inflate is the class for decompressing compressed data.  Unlike Zlib::Deflate, an instance of this …\n"],["Zlib::MemError","","Zlib/MemError.html","","<p>Subclass of Zlib::Error\n<p>When zlib returns a Z_MEM_ERROR, usually if there was not enough memory.\n"],["Zlib::NeedDict","","Zlib/NeedDict.html","","<p>Subclass of Zlib::Error\n<p>When zlib returns a Z_NEED_DICT if a preset dictionary is needed at this point. …\n"],["Zlib::StreamEnd","","Zlib/StreamEnd.html","","<p>Subclass of Zlib::Error\n<p>When zlib returns a Z_STREAM_END is return if the end of the compressed data has …\n"],["Zlib::StreamError","","Zlib/StreamError.html","","<p>Subclass of Zlib::Error\n<p>When zlib returns a Z_STREAM_ERROR, usually if the stream state was inconsistent. …\n"],["Zlib::VersionError","","Zlib/VersionError.html","","<p>Subclass of Zlib::Error\n<p>When zlib returns a Z_VERSION_ERROR, usually if the zlib library version is incompatible …\n"],["Zlib::ZStream","","Zlib/ZStream.html","","<p>Zlib::ZStream is the abstract class for the stream which handles the compressed data. The operations …\n"],["fatal","","fatal.html","","<p>fatal is an Exception that is raised when Ruby has encountered a fatal error and must exit.\n"],["!","BasicObject","BasicObject.html#method-i-21","()","<p>Boolean negate.\n"],["!","Delegator","Delegator.html#method-i-21","()","<p>Delegates ! to the _<em>getobj</em>_\n"],["!=","BasicObject","BasicObject.html#method-i-21-3D","(p1)","<p>Returns true if two objects are not-equal, otherwise false.\n"],["!=","Delegator","Delegator.html#method-i-21-3D","(obj)","<p>Returns true if two objects are not considered of equal value.\n"],["!~","Object","Object.html#method-i-21~","(p1)","<p>Returns true if two objects do not match (using the <em>=~</em> method), otherwise false.\n"],["%","BigDecimal","BigDecimal.html#method-i-25","(p1)","<p>Returns the modulus from dividing by b.\n<p>See BigDecimal#divmod.\n"],["%","Float","Float.html#method-i-25","(p1)","<p>Returns the modulo after division of <code>float</code> by <code>other</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">6543.21</span>.<span class=\"ruby-identifier\">modulo</span>(<span class=\"ruby-value\">137</span>)      <span class=\"ruby-comment\">#=&gt; 104.21000000000004</span>\n<span class=\"ruby-value\">6543.21</span>.<span class=\"ruby-identifier\">modulo</span>(<span class=\"ruby-value\">137.24</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["%","Integer","Integer.html#method-i-25","(p1)","<p>Returns <code>int</code> modulo <code>other</code>.\n<p>See Numeric#divmod for more information.\n"],["%","Numeric","Numeric.html#method-i-25","(p1)","<p><code>x.modulo(y)</code> means <code>x-y*(x/y).floor</code>.\n<p>Equivalent to <code>num.divmod(numeric)[1]</code>.\n<p>See Numeric#divmod.\n"],["%","OpenSSL::BN","OpenSSL/BN.html#method-i-25","(p1)",""],["%","Range","Range.html#method-i-25","(p1)","<p>Iterates over the range, passing each <code>n</code>th element to the block. If begin and end are numeric, <code>n</code> is added …\n"],["%","String","String.html#method-i-25","(p1)","<p>Format—Uses <em>str</em> as a format specification, and returns the result of applying it to <em>arg</em>. If the format …\n"],["&","Array","Array.html#method-i-26","(p1)","<p>Set Intersection — Returns a new array containing unique elements common to the two arrays. The order …\n"],["&","FalseClass","FalseClass.html#method-i-26","(p1)","<p>And—Returns <code>false</code>. <em>obj</em> is always evaluated as it is the argument to a method call—there is no short-circuit …\n"],["&","IPAddr","IPAddr.html#method-i-26","(other)","<p>Returns a new ipaddr built by bitwise AND.\n"],["&","Integer","Integer.html#method-i-26","(p1)","<p>Bitwise AND.\n"],["&","NilClass","NilClass.html#method-i-26","(p1)","<p>And—Returns <code>false</code>. <em>obj</em> is always evaluated as it is the argument to a method call—there is no short-circuit …\n"],["&","Process::Status","Process/Status.html#method-i-26","(p1)","<p>Logical AND of the bits in <em>stat</em> with <em>num</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">fork</span> { <span class=\"ruby-identifier\">exit</span> <span class=\"ruby-value\">0x37</span> }\n<span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">wait</span>\n<span class=\"ruby-identifier\">sprintf</span>(<span class=\"ruby-string\">&#39;%04x&#39;</span>, <span class=\"ruby-identifier\">$?</span>.<span class=\"ruby-identifier\">to_i</span>)    <span class=\"ruby-operator\">...</span>\n</pre>\n"],["&","Set","Set.html#method-i-26","(enum)","<p>Returns a new set containing elements common to the set and the given enumerable object.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">5</span>] <span class=\"ruby-operator\">...</span>\n</pre>\n"],["&","TrueClass","TrueClass.html#method-i-26","(p1)","<p>And—Returns <code>false</code> if <em>obj</em> is <code>nil</code> or <code>false</code>, <code>true</code> otherwise.\n"],["*","Array","Array.html#method-i-2A","(p1)","<p>Repetition — With a String argument, equivalent to <code>ary.join(str)</code>.\n<p>Otherwise, returns a new array built …\n"],["*","Benchmark::Tms","Benchmark/Tms.html#method-i-2A","(x)","<p>Returns a new Tms object obtained by memberwise multiplication of the individual times for this Tms object …\n"],["*","BigDecimal","BigDecimal.html#method-i-2A","(p1)","<p>Multiply by the specified value.\n<p>e.g.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">mult</span>(<span class=\"ruby-identifier\">b</span>,<span class=\"ruby-identifier\">n</span>)\n<span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">*</span> <span class=\"ruby-identifier\">b</span>\n</pre>\n"],["*","Complex","Complex.html#method-i-2A","(p1)","<p>Performs multiplication.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">*</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (-5+12i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">*</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>)    <span class=\"ruby-operator\">...</span>\n</pre>\n"],["*","Float","Float.html#method-i-2A","(p1)","<p>Returns a new Float which is the product of <code>float</code> and <code>other</code>.\n"],["*","Integer","Integer.html#method-i-2A","(p1)","<p>Performs multiplication: the class of the resulting object depends on the class of <code>numeric</code>.\n"],["*","Matrix","Matrix.html#method-i-2A","(m)","<p>Matrix multiplication.\n\n<pre>Matrix[[2,4], [6,8]] * Matrix.identity(2)\n  =&gt; 2 4\n     6 8</pre>\n"],["*","OpenSSL::BN","OpenSSL/BN.html#method-i-2A","(p1)",""],["*","Rational","Rational.html#method-i-2A","(p1)","<p>Performs multiplication.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">*</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (4/9)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">*</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">1</span>)   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["*","String","String.html#method-i-2A","(p1)","<p>Copy — Returns a new String containing <code>integer</code> copies of the receiver. <code>integer</code> must be greater than …\n"],["*","Vector","Vector.html#method-i-2A","(x)","<p>Multiplies the vector by <code>x</code>, where <code>x</code> is a number or a matrix.\n"],["**","BigDecimal","BigDecimal.html#method-i-2A-2A","(p1)","<p>Returns the value raised to the power of n.\n<p>See BigDecimal#power.\n"],["**","Complex","Complex.html#method-i-2A-2A","(p1)","<p>Performs exponentiation.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-string\">&#39;i&#39;</span>) <span class=\"ruby-operator\">**</span> <span class=\"ruby-value\">2</span>              <span class=\"ruby-comment\">#=&gt; (-1+0i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">-8</span>) <span class=\"ruby-operator\">**</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["**","Float","Float.html#method-i-2A-2A","(p1)","<p>Raises <code>float</code> to the power of <code>other</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">2.0</span><span class=\"ruby-operator\">**</span><span class=\"ruby-value\">3</span>   <span class=\"ruby-comment\">#=&gt; 8.0</span>\n</pre>\n"],["**","Integer","Integer.html#method-i-2A-2A","(p1)","<p>Raises <code>int</code> to the power of <code>numeric</code>, which may be negative or fractional. The result may be an Integer …\n"],["**","Matrix","Matrix.html#method-i-2A-2A","(other)","<p>Matrix exponentiation. Equivalent to multiplying the matrix by itself N times. Non integer exponents …\n"],["**","OpenSSL::BN","OpenSSL/BN.html#method-i-2A-2A","(p1)",""],["**","Rational","Rational.html#method-i-2A-2A","(p1)","<p>Performs exponentiation.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>)    <span class=\"ruby-operator\">**</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">3</span>)     <span class=\"ruby-comment\">#=&gt; (8/1)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">10</span>)   <span class=\"ruby-operator\">**</span> <span class=\"ruby-value\">-2</span>             <span class=\"ruby-operator\">...</span>\n</pre>\n"],["+","Array","Array.html#method-i-2B","(p1)","<p>Concatenation — Returns a new array built by concatenating the two arrays together to produce a third …\n"],["+","Benchmark::Tms","Benchmark/Tms.html#method-i-2B","(other)","<p>Returns a new Tms object obtained by memberwise summation of the individual times for this Tms object …\n"],["+","BigDecimal","BigDecimal.html#method-i-2B","(p1)","<p>Add the specified value.\n<p>e.g.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">add</span>(<span class=\"ruby-identifier\">b</span>,<span class=\"ruby-identifier\">n</span>)\n<span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-identifier\">b</span>\n</pre>\n"],["+","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-2B","(oth)",""],["+","Complex","Complex.html#method-i-2B","(p1)","<p>Performs addition.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">+</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (4+6i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">+</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>)      <span class=\"ruby-comment\">#=&gt; (901+0i) ...</span>\n</pre>\n"],["+","Date","Date.html#method-i-2B","(p1)","<p>Returns a date object pointing <code>other</code> days after self.  The other should be a numeric value.  If the other …\n"],["+","Enumerator","Enumerator.html#method-i-2B","(p1)","<p>Returns an enumerator object generated from this enumerator and a given enumerable.\n\n<pre>e = (1..3).each + ...</pre>\n"],["+","Fiddle::Pointer","Fiddle/Pointer.html#method-i-2B","(p1)","<p>Returns a new pointer instance that has been advanced <code>n</code> bytes.\n"],["+","Float","Float.html#method-i-2B","(p1)","<p>Returns a new Float which is the sum of <code>float</code> and <code>other</code>.\n"],["+","Integer","Integer.html#method-i-2B","(p1)","<p>Performs addition: the class of the resulting object depends on the class of <code>numeric</code>.\n"],["+","Matrix","Matrix.html#method-i-2B","(m)","<p>Matrix addition.\n\n<pre>Matrix.scalar(2,5) + Matrix[[1,0], [-4,7]]\n  =&gt;  6  0\n     -4 12</pre>\n"],["+","OpenSSL::BN","OpenSSL/BN.html#method-i-2B","(p1)",""],["+","Pathname","Pathname.html#method-i-2B","(other)","<p>Appends a pathname fragment to <code>self</code> to produce a new Pathname object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p1</span> = <span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/usr&quot;</span>)      <span class=\"ruby-comment\"># ...</span>\n</pre>\n"],["+","Rational","Rational.html#method-i-2B","(p1)","<p>Performs addition.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">+</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (4/3)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">+</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">1</span>)      <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["+","Set","Set.html#method-i-2B","(enum)",""],["+","String","String.html#method-i-2B","(p1)","<p>Concatenation—Returns a new String containing <em>other_str</em> concatenated to <em>str</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;Hello from &quot;</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-keyword\">self</span>.<span class=\"ruby-identifier\">to_s</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["+","Time","Time.html#method-i-2B","(p1)","<p>Addition — Adds some number of seconds (possibly fractional) to <em>time</em> and returns that value as a new …\n"],["+","URI::Generic","URI/Generic.html#method-i-2B","(oth)",""],["+","Vector","Vector.html#method-i-2B","(v)","<p>Vector addition.\n"],["+@","BigDecimal","BigDecimal.html#method-i-2B-40","()","<p>Return self.\n\n<pre class=\"ruby\"><span class=\"ruby-operator\">+</span><span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;5&#39;</span>)  <span class=\"ruby-comment\">#=&gt; 0.5e1</span>\n</pre>\n"],["+@","Fiddle::Pointer","Fiddle/Pointer.html#method-i-2B-40","()","<p>Returns a new Fiddle::Pointer instance that is a dereferenced pointer for this pointer.\n<p>Analogous to the …\n"],["+@","Matrix","Matrix.html#method-i-2B-40","()",""],["+@","Numeric","Numeric.html#method-i-2B-40","()","<p>Unary Plus—Returns the receiver.\n"],["+@","OpenSSL::BN","OpenSSL/BN.html#method-i-2B-40","()",""],["+@","String","String.html#method-i-2B-40","()","<p>If the string is frozen, then return duplicated mutable string.\n<p>If the string is not frozen, then return …\n"],["+@","Vector","Vector.html#method-i-2B-40","()",""],["-","Array","Array.html#method-i-2D","(p1)","<p>Array Difference\n<p>Returns a new array that is a copy of the original array, removing all occurrences of …\n"],["-","Benchmark::Tms","Benchmark/Tms.html#method-i-2D","(other)","<p>Returns a new Tms object obtained by memberwise subtraction of the individual times for the <code>other</code> Tms …\n"],["-","BigDecimal","BigDecimal.html#method-i-2D","(p1)","<p>Subtract the specified value.\n<p>e.g.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">-</span> <span class=\"ruby-identifier\">b</span>\n</pre>\n"],["-","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-2D","(oth)",""],["-","Complex","Complex.html#method-i-2D","(p1)","<p>Performs subtraction.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">-</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (0+0i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">-</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>)      <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["-","Date","Date.html#method-i-2D","(p1)","<p>Returns the difference between the two dates if the other is a date object.  If the other is a numeric …\n"],["-","Fiddle::Pointer","Fiddle/Pointer.html#method-i-2D","(p1)","<p>Returns a new pointer instance that has been moved back <code>n</code> bytes.\n"],["-","Float","Float.html#method-i-2D","(p1)","<p>Returns a new Float which is the difference of <code>float</code> and <code>other</code>.\n"],["-","Integer","Integer.html#method-i-2D","(p1)","<p>Performs subtraction: the class of the resulting object depends on the class of <code>numeric</code>.\n"],["-","Matrix","Matrix.html#method-i-2D","(m)","<p>Matrix subtraction.\n\n<pre>Matrix[[1,5], [4,2]] - Matrix[[9,3], [-4,1]]\n  =&gt; -8  2\n      8  1</pre>\n"],["-","OpenSSL::BN","OpenSSL/BN.html#method-i-2D","(p1)",""],["-","Rational","Rational.html#method-i-2D","(p1)","<p>Performs subtraction.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">-</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (0/1)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">-</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">1</span>)      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["-","Set","Set.html#method-i-2D","(enum)","<p>Returns a new set built by duplicating the set, removing every element that appears in the given enumerable …\n"],["-","Time","Time.html#method-i-2D","(p1)","<p>Difference — Returns a difference in seconds as a Float between <em>time</em> and <code>other_time</code>, or subtracts the …\n"],["-","URI::Generic","URI/Generic.html#method-i-2D","(oth)",""],["-","Vector","Vector.html#method-i-2D","(v)","<p>Vector subtraction.\n"],["-@","BigDecimal","BigDecimal.html#method-i-2D-40","()","<p>Return the negation of self.\n\n<pre class=\"ruby\"><span class=\"ruby-operator\">-</span><span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;5&#39;</span>)  <span class=\"ruby-comment\">#=&gt; -0.5e1</span>\n</pre>\n"],["-@","Complex","Complex.html#method-i-2D-40","()","<p>Returns negation of the value.\n\n<pre class=\"ruby\"><span class=\"ruby-operator\">-</span><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>)  <span class=\"ruby-comment\">#=&gt; (-1-2i)</span>\n</pre>\n"],["-@","Fiddle::Pointer","Fiddle/Pointer.html#method-i-2D-40","()","<p>Returns a new Fiddle::Pointer instance that is a reference pointer for this pointer.\n<p>Analogous to the …\n"],["-@","Float","Float.html#method-i-2D-40","()","<p>Returns <code>float</code>, negated.\n"],["-@","Integer","Integer.html#method-i-2D-40","()","<p>Returns <code>int</code>, negated.\n"],["-@","Matrix","Matrix.html#method-i-2D-40","()",""],["-@","Numeric","Numeric.html#method-i-2D-40","()","<p>Unary Minus—Returns the receiver, negated.\n"],["-@","OpenSSL::BN","OpenSSL/BN.html#method-i-2D-40","()",""],["-@","Rational","Rational.html#method-i-2D-40","()","<p>Negates <code>rat</code>.\n"],["-@","String","String.html#method-i-2D-40","()","<p>Returns a frozen, possibly pre-existing copy of the string.\n<p>The string will be deduplicated as long as …\n"],["-@","Vector","Vector.html#method-i-2D-40","()",""],["/","Benchmark::Tms","Benchmark/Tms.html#method-i-2F","(x)","<p>Returns a new Tms object obtained by memberwise division of the individual times for this Tms object …\n"],["/","BigDecimal","BigDecimal.html#method-i-2F","(p1)","<p>Divide by the specified value.\n<p>See BigDecimal#div.\n"],["/","Complex","Complex.html#method-i-2F","(p1)","<p>Performs division.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; ((1/1)+(0/1)*i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>)   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["/","Float","Float.html#method-i-2F","(p1)","<p>Returns a new Float which is the result of dividing <code>float</code> by <code>other</code>.\n"],["/","Integer","Integer.html#method-i-2F","(p1)","<p>Performs division: the class of the resulting object depends on the class of <code>numeric</code>.\n"],["/","Matrix","Matrix.html#method-i-2F","(other)","<p>Matrix division (multiplication by the inverse).\n\n<pre>Matrix[[7,6], [3,9]] / Matrix[[2,9], [3,1]]\n  =&gt; -7  ...</pre>\n"],["/","OpenSSL::BN","OpenSSL/BN.html#method-i-2F","(p1)","<p>Division of OpenSSL::BN instances\n"],["/","Pathname","Pathname.html#method-i-2F","(other)",""],["/","Rational","Rational.html#method-i-2F","(p1)","<p>Performs division.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (1/1)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">1</span>)      <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["/","Vector","Vector.html#method-i-2F","(x)","<p>Vector division.\n"],["<","BigDecimal","BigDecimal.html#method-i-3C","(p1)","<p>Returns true if a is less than b.\n<p>Values may be coerced to perform the comparison (see ==, BigDecimal#coerce …\n"],["<","Comparable","Comparable.html#method-i-3C","(p1)","<p>Compares two objects based on the receiver&#39;s <code>&lt;=&gt;</code> method, returning true if it returns a value …\n"],["<","Float","Float.html#method-i-3C","(p1)","<p>Returns <code>true</code> if <code>float</code> is less than <code>real</code>.\n<p>The result of <code>NaN &lt; NaN</code> is undefined, so an implementation-dependent …\n"],["<","Hash","Hash.html#method-i-3C","(p1)","<p>Returns <code>true</code> if <em>hash</em> is subset of <em>other</em>.\n\n<pre>h1 = {a:1, b:2}\nh2 = {a:1, b:2, c:3}\nh1 &lt; h2    #=&gt; true\nh2 &lt; ...</pre>\n"],["<","Integer","Integer.html#method-i-3C","(p1)","<p>Returns <code>true</code> if the value of <code>int</code> is less than that of <code>real</code>.\n"],["<","Module","Module.html#method-i-3C","(p1)","<p>Returns true if <em>mod</em> is a subclass of <em>other</em>. Returns <code>nil</code> if there&#39;s no relationship between the two. …\n"],["<","Set","Set.html#method-i-3C","(set)",""],["<<","Array","Array.html#method-i-3C-3C","(p1)","<p>Append—Pushes the given object on to the end of this array. This expression returns the array itself, …\n"],["<<","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-3C-3C","(obj, options = {})",""],["<<","Bundler::Index","Bundler/Index.html#method-i-3C-3C","(spec)",""],["<<","Bundler::SpecSet","Bundler/SpecSet.html#method-i-3C-3C","(spec)",""],["<<","CSV","CSV.html#method-i-3C-3C","(row)","<p>The primary write method for wrapped Strings and IOs, <code>row</code> (an Array or CSV::Row) is converted to CSV …\n"],["<<","CSV::Row","CSV/Row.html#method-i-3C-3C","(arg)","<p>If a two-element Array is provided, it is assumed to be a header and field and the pair is appended. …\n"],["<<","CSV::Table","CSV/Table.html#method-i-3C-3C","(row_or_array)","<p>Adds a new row to the bottom end of this table. You can provide an Array, which will be converted to …\n"],["<<","CSV::Writer","CSV/Writer.html#method-i-3C-3C","(row)","<p>Adds a new row\n"],["<<","Date","Date.html#method-i-3C-3C","(p1)","<p>Returns a date object pointing <code>n</code> months before self. The argument <code>n</code> should be a numeric value.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["<<","Digest::Base","Digest/Base.html#method-i-3C-3C","(p1)","<p>Update the digest using given <em>string</em> and return <code>self</code>.\n"],["<<","Digest::Instance","Digest/Instance.html#method-i-3C-3C","(p1)","<p>Updates the digest using a given <em>string</em> and returns self.\n<p>The update() method and the left-shift operator …\n"],["<<","Gem::AvailableSet","Gem/AvailableSet.html#method-i-3C-3C","(o)",""],["<<","Gem::SourceList","Gem/SourceList.html#method-i-3C-3C","(obj)","<p>Appends <code>obj</code> to the source list which may be a Gem::Source, URI or URI String.\n"],["<<","IO","IO.html#method-i-3C-3C","(p1)","<p>String Output—Writes <em>obj</em> to <em>ios</em>. <em>obj</em> will be converted to a string using <code>to_s</code>.\n\n<pre>$stdout &lt;&lt; &quot;Hello &quot; &lt;&lt; ...</pre>\n"],["<<","IO::generic_writable","IO/generic_writable.html#method-i-3C-3C","(p1)","<p>See IO#<<.\n"],["<<","IPAddr","IPAddr.html#method-i-3C-3C","(num)","<p>Returns a new ipaddr built by bitwise left shift.\n"],["<<","Integer","Integer.html#method-i-3C-3C","(p1)","<p>Returns <code>int</code> shifted left <code>count</code> positions, or right if <code>count</code> is negative.\n"],["<<","Logger","Logger.html#method-i-3C-3C","(msg)","<p>Dump given message to the log device without any formatting.  If no log device exists, return <code>nil</code>.\n"],["<<","Method","Method.html#method-i-3C-3C","(p1)","<p>Returns a proc that is the composition of this method and the given <em>g</em>. The returned proc takes a variable …\n"],["<<","Net::WriteAdapter","Net/WriteAdapter.html#method-i-3C-3C","(str)",""],["<<","OpenSSL::BN","OpenSSL/BN.html#method-i-3C-3C","(p1)",""],["<<","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-3C-3C","(s)","<p>Writes <em>s</em> to the stream.  <em>s</em> will be converted to a String using <code>.to_s</code> method.\n"],["<<","OpenSSL::Digest","OpenSSL/Digest.html#method-i-3C-3C","(p1)",""],["<<","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-3C-3C","(p1)",""],["<<","Proc","Proc.html#method-i-3C-3C","(p1)","<p>Returns a proc that is the composition of this proc and the given <em>g</em>. The returned proc takes a variable …\n"],["<<","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-3C-3C","(object)",""],["<<","Queue","Queue.html#method-i-3C-3C","(p1)",""],["<<","REXML::Attributes","REXML/Attributes.html#method-i-3C-3C","( attribute )",""],["<<","REXML::Document","REXML/Document.html#method-i-3C-3C","( child )",""],["<<","REXML::Elements","REXML/Elements.html#method-i-3C-3C","(element=nil)",""],["<<","REXML::Light::Node","REXML/Light/Node.html#method-i-3C-3C","(element)","<p>Append a child to this element, optionally under a provided namespace. The namespace argument is ignored …\n"],["<<","REXML::Output","REXML/Output.html#method-i-3C-3C","( content )",""],["<<","REXML::Parent","REXML/Parent.html#method-i-3C-3C","( object )",""],["<<","REXML::Text","REXML/Text.html#method-i-3C-3C","( to_append )","<p>Appends text to this text node.  The text is appended in the <code>raw</code> mode of this text node.\n<p><code>returns</code> the text …\n"],["<<","REXML::Validation::Choice","REXML/Validation/Choice.html#method-i-3C-3C","( event )",""],["<<","REXML::Validation::State","REXML/Validation/State.html#method-i-3C-3C","( event )",""],["<<","RSS::XML::Element","RSS/XML/Element.html#method-i-3C-3C","(child)",""],["<<","Set","Set.html#method-i-3C-3C","(o)",""],["<<","SizedQueue","SizedQueue.html#method-i-3C-3C","(*args)",""],["<<","String","String.html#method-i-3C-3C","(p1)","<p>Appends the given object to <em>str</em>. If the object is an Integer, it is considered a codepoint and converted …\n"],["<<","StringScanner","StringScanner.html#method-i-3C-3C","(p1)","<p>Appends <code>str</code> to the string being scanned. This method does not affect scan pointer.\n\n<pre>s = StringScanner.new(&quot;Fri ...</pre>\n"],["<<","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-3C-3C","(obj)","<p>Synonym for log(INFO, obj.to_s)\n"],["<<","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-i-3C-3C","(str)","<p>Adds <code>str</code> to this FormData which may be the body, a header or a header entry.\n<p>This is called by WEBrick::HTTPUtils.parse_form_data …\n"],["<<","Zlib::Deflate","Zlib/Deflate.html#method-i-3C-3C","(p1)","<p>Inputs <code>string</code> into the deflate stream just like Zlib::Deflate#deflate, but returns the Zlib::Deflate …\n"],["<<","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-3C-3C","(p1)","<p>Same as IO.\n"],["<<","Zlib::Inflate","Zlib/Inflate.html#method-i-3C-3C","(p1)","<p>Same as IO.\n"],["<=","BigDecimal","BigDecimal.html#method-i-3C-3D","(p1)","<p>Returns true if a is less than or equal to b.\n<p>Values may be coerced to perform the comparison (see ==, …\n"],["<=","Comparable","Comparable.html#method-i-3C-3D","(p1)","<p>Compares two objects based on the receiver&#39;s <code>&lt;=&gt;</code> method, returning true if it returns a value …\n"],["<=","Float","Float.html#method-i-3C-3D","(p1)","<p>Returns <code>true</code> if <code>float</code> is less than or equal to <code>real</code>.\n<p>The result of <code>NaN &lt;= NaN</code> is undefined, so an implementation-dependent …\n"],["<=","Hash","Hash.html#method-i-3C-3D","(p1)","<p>Returns <code>true</code> if <em>hash</em> is subset of <em>other</em> or equals to <em>other</em>.\n\n<pre>h1 = {a:1, b:2}\nh2 = {a:1, b:2, c:3}\nh1 &lt;= ...</pre>\n"],["<=","Integer","Integer.html#method-i-3C-3D","(p1)","<p>Returns <code>true</code> if the value of <code>int</code> is less than or equal to that of <code>real</code>.\n"],["<=","Module","Module.html#method-i-3C-3D","(p1)","<p>Returns true if <em>mod</em> is a subclass of <em>other</em> or is the same as <em>other</em>. Returns <code>nil</code> if there&#39;s no relationship …\n"],["<=","Set","Set.html#method-i-3C-3D","(set)",""],["<=>","Array","Array.html#method-i-3C-3D-3E","(p1)","<p>Comparison — Returns an integer (<code>-1</code>, <code>0</code>, or <code>+1</code>) if this array is less than, equal to, or greater than …\n"],["<=>","BigDecimal","BigDecimal.html#method-i-3C-3D-3E","(p1)","<p>The comparison operator. a &lt;=&gt; b is 0 if a == b, 1 if a &gt; b, -1 if a &lt; b.\n"],["<=>","Bundler::GemHelpers::PlatformMatch","Bundler/GemHelpers/PlatformMatch.html#method-i-3C-3D-3E","(other)",""],["<=>","Bundler::LazySpecification::Identifier","Bundler/LazySpecification/Identifier.html#method-i-3C-3D-3E","(other)",""],["<=>","Bundler::Molinillo::Resolver::Resolution::UnwindDetails","Bundler/Molinillo/Resolver/Resolution/UnwindDetails.html#method-i-3C-3D-3E","(other)","<p>We compare UnwindDetails when choosing which state to unwind to. If two options have the same state_index …\n"],["<=>","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-3C-3D-3E","(other)","<p>Compare this specification against another object. Using sort_obj is compatible with Gem::Specification …\n"],["<=>","Bundler::VersionRanges::ReqR","Bundler/VersionRanges/ReqR.html#method-i-3C-3D-3E","(other)",""],["<=>","Complex","Complex.html#method-i-3C-3D-3E","(p1)","<p>If <code>cmp</code>&#39;s imaginary part is zero, and <code>object</code> is also a real number (or a Complex number where the …\n"],["<=>","Date","Date.html#method-i-3C-3D-3E","(p1)","<p>Compares the two dates and returns -1, zero, 1 or nil.  The other should be a date object or a numeric …\n"],["<=>","Fiddle::Pointer","Fiddle/Pointer.html#method-i-3C-3D-3E","(p1)","<p>Returns -1 if less than, 0 if equal to, 1 if greater than <code>other</code>.\n<p>Returns nil if <code>ptr</code> cannot be compared …\n"],["<=>","File::Stat","File/Stat.html#method-i-3C-3D-3E","(p1)","<p>Compares File::Stat objects by comparing their respective modification times.\n<p><code>nil</code> is returned if <code>other_stat</code> …\n"],["<=>","Float","Float.html#method-i-3C-3D-3E","(p1)","<p>Returns -1, 0, or +1 depending on whether <code>float</code> is less than, equal to, or greater than <code>real</code>. This is …\n"],["<=>","Gem::Dependency","Gem/Dependency.html#method-i-3C-3D-3E","(other)","<p>Dependencies are ordered by name.\n"],["<=>","Gem::NameTuple","Gem/NameTuple.html#method-i-3C-3D-3E","(other)",""],["<=>","Gem::Source","Gem/Source.html#method-i-3C-3D-3E","(other)","<p>Sources are ordered by installation preference.\n"],["<=>","Gem::Source::Git","Gem/Source/Git.html#method-i-3C-3D-3E","(other)",""],["<=>","Gem::Source::Installed","Gem/Source/Installed.html#method-i-3C-3D-3E","(other)","<p>Installed sources sort before all other sources\n"],["<=>","Gem::Source::Local","Gem/Source/Local.html#method-i-3C-3D-3E","(other)","<p>Local sorts before Gem::Source and after Gem::Source::Installed\n"],["<=>","Gem::Source::SpecificFile","Gem/Source/SpecificFile.html#method-i-3C-3D-3E","(other)","<p>Orders this source against <code>other</code>.\n<p>If <code>other</code> is a SpecificFile from a different gem name <code>nil</code> is returned. …\n"],["<=>","Gem::Source::Vendor","Gem/Source/Vendor.html#method-i-3C-3D-3E","(other)",""],["<=>","Gem::Version","Gem/Version.html#method-i-3C-3D-3E","(other)","<p>Compares this version with <code>other</code> returning -1, 0, or 1 if the other version is larger, the same, or smaller …\n"],["<=>","IPAddr","IPAddr.html#method-i-3C-3D-3E","(other)","<p>Compares the ipaddr with another.\n"],["<=>","IRB::Notifier::LeveledNotifier","IRB/Notifier/LeveledNotifier.html#method-i-3C-3D-3E","(other)","<p>Compares the level of this notifier object with the given <code>other</code> notifier.\n<p>See the Comparable module for …\n"],["<=>","Integer","Integer.html#method-i-3C-3D-3E","(p1)","<p>Comparison—Returns -1, 0, or +1 depending on whether <code>int</code> is less than, equal to, or greater than <code>numeric</code> …\n"],["<=>","Module","Module.html#method-i-3C-3D-3E","(p1)","<p>Comparison—Returns -1, 0, +1 or nil depending on whether <code>module</code> includes <code>other_module</code>, they are the …\n"],["<=>","Numeric","Numeric.html#method-i-3C-3D-3E","(p1)","<p>Returns zero if <code>number</code> equals <code>other</code>, otherwise returns <code>nil</code>.\n"],["<=>","Object","Object.html#method-i-3C-3D-3E","(p1)","<p>Returns 0 if <code>obj</code> and <code>other</code> are the same object or <code>obj == other</code>, otherwise nil.\n<p>The #&lt;=&gt; is used …\n"],["<=>","OpenSSL::BN","OpenSSL/BN.html#method-i-3C-3D-3E","(p1)",""],["<=>","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-3C-3D-3E","(p1)",""],["<=>","Pathname","Pathname.html#method-i-3C-3D-3E","(p1)","<p>Provides a case-sensitive comparison operator for pathnames.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;/usr&#39;</span>) <span class=\"ruby-operator\">&lt;=&gt;</span> <span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;/usr/bin&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["<=>","RDoc::Alias","RDoc/Alias.html#method-i-3C-3D-3E","(other)","<p>Order by #singleton then #new_name\n"],["<=>","RDoc::Constant","RDoc/Constant.html#method-i-3C-3D-3E","(other)","<p>Constants are ordered by name\n"],["<=>","RDoc::Context","RDoc/Context.html#method-i-3C-3D-3E","(other)","<p>Contexts are sorted by full_name\n"],["<=>","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-3C-3D-3E","(other)","<p>Order by #singleton then #name\n"],["<=>","RDoc::Mixin","RDoc/Mixin.html#method-i-3C-3D-3E","(other)","<p>Mixins are sorted by name\n"],["<=>","REXML::Comment","REXML/Comment.html#method-i-3C-3D-3E","(other)","<p>Compares this Comment to another; the contents of the comment are used in the comparison.\n"],["<=>","REXML::Text","REXML/Text.html#method-i-3C-3D-3E","( other )","<p><code>other</code> a String or a Text <code>returns</code> the result of (to_s &lt;=&gt; arg.to_s)\n"],["<=>","RSS::Maker::ItemsBase::ItemBase","RSS/Maker/ItemsBase/ItemBase.html#method-i-3C-3D-3E","(other)",""],["<=>","Rational","Rational.html#method-i-3C-3D-3E","(p1)","<p>Returns -1, 0, or +1 depending on whether <code>rational</code> is less than, equal to, or greater than <code>numeric</code>.\n<p><code>nil</code> …\n"],["<=>","String","String.html#method-i-3C-3D-3E","(p1)","<p>Comparison—Returns -1, 0, +1, or <code>nil</code> depending on whether <code>string</code> is less than, equal to, or greater …\n"],["<=>","Symbol","Symbol.html#method-i-3C-3D-3E","(p1)","<p>Compares <code>symbol</code> with <code>other_symbol</code> after calling #to_s on each of the symbols. Returns -1, 0, +1, or  …\n"],["<=>","Time","Time.html#method-i-3C-3D-3E","(p1)","<p>Comparison—Compares <code>time</code> with <code>other_time</code>.\n<p>-1, 0, +1 or nil depending on whether <code>time</code> is less  than, …\n"],["<=>","WEBrick::HTTPVersion","WEBrick/HTTPVersion.html#method-i-3C-3D-3E","(other)","<p>Compares this version with <code>other</code> according to the HTTP specification rules.\n"],["==","Array","Array.html#method-i-3D-3D","(p1)","<p>Equality — Two arrays are equal if they contain the same number of elements and if each element is …\n"],["==","BasicObject","BasicObject.html#method-i-3D-3D","(p1)","<p>Equality — At the Object level, #== returns <code>true</code> only if <code>obj</code> and <code>other</code> are the same object.  Typically …\n"],["==","BigDecimal","BigDecimal.html#method-i-3D-3D","(p1)","<p>Tests for value equality; returns true if the values are equal.\n<p>The == and === operators and the eql? …\n"],["==","Bundler::DepProxy","Bundler/DepProxy.html#method-i-3D-3D","(other)",""],["==","Bundler::Index","Bundler/Index.html#method-i-3D-3D","(other)","<p>Whether all the specs in self are in other TODO: rename to #include?\n"],["==","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-3D-3D","(other)",""],["==","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-3D-3D","(other)","<p>@return [Boolean] whether the two dependency graphs are equal, determined\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">by</span> <span class=\"ruby-identifier\">a</span> <span class=\"ruby-identifier\">recursive</span> <span class=\"ruby-identifier\">traversal</span> <span class=\"ruby-identifier\">of</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["==","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-3D-3D","(other)","<p>@return [Boolean] whether the two vertices are equal, determined\n\n<pre>by a recursive traversal of each {Vertex#successors}</pre>\n"],["==","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-3D-3D","(other)","<p>This shall check if two source object represent the same source.\n<p>The comparison shall take place only …\n"],["==","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-3D-3D","(other)",""],["==","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-3D-3D","(other)",""],["==","Bundler::Settings::Mirror","Bundler/Settings/Mirror.html#method-i-3D-3D","(other)",""],["==","Bundler::Source::Git","Bundler/Source/Git.html#method-i-3D-3D","(other)",""],["==","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-3D-3D","(other)",""],["==","Bundler::Source::Path","Bundler/Source/Path.html#method-i-3D-3D","(other)",""],["==","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-3D-3D","(other)",""],["==","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-3D-3D","(oth)","<p>Compares two URIs.\n"],["==","CSV::Row","CSV/Row.html#method-i-3D-3D","(other)","<p>Returns <code>true</code> if this row contains the same headers and fields in the same order as <code>other</code>.\n"],["==","CSV::Table","CSV/Table.html#method-i-3D-3D","(other)","<p>Returns <code>true</code> if all rows of this table ==() <code>other</code>&#39;s rows.\n"],["==","Comparable","Comparable.html#method-i-3D-3D","(p1)","<p>Compares two objects based on the receiver&#39;s <code>&lt;=&gt;</code> method, returning true if it returns 0. Also …\n"],["==","Complex","Complex.html#method-i-3D-3D","(p1)","<p>Returns true if cmp equals object numerically.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">==</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; true</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">5</span>)  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["==","Delegator","Delegator.html#method-i-3D-3D","(obj)","<p>Returns true if two objects are considered of equal value.\n"],["==","Digest::Instance","Digest/Instance.html#method-i-3D-3D","(p1)","<p>If a string is given, checks whether it is equal to the hex-encoded hash value of the digest object. …\n"],["==","Encoding::Converter","Encoding/Converter.html#method-i-3D-3D","(p1)",""],["==","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> only if <code>obj</code> is an Enumerator::ArithmeticSequence, has equivalent begin, end, step, and  …\n"],["==","Exception","Exception.html#method-i-3D-3D","(p1)","<p>Equality—If <em>obj</em> is not an Exception, returns <code>false</code>. Otherwise, returns <code>true</code> if <em>exc</em> and <em>obj</em> share same …\n"],["==","Fiddle::Pointer","Fiddle/Pointer.html#method-i-3D-3D","(p1)","<p>Returns true if <code>other</code> wraps the same pointer, otherwise returns false.\n"],["==","Float","Float.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> only if <code>obj</code> has the same value as <code>float</code>. Contrast this with Float#eql?, which requires  …\n"],["==","Gem::NameTuple","Gem/NameTuple.html#method-i-3D-3D","(other)","<p>Compare with <code>other</code>. Supports another NameTuple or an Array in the [name, version, platform] format.\n"],["==","Gem::Platform","Gem/Platform.html#method-i-3D-3D","(other)","<p>Is <code>other</code> equal to this platform?  Two platforms are equal if they have the same CPU, OS and version. …\n"],["==","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-3D-3D","(other)","<p>@return [Boolean] whether the two dependency graphs are equal, determined\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">by</span> <span class=\"ruby-identifier\">a</span> <span class=\"ruby-identifier\">recursive</span> <span class=\"ruby-identifier\">traversal</span> <span class=\"ruby-identifier\">of</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["==","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-3D-3D","(other)","<p>@return [Boolean] whether the two vertices are equal, determined\n\n<pre>by a recursive traversal of each {Vertex#successors}</pre>\n"],["==","Hash","Hash.html#method-i-3D-3D","(p1)","<p>Equality—Two hashes are equal if they each contain the same number of keys and if each key-value pair …\n"],["==","IPAddr","IPAddr.html#method-i-3D-3D","(other)","<p>Returns true if two ipaddrs are equal.\n"],["==","Integer","Integer.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> if <code>int</code> equals <code>other</code> numerically. Contrast this with Integer#eql?, which requires <code>other</code> to …\n"],["==","MatchData","MatchData.html#method-i-3D-3D","(p1)","<p>Equality—Two matchdata are equal if their target strings, patterns, and matched positions are identical. …\n"],["==","Matrix","Matrix.html#method-i-3D-3D","(other)","<p>Returns <code>true</code> if and only if the two matrices contain equal elements.\n"],["==","Method","Method.html#method-i-3D-3D","(p1)","<p>Two method objects are equal if they are bound to the same object and refer to the same method definition …\n"],["==","Module","Module.html#method-i-3D-3D","(p1)","<p>Equality — At the Object level, #== returns <code>true</code> only if <code>obj</code> and <code>other</code> are the same object.  Typically …\n"],["==","OpenSSL::BN","OpenSSL/BN.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> only if <em>obj</em> has the same value as <em>bn</em>. Contrast this with OpenSSL::BN#eql?, which requires …\n"],["==","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-3D-3D","(p1)",""],["==","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-3D-3D","(p1)",""],["==","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> if the two Session is the same, <code>false</code> if not.\n"],["==","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-i-3D-3D","(other)",""],["==","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-3D-3D","(other)",""],["==","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-3D-3D","(p1)","<p>Compares the two certificates. Note that this takes into account all fields, not just the issuer name …\n"],["==","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-3D-3D","(other)",""],["==","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-3D-3D","(other)",""],["==","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-3D-3D","(other)",""],["==","OpenStruct","OpenStruct.html#method-i-3D-3D","(other)","<p>Compares this object and <code>other</code> for equality.  An OpenStruct is equal to <code>other</code> when <code>other</code> is an OpenStruct …\n"],["==","Pathname","Pathname.html#method-i-3D-3D","(p1)","<p>Compare this pathname with <code>other</code>.  The comparison is string-based. Be aware that two different paths …\n"],["==","Process::Status","Process/Status.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> if the integer value of <em>stat</em> equals <em>other</em>.\n"],["==","RDoc::Attr","RDoc/Attr.html#method-i-3D-3D","(other)","<p>Attributes are equal when their names, singleton and rw are identical\n"],["==","RDoc::Constant","RDoc/Constant.html#method-i-3D-3D","(other)","<p>Constants are equal when their #parent and #name is the same\n"],["==","RDoc::TopLevel","RDoc/TopLevel.html#method-i-3D-3D","(other)","<p>An RDoc::TopLevel is equal to another with the same relative_name\n"],["==","REXML::Attribute","REXML/Attribute.html#method-i-3D-3D","( other )","<p>Returns true if other is an Attribute and has the same name and value, false otherwise.\n"],["==","REXML::Comment","REXML/Comment.html#method-i-3D-3D","( other )","<p>Compares this Comment to another; the contents of the comment are used in the comparison.\n"],["==","REXML::Instruction","REXML/Instruction.html#method-i-3D-3D","( other )","<p>@return true if other is an Instruction, and the content and target of the other matches the target and …\n"],["==","REXML::Validation::Event","REXML/Validation/Event.html#method-i-3D-3D","( other )",""],["==","REXML::XMLDecl","REXML/XMLDecl.html#method-i-3D-3D","( other )",""],["==","RSS::XML::Element","RSS/XML/Element.html#method-i-3D-3D","(other)",""],["==","Racc::LocationPointer","Racc/LocationPointer.html#method-i-3D-3D","(ot)",""],["==","Racc::Rule","Racc/Rule.html#method-i-3D-3D","(other)",""],["==","Racc::State","Racc/State.html#method-i-3D-3D","(oth)",""],["==","Random","Random.html#method-i-3D-3D","(p1)","<p>Returns true if the two generators have the same internal state, otherwise false.  Equivalent generators …\n"],["==","Range","Range.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> only if <code>obj</code> is a Range, has equivalent begin and end items (by comparing them with <code>==</code>), …\n"],["==","Rational","Rational.html#method-i-3D-3D","(p1)","<p>Returns <code>true</code> if <code>rat</code> equals <code>object</code> numerically.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">==</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; true</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">5</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["==","Regexp","Regexp.html#method-i-3D-3D","(p1)","<p>Equality—Two regexps are equal if their patterns are identical, they have the same character set code, …\n"],["==","Set","Set.html#method-i-3D-3D","(other)","<p>Returns true if two sets are equal.  The equality of each couple of elements is defined according to …\n"],["==","String","String.html#method-i-3D-3D","(p1)","<p>Equality—Returns whether <code>str</code> == <code>obj</code>, similar to Object#==.\n<p>If <code>obj</code> is not an instance of String but responds …\n"],["==","Struct","Struct.html#method-i-3D-3D","(p1)","<p>Equality—Returns <code>true</code> if <code>other</code> has the same struct subclass and has equal member values (according …\n"],["==","Symbol","Symbol.html#method-i-3D-3D","(p1)","<p>Equality—If <em>sym</em> and <em>obj</em> are exactly the same symbol, returns <code>true</code>.\n"],["==","URI::Generic","URI/Generic.html#method-i-3D-3D","(oth)","<p>Compares two URIs.\n"],["==","UnboundMethod","UnboundMethod.html#method-i-3D-3D","(p1)","<p>Two method objects are equal if they are bound to the same object and refer to the same method definition …\n"],["==","Vector","Vector.html#method-i-3D-3D","(other)","<p>Returns <code>true</code> iff the two vectors have the same elements in the same order.\n"],["===","BigDecimal","BigDecimal.html#method-i-3D-3D-3D","(p1)","<p>Tests for value equality; returns true if the values are equal.\n<p>The == and === operators and the eql? …\n"],["===","Date","Date.html#method-i-3D-3D-3D","(p1)","<p>Returns true if they are the same day.\n\n<pre>Date.new(2001,2,3) === Date.new(2001,2,3)\n                     ...</pre>\n"],["===","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-3D-3D-3D","(p1)","<p>Returns <code>true</code> only if <code>obj</code> is an Enumerator::ArithmeticSequence, has equivalent begin, end, step, and  …\n"],["===","FalseClass","FalseClass.html#method-i-3D-3D-3D","(p1)","<p>Case Equality – For class Object, effectively the same as calling <code>#==</code>, but typically overridden by descendants …\n"],["===","Float","Float.html#method-i-3D-3D-3D","(p1)","<p>Returns <code>true</code> only if <code>obj</code> has the same value as <code>float</code>. Contrast this with Float#eql?, which requires  …\n"],["===","Gem::Dependency","Gem/Dependency.html#method-i-3D-3D-3D","(other)",""],["===","Gem::Platform","Gem/Platform.html#method-i-3D-3D-3D","(other)","<p>Does <code>other</code> match this platform?  Two platforms match if they have the same CPU, or either has a CPU of …\n"],["===","Gem::Requirement","Gem/Requirement.html#method-i-3D-3D-3D","(version)",""],["===","IPAddr","IPAddr.html#method-i-3D-3D-3D","(other)",""],["===","Integer","Integer.html#method-i-3D-3D-3D","(p1)","<p>Returns <code>true</code> if <code>int</code> equals <code>other</code> numerically. Contrast this with Integer#eql?, which requires <code>other</code> to …\n"],["===","Method","Method.html#method-i-3D-3D-3D","(*args)","<p>Invokes the method with <code>obj</code> as the parameter like #call. This allows a method object to be the target …\n"],["===","Module","Module.html#method-i-3D-3D-3D","(p1)","<p>Case Equality—Returns <code>true</code> if <em>obj</em> is an instance of <em>mod</em> or an instance of one of <em>mod</em>&#39;s descendants. …\n"],["===","NilClass","NilClass.html#method-i-3D-3D-3D","(p1)","<p>Case Equality – For class Object, effectively the same as calling <code>#==</code>, but typically overridden by descendants …\n"],["===","Object","Object.html#method-i-3D-3D-3D","(p1)","<p>Case Equality – For class Object, effectively the same as calling <code>#==</code>, but typically overridden by descendants …\n"],["===","OpenSSL::BN","OpenSSL/BN.html#method-i-3D-3D-3D","(p1)",""],["===","Pathname","Pathname.html#method-i-3D-3D-3D","(p1)","<p>Compare this pathname with <code>other</code>.  The comparison is string-based. Be aware that two different paths …\n"],["===","Proc","Proc.html#method-i-3D-3D-3D","(*args)","<p>Invokes the block with <code>obj</code> as the proc&#39;s parameter like Proc#call. This allows a proc object to be …\n"],["===","Range","Range.html#method-i-3D-3D-3D","(p1)","<p>Returns <code>true</code> if <code>obj</code> is between begin and end of range, <code>false</code> otherwise (same as #cover?). Conveniently …\n"],["===","Regexp","Regexp.html#method-i-3D-3D-3D","(p1)","<p>Case Equality—Used in case statements.\n\n<pre>a = &quot;HELLO&quot;\ncase a\nwhen /\\A[a-z]*\\z/; print &quot;Lower case\\n&quot;\nwhen ...</pre>\n"],["===","Rinda::DRbObjectTemplate","Rinda/DRbObjectTemplate.html#method-i-3D-3D-3D","(ro)","<p>This DRbObjectTemplate matches <code>ro</code> if the remote object&#39;s drburi and drbref are the same.  <code>nil</code> is …\n"],["===","Rinda::Template","Rinda/Template.html#method-i-3D-3D-3D","(tuple)","<p>Alias for #match.\n"],["===","Rinda::TemplateEntry","Rinda/TemplateEntry.html#method-i-3D-3D-3D","(tuple)",""],["===","Set","Set.html#method-i-3D-3D-3D","(o)","<p>Returns true if the given object is a member of the set, and false otherwise.\n<p>Used in case statements: …\n"],["===","String","String.html#method-i-3D-3D-3D","(p1)","<p>Equality—Returns whether <code>str</code> == <code>obj</code>, similar to Object#==.\n<p>If <code>obj</code> is not an instance of String but responds …\n"],["===","Symbol","Symbol.html#method-i-3D-3D-3D","(p1)","<p>Equality—If <em>sym</em> and <em>obj</em> are exactly the same symbol, returns <code>true</code>.\n"],["===","SystemCallError","SystemCallError.html#method-c-3D-3D-3D","(p1)","<p>Return <code>true</code> if the receiver is a generic <code>SystemCallError</code>, or if the error numbers <code>self</code> and <em>other</em> are …\n"],["===","TrueClass","TrueClass.html#method-i-3D-3D-3D","(p1)","<p>Case Equality – For class Object, effectively the same as calling <code>#==</code>, but typically overridden by descendants …\n"],["=~","Gem::Dependency","Gem/Dependency.html#method-i-3D~","(other)","<p>Uses this dependency as a pattern to compare to <code>other</code>. This dependency will match if the name matches …\n"],["=~","Gem::Platform","Gem/Platform.html#method-i-3D~","(other)","<p>Does <code>other</code> match this platform?  If <code>other</code> is a String it will be converted to a Gem::Platform first. …\n"],["=~","Gem::Requirement","Gem/Requirement.html#method-i-3D~","(version)",""],["=~","NilClass","NilClass.html#method-i-3D~","(p1)","<p>Dummy pattern matching – always returns nil.\n"],["=~","Object","Object.html#method-i-3D~","(p1)","<p>This method is deprecated.\n<p>This is not only unuseful but also troublesome because it may hide a type error. …\n"],["=~","REXML::Light::Node","REXML/Light/Node.html#method-i-3D~","( path )",""],["=~","Regexp","Regexp.html#method-i-3D~","(p1)","<p>Match—Matches <em>rxp</em> against <em>str</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-regexp\">/at/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-string\">&quot;input data&quot;</span>   <span class=\"ruby-comment\">#=&gt; 7</span>\n<span class=\"ruby-regexp\">/ax/</span> <span class=\"ruby-operator\">=~</span> <span class=\"ruby-string\">&quot;input data&quot;</span>   <span class=\"ruby-comment\">#=&gt; nil</span>\n</pre>\n<p>If <code>=~</code> is used …\n"],["=~","String","String.html#method-i-3D~","(p1)","<p>Match—If <em>obj</em> is a Regexp, use it as a pattern to match against <em>str</em>,and returns the position the match …\n"],["=~","Symbol","Symbol.html#method-i-3D~","(p1)","<p>Returns <code>sym.to_s =~ obj</code>.\n"],[">","BigDecimal","BigDecimal.html#method-i-3E","(p1)","<p>Returns true if a is greater than b.\n<p>Values may be coerced to perform the comparison (see ==, BigDecimal#coerce …\n"],[">","Comparable","Comparable.html#method-i-3E","(p1)","<p>Compares two objects based on the receiver&#39;s <code>&lt;=&gt;</code> method, returning true if it returns a value …\n"],[">","Float","Float.html#method-i-3E","(p1)","<p>Returns <code>true</code> if <code>float</code> is greater than <code>real</code>.\n<p>The result of <code>NaN &gt; NaN</code> is undefined, so an implementation-dependent …\n"],[">","Hash","Hash.html#method-i-3E","(p1)","<p>Returns <code>true</code> if <em>other</em> is subset of <em>hash</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h1</span> = {<span class=\"ruby-value\">a:</span><span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">b:</span><span class=\"ruby-value\">2</span>}\n<span class=\"ruby-identifier\">h2</span> = {<span class=\"ruby-value\">a:</span><span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">b:</span><span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">c:</span><span class=\"ruby-value\">3</span>}\n<span class=\"ruby-identifier\">h1</span> <span class=\"ruby-operator\">&gt;</span> <span class=\"ruby-identifier\">h2</span>    <span class=\"ruby-comment\">#=&gt; false</span>\n<span class=\"ruby-identifier\">h2</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],[">","Integer","Integer.html#method-i-3E","(p1)","<p>Returns <code>true</code> if the value of <code>int</code> is greater than that of <code>real</code>.\n"],[">","Module","Module.html#method-i-3E","(p1)","<p>Returns true if <em>mod</em> is an ancestor of <em>other</em>. Returns <code>nil</code> if there&#39;s no relationship between the two. …\n"],[">","Set","Set.html#method-i-3E","(set)",""],[">=","BigDecimal","BigDecimal.html#method-i-3E-3D","(p1)","<p>Returns true if a is greater than or equal to b.\n<p>Values may be coerced to perform the comparison (see …\n"],[">=","Comparable","Comparable.html#method-i-3E-3D","(p1)","<p>Compares two objects based on the receiver&#39;s <code>&lt;=&gt;</code> method, returning true if it returns a value …\n"],[">=","Float","Float.html#method-i-3E-3D","(p1)","<p>Returns <code>true</code> if <code>float</code> is greater than or equal to <code>real</code>.\n<p>The result of <code>NaN &gt;= NaN</code> is undefined, so an …\n"],[">=","Hash","Hash.html#method-i-3E-3D","(p1)","<p>Returns <code>true</code> if <em>other</em> is subset of <em>hash</em> or equals to <em>hash</em>.\n\n<pre>h1 = {a:1, b:2}\nh2 = {a:1, b:2, c:3}\nh1 &gt;= ...</pre>\n"],[">=","Integer","Integer.html#method-i-3E-3D","(p1)","<p>Returns <code>true</code> if the value of <code>int</code> is greater than or equal to that of <code>real</code>.\n"],[">=","Module","Module.html#method-i-3E-3D","(p1)","<p>Returns true if <em>mod</em> is an ancestor of <em>other</em>, or the two modules are the same. Returns <code>nil</code> if there&#39;s …\n"],[">=","Set","Set.html#method-i-3E-3D","(set)",""],[">>","Date","Date.html#method-i-3E-3E","(p1)","<p>Returns a date object pointing <code>n</code> months after self. The argument <code>n</code> should be a numeric value.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],[">>","IPAddr","IPAddr.html#method-i-3E-3E","(num)","<p>Returns a new ipaddr built by bitwise right-shift.\n"],[">>","Integer","Integer.html#method-i-3E-3E","(p1)","<p>Returns <code>int</code> shifted right <code>count</code> positions, or left if <code>count</code> is negative.\n"],[">>","Method","Method.html#method-i-3E-3E","(p1)","<p>Returns a proc that is the composition of this method and the given <em>g</em>. The returned proc takes a variable …\n"],[">>","OpenSSL::BN","OpenSSL/BN.html#method-i-3E-3E","(p1)",""],[">>","Proc","Proc.html#method-i-3E-3E","(p1)","<p>Returns a proc that is the composition of this proc and the given <em>g</em>. The returned proc takes a variable …\n"],[">>","Process::Status","Process/Status.html#method-i-3E-3E","(p1)","<p>Shift the bits in <em>stat</em> right <em>num</em> places.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">fork</span> { <span class=\"ruby-identifier\">exit</span> <span class=\"ruby-value\">99</span> }   <span class=\"ruby-comment\">#=&gt; 26563</span>\n<span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">wait</span>       <span class=\"ruby-comment\">#=&gt; 26563</span>\n<span class=\"ruby-identifier\">$?</span>.<span class=\"ruby-identifier\">to_i</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["APOP","Net::POP3","Net/POP3.html#method-c-APOP","(isapop)","<p>Returns the APOP class if <code>isapop</code> is true; otherwise, returns the POP class.  For example:\n\n<pre class=\"ruby\"><span class=\"ruby-comment\"># Example 1 ...</span>\n</pre>\n"],["ASCIIZ","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-ASCIIZ","(str, length)",""],["AdditiveExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-AdditiveExpr","(path, parsed)","<p>| AdditiveExpr (&#39;+&#39; | &#39;-&#39;) MultiplicativeExpr | MultiplicativeExpr\n"],["AndExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-AndExpr","(path, parsed)","<p>| AndExpr S &#39;and&#39; S EqualityExpr | EqualityExpr\n"],["Array","Kernel","Kernel.html#method-i-Array","(p1)","<p>Returns <code>arg</code> as an Array.\n<p>First tries to call <code>to_ary</code> on <code>arg</code>, then <code>to_a</code>. If <code>arg</code> does not respond to <code>to_ary</code> …\n"],["BigDecimal","Kernel","Kernel.html#method-i-BigDecimal","(*args)","<p>Create a new BigDecimal object.\n<p>initial &mdash; The initial value, as an Integer, a Float, a Rational, a BigDecimal …\n"],["CSV","Object","Object.html#method-i-CSV","(*args, &block)","<p>Passes <code>args</code> to CSV::instance.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">CSV</span>(<span class=\"ruby-string\">&quot;CSV,data&quot;</span>).<span class=\"ruby-identifier\">read</span>\n  <span class=\"ruby-comment\">#=&gt; [[&quot;CSV&quot;, &quot;data&quot;]]</span>\n</pre>\n<p>If a block is given, the instance …\n"],["Complex","Kernel","Kernel.html#method-i-Complex","(p1, p2 = v2, p3 = {})","<p>Returns x+i*y;\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>)    <span class=\"ruby-comment\">#=&gt; (1+2i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-string\">&#39;1+2i&#39;</span>)  <span class=\"ruby-comment\">#=&gt; (1+2i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-keyword\">nil</span>)     <span class=\"ruby-comment\">#=&gt; TypeError ...</span>\n</pre>\n"],["CurrentContext","IRB","IRB.html#method-c-CurrentContext","()","<p>The current IRB::Context of the session, see IRB.conf\n\n<pre>irb\nirb(main):001:0&gt; IRB.CurrentContext.irb_name ...</pre>\n"],["D","Net::HTTP","Net/HTTP.html#method-i-D","(msg)",""],["DEBUG","Thread","Thread.html#method-c-DEBUG","()","<p>Returns the thread debug level.  Available only if compiled with THREAD_DEBUG=-1.\n"],["DEBUG=","Thread","Thread.html#method-c-DEBUG-3D","(p1)","<p>Sets the thread debug level.  Available only if compiled with THREAD_DEBUG=-1.\n"],["DelegateClass","Object","Object.html#method-i-DelegateClass","(superclass, &block)","<p>The primary interface to this library.  Use to setup delegation when defining your class.\n\n<pre>class MyClass ...</pre>\n"],["Digest","Object","Object.html#method-i-Digest","(name)","<p>Returns a Digest subclass by <code>name</code> in a thread-safe manner even when on-demand loading is involved.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["Digest","OpenSSL","OpenSSL.html#method-i-Digest","(name)","<p>Returns a Digest subclass by <em>name</em>\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;openssl&#39;</span>\n\n<span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Digest</span>(<span class=\"ruby-string\">&quot;MD5&quot;</span>)\n<span class=\"ruby-comment\"># =&gt; OpenSSL::Digest::MD5 ...</span>\n</pre>\n"],["Digest","OpenSSL","OpenSSL.html#method-c-Digest","(name)","<p>Returns a Digest subclass by <em>name</em>\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;openssl&#39;</span>\n\n<span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Digest</span>(<span class=\"ruby-string\">&quot;MD5&quot;</span>)\n<span class=\"ruby-comment\"># =&gt; OpenSSL::Digest::MD5 ...</span>\n</pre>\n"],["E","BigMath","BigMath.html#method-i-E","(prec)","<p>Computes e (the base of natural logarithms) to the specified number of digits of precision, <code>numeric</code>. …\n"],["EqualityExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-EqualityExpr","(path, parsed)","<p>| EqualityExpr (&#39;=&#39; | &#39;!=&#39;)  RelationalExpr | RelationalExpr\n"],["FilterExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-FilterExpr","(path, parsed)","<p>| FilterExpr Predicate | PrimaryExpr\n"],["Float","Kernel","Kernel.html#method-i-Float","(p1, p2 = {})","<p>Returns <em>arg</em> converted to a float. Numeric types are converted directly, and with exception to String …\n"],["FunctionCall","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-FunctionCall","(rest, parsed)","<p>| FUNCTION_NAME &#39;(&#39; ( expr ( &#39;,&#39; expr )* )? &#39;)&#39;\n"],["Hash","Kernel","Kernel.html#method-i-Hash","(p1)","<p>Converts <em>arg</em> to a Hash by calling <em>arg</em><code>.to_hash</code>. Returns an empty Hash when <em>arg</em> is <code>nil</code> or <code>[]</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Hash</span>([])  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["I","Matrix","Matrix.html#method-c-I","(n)",""],["Integer","Kernel","Kernel.html#method-i-Integer","(*args)","<p>Converts <em>arg</em> to an Integer. Numeric types are converted directly (with floating point numbers being truncated). …\n"],["JSON","Kernel","Kernel.html#method-i-JSON","(object, *args)","<p>If <em>object</em> is string-like, parse the string and return the parsed result as a Ruby data structure. Otherwise …\n"],["JobManager","IRB","IRB.html#method-c-JobManager","()","<p>The current JobManager in the session\n"],["LOG_MASK","Syslog::Macros","Syslog/Macros.html#method-i-LOG_MASK","(p1)","<p>Generates a mask bit for a priority level. See #mask=\n"],["LOG_UPTO","Syslog::Macros","Syslog/Macros.html#method-i-LOG_UPTO","(p1)","<p>Generates a mask value for priority levels at or below the level specified. See #mask=\n"],["LocationPath","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-LocationPath","(path, parsed)","<p>LocationPath\n\n<pre>| RelativeLocationPath\n| &#39;/&#39; RelativeLocationPath?\n| &#39;//&#39; RelativeLocationPath</pre>\n"],["MultiplicativeExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-MultiplicativeExpr","(path, parsed)","<p>| MultiplicativeExpr (&#39;*&#39; | S (&#39;div&#39; | &#39;mod&#39;) S) UnaryExpr | UnaryExpr\n"],["NodeTest","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-NodeTest","(path, parsed)",""],["OrExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-OrExpr","(path, parsed)","<p>| OrExpr S &#39;or&#39; S AndExpr | AndExpr\n"],["PI","BigMath","BigMath.html#method-i-PI","(prec)","<p>Computes the value of pi to the specified number of digits of precision, <code>numeric</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BigMath</span>.<span class=\"ruby-constant\">PI</span>(<span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">to_s</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["PathExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-PathExpr","(path, parsed)","<p>| LocationPath | FilterExpr (&#39;/&#39; | &#39;//&#39;) RelativeLocationPath\n"],["Pathname","Kernel","Kernel.html#method-i-Pathname","(p1)","<p>Creates a new Pathname object from the given string, <code>path</code>, and returns pathname object.\n<p>In order to use …\n"],["PermaLink?","RSS::Rss::Channel::Item::Guid","RSS/Rss/Channel/Item/Guid.html#method-i-PermaLink-3F","()",""],["Predicate","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-Predicate","(path, parsed)","<p>Filters the supplied nodeset on the predicate(s)\n"],["PrimaryExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-PrimaryExpr","(path, parsed)",""],["Proxy","Net::HTTP","Net/HTTP.html#method-c-Proxy","(p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil)","<p>Creates an HTTP proxy class which behaves like Net::HTTP, but performs all access via the specified proxy. …\n"],["Rational","Kernel","Kernel.html#method-i-Rational","(p1, p2 = v2, p3 = {})","<p>Returns <code>x/y</code> or <code>arg</code> as a Rational.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (2/3)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">5</span>)      <span class=\"ruby-comment\">#=&gt; (5/1)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">0.5</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["RelationalExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-RelationalExpr","(path, parsed)","<p>| RelationalExpr (&#39;&lt;&#39; | &#39;&gt;&#39; | &#39;&lt;=&#39; | &#39;&gt;=&#39;) AdditiveExpr | …\n"],["RelativeLocationPath","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-RelativeLocationPath","(path, parsed)",""],["SP","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-SP","(s)",""],["SP_Z","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-SP_Z","(s)",""],["String","IRB::Locale","IRB/Locale.html#method-i-String","(mes)",""],["String","Kernel","Kernel.html#method-i-String","(p1)","<p>Returns <em>arg</em> as a String.\n<p>First tries to call its <code>to_str</code> method, then its <code>to_s</code> method.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">String</span>(<span class=\"ruby-keyword\">self</span>)     <span class=\"ruby-operator\">...</span>\n</pre>\n"],["URI","Bundler","Bundler.html#method-i-URI","(uri)","<p>Returns <code>uri</code> converted to an Bundler::URI object.\n"],["URI","Bundler","Bundler.html#method-c-URI","(uri)","<p>Returns <code>uri</code> converted to an Bundler::URI object.\n"],["URI","Kernel","Kernel.html#method-i-URI","(uri)","<p>Returns <code>uri</code> converted to an URI object.\n"],["URI","Kernel","Kernel.html#method-c-URI","(uri)","<p>Returns <code>uri</code> converted to an URI object.\n"],["UnaryExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-UnaryExpr","(path, parsed)","<p>| &#39;-&#39; UnaryExpr | UnionExpr\n"],["UnionExpr","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-UnionExpr","(path, parsed)","<p>| UnionExpr &#39;|&#39; PathExpr | PathExpr\n"],["Z","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-Z","(s)",""],["[]","Array","Array.html#method-c-5B-5D","(*args)","<p>Returns a new array populated with the given objects.\n\n<pre>Array.[]( 1, &#39;a&#39;, /^A/)  # =&gt; [1, &quot;a&quot;, /^A/]\nArray[ ...</pre>\n"],["[]","Array","Array.html#method-i-5B-5D","(*args)","<p>Element Reference — Returns the element at <code>index</code>, or returns a subarray starting at the <code>start</code> index …\n"],["[]","Bundler::Index","Bundler/Index.html#method-i-5B-5D","(query, base = nil)",""],["[]","Bundler::Settings","Bundler/Settings.html#method-i-5B-5D","(name)",""],["[]","Bundler::SpecSet","Bundler/SpecSet.html#method-i-5B-5D","(key)",""],["[]","CGI::QueryExtension","CGI/QueryExtension.html#method-i-5B-5D","(key)","<p>Get the value for the parameter with a given key.\n<p>If the parameter has multiple values, only the first …\n"],["[]","CGI::Session","CGI/Session.html#method-i-5B-5D","(key)","<p>Retrieve the session data for key <code>key</code>.\n"],["[]","CSV::Row","CSV/Row.html#method-i-5B-5D","(header_or_index, minimum_index = 0)",""],["[]","CSV::Table","CSV/Table.html#method-i-5B-5D","(index_or_header)","<p>In the default mixed mode, this method returns rows for index access and columns for header access.  …\n"],["[]","Continuation","Continuation.html#method-i-5B-5D","(*args)","<p>Invokes the continuation. The program continues from the end of the #callcc block. If no arguments are …\n"],["[]","DBM","DBM.html#method-i-5B-5D","(p1)","<p>Return a value from the database by locating the key string provided.  If the key is not found, returns …\n"],["[]","DRb::DRbSSLSocket::SSLConfig","DRb/DRbSSLSocket/SSLConfig.html#method-i-5B-5D","(key)","<p>A convenience method to access the values like a Hash\n"],["[]","DRb::GW","DRb/GW.html#method-i-5B-5D","(key)","<p>Retrieves <code>key</code> from the GW\n"],["[]","Dir","Dir.html#method-c-5B-5D","(*args, p2 = {})","<p>Equivalent to calling <code>Dir.glob([string,...], 0)</code>.\n"],["[]","ENV","ENV.html#method-c-5B-5D","(p1)","<p>Returns the value for the environment variable <code>name</code> if it exists:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>[<span class=\"ruby-string\">&#39;foo&#39;</span>] = <span class=\"ruby-string\">&#39;0&#39;</span>\n<span class=\"ruby-constant\">ENV</span>[<span class=\"ruby-string\">&#39;foo&#39;</span>] <span class=\"ruby-comment\"># =&gt; &quot;0&quot;</span>\n</pre>\n"],["[]","Fiddle::CStructEntity","Fiddle/CStructEntity.html#method-i-5B-5D","(name)","<p>Fetch struct member <code>name</code>\n"],["[]","Fiddle::CompositeHandler","Fiddle/CompositeHandler.html#method-i-5B-5D","(symbol)","<p>See Fiddle::CompositeHandler.sym\n"],["[]","Fiddle::Handle","Fiddle/Handle.html#method-i-5B-5D","(p1)","<p>Get the address as an Integer for the function named <code>name</code>.\n"],["[]","Fiddle::Handle","Fiddle/Handle.html#method-c-5B-5D","(p1)","<p>Get the address as an Integer for the function named <code>name</code>.  The function is searched via dlsym on RTLD_NEXT …\n"],["[]","Fiddle::Importer","Fiddle/Importer.html#method-i-5B-5D","(name)","<p>Returns the function mapped to <code>name</code>, that was created by either Fiddle::Importer.extern or Fiddle::Importer.bind …\n"],["[]","Fiddle::Pointer","Fiddle/Pointer.html#method-i-5B-5D","(p1, p2 = v2)","<p>Returns integer stored at <em>index</em>.\n<p>If <em>start</em> and <em>length</em> are given, a string containing the bytes from <em>start</em> …\n"],["[]","Fiddle::Pointer","Fiddle/Pointer.html#method-c-5B-5D","(p1)","<p>Get the underlying pointer for ruby object <code>val</code> and return it as a Fiddle::Pointer object.\n"],["[]","GDBM","GDBM.html#method-i-5B-5D","(p1)","<p>Retrieves the <em>value</em> corresponding to <em>key</em>.\n"],["[]","Gem::CommandManager","Gem/CommandManager.html#method-i-5B-5D","(command_name)","<p>Returns a Command instance for <code>command_name</code>\n"],["[]","Gem::ConfigFile","Gem/ConfigFile.html#method-i-5B-5D","(key)","<p>Return the configuration information for <code>key</code>.\n"],["[]","Hash","Hash.html#method-i-5B-5D","(p1)","<p>Element Reference—Retrieves the <em>value</em> object corresponding to the <em>key</em> object. If not found, returns …\n"],["[]","Hash","Hash.html#method-c-5B-5D","(*args)","<p>Creates a new hash populated with the given objects.\n<p>Similar to the literal <code>{ <em>key</em> =&gt; <em>value</em>, ... }</code>. …\n"],["[]","IRB::History","IRB/History.html#method-i-5B-5D","(idx)","<p>Get one item of the content (both positive and negative indexes work).\n"],["[]","Integer","Integer.html#method-i-5B-5D","(*args)","<p>Bit Reference—Returns the <code>n</code>th bit in the binary representation of <code>int</code>, where <code>int[0]</code> is the least significant …\n"],["[]","JSON","JSON.html#method-c-5B-5D","(object, opts = {})","<p>If <em>object</em> is string-like, parse the string and return the parsed result as a Ruby data structure. Otherwise …\n"],["[]","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-5B-5D","(p1)","<p>Returns the value returned by method <code>name</code>.\n"],["[]","JSON::GenericObject","JSON/GenericObject.html#method-i-5B-5D","(name)",""],["[]","MakeMakefile","MakeMakefile.html#method-c-5B-5D","(name)",""],["[]","MatchData","MatchData.html#method-i-5B-5D","(p1, p2 = v2)","<p>Match Reference – MatchData acts as an array, and may be accessed using the normal array indexing techniques. …\n"],["[]","Matrix","Matrix.html#method-i-5B-5D","(i, j)","<p>Returns element (<code>i</code>,<code>j</code>) of the matrix.  That is: row <code>i</code>, column <code>j</code>.\n"],["[]","Matrix","Matrix.html#method-c-5B-5D","(*rows)","<p>Creates a matrix where each argument is a row.\n\n<pre>Matrix[ [25, 93], [-1, 66] ]\n   =&gt;  25 93\n       -1 66</pre>\n"],["[]","Method","Method.html#method-i-5B-5D","(*args)","<p>Invokes the <em>meth</em> with the specified arguments, returning the method&#39;s return value, like #call.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["[]","Net::HTTPHeader","Net/HTTPHeader.html#method-i-5B-5D","(key)","<p>Returns the header field corresponding to the case-insensitive key. For example, a key of “Content-Type” …\n"],["[]","OLEProperty","OLEProperty.html#method-i-5B-5D","(*args)",""],["[]","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-5B-5D","(p1)","<p>Retrieves a weakly referenced object with the given key\n"],["[]","OpenSSL::Config","OpenSSL/Config.html#method-i-5B-5D","(section)","<p>Get a specific <em>section</em> from the current configuration\n<p>Given the following configurating file being loaded: …\n"],["[]","OpenStruct","OpenStruct.html#method-i-5B-5D","(name)","<p>Returns the value of an attribute.\n\n<pre>require &quot;ostruct&quot;\nperson = OpenStruct.new(&quot;name&quot; =&gt; &quot;John Smith&quot;, &quot;age&quot; ...</pre>\n"],["[]","PStore","PStore.html#method-i-5B-5D","(name)","<p>Retrieves a value from the PStore file data, by <em>name</em>.  The hierarchy of Ruby objects stored under that …\n"],["[]","Prime::TrialDivision","Prime/TrialDivision.html#method-i-5B-5D","(index)","<p>Returns the +index+th prime number.\n<p><code>index</code> is a 0-based index.\n"],["[]","Proc","Proc.html#method-i-5B-5D","(*args)","<p>Invokes the block, setting the block&#39;s parameters to the values in <em>params</em> using something close to …\n"],["[]","Psych::Coder","Psych/Coder.html#method-i-5B-5D","(k)",""],["[]","REXML::AttlistDecl","REXML/AttlistDecl.html#method-i-5B-5D","(key)","<p>Access the attlist attribute/value pairs.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">value</span> = <span class=\"ruby-identifier\">attlist_decl</span>[ <span class=\"ruby-identifier\">attribute_name</span> ]\n</pre>\n"],["[]","REXML::Attributes","REXML/Attributes.html#method-i-5B-5D","(name)","<p>Fetches an attribute value.  If you want to get the Attribute itself, use get_attribute()\n<p>name &mdash; an XPath …\n"],["[]","REXML::Element","REXML/Element.html#method-i-5B-5D","(name_or_index)","<p>Fetches an attribute value or a child.\n<p>If String or Symbol is specified, it&#39;s treated as attribute …\n"],["[]","REXML::Elements","REXML/Elements.html#method-i-5B-5D","( index, name=nil)","<p>Fetches a child element.  Filters only Element children, regardless of the XPath match.\n<p>index &mdash; the search …\n"],["[]","REXML::Light::Node","REXML/Light/Node.html#method-i-5B-5D","( reference, ns=nil )",""],["[]","REXML::Parent","REXML/Parent.html#method-i-5B-5D","( index )","<p>Fetches a child at a given index @param index the Integer index of the child to fetch\n"],["[]","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-5B-5D","( start, endd=nil)",""],["[]","RSS::Maker","RSS/Maker.html#method-c-5B-5D","(version)","<p>Returns the maker for the <code>version</code>\n"],["[]","RSS::XML::Element","RSS/XML/Element.html#method-i-5B-5D","(name)",""],["[]","Racc::Grammar","Racc/Grammar.html#method-i-5B-5D","(x)",""],["[]","Racc::ISet","Racc/ISet.html#method-i-5B-5D","(key)",""],["[]","Racc::Rule","Racc/Rule.html#method-i-5B-5D","(idx)",""],["[]","Racc::States","Racc/States.html#method-i-5B-5D","(i)",""],["[]","Racc::SymbolTable","Racc/SymbolTable.html#method-i-5B-5D","(id)",""],["[]","Rinda::Tuple","Rinda/Tuple.html#method-i-5B-5D","(k)","<p>Accessor method for elements of the tuple.\n"],["[]","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-5B-5D","(key)","<p>Retrieves <code>key</code> from the tuple.\n"],["[]","SDBM","SDBM.html#method-i-5B-5D","(p1)","<p>Returns the <code>value</code> in the database associated with the given <code>key</code> string.\n<p>If no value is found, returns …\n"],["[]","Set","Set.html#method-c-5B-5D","(*ary)","<p>Creates a new set containing the given objects.\n\n<pre>Set[1, 2]                   # =&gt; #&lt;Set: {1, 2}&gt;\nSet[1, ...</pre>\n"],["[]","String","String.html#method-i-5B-5D","(*args)","<p>Element Reference — If passed a single <code>index</code>, returns a substring of one character at that index.  …\n"],["[]","StringScanner","StringScanner.html#method-i-5B-5D","(p1)","<p>Returns the n-th subgroup in the most recent match.\n\n<pre>s = StringScanner.new(&quot;Fri Dec 12 1975 14:39&quot;)\ns.scan(/(\\w+) ...</pre>\n"],["[]","Struct","Struct.html#method-i-5B-5D","(p1)","<p>Attribute Reference—Returns the value of the given struct <code>member</code> or the member at the given <code>index</code>. …\n"],["[]","Symbol","Symbol.html#method-i-5B-5D","(*args)","<p>Returns <code>sym.to_s[]</code>.\n"],["[]","Thread","Thread.html#method-i-5B-5D","(p1)","<p>Attribute Reference—Returns the value of a fiber-local variable (current thread&#39;s root fiber if …\n"],["[]","Vector","Vector.html#method-i-5B-5D","(i)","<p>Returns element or elements of the vector.\n"],["[]","Vector","Vector.html#method-c-5B-5D","(*array)","<p>Creates a Vector from a list of elements.\n\n<pre>Vector[7, 4, ...]</pre>\n"],["[]","WEBrick::CGI","WEBrick/CGI.html#method-i-5B-5D","(key)","<p>Reads <code>key</code> from the configuration\n"],["[]","WEBrick::GenericServer","WEBrick/GenericServer.html#method-i-5B-5D","(key)","<p>Retrieves <code>key</code> from the configuration\n"],["[]","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-5B-5D","(header_name)","<p>Retrieves <code>header_name</code>\n"],["[]","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-5B-5D","(field)","<p>Retrieves the response header <code>field</code>\n"],["[]","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-5B-5D","(code)","<p>Returns the status class corresponding to <code>code</code>\n\n<pre>WEBrick::HTTPStatus[302]\n=&gt; WEBrick::HTTPStatus::NotFound</pre>\n"],["[]","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-i-5B-5D","(*key)","<p>Retrieves the header at the first entry in <code>key</code>\n"],["[]","WIN32OLE","WIN32OLE.html#method-i-5B-5D","(*args)","<p>Returns the value of Collection specified by a1, a2,.…\n\n<pre>dict = WIN32OLE.new(&#39;Scripting.Dictionary&#39;)\ndict.add(&#39;ruby&#39;, ...</pre>\n"],["[]","WIN32OLE_VARIANT","WIN32OLE_VARIANT.html#method-i-5B-5D","(*args)","<p>Returns the element of WIN32OLE_VARIANT object(OLE array). This method is available only when the variant …\n"],["[]","Warning","Warning.html#method-c-5B-5D","(p1)","<p>call-seq\n\n<pre>Warning[category]  -&gt; true or false</pre>\n<p>Returns the flag to show the warning messages for <code>category</code> …\n"],["[]","YAML::DBM","YAML/DBM.html#method-i-5B-5D","( key )","<p>Return value associated with <code>key</code> from database.\n<p>Returns <code>nil</code> if there is no such <code>key</code>.\n<p>See #fetch for more …\n"],["[]=","Array","Array.html#method-i-5B-5D-3D","(*args)","<p>Element Assignment — Sets the element at <code>index</code>, or replaces a subarray from the <code>start</code> index for <code>length</code> …\n"],["[]=","Bundler::SpecSet","Bundler/SpecSet.html#method-i-5B-5D-3D","(key, value)",""],["[]=","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-5B-5D-3D","(key, value)",""],["[]=","CGI::Session","CGI/Session.html#method-i-5B-5D-3D","(key, val)","<p>Set the session data for key <code>key</code>.\n"],["[]=","CSV::Row","CSV/Row.html#method-i-5B-5D-3D","(*args)","<p>Looks up the field by the semantics described in CSV::Row.field() and assigns the <code>value</code>.\n<p>Assigning past …\n"],["[]=","CSV::Table","CSV/Table.html#method-i-5B-5D-3D","(index_or_header, value)","<p>In the default mixed mode, this method assigns rows for index access and columns for header access.  …\n"],["[]=","DBM","DBM.html#method-i-5B-5D-3D","(p1, p2)","<p>Stores the specified string value in the database, indexed via the string key provided.\n"],["[]=","DRb::GW","DRb/GW.html#method-i-5B-5D-3D","(key, v)","<p>Stores value <code>v</code> at <code>key</code> in the GW\n"],["[]=","ENV","ENV.html#method-c-5B-5D-3D","(p1, p2)","<p>ENV.store is an alias for ENV.[]=.\n<p>Creates, updates, or deletes the named environment variable, returning …\n"],["[]=","Fiddle::CStructEntity","Fiddle/CStructEntity.html#method-i-5B-5D-3D","(name, val)","<p>Set struct member <code>name</code>, to value <code>val</code>\n"],["[]=","Fiddle::Pointer","Fiddle/Pointer.html#method-i-5B-5D-3D","(p1, p2, p3 = v3)","<p>Set the value at <code>index</code> to <code>int</code>.\n<p>Or, set the memory at <code>start</code> until <code>length</code> with the contents of <code>string</code>, the …\n"],["[]=","GDBM","GDBM.html#method-i-5B-5D-3D","(p1, p2)","<p>Associates the value <em>value</em> with the specified <em>key</em>.\n"],["[]=","Gem::ConfigFile","Gem/ConfigFile.html#method-i-5B-5D-3D","(key, value)","<p>Set configuration option <code>key</code> to <code>value</code>.\n"],["[]=","Hash","Hash.html#method-i-5B-5D-3D","(p1, p2)","<p>Element Assignment\n<p>Associates the value given by <code>value</code> with the key given by <code>key</code>.\n\n<pre>h = { &quot;a&quot; =&gt; 100, &quot;b&quot; ...</pre>\n"],["[]=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-5B-5D-3D","(p1, p2)","<p>Sets the attribute name to value.\n"],["[]=","JSON::GenericObject","JSON/GenericObject.html#method-i-5B-5D-3D","(name, value)",""],["[]=","MakeMakefile","MakeMakefile.html#method-c-5B-5D-3D","(name, mod)",""],["[]=","Matrix","Matrix.html#method-i-5B-5D-3D","(i, j, v)","<p>Set element or elements of matrix.\n"],["[]=","Net::HTTPHeader","Net/HTTPHeader.html#method-i-5B-5D-3D","(key, val)","<p>Sets the header field corresponding to the case-insensitive key.\n"],["[]=","OLEProperty","OLEProperty.html#method-i-5B-5D-3D","(*args)",""],["[]=","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-5B-5D-3D","(p1, p2)","<p>Creates a weak reference from the given key to the given value\n"],["[]=","OpenSSL::Config","OpenSSL/Config.html#method-i-5B-5D-3D","(section, pairs)","<p>Sets a specific <em>section</em> name with a Hash <em>pairs</em>.\n<p>Given the following configuration being created:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">config</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["[]=","OpenStruct","OpenStruct.html#method-i-5B-5D-3D","(name, value)","<p>Sets the value of an attribute.\n\n<pre>require &quot;ostruct&quot;\nperson = OpenStruct.new(&quot;name&quot; =&gt; &quot;John Smith&quot;, &quot;age&quot; ...</pre>\n"],["[]=","PStore","PStore.html#method-i-5B-5D-3D","(name, value)","<p>Stores an individual Ruby object or a hierarchy of Ruby objects in the data store file under the root …\n"],["[]=","Psych::Coder","Psych/Coder.html#method-i-5B-5D-3D","(k, v)",""],["[]=","REXML::Attributes","REXML/Attributes.html#method-i-5B-5D-3D","( name, value )","<p>Sets an attribute, overwriting any existing attribute value by the same name.  Namespace is significant. …\n"],["[]=","REXML::Elements","REXML/Elements.html#method-i-5B-5D-3D","( index, element )","<p>Sets an element, replacing any previous matching element.  If no existing element is found ,the element …\n"],["[]=","REXML::Light::Node","REXML/Light/Node.html#method-i-5B-5D-3D","( reference, ns, value=nil )","<p>Doesn&#39;t handle namespaces yet\n"],["[]=","REXML::Parent","REXML/Parent.html#method-i-5B-5D-3D","( *args )","<p>Set an index entry.  See Array.[]= @param index the index of the element to set @param opt either the …\n"],["[]=","REXML::XPathParser","REXML/XPathParser.html#method-i-5B-5D-3D","( variable_name, value )",""],["[]=","RSS::XML::Element","RSS/XML/Element.html#method-i-5B-5D-3D","(name, value)",""],["[]=","Racc::ISet","Racc/ISet.html#method-i-5B-5D-3D","(key, val)",""],["[]=","SDBM","SDBM.html#method-i-5B-5D-3D","(p1, p2)","<p>Stores a new <code>value</code> in the database with the given <code>key</code> as an index.\n<p>If the <code>key</code> already exists, this will …\n"],["[]=","String","String.html#method-i-5B-5D-3D","(*args)","<p>Element Assignment—Replaces some or all of the content of <em>str</em>. The portion of the string affected is …\n"],["[]=","Struct","Struct.html#method-i-5B-5D-3D","(p1, p2)","<p>Attribute Assignment—Sets the value of the given struct <code>member</code> or the member at the given <code>index</code>.   …\n"],["[]=","Thread","Thread.html#method-i-5B-5D-3D","(p1, p2)","<p>Attribute Assignment—Sets or creates the value of a fiber-local variable, using either a symbol or …\n"],["[]=","Vector","Vector.html#method-i-5B-5D-3D","(i, v)","<p>Set element or elements of vector.\n"],["[]=","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-5B-5D-3D","(field, value)","<p>Sets the response header <code>field</code> to <code>value</code>\n"],["[]=","WIN32OLE","WIN32OLE.html#method-i-5B-5D-3D","(*args)","<p>Sets the value to WIN32OLE object specified by a1, a2, …\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">dict</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Scripting.Dictionary&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["[]=","WIN32OLE_VARIANT","WIN32OLE_VARIANT.html#method-i-5B-5D-3D","(*args)","<p>Set the element of WIN32OLE_VARIANT object(OLE array) to val. This method is available only when the …\n"],["[]=","Warning","Warning.html#method-c-5B-5D-3D","(p1, p2)","<p>call-seq\n\n<pre>Warning[category] = flag -&gt; flag</pre>\n<p>Sets the warning flags for <code>category</code>. See Warning.[] for the categories. …\n"],["[]=","YAML::DBM","YAML/DBM.html#method-i-5B-5D-3D","( key, val )","<p>Set <code>key</code> to <code>value</code> in database.\n<p><code>value</code> will be converted to YAML before storage.\n<p>See #store for more information. …\n"],["^","FalseClass","FalseClass.html#method-i-5E","(p1)","<p>Exclusive Or—If <em>obj</em> is <code>nil</code> or <code>false</code>, returns <code>false</code>; otherwise, returns <code>true</code>.\n"],["^","Integer","Integer.html#method-i-5E","(p1)","<p>Bitwise EXCLUSIVE OR.\n"],["^","NilClass","NilClass.html#method-i-5E","(p1)","<p>Exclusive Or—If <em>obj</em> is <code>nil</code> or <code>false</code>, returns <code>false</code>; otherwise, returns <code>true</code>.\n"],["^","Set","Set.html#method-i-5E","(enum)","<p>Returns a new set containing elements exclusive between the set and the given enumerable object.  (set …\n"],["^","TrueClass","TrueClass.html#method-i-5E","(p1)","<p>Exclusive Or—Returns <code>true</code> if <em>obj</em> is <code>nil</code> or <code>false</code>, <code>false</code> otherwise.\n"],["_","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_","(&block)",""],["_PermaLink?","RSS::Rss::Channel::Item::Guid","RSS/Rss/Channel/Item/Guid.html#method-i-_PermaLink-3F","()",""],["__callee__","Kernel","Kernel.html#method-i-__callee__","()","<p>Returns the called name of the current method as a Symbol. If called outside of a method, it returns …\n"],["__dependencies","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-__dependencies","()",""],["__dir__","Kernel","Kernel.html#method-i-__dir__","()","<p>Returns the canonicalized absolute path of the directory of the file from which this method is called. …\n"],["__drbref","DRb::DRbObject","DRb/DRbObject.html#method-i-__drbref","()","<p>Get the reference of the object, if local.\n"],["__drbref","DRb::DRbObject","DRb/DRbObject.html#method-i-__drbref","()","<p>Get the reference of the object, if local.\n"],["__drburi","DRb::DRbObject","DRb/DRbObject.html#method-i-__drburi","()","<p>Get the URI of the remote object.\n"],["__drburi","DRb::DRbObject","DRb/DRbObject.html#method-i-__drburi","()","<p>Get the URI of the remote object.\n"],["__evaluate__","IRB::WorkSpace","IRB/WorkSpace.html#method-i-__evaluate__","(context, statements, file = nil, line = nil)",""],["__exit__","IRB::Context","IRB/Context.html#method-i-__exit__","(ret = 0)",""],["__getobj__","Delegator","Delegator.html#method-i-__getobj__","()","<p>This method must be overridden by subclasses and should return the object method calls are being delegated …\n"],["__getobj__","SimpleDelegator","SimpleDelegator.html#method-i-__getobj__","()","<p>Returns the current object method calls are being delegated to.\n"],["__id__","BasicObject","BasicObject.html#method-i-__id__","()","<p>Returns an integer identifier for <code>obj</code>.\n<p>The same number will be returned on all calls to <code>object_id</code> for …\n"],["__materialize__","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-__materialize__","()",""],["__method__","Kernel","Kernel.html#method-i-__method__","()","<p>Returns the name at the definition of the current method as a Symbol. If called outside of a method, …\n"],["__raise__","Delegator","Delegator.html#method-i-__raise__","",""],["__send__","BasicObject","BasicObject.html#method-i-__send__","(*args)","<p>Invokes the method identified by <em>symbol</em>, passing it any arguments specified. You can use <code>__send__</code> if …\n"],["__setobj__","Delegator","Delegator.html#method-i-__setobj__","(obj)","<p>This method must be overridden by subclasses and change the object delegate to <em>obj</em>.\n"],["__setobj__","SimpleDelegator","SimpleDelegator.html#method-i-__setobj__","(obj)","<p>Changes the delegate object to <em>obj</em>.\n<p>It&#39;s important to note that this does <strong>not</strong> cause SimpleDelegator&#39;s …\n"],["__swap__","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-__swap__","(spec)",""],["__swap__","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-__swap__","(spec)","<p>Because Rubyforge cannot be trusted to provide valid specifications once the remote gem is downloaded, …\n"],["__to_xpath_helper","REXML::Element","REXML/Element.html#method-i-__to_xpath_helper","(node)",""],["__validate","RSS::Element","RSS/Element.html#method-i-__validate","(ignore_unknown_element, tags=_tags, recursive=true)",""],["_ac_arg_enable","OptionParser::AC","OptionParser/AC.html#method-i-_ac_arg_enable","(prefix, name, help_string, block)",""],["_add","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_add","(target, x)",""],["_added?","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_added-3F","(sym)",""],["_attrs","RSS::Element","RSS/Element.html#method-i-_attrs","()",""],["_attrs","RSS::Rss","RSS/Rss.html#method-i-_attrs","()",""],["_check_ac_args","OptionParser::AC","OptionParser/AC.html#method-i-_check_ac_args","(name, block)",""],["_compute_expand","Racc::Grammar","Racc/Grammar.html#method-i-_compute_expand","(t, set, lock)",""],["_defmetasyntax","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_defmetasyntax","(type, id, action, &block)",""],["_delayed_add","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_delayed_add","(rule)",""],["_dump","BigDecimal","BigDecimal.html#method-i-_dump","(p1 = v1)","<p>Method used to provide marshalling support.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">inf</span> = <span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;Infinity&#39;</span>)\n  <span class=\"ruby-comment\">#=&gt; Infinity</span>\n<span class=\"ruby-constant\">BigDecimal</span>.<span class=\"ruby-identifier\">_load</span>(<span class=\"ruby-identifier\">inf</span>.<span class=\"ruby-identifier\">_dump</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["_dump","DRb::DRbObject","DRb/DRbObject.html#method-i-_dump","(lv)","<p>Marshall this object.\n<p>The URI and ref of the object are marshalled.\n"],["_dump","DRb::DRbObject","DRb/DRbObject.html#method-i-_dump","(lv)","<p>Marshall this object.\n<p>The URI and ref of the object are marshalled.\n"],["_dump","Gem::Specification","Gem/Specification.html#method-i-_dump","(limit)","<p>Dump only crucial instance variables.\n"],["_dump","Singleton","Singleton.html#method-i-_dump","(depth = -1)","<p>By default, do not retain any state when marshalling.\n"],["_enumerable_collect","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_collect","()",""],["_enumerable_collect_concat","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_collect_concat","()",""],["_enumerable_drop","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_drop","(p1)",""],["_enumerable_drop_while","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_drop_while","()",""],["_enumerable_filter","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_filter","()",""],["_enumerable_filter_map","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_filter_map","()",""],["_enumerable_find_all","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_find_all","()",""],["_enumerable_flat_map","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_flat_map","()",""],["_enumerable_grep","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_grep","(p1)",""],["_enumerable_grep_v","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_grep_v","(p1)",""],["_enumerable_map","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_map","()",""],["_enumerable_reject","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_reject","()",""],["_enumerable_select","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_select","()",""],["_enumerable_take","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_take","(p1)",""],["_enumerable_take_while","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_take_while","()",""],["_enumerable_uniq","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_uniq","()",""],["_enumerable_with_index","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_with_index","(*args)","<p>Iterates the given block for each element with an index, which starts from <code>offset</code>.  If no block is given, …\n"],["_enumerable_zip","Enumerator::Lazy","Enumerator/Lazy.html#method-i-_enumerable_zip","(*args)",""],["_execute","DRb::ThreadObject","DRb/ThreadObject.html#method-i-_execute","()",""],["_getproperty","WIN32OLE","WIN32OLE.html#method-i-_getproperty","(p1, p2, p3)","<p>Runs the early binding method to get property. The 1st argument specifies dispatch ID, the 2nd argument …\n"],["_gets_noecho","Gem::StreamUI","Gem/StreamUI.html#method-i-_gets_noecho","()",""],["_groups","Bundler::Graph","Bundler/Graph.html#method-i-_groups","()",""],["_httpdate","Date","Date.html#method-c-_httpdate","(p1, p2 = {})","<p>Returns a hash of parsed elements.\n<p>Raise an ArgumentError when the string length is longer than <em>limit</em> …\n"],["_id2ref","ObjectSpace","ObjectSpace.html#method-c-_id2ref","(p1)",""],["_intern","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_intern","(x)",""],["_invoke","WIN32OLE","WIN32OLE.html#method-i-_invoke","(p1, p2, p3)","<p>Runs the early binding method. The 1st argument specifies dispatch ID, the 2nd argument specifies the …\n"],["_ipv4_compat?","IPAddr","IPAddr.html#method-i-_ipv4_compat-3F","()",""],["_iso8601","Date","Date.html#method-c-_iso8601","(p1, p2 = {})","<p>Returns a hash of parsed elements.\n<p>Raise an ArgumentError when the string length is longer than <em>limit</em> …\n"],["_jisx0301","Date","Date.html#method-c-_jisx0301","(p1, p2 = {})","<p>Returns a hash of parsed elements.\n<p>Raise an ArgumentError when the string length is longer than <em>limit</em> …\n"],["_load","BigDecimal","BigDecimal.html#method-c-_load","(p1)","<p>Internal method used to provide marshalling support. See the Marshal module.\n"],["_load","DRb::DRbObject","DRb/DRbObject.html#method-c-_load","(s)","<p>Unmarshall a marshalled DRbObject.\n<p>If the referenced object is located within the local server, then the …\n"],["_load","DRb::DRbObject","DRb/DRbObject.html#method-c-_load","(s)","<p>Unmarshall a marshalled DRbObject.\n<p>If the referenced object is located within the local server, then the …\n"],["_load","Gem::Specification","Gem/Specification.html#method-c-_load","(str)","<p>Load custom marshal format, re-initializing defaults as needed\n"],["_load","Singleton","Singleton.html#method-c-_load","","<p>By default calls instance(). Override to retain singleton state.\n"],["_local_specification","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-_local_specification","()",""],["_make_label","Bundler::Graph","Bundler/Graph.html#method-i-_make_label","(symbol_or_string_or_dependency, element_type)",""],["_no_crlf_check","CGI","CGI.html#method-i-_no_crlf_check","(str)",""],["_ns","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-_ns","(ns, prefix)",""],["_parse","Date","Date.html#method-c-_parse","(*args)","<p>Parses the given representation of date and time, and returns a hash of parsed elements.  This method …\n"],["_parse","RSS::REXMLParser","RSS/REXMLParser.html#method-i-_parse","()",""],["_parse","RSS::XMLParserParser","RSS/XMLParserParser.html#method-i-_parse","()",""],["_parse","RSS::XMLScanParser","RSS/XMLScanParser.html#method-i-_parse","()",""],["_parse_date_if_needed","RSS::Maker::SetupDefaultDate","RSS/Maker/SetupDefaultDate.html#method-i-_parse_date_if_needed","(date_value)",""],["_path_to?","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-_path_to-3F","(other, visited = Set.new)","<p>@param [Vertex] other the vertex to check if there&#39;s a path to @param [Set&lt;Vertex&gt;] visited …\n"],["_populate_relations","Bundler::Graph","Bundler/Graph.html#method-i-_populate_relations","()",""],["_racc_do_parse_c","Racc::Parser","Racc/Parser.html#method-i-_racc_do_parse_c","(p1, p2)",""],["_racc_do_parse_rb","Racc::Parser","Racc/Parser.html#method-i-_racc_do_parse_rb","(arg, in_debug)",""],["_racc_do_reduce","Racc::Parser","Racc/Parser.html#method-i-_racc_do_reduce","(arg, act)",""],["_racc_evalact","Racc::Parser","Racc/Parser.html#method-i-_racc_evalact","(act, arg)","<p>common\n"],["_racc_init_sysvars","Racc::Parser","Racc/Parser.html#method-i-_racc_init_sysvars","()",""],["_racc_setup","Racc::Parser","Racc/Parser.html#method-i-_racc_setup","()",""],["_racc_yyparse_c","Racc::Parser","Racc/Parser.html#method-i-_racc_yyparse_c","(p1, p2, p3, p4)",""],["_racc_yyparse_rb","Racc::Parser","Racc/Parser.html#method-i-_racc_yyparse_rb","(recv, mid, arg, c_debug)",""],["_recursive_predecessors","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-_recursive_predecessors","(vertices = Set.new)","<p>@param [Set&lt;Vertex&gt;] vertices the set to add the predecessors to @return [Set&lt;Vertex&gt;] the …\n"],["_recursive_successors","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-_recursive_successors","(vertices = Set.new)","<p>@param [Set&lt;Vertex&gt;] vertices the set to add the successors to @return [Set&lt;Vertex&gt;] the …\n"],["_regist","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_regist","(target_name)",""],["_remote_specification","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-_remote_specification","()",""],["_remote_specification","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-_remote_specification","()",""],["_reverse","IPAddr","IPAddr.html#method-i-_reverse","()",""],["_rfc2822","Date","Date.html#method-c-_rfc2822","(p1, p2 = {})","<p>Returns a hash of parsed elements.\n<p>Raise an ArgumentError when the string length is longer than <em>limit</em> …\n"],["_rfc3339","Date","Date.html#method-c-_rfc3339","(p1, p2 = {})","<p>Returns a hash of parsed elements.\n<p>Raise an ArgumentError when the string length is longer than <em>limit</em> …\n"],["_rfc822","Date","Date.html#method-c-_rfc822","(p1, p2 = {})","<p>Returns a hash of parsed elements.\n<p>Raise an ArgumentError when the string length is longer than <em>limit</em> …\n"],["_segments","Gem::Version","Gem/Version.html#method-i-_segments","()",""],["_set_default_values","RSS::Maker::Atom::Entry::Items::Item","RSS/Maker/Atom/Entry/Items/Item.html#method-i-_set_default_values","()",""],["_set_default_values","RSS::Maker::Atom::Feed::Channel","RSS/Maker/Atom/Feed/Channel.html#method-i-_set_default_values","(&block)",""],["_set_default_values","RSS::Maker::Atom::Feed::Items::Item","RSS/Maker/Atom/Feed/Items/Item.html#method-i-_set_default_values","(&block)",""],["_set_default_values","RSS::Maker::Base","RSS/Maker/Base.html#method-i-_set_default_values","(&block)",""],["_set_default_values","RSS::Maker::SetupDefaultDate","RSS/Maker/SetupDefaultDate.html#method-i-_set_default_values","()",""],["_set_default_values","RSS::Maker::SetupDefaultLanguage","RSS/Maker/SetupDefaultLanguage.html#method-i-_set_default_values","()",""],["_set_last_value","IRB::Context","IRB/Context.html#method-i-_set_last_value","(value)","<p>See #set_last_value\n"],["_setproperty","WIN32OLE","WIN32OLE.html#method-i-_setproperty","(p1, p2, p3)","<p>Runs the early binding method to set property. The 1st argument specifies dispatch ID, the 2nd argument …\n"],["_setup_maker_element","RSS::Rss::Channel::Item","RSS/Rss/Channel/Item.html#method-i-_setup_maker_element","(item)",""],["_split_segments","Gem::Version","Gem/Version.html#method-i-_split_segments","()",""],["_strptime","Date","Date.html#method-c-_strptime","(*args)","<p>Parses the given representation of date and time with the given template, and returns a hash of parsed …\n"],["_strptime","DateTime","DateTime.html#method-c-_strptime","(*args)","<p>Parses the given representation of date and time with the given template, and returns a hash of parsed …\n"],["_tags","RSS::Element","RSS/Element.html#method-i-_tags","()",""],["_tilde_requirements","Gem::Requirement","Gem/Requirement.html#method-i-_tilde_requirements","()",""],["_to_string","IPAddr","IPAddr.html#method-i-_to_string","(addr)",""],["_validate","RSS::Element","RSS/Element.html#method-i-_validate","(ignore_unknown_element, tags, uri, models=self.class.models)",""],["_version","Gem::Version","Gem/Version.html#method-i-_version","()",""],["_wrap","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-_wrap","(target_name, sym, block)",""],["_xmlschema","Date","Date.html#method-c-_xmlschema","(p1, p2 = {})","<p>Returns a hash of parsed elements.\n<p>Raise an ArgumentError when the string length is longer than <em>limit</em> …\n"],["`","Kernel","Kernel.html#method-i-60","(p1)","<p>Returns the standard output of running <em>cmd</em> in a subshell. The built-in syntax <code>%x{...}</code> uses this method. …\n"],["a","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-a","(href = \"\")","<p>Generate an Anchor element as a string.\n<p><code>href</code> can either be a string, giving the URL for the HREF attribute, …\n"],["abbrev","Abbrev","Abbrev.html#method-c-abbrev","(words, pattern = nil)","<p>Given a set of strings, calculate the set of unambiguous abbreviations for those strings, and return …\n"],["abbrev","Abbrev","Abbrev.html#method-i-abbrev","(words, pattern = nil)","<p>Given a set of strings, calculate the set of unambiguous abbreviations for those strings, and return …\n"],["abbrev","Array","Array.html#method-i-abbrev","(pattern = nil)","<p>Calculates the set of unambiguous abbreviations for the strings in <code>self</code>.\n\n<pre>require &#39;abbrev&#39;\n%w{ car cone ...</pre>\n"],["abbreviate","Gem::Specification","Gem/Specification.html#method-i-abbreviate","()","<p>Abbreviate the spec for downloading.  Abbreviated specs are only used for searching, downloading and …\n"],["abbreviate","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-abbreviate","( path )",""],["abort","Kernel","Kernel.html#method-i-abort","(*args)",""],["abort","Net::FTP","Net/FTP.html#method-i-abort","()","<p>Aborts the previous command (ABOR command).\n"],["abort","OptionParser","OptionParser.html#method-i-abort","(mesg = $!)",""],["abort","PStore","PStore.html#method-i-abort","()","<p>Ends the current PStore#transaction, discarding any changes to the data store.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&quot;pstore&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["abort","Process","Process.html#method-c-abort","(*args)",""],["abort_on_exception","Thread","Thread.html#method-i-abort_on_exception","()","<p>Returns the status of the thread-local “abort on exception&#39;&#39; condition for this <code>thr</code>.\n<p>The default …\n"],["abort_on_exception","Thread","Thread.html#method-c-abort_on_exception","()","<p>Returns the status of the global “abort on exception&#39;&#39; condition.\n<p>The default is <code>false</code>.\n<p>When set …\n"],["abort_on_exception=","Thread","Thread.html#method-c-abort_on_exception-3D","(p1)","<p>When set to <code>true</code>, if any thread is aborted by an exception, the raised exception will be re-raised in …\n"],["abort_on_exception=","Thread","Thread.html#method-i-abort_on_exception-3D","(p1)","<p>When set to <code>true</code>, if this <code>thr</code> is aborted by an exception, the raised exception will be re-raised in the …\n"],["abort_threads","Bundler::Worker","Bundler/Worker.html#method-i-abort_threads","()",""],["abs","BigDecimal","BigDecimal.html#method-i-abs","()","<p>Returns the absolute value, as a BigDecimal.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;5&#39;</span>).<span class=\"ruby-identifier\">abs</span>  <span class=\"ruby-comment\">#=&gt; 0.5e1</span>\n<span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;-3&#39;</span>).<span class=\"ruby-identifier\">abs</span> <span class=\"ruby-comment\">#=&gt; 0.3e1</span>\n</pre>\n"],["abs","Complex","Complex.html#method-i-abs","()","<p>Returns the absolute part of its polar form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">-1</span>).<span class=\"ruby-identifier\">abs</span>         <span class=\"ruby-comment\">#=&gt; 1</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">3.0</span>, <span class=\"ruby-value\">-4.0</span>).<span class=\"ruby-identifier\">abs</span>  <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["abs","Float","Float.html#method-i-abs","()","<p>Returns the absolute value of <code>float</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">-34.56</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; 34.56</span>\n<span class=\"ruby-value\">-34.56</span>.<span class=\"ruby-identifier\">abs</span>     <span class=\"ruby-comment\">#=&gt; 34.56</span>\n<span class=\"ruby-value\">34.56</span>.<span class=\"ruby-identifier\">abs</span>      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["abs","Integer","Integer.html#method-i-abs","()","<p>Returns the absolute value of <code>int</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">-12345</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; 12345</span>\n<span class=\"ruby-value\">-12345</span>.<span class=\"ruby-identifier\">abs</span>     <span class=\"ruby-comment\">#=&gt; 12345</span>\n<span class=\"ruby-value\">12345</span>.<span class=\"ruby-identifier\">abs</span>      <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["abs","Matrix","Matrix.html#method-i-abs","()","<p>Returns the absolute value elementwise\n"],["abs","Numeric","Numeric.html#method-i-abs","()","<p>Returns the absolute value of <code>num</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">12</span>.<span class=\"ruby-identifier\">abs</span>         <span class=\"ruby-comment\">#=&gt; 12</span>\n(<span class=\"ruby-value\">-34.56</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; 34.56</span>\n<span class=\"ruby-value\">-34.56</span>.<span class=\"ruby-identifier\">abs</span>     <span class=\"ruby-comment\">#=&gt; 34.56</span>\n</pre>\n"],["abs","Rational","Rational.html#method-i-abs","()","<p>Returns the absolute value of <code>rat</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2r</span>).<span class=\"ruby-identifier\">abs</span>    <span class=\"ruby-comment\">#=&gt; (1/2)</span>\n(<span class=\"ruby-value\">-1</span><span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2r</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; (1/2)</span>\n</pre>\n<p>Rational#magnitude is …\n"],["abs2","Complex","Complex.html#method-i-abs2","()","<p>Returns square of the absolute value.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">-1</span>).<span class=\"ruby-identifier\">abs2</span>         <span class=\"ruby-comment\">#=&gt; 1</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">3.0</span>, <span class=\"ruby-value\">-4.0</span>).<span class=\"ruby-identifier\">abs2</span>  <span class=\"ruby-comment\">#=&gt; 25.0</span>\n</pre>\n"],["abs2","Numeric","Numeric.html#method-i-abs2","()","<p>Returns square of self.\n"],["absolute","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-absolute","()",""],["absolute","URI::Generic","URI/Generic.html#method-i-absolute","()",""],["absolute?","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-absolute-3F","()","<p>Returns true if Bundler::URI has a scheme (e.g. http:// or https://) specified.\n"],["absolute?","Pathname","Pathname.html#method-i-absolute-3F","()","<p>Predicate method for testing whether a path is absolute.\n<p>It returns <code>true</code> if the pathname begins with a …\n"],["absolute?","Resolv::DNS::Name","Resolv/DNS/Name.html#method-i-absolute-3F","()","<p>True if this name is absolute.\n"],["absolute?","URI::Generic","URI/Generic.html#method-i-absolute-3F","()","<p>Returns true if URI has a scheme (e.g. http:// or https://) specified.\n"],["absolute_matches","Bundler::Thor::LineEditor::Readline::PathCompletion","Bundler/Thor/LineEditor/Readline/PathCompletion.html#method-i-absolute_matches","()",""],["absolute_path","File","File.html#method-c-absolute_path","(*args)","<p>Converts a pathname to an absolute pathname. Relative paths are referenced from the current working directory …\n"],["absolute_path","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-absolute_path","()","<p>Returns the absolute path of this instruction sequence.\n<p><code>nil</code> if the iseq was evaluated from a string.\n<p>For …\n"],["absolute_path","Thread::Backtrace::Location","Thread/Backtrace/Location.html#method-i-absolute_path","()","<p>Returns the full file path of this frame.\n<p>Same as #path, but includes the absolute path.\n"],["absolute_path?","File","File.html#method-c-absolute_path-3F","(p1)","<p>Returns <code>true</code> if <code>file_name</code> is an absolute path, and <code>false</code> otherwise.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">absolute_path?</span>(<span class=\"ruby-string\">&quot;c:/foo&quot;</span>)     <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ac_arg_disable","OptionParser::AC","OptionParser/AC.html#method-i-ac_arg_disable","(name, help_string, &block)",""],["ac_arg_enable","OptionParser::AC","OptionParser/AC.html#method-i-ac_arg_enable","(name, help_string, &block)",""],["ac_arg_with","OptionParser::AC","OptionParser/AC.html#method-i-ac_arg_with","(name, help_string, &block)",""],["accept","DRb::DRbSSLSocket::SSLConfig","DRb/DRbSSLSocket/SSLConfig.html#method-i-accept","(tcp)","<p>Accept connection to IO <code>tcp</code>, with context of the current certificate configuration\n"],["accept","OpenSSL::SSL::SSLServer","OpenSSL/SSL/SSLServer.html#method-i-accept","()","<p>Works similar to TCPServer#accept.\n"],["accept","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-accept","()","<p>Waits for a SSL/TLS client to initiate a handshake.  The handshake may be started after unencrypted data …\n"],["accept","OptionParser","OptionParser.html#method-c-accept","(*args, &blk)","<p>See #accept.\n"],["accept","OptionParser","OptionParser.html#method-i-accept","(*args, &blk)","<p>Directs to accept specified class <code>t</code>. The argument string is passed to the block in which it should be …\n"],["accept","OptionParser::List","OptionParser/List.html#method-i-accept","(t, pat = /.*/m, &block)","<p>See OptionParser.accept.\n"],["accept","Psych::Visitors::JSONTree","Psych/Visitors/JSONTree.html#method-i-accept","(target)",""],["accept","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-accept","(target)",""],["accept","Psych::Visitors::Visitor","Psych/Visitors/Visitor.html#method-i-accept","(target)",""],["accept","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-accept","(target)",""],["accept","Socket","Socket.html#method-i-accept","()","<p>Accepts a next connection. Returns a new Socket object and Addrinfo object.\n\n<pre>serv = Socket.new(:INET, :STREAM, ...</pre>\n"],["accept","TCPServer","TCPServer.html#method-i-accept","()","<p>Accepts an incoming connection. It returns a new TCPSocket object.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">TCPServer</span>.<span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;127.0.0.1&quot;</span>, <span class=\"ruby-value\">14641</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["accept","UNIXServer","UNIXServer.html#method-i-accept","()","<p>Accepts an incoming connection. It returns a new UNIXSocket object.\n\n<pre>UNIXServer.open(&quot;/tmp/sock&quot;) {|serv| ...</pre>\n"],["accept?","Racc::Rule","Racc/Rule.html#method-i-accept-3F","()",""],["accept_charset","CGI","CGI.html#method-c-accept_charset","()","<p>Return the accept character set for all new CGI instances.\n"],["accept_charset=","CGI","CGI.html#method-c-accept_charset-3D","(accept_charset)","<p>Set the accept character set for all new CGI instances.\n"],["accept_loop","Socket","Socket.html#method-c-accept_loop","(*sockets)","<p>yield socket and client address for each a connection accepted via given sockets.\n<p>The arguments are a …\n"],["accept_nonblock","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-accept_nonblock","(p1 = {})","<p>Initiates the SSL/TLS handshake as a server in non-blocking manner.\n\n<pre># emulates blocking accept\nbegin\n ...</pre>\n"],["accept_nonblock","Socket","Socket.html#method-i-accept_nonblock","(exception: true)","<p>Accepts an incoming connection using accept(2) after O_NONBLOCK is set for the underlying file descriptor. …\n"],["accept_nonblock","TCPServer","TCPServer.html#method-i-accept_nonblock","(exception: true)","<p>Accepts an incoming connection using accept(2) after O_NONBLOCK is set for the underlying file descriptor. …\n"],["accept_nonblock","UNIXServer","UNIXServer.html#method-i-accept_nonblock","(exception: true)","<p>Accepts an incoming connection using accept(2) after O_NONBLOCK is set for the underlying file descriptor. …\n"],["accept_uri_http","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-accept_uri_http","()","<p>Allows OptionParser to handle HTTP URIs.\n"],["access_log","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-access_log","(config, req, res)","<p>Logs <code>req</code> and <code>res</code> in the access logs.  <code>config</code> is used for the server name.\n"],["acct","Net::FTP","Net/FTP.html#method-i-acct","(account)","<p>Sends the ACCT command.\n<p>This is a less common FTP command, to send account information if the destination …\n"],["acos","Math","Math.html#method-c-acos","(p1)","<p>Computes the arc cosine of <code>x</code>. Returns 0..PI.\n<p>Domain: [-1, 1]\n<p>Codomain: [0, PI]\n"],["acosh","Math","Math.html#method-c-acosh","(p1)","<p>Computes the inverse hyperbolic cosine of <code>x</code>.\n<p>Domain: [1, INFINITY)\n<p>Codomain: [0, INFINITY)\n"],["act2actid","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-act2actid","(act)",""],["action","Bundler::PermissionError","Bundler/PermissionError.html#method-i-action","()",""],["action","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-action","(&block)",""],["action_name","Bundler::Molinillo::DependencyGraph::Action","Bundler/Molinillo/DependencyGraph/Action.html#method-c-action_name","()","<p>@return [Symbol] The name of the action.\n"],["action_name","Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular","Bundler/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-c-action_name","()","<p>(see Action.action_name)\n"],["action_name","Bundler::Molinillo::DependencyGraph::DeleteEdge","Bundler/Molinillo/DependencyGraph/DeleteEdge.html#method-c-action_name","()","<p>(see Action.action_name)\n"],["action_name","Bundler::Molinillo::DependencyGraph::DetachVertexNamed","Bundler/Molinillo/DependencyGraph/DetachVertexNamed.html#method-c-action_name","()","<p>(see Action#name)\n"],["action_name","Bundler::Molinillo::DependencyGraph::Tag","Bundler/Molinillo/DependencyGraph/Tag.html#method-c-action_name","()","<p>(see Action.action_name)\n"],["action_name","Gem::Resolver::Molinillo::DependencyGraph::Action","Gem/Resolver/Molinillo/DependencyGraph/Action.html#method-c-action_name","()","<p>@return [Symbol] The name of the action.\n"],["action_name","Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular","Gem/Resolver/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-c-action_name","()","<p>(see Action.action_name)\n"],["action_name","Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge","Gem/Resolver/Molinillo/DependencyGraph/DeleteEdge.html#method-c-action_name","()","<p>(see Action.action_name)\n"],["action_name","Gem::Resolver::Molinillo::DependencyGraph::DetachVertexNamed","Gem/Resolver/Molinillo/DependencyGraph/DetachVertexNamed.html#method-c-action_name","()","<p>(see Action#name)\n"],["action_name","Gem::Resolver::Molinillo::DependencyGraph::Tag","Gem/Resolver/Molinillo/DependencyGraph/Tag.html#method-c-action_name","()","<p>(see Action.action_name)\n"],["action_out","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-action_out","(f, state)",""],["actions","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-actions","()",""],["activate","Gem::Specification","Gem/Specification.html#method-i-activate","()","<p>Activate this spec, registering it as a loaded spec and adding it&#39;s lib paths to $LOAD_PATH. Returns …\n"],["activate_dependencies","Gem::Specification","Gem/Specification.html#method-i-activate_dependencies","()","<p>Activate all unambiguously resolved runtime dependencies of this spec. Add any ambiguous dependencies …\n"],["activate_new_spec","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-activate_new_spec","()","<p>Add the current {#possibility} to the dependency graph of the current {#state} @return [void]\n"],["activate_platform!","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-activate_platform-21","(platform)",""],["activate_spec","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-activate_spec","()","<p>Add the current {#possibility} to the dependency graph of the current {#state} @return [void]\n"],["activated","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-activated","()","<p>(see Bundler::Molinillo::ResolutionState#activated)\n"],["activated","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-activated","()",""],["activated","Gem::Resolver::Molinillo::Delegates::ResolutionState","Gem/Resolver/Molinillo/Delegates/ResolutionState.html#method-i-activated","()","<p>(see Gem::Resolver::Molinillo::ResolutionState#activated)\n"],["activated=","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-activated-3D","(activated)",""],["activated?","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-activated-3F","()","<p>True when the gem has been activated\n"],["activated_gem_paths","Gem","Gem.html#method-c-activated_gem_paths","()","<p>The number of paths in the `$LOAD_PATH` from activated gems. Used to prioritize `-I` and `ENV` entries …\n"],["active?","Net::HTTP","Net/HTTP.html#method-i-active-3F","()",""],["active?","Net::POP3","Net/POP3.html#method-i-active-3F","()",""],["active_count","Gem::DependencyList","Gem/DependencyList.html#method-i-active_count","(specs, ignored)","<p>Count the number of gemspecs in the list <code>specs</code> that are not in <code>ignored</code>.\n"],["add","ACL::ACLList","ACL/ACLList.html#method-i-add","(str)","<p>Adds <code>str</code> as an ACLEntry in this list\n"],["add","Benchmark::Tms","Benchmark/Tms.html#method-i-add","()","<p>Returns a new Tms object whose times are the sum of the times for this Tms object, plus the time required …\n"],["add","BigDecimal","BigDecimal.html#method-i-add","(p1, p2)","<p>Add the specified value.\n<p>e.g.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">add</span>(<span class=\"ruby-identifier\">b</span>,<span class=\"ruby-identifier\">n</span>)\n<span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-identifier\">b</span>\n</pre>\n"],["add","Bundler::CLI","Bundler/CLI.html#method-i-add","(*gems)",""],["add","DRb::WeakIdConv::WeakSet","DRb/WeakIdConv/WeakSet.html#method-i-add","(obj)",""],["add","Gem::AvailableSet","Gem/AvailableSet.html#method-i-add","(spec, source)",""],["add","Gem::DependencyList","Gem/DependencyList.html#method-i-add","(*gemspecs)","<p>Adds <code>gemspecs</code> to the dependency list.\n"],["add","Gem::Resolver::RequirementList","Gem/Resolver/RequirementList.html#method-i-add","(req)","<p>Adds Resolver::DependencyRequest <code>req</code> to this requirements list.\n"],["add","Gem::TestCase::StaticSet","Gem/TestCase/StaticSet.html#method-i-add","(spec)","<p>Adds <code>spec</code> to this set.\n"],["add","Logger","Logger.html#method-i-add","(severity, message = nil, progname = nil)","<p>Args\n<p><code>severity</code> &mdash; Severity.  Constants are defined in Logger namespace: <code>DEBUG</code>, <code>INFO</code>, <code>WARN</code>, <code>ERROR</code>, <code>FATAL</code>, or …\n"],["add","Psych::Coder","Psych/Coder.html#method-i-add","(k, v)",""],["add","RDoc::Context","RDoc/Context.html#method-i-add","(klass, name, comment)","<p>Adds an item of type <code>klass</code> with the given <code>name</code> and <code>comment</code> to the context.\n<p>Currently only RDoc::Extend …\n"],["add","REXML::Attributes","REXML/Attributes.html#method-i-add","( attribute )","<p>Adds an attribute, overriding any existing attribute by the same name.  Namespaces are significant.\n<p>attribute … &mdash; "],["add","REXML::DocType","REXML/DocType.html#method-i-add","(child)",""],["add","REXML::Document","REXML/Document.html#method-i-add","( child )","<p>We override this, because XMLDecls and DocTypes must go at the start of the document\n"],["add","REXML::Elements","REXML/Elements.html#method-i-add","(element=nil)","<p>Adds an element\n<p>element &mdash; if supplied, is either an Element, String, or Source (see Element.initialize). …\n"],["add","REXML::Parent","REXML/Parent.html#method-i-add","( object )",""],["add","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-add","( pair )",""],["add","Racc::Grammar","Racc/Grammar.html#method-i-add","(rule)","<p>Grammar Definition Interface\n"],["add","Racc::ISet","Racc/ISet.html#method-i-add","(i)",""],["add","Rinda::TupleBag::TupleBin","Rinda/TupleBag/TupleBin.html#method-i-add","(tuple)",""],["add","Set","Set.html#method-i-add","(o)","<p>Adds the given object to the set and returns self.  Use <code>merge</code> to add many elements at once.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>].<span class=\"ruby-identifier\">add</span>(<span class=\"ruby-value\">3</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["add","Syslog::Logger","Syslog/Logger.html#method-i-add","(severity, message = nil, progname = nil, &block)","<p>Almost duplicates Logger#add.  <code>progname</code> is ignored.\n"],["add","ThreadGroup","ThreadGroup.html#method-i-add","(p1)","<p>Adds the given <code>thread</code> to this group, removing it from any other group to which it may have previously …\n"],["add","WEBrick::HTTPAuth::Htgroup","WEBrick/HTTPAuth/Htgroup.html#method-i-add","(group, members)","<p>Add an Array of <code>members</code> to <code>group</code>\n"],["add!","Benchmark::Tms","Benchmark/Tms.html#method-i-add-21","(&blk)","<p>An in-place version of #add. Changes the times of this Tms object by making it the sum of the times for …\n"],["add?","Set","Set.html#method-i-add-3F","(o)","<p>Adds the given object to the set and returns self.  If the object is already in the set, returns nil. …\n"],["add_GIT","Gem::RequestSet::Lockfile","Gem/RequestSet/Lockfile.html#method-i-add_GIT","(out, git_requests)",""],["add_alias","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-add_alias","(an_alias, context = nil)","<p>Adds <code>an_alias</code> as an alias for this method in <code>context</code>.\n"],["add_alias","RDoc::Attr","RDoc/Attr.html#method-i-add_alias","(an_alias, context)","<p>Add <code>an_alias</code> as an attribute in <code>context</code>.\n"],["add_alias","RDoc::Context","RDoc/Context.html#method-i-add_alias","(an_alias)","<p>Adds <code>an_alias</code> that is automatically resolved\n"],["add_alias","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-add_alias","(an_alias, context)","<p>Abstract method. Contexts in their building phase call this to register a new alias for this known method/attribute. …\n"],["add_alias","RDoc::Stats","RDoc/Stats.html#method-i-add_alias","(as)","<p>Records the parsing of an alias <code>as</code>.\n"],["add_alias","RDoc::TopLevel","RDoc/TopLevel.html#method-i-add_alias","(an_alias)","<p>Adds <code>an_alias</code> to <code>Object</code> instead of <code>self</code>.\n"],["add_always_install","Gem::Resolver::InstallerSet","Gem/Resolver/InstallerSet.html#method-i-add_always_install","(dependency)","<p>Looks up the latest specification for <code>dependency</code> and adds it to the always_install list.\n"],["add_attribute","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-add_attribute","(p1)",""],["add_attribute","RDoc::Context","RDoc/Context.html#method-i-add_attribute","(attribute)","<p>Adds <code>attribute</code> if not already there. If it is (as method(s) or attribute), updates the comment if it …\n"],["add_attribute","RDoc::Stats","RDoc/Stats.html#method-i-add_attribute","(attribute)","<p>Records the parsing of an attribute <code>attribute</code>\n"],["add_attribute","REXML::Element","REXML/Element.html#method-i-add_attribute","( key, value=nil )","<p>Adds an attribute to this element, overwriting any existing attribute by the same name.\n<p>key &mdash; can be either …\n"],["add_attributes","REXML::Element","REXML/Element.html#method-i-add_attributes","(hash)","<p>Add multiple attributes to this element.\n<p>hash &mdash; is either a hash, or array of arrays\n\n\n<pre>el.add_attributes( {&quot;name1&quot;=&gt;&quot;value1&quot;, ...</pre>\n"],["add_authenticator","Net::IMAP","Net/IMAP.html#method-c-add_authenticator","(auth_type, authenticator)","<p>Adds an authenticator for Net::IMAP#authenticate.  <code>auth_type</code> is the type of authentication this authenticator …\n"],["add_bindir","Gem::Specification","Gem/Specification.html#method-i-add_bindir","(executables)","<p>Returns an array with bindir attached to each executable in the <code>executables</code> list\n"],["add_bulk_threshold_option","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-add_bulk_threshold_option","()","<p>Add the –bulk-threshold option\n"],["add_bundled_with","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-add_bundled_with","()",""],["add_c_enclosure","RDoc::Store","RDoc/Store.html#method-i-add_c_enclosure","(variable, namespace)","<p>Adds <code>module</code> as an enclosure (namespace) for the given <code>variable</code> for C files.\n"],["add_c_variables","RDoc::Store","RDoc/Store.html#method-i-add_c_variables","(c_parser)","<p>Adds C variables from an RDoc::Parser::C\n"],["add_cert","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-add_cert","(p1)","<p>Adds the OpenSSL::X509::Certificate <em>cert</em> to the certificate store.\n"],["add_certid","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-add_certid","(p1)","<p>Adds <em>certificate_id</em> to the request.\n"],["add_certificate","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-add_certificate","(p1)",""],["add_certificate","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-add_certificate","(p1, p2, p3 = v3)","<p>Adds a certificate to the context. <em>pkey</em> must be a corresponding private key with <em>certificate</em>.\n<p>Multiple …\n"],["add_checksums","Gem::Package","Gem/Package.html#method-i-add_checksums","(tar)","<p>Adds a checksum for each entry in the gem to checksums.yaml.gz.\n"],["add_child_vertex","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-add_child_vertex","(name, payload, parent_names, requirement)","<p>@param [String] name @param [Object] payload @param [Array&lt;String&gt;] parent_names @param [Object] …\n"],["add_child_vertex","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-add_child_vertex","(name, payload, parent_names, requirement)","<p>@param [String] name @param [Object] payload @param [Array&lt;String&gt;] parent_names @param [Object] …\n"],["add_class","RDoc::Context","RDoc/Context.html#method-i-add_class","(class_type, given_name, superclass = '::Object')","<p>Adds a class named <code>given_name</code> with <code>superclass</code>.\n<p>Both <code>given_name</code> and <code>superclass</code> may contain &#39;::&#39;, …\n"],["add_class","RDoc::Stats","RDoc/Stats.html#method-i-add_class","(klass)","<p>Records the parsing of a class <code>klass</code>\n"],["add_class_or_module","RDoc::Context","RDoc/Context.html#method-i-add_class_or_module","(mod, self_hash, all_hash)","<p>Adds the class or module <code>mod</code> to the modules or classes Hash <code>self_hash</code>, and to <code>all_hash</code> (either <code>TopLevel::modules_hash</code> …\n"],["add_clear_sources_option","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-add_clear_sources_option","()","<p>Add the –clear-sources option\n"],["add_color","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-add_color","(string, *color)",""],["add_color","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-add_color","(string, color)",""],["add_command","Bundler::Plugin","Bundler/Plugin.html#method-i-add_command","(command, cls)","<p>To be called via the API to register to handle a command\n"],["add_comment","RDoc::ClassModule","RDoc/ClassModule.html#method-i-add_comment","(comment, location)","<p>Adds <code>comment</code> to this ClassModule&#39;s list of comments at <code>location</code>.  This method is preferred over  …\n"],["add_common_option","Gem::Command","Gem/Command.html#method-c-add_common_option","(*args, &handler)",""],["add_constant","RDoc::Context","RDoc/Context.html#method-i-add_constant","(constant)","<p>Adds <code>constant</code> if not already there. If it is, updates the comment, value and/or is_alias_for of the known …\n"],["add_constant","RDoc::Stats","RDoc/Stats.html#method-i-add_constant","(constant)","<p>Records the parsing of <code>constant</code>\n"],["add_constant","RDoc::TopLevel","RDoc/TopLevel.html#method-i-add_constant","(constant)","<p>Adds <code>constant</code> to <code>Object</code> instead of <code>self</code>.\n"],["add_converter","CSV::FieldsConverter","CSV/FieldsConverter.html#method-i-add_converter","(name=nil, &converter)",""],["add_crl","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-add_crl","(p1)",""],["add_crl","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-add_crl","(p1)","<p>Adds the OpenSSL::X509::CRL <em>crl</em> to the store.\n"],["add_current_platform","Bundler::Definition","Bundler/Definition.html#method-i-add_current_platform","()",""],["add_data","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-add_data","(p1)",""],["add_date","Gem::Server","Gem/Server.html#method-i-add_date","(res)",""],["add_dependencies","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-add_dependencies","()",""],["add_dependency","Gem::Specification","Gem/Specification.html#method-i-add_dependency","(gem, *requirements)",""],["add_dependency_with_type","Gem::Specification","Gem/Specification.html#method-i-add_dependency_with_type","(dependency, type, requirements)","<p>Adds a dependency on gem <code>dependency</code> with type <code>type</code> that requires <code>requirements</code>.  Valid types are currently …\n"],["add_development_dependency","Gem::Specification","Gem/Specification.html#method-i-add_development_dependency","(gem, *requirements)","<p>Adds a development dependency named <code>gem</code> with <code>requirements</code> to this gem.\n<p>Usage:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">spec</span>.<span class=\"ruby-identifier\">add_development_dependency</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["add_dictionary","Zlib::Inflate","Zlib/Inflate.html#method-i-add_dictionary","(p1)","<p>Provide the inflate stream with a dictionary that may be required in the future.  Multiple dictionaries …\n"],["add_edge","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-add_edge","(origin, destination, requirement)","<p>Adds a new {Edge} to the dependency graph @param [Vertex] origin @param [Vertex] destination @param [Object] …\n"],["add_edge","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-add_edge","(origin, destination, requirement)","<p>Adds a new {Edge} to the dependency graph @param [Vertex] origin @param [Vertex] destination @param [Object] …\n"],["add_edge_no_circular","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-add_edge_no_circular","(origin, destination, requirement)","<p>Adds a new {Edge} to the dependency graph without checking for circularity. @param (see #add_edge) @return …\n"],["add_edge_no_circular","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-add_edge_no_circular","(graph, origin, destination, requirement)","<p>@macro action\n"],["add_edge_no_circular","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-add_edge_no_circular","(origin, destination, requirement)","<p>Adds a new {Edge} to the dependency graph without checking for circularity. @param (see #add_edge) @return …\n"],["add_edge_no_circular","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-add_edge_no_circular","(graph, origin, destination, requirement)","<p>@macro action\n"],["add_element","REXML::Document","REXML/Document.html#method-i-add_element","(arg=nil, arg2=nil)",""],["add_element","REXML::Element","REXML/Element.html#method-i-add_element","(element, attrs=nil)","<p>Adds a child to this element, optionally setting attributes in the element.\n<p>element &mdash; optional.  If Element …\n"],["add_entry","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-add_entry","(p1, p2, p3 = v3, p4 = {})","<p>Adds a new entry with the given <em>oid</em> and <em>value</em> to this name.  The <em>oid</em> is an object identifier defined …\n"],["add_event_to_arry","REXML::Validation::Choice","REXML/Validation/Choice.html#method-i-add_event_to_arry","( arry, evt )",""],["add_event_to_arry","REXML::Validation::State","REXML/Validation/State.html#method-i-add_event_to_arry","( arry, evt )",""],["add_extend","RDoc::Context","RDoc/Context.html#method-i-add_extend","(ext)","<p>Adds extension module <code>ext</code> which should be an RDoc::Extend\n"],["add_extension","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-add_extension","(p1)",""],["add_extension","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-add_extension","(p1)",""],["add_extension","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-add_extension","(p1)",""],["add_extra_args","Gem::Command","Gem/Command.html#method-i-add_extra_args","(args)","<p>Adds extra args from ~/.gemrc\n"],["add_field","Net::HTTPHeader","Net/HTTPHeader.html#method-i-add_field","(key, val)","<p>Ruby 1.8.3 &mdash; Adds a value to a named header field, instead of replacing its value. Second argument <code>val</code> …\n"],["add_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-add_file","(destination, *args, &block)",""],["add_file","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-add_file","(name, mode)","<p>Adds file <code>name</code> with permissions <code>mode</code>, and yields an IO for writing the file to\n"],["add_file","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-add_file","(p1)","<p>Adds the certificates in <em>file</em> to the certificate store. <em>file</em> is the path to the file, and the file contains …\n"],["add_file","RDoc::Stats","RDoc/Stats.html#method-i-add_file","(file)","<p>Records the parsing of <code>file</code>\n"],["add_file","RDoc::Store","RDoc/Store.html#method-i-add_file","(absolute_name, relative_name: absolute_name, parser: nil)","<p>Adds the file with <code>name</code> as an RDoc::TopLevel to the store.  Returns the created RDoc::TopLevel.\n"],["add_file_digest","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-add_file_digest","(name, mode, digest_algorithms)","<p>Adds <code>name</code> with permissions <code>mode</code> to the tar, yielding <code>io</code> for writing the file.  The <code>digest_algorithm</code> is …\n"],["add_file_signed","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-add_file_signed","(name, mode, signer)","<p>Adds <code>name</code> with permissions <code>mode</code> to the tar, yielding <code>io</code> for writing the file.  The <code>signer</code> is used to …\n"],["add_file_simple","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-add_file_simple","(name, mode, size)","<p>Add file <code>name</code> with permissions <code>mode</code> <code>size</code> bytes long.  Yields an IO to write the file to.\n"],["add_filter","Tracer","Tracer.html#method-c-add_filter","(p = nil, &b)","<p>Used to filter unwanted trace output\n<p>Example which only outputs lines of code executed within the Kernel …\n"],["add_generator","RDoc::RDoc","RDoc/RDoc.html#method-c-add_generator","(klass)","<p>Add <code>klass</code> that can generate output after parsing\n"],["add_git_source","Bundler::Plugin::SourceList","Bundler/Plugin/SourceList.html#method-i-add_git_source","(options = {})",""],["add_git_source","Bundler::SourceList","Bundler/SourceList.html#method-i-add_git_source","(options = {})",""],["add_git_sources","Bundler::Dsl","Bundler/Dsl.html#method-i-add_git_sources","()",""],["add_handler","WEBrick::HTTPServlet::FileHandler","WEBrick/HTTPServlet/FileHandler.html#method-c-add_handler","(suffix, handler)","<p>Allow custom handling of requests for files with <code>suffix</code> by class <code>handler</code>\n"],["add_have_children_element","RSS::Element","RSS/Element.html#method-c-add_have_children_element","(variable_name, plural_name)",""],["add_hook","Bundler::Plugin","Bundler/Plugin.html#method-i-add_hook","(event, &block)","<p>To be called via the API to register a hooks and corresponding block that will be called to handle the …\n"],["add_html","RDoc::Markup","RDoc/Markup.html#method-i-add_html","(tag, name)","<p>Add to the sequences recognized as general markup.\n"],["add_include","RDoc::Context","RDoc/Context.html#method-i-add_include","(include)","<p>Adds included module <code>include</code> which should be an RDoc::Include\n"],["add_include","RDoc::TopLevel","RDoc/TopLevel.html#method-i-add_include","(include)","<p>Adds <code>include</code> to <code>Object</code> instead of <code>self</code>.\n"],["add_install_update_options","Gem::InstallUpdateOptions","Gem/InstallUpdateOptions.html#method-i-add_install_update_options","()","<p>Add the install/update options to the option parser.\n"],["add_key_option","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-add_key_option","()","<p>Add the –key option\n"],["add_link","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-add_link","(destination, *args)",""],["add_listener","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-add_listener","( listener )",""],["add_listener","REXML::Parsers::LightParser","REXML/Parsers/LightParser.html#method-i-add_listener","( listener )",""],["add_listener","REXML::Parsers::PullParser","REXML/Parsers/PullParser.html#method-i-add_listener","( listener )",""],["add_listener","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-add_listener","( listener )",""],["add_listener","REXML::Parsers::StreamParser","REXML/Parsers/StreamParser.html#method-i-add_listener","( listener )",""],["add_listener","REXML::Parsers::TreeParser","REXML/Parsers/TreeParser.html#method-i-add_listener","( listener )",""],["add_listener","REXML::Parsers::UltraLightParser","REXML/Parsers/UltraLightParser.html#method-i-add_listener","( listener )",""],["add_local","Gem::Resolver::InstallerSet","Gem/Resolver/InstallerSet.html#method-i-add_local","(dep_name, spec, source)","<p>Adds a local gem requested using <code>dep_name</code> with the given <code>spec</code> that can be loaded and installed using …\n"],["add_local_remote_options","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-add_local_remote_options","()","<p>Add local/remote options to the command line parser.\n"],["add_locked_ruby_version","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-add_locked_ruby_version","()",""],["add_maker","RSS::Maker","RSS/Maker.html#method-c-add_maker","(version, normalized_version, maker)","<p>Adds a maker to the set of supported makers\n"],["add_method","RDoc::Context","RDoc/Context.html#method-i-add_method","(method)","<p>Adds <code>method</code> if not already there. If it is (as method or attribute), updates the comment if it was empty. …\n"],["add_method","RDoc::Stats","RDoc/Stats.html#method-i-add_method","(method)","<p>Records the parsing of <code>method</code>\n"],["add_method","RDoc::TopLevel","RDoc/TopLevel.html#method-i-add_method","(method)","<p>Adds <code>method</code> to <code>Object</code> instead of <code>self</code>.\n"],["add_module","RDoc::Context","RDoc/Context.html#method-i-add_module","(class_type, name)","<p>Adds a module named <code>name</code>.  If RDoc already knows <code>name</code> is a class then that class is returned instead. …\n"],["add_module","RDoc::Stats","RDoc/Stats.html#method-i-add_module","(mod)","<p>Records the parsing of a module <code>mod</code>\n"],["add_module_alias","RDoc::Context","RDoc/Context.html#method-i-add_module_alias","(from, from_name, to, file)","<p>Adds an alias from <code>from</code> (a class or module) to <code>name</code> which was defined in <code>file</code>.\n"],["add_module_by_normal_module","RDoc::Context","RDoc/Context.html#method-i-add_module_by_normal_module","(mod)","<p>Adds a module by <code>RDoc::NormalModule</code> instance. See also #add_module.\n"],["add_namespace","REXML::Element","REXML/Element.html#method-i-add_namespace","( prefix, uri=nil )","<p>Adds a namespace to this element.\n<p>prefix &mdash; the prefix string, or the namespace URI if <code>uri</code> is not supplied …\n"],["add_need_initialize_variable","RSS::Element","RSS/Element.html#method-c-add_need_initialize_variable","(variable_name)",""],["add_need_initialize_variable","RSS::Maker::Base","RSS/Maker/Base.html#method-c-add_need_initialize_variable","(variable_name, init_value=nil, &init_block)",""],["add_nonce","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-add_nonce","(p1 = v1)","<p>Adds <em>nonce</em> to this response.  If no nonce was provided a random nonce will be added.\n"],["add_nonce","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-add_nonce","(p1 = v1)","<p>Adds a <em>nonce</em> to the OCSP request.  If no nonce is given a random one will be generated.\n<p>The nonce is used …\n"],["add_observer","Observable","Observable.html#method-i-add_observer","(observer, func=:update)","<p>Add <code>observer</code> as an observer on this object. So that it will receive notifications.\n<p><code>observer</code> &mdash; the object …\n"],["add_option","Gem::Command","Gem/Command.html#method-i-add_option","(*opts)","<p>Add a command-line option and handler to the command.\n<p>See OptionParser#make_switch for an explanation …\n"],["add_other_element","RSS::Maker::Base","RSS/Maker/Base.html#method-c-add_other_element","(variable_name)",""],["add_otp_option","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-add_otp_option","()","<p>Add the –otp option\n"],["add_owners","Gem::Commands::OwnerCommand","Gem/Commands/OwnerCommand.html#method-i-add_owners","(name, owners)",""],["add_parser_run_info","Gem::Command","Gem/Command.html#method-i-add_parser_run_info","(title, content)","<p>Adds a section with <code>title</code> and <code>content</code> to the parser help view.  Used for adding command arguments and …\n"],["add_path","Gem::Commands::EnvironmentCommand","Gem/Commands/EnvironmentCommand.html#method-i-add_path","(out, path)",""],["add_path","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-add_path","(p1)","<p>Adds <em>path</em> as the hash dir to be looked up by the store.\n"],["add_path_source","Bundler::SourceList","Bundler/SourceList.html#method-i-add_path_source","(options = {})",""],["add_platform","Bundler::Definition","Bundler/Definition.html#method-i-add_platform","(platform)",""],["add_platform","Gem::PlatformMismatch","Gem/PlatformMismatch.html#method-i-add_platform","(platform)","<p>append a platform to the list of mismatched platforms.\n<p>Platforms are added via this instead of injected …\n"],["add_platform_option","Gem::VersionOption","Gem/VersionOption.html#method-i-add_platform_option","(task = command, *wrap)","<p>Add the –platform option to the option parser.\n"],["add_platforms","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-add_platforms","()",""],["add_plugin_source","Bundler::SourceList","Bundler/SourceList.html#method-i-add_plugin_source","(source, options = {})",""],["add_plural_form","RSS::Element","RSS/Element.html#method-c-add_plural_form","(singular, plural)",""],["add_prerelease_option","Gem::VersionOption","Gem/VersionOption.html#method-i-add_prerelease_option","(*wrap)","<p>Add the –prerelease option to the option parser.\n"],["add_protocol","DRb::DRbProtocol","DRb/DRbProtocol.html#method-i-add_protocol","(prot)","<p>Add a new protocol to the DRbProtocol module.\n"],["add_protocol","DRb::DRbProtocol","DRb/DRbProtocol.html#method-c-add_protocol","(prot)","<p>Add a new protocol to the DRbProtocol module.\n"],["add_proxy_option","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-add_proxy_option","()","<p>Add the –http-proxy option\n"],["add_recipient","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-add_recipient","(p1)",""],["add_regexp_handling","RDoc::Markup","RDoc/Markup.html#method-i-add_regexp_handling","(pattern, name)","<p>Add to other inline sequences.  For example, we could add WikiWords using something like:\n\n<pre>parser.add_regexp_handling(/\\b([A-Z][a-z]+[A-Z]\\w+)/, ...</pre>\n"],["add_remote","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-add_remote","(source)",""],["add_require","RDoc::Context","RDoc/Context.html#method-i-add_require","(require)","<p>Adds <code>require</code> to this context&#39;s top level\n"],["add_response_handler","Net::IMAP","Net/IMAP.html#method-i-add_response_handler","(handler = nil, &block)","<p>Adds a response handler. For example, to detect when the server sends a new EXISTS response (which normally …\n"],["add_revoked","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-add_revoked","(p1)",""],["add_row","CSV","CSV.html#method-i-add_row","(row)",""],["add_rubygems_remote","Bundler::SourceList","Bundler/SourceList.html#method-i-add_rubygems_remote","(uri)",""],["add_rubygems_source","Bundler::Plugin::SourceList","Bundler/Plugin/SourceList.html#method-i-add_rubygems_source","(options = {})",""],["add_rubygems_source","Bundler::SourceList","Bundler/SourceList.html#method-i-add_rubygems_source","(options = {})",""],["add_rule","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-add_rule","(target, list, sprec)",""],["add_rule_block","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-add_rule_block","(list)",""],["add_runtime_dependency","Gem::Specification","Gem/Specification.html#method-i-add_runtime_dependency","(gem, *requirements)","<p>Adds a runtime dependency named <code>gem</code> with <code>requirements</code> to this gem.\n<p>Usage:\n\n<pre>spec.add_runtime_dependency &#39;example&#39;, ...</pre>\n"],["add_runtime_options!","Bundler::Thor::Actions::ClassMethods","Bundler/Thor/Actions/ClassMethods.html#method-i-add_runtime_options-21","()","<p>Add runtime options that help actions execution.\n"],["add_section","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-add_section","(name, value)",""],["add_section","RDoc::Context","RDoc/Context.html#method-i-add_section","(title, comment = nil)","<p>Returns a section with <code>title</code>, creating it if it doesn&#39;t already exist. <code>comment</code> will be appended to …\n"],["add_security_option","Gem::SecurityOption","Gem/SecurityOption.html#method-i-add_security_option","()",""],["add_self_to_load_path","Gem::Specification","Gem/Specification.html#method-i-add_self_to_load_path","()","<p>Adds this spec&#39;s require paths to LOAD_PATH, in the proper location.\n"],["add_signer","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-add_signer","(p1)",""],["add_source","Bundler::Index","Bundler/Index.html#method-i-add_source","(index)",""],["add_source","Bundler::Plugin","Bundler/Plugin.html#method-i-add_source","(source, cls)","<p>To be called via the API to register to handle a source plugin\n"],["add_source_gem","Gem::Resolver::SourceSet","Gem/Resolver/SourceSet.html#method-i-add_source_gem","(name, source)",""],["add_source_option","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-add_source_option","()","<p>Add the –source option\n"],["add_source_to_list","Bundler::SourceList","Bundler/SourceList.html#method-i-add_source_to_list","(source, list)",""],["add_sources","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-add_sources","()",""],["add_specific_extra_args","Gem::Command","Gem/Command.html#method-c-add_specific_extra_args","(cmd,args)","<p>Add a list of extra arguments for the given command.  <code>args</code> may be an array or a string to be split on …\n"],["add_specs","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-add_specs","(specs)",""],["add_start_rule","Racc::Grammar","Racc/Grammar.html#method-i-add_start_rule","()",""],["add_status","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-add_status","(p1, p2, p3, p4, p5, p6, p7)","<p>Adds a certificate status for <em>certificate_id</em>. <em>status</em> is the status, and must be one of these:\n<p>OpenSSL::OCSP::V_CERTSTATUS_GOOD …\n"],["add_stress_to_class","GC","GC.html#method-c-add_stress_to_class","(*args)","<p>Raises NoMemoryError when allocating an instance of the given classes.\n"],["add_symlink","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-add_symlink","(name, target, mode)","<p>Adds symlink <code>name</code> with permissions <code>mode</code>, linking to <code>target</code>.\n"],["add_text","REXML::Element","REXML/Element.html#method-i-add_text","( text )","<p>A helper method to add a Text child.  Actual Text instances can be added with regular Parent methods, …\n"],["add_to","RDoc::Context","RDoc/Context.html#method-i-add_to","(array, thing)","<p>Adds <code>thing</code> to the collection <code>array</code>\n"],["add_to_classes_or_modules","RDoc::TopLevel","RDoc/TopLevel.html#method-i-add_to_classes_or_modules","(mod)","<p>Adds class or module <code>mod</code>. Used in the building phase by the Ruby parser.\n"],["add_to_element_method","RSS::Element","RSS/Element.html#method-c-add_to_element_method","(method_name)",""],["add_to_fetcher","Gem::TestCase","Gem/TestCase.html#method-i-add_to_fetcher","(spec, path=nil, repo=@gem_repo)","<p>Add <code>spec</code> to +@fetcher+ serving the data in the file <code>path</code>. <code>repo</code> indicates which repo to make <code>spec</code> appear …\n"],["add_to_history?","Bundler::Thor::LineEditor::Readline","Bundler/Thor/LineEditor/Readline.html#method-i-add_to_history-3F","()",""],["add_to_load_path","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-add_to_load_path","(paths)",""],["add_to_load_path","Gem","Gem.html#method-c-add_to_load_path","(*paths)","<p>Add a list of paths to the $LOAD_PATH at the proper place.\n"],["add_token","RDoc::TokenStream","RDoc/TokenStream.html#method-i-add_token","(token)","<p>Adds one <code>token</code> to the collected tokens\n"],["add_token_listener","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-add_token_listener","(obj)","<p>Adds a token listener <code>obj</code>, but you should probably use token_listener\n"],["add_tokens","RDoc::TokenStream","RDoc/TokenStream.html#method-i-add_tokens","(tokens)","<p>Adds <code>tokens</code> to the collected tokens\n"],["add_trace_func","Thread","Thread.html#method-i-add_trace_func","(p1)","<p>Adds <em>proc</em> as a handler for tracing.\n<p>See Thread#set_trace_func and Kernel#set_trace_func.\n"],["add_unconverted_fields","CSV::Parser","CSV/Parser.html#method-i-add_unconverted_fields","(row, fields)","<p>This method injects an instance variable <code>unconverted_fields</code> into <code>row</code> and an accessor method for <code>row</code> called …\n"],["add_update_sources_option","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-add_update_sources_option","()","<p>Add the –update-sources option\n"],["add_user_code","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-add_user_code","(label, src)",""],["add_value","OpenSSL::Config","OpenSSL/Config.html#method-i-add_value","(section, key, value)","<p>Set the target <em>key</em> with a given <em>value</em> under a specific <em>section</em>.\n<p>Given the following configurating file …\n"],["add_version_option","Gem::VersionOption","Gem/VersionOption.html#method-i-add_version_option","(task = command, *wrap)","<p>Add the –version option to the option parser.\n"],["add_vertex","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-add_vertex","(name, payload, root = false)","<p>Adds a vertex with the given name, or updates the existing one. @param [String] name @param [Object] …\n"],["add_vertex","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-add_vertex","(graph, name, payload, root)","<p>@macro action\n"],["add_vertex","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-add_vertex","(name, payload, root = false)","<p>Adds a vertex with the given name, or updates the existing one. @param [String] name @param [Object] …\n"],["add_vertex","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-add_vertex","(graph, name, payload, root)","<p>@macro action\n"],["add_word_pair","RDoc::Markup","RDoc/Markup.html#method-i-add_word_pair","(start, stop, name)","<p>Add to the sequences used to add formatting to an individual word (such as <strong>bold</strong>).  Matching entries will …\n"],["added?","Racc::Grammar","Racc/Grammar.html#method-i-added-3F","(sym)",""],["addent","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-addent","(all, arr, chkval, ptr)",""],["additional_base_requirements_for_resolve","Bundler::Definition","Bundler/Definition.html#method-i-additional_base_requirements_for_resolve","()",""],["additional_message","OptionParser","OptionParser.html#method-i-additional_message","(typ, opt)","<p>Returns additional info.\n"],["addr","IPSocket","IPSocket.html#method-i-addr","(*args)","<p>Returns the local address as an array which contains address_family, port, hostname and numeric_address. …\n"],["addr","OpenSSL::SSL::SocketForwarder","OpenSSL/SSL/SocketForwarder.html#method-i-addr","()",""],["addr","Socket::Ifaddr","Socket/Ifaddr.html#method-i-addr","()","<p>Returns the address of <em>ifaddr</em>. nil is returned if address is not available in <em>ifaddr</em>.\n"],["addr","UNIXSocket","UNIXSocket.html#method-i-addr","()","<p>Returns the local address as an array which contains address_family and unix_path.\n<p>Example\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">serv</span> = <span class=\"ruby-constant\">UNIXServer</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["addr_mask","IPAddr","IPAddr.html#method-i-addr_mask","(addr)",""],["addr_port","Net::HTTP","Net/HTTP.html#method-i-addr_port","()","<p>utils\n"],["addrel","Racc::States","Racc/States.html#method-i-addrel","(tbl, i, item)",""],["addsym","Racc::States","Racc/States.html#method-i-addsym","(table, sym, ptr)",""],["adjugate","Matrix","Matrix.html#method-i-adjugate","()","<p>Returns the adjugate of the matrix.\n\n<pre>Matrix[ [7,6],[3,9] ].adjugate\n  =&gt; 9 -6\n     -3 7</pre>\n"],["adjust_headers","CSV::Parser","CSV/Parser.html#method-i-adjust_headers","(headers)",""],["adler","Zlib::ZStream","Zlib/ZStream.html#method-i-adler","()","<p>Returns the adler-32 checksum.\n"],["adler32","Zlib","Zlib.html#method-c-adler32","(*args)","<p>Calculates Adler-32 checksum for <code>string</code>, and returns updated value of <code>adler</code>. If <code>string</code> is omitted, it …\n"],["adler32_combine","Zlib","Zlib.html#method-c-adler32_combine","(p1, p2, p3)","<p>Combine two Adler-32 check values in to one.  <code>alder1</code> is the first Adler-32 value, <code>adler2</code> is the second …\n"],["advise","IO","IO.html#method-i-advise","(p1, p2 = v2, p3 = v3)","<p>Announce an intention to access data from the current file in a specific pattern. On platforms that do …\n"],["afamily","Addrinfo","Addrinfo.html#method-i-afamily","()","<p>returns the address family as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">afamily</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AF_INET</span> <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["after_resolution","Bundler::Molinillo::UI","Bundler/Molinillo/UI.html#method-i-after_resolution","()","<p>Called after resolution ends (either successfully or with an error). By default, prints a newline.\n<p>@return …\n"],["after_resolution","Bundler::Resolver","Bundler/Resolver.html#method-i-after_resolution","()",""],["after_resolution","Gem::Resolver::Molinillo::UI","Gem/Resolver/Molinillo/UI.html#method-i-after_resolution","()","<p>Called after resolution ends (either successfully or with an error). By default, prints a newline.\n<p>@return …\n"],["ajd","Date","Date.html#method-i-ajd","()","<p>Returns the astronomical Julian day number.  This is a fractional number, which is not adjusted by the …\n"],["alert","Gem::StreamUI","Gem/StreamUI.html#method-i-alert","(statement, question=nil)","<p>Display an informational alert.  Will ask <code>question</code> if it is not nil.\n"],["alert","Gem::UserInteraction","Gem/UserInteraction.html#method-i-alert","(statement, question = nil)","<p>Displays an alert <code>statement</code>.  Asks a <code>question</code> if given.\n"],["alert_error","Gem::StreamUI","Gem/StreamUI.html#method-i-alert_error","(statement, question=nil)","<p>Display an error message in a location expected to get error messages. Will ask <code>question</code> if it is not …\n"],["alert_error","Gem::UserInteraction","Gem/UserInteraction.html#method-i-alert_error","(statement, question = nil)","<p>Displays an error <code>statement</code> to the error output location.  Asks a <code>question</code> if given.\n"],["alert_warning","Gem::StreamUI","Gem/StreamUI.html#method-i-alert_warning","(statement, question=nil)","<p>Display a warning on stderr.  Will ask <code>question</code> if it is not nil.\n"],["alert_warning","Gem::UserInteraction","Gem/UserInteraction.html#method-i-alert_warning","(statement, question = nil)","<p>Displays a warning <code>statement</code> to the warning output location.  Asks a <code>question</code> if given.\n"],["alias","Psych::Emitter","Psych/Emitter.html#method-i-alias","(p1)","<p>Emit an alias with <code>anchor</code>.\n<p>See Psych::Handler#alias\n"],["alias","Psych::Handler","Psych/Handler.html#method-i-alias","(anchor)","<p>Called when an alias is found to <code>anchor</code>.  <code>anchor</code> will be the name of the anchor found.\n<p>Example\n<p>Here we …\n"],["alias","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-alias","(anchor)",""],["alias?","Psych::Nodes::Alias","Psych/Nodes/Alias.html#method-i-alias-3F","()",""],["alias?","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-alias-3F","()",""],["alias_extension","RDoc::Parser","RDoc/Parser.html#method-c-alias_extension","(old_ext, new_ext)","<p>Alias an extension to another extension. After this call, files ending “new_ext” will be parsed …\n"],["alias_method","Module","Module.html#method-i-alias_method","(p1, p2)","<p>Makes <em>new_name</em> a new copy of the method <em>old_name</em>. This can be used to retain access to methods that are …\n"],["aliases","Encoding","Encoding.html#method-c-aliases","()","<p>Returns the hash of available encoding alias and original encoding name.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span>.<span class=\"ruby-identifier\">aliases</span>\n<span class=\"ruby-comment\">#=&gt; {&quot;BINARY&quot;=&gt;&quot;ASCII-8BIT&quot;, ...</span>\n</pre>\n"],["aliases_for","Bundler::CLI","Bundler/CLI.html#method-c-aliases_for","(command_name)",""],["alien","Gem::Validator","Gem/Validator.html#method-i-alien","(gems=[])","<p>Checks the gem directory for the following potential inconsistencies/problems:\n<p>Checksum gem itself\n<p>For …\n"],["alive?","DRb::DRbServer","DRb/DRbServer.html#method-i-alive-3F","()","<p>Is this server alive?\n"],["alive?","DRb::ExtServ","DRb/ExtServ.html#method-i-alive-3F","()",""],["alive?","DRb::ThreadObject","DRb/ThreadObject.html#method-i-alive-3F","()",""],["alive?","Fiber","Fiber.html#method-i-alive-3F","()","<p>Returns true if the fiber can still be resumed (or transferred to). After finishing execution of the …\n"],["alive?","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-alive-3F","()","<p>A TupleEntry is dead when it is canceled or expired.\n"],["alive?","Thread","Thread.html#method-i-alive-3F","()","<p>Returns <code>true</code> if <code>thr</code> is running or sleeping.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">thr</span> = <span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">new</span> { }\n<span class=\"ruby-identifier\">thr</span>.<span class=\"ruby-identifier\">join</span>                <span class=\"ruby-comment\">#=&gt; #&lt;Thread:0x401b3fb0 ...</span>\n</pre>\n"],["all","Bundler::Settings","Bundler/Settings.html#method-i-all","()",""],["all","Gem::Specification","Gem/Specification.html#method-c-all","()","<p>Returns all specifications. This method is discouraged from use. You probably want to use one of the …\n"],["all","Net::POPMail","Net/POPMail.html#method-i-all","( dest = +'' )",""],["all=","Gem::Specification","Gem/Specification.html#method-c-all-3D","(specs)","<p>Sets the known specs to <code>specs</code>. Not guaranteed to work for you in the future. Use at your own risk. Caveat …\n"],["all?","Array","Array.html#method-i-all-3F","(*args)","<p>See also Enumerable#all?\n"],["all?","Bundler::Settings::MirrorConfig","Bundler/Settings/MirrorConfig.html#method-i-all-3F","()",""],["all?","Enumerable","Enumerable.html#method-i-all-3F","(*args)","<p>Passes each element of the collection to the given block. The method returns <code>true</code> if the block never …\n"],["all_aliases","Bundler::CLI","Bundler/CLI.html#method-c-all_aliases","()",""],["all_classes","RDoc::Store","RDoc/Store.html#method-i-all_classes","()","<p>Returns all classes discovered by RDoc\n"],["all_classes_and_modules","RDoc::Store","RDoc/Store.html#method-i-all_classes_and_modules","()","<p>Returns all classes and modules discovered by RDoc\n"],["all_commands","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-all_commands","()","<p>Returns the commands for this Bundler::Thor class and all subclasses.\n<p>Returns\n<p>Hash &mdash; An ordered hash with …\n"],["all_dependencies","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-all_dependencies","()","<p>Represents all dependencies\n"],["all_errors","Bundler::BundlerError","Bundler/BundlerError.html#method-c-all_errors","()",""],["all_files","RDoc::Store","RDoc/Store.html#method-i-all_files","()","<p>All TopLevels known to RDoc\n"],["all_modules","RDoc::Store","RDoc/Store.html#method-i-all_modules","()","<p>Returns all modules discovered by RDoc\n"],["all_names","Gem::Specification","Gem/Specification.html#method-c-all_names","()","<p>Return full names of all specs in sorted order.\n"],["all_requirements","Bundler::Molinillo::Resolver::Resolution::UnwindDetails","Bundler/Molinillo/Resolver/Resolution/UnwindDetails.html#method-i-all_requirements","()","<p>@return [Array] array of all the requirements that led to the need for\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">this</span> <span class=\"ruby-identifier\">unwind</span>\n</pre>\n"],["all_sources","Bundler::Plugin::SourceList","Bundler/Plugin/SourceList.html#method-i-all_sources","()",""],["all_sources","Bundler::SourceList","Bundler/SourceList.html#method-i-all_sources","()",""],["all_spec_names","Gem::TestCase","Gem/TestCase.html#method-i-all_spec_names","()",""],["all_specs","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-all_specs","()",""],["all_specs","Gem::AvailableSet","Gem/AvailableSet.html#method-i-all_specs","()",""],["all_symbols","Symbol","Symbol.html#method-c-all_symbols","()","<p>Returns an array of all the symbols currently in Ruby&#39;s symbol table.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Symbol</span>.<span class=\"ruby-identifier\">all_symbols</span>.<span class=\"ruby-identifier\">size</span>    <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["all_tasks","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-all_tasks","()",""],["allbits?","Integer","Integer.html#method-i-allbits-3F","(p1)","<p>Returns <code>true</code> if all bits of <code>int &amp; mask</code> are 1.\n"],["allocate","Class","Class.html#method-i-allocate","()","<p>Allocates space for a new object of <em>class</em>&#39;s class and does not call initialize on the new instance. …\n"],["allocation_class_path","ObjectSpace","ObjectSpace.html#method-c-allocation_class_path","(p1)","<p>Returns the class for the given <code>object</code>.\n\n<pre>class A\n  def foo\n    ObjectSpace::trace_object_allocations do ...</pre>\n"],["allocation_generation","ObjectSpace","ObjectSpace.html#method-c-allocation_generation","(p1)","<p>Returns garbage collector generation for the given <code>object</code>.\n\n<pre>class B\n  include ObjectSpace\n\n  def foo\n  ...</pre>\n"],["allocation_method_id","ObjectSpace","ObjectSpace.html#method-c-allocation_method_id","(p1)","<p>Returns the method identifier for the given <code>object</code>.\n\n<pre>class A\n  include ObjectSpace\n\n  def foo\n    trace_object_allocations ...</pre>\n"],["allocation_sourcefile","ObjectSpace","ObjectSpace.html#method-c-allocation_sourcefile","(p1)","<p>Returns the source file origin from the given <code>object</code>.\n<p>See ::trace_object_allocations for more information …\n"],["allocation_sourceline","ObjectSpace","ObjectSpace.html#method-c-allocation_sourceline","(p1)","<p>Returns the original line from source for from the given <code>object</code>.\n<p>See ::trace_object_allocations for more …\n"],["allow?","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-allow-3F","()",""],["allow_addr?","ACL","ACL.html#method-i-allow_addr-3F","(addr)","<p>Allow connections from addrinfo <code>addr</code>?  It must be formatted like Socket#peeraddr:\n\n<pre>[&quot;AF_INET&quot;, 10, &quot;lc630&quot;, ...</pre>\n"],["allow_git_ops?","Bundler::Source::Git","Bundler/Source/Git.html#method-i-allow_git_ops-3F","()",""],["allow_incompatible_default_type!","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-allow_incompatible_default_type-21","()","<p>If you want to use defaults that don&#39;t match the type of an option, either specify `check_default_type: …\n"],["allow_missing?","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-allow_missing-3F","(dependency)","<p>(see Bundler::Molinillo::SpecificationProvider#allow_missing?)\n"],["allow_missing?","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-allow_missing-3F","(dependency)","<p>Returns whether this dependency, which has no possible matching specifications, can safely be ignored. …\n"],["allow_missing?","Gem::Resolver","Gem/Resolver.html#method-i-allow_missing-3F","(dependency)",""],["allow_missing?","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-allow_missing-3F","(dependency)","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#allow_missing?)\n"],["allow_missing?","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-allow_missing-3F","(dependency)","<p>Returns whether this dependency, which has no possible matching specifications, can safely be ignored. …\n"],["allow_nan?","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-allow_nan-3F","()","<p>Returns true, if NaN, Infinity, and -Infinity should be generated, otherwise returns false.\n"],["allow_socket?","ACL","ACL.html#method-i-allow_socket-3F","(soc)","<p>Allow connections from Socket <code>soc</code>?\n"],["allow_sudo?","Bundler::Settings","Bundler/Settings.html#method-i-allow_sudo-3F","()",""],["allowed_in_path","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-allowed_in_path","()",""],["allowed_push_host","Bundler::GemHelper","Bundler/GemHelper.html#method-i-allowed_push_host","()",""],["alphanumeric","Random::Formatter","Random/Formatter.html#method-i-alphanumeric","(n=nil)","<p>SecureRandom.alphanumeric generates a random alphanumeric string.\n<p>The argument <em>n</em> specifies the length, …\n"],["alpn_protocol","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-alpn_protocol","()","<p>Returns the ALPN protocol string that was finally selected by the server during the handshake.\n"],["already_tagged?","Bundler::GemHelper","Bundler/GemHelper.html#method-i-already_tagged-3F","()",""],["alt_name_or_x509_entry","Gem::Security","Gem/Security.html#method-c-alt_name_or_x509_entry","(certificate, x509_entry)",""],["alternate=","RSS::XMLStyleSheet","RSS/XMLStyleSheet.html#method-i-alternate-3D","(value)",""],["amjd","Date","Date.html#method-i-amjd","()","<p>Returns the astronomical modified Julian day number.  This is a fractional number, which is not adjusted …\n"],["amount_constrained","Bundler::Resolver","Bundler/Resolver.html#method-i-amount_constrained","(dependency)","<p>returns an integer in (-infty, 0] a number closer to 0 means the dependency is less constraining\n<p>dependencies …\n"],["amount_constrained","Gem::Resolver","Gem/Resolver.html#method-i-amount_constrained","(dependency)","<p>returns an integer in (-infty, 0] a number closer to 0 means the dependency is less constraining\n<p>dependencies …\n"],["ancestor?","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-ancestor-3F","(other)","<p>Is there a path from `other` to `self` following edges in the dependency graph? @return true iff there …\n"],["ancestor?","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-ancestor-3F","(other)","<p>Is there a path from `other` to `self` following edges in the dependency graph? @return true iff there …\n"],["ancestors","Module","Module.html#method-i-ancestors","()","<p>Returns a list of modules included/prepended in <em>mod</em> (including <em>mod</em> itself).\n\n<pre>module Mod\n  include Math ...</pre>\n"],["ancestors","RDoc::ClassModule","RDoc/ClassModule.html#method-i-ancestors","()","<p>Ancestors list for this ClassModule: the list of included modules (classes will add their superclass …\n"],["ancestors","RDoc::NormalClass","RDoc/NormalClass.html#method-i-ancestors","()","<p>The ancestors of this class including modules.  Unlike Module#ancestors, this class is not included in …\n"],["ancestors","RDoc::SingleClass","RDoc/SingleClass.html#method-i-ancestors","()","<p>Adds the superclass to the included modules.\n"],["ancestors","RDoc::Store","RDoc/Store.html#method-i-ancestors","()","<p>Ancestors cache accessor.  Maps a klass name to an Array of its ancestors in this store.  If Foo in this …\n"],["angle","Complex","Complex.html#method-i-angle","()","<p>Returns the angle part of its polar form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>.<span class=\"ruby-identifier\">polar</span>(<span class=\"ruby-value\">3</span>, <span class=\"ruby-constant\">Math</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">PI</span><span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">arg</span>  <span class=\"ruby-comment\">#=&gt; 1.5707963267948966</span>\n</pre>\n"],["angle","Float","Float.html#method-i-angle","()","<p>Returns 0 if the value is positive, pi otherwise.\n"],["angle","Numeric","Numeric.html#method-i-angle","()","<p>Returns 0 if the value is positive, pi otherwise.\n"],["angle_with","Vector","Vector.html#method-i-angle_with","(v)","<p>Returns an angle with another vector. Result is within the [0..Math::PI].\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">0</span>].<span class=\"ruby-identifier\">angle_with</span>(<span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">0</span>,<span class=\"ruby-value\">1</span>]) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["answer_match","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-answer_match","(possibilities, answer, case_insensitive)",""],["antisymmetric?","Matrix","Matrix.html#method-i-antisymmetric-3F","()","<p>Returns <code>true</code> if this is an antisymmetric matrix. Raises an error if matrix is not square.\n"],["any?","Array","Array.html#method-i-any-3F","(*args)","<p>See also Enumerable#any?\n"],["any?","Bundler::MirrorSockets","Bundler/MirrorSockets.html#method-i-any-3F","()",""],["any?","Enumerable","Enumerable.html#method-i-any-3F","(*args)","<p>Passes each element of the collection to the given block. The method returns <code>true</code> if the block ever returns …\n"],["any?","Hash","Hash.html#method-i-any-3F","(*args)","<p>See also Enumerable#any?\n"],["any?","Racc::DebugFlags","Racc/DebugFlags.html#method-i-any-3F","()",""],["any_content","RDoc::Context","RDoc/Context.html#method-i-any_content","(includes = true)","<p>Is there any content?\n<p>This means any of: comment, aliases, methods, attributes, external aliases, require, …\n"],["any_to_s","DRb::DRbServer","DRb/DRbServer.html#method-i-any_to_s","(obj)","<p>Coerce an object to a string, providing our own representation if to_s is not defined for the object. …\n"],["anybits?","Integer","Integer.html#method-i-anybits-3F","(p1)","<p>Returns <code>true</code> if any bits of <code>int &amp; mask</code> are 1.\n"],["api_fetcher?","Bundler::Fetcher::Base","Bundler/Fetcher/Base.html#method-i-api_fetcher-3F","()",""],["api_fetcher?","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-api_fetcher-3F","()",""],["api_fetcher?","Bundler::Fetcher::Dependency","Bundler/Fetcher/Dependency.html#method-i-api_fetcher-3F","()",""],["api_fetchers","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-api_fetchers","()",""],["api_key","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-api_key","()","<p>The API key from the command options or from the user&#39;s configuration.\n"],["api_keys","Gem::ConfigFile","Gem/ConfigFile.html#method-i-api_keys","()","<p>Hash of RubyGems.org and alternate API keys\n"],["apop?","Net::APOP","Net/APOP.html#method-i-apop-3F","()","<p>Always returns true.\n"],["apop?","Net::APOP","Net/APOP.html#method-i-apop-3F","()","<p>Always returns true.\n"],["apop?","Net::POP3","Net/POP3.html#method-i-apop-3F","()","<p>Does this instance use APOP authentication?\n"],["app_cache","Bundler","Bundler.html#method-c-app_cache","(custom_path = nil)",""],["app_cache_dirname","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-app_cache_dirname","()","<p>Name of directory where plugin the is expected to cache the gems when #cache is called.\n<p>Also this name …\n"],["app_cache_dirname","Bundler::Source::Git","Bundler/Source/Git.html#method-i-app_cache_dirname","()",""],["app_cache_dirname","Bundler::Source::Path","Bundler/Source/Path.html#method-i-app_cache_dirname","()",""],["app_cache_path","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-app_cache_path","(custom_path = nil)","<p>The full path where the plugin should cache the gem so that it can be installed latter.\n<p>Note: Do not override …\n"],["app_cache_path","Bundler::Settings","Bundler/Settings.html#method-i-app_cache_path","()",""],["app_cache_path","Bundler::Source::Path","Bundler/Source/Path.html#method-i-app_cache_path","(custom_path = nil)",""],["app_config_path","Bundler","Bundler.html#method-c-app_config_path","()",""],["app_script_text","Gem::Installer","Gem/Installer.html#method-i-app_script_text","(bin_file_name)","<p>Return the text for an application file.\n"],["append","Array","Array.html#method-i-append","(*args)",""],["append","Net::IMAP","Net/IMAP.html#method-i-append","(mailbox, message, flags = nil, date_time = nil)","<p>Sends a APPEND command to append the <code>message</code> to the end of the <code>mailbox</code>. The optional <code>flags</code> argument is …\n"],["append","OptionParser::List","OptionParser/List.html#method-i-append","(*args)","<p>Appends <code>switch</code> at the tail of the list, and associates short, long and negated long options. Arguments …\n"],["append_data","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-i-append_data","(data)","<p>Adds <code>data</code> at the end of the chain of entries\n<p>This is called by WEBrick::HTTPUtils.parse_form_data for …\n"],["append_features","Module","Module.html#method-i-append_features","(p1)","<p>When this module is included in another, Ruby calls #append_features in this module, passing it the receiving …\n"],["append_features","RSS::Atom::CommonModel","RSS/Atom/CommonModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Atom::ContentModel","RSS/Atom/ContentModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Atom::DateConstruct","RSS/Atom/DateConstruct.html#method-c-append_features","(klass)",""],["append_features","RSS::Atom::PersonConstruct","RSS/Atom/PersonConstruct.html#method-c-append_features","(klass)","<p>Adds attributes for name, uri, and email to the <code>klass</code>\n"],["append_features","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-c-append_features","(klass)",""],["append_features","RSS::Atom::URIContentModel","RSS/Atom/URIContentModel.html#method-c-append_features","(klass)",""],["append_features","RSS::BaseDublinCoreModel","RSS/BaseDublinCoreModel.html#method-i-append_features","(klass)",""],["append_features","RSS::ContentModel","RSS/ContentModel.html#method-c-append_features","(klass)",""],["append_features","RSS::ITunesChannelModel","RSS/ITunesChannelModel.html#method-c-append_features","(klass)",""],["append_features","RSS::ITunesItemModel","RSS/ITunesItemModel.html#method-c-append_features","(klass)",""],["append_features","RSS::ImageFaviconModel","RSS/ImageFaviconModel.html#method-c-append_features","(klass)",""],["append_features","RSS::ImageItemModel","RSS/ImageItemModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::AtomPersonConstructBase","RSS/Maker/AtomPersonConstructBase.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::AtomTextConstructBase","RSS/Maker/AtomTextConstructBase.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::ContentModel","RSS/Maker/ContentModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::DublinCoreModel","RSS/Maker/DublinCoreModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::ITunesChannelModel","RSS/Maker/ITunesChannelModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::ITunesItemModel","RSS/Maker/ITunesItemModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::ImageFaviconModel","RSS/Maker/ImageFaviconModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::ImageItemModel","RSS/Maker/ImageItemModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::SlashModel","RSS/Maker/SlashModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::SyndicationModel","RSS/Maker/SyndicationModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::TaxonomyTopicModel","RSS/Maker/TaxonomyTopicModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::TaxonomyTopicsModel","RSS/Maker/TaxonomyTopicsModel.html#method-c-append_features","(klass)",""],["append_features","RSS::Maker::TrackBackModel","RSS/Maker/TrackBackModel.html#method-c-append_features","(klass)",""],["append_features","RSS::RSS09","RSS/RSS09.html#method-c-append_features","(klass)",""],["append_features","RSS::RSS10","RSS/RSS10.html#method-c-append_features","(klass)",""],["append_features","RSS::SlashModel","RSS/SlashModel.html#method-c-append_features","(klass)",""],["append_features","RSS::SyndicationModel","RSS/SyndicationModel.html#method-c-append_features","(klass)",""],["append_features","RSS::TaxonomyTopicModel","RSS/TaxonomyTopicModel.html#method-c-append_features","(klass)",""],["append_features","RSS::TaxonomyTopicsModel","RSS/TaxonomyTopicsModel.html#method-c-append_features","(klass)",""],["append_features","Singleton","Singleton.html#method-c-append_features","(mod)",""],["append_field_value","Net::HTTPHeader","Net/HTTPHeader.html#method-i-append_field_value","(ary, val)",""],["append_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-append_file","(path, *args, &block)",""],["append_formatted_table","Bundler::Env","Bundler/Env.html#method-c-append_formatted_table","(title, pairs, out)",""],["append_to","Bundler::Injector","Bundler/Injector.html#method-i-append_to","(gemfile_path, new_gem_lines)",""],["append_to_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-append_to_file","(path, *args, &block)","<p>Append text to a file. Since it depends on insert_into_file, it&#39;s reversible.\n<p>Parameters\n<p>path&lt;String&gt; … &mdash; "],["appendable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-appendable-3F","()","<p>Returns <code>true</code> if the APPE command may be applied to the file.\n"],["apply","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-apply","(path, config = {})","<p>Loads an external file and execute it in the instance binding.\n<p>Parameters\n<p>path&lt;String&gt; &mdash; The path to …\n"],["apply_auth","Bundler::Source::Rubygems::Remote","Bundler/Source/Rubygems/Remote.html#method-i-apply_auth","(uri, auth)",""],["apply_func","Bundler::Worker","Bundler/Worker.html#method-i-apply_func","(obj, i)",""],["apply_offset","Time","Time.html#method-c-apply_offset","(year, mon, day, hour, min, sec, off)",""],["approximate_recommendation","Gem::Version","Gem/Version.html#method-i-approximate_recommendation","()","<p>A recommended version for use with a ~&gt; Requirement.\n"],["are_colors_disabled?","Bundler::Thor::Shell::Color","Bundler/Thor/Shell/Color.html#method-i-are_colors_disabled-3F","()",""],["aref","RDoc::Alias","RDoc/Alias.html#method-i-aref","()","<p>HTML fragment reference for this alias\n"],["aref","RDoc::ClassModule","RDoc/ClassModule.html#method-i-aref","()","<p>HTML fragment reference for this module or class.  See RDoc::NormalClass#aref and RDoc::NormalModule#aref …\n"],["aref","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-aref","()","<p>HTML fragment reference for this method\n"],["aref_prefix","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-aref_prefix","()","<p>Prefix for <code>aref</code> is &#39;method&#39;.\n"],["aref_prefix","RDoc::Attr","RDoc/Attr.html#method-i-aref_prefix","()","<p>The #aref prefix for attributes\n"],["aref_prefix","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-aref_prefix","()","<p>Prefix for <code>aref</code>, defined by subclasses.\n"],["arg","Complex","Complex.html#method-i-arg","()","<p>Returns the angle part of its polar form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>.<span class=\"ruby-identifier\">polar</span>(<span class=\"ruby-value\">3</span>, <span class=\"ruby-constant\">Math</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">PI</span><span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">arg</span>  <span class=\"ruby-comment\">#=&gt; 1.5707963267948966</span>\n</pre>\n"],["arg","Float","Float.html#method-i-arg","()","<p>Returns 0 if the value is positive, pi otherwise.\n"],["arg","Numeric","Numeric.html#method-i-arg","()","<p>Returns 0 if the value is positive, pi otherwise.\n"],["arglists","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-arglists","()","<p>The call_seq or the param_seq with method name, if there is no call_seq.\n<p>Use this for displaying a method&#39;s …\n"],["args","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-args","()",""],["args","NoMethodError","NoMethodError.html#method-i-args","()","<p>Return the arguments passed in as the third parameter to the constructor.\n"],["argument","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-argument","(name, options = {})","<p>Adds an argument to the class and creates an attr_accessor for it.\n<p>Arguments are different from options …\n"],["arguments","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-arguments","()","<p>Returns this class arguments, looking up in the ancestors chain.\n<p>Returns\n<p>Array\n"],["arguments","Gem::Command","Gem/Command.html#method-i-arguments","()","<p>Override to provide details of the arguments a command takes.  It should return a left-justified string, …\n"],["argv","ARGF","ARGF.html#method-i-argv","()","<p>Returns the <code>ARGV</code> array, which contains the arguments passed to your script, one per element.\n<p>For example: …\n"],["argv0","Process","Process.html#method-c-argv0","()","<p>Returns the name of the script being executed.  The value is not affected by assigning a new value to …\n"],["arity","Method","Method.html#method-i-arity","()","<p>Returns an indication of the number of arguments accepted by a method. Returns a nonnegative integer …\n"],["arity","Proc","Proc.html#method-i-arity","()","<p>Returns the number of mandatory arguments. If the block is declared to take no arguments, returns 0. …\n"],["arity","UnboundMethod","UnboundMethod.html#method-i-arity","()","<p>Returns an indication of the number of arguments accepted by a method. Returns a nonnegative integer …\n"],["array","WIN32OLE_VARIANT","WIN32OLE_VARIANT.html#method-c-array","(p1, p2)","<p>Returns Ruby object wrapping OLE variant whose variant type is VT_ARRAY. The first argument should be …\n"],["array_attributes","Gem::Specification","Gem/Specification.html#method-c-array_attributes","()","<p>Return the list of all array-oriented instance variables.\n"],["array_nl","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-array_nl","()","<p>This string is put at the end of a line that holds a JSON array.\n"],["array_nl=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-array_nl-3D","(p1)","<p>This string is put at the end of a line that holds a JSON array.\n"],["array_to_s","Bundler::Settings","Bundler/Settings.html#method-i-array_to_s","(array)",""],["as_json","BigDecimal","BigDecimal.html#method-i-as_json","(*)","<p>Marshal the object to JSON.\n<p>method used for JSON marshalling support.\n"],["as_json","Complex","Complex.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Date","Date.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","DateTime","DateTime.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Exception","Exception.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","JSON::GenericObject","JSON/GenericObject.html#method-i-as_json","(*)",""],["as_json","OpenStruct","OpenStruct.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Range","Range.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Rational","Rational.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Regexp","Regexp.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Set","Set.html#method-i-as_json","(*)","<p>Marshal the object to JSON.\n<p>method used for JSON marshalling support.\n"],["as_json","Struct","Struct.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Symbol","Symbol.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_json","Time","Time.html#method-i-as_json","(*)","<p>Returns a hash, that will be turned into a JSON object and represent this object.\n"],["as_path_source","Bundler::Source::Gemspec","Bundler/Source/Gemspec.html#method-i-as_path_source","()",""],["as_unicode","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-as_unicode","()",""],["ascend","Pathname","Pathname.html#method-i-ascend","()","<p>Iterates over and yields a new Pathname object for each element in the given path in ascending order. …\n"],["ascii_compatible?","Encoding","Encoding.html#method-i-ascii_compatible-3F","()","<p>Returns whether ASCII-compatible or not.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">UTF_8</span>.<span class=\"ruby-identifier\">ascii_compatible?</span>     <span class=\"ruby-comment\">#=&gt; true</span>\n<span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">UTF_16BE</span>.<span class=\"ruby-identifier\">ascii_compatible?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ascii_only?","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-ascii_only-3F","()","<p>Returns true, if only ASCII characters should be generated. Otherwise returns false.\n"],["ascii_only?","String","String.html#method-i-ascii_only-3F","()","<p>Returns true for a string which has only ASCII characters.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;abc&quot;</span>.<span class=\"ruby-identifier\">force_encoding</span>(<span class=\"ruby-string\">&quot;UTF-8&quot;</span>).<span class=\"ruby-identifier\">ascii_only?</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["asciicompat_encoding","Encoding::Converter","Encoding/Converter.html#method-c-asciicompat_encoding","(p1)","<p>Returns the corresponding ASCII compatible encoding.\n<p>Returns nil if the argument is an ASCII compatible …\n"],["asctime","Date","Date.html#method-i-asctime","()","<p>Returns a string in asctime(3) format (but without “n0” at the end).  This method is equivalent …\n"],["asctime","Time","Time.html#method-i-asctime","()","<p>Returns a canonical string representation of <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>.<span class=\"ruby-identifier\">asctime</span>   <span class=\"ruby-comment\">#=&gt; &quot;Wed Apr  9 08:56:03 2003&quot;</span>\n<span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>.<span class=\"ruby-identifier\">ctime</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["asin","Math","Math.html#method-c-asin","(p1)","<p>Computes the arc sine of <code>x</code>. Returns -PI/2..PI/2.\n<p>Domain: [-1, -1]\n<p>Codomain: [-PI/2, PI/2]\n"],["asinh","Math","Math.html#method-c-asinh","(p1)","<p>Computes the inverse hyperbolic sine of <code>x</code>.\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (-INFINITY, INFINITY …\n"],["ask","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-ask","(statement, *args)","<p>Asks something to the user and receives a response.\n<p>If a default value is specified it will be presented …\n"],["ask","Bundler::Thor::Shell::HTML","Bundler/Thor/Shell/HTML.html#method-i-ask","(statement, color = nil)","<p>Ask something to the user and receives a response.\n<p>Example\n<p>ask(“What is your name?”)\n"],["ask","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-ask","(msg)",""],["ask","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-ask","(message)",""],["ask","Gem::MockGemUi","Gem/MockGemUi.html#method-i-ask","(question)",""],["ask","Gem::StreamUI","Gem/StreamUI.html#method-i-ask","(question)","<p>Ask a question.  Returns an answer if connected to a tty, nil otherwise.\n"],["ask","Gem::UserInteraction","Gem/UserInteraction.html#method-i-ask","(question)","<p>Asks a <code>question</code> and returns the answer.\n"],["ask_and_set","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-ask_and_set","(key, header, message)",""],["ask_and_set_test_framework","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-ask_and_set_test_framework","()",""],["ask_filtered","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-ask_filtered","(statement, color, options)",""],["ask_for_password","Gem::StreamUI","Gem/StreamUI.html#method-i-ask_for_password","(question)","<p>Ask for a password. Does not echo response to terminal.\n"],["ask_for_password","Gem::UserInteraction","Gem/UserInteraction.html#method-i-ask_for_password","(prompt)","<p>Asks for a password with a <code>prompt</code>\n"],["ask_for_spec_from","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-ask_for_spec_from","(specs)",""],["ask_if_ok","Gem::TestCase","Gem/TestCase.html#method-i-ask_if_ok","(spec)",""],["ask_simply","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-ask_simply","(statement, color, options)",""],["ask_yes_no","Gem::StreamUI","Gem/StreamUI.html#method-i-ask_yes_no","(question, default=nil)","<p>Ask a question.  Returns a true for yes, false for no.  If not connected to a tty, raises an exception …\n"],["ask_yes_no","Gem::UserInteraction","Gem/UserInteraction.html#method-i-ask_yes_no","(question, default = nil)","<p>Asks a yes or no <code>question</code>.  Returns true for yes, false for no.\n"],["asn1_flag","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-asn1_flag","()","<p>Returns the flags set on the group.\n<p>See also #asn1_flag=.\n"],["asn1_flag=","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-asn1_flag-3D","(p1)","<p>Sets flags on the group. The flag value is used to determine how to encode the group: encode explicit …\n"],["assert_activate","Gem::TestCase","Gem/TestCase.html#method-i-assert_activate","(expected, *specs)",""],["assert_contains_make_command","Gem::TestCase","Gem/TestCase.html#method-i-assert_contains_make_command","(target, output, msg = nil)",""],["assert_directory_exists","Gem::TestCase","Gem/TestCase.html#method-i-assert_directory_exists","(path, msg = nil)",""],["assert_headers_equal","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-assert_headers_equal","(expected, actual)",""],["assert_path_exists","Gem::TestCase","Gem/TestCase.html#method-i-assert_path_exists","(path, msg = nil)","<p>TODO: move to minitest\n"],["asset","RDoc::Servlet","RDoc/Servlet.html#method-i-asset","(generator_name, req, res)","<p>Serves the asset at the path in <code>req</code> for <code>generator_name</code> via <code>res</code>.\n"],["assign_names","Fiddle::CStructEntity","Fiddle/CStructEntity.html#method-i-assign_names","(members)","<p>Set the names of the <code>members</code> in this C struct\n"],["assignment_expression?","IRB::Irb","IRB/Irb.html#method-i-assignment_expression-3F","(line)",""],["assoc","Array","Array.html#method-i-assoc","(p1)","<p>Searches through an array whose elements are also arrays comparing <code>obj</code> with the first element of each …\n"],["assoc","ENV","ENV.html#method-c-assoc","(p1)","<p>Returns a 2-element Array containing the name and value of the environment variable for <code>name</code> if it exists: …\n"],["assoc","Hash","Hash.html#method-i-assoc","(p1)","<p>Searches through the hash comparing <em>obj</em> with the key using <code>==</code>. Returns the key-value pair (two elements …\n"],["at","Array","Array.html#method-i-at","(p1)","<p>Returns the element at <code>index</code>. A negative index counts from the end of <code>self</code>. Returns <code>nil</code> if the index …\n"],["at","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-c-at","(*args)",""],["at","Gem::Installer","Gem/Installer.html#method-c-at","(path, options = {})","<p>Construct an installer object for the gem file located at <code>path</code>\n"],["at","Time","Time.html#method-c-at","(p1, p2 = v2, p3 = v3, p4 = {})","<p>Creates a new Time object with the value given by <code>time</code>, the given number of <code>seconds_with_frac</code>, or <code>seconds</code> …\n"],["at_exit","Kernel","Kernel.html#method-i-at_exit","()","<p>Converts <em>block</em> to a <code>Proc</code> object (and therefore binds it at the point of call) and registers it for execution …\n"],["atan","BigMath","BigMath.html#method-i-atan","(x, prec)","<p>Computes the arctangent of <code>decimal</code> to the specified number of digits of precision, <code>numeric</code>.\n<p>If <code>decimal</code> …\n"],["atan","Math","Math.html#method-c-atan","(p1)","<p>Computes the arc tangent of <code>x</code>. Returns -PI/2..PI/2.\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (-PI/2, PI/2 …\n"],["atan2","Math","Math.html#method-c-atan2","(p1, p2)","<p>Computes the arc tangent given <code>y</code> and <code>x</code>. Returns a Float in the range -PI..PI. Return value is a angle …\n"],["atanh","Math","Math.html#method-c-atanh","(p1)","<p>Computes the inverse hyperbolic tangent of <code>x</code>.\n<p>Domain: (-1, 1)\n<p>Codomain: (-INFINITY, INFINITY)\n"],["atime","File","File.html#method-i-atime","()","<p>Returns the last access time (a Time object) for <em>file</em>, or epoch if <em>file</em> has not been accessed.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">atime</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["atime","File","File.html#method-c-atime","(p1)","<p>Returns the last access time for the named file as a Time object.\n<p><em>file_name</em> can be an IO object.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">atime</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["atime","File::Stat","File/Stat.html#method-i-atime","()","<p>Returns the last access time for this file as an object of class Time.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">atime</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["atime","Pathname","Pathname.html#method-i-atime","()","<p>Returns the last access time for the file.\n<p>See File.atime.\n"],["atom_symbol","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-atom_symbol","(token)",""],["atom_validate","RSS::Atom::DateConstruct","RSS/Atom/DateConstruct.html#method-i-atom_validate","(ignore_unknown_element, tags, uri)","<p>Raises NotAvailableValueError if element content is nil\n"],["atom_validate","RSS::Atom::Entry","RSS/Atom/Entry.html#method-i-atom_validate","(ignore_unknown_element, tags, uri)",""],["atom_validate","RSS::Atom::Feed","RSS/Atom/Feed.html#method-i-atom_validate","(ignore_unknown_element, tags, uri)",""],["atom_validate","RSS::Atom::Feed::Entry","RSS/Atom/Feed/Entry.html#method-i-atom_validate","(ignore_unknown_element, tags, uri)",""],["atom_validate","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-atom_validate","(ignore_unknown_element, tags, uri)","<p>Raises a MissingAttributeError, NotAvailableValueError, MissingTagError or NotExpectedTagError if the …\n"],["atom_validate","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-i-atom_validate","(ignore_unknown_element, tags, uri)","<p>Raises a MissingTagError or NotExpectedTagError if the element is not properly formatted.\n"],["attempt","Bundler::Retry","Bundler/Retry.html#method-i-attempt","(&block)",""],["attempt_to_activate","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-attempt_to_activate","()","<p>Attempts to activate the current {#possibility} @return [void]\n"],["attempt_to_activate","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-attempt_to_activate","()","<p>Attempts to activate the current {#possibility} @return [void]\n"],["attempt_to_activate_existing_spec","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-attempt_to_activate_existing_spec","(existing_node)","<p>Attempts to activate the current {#possibility} (given that it has already been activated) @return [void] …\n"],["attempt_to_activate_new_spec","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-attempt_to_activate_new_spec","()","<p>Attempts to activate the current {#possibility} (given that it hasn&#39;t already been activated) @return …\n"],["attempt_to_filter_existing_spec","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-attempt_to_filter_existing_spec","(vertex)","<p>Attempts to update the existing vertex&#39;s `PossibilitySet` with a filtered version @return [void] …\n"],["attempt_to_swap_possibility","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-attempt_to_swap_possibility","()","<p>Attempts to swp the current {#possibility} with the already-activated spec with the given name @return …\n"],["attempts","Bundler::Retry","Bundler/Retry.html#method-c-attempts","()",""],["attempts","Bundler::Retry","Bundler/Retry.html#method-i-attempts","(&block)",""],["attlistdecl","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-attlistdecl","(element, pairs, contents)","<p>If a doctype includes an ATTLIST declaration, it will cause this method to be called.  The content is …\n"],["attlistdecl","REXML::StreamListener","REXML/StreamListener.html#method-i-attlistdecl","(element_name, attributes, raw_content)","<p>If a doctype includes an ATTLIST declaration, it will cause this method to be called.  The content is …\n"],["attlistdecl?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-attlistdecl-3F","()","<p>Content: [ String text ]\n"],["attr","Module","Module.html#method-i-attr","(*args)","<p>The first form is equivalent to #attr_reader. The second form is equivalent to <code>attr_accessor(name)</code> but …\n"],["attr_accessor","Module","Module.html#method-i-attr_accessor","(*args)","<p>Defines a named attribute for this module, where the name is <em>symbol.</em><code>id2name</code>, creating an instance variable …\n"],["attr_reader","Module","Module.html#method-i-attr_reader","(*args)","<p>Creates instance variables and corresponding methods that return the value of each instance variable. …\n"],["attr_writer","Module","Module.html#method-i-attr_writer","(*args)","<p>Creates an accessor method to allow assignment to the attribute <em>symbol</em><code>.id2name</code>. String arguments are …\n"],["attribute","REXML::Element","REXML/Element.html#method-i-attribute","( name, namespace=nil )",""],["attribute","REXML::QuickPath","REXML/QuickPath.html#method-c-attribute","( name )",""],["attribute_names","Gem::Specification","Gem/Specification.html#method-c-attribute_names","()","<p>Return the list of all instance variables.\n"],["attribute_of","REXML::DocType","REXML/DocType.html#method-i-attribute_of","(element, attribute)",""],["attributes","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-attributes","()","<p>Returns attributes.\n"],["attributes","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-attributes","()",""],["attributes","RDoc::Store","RDoc/Store.html#method-i-attributes","()","<p>Attributes cache accessor.  Maps a class to an Array of its attributes.\n"],["attributes","URI::LDAP","URI/LDAP.html#method-i-attributes","()","<p>Returns attributes.\n"],["attributes=","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-attributes-3D","(val)","<p>Setter for attributes <code>val</code>.\n"],["attributes=","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-attributes-3D","(p1)",""],["attributes=","URI::LDAP","URI/LDAP.html#method-i-attributes-3D","(val)","<p>Setter for attributes <code>val</code>.\n"],["attributes_of","REXML::DocType","REXML/DocType.html#method-i-attributes_of","(element)",""],["auth_capable?","Net::SMTP","Net/SMTP.html#method-i-auth_capable-3F","(type)",""],["auth_cram_md5","Net::SMTP","Net/SMTP.html#method-i-auth_cram_md5","(user, secret)",""],["auth_data=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-auth_data-3D","(p1)","<p>Sets the cipher&#39;s additional authenticated data. This field must be set when using AEAD cipher modes …\n"],["auth_login","Net::SMTP","Net/SMTP.html#method-i-auth_login","(user, secret)",""],["auth_method","Net::SMTP","Net/SMTP.html#method-i-auth_method","(type)",""],["auth_only","Net::POP3","Net/POP3.html#method-c-auth_only","(address, port = nil, account = nil, password = nil, isapop = false)","<p>Opens a POP3 session, attempts authentication, and quits.\n<p>This method raises POPAuthenticationError if …\n"],["auth_only","Net::POP3","Net/POP3.html#method-i-auth_only","(account, password)","<p>Starts a pop3 session, attempts authentication, and quits. This method must not be called while POP3 …\n"],["auth_plain","Net::SMTP","Net/SMTP.html#method-i-auth_plain","(user, secret)",""],["auth_tag","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-auth_tag","(p1 = v1)","<p>Gets the authentication tag generated by Authenticated Encryption Cipher modes (GCM for example). This …\n"],["auth_tag=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-auth_tag-3D","(p1)","<p>Sets the authentication tag to verify the integrity of the ciphertext. This can be called only when the …\n"],["auth_tag_len=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-auth_tag_len-3D","(p1)","<p>Sets the length of the authentication tag to be generated or to be given for AEAD ciphers that requires …\n"],["authenticate","Net::IMAP","Net/IMAP.html#method-i-authenticate","(auth_type, *args)","<p>Sends an AUTHENTICATE command to authenticate the client. The <code>auth_type</code> parameter is a string that represents …\n"],["authenticate","Net::SMTP","Net/SMTP.html#method-i-authenticate","(user, secret, authtype = DEFAULT_AUTH_TYPE)",""],["authenticate","WEBrick::HTTPAuth::BasicAuth","WEBrick/HTTPAuth/BasicAuth.html#method-i-authenticate","(req, res)","<p>Authenticates a <code>req</code> and returns a 401 Unauthorized using <code>res</code> if the authentication was not correct.\n"],["authenticate","WEBrick::HTTPAuth::DigestAuth","WEBrick/HTTPAuth/DigestAuth.html#method-i-authenticate","(req, res)","<p>Authenticates a <code>req</code> and returns a 401 Unauthorized using <code>res</code> if the authentication was not correct.\n"],["authenticated?","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-authenticated-3F","()","<p>Indicated whether this Cipher instance uses an Authenticated Encryption mode.\n"],["author","Gem::Specification","Gem/Specification.html#method-i-author","()","<p>Singular reader for #authors.  Returns the first author in the list\n"],["author=","Gem::Specification","Gem/Specification.html#method-i-author-3D","(o)","<p>Singular (alternative) writer for #authors\n<p>Usage:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">spec</span>.<span class=\"ruby-identifier\">author</span> = <span class=\"ruby-string\">&#39;John Jones&#39;</span>\n</pre>\n"],["authors","Gem::Specification","Gem/Specification.html#method-i-authors","()","<p>The list of author names who wrote this gem.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">spec</span>.<span class=\"ruby-identifier\">authors</span> = [<span class=\"ruby-string\">&#39;Chad Fowler&#39;</span>, <span class=\"ruby-string\">&#39;Jim Weirich&#39;</span>, <span class=\"ruby-string\">&#39;Rich Kilmer&#39;</span>]\n</pre>\n"],["authors=","Gem::Specification","Gem/Specification.html#method-i-authors-3D","(value)","<p>A list of authors for this gem.\n<p>Alternatively, a single author can be specified by assigning a string …\n"],["auto_indent","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-auto_indent","(&block)",""],["auto_indent_proc=","Reline::Core","Reline/Core.html#method-i-auto_indent_proc-3D","(p)",""],["auto_install","Bundler::CLI","Bundler/CLI.html#method-i-auto_install","()","<p>Automatically invoke `bundle install` and resume if Bundler.settings exists. This is set through config …\n"],["autoclose=","IO","IO.html#method-i-autoclose-3D","(p1)","<p>Sets auto-close flag.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;/dev/null&quot;</span>)\n<span class=\"ruby-constant\">IO</span>.<span class=\"ruby-identifier\">for_fd</span>(<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">fileno</span>)\n<span class=\"ruby-comment\"># ...</span>\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">gets</span> <span class=\"ruby-comment\"># may cause Errno::EBADF ...</span>\n</pre>\n"],["autoclose?","IO","IO.html#method-i-autoclose-3F","()","<p>Returns <code>true</code> if the underlying file descriptor of <em>ios</em> will be closed automatically at its finalization, …\n"],["autoload","Kernel","Kernel.html#method-i-autoload","(p1, p2)","<p>Registers <em>filename</em> to be loaded (using Kernel::require) the first time that <em>module</em> (which may be a String …\n"],["autoload","Module","Module.html#method-i-autoload","(p1, p2)","<p>Registers <em>filename</em> to be loaded (using Kernel::require) the first time that <em>module</em> (which may be a String …\n"],["autoload?","Kernel","Kernel.html#method-i-autoload-3F","(*args)","<p>Returns <em>filename</em> to be loaded if <em>name</em> is registered as <code>autoload</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">autoload</span>(<span class=\"ruby-value\">:B</span>, <span class=\"ruby-string\">&quot;b&quot;</span>)\n<span class=\"ruby-identifier\">autoload?</span>(<span class=\"ruby-value\">:B</span>)      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["autoload?","Module","Module.html#method-i-autoload-3F","(*args)","<p>Returns <em>filename</em> to be loaded if <em>name</em> is registered as <code>autoload</code> in the namespace of <em>mod</em> or one of its …\n"],["avail_in","Zlib::ZStream","Zlib/ZStream.html#method-i-avail_in","()","<p>Returns bytes of data in the input buffer. Normally, returns 0.\n"],["avail_out","Zlib::ZStream","Zlib/ZStream.html#method-i-avail_out","()","<p>Returns number of bytes of free spaces in output buffer.  Because the free space is allocated automatically, …\n"],["avail_out=","Zlib::ZStream","Zlib/ZStream.html#method-i-avail_out-3D","(p1)","<p>Allocates <code>size</code> bytes of free space in the output buffer. If there are more than <code>size</code> bytes already in …\n"],["available","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-i-available","()","<p>Number of pool entries available for checkout at this instant.\n"],["available?","Bundler::Fetcher::Base","Bundler/Fetcher/Base.html#method-i-available-3F","()",""],["available?","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-available-3F","()",""],["available?","Bundler::Fetcher::Dependency","Bundler/Fetcher/Dependency.html#method-i-available-3F","()",""],["available?","Bundler::Thor::LineEditor::Basic","Bundler/Thor/LineEditor/Basic.html#method-c-available-3F","()",""],["available?","Bundler::Thor::LineEditor::Readline","Bundler/Thor/LineEditor/Readline.html#method-c-available-3F","()",""],["available_specs","Gem::SpecFetcher","Gem/SpecFetcher.html#method-i-available_specs","(type)","<p>Returns a list of gems available for each source in Gem::sources.\n<p><code>type</code> can be one of 3 values: :released …\n"],["available_tags","RSS::BaseListener","RSS/BaseListener.html#method-c-available_tags","(uri)","<p>return the tag_names for setters associated with uri\n"],["axe","REXML::QuickPath","REXML/QuickPath.html#method-c-axe","( elements, axe_name, rest )",""],["b","String","String.html#method-i-b","()","<p>Returns a copied string whose encoding is ASCII-8BIT.\n"],["backport_base_dir","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-backport_base_dir","()","<p>This backports base_dir which replaces installation path RubyGems 1.8+\n"],["backport_cache_file","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-backport_cache_file","()",""],["backport_ext_builder_monitor","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-backport_ext_builder_monitor","()",""],["backport_spec_file","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-backport_spec_file","()",""],["backtrace","Exception","Exception.html#method-i-backtrace","()","<p>Returns any backtrace associated with the exception. The backtrace is an array of strings, each containing …\n"],["backtrace","Gem::ConfigFile","Gem/ConfigFile.html#method-i-backtrace","()","<p>True if the backtrace option has been specified, or debug is on.\n"],["backtrace","Gem::StreamUI","Gem/StreamUI.html#method-i-backtrace","(exception)","<p>Prints a formatted backtrace to the errors stream if backtraces are enabled.\n"],["backtrace","Thread","Thread.html#method-i-backtrace","(*args)","<p>Returns the current backtrace of the target thread.\n"],["backtrace_locations","Exception","Exception.html#method-i-backtrace_locations","()","<p>Returns any backtrace associated with the exception. This method is similar to Exception#backtrace, but …\n"],["backtrace_locations","Thread","Thread.html#method-i-backtrace_locations","(*args)","<p>Returns the execution stack for the target thread—an array containing backtrace location objects.\n<p>See …\n"],["backtracking!","Gem::Resolver::Stats","Gem/Resolver/Stats.html#method-i-backtracking-21","()",""],["backup","Bundler::EnvironmentPreserver","Bundler/EnvironmentPreserver.html#method-i-backup","()","<p>@return [Hash]\n"],["banner","Bundler::Thor","Bundler/Thor.html#method-c-banner","(command, namespace = nil, subcommand = false)","<p>The banner for this class. You can customize it if you are invoking the thor class by another ways which …\n"],["banner","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-banner","()","<p>The banner for this class. You can customize it if you are invoking the thor class by another ways which …\n"],["banner","OptionParser","OptionParser.html#method-i-banner","()","<p>Heading banner preceding summary.\n"],["base","Bundler::CLI::Config","Bundler/CLI/Config.html#method-i-base","(name = nil, *value)",""],["base","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-base","(href = \"\")","<p>Generate a Document Base URI element as a String.\n<p><code>href</code> can either by a string, giving the base URL for …\n"],["base","OptionParser","OptionParser.html#method-i-base","()","<p>Subject of #on_tail.\n"],["base64","Random::Formatter","Random/Formatter.html#method-i-base64","(n=nil)","<p>SecureRandom.base64 generates a random base64 string.\n<p>The argument <em>n</em> specifies the length, in bytes, of …\n"],["base64_encode","Net::SMTP","Net/SMTP.html#method-i-base64_encode","(str)",""],["base64_uri_escape","Gem::S3URISigner","Gem/S3URISigner.html#method-i-base64_uri_escape","(str)",""],["base64digest","Digest::Class","Digest/Class.html#method-c-base64digest","(str, *args)","<p>Returns the base64 encoded hash value of a given <em>string</em>.  The return value is properly padded with &#39;=&#39; …\n"],["base64digest","Digest::Instance","Digest/Instance.html#method-i-base64digest","(str = nil)","<p>If none is given, returns the resulting hash value of the digest in a base64 encoded form, keeping the …\n"],["base64digest!","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-i-base64digest-21","(digest)",""],["base64digest!","Digest::Instance","Digest/Instance.html#method-i-base64digest-21","()","<p>Returns the resulting hash value and resets the digest to the initial state.\n"],["base_dir","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-base_dir","()","<p>Returns the full path to the base gem directory.\n<p>eg: /usr/local/lib/ruby/gems/1.8\n"],["base_dir","Gem::Specification","Gem/Specification.html#method-i-base_dir","()",""],["base_label","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-base_label","()","<p>Returns the base label of this instruction sequence.\n<p>For example, using irb:\n\n<pre>iseq = RubyVM::InstructionSequence.compile(&#39;num ...</pre>\n"],["base_label","Thread::Backtrace::Location","Thread/Backtrace/Location.html#method-i-base_label","()","<p>Returns the base label of this frame.\n<p>Usually same as #label, without decoration.\n"],["base_name","Bundler::Source::Git","Bundler/Source/Git.html#method-i-base_name","()",""],["base_name","RDoc::TopLevel","RDoc/TopLevel.html#method-i-base_name","()","<p>Base name of this file\n"],["base_path","Bundler::Thor::LineEditor::Readline::PathCompletion","Bundler/Thor/LineEditor/Readline/PathCompletion.html#method-i-base_path","()",""],["basename","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-basename","()","<p>The basename of the program invoking the thor class.\n"],["basename","File","File.html#method-c-basename","(*args)","<p>Returns the last component of the filename given in <em>file_name</em> (after first stripping trailing separators), …\n"],["basename","Pathname","Pathname.html#method-i-basename","(p1 = v1)","<p>Returns the last component of the path.\n<p>See File.basename.\n"],["basic","OpenSSL::OCSP::Response","OpenSSL/OCSP/Response.html#method-i-basic","()","<p>Returns a BasicResponse for this response\n"],["basic_auth","Net::HTTPHeader","Net/HTTPHeader.html#method-i-basic_auth","(account, password)","<p>Set the Authorization: header for “Basic” authorization.\n"],["basic_auth","WEBrick::HTTPAuth","WEBrick/HTTPAuth.html#method-i-basic_auth","(req, res, realm)","<p>Simple wrapper for providing basic authentication for a request.  When called with a request <code>req</code>, response …\n"],["basic_encode","Net::HTTPHeader","Net/HTTPHeader.html#method-i-basic_encode","(account, password)",""],["basic_quote_characters","Readline","Readline.html#method-c-basic_quote_characters","()","<p>Gets a list of quote characters which can cause a word break.\n<p>Raises NotImplementedError if the using …\n"],["basic_quote_characters=","Readline","Readline.html#method-c-basic_quote_characters-3D","(p1)","<p>Sets a list of quote characters which can cause a word break.\n<p>Raises NotImplementedError if the using …\n"],["basic_quote_characters=","Reline::Core","Reline/Core.html#method-i-basic_quote_characters-3D","(v)",""],["basic_word_break_characters","Readline","Readline.html#method-c-basic_word_break_characters","()","<p>Gets the basic list of characters that signal a break between words for the completer routine.\n<p>Raises …\n"],["basic_word_break_characters=","Readline","Readline.html#method-c-basic_word_break_characters-3D","(p1)","<p>Sets the basic list of characters that signal a break between words for the completer routine. The default …\n"],["basic_word_break_characters=","Reline::Core","Reline/Core.html#method-i-basic_word_break_characters-3D","(v)",""],["basis","Vector","Vector.html#method-c-basis","(size:, index:)","<p>Returns a standard basis <code>n</code>-vector, where k is the index.\n\n<pre>Vector.basis(size:, index:) # =&gt; Vector[0, 1, ...</pre>\n"],["beep","IO","IO.html#method-i-beep","()",""],["before","Racc::LocationPointer","Racc/LocationPointer.html#method-i-before","(len)",""],["before_resolution","Bundler::Molinillo::UI","Bundler/Molinillo/UI.html#method-i-before_resolution","()","<p>Called before resolution begins.\n<p>@return [void]\n"],["before_resolution","Bundler::Resolver","Bundler/Resolver.html#method-i-before_resolution","()",""],["before_resolution","Gem::Resolver::Molinillo::UI","Gem/Resolver/Molinillo/UI.html#method-i-before_resolution","()","<p>Called before resolution begins.\n<p>@return [void]\n"],["before_running_rdoc","RDoc::Task","RDoc/Task.html#method-i-before_running_rdoc","(&block)","<p>The block passed to this method will be called just before running the RDoc generator. It is allowed …\n"],["before_running_rdoc","RDoc::Task","RDoc/Task.html#method-i-before_running_rdoc","(&block)","<p>The block passed to this method will be called just before running the RDoc generator. It is allowed …\n"],["begin","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-begin","()",""],["begin","MatchData","MatchData.html#method-i-begin","(p1)","<p>Returns the offset of the start of the <em>n</em>th element of the match array in the string. <em>n</em> can be a string …\n"],["begin","Range","Range.html#method-i-begin","()","<p>Returns the object that defines the beginning of the range.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">begin</span>   <span class=\"ruby-comment\">#=&gt; 1</span>\n</pre>\n"],["begin_adding","RDoc::Stats","RDoc/Stats.html#method-i-begin_adding","()","<p>Call this to mark the beginning of parsing for display purposes\n"],["begin_transport","Net::HTTP","Net/HTTP.html#method-i-begin_transport","(req)",""],["beginning_of_line?","StringScanner","StringScanner.html#method-i-beginning_of_line-3F","()","<p>Returns <code>true</code> iff the scan pointer is at the beginning of the line.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">StringScanner</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;test\\ntest\\n&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["begins?","Gem::Command","Gem/Command.html#method-i-begins-3F","(long, short)","<p>True if <code>long</code> begins with the characters from <code>short</code>.\n"],["benchmark","Benchmark","Benchmark.html#method-i-benchmark","(caption = \"\", label_width = nil, format = nil, *labels)","<p>Invokes the block with a Benchmark::Report object, which may be used to collect and report on the results …\n"],["benchmark","Benchmark","Benchmark.html#method-c-benchmark","(caption = \"\", label_width = nil, format = nil, *labels)","<p>Invokes the block with a Benchmark::Report object, which may be used to collect and report on the results …\n"],["best_available","Bundler::Thor::LineEditor","Bundler/Thor/LineEditor.html#method-c-best_available","()",""],["between?","Comparable","Comparable.html#method-i-between-3F","(p1, p2)","<p>Returns <code>false</code> if <em>obj</em> <code>&lt;=&gt;</code> <em>min</em> is less than zero or if <em>obj</em> <code>&lt;=&gt;</code> <em>max</em> is greater than zero, <code>true</code> …\n"],["bin_dir","Gem::Specification","Gem/Specification.html#method-i-bin_dir","()","<p>Returns the full path to installed gem&#39;s bin directory.\n<p>NOTE: do not confuse this with <code>bindir</code>, which …\n"],["bin_file","Gem::Specification","Gem/Specification.html#method-i-bin_file","(name)","<p>Returns the full path to an executable named <code>name</code> in this gem.\n"],["bin_file_names","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-bin_file_names","()",""],["bin_for_find","Rinda::TupleBag","Rinda/TupleBag.html#method-i-bin_for_find","(template)",""],["bin_key","Rinda::TupleBag","Rinda/TupleBag.html#method-i-bin_key","(tuple)",""],["bin_path","Bundler","Bundler.html#method-c-bin_path","()","<p>Returns absolute location of where binstubs are installed to.\n"],["bin_path","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-bin_path","(gem, bin, ver)",""],["bin_path","Gem","Gem.html#method-c-bin_path","(name, exec_name = nil, *requirements)","<p>Find the full path to the executable for gem <code>name</code>.  If the <code>exec_name</code> is not given, an exception will …\n"],["binary=","Net::FTP","Net/FTP.html#method-i-binary-3D","(newmode)","<p>A setter to toggle transfers in binary mode. <code>newmode</code> is either <code>true</code> or <code>false</code>\n"],["binary?","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-binary-3F","(string)",""],["binary?","RDoc::Parser","RDoc/Parser.html#method-c-binary-3F","(file)","<p>Determines if the file is a “binary” file which basically means it has content that an RDoc …\n"],["binary_mode","Gem","Gem.html#method-c-binary_mode","()","<p>The mode needed to read a file as straight binary.\n"],["bind","Addrinfo","Addrinfo.html#method-i-bind","()","<p>creates a socket bound to self.\n<p>If a block is given, it is called with the socket and the value of the …\n"],["bind","Fiddle::Importer","Fiddle/Importer.html#method-i-bind","(signature, *opts, &blk)","<p>Creates a global method from the given C <code>signature</code> using the given <code>opts</code> as bind parameters with the given …\n"],["bind","Socket","Socket.html#method-i-bind","(p1)","<p>Binds to the given local address.\n<p>Parameter\n<p><code>local_sockaddr</code> - the <code>struct</code> sockaddr contained in a string …\n"],["bind","UDPSocket","UDPSocket.html#method-i-bind","(p1, p2)","<p>Binds <em>udpsocket</em> to <em>host</em>:<em>port</em>.\n\n<pre>u1 = UDPSocket.new\nu1.bind(&quot;127.0.0.1&quot;, 4913)\nu1.send &quot;message-to-self&quot;, ...</pre>\n"],["bind","UnboundMethod","UnboundMethod.html#method-i-bind","(p1)","<p>Bind <em>umeth</em> to <em>obj</em>. If Klass was the class from which <em>umeth</em> was obtained, <code>obj.kind_of?(Klass)</code> must be …\n"],["bind_call","UnboundMethod","UnboundMethod.html#method-i-bind_call","(*args)","<p>Bind <em>umeth</em> to <em>recv</em> and then invokes the method with the specified arguments. This is semantically equivalent …\n"],["bind_function","Fiddle::Importer","Fiddle/Importer.html#method-i-bind_function","(name, ctype, argtype, call_type = nil, &block)","<p>Returns a new closure wrapper for the <code>name</code> function.\n<p><code>ctype</code> is the return type of the function\n<p><code>argtype</code> is …\n"],["binding","Kernel","Kernel.html#method-i-binding","()","<p>Returns a <code>Binding</code> object, describing the variable and method bindings at the point of call. This object …\n"],["binding","Proc","Proc.html#method-i-binding","()","<p>Returns the binding associated with <em>prc</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">fred</span>(<span class=\"ruby-identifier\">param</span>)\n  <span class=\"ruby-identifier\">proc</span> {}\n<span class=\"ruby-keyword\">end</span>\n\n<span class=\"ruby-identifier\">b</span> = <span class=\"ruby-identifier\">fred</span>(<span class=\"ruby-value\">99</span>)\n<span class=\"ruby-identifier\">eval</span>(<span class=\"ruby-string\">&quot;param&quot;</span>, <span class=\"ruby-identifier\">b</span>.<span class=\"ruby-identifier\">binding</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["binding","TracePoint","TracePoint.html#method-i-binding","()","<p>Return the generated binding object from event\n"],["binding_requirement_in_set?","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-binding_requirement_in_set-3F","(requirement, possible_binding_requirements, possibilities)","<p>@param [Object] requirement we wish to check @param [Array] array of requirements @param [Array] array …\n"],["binding_requirements_for_conflict","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-binding_requirements_for_conflict","(conflict)","<p>@param [Conflict] conflict @return [Array] minimal array of requirements that would cause the passed …\n"],["bindir","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-bindir","()","<p>needed for bundle clean\n"],["bindir","Gem","Gem.html#method-c-bindir","(install_dir=Gem.dir)","<p>The path where gem executables are to be installed.\n"],["bindir","Gem::TestCase","Gem/TestCase.html#method-i-bindir","(value)","<p>Sets the bindir entry in RbConfig::CONFIG to <code>value</code> and restores the original value when the block ends …\n"],["binmode","ARGF","ARGF.html#method-i-binmode","()","<p>Puts <code>ARGF</code> into binary mode. Once a stream is in binary mode, it cannot be reset to non-binary mode.  …\n"],["binmode","IO","IO.html#method-i-binmode","()","<p>Puts <em>ios</em> into binary mode. Once a stream is in binary mode, it cannot be reset to nonbinary mode.\n<p>newline …\n"],["binmode","StringIO","StringIO.html#method-i-binmode","()","<p>Puts stream into binary mode. See IO#binmode.\n"],["binmode?","ARGF","ARGF.html#method-i-binmode-3F","()","<p>Returns true if <code>ARGF</code> is being read in binary mode; false otherwise. To enable binary mode use <code>ARGF.binmode</code> …\n"],["binmode?","CSV","CSV.html#method-i-binmode-3F","()",""],["binmode?","IO","IO.html#method-i-binmode-3F","()","<p>Returns <code>true</code> if <em>ios</em> is binmode.\n"],["binread","IO","IO.html#method-c-binread","(p1, p2 = v2, p3 = v3)","<p>Opens the file, optionally seeks to the given <em>offset</em>, then returns <em>length</em> bytes (defaulting to the rest …\n"],["binread","Pathname","Pathname.html#method-i-binread","(p1 = v1, p2 = v2)","<p>Returns all the bytes from the file, or the first <code>N</code> if specified.\n<p>See File.binread.\n"],["binstubs","Bundler::CLI","Bundler/CLI.html#method-i-binstubs","(*gems)",""],["binwrite","IO","IO.html#method-c-binwrite","(*args)","<p>Same as IO.write except opening the file in binary mode and ASCII-8BIT encoding (<code>&quot;wb:ASCII-8BIT&quot;</code> …\n"],["binwrite","Pathname","Pathname.html#method-i-binwrite","(p1 = v1, p2 = v2, p3 = v3)","<p>Writes <code>contents</code> to the file, opening it in binary mode.\n<p>See File.binwrite.\n"],["birthtime","File","File.html#method-i-birthtime","()","<p>Returns the birth time for <em>file</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">birthtime</span>   <span class=\"ruby-comment\">#=&gt; Wed Apr 09 08:53:14 CDT 2003</span>\n</pre>\n<p>If the …\n"],["birthtime","File","File.html#method-c-birthtime","(p1)",""],["birthtime","File::Stat","File/Stat.html#method-i-birthtime","()","<p>Returns the birth time for <em>stat</em>.\n<p>If the platform doesn&#39;t have birthtime, raises NotImplementedError …\n"],["birthtime","Pathname","Pathname.html#method-i-birthtime","()","<p>Returns the birth time for the file. If the platform doesn&#39;t have birthtime, raises NotImplementedError …\n"],["bit_length","Integer","Integer.html#method-i-bit_length","()","<p>Returns the number of bits of the value of <code>int</code>.\n<p>“Number of bits” means the bit position of the …\n"],["bit_set?","OpenSSL::BN","OpenSSL/BN.html#method-i-bit_set-3F","(p1)","<p>Tests bit <em>bit</em> in <em>bn</em> and returns <code>true</code> if set, <code>false</code> if not set.\n"],["blinding_off!","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-blinding_off-21","()",""],["blinding_on!","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-blinding_on-21","()",""],["blksize","File::Stat","File/Stat.html#method-i-blksize","()","<p>Returns the native file system&#39;s block size. Will return <code>nil</code> on platforms that don&#39;t support …\n"],["block_given?","Kernel","Kernel.html#method-i-block_given-3F","()","<p>Returns <code>true</code> if <code>yield</code> would execute a block in the current context. The <code>iterator?</code> form is mildly deprecated. …\n"],["block_length","Digest::Base","Digest/Base.html#method-i-block_length","()","<p>Return the block length of the digest in bytes.\n"],["block_length","Digest::Instance","Digest/Instance.html#method-i-block_length","()","<p>Returns the block length of the digest.\n<p>This method is overridden by each implementation subclass.\n"],["block_length","OpenSSL::Digest","OpenSSL/Digest.html#method-i-block_length","()","<p>Returns the block length of the digest algorithm, i.e. the length in bytes of an individual block. Most …\n"],["block_params=","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-block_params-3D","(value)","<p>Attempts to sanitize the content passed by the Ruby parser: remove outer parentheses, etc.\n"],["block_size","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-block_size","()","<p>Returns the size in bytes of the blocks on which this Cipher operates on.\n"],["blockdev?","File","File.html#method-c-blockdev-3F","(p1)","<p>Returns <code>true</code> if the named file is a block device.\n<p><em>file_name</em> can be an IO object.\n"],["blockdev?","File::Stat","File/Stat.html#method-i-blockdev-3F","()","<p>Returns <code>true</code> if the file is a block device, <code>false</code> if it isn&#39;t or if the operating system doesn&#39;t …\n"],["blockdev?","FileTest","FileTest.html#method-i-blockdev-3F","(p1)","<p>Returns <code>true</code> if the named file is a block device.\n<p><em>file_name</em> can be an IO object.\n"],["blockdev?","Pathname","Pathname.html#method-i-blockdev-3F","()","<p>See FileTest.blockdev?.\n"],["blockquote","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-blockquote","(cite = {})","<p>Generate a BlockQuote element as a string.\n<p><code>cite</code> can either be a string, give the URI for the source of …\n"],["blocks","File::Stat","File/Stat.html#method-i-blocks","()","<p>Returns the number of native file system blocks allocated for this file, or <code>nil</code> if the operating system …\n"],["bm","Benchmark","Benchmark.html#method-i-bm","(label_width = 0, *labels)","<p>A simple interface to the #benchmark method, #bm generates sequential reports with labels. <code>label_width</code> …\n"],["bm","Benchmark","Benchmark.html#method-c-bm","(label_width = 0, *labels)","<p>A simple interface to the #benchmark method, #bm generates sequential reports with labels. <code>label_width</code> …\n"],["bmbm","Benchmark","Benchmark.html#method-c-bmbm","(width = 0)","<p>Sometimes benchmark results are skewed because code executed earlier encounters different garbage collection …\n"],["bmbm","Benchmark","Benchmark.html#method-i-bmbm","(width = 0)","<p>Sometimes benchmark results are skewed because code executed earlier encounters different garbage collection …\n"],["body","Net::HTTPResponse","Net/HTTPResponse.html#method-i-body","()","<p>Returns the full entity body.\n<p>Calling this method a second or subsequent time will return the string already …\n"],["body","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-body","()","<p>Returns the request body.\n"],["body=","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-body-3D","(str)",""],["body=","Net::HTTPResponse","Net/HTTPResponse.html#method-i-body-3D","(value)","<p>Because it may be necessary to modify the body, Eg, decompression this method facilitates that.\n"],["body_exist?","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-body_exist-3F","()",""],["body_permitted?","Net::HTTPResponse","Net/HTTPResponse.html#method-c-body_permitted-3F","()","<p>true if the response has a body.\n"],["body_reader","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-body_reader","()","<p>Prepares the HTTPRequest object for use as the source for IO.copy_stream\n"],["body_stream=","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-body_stream-3D","(input)",""],["bool","Socket::Option","Socket/Option.html#method-c-bool","(p1, p2, p3, p4)","<p>Creates a new Socket::Option object which contains boolean as data. Actually 0 or 1 as int is used.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["bool","Socket::Option","Socket/Option.html#method-i-bool","()","<p>Returns the data in <em>sockopt</em> as an boolean value.\n\n<pre>sockopt = Socket::Option.int(:INET, :SOCKET, :KEEPALIVE, ...</pre>\n"],["bool_attr","Racc::ParserFileGenerator::Params","Racc/ParserFileGenerator/Params.html#method-c-bool_attr","(name)",""],["boolean","REXML::Functions","REXML/Functions.html#method-c-boolean","(object=@@context[:node])",""],["boolean_argument","RSS::Parser","RSS/Parser.html#method-c-boolean_argument","(positioned_value, option_value, default)",""],["boolean_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-boolean_writer","(name, disp_name=name)",""],["both?","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-both-3F","()","<p>Is fetching of local and remote information enabled?\n"],["bottom","IRB::Frame","IRB/Frame.html#method-i-bottom","(n = 0)","<p>Returns the <code>n</code> number of frames on the call stack from the first frame initialized.\n<p>Raises FrameOverflow …\n"],["bottom","IRB::Frame","IRB/Frame.html#method-c-bottom","(n = 0)","<p>Convenience method for Frame#bottom\n"],["branch","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-branch","()",""],["break_on_newline","RDoc::Markdown","RDoc/Markdown.html#method-i-break_on_newline","","<p>Converts all newlines into hard breaks\n"],["break_outmost_groups","PrettyPrint","PrettyPrint.html#method-i-break_outmost_groups","()","<p>Breaks the buffer into lines that are shorter than #maxwidth\n"],["break_points","DEBUGGER__","DEBUGGER__.html#method-c-break_points","()","<p>Returns the list of break points where execution will be stopped.\n<p>See DEBUGGER__ for more usage\n"],["breakable","PrettyPrint","PrettyPrint.html#method-i-breakable","(sep=' ', width=sep.length)","<p>This says “you can break a line here if necessary”, and a <code>width</code>-column text <code>sep</code> is inserted …\n"],["breakable","PrettyPrint::SingleLine","PrettyPrint/SingleLine.html#method-i-breakable","(sep=' ', width=nil)","<p>Appends <code>sep</code> to the text to be output. By default <code>sep</code> is &#39; &#39;\n<p><code>width</code> argument is here for compatibility. …\n"],["broadaddr","Socket::Ifaddr","Socket/Ifaddr.html#method-i-broadaddr","()","<p>Returns the broadcast address of <em>ifaddr</em>. nil is returned if the flags doesn&#39;t have IFF_BROADCAST …\n"],["broadcast","ConditionVariable","ConditionVariable.html#method-i-broadcast","()","<p>Wakes up all threads waiting for this lock.\n"],["broadcast","MonitorMixin::ConditionVariable","MonitorMixin/ConditionVariable.html#method-i-broadcast","()","<p>Wakes up all threads waiting for this lock.\n"],["bsearch","Array","Array.html#method-i-bsearch","()","<p>By using binary search, finds a value from this array which meets the given condition in O(log n) where …\n"],["bsearch","Range","Range.html#method-i-bsearch","()","<p>By using binary search, finds a value in range which meets the given condition in O(log n) where n is …\n"],["bsearch_index","Array","Array.html#method-i-bsearch_index","()","<p>By using binary search, finds an index of a value from this array which meets the given condition in …\n"],["bubblebabble","Digest","Digest.html#method-c-bubblebabble","(p1)","<p>Returns a BubbleBabble encoded version of a given <em>string</em>.\n"],["bubblebabble","Digest::Class","Digest/Class.html#method-c-bubblebabble","(*args)","<p>Returns the BubbleBabble encoded hash value of a given <em>string</em>.\n"],["bubblebabble","Digest::Instance","Digest/Instance.html#method-i-bubblebabble","()","<p>Returns the resulting hash value in a Bubblebabble encoded form.\n"],["buffer_initial_length","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-buffer_initial_length","()","<p>This integer returns the current initial length of the buffer.\n"],["buffer_initial_length=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-buffer_initial_length-3D","(p1)","<p>This sets the initial length of the buffer to <code>length</code>, if <code>length</code> &gt; 0, otherwise its value isn&#39;t …\n"],["build","Bundler::Definition","Bundler/Definition.html#method-c-build","(gemfile, lockfile, unlock)","<p>Given a gemfile and lockfile creates a Bundler definition\n<p>@param gemfile [Pathname] Path to Gemfile @param …\n"],["build","Bundler::Index","Bundler/Index.html#method-c-build","()",""],["build","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-build","(spec, skip_validation = false)",""],["build","Bundler::URI::FTP","Bundler/URI/FTP.html#method-c-build","(args)","<p>Description\n<p>Creates a new Bundler::URI::FTP object from components, with syntax checking.\n<p>The components …\n"],["build","Bundler::URI::File","Bundler/URI/File.html#method-c-build","(args)","<p>Description\n<p>Creates a new Bundler::URI::File object from components, with syntax checking.\n<p>The components …\n"],["build","Bundler::URI::Generic","Bundler/URI/Generic.html#method-c-build","(args)","<p>Synopsis\n<p>See ::new.\n<p>Description\n"],["build","Bundler::URI::HTTP","Bundler/URI/HTTP.html#method-c-build","(args)","<p>Description\n<p>Creates a new Bundler::URI::HTTP object from components, with syntax checking.\n<p>The components …\n"],["build","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-c-build","(args)","<p>Description\n<p>Creates a new Bundler::URI::LDAP object from components, with syntax checking.\n<p>The components …\n"],["build","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-c-build","(args)","<p>Description\n<p>Creates a new Bundler::URI::MailTo object from components, with syntax checking.\n<p>Components …\n"],["build","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-build","(email)",""],["build","Gem::Ext::CmakeBuilder","Gem/Ext/CmakeBuilder.html#method-c-build","(extension, dest_path, results, args=[], lib_dir=nil)",""],["build","Gem::Ext::ConfigureBuilder","Gem/Ext/ConfigureBuilder.html#method-c-build","(extension, dest_path, results, args=[], lib_dir=nil)",""],["build","Gem::Ext::ExtConfBuilder","Gem/Ext/ExtConfBuilder.html#method-c-build","(extension, dest_path, results, args=[], lib_dir=nil)",""],["build","Gem::Ext::RakeBuilder","Gem/Ext/RakeBuilder.html#method-c-build","(extension, dest_path, results, args=[], lib_dir=nil)",""],["build","Gem::Package","Gem/Package.html#method-c-build","(spec, skip_validation = false, strict_validation = false, file_name = nil)",""],["build","Gem::Package","Gem/Package.html#method-i-build","(skip_validation = false, strict_validation = false)","<p>Builds this package based on the specification set by #spec=\n"],["build","Gem::RequestSet::Lockfile","Gem/RequestSet/Lockfile.html#method-c-build","(request_set, gem_deps_file, dependencies = nil)","<p>Creates a new Lockfile for the given <code>request_set</code> and <code>gem_deps_file</code> location.\n"],["build","Matrix","Matrix.html#method-c-build","(row_count, column_count = row_count)","<p>Creates a matrix of size <code>row_count</code> x <code>column_count</code>. It fills the values by calling the given block, passing …\n"],["build","REXML::Document","REXML/Document.html#method-i-build","( source )",""],["build","URI::FTP","URI/FTP.html#method-c-build","(args)","<p>Description\n<p>Creates a new URI::FTP object from components, with syntax checking.\n<p>The components accepted …\n"],["build","URI::File","URI/File.html#method-c-build","(args)","<p>Description\n<p>Creates a new URI::File object from components, with syntax checking.\n<p>The components accepted …\n"],["build","URI::Generic","URI/Generic.html#method-c-build","(args)","<p>Synopsis\n<p>See ::new.\n<p>Description\n"],["build","URI::HTTP","URI/HTTP.html#method-c-build","(args)","<p>Description\n<p>Creates a new URI::HTTP object from components, with syntax checking.\n<p>The components accepted …\n"],["build","URI::LDAP","URI/LDAP.html#method-c-build","(args)","<p>Description\n<p>Creates a new URI::LDAP object from components, with syntax checking.\n<p>The components accepted …\n"],["build","URI::MailTo","URI/MailTo.html#method-c-build","(args)","<p>Description\n<p>Creates a new URI::MailTo object from components, with syntax checking.\n<p>Components can be provided …\n"],["build2","Bundler::URI::Generic","Bundler/URI/Generic.html#method-c-build2","(args)","<p>Synopsis\n<p>See ::new.\n<p>Description\n"],["build2","URI::Generic","URI/Generic.html#method-c-build2","(args)","<p>Synopsis\n<p>See ::new.\n<p>Description\n"],["build_args","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-build_args","()",""],["build_args","Gem::Command","Gem/Command.html#method-c-build_args","()","<p>Arguments used when building gems\n"],["build_args","Gem::Specification","Gem/Specification.html#method-i-build_args","()","<p>Returns the build_args used to install the gem\n"],["build_args=","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-build_args-3D","(args)",""],["build_args=","Gem::Command","Gem/Command.html#method-c-build_args-3D","(value)",""],["build_dependency","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-build_dependency","(name, requirements)",""],["build_details_for_unwind","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-build_details_for_unwind","()","<p>@return [UnwindDetails] Details of the nearest index to which we could unwind\n"],["build_eigenvectors","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-build_eigenvectors","()",""],["build_exception","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-build_exception","(p1, p2)","<p>Create an exception with class <code>klass</code> and <code>message</code>\n"],["build_extensions","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-i-build_extensions","()",""],["build_extensions","Gem::Ext::Builder","Gem/Ext/Builder.html#method-i-build_extensions","()","<p>Builds extensions.  Valid types of extensions are extconf.rb files, configure scripts and rakefiles or …\n"],["build_extensions","Gem::Installer","Gem/Installer.html#method-i-build_extensions","()","<p>Builds extensions.  Valid types of extensions are extconf.rb files, configure scripts and rakefiles or …\n"],["build_fields_converter","CSV","CSV.html#method-i-build_fields_converter","(initial_converters, options)",""],["build_gem","Bundler::GemHelper","Bundler/GemHelper.html#method-i-build_gem","()",""],["build_gem","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-build_gem","(gem_dir, spec)",""],["build_gem","Gem::Commands::BuildCommand","Gem/Commands/BuildCommand.html#method-i-build_gem","(gem_name)",""],["build_gem_lines","Bundler::Injector","Bundler/Injector.html#method-i-build_gem_lines","(conservative_versioning)",""],["build_header_fields_converter","CSV","CSV.html#method-i-build_header_fields_converter","()",""],["build_heading","RDoc::TomDoc","RDoc/TomDoc.html#method-i-build_heading","(level)","<p>Builds a heading from the token stream\n<p>level &mdash; The level of heading to create\n\n<p>Returns\n"],["build_indices","Gem::Indexer","Gem/Indexer.html#method-i-build_indices","()","<p>Build various indices\n"],["build_info_dir","Gem::Specification","Gem/Specification.html#method-i-build_info_dir","()","<p>Returns the full path to the build info directory\n"],["build_info_file","Gem::Specification","Gem/Specification.html#method-i-build_info_file","()","<p>Returns the full path to the file containing the build information generated when the gem was installed …\n"],["build_marshal_gemspecs","Gem::Indexer","Gem/Indexer.html#method-i-build_marshal_gemspecs","(specs)","<p>Builds Marshal quick index gemspecs.\n"],["build_message","Gem::MissingSpecError","Gem/MissingSpecError.html#method-i-build_message","()",""],["build_message","Gem::MissingSpecVersionError","Gem/MissingSpecVersionError.html#method-i-build_message","()",""],["build_modern_index","Gem::Indexer","Gem/Indexer.html#method-i-build_modern_index","(index, file, name)","<p>Build a single index for RubyGems 1.2 and newer\n"],["build_modern_indices","Gem::Indexer","Gem/Indexer.html#method-i-build_modern_indices","(specs)","<p>Builds indices for RubyGems 1.2 and newer. Handles full, latest, prerelease\n"],["build_package","Gem::Commands::BuildCommand","Gem/Commands/BuildCommand.html#method-i-build_package","(spec)",""],["build_paragraph","RDoc::TomDoc","RDoc/TomDoc.html#method-i-build_paragraph","(margin)","<p>Builds a paragraph from the token stream\n<p>margin &mdash; Unused\n\n<p>Returns\n"],["build_parser_fields_converter","CSV","CSV.html#method-i-build_parser_fields_converter","()",""],["build_path_query","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-build_path_query","()","<p>Private method to assemble <code>query</code> from <code>attributes</code>, <code>scope</code>, <code>filter</code>, and <code>extensions</code>.\n"],["build_path_query","URI::LDAP","URI/LDAP.html#method-i-build_path_query","()","<p>Private method to assemble <code>query</code> from <code>attributes</code>, <code>scope</code>, <code>filter</code>, and <code>extensions</code>.\n"],["build_rake_in","Gem::TestCase","Gem/TestCase.html#method-i-build_rake_in","(good=true)","<p>Allows the proper version of <code>rake</code> to be used for the test.\n"],["build_scanner","CSV::Parser","CSV/Parser.html#method-i-build_scanner","()",""],["build_verbatim","RDoc::TomDoc","RDoc/TomDoc.html#method-i-build_verbatim","(margin)","<p>Builds a verbatim from the token stream.  A verbatim in the Examples section will be marked as in Ruby …\n"],["build_writer_fields_converter","CSV","CSV.html#method-i-build_writer_fields_converter","()",""],["built_at","Bundler::BuildMetadata","Bundler/BuildMetadata.html#method-c-built_at","()","<p>A string representing the date the bundler gem was built.\n"],["built_gem_path","Bundler::GemHelper","Bundler/GemHelper.html#method-i-built_gem_path","()",""],["builtin_curves","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-c-builtin_curves","()","<p>Obtains a list of all predefined curves by the OpenSSL. Curve names are returned as sn.\n<p>See the OpenSSL …\n"],["builtin_gem?","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-builtin_gem-3F","(spec)",""],["bump","Gem::Version","Gem/Version.html#method-i-bump","()","<p>Return a new version object where the next to the last revision number is one greater (e.g., 5.3.1 =&gt; …\n"],["bundle_path","Bundler","Bundler.html#method-c-bundle_path","()","<p>Returns absolute path of where gems are installed on the filesystem.\n"],["bundle_update_bundler_version","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-bundle_update_bundler_version","()",""],["bundle_worker","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-bundle_worker","(func = nil)",""],["bundler_cert_store","Bundler::Fetcher","Bundler/Fetcher.html#method-i-bundler_cert_store","()",""],["bundler_dependency_version","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-bundler_dependency_version","()",""],["bundler_major_version","Bundler","Bundler.html#method-c-bundler_major_version","()",""],["bundler_path","Bundler::Standalone","Bundler/Standalone.html#method-i-bundler_path","()",""],["bundler_plugin_api_source?","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-bundler_plugin_api_source-3F","()","<p>@private Returns true\n"],["bundler_ruby_lib","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-bundler_ruby_lib","()",""],["bundler_version","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-bundler_version","()",""],["bundler_version_with_reason","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-bundler_version_with_reason","()",""],["bundles_for_gem","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-bundles_for_gem","(spec)",""],["by_col","CSV::Table","CSV/Table.html#method-i-by_col","()","<p>Returns a duplicate table object, in column mode. This is handy for chaining in a single call without …\n"],["by_col!","CSV::Table","CSV/Table.html#method-i-by_col-21","()","<p>Switches the mode of this table to column mode. All calls to indexing and iteration methods will work …\n"],["by_col_or_row","CSV::Table","CSV/Table.html#method-i-by_col_or_row","()","<p>Returns a duplicate table object, in mixed mode. This is handy for chaining in a single call without …\n"],["by_col_or_row!","CSV::Table","CSV/Table.html#method-i-by_col_or_row-21","()","<p>Switches the mode of this table to mixed mode. All calls to indexing and iteration methods will use the …\n"],["by_id","OpenSSL::Engine","OpenSSL/Engine.html#method-c-by_id","(p1)","<p>Fetches the engine as specified by the <em>id</em> String.\n\n<pre>OpenSSL::Engine.by_id(&quot;openssl&quot;)\n =&gt; #&lt;OpenSSL::Engine ...</pre>\n"],["by_row","CSV::Table","CSV/Table.html#method-i-by_row","()","<p>Returns a duplicate table object, in row mode.  This is handy for chaining in a single call without changing …\n"],["by_row!","CSV::Table","CSV/Table.html#method-i-by_row-21","()","<p>Switches the mode of this table to row mode. All calls to indexing and iteration methods will work with …\n"],["byte","Socket::Option","Socket/Option.html#method-i-byte","()","<p>Returns the data in <em>sockopt</em> as an byte.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">sockopt</span> = <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">byte</span>(<span class=\"ruby-value\">:INET</span>, <span class=\"ruby-value\">:SOCKET</span>, <span class=\"ruby-value\">:KEEPALIVE</span>, <span class=\"ruby-value\">1</span>)\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["byte","Socket::Option","Socket/Option.html#method-c-byte","(p1, p2, p3, p4)","<p>Creates a new Socket::Option object which contains a byte as data.\n\n<pre>p Socket::Option.byte(:INET, :SOCKET, ...</pre>\n"],["bytes","ARGF","ARGF.html#method-i-bytes","()","<p>This is a deprecated alias for #each_byte.\n"],["bytes","IO","IO.html#method-i-bytes","()","<p>This is a deprecated alias for #each_byte.\n"],["bytes","REXML::Child","REXML/Child.html#method-i-bytes","()","<p>This doesn&#39;t yet handle encodings\n"],["bytes","Random","Random.html#method-c-bytes","(p1)","<p>Returns a random binary string. The argument <code>size</code> specifies the length of the returned string.\n"],["bytes","Random","Random.html#method-i-bytes","(p1)","<p>Returns a random binary string containing <code>size</code> bytes.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">random_string</span> = <span class=\"ruby-constant\">Random</span>.<span class=\"ruby-identifier\">new</span>.<span class=\"ruby-identifier\">bytes</span>(<span class=\"ruby-value\">10</span>) <span class=\"ruby-comment\"># =&gt; &quot;\\xD7:R\\xAB?\\x83\\xCE\\xFAkO&quot; ...</span>\n</pre>\n"],["bytes","SecureRandom","SecureRandom.html#method-c-bytes","(n)",""],["bytes","String","String.html#method-i-bytes","()","<p>Returns an array of bytes in <em>str</em>.  This is a shorthand for <code>str.each_byte.to_a</code>.\n<p>If a block is given, which …\n"],["bytes","StringIO","StringIO.html#method-i-bytes","()","<p>This is a deprecated alias for #each_byte.\n"],["bytes","Zlib::GzipReader","Zlib/GzipReader.html#method-i-bytes","()","<p>This is a deprecated alias for <code>each_byte</code>.\n"],["bytes_read","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-bytes_read","()","<p>Number of bytes read out of the tar entry\n"],["bytesize","String","String.html#method-i-bytesize","()","<p>Returns the length of <code>str</code> in bytes.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;\\x80\\u3042&quot;</span>.<span class=\"ruby-identifier\">bytesize</span>  <span class=\"ruby-comment\">#=&gt; 4</span>\n<span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">bytesize</span>       <span class=\"ruby-comment\">#=&gt; 5</span>\n</pre>\n"],["byteslice","String","String.html#method-i-byteslice","(*args)","<p>Byte Reference—If passed a single Integer, returns a substring of one byte at that position. If passed …\n"],["ca_file=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-ca_file-3D","(file)","<p>Sets the SSL certificate authority file.\n"],["ca_path=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-ca_path-3D","(path)","<p>Sets the SSL certificate authority path.\n"],["cache","Bundler::CLI","Bundler/CLI.html#method-i-cache","()",""],["cache","Bundler::Plugin","Bundler/Plugin.html#method-i-cache","()","<p>The cache directory for plugin stuffs\n"],["cache","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-cache","(spec, custom_path = nil)","<p>This method is called while caching to save copy of the gems that the source can resolve to path provided …\n"],["cache","Bundler::Runtime","Bundler/Runtime.html#method-i-cache","(custom_path = nil)",""],["cache","Bundler::Source::Git","Bundler/Source/Git.html#method-i-cache","(spec, custom_path = nil)",""],["cache","Bundler::Source::Path","Bundler/Source/Path.html#method-i-cache","(spec, custom_path = nil)",""],["cache","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cache","(spec, custom_path = nil)",""],["cache_dir","Bundler::Plugin::API","Bundler/Plugin/API.html#method-i-cache_dir","()","<p>The cache dir to be used by the plugins for storage\n<p>@return [Pathname] path of the cache dir\n"],["cache_dir","Gem::Source","Gem/Source.html#method-i-cache_dir","(uri)","<p>Returns the local directory to write <code>uri</code> to.\n"],["cache_dir","Gem::Specification","Gem/Specification.html#method-i-cache_dir","()","<p>Returns the full path to the cache directory containing this spec&#39;s cached gem.\n"],["cache_file","Gem::Specification","Gem/Specification.html#method-i-cache_file","()","<p>Returns the full path to the cached gem for this spec.\n"],["cache_globally","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cache_globally","(spec, local_cache_path)","<p>Checks if the requested spec exists in the global cache. If it does not, we create the relevant global …\n"],["cache_path","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-cache_path","()",""],["cache_path","Bundler::Plugin::Installer::Git","Bundler/Plugin/Installer/Git.html#method-i-cache_path","()",""],["cache_path","Bundler::Plugin::Installer::Rubygems","Bundler/Plugin/Installer/Rubygems.html#method-i-cache_path","()",""],["cache_path","Bundler::Source::Git","Bundler/Source/Git.html#method-i-cache_path","()","<p>This is the path which is going to contain a cache of the git repository. When using the same git repository …\n"],["cache_path","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cache_path","()",""],["cache_path","RDoc::Store","RDoc/Store.html#method-i-cache_path","()","<p>Path to the cache file\n"],["cache_slug","Bundler::Source::Rubygems::Remote","Bundler/Source/Rubygems/Remote.html#method-i-cache_slug","()","<p>@return [String] A slug suitable for use as a cache key for this\n\n<pre>remote.</pre>\n"],["cache_update_path","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-cache_update_path","(uri, path = nil, update = true)",""],["cache_update_path","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-cache_update_path","(uri, path = nil, update = true)","<p>Downloads <code>uri</code> to <code>path</code> if necessary. If no path is given, it just passes the data.\n"],["cached!","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-cached-21","()","<p>Set internal representation to fetch the gems/specs from app cache.\n<p>When this is called, the source should …\n"],["cached!","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-cached-21","()",""],["cached!","Bundler::Source::Path","Bundler/Source/Path.html#method-i-cached-21","()",""],["cached!","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cached-21","()",""],["cached!","Bundler::SourceList","Bundler/SourceList.html#method-i-cached-21","()",""],["cached?","Bundler::Source::Git","Bundler/Source/Git.html#method-i-cached-3F","()",""],["cached_built_in_gem","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cached_built_in_gem","(spec)",""],["cached_gem","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cached_gem","(spec)",""],["cached_path","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cached_path","(spec)",""],["cached_revision","Bundler::Source::Git","Bundler/Source/Git.html#method-i-cached_revision","()",""],["cached_revision_checked_out?","Bundler::Source::Git","Bundler/Source/Git.html#method-i-cached_revision_checked_out-3F","()",""],["cached_specs","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-cached_specs","()",""],["cachesize=","GDBM","GDBM.html#method-i-cachesize-3D","(p1)","<p>Sets the size of the internal bucket cache to <em>size</em>.\n"],["calc_checksum","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-calc_checksum","(header)",""],["calc_indent","RSS::Element","RSS/Element.html#method-i-calc_indent","()","<p>For backward compatibility\n"],["calculate","RDoc::Stats","RDoc/Stats.html#method-i-calculate","()","<p>Calculates documentation totals and percentages for classes, modules, constants, attributes and methods. …\n"],["calculate_checksum","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-i-calculate_checksum","(header)",""],["call","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-call","()",""],["call","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-c-call","(*args)",""],["call","Continuation","Continuation.html#method-i-call","(*args)","<p>Invokes the continuation. The program continues from the end of the #callcc block. If no arguments are …\n"],["call","Fiddle::Closure::BlockCaller","Fiddle/Closure/BlockCaller.html#method-i-call","(*args)","<p>Calls the constructed BlockCaller, with <code>args</code>\n<p>For an example see Fiddle::Closure::BlockCaller.new\n"],["call","Fiddle::Function","Fiddle/Function.html#method-i-call","(*args)","<p>Calls the constructed Function, with <code>args</code>. Caller must ensure the underlying function is called in a …\n"],["call","Method","Method.html#method-i-call","(*args)","<p>Invokes the <em>meth</em> with the specified arguments, returning the method&#39;s return value.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> = <span class=\"ruby-value\">12</span>.<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-string\">&quot;+&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["call","Proc","Proc.html#method-i-call","(*args)","<p>Invokes the block, setting the block&#39;s parameters to the values in <em>params</em> using something close to …\n"],["call","Syslog::Logger::Formatter","Syslog/Logger/Formatter.html#method-i-call","(severity, time, progname, msg)",""],["call_seq=","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-call_seq-3D","(call_seq)","<p>Sets the different ways you can call this method.  If an empty <code>call_seq</code> is given nil is assumed.\n<p>See also …\n"],["callcc","Kernel","Kernel.html#method-i-callcc","()","<p>Generates a Continuation object, which it passes to the associated block. You need to <code>require &#39;continuation&#39;</code> …\n"],["callee_id","TracePoint","TracePoint.html#method-i-callee_id","()","<p>Return the called name of the method being called\n"],["caller","Kernel","Kernel.html#method-i-caller","(*args)","<p>Returns the current execution stack—an array containing strings in the form <code>file:line</code> or <code>file:line:</code> …\n"],["caller_locations","Kernel","Kernel.html#method-i-caller_locations","(*args)","<p>Returns the current execution stack—an array containing backtrace location objects.\n<p>See Thread::Backtrace::Location …\n"],["camel_case","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-camel_case","(str)","<p>Receives a string and convert it to camel case. camel_case returns CamelCase.\n<p>Parameters\n<p>String\n"],["can_display_colors?","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-can_display_colors-3F","()",""],["can_display_colors?","Bundler::Thor::Shell::Color","Bundler/Thor/Shell/Color.html#method-i-can_display_colors-3F","()",""],["can_display_colors?","Bundler::Thor::Shell::HTML","Bundler/Thor/Shell/HTML.html#method-i-can_display_colors-3F","()",""],["can_install_in_parallel?","Bundler::Installer","Bundler/Installer.html#method-i-can_install_in_parallel-3F","()",""],["can_lock?","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-can_lock-3F","(spec)","<p>Note: Do not override if you don&#39;t know what you are doing.\n"],["can_lock?","Bundler::Source","Bundler/Source.html#method-i-can_lock-3F","(spec)",""],["can_lock?","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-can_lock-3F","(spec)",""],["can_parse","RDoc::Parser","RDoc/Parser.html#method-c-can_parse","(file_name)","<p>Return a parser that can handle a particular extension\n"],["can_parse_by_name","RDoc::Parser","RDoc/Parser.html#method-c-can_parse_by_name","(file_name)","<p>Returns a parser that can handle the extension for <code>file_name</code>.  This does not depend upon the file being …\n"],["can_retry?","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-can_retry-3F","(req)","<p>Is the request <code>req</code> idempotent or is retry_change_requests allowed.\n"],["cancel","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-cancel","()","<p>Marks this TupleEntry as canceled.\n"],["cancel","Rinda::WaitTemplateEntry","Rinda/WaitTemplateEntry.html#method-i-cancel","()",""],["cancel","WEBrick::Utils::TimeoutHandler","WEBrick/Utils/TimeoutHandler.html#method-c-cancel","(id)","<p>Cancels the timeout handler <code>id</code>\n"],["canceled?","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-canceled-3F","()","<p>Returns the canceled status.\n"],["candidate","OptionParser","OptionParser.html#method-i-candidate","(word)",""],["candidate","OptionParser::Completion","OptionParser/Completion.html#method-i-candidate","(key, icase = false, pat = nil)",""],["candidate","OptionParser::Completion","OptionParser/Completion.html#method-c-candidate","(key, icase = false, pat = nil, &block)",""],["canonical","Psych::Emitter","Psych/Emitter.html#method-i-canonical","()","<p>Get the output style, canonical or not.\n"],["canonical=","Psych::Emitter","Psych/Emitter.html#method-i-canonical-3D","(p1)","<p>Set the output style to canonical, or not.\n"],["canonical_each","Net::HTTPHeader","Net/HTTPHeader.html#method-i-canonical_each","()",""],["canonical_label","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-canonical_label","(src)",""],["canonical_segments","Gem::Version","Gem/Version.html#method-i-canonical_segments","()",""],["canonname","Addrinfo","Addrinfo.html#method-i-canonname","()","<p>returns the canonical name as an string.\n<p>nil is returned if no canonical name.\n<p>The canonical name is set …\n"],["capabilities","Net::SMTP::Response","Net/SMTP/Response.html#method-i-capabilities","()","<p>Returns a hash of the human readable reply text in the response if it is multiple lines. It does not …\n"],["capability","Net::IMAP","Net/IMAP.html#method-i-capability","()","<p>Sends a CAPABILITY command, and returns an array of capabilities that the server supports.  Each capability …\n"],["capable?","Net::SMTP","Net/SMTP.html#method-i-capable-3F","(key)",""],["capable_auth_types","Net::SMTP","Net/SMTP.html#method-i-capable_auth_types","()","<p>Returns supported authentication methods on this server. You cannot get valid value before opening SMTP …\n"],["capable_cram_md5_auth?","Net::SMTP","Net/SMTP.html#method-i-capable_cram_md5_auth-3F","()","<p>true if server advertises AUTH CRAM-MD5. You cannot get valid value before opening SMTP session.\n"],["capable_login_auth?","Net::SMTP","Net/SMTP.html#method-i-capable_login_auth-3F","()","<p>true if server advertises AUTH LOGIN. You cannot get valid value before opening SMTP session.\n"],["capable_plain_auth?","Net::SMTP","Net/SMTP.html#method-i-capable_plain_auth-3F","()","<p>true if server advertises AUTH PLAIN. You cannot get valid value before opening SMTP session.\n"],["capable_starttls?","Net::SMTP","Net/SMTP.html#method-i-capable_starttls-3F","()","<p>true if server advertises STARTTLS. You cannot get valid value before opening SMTP session.\n"],["capitalize","Net::HTTPHeader","Net/HTTPHeader.html#method-i-capitalize","(name)",""],["capitalize","String","String.html#method-i-capitalize","(*args)","<p>Returns a copy of <em>str</em> with the first character converted to uppercase and the remainder to lowercase. …\n"],["capitalize","Symbol","Symbol.html#method-i-capitalize","(*args)","<p>Same as <code>sym.to_s.capitalize.intern</code>.\n"],["capitalize!","String","String.html#method-i-capitalize-21","(*args)","<p>Modifies <em>str</em> by converting the first character to uppercase and the remainder to lowercase. Returns  …\n"],["caption","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-caption","(align = {})","<p>Generate a Table Caption element as a string.\n<p><code>align</code> can be a string, giving the alignment of the caption …\n"],["capture","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-capture","(*args)",""],["capture2","Open3","Open3.html#method-i-capture2","(*cmd)","<p>Open3.capture2 captures the standard output of a command.\n\n<pre>stdout_str, status = Open3.capture2([env,] cmd... ...</pre>\n"],["capture2","Open3","Open3.html#method-c-capture2","(*cmd)","<p>Open3.capture2 captures the standard output of a command.\n\n<pre>stdout_str, status = Open3.capture2([env,] cmd... ...</pre>\n"],["capture2e","Open3","Open3.html#method-i-capture2e","(*cmd)","<p>Open3.capture2e captures the standard output and the standard error of a command.\n\n<pre>stdout_and_stderr_str, ...</pre>\n"],["capture2e","Open3","Open3.html#method-c-capture2e","(*cmd)","<p>Open3.capture2e captures the standard output and the standard error of a command.\n\n<pre>stdout_and_stderr_str, ...</pre>\n"],["capture3","Open3","Open3.html#method-i-capture3","(*cmd)","<p>Open3.capture3 captures the standard output and the standard error of a command.\n\n<pre>stdout_str, stderr_str, ...</pre>\n"],["capture3","Open3","Open3.html#method-c-capture3","(*cmd)","<p>Open3.capture3 captures the standard output and the standard error of a command.\n\n<pre>stdout_str, stderr_str, ...</pre>\n"],["capture_and_filter_stderr","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-capture_and_filter_stderr","(uri, cmd)",""],["capture_and_ignore_stderr","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-capture_and_ignore_stderr","(cmd)",""],["captures","MatchData","MatchData.html#method-i-captures","()","<p>Returns the array of captures; equivalent to <code>mtch.to_a[1..-1]</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f1</span>,<span class=\"ruby-identifier\">f2</span>,<span class=\"ruby-identifier\">f3</span>,<span class=\"ruby-identifier\">f4</span> = <span class=\"ruby-regexp\">/(.)(.)(\\d+)(\\d)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;THX1138.&quot;</span>).<span class=\"ruby-identifier\">captures</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["captures","StringScanner","StringScanner.html#method-i-captures","()","<p>Returns the subgroups in the most recent match (not including the full match). If nothing was priorly …\n"],["casecmp","String","String.html#method-i-casecmp","(p1)","<p>Case-insensitive version of String#&lt;=&gt;. Currently, case-insensitivity only works on characters …\n"],["casecmp","Symbol","Symbol.html#method-i-casecmp","(p1)","<p>Case-insensitive version of Symbol#&lt;=&gt;. Currently, case-insensitivity only works on characters …\n"],["casecmp?","String","String.html#method-i-casecmp-3F","(p1)","<p>Returns <code>true</code> if <code>str</code> and <code>other_str</code> are equal after Unicode case folding, <code>false</code> if they are not equal. …\n"],["casecmp?","Symbol","Symbol.html#method-i-casecmp-3F","(p1)","<p>Returns <code>true</code> if <code>sym</code> and <code>other_symbol</code> are equal after Unicode case folding, <code>false</code> if they are not equal. …\n"],["casefold?","Regexp","Regexp.html#method-i-casefold-3F","()","<p>Returns the value of the case-insensitive flag.\n\n<pre class=\"ruby\"><span class=\"ruby-regexp\">/a/</span>.<span class=\"ruby-identifier\">casefold?</span>           <span class=\"ruby-comment\">#=&gt; false</span>\n<span class=\"ruby-regexp\">/a/i</span>.<span class=\"ruby-identifier\">casefold?</span>      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["catch","Kernel","Kernel.html#method-i-catch","(*args)","<p><code>catch</code> executes its block. If <code>throw</code> is not called, the block executes normally, and <code>catch</code> returns the …\n"],["catch","Timeout::Error","Timeout/Error.html#method-c-catch","(*args)",""],["catch","Timeout::Error","Timeout/Error.html#method-c-catch","(*args)",""],["catch","Timeout::Error","Timeout/Error.html#method-c-catch","(*args)",""],["cause","Exception","Exception.html#method-i-cause","()","<p>Returns the previous exception ($!) at the time this exception was raised. This is useful for wrapping …\n"],["cbrt","Math","Math.html#method-c-cbrt","(p1)","<p>Returns the cube root of <code>x</code>.\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (-INFINITY, INFINITY)\n"],["cc_command","MakeMakefile","MakeMakefile.html#method-i-cc_command","(opt=\"\")",""],["cd","Bundler::FileUtils","Bundler/FileUtils.html#method-i-cd","(dir, verbose: nil)","<p>Changes the current directory to the directory <code>dir</code>.\n<p>If this method is called with block, resumes to the …\n"],["cd","Bundler::FileUtils","Bundler/FileUtils.html#method-c-cd","(dir, verbose: nil)","<p>Changes the current directory to the directory <code>dir</code>.\n<p>If this method is called with block, resumes to the …\n"],["cd","FileUtils","FileUtils.html#method-c-cd","(dir, verbose: nil)","<p>Changes the current directory to the directory <code>dir</code>.\n<p>If this method is called with block, resumes to the …\n"],["cd","FileUtils","FileUtils.html#method-i-cd","(dir, verbose: nil)","<p>Changes the current directory to the directory <code>dir</code>.\n<p>If this method is called with block, resumes to the …\n"],["cdata","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-cdata","(content)","<p>Called when &lt;![CDATA[ … ]]&gt; is encountered in a document. @p content “…”\n"],["cdata","REXML::StreamListener","REXML/StreamListener.html#method-i-cdata","(content)","<p>Called when &lt;![CDATA[ … ]]&gt; is encountered in a document. @p content “…”\n"],["cdata?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-cdata-3F","()","<p>Content: [ String text ]\n"],["cdatas","REXML::Element","REXML/Element.html#method-i-cdatas","()","<p>Get an array of all CData children. IMMUTABLE\n"],["cdiv","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-cdiv","(xr, xi, yr, yi)","<p>Complex scalar division.\n"],["ceil","BigDecimal","BigDecimal.html#method-i-ceil","(p1 = v1)","<p>Return the smallest integer greater than or equal to the value, as a BigDecimal.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;3.14159&#39;</span>).<span class=\"ruby-identifier\">ceil</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ceil","Float","Float.html#method-i-ceil","(*args)","<p>Returns the smallest number greater than or equal to <code>float</code> with a precision of <code>ndigits</code> decimal digits …\n"],["ceil","Integer","Integer.html#method-i-ceil","(*args)","<p>Returns the smallest number greater than or equal to <code>int</code> with a precision of <code>ndigits</code> decimal digits (default: …\n"],["ceil","Numeric","Numeric.html#method-i-ceil","(*args)","<p>Returns the smallest number greater than or equal to <code>num</code> with a precision of <code>ndigits</code> decimal digits (default: …\n"],["ceil","Rational","Rational.html#method-i-ceil","(*args)","<p>Returns the smallest number greater than or equal to <code>rat</code> with a precision of <code>ndigits</code> decimal digits (default: …\n"],["ceil","Time","Time.html#method-i-ceil","(*args)","<p>Ceils sub seconds to a given precision in decimal digits (0 digits by default). It returns a new Time …\n"],["ceiling","REXML::Functions","REXML/Functions.html#method-c-ceiling","( number )",""],["center","String","String.html#method-i-center","(*args)","<p>Centers <code>str</code> in <code>width</code>.  If <code>width</code> is greater than the length of <code>str</code>, returns a new String of length <code>width</code> …\n"],["cert","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-cert","()","<p>The X509 certificate for this socket endpoint.\n"],["cert=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-cert-3D","(certificate)","<p>For Net::HTTP parity\n"],["cert_files","Gem::Request","Gem/Request.html#method-i-cert_files","()",""],["cert_path","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-i-cert_path","(certificate)","<p>Returns the path to the trusted <code>certificate</code>\n"],["cert_status","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-cert_status","()","<p>Returns the status of the certificate identified by the certid. The return value may be one of these …\n"],["cert_store=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-cert_store-3D","(store)","<p>Overrides the default SSL certificate store used for verifying connections.\n"],["certid","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-certid","()","<p>Returns all certificate IDs in this request.\n"],["certid","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-certid","()","<p>Returns the CertificateId for which this SingleResponse is.\n"],["certificate=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-certificate-3D","(certificate)","<p>Sets this client&#39;s OpenSSL::X509::Certificate\n"],["certificates","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-certificates","()",""],["certificates=","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-certificates-3D","(p1)",""],["certificates_matching","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-certificates_matching","(filter)",""],["certs","Net::POP3","Net/POP3.html#method-c-certs","()","<p>returns the :ca_file or :ca_path from POP3.ssl_params\n"],["chain","Enumerable","Enumerable.html#method-i-chain","(*args)","<p>Returns an enumerator object generated from this enumerator and given enumerables.\n\n<pre>e = (1..3).chain([4, ...</pre>\n"],["chain","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-chain","()",""],["challenge","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-challenge","()","<p>Returns the challenge string associated with this SPKI.\n"],["challenge","WEBrick::HTTPAuth::BasicAuth","WEBrick/HTTPAuth/BasicAuth.html#method-i-challenge","(req, res)","<p>Returns a challenge response which asks for authentication information\n"],["challenge","WEBrick::HTTPAuth::DigestAuth","WEBrick/HTTPAuth/DigestAuth.html#method-i-challenge","(req, res, stale=false)","<p>Returns a challenge response which asks for authentication information\n"],["challenge=","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-challenge-3D","(p1)","<p>Parameters\n<p><em>str</em> - the challenge string to be set for this instance\n\n<p>Sets the challenge to be associated with …\n"],["change_encoding","RDoc::Encoding","RDoc/Encoding.html#method-c-change_encoding","(text, encoding)","<p>Changes encoding based on <code>encoding</code> without converting and returns new string\n"],["change_privilege","Process::GID","Process/GID.html#method-c-change_privilege","(p1)","<p>Change the current process&#39;s real and effective group ID to that specified by <em>group</em>. Returns the …\n"],["change_privilege","Process::UID","Process/UID.html#method-c-change_privilege","(p1)","<p>Change the current process&#39;s real and effective user ID to that specified by <em>user</em>. Returns the new …\n"],["change_reason","Bundler::Definition","Bundler/Definition.html#method-i-change_reason","()",""],["change_workspace","IRB::Context","IRB/Context.html#method-i-change_workspace","(*_main)","<p>Changes the current workspace to given object or binding.\n<p>If the optional argument is omitted, the workspace …\n"],["changed","Observable","Observable.html#method-i-changed","(state=true)","<p>Set the changed state of this object.  Notifications will be sent only if the changed <code>state</code> is <code>true</code>. …\n"],["changed?","Observable","Observable.html#method-i-changed-3F","()","<p>Returns true if this object&#39;s state has been changed since the last #notify_observers call.\n"],["character","RSS::REXMLLikeXMLParser","RSS/REXMLLikeXMLParser.html#method-i-character","(data)",""],["characters","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-characters","(text)",""],["chardev?","File","File.html#method-c-chardev-3F","(p1)","<p>Returns <code>true</code> if the named file is a character device.\n<p><em>file_name</em> can be an IO object.\n"],["chardev?","File::Stat","File/Stat.html#method-i-chardev-3F","()","<p>Returns <code>true</code> if the file is a character device, <code>false</code> if it isn&#39;t or if the operating system doesn&#39;t …\n"],["chardev?","FileTest","FileTest.html#method-i-chardev-3F","(p1)","<p>Returns <code>true</code> if the named file is a character device.\n<p><em>file_name</em> can be an IO object.\n"],["chardev?","Pathname","Pathname.html#method-i-chardev-3F","()","<p>See FileTest.chardev?.\n"],["charpos","StringScanner","StringScanner.html#method-i-charpos","()","<p>Returns the character position of the scan pointer.  In the &#39;reset&#39; position, this value is zero. …\n"],["chars","ARGF","ARGF.html#method-i-chars","()","<p>This is a deprecated alias for #each_char.\n"],["chars","IO","IO.html#method-i-chars","()","<p>This is a deprecated alias for #each_char.\n"],["chars","String","String.html#method-i-chars","()","<p>Returns an array of characters in <em>str</em>.  This is a shorthand for <code>str.each_char.to_a</code>.\n<p>If a block is given, …\n"],["chars","StringIO","StringIO.html#method-i-chars","()","<p>This is a deprecated alias for #each_char.\n"],["charset","OpenURI::Meta","OpenURI/Meta.html#method-i-charset","()","<p>returns a charset parameter in Content-Type field. It is downcased for canonicalization.\n<p>If charset parameter …\n"],["chdir","Bundler::FileUtils","Bundler/FileUtils.html#method-i-chdir","(dir, verbose: nil)",""],["chdir","Bundler::FileUtils","Bundler/FileUtils.html#method-c-chdir","(dir, verbose: nil)",""],["chdir","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-chdir","(dir, &blk)",""],["chdir","Dir","Dir.html#method-c-chdir","(*args)","<p>Changes the current working directory of the process to the given string. When called without an argument, …\n"],["chdir","FileUtils","FileUtils.html#method-c-chdir","(dir, verbose: nil)",""],["chdir","FileUtils","FileUtils.html#method-i-chdir","(dir, verbose: nil)",""],["chdir","Net::FTP","Net/FTP.html#method-i-chdir","(dirname)","<p>Changes the (remote) directory.\n"],["check","Bundler::CLI","Bundler/CLI.html#method-i-check","()",""],["check","Net::IMAP","Net/IMAP.html#method-i-check","()","<p>Sends a CHECK command to request a checkpoint of the currently selected mailbox.  This performs implementation-specific …\n"],["check","PTY","PTY.html#method-c-check","(p1, p2 = v2)","<p>Checks the status of the child process specified by <code>pid</code>. Returns <code>nil</code> if the process is still alive.\n<p>If …\n"],["check","REXML::Text","REXML/Text.html#method-c-check","(string, pattern, doctype)","<p>check for illegal characters\n"],["check","StringScanner","StringScanner.html#method-i-check","(p1)","<p>This returns the value that #scan would return, without advancing the scan pointer.  The match register …\n"],["check!","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-check-21","()",""],["check_auth_args","Net::SMTP","Net/SMTP.html#method-i-check_auth_args","(user, secret, authtype = DEFAULT_AUTH_TYPE)",""],["check_auth_continue","Net::SMTP","Net/SMTP.html#method-i-check_auth_continue","(res)",""],["check_auth_method","Net::SMTP","Net/SMTP.html#method-i-check_auth_method","(type)",""],["check_auth_response","Net::SMTP","Net/SMTP.html#method-i-check_auth_response","(res)",""],["check_cert","Gem::Security::Policy","Gem/Security/Policy.html#method-i-check_cert","(signer, issuer, time)","<p>Ensures that <code>signer</code> is valid for <code>time</code> and was signed by the <code>issuer</code>. If the <code>issuer</code> is <code>nil</code> no verification …\n"],["check_chain","Gem::Security::Policy","Gem/Security/Policy.html#method-i-check_chain","(chain, time)","<p>Verifies each certificate in <code>chain</code> has signed the following certificate and is valid for the given <code>time</code> …\n"],["check_circular?","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-check_circular-3F","()","<p>Returns true, if circular data structures should be checked, otherwise returns false.\n"],["check_closed","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-check_closed","()","<p>Raises IOError if the TarWriter is closed\n"],["check_continue","Net::SMTP","Net/SMTP.html#method-i-check_continue","(res)",""],["check_credentials_permissions","Gem::ConfigFile","Gem/ConfigFile.html#method-i-check_credentials_permissions","()","<p>Checks the permissions of the credentials file.  If they are not 0600 an error message is displayed and …\n"],["check_data","Gem::Security::Policy","Gem/Security/Policy.html#method-i-check_data","(public_key, digest, signature, data)","<p>Verifies that <code>data</code> matches the <code>signature</code> created by <code>public_key</code> and the <code>digest</code> algorithm.\n"],["check_default_type!","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-check_default_type-21","()","<p>If you want to raise an error when the default value of an option does not match the type call check_default_type …\n"],["check_deprecated_options","Gem::Command","Gem/Command.html#method-i-check_deprecated_options","(options)",""],["check_executable_overwrite","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-i-check_executable_overwrite","(filename)",""],["check_files","RDoc::Options","RDoc/Options.html#method-i-check_files","()","<p>Check that the files on the command line exist\n"],["check_for_activated_spec!","Bundler::Runtime","Bundler/Runtime.html#method-i-check_for_activated_spec-21","(spec)",""],["check_for_corrupt_lockfile","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-check_for_corrupt_lockfile","()",""],["check_for_deployment_mode!","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-check_for_deployment_mode-21","()",""],["check_for_group_conflicts_in_cli_options","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-check_for_group_conflicts_in_cli_options","()",""],["check_for_options_conflicts","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-check_for_options_conflicts","()",""],["check_gems","Gem::Commands::CheckCommand","Gem/Commands/CheckCommand.html#method-i-check_gems","()",""],["check_generator","RDoc::Options","RDoc/Options.html#method-i-check_generator","()","<p>Ensure only one generator is loaded\n"],["check_header","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-check_header","(header_value)",""],["check_headers","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-check_headers","(v)","<p>Checks the headers <code>v</code> component against either\n<p>HEADER_REGEXP\n\n"],["check_headers","URI::MailTo","URI/MailTo.html#method-i-check_headers","(v)","<p>Checks the headers <code>v</code> component against either\n<p>HEADER_REGEXP\n\n"],["check_home_permissions","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-check_home_permissions","()",""],["check_host","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_host","(v)","<p>Checks the host <code>v</code> component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :HOST. …\n"],["check_host","URI::Generic","URI/Generic.html#method-i-check_host","(v)","<p>Checks the host <code>v</code> component for RFC2396 compliance and against the URI::Parser Regexp for :HOST.\n<p>Can not …\n"],["check_insecure_method","DRb::DRbServer","DRb/DRbServer.html#method-i-check_insecure_method","(obj, msg_id)","<p>Check that a method is callable via dRuby.\n<p><code>obj</code> is the object we want to invoke the method on. <code>msg_id</code> is …\n"],["check_inspect_key","PP::PPMethods","PP/PPMethods.html#method-i-check_inspect_key","(id)","<p>Check whether the object_id <code>id</code> is in the current buffer of objects to be pretty printed. Used to break …\n"],["check_installed_gems","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-check_installed_gems","(gem_names)",""],["check_installed_gems?","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-check_installed_gems-3F","()",""],["check_int","Matrix","Matrix.html#method-i-check_int","(val, direction)",""],["check_key","Gem::Security::Policy","Gem/Security/Policy.html#method-i-check_key","(signer, key)","<p>Ensures the public key of <code>key</code> matches the public key in <code>signer</code>\n"],["check_key","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-check_key","()","<p>Raises an exception if the key is invalid.\n<p>See the OpenSSL documentation for EC_KEY_check_key()\n"],["check_la","Racc::State","Racc/State.html#method-i-check_la","(la_rules)",""],["check_modeline","RDoc::Parser","RDoc/Parser.html#method-c-check_modeline","(file_name)","<p>Returns the file type from the modeline in <code>file_name</code>\n"],["check_modify","OpenSSL::Config","OpenSSL/Config.html#method-i-check_modify","()",""],["check_names","RDoc::Task","RDoc/Task.html#method-i-check_names","(names)","<p>Ensures that <code>names</code> only includes names for the :rdoc, :clobber_rdoc and :rerdoc.  If other names are …\n"],["check_names","RDoc::Task","RDoc/Task.html#method-i-check_names","(names)","<p>Ensures that <code>names</code> only includes names for the :rdoc, :clobber_rdoc and :rerdoc.  If other names are …\n"],["check_nonce","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-check_nonce","(p1)","<p>Checks the nonce validity for this request and <em>response</em>.\n<p>The return value is one of the following:\n<p>-1  … &mdash; "],["check_ns","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-check_ns","(tag_name, prefix, ns, require_uri, ignore_unknown_element=nil)",""],["check_opaque","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_opaque","(v)","<p>Checks the opaque <code>v</code> component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for …\n"],["check_opaque","URI::Generic","URI/Generic.html#method-i-check_opaque","(v)","<p>Checks the opaque <code>v</code> component for RFC2396 compliance and against the URI::Parser Regexp for :OPAQUE. …\n"],["check_password","Bundler::URI::File","Bundler/URI/File.html#method-i-check_password","(user)","<p>raise InvalidURIError\n"],["check_password","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_password","(v, user = @user)","<p>Checks the password <code>v</code> component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for …\n"],["check_password","URI::File","URI/File.html#method-i-check_password","(user)","<p>raise InvalidURIError\n"],["check_password","URI::Generic","URI/Generic.html#method-i-check_password","(v, user = @user)","<p>Checks the password <code>v</code> component for RFC2396 compliance and against the URI::Parser Regexp for :USERINFO. …\n"],["check_path","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_path","(v)","<p>Checks the path <code>v</code> component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :ABS_PATH …\n"],["check_path","URI::Generic","URI/Generic.html#method-i-check_path","(v)","<p>Checks the path <code>v</code> component for RFC2396 compliance and against the URI::Parser Regexp for :ABS_PATH and …\n"],["check_port","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_port","(v)","<p>Checks the port <code>v</code> component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :PORT. …\n"],["check_port","URI::Generic","URI/Generic.html#method-i-check_port","(v)","<p>Checks the port <code>v</code> component for RFC2396 compliance and against the URI::Parser Regexp for :PORT.\n<p>Can not …\n"],["check_primary_source_safety","Bundler::Dsl","Bundler/Dsl.html#method-i-check_primary_source_safety","(source_list)",""],["check_private_key","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-check_private_key","(p1)","<p>Returns <code>true</code> if <em>key</em> is the corresponding private key to the Subject Public Key Information, <code>false</code> otherwise. …\n"],["check_range","Matrix","Matrix.html#method-i-check_range","(val, direction)","<p>Returns range or nil\n"],["check_response","Net::SMTP","Net/SMTP.html#method-i-check_response","(res)",""],["check_root","Gem::Security::Policy","Gem/Security/Policy.html#method-i-check_root","(chain, time)","<p>Ensures the root certificate in <code>chain</code> is self-signed and valid for <code>time</code>.\n"],["check_ruby_version","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-check_ruby_version","()",""],["check_rules_nullable","Racc::Grammar","Racc/Grammar.html#method-i-check_rules_nullable","(rules)",""],["check_rules_useless","Racc::Grammar","Racc/Grammar.html#method-i-check_rules_useless","(rules)",""],["check_scheme","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_scheme","(v)","<p>Checks the scheme <code>v</code> component against the Bundler::URI::Parser Regexp for :SCHEME.\n"],["check_scheme","URI::Generic","URI/Generic.html#method-i-check_scheme","(v)","<p>Checks the scheme <code>v</code> component against the URI::Parser Regexp for :SCHEME.\n"],["check_signedness","MakeMakefile","MakeMakefile.html#method-i-check_signedness","(type, headers = nil, opts = nil, &b)","<p>Returns the signedness of the given <code>type</code>.  You may optionally specify additional <code>headers</code> to search in …\n"],["check_sizeof","MakeMakefile","MakeMakefile.html#method-i-check_sizeof","(type, headers = nil, opts = \"\", &b)","<p>Returns the size of the given <code>type</code>.  You may optionally specify additional <code>headers</code> to search in for the …\n"],["check_sources_consistency!","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-check_sources_consistency-21","(options)",""],["check_symbols_nullable","Racc::Grammar","Racc/Grammar.html#method-i-check_symbols_nullable","(symbols)",""],["check_symbols_useless","Racc::Grammar","Racc/Grammar.html#method-i-check_symbols_useless","(s)",""],["check_terminals","Racc::SymbolTable","Racc/SymbolTable.html#method-i-check_terminals","()",""],["check_termination","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-check_termination","(&block)",""],["check_to","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-check_to","(v)","<p>Checks the to <code>v</code> component.\n"],["check_to","URI::MailTo","URI/MailTo.html#method-i-check_to","(v)","<p>Checks the to <code>v</code> component.\n"],["check_trust","Gem::Security::Policy","Gem/Security/Policy.html#method-i-check_trust","(chain, digester, trust_dir)","<p>Ensures the root of <code>chain</code> has a trusted certificate in <code>trust_dir</code> and the digests of the two certificates …\n"],["check_trust_policy","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-check_trust_policy","()",""],["check_typecode","Bundler::URI::FTP","Bundler/URI/FTP.html#method-i-check_typecode","(v)","<p>Validates typecode <code>v</code>, returns <code>true</code> or <code>false</code>.\n"],["check_typecode","URI::FTP","URI/FTP.html#method-i-check_typecode","(v)","<p>Validates typecode <code>v</code>, returns <code>true</code> or <code>false</code>.\n"],["check_typo_squatting","Gem::Commands::SourcesCommand","Gem/Commands/SourcesCommand.html#method-i-check_typo_squatting","(source)",""],["check_unknown_options!","Bundler::Thor","Bundler/Thor.html#method-c-check_unknown_options-21","(options = {})","<p>Extend check unknown options to accept a hash of conditions.\n<p>Parameters\n<p>options&lt;Hash&gt;: A hash containing …\n"],["check_unknown_options!","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-check_unknown_options-21","()","<p>If you want to raise an error for unknown options, call check_unknown_options! This is disabled by default …\n"],["check_until","StringScanner","StringScanner.html#method-i-check_until","(p1)","<p>This returns the value that #scan_until would return, without advancing the scan pointer.  The match …\n"],["check_useless","Racc::States","Racc/States.html#method-i-check_useless","()",""],["check_user","Bundler::URI::File","Bundler/URI/File.html#method-i-check_user","(user)","<p>raise InvalidURIError\n"],["check_user","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_user","(v)","<p>Checks the user <code>v</code> component for RFC2396 compliance and against the Bundler::URI::Parser Regexp for :USERINFO. …\n"],["check_user","URI::File","URI/File.html#method-i-check_user","(user)","<p>raise InvalidURIError\n"],["check_user","URI::Generic","URI/Generic.html#method-i-check_user","(v)","<p>Checks the user <code>v</code> component for RFC2396 compliance and against the URI::Parser Regexp for :USERINFO. …\n"],["check_userinfo","Bundler::URI::File","Bundler/URI/File.html#method-i-check_userinfo","(user)","<p>raise InvalidURIError\n"],["check_userinfo","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-check_userinfo","(user, password = nil)","<p>Checks the <code>user</code> and <code>password</code>.\n<p>If <code>password</code> is not provided, then <code>user</code> is split, using Bundler::URI::Generic.split_userinfo …\n"],["check_userinfo","URI::File","URI/File.html#method-i-check_userinfo","(user)","<p>raise InvalidURIError\n"],["check_userinfo","URI::Generic","URI/Generic.html#method-i-check_userinfo","(user, password = nil)","<p>Checks the <code>user</code> and <code>password</code>.\n<p>If <code>password</code> is not provided, then <code>user</code> is split, using URI::Generic.split_userinfo …\n"],["check_validity","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-check_validity","(p1 = v1, p2 = v2)","<p>Checks the validity of thisUpdate and nextUpdate fields of this SingleResponse. This checks the current …\n"],["check_winsize_changed","IO","IO.html#method-i-check_winsize_changed","()",""],["checkbox","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-checkbox","(name = \"\", value = nil, checked = nil)","<p>Generate a Checkbox Input element as a string.\n<p>The attributes of the element can be specified as three …\n"],["checkbox_group","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-checkbox_group","(name = \"\", *values)","<p>Generate a sequence of checkbox elements, as a String.\n<p>The checkboxes will all have the same <code>name</code> attribute. …\n"],["checkin","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-i-checkin","()",""],["checkout","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-i-checkout","(options = {})",""],["checkout","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-checkout","()",""],["checksum_for_file","Bundler::CompactIndexClient::Updater","Bundler/CompactIndexClient/Updater.html#method-i-checksum_for_file","(path)",""],["checksum_type","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-i-checksum_type","(checksum)",""],["checksums","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-checksums","()",""],["child","REXML::XPathParser","REXML/XPathParser.html#method-i-child","(nodeset)",""],["child_name","RDoc::Context","RDoc/Context.html#method-i-child_name","(name)","<p>Creates the full name for a child with <code>name</code>\n"],["children","Dir","Dir.html#method-c-children","(*args)","<p>Returns an array containing all of the filenames except for “.” and “..” in the given …\n"],["children","Dir","Dir.html#method-i-children","()","<p>Returns an array containing all of the filenames except for “.” and “..” in this …\n"],["children","Pathname","Pathname.html#method-i-children","(with_directory=true)","<p>Returns the children of the directory (files and subdirectories, not recursive) as an array of Pathname …\n"],["children","REXML::Light::Node","REXML/Light/Node.html#method-i-children","()",""],["children","REXML::Parent","REXML/Parent.html#method-i-children","()",""],["children","RSS::Element","RSS/Element.html#method-i-children","()",""],["children","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-children","()","<p>Returns AST nodes under this one.  Each kind of node has different children, depending on what kind of …\n"],["chmod","Bundler::FileUtils","Bundler/FileUtils.html#method-c-chmod","(mode, list, noop: nil, verbose: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n<p><code>mode</code> is the …\n"],["chmod","Bundler::FileUtils","Bundler/FileUtils.html#method-i-chmod","(mode, list, noop: nil, verbose: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n<p><code>mode</code> is the …\n"],["chmod","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-chmod","(path, mode, config = {})","<p>Changes the mode of the given file or directory.\n<p>Parameters\n<p>mode&lt;Integer&gt; &mdash; the file mode\n"],["chmod","File","File.html#method-c-chmod","(*args)","<p>Changes permission bits on the named file(s) to the bit pattern represented by <em>mode_int</em>. Actual effects …\n"],["chmod","File","File.html#method-i-chmod","(p1)","<p>Changes permission bits on <em>file</em> to the bit pattern represented by <em>mode_int</em>. Actual effects are platform …\n"],["chmod","FileUtils","FileUtils.html#method-c-chmod","(mode, list, noop: nil, verbose: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n<p><code>mode</code> is the …\n"],["chmod","FileUtils","FileUtils.html#method-i-chmod","(mode, list, noop: nil, verbose: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n<p><code>mode</code> is the …\n"],["chmod","Pathname","Pathname.html#method-i-chmod","(p1)","<p>Changes file permissions.\n<p>See File.chmod.\n"],["chmod_R","Bundler::FileUtils","Bundler/FileUtils.html#method-i-chmod_R","(mode, list, noop: nil, verbose: nil, force: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">chmod_R</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["chmod_R","Bundler::FileUtils","Bundler/FileUtils.html#method-c-chmod_R","(mode, list, noop: nil, verbose: nil, force: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">chmod_R</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["chmod_R","FileUtils","FileUtils.html#method-i-chmod_R","(mode, list, noop: nil, verbose: nil, force: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">chmod_R</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["chmod_R","FileUtils","FileUtils.html#method-c-chmod_R","(mode, list, noop: nil, verbose: nil, force: nil)","<p>Changes permission bits on the named files (in <code>list</code>) to the bit pattern represented by <code>mode</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">chmod_R</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["chomp","Kernel","Kernel.html#method-i-chomp","(*args)","<p>Equivalent to <code>$_ = $_.chomp(<em>string</em>)</code>. See String#chomp. Available only when -p/-n command line option …\n"],["chomp","String","String.html#method-i-chomp","(*args)","<p>Returns a new String with the given record separator removed from the end of <em>str</em> (if present). If <code>$/</code> …\n"],["chomp!","String","String.html#method-i-chomp-21","(*args)","<p>Modifies <em>str</em> in place as described for String#chomp, returning <em>str</em>, or <code>nil</code> if no modifications were made. …\n"],["choose","Random::Formatter","Random/Formatter.html#method-i-choose","(source, n)","<p>SecureRandom.choose generates a string that randomly draws from a source array of characters.\n<p>The argument …\n"],["choose_from_list","Gem::StreamUI","Gem/StreamUI.html#method-i-choose_from_list","(question, list)","<p>Choose from a list of options.  <code>question</code> is a prompt displayed above the list.  <code>list</code> is a list of option …\n"],["choose_from_list","Gem::UserInteraction","Gem/UserInteraction.html#method-i-choose_from_list","(question, list)","<p>Asks the user to answer <code>question</code> with an answer from the given <code>list</code>.\n"],["chop","Kernel","Kernel.html#method-i-chop","()","<p>Equivalent to <code>($_.dup).chop!</code>, except <code>nil</code> is never returned. See String#chop!. Available only when -p/-n …\n"],["chop","String","String.html#method-i-chop","()","<p>Returns a new String with the last character removed.  If the string ends with <code>\\r\\n</code>, both characters …\n"],["chop!","String","String.html#method-i-chop-21","()","<p>Processes <em>str</em> as for String#chop, returning <em>str</em>, or <code>nil</code> if <em>str</em> is the empty string.  See also String#chomp! …\n"],["chown","Bundler::FileUtils","Bundler/FileUtils.html#method-c-chown","(user, group, list, noop: nil, verbose: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code>.  <code>user</code> and …\n"],["chown","Bundler::FileUtils","Bundler/FileUtils.html#method-i-chown","(user, group, list, noop: nil, verbose: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code>.  <code>user</code> and …\n"],["chown","File","File.html#method-c-chown","(*args)","<p>Changes the owner and group of the named file(s) to the given numeric owner and group id&#39;s. Only …\n"],["chown","File","File.html#method-i-chown","(p1, p2)","<p>Changes the owner and group of <em>file</em> to the given numeric owner and group id&#39;s. Only a process with …\n"],["chown","FileUtils","FileUtils.html#method-c-chown","(user, group, list, noop: nil, verbose: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code>.  <code>user</code> and …\n"],["chown","FileUtils","FileUtils.html#method-i-chown","(user, group, list, noop: nil, verbose: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code>.  <code>user</code> and …\n"],["chown","Pathname","Pathname.html#method-i-chown","(p1, p2)","<p>Change owner and group of the file.\n<p>See File.chown.\n"],["chown_R","Bundler::FileUtils","Bundler/FileUtils.html#method-i-chown_R","(user, group, list, noop: nil, verbose: nil, force: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code> recursively. …\n"],["chown_R","Bundler::FileUtils","Bundler/FileUtils.html#method-c-chown_R","(user, group, list, noop: nil, verbose: nil, force: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code> recursively. …\n"],["chown_R","FileUtils","FileUtils.html#method-c-chown_R","(user, group, list, noop: nil, verbose: nil, force: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code> recursively. …\n"],["chown_R","FileUtils","FileUtils.html#method-i-chown_R","(user, group, list, noop: nil, verbose: nil, force: nil)","<p>Changes owner and group on the named files (in <code>list</code>) to the user <code>user</code> and the group <code>group</code> recursively. …\n"],["chr","Integer","Integer.html#method-i-chr","(*args)","<p>Returns a string containing the character represented by the <code>int</code>&#39;s value according to <code>encoding</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">65</span>.<span class=\"ruby-identifier\">chr</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["chr","String","String.html#method-i-chr","()","<p>Returns a one-character string at the beginning of the string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-string\">&quot;abcde&quot;</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">chr</span>    <span class=\"ruby-comment\">#=&gt; &quot;a&quot;</span>\n</pre>\n"],["chroot","Dir","Dir.html#method-c-chroot","(p1)","<p>Changes this process&#39;s idea of the file system root. Only a privileged process may make this call. …\n"],["chruby_version","Bundler::Env","Bundler/Env.html#method-c-chruby_version","()",""],["chunk","Enumerable","Enumerable.html#method-i-chunk","()","<p>Enumerates over the items, chunking them together based on the return value of the block.\n<p>Consecutive …\n"],["chunk","Enumerator::Lazy","Enumerator/Lazy.html#method-i-chunk","(*args)","<p>Like Enumerable#chunk, but chains operation to be lazy-evaluated.\n"],["chunk_while","Enumerable","Enumerable.html#method-i-chunk_while","()","<p>Creates an enumerator for each chunked elements. The beginnings of chunks are defined by the block.\n<p>This …\n"],["chunk_while","Enumerator::Lazy","Enumerator/Lazy.html#method-i-chunk_while","(*args)","<p>Like Enumerable#chunk_while, but chains operation to be lazy-evaluated.\n"],["chunked=","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-chunked-3D","(val)","<p>Enables chunked transfer encoding.\n"],["chunked?","Net::HTTPHeader","Net/HTTPHeader.html#method-i-chunked-3F","()","<p>Returns “true” if the “transfer-encoding” header is present and set to “chunked”. …\n"],["chunked?","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-chunked-3F","()","<p>Will this response body be returned using chunked transfer-encoding?\n"],["cipher","OpenSSL::Engine","OpenSSL/Engine.html#method-i-cipher","(p1)","<p>Returns a new instance of OpenSSL::Cipher by <em>name</em>, if it is available in this engine.\n<p>An EngineError will …\n"],["cipher","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-cipher","()","<p>Returns the cipher suite actually used in the current session, or nil if no session has been established. …\n"],["cipher=","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-cipher-3D","(p1)",""],["ciphers","OpenSSL::Cipher","OpenSSL/Cipher.html#method-c-ciphers","()","<p>Returns the names of all available ciphers in an array.\n"],["ciphers","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-ciphers","()","<p>The list of cipher suites configured for this context.\n"],["ciphers=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-ciphers-3D","(ciphers)","<p>The ciphers allowed for SSL connections\n"],["ciphers=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-ciphers-3D","(p1)","<p>Sets the list of available cipher suites for this context.  Note in a server context some ciphers require …\n"],["cis","Bundler::Fetcher","Bundler/Fetcher.html#method-i-cis","()",""],["civil","Date","Date.html#method-c-civil","(*args)","<p>Creates a date object denoting the given calendar date.\n<p>In this class, BCE years are counted astronomically. …\n"],["civil","DateTime","DateTime.html#method-c-civil","(*args)","<p>Creates a DateTime object denoting the given calendar date.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>)    <span class=\"ruby-comment\">#=&gt; #&lt;DateTime: ...</span>\n</pre>\n"],["clamp","Comparable","Comparable.html#method-i-clamp","(p1, p2 = v2)","<p>In <code>(min, max)</code> form, returns <em>min</em> if <em>obj</em> <code>&lt;=&gt;</code> <em>min</em> is less than zero, <em>max</em> if <em>obj</em> <code>&lt;=&gt;</code> <em>max</em> is greater …\n"],["class","Object","Object.html#method-i-class","()","<p>Returns the class of <em>obj</em>. This method must always be called with an explicit receiver, as #class is also …\n"],["class_attributes","RDoc::Context","RDoc/Context.html#method-i-class_attributes","()","<p>Class attributes\n"],["class_eval","Module","Module.html#method-i-class_eval","(*args)","<p>Evaluates the string or block in the context of <em>mod</em>, except that when a block is given, constant/class …\n"],["class_exec","Module","Module.html#method-i-class_exec","(*args)","<p>Evaluates the given block in the context of the class/module. The method defined in the block will belong …\n"],["class_file","RDoc::Store","RDoc/Store.html#method-i-class_file","(klass_name)","<p>Path to the ri data for <code>klass_name</code>\n"],["class_method_list","RDoc::Context","RDoc/Context.html#method-i-class_method_list","()","<p>Class methods\n"],["class_methods","RDoc::Store","RDoc/Store.html#method-i-class_methods","()","<p>Class methods cache accessor.  Maps a class to an Array of its class methods (not full name).\n"],["class_name","Gem::Ext::Builder","Gem/Ext/Builder.html#method-c-class_name","()",""],["class_name","RSS::BaseListener","RSS/BaseListener.html#method-c-class_name","(uri, tag_name)","<p>retrieve class_name for the supplied uri and tag_name If it doesn&#39;t exist, capitalize the tag_name …\n"],["class_option","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-class_option","(name, options = {})","<p>Adds an option to the set of class options\n<p>Parameters\n<p>name&lt;Symbol&gt; &mdash; The name of the argument.\n"],["class_options","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-class_options","(options = nil)","<p>Adds a bunch of options to the set of class options.\n\n<pre>class_options :foo =&gt; false, :bar =&gt; :required, :baz ...</pre>\n"],["class_path","RDoc::Store","RDoc/Store.html#method-i-class_path","(klass_name)","<p>Path where data for <code>klass_name</code> will be stored (methods or class data)\n"],["class_variable_defined?","Module","Module.html#method-i-class_variable_defined-3F","(p1)","<p>Returns <code>true</code> if the given class variable is defined in <em>obj</em>. String arguments are converted to symbols. …\n"],["class_variable_get","Module","Module.html#method-i-class_variable_get","(p1)","<p>Returns the value of the given class variable (or throws a NameError exception). The <code>@@</code> part of the variable …\n"],["class_variable_set","Module","Module.html#method-i-class_variable_set","(p1, p2)","<p>Sets the class variable named by <em>symbol</em> to the given object. If the class variable name is passed as …\n"],["class_variables","Module","Module.html#method-i-class_variables","(*args)","<p>Returns an array of the names of class variables in <em>mod</em>. This includes the names of class variables in …\n"],["classes","RDoc::Context","RDoc/Context.html#method-i-classes","()","<p>Array of classes in this context\n"],["classes_and_modules","RDoc::Context","RDoc/Context.html#method-i-classes_and_modules","()","<p>All classes and modules in this namespace\n"],["classes_hash","RDoc::Context","RDoc/Context.html#method-i-classes_hash","()","<p>Hash of classes keyed by class name\n"],["classes_hash","RDoc::Store","RDoc/Store.html#method-i-classes_hash","()","<p>Hash of all classes known to RDoc\n"],["classify","Set","Set.html#method-i-classify","()","<p>Classifies the set by the return value of the given block and returns a hash of {value =&gt; set of elements} …\n"],["clean","Bundler::CLI","Bundler/CLI.html#method-i-clean","()",""],["clean","Bundler::Runtime","Bundler/Runtime.html#method-i-clean","(dry_run = false)",""],["clean","Syslog::Logger::Formatter","Syslog/Logger/Formatter.html#method-i-clean","(message)","<p>Clean up messages so they&#39;re nice and pretty.\n"],["clean?","Bundler::GemHelper","Bundler/GemHelper.html#method-i-clean-3F","()",""],["clean_after_install?","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-clean_after_install-3F","()",""],["clean_env","Bundler","Bundler.html#method-c-clean_env","()","<p>@deprecated Use `unbundled_env` instead\n"],["clean_exec","Bundler","Bundler.html#method-c-clean_exec","(*args)","<p>@deprecated Use `unbundled_exec` instead\n"],["clean_gems","Gem::Commands::CleanupCommand","Gem/Commands/CleanupCommand.html#method-i-clean_gems","()",""],["clean_load_path","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-clean_load_path","()",""],["clean_system","Bundler","Bundler.html#method-c-clean_system","(*args)","<p>@deprecated Use `unbundled_system` instead\n"],["clean_text","Gem::Text","Gem/Text.html#method-i-clean_text","(text)","<p>Remove any non-printable characters and make the text suitable for printing.\n"],["cleanpath","Pathname","Pathname.html#method-i-cleanpath","(consider_symlink=false)","<p>Returns clean pathname of <code>self</code> with consecutive slashes and useless dots removed.  The filesystem is …\n"],["cleanup","OpenSSL::Engine","OpenSSL/Engine.html#method-c-cleanup","()","<p>It is only necessary to run cleanup when engines are loaded via OpenSSL::Engine.load. However, running …\n"],["cleanup","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-cleanup","()",""],["clear","Array","Array.html#method-i-clear","()","<p>Removes all elements from <code>self</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [ <span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;b&quot;</span>, <span class=\"ruby-string\">&quot;c&quot;</span>, <span class=\"ruby-string\">&quot;d&quot;</span>, <span class=\"ruby-string\">&quot;e&quot;</span> ]\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">clear</span>    <span class=\"ruby-comment\">#=&gt; [ ]</span>\n</pre>\n"],["clear","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-clear","()",""],["clear","DBM","DBM.html#method-i-clear","()","<p>Deletes all data from the database.\n"],["clear","ENV","ENV.html#method-c-clear","()","<p>Removes every environment variable; returns ENV:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">replace</span>(<span class=\"ruby-string\">&#39;foo&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;0&#39;</span>, <span class=\"ruby-string\">&#39;bar&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;1&#39;</span>)\n<span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">size</span> <span class=\"ruby-comment\"># =&gt; ...</span>\n</pre>\n"],["clear","GC::Profiler","GC/Profiler.html#method-c-clear","()","<p>Clears the GC profiler data.\n"],["clear","GDBM","GDBM.html#method-i-clear","()","<p>Removes all the key-value pairs within <em>gdbm</em>.\n"],["clear","Gem::DependencyList","Gem/DependencyList.html#method-i-clear","()",""],["clear","Gem::SourceList","Gem/SourceList.html#method-i-clear","()","<p>Removes all sources from the SourceList.\n"],["clear","Hash","Hash.html#method-i-clear","()","<p>Removes all key-value pairs from <em>hsh</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;b&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">200</span> }   <span class=\"ruby-comment\">#=&gt; {&quot;a&quot;=&gt;100, &quot;b&quot;=&gt;200}</span>\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">clear</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["clear","IRB::Color","IRB/Color.html#method-c-clear","()",""],["clear","Queue","Queue.html#method-i-clear","()","<p>Removes all objects from the queue.\n"],["clear","Racc::ISet","Racc/ISet.html#method-i-clear","()",""],["clear","SDBM","SDBM.html#method-i-clear","()","<p>Deletes all data from the database.\n"],["clear","Set","Set.html#method-i-clear","()","<p>Removes all elements and returns self.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">set</span> = <span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-string\">&#39;c&#39;</span>, <span class=\"ruby-value\">:s</span>]             <span class=\"ruby-comment\">#=&gt; #&lt;Set: {1, &quot;c&quot;, :s}&gt;</span>\n<span class=\"ruby-identifier\">set</span>.<span class=\"ruby-identifier\">clear</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["clear","SizedQueue","SizedQueue.html#method-i-clear","()","<p>Removes all objects from the queue.\n"],["clear","String","String.html#method-i-clear","()","<p>Makes string empty.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-string\">&quot;abcde&quot;</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">clear</span>    <span class=\"ruby-comment\">#=&gt; &quot;&quot;</span>\n</pre>\n"],["clear","StringScanner","StringScanner.html#method-i-clear","()","<p>Equivalent to #terminate. This method is obsolete; use #terminate instead.\n"],["clear_bit!","OpenSSL::BN","OpenSSL/BN.html#method-i-clear_bit-21","(p1)",""],["clear_cache","REXML::Text","REXML/Text.html#method-i-clear_cache","()",""],["clear_comment","RDoc::ClassModule","RDoc/ClassModule.html#method-i-clear_comment","()","<p>Clears the comment. Used by the Ruby parser.\n"],["clear_comments","OpenSSL::Config","OpenSSL/Config.html#method-c-clear_comments","(line)",""],["clear_default_specs","Gem","Gem.html#method-c-clear_default_specs","()","<p>Clear default gem related variables. It is for test\n"],["clear_gemspec_cache","Bundler","Bundler.html#method-c-clear_gemspec_cache","()",""],["clear_paths","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-clear_paths","()",""],["clear_paths","Gem","Gem.html#method-c-clear_paths","()","<p>Reset the <code>dir</code> and <code>path</code> values.  The next time <code>dir</code> or <code>path</code> is requested, the values will be calculated …\n"],["clear_screen","IO","IO.html#method-i-clear_screen","()",""],["cli_help","Bundler::CLI","Bundler/CLI.html#method-i-cli_help","()",""],["client_ca","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-client_ca","()","<p>Returns the list of client CAs. Please note that in contrast to SSLContext#client_ca= no array of X509::Certificate …\n"],["client_cert_cb","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-client_cert_cb","()",""],["client_error?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-i-client_error-3F","(code)","<p>Is <code>code</code> a client error status?\n"],["client_error?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-client_error-3F","(code)","<p>Is <code>code</code> a client error status?\n"],["client_fetcher","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-client_fetcher","()",""],["clobber_task_description","RDoc::Task","RDoc/Task.html#method-i-clobber_task_description","()","<p>Task description for the clobber rdoc task or its renamed equivalent\n"],["clobber_task_description","RDoc::Task","RDoc/Task.html#method-i-clobber_task_description","()","<p>Task description for the clobber rdoc task or its renamed equivalent\n"],["clobber_task_name","RDoc::Task","RDoc/Task.html#method-i-clobber_task_name","()",""],["clobber_task_name","RDoc::Task","RDoc/Task.html#method-i-clobber_task_name","()",""],["clock_getres","Process","Process.html#method-c-clock_getres","(*args)","<p>Returns the time resolution returned by POSIX clock_getres() function.\n<p><code>clock_id</code> specifies a kind of clock. …\n"],["clock_gettime","Process","Process.html#method-c-clock_gettime","(*args)","<p>Returns a time returned by POSIX clock_gettime() function.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">clock_gettime</span>(<span class=\"ruby-constant\">Process</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">CLOCK_MONOTONIC</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["clone","BigDecimal","BigDecimal.html#method-i-clone","()",""],["clone","Method","Method.html#method-i-clone","()","<p>Returns a clone of this method.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">class</span> <span class=\"ruby-constant\">A</span>\n  <span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">foo</span>\n    <span class=\"ruby-keyword\">return</span> <span class=\"ruby-string\">&quot;bar&quot;</span>\n  <span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-keyword\">end</span>\n\n<span class=\"ruby-identifier\">m</span> = <span class=\"ruby-constant\">A</span>.<span class=\"ruby-identifier\">new</span>.<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:foo</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">call</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["clone","Numeric","Numeric.html#method-i-clone","(*args)","<p>Returns the receiver.  <code>freeze</code> cannot be <code>false</code>.\n"],["clone","Object","Object.html#method-i-clone","(*args)","<p>Produces a shallow copy of <em>obj</em>—the instance variables of <em>obj</em> are copied, but not the objects they reference. …\n"],["clone","REXML::Attribute","REXML/Attribute.html#method-i-clone","()","<p>Returns a copy of this attribute\n"],["clone","REXML::CData","REXML/CData.html#method-i-clone","()","<p>Make a copy of this object\n<p><em>Examples</em>\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-constant\">CData</span>.<span class=\"ruby-identifier\">new</span>( <span class=\"ruby-string\">&quot;Some text&quot;</span> )\n<span class=\"ruby-identifier\">d</span> = <span class=\"ruby-identifier\">c</span>.<span class=\"ruby-identifier\">clone</span>\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">to_s</span>        <span class=\"ruby-comment\"># -&gt; &quot;Some text&quot;</span>\n</pre>\n"],["clone","REXML::Comment","REXML/Comment.html#method-i-clone","()",""],["clone","REXML::DocType","REXML/DocType.html#method-i-clone","()",""],["clone","REXML::Document","REXML/Document.html#method-i-clone","()","<p>Should be obvious\n"],["clone","REXML::Element","REXML/Element.html#method-i-clone","()","<p>Creates a shallow copy of self.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Document</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-string\">&quot;&lt;a&gt;&lt;b/&gt;&lt;b/&gt;&lt;c&gt;&lt;d/&gt;&lt;/c&gt;&lt;/a&gt;&quot;</span>\n<span class=\"ruby-identifier\">new_a</span> = <span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">root</span>.<span class=\"ruby-identifier\">clone</span>\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["clone","REXML::Instruction","REXML/Instruction.html#method-i-clone","()",""],["clone","REXML::Text","REXML/Text.html#method-i-clone","()",""],["clone","REXML::XMLDecl","REXML/XMLDecl.html#method-i-clone","()",""],["clone","Singleton","Singleton.html#method-i-clone","()","<p>Raises a TypeError to prevent cloning.\n"],["clone","UnboundMethod","UnboundMethod.html#method-i-clone","()","<p>Returns a clone of this method.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">class</span> <span class=\"ruby-constant\">A</span>\n  <span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">foo</span>\n    <span class=\"ruby-keyword\">return</span> <span class=\"ruby-string\">&quot;bar&quot;</span>\n  <span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-keyword\">end</span>\n\n<span class=\"ruby-identifier\">m</span> = <span class=\"ruby-constant\">A</span>.<span class=\"ruby-identifier\">new</span>.<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:foo</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">call</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["close","ARGF","ARGF.html#method-i-close","()","<p>Closes the current file and skips to the next file in ARGV. If there are no more files to open, just …\n"],["close","CGI::Session","CGI/Session.html#method-i-close","()","<p>Store session data on the server and close the session storage. For some session storage types, this …\n"],["close","CGI::Session::FileStore","CGI/Session/FileStore.html#method-i-close","()","<p>Update and close the session&#39;s FileStore file.\n"],["close","CGI::Session::MemoryStore","CGI/Session/MemoryStore.html#method-i-close","()","<p>Close session storage.\n<p>A no-op.\n"],["close","CGI::Session::NullStore","CGI/Session/NullStore.html#method-i-close","()","<p>Close session storage.\n<p>A no-op.\n"],["close","CGI::Session::PStore","CGI/Session/PStore.html#method-i-close","()","<p>Update and close the session&#39;s PStore file.\n"],["close","DBM","DBM.html#method-i-close","()","<p>Closes the database.\n"],["close","Dir","Dir.html#method-i-close","()","<p>Closes the directory stream. Calling this method on closed Dir object is ignored since Ruby 2.3.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testdir&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["close","Fiddle::Handle","Fiddle/Handle.html#method-i-close","()","<p>Close this handle.\n<p>Calling close more than once will raise a Fiddle::DLError exception.\n"],["close","GDBM","GDBM.html#method-i-close","()","<p>Closes the associated database file.\n"],["close","Gem::Package::TarReader","Gem/Package/TarReader.html#method-i-close","()","<p>Close the tar file\n"],["close","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-close","()","<p>Closes the tar entry\n"],["close","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-close","()","<p>Closes the TarWriter\n"],["close","Gem::SilentUI","Gem/SilentUI.html#method-i-close","()",""],["close","Gem::StreamUI","Gem/StreamUI.html#method-i-close","()",""],["close","IO","IO.html#method-i-close","()","<p>Closes <em>ios</em> and flushes any pending writes to the operating system. The stream is unavailable for any …\n"],["close","Logger","Logger.html#method-i-close","()","<p>Close the logging device.\n"],["close","Net::FTP","Net/FTP.html#method-i-close","()","<p>Closes the connection.  Further operations are impossible until you open a new connection with #connect …\n"],["close","Net::IMAP","Net/IMAP.html#method-i-close","()","<p>Sends a CLOSE command to close the currently selected mailbox. The CLOSE command permanently removes …\n"],["close","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-close","()","<p>Closes the SSLSocket and flushes any unwritten data.\n"],["close","OpenSSL::SSL::SSLServer","OpenSSL/SSL/SSLServer.html#method-i-close","()","<p>See IO#close for details.\n"],["close","Queue","Queue.html#method-i-close","()","<p>Closes the queue. A closed queue cannot be re-opened.\n<p>After the call to close completes, the following …\n"],["close","Resolv::DNS","Resolv/DNS.html#method-i-close","()","<p>Closes the DNS resolver.\n"],["close","SDBM","SDBM.html#method-i-close","()","<p>Closes the database file.\n<p>Raises SDBMError if the database is already closed.\n"],["close","SOCKSSocket","SOCKSSocket.html#method-i-close","()","<p>Closes the SOCKS connection.\n"],["close","SizedQueue","SizedQueue.html#method-i-close","()","<p>Similar to Queue#close.\n<p>The difference is behavior with waiting enqueuing threads.\n<p>If there are waiting …\n"],["close","StringIO","StringIO.html#method-i-close","()","<p>Closes a StringIO. The stream is unavailable for any further data operations; an <code>IOError</code> is raised if …\n"],["close","Syslog","Syslog.html#method-c-close","()","<p>Closes the syslog facility. Raises a runtime exception if it is not open.\n"],["close","Tempfile","Tempfile.html#method-i-close","(unlink_now=false)","<p>Closes the file. If <code>unlink_now</code> is true, then the file will be unlinked (deleted) after closing. Of course, …\n"],["close","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-close","()","<p>Closes the logger (also closes the log device associated to the logger)\n"],["close","Zlib::GzipFile","Zlib/GzipFile.html#method-i-close","()","<p>Closes the GzipFile object. This method calls close method of the associated IO object. Returns the associated …\n"],["close","Zlib::ZStream","Zlib/ZStream.html#method-i-close","()","<p>Closes the stream. All operations on the closed stream will raise an exception.\n"],["close!","Tempfile","Tempfile.html#method-i-close-21","()","<p>Closes and unlinks (deletes) the file. Has the same effect as called <code>close(true)</code>.\n"],["close_all","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-close_all","()",""],["close_enabled?","Fiddle::Handle","Fiddle/Handle.html#method-i-close_enabled-3F","()","<p>Returns <code>true</code> if dlclose() will be called when this handle is garbage collected.\n<p>See man(3) dlclose() for …\n"],["close_on_exec=","IO","IO.html#method-i-close_on_exec-3D","(p1)","<p>Sets a close-on-exec flag.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;/dev/null&quot;</span>)\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">close_on_exec</span> = <span class=\"ruby-keyword\">true</span>\n<span class=\"ruby-identifier\">system</span>(<span class=\"ruby-string\">&quot;cat&quot;</span>, <span class=\"ruby-node\">&quot;/proc/self/fd/#{f.fileno}&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["close_on_exec?","IO","IO.html#method-i-close_on_exec-3F","()","<p>Returns <code>true</code> if <em>ios</em> will be closed on exec.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;/dev/null&quot;</span>)\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">close_on_exec?</span>                 <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["close_read","BasicSocket","BasicSocket.html#method-i-close_read","()","<p>Disallows further read using shutdown system call.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s1</span>, <span class=\"ruby-identifier\">s2</span> = <span class=\"ruby-constant\">UNIXSocket</span>.<span class=\"ruby-identifier\">pair</span>\n<span class=\"ruby-identifier\">s1</span>.<span class=\"ruby-identifier\">close_read</span>\n<span class=\"ruby-identifier\">s2</span>.<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["close_read","IO","IO.html#method-i-close_read","()","<p>Closes the read end of a duplex I/O stream (i.e., one that contains both a read and a write stream, such …\n"],["close_read","StringIO","StringIO.html#method-i-close_read","()","<p>Closes the read end of a StringIO.  Will raise an <code>IOError</code> if the receiver is not readable.\n"],["close_write","BasicSocket","BasicSocket.html#method-i-close_write","()","<p>Disallows further write using shutdown system call.\n\n<pre>UNIXSocket.pair {|s1, s2|\n  s1.print &quot;ping&quot;\n  s1.close_write ...</pre>\n"],["close_write","IO","IO.html#method-i-close_write","()","<p>Closes the write end of a duplex I/O stream (i.e., one that contains both a read and a write stream, …\n"],["close_write","StringIO","StringIO.html#method-i-close_write","()","<p>Closes the write end of a StringIO.  Will raise an  <code>IOError</code> if the receiver is not writeable.\n"],["closed?","ARGF","ARGF.html#method-i-closed-3F","()","<p>Returns <em>true</em> if the current file has been closed; <em>false</em> otherwise. Use <code>ARGF.close</code> to actually close the …\n"],["closed?","DBM","DBM.html#method-i-closed-3F","()","<p>Returns true if the database is closed, false otherwise.\n"],["closed?","GDBM","GDBM.html#method-i-closed-3F","()","<p>Returns true if the associated database file has been closed.\n"],["closed?","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-closed-3F","()","<p>Is the tar entry closed?\n"],["closed?","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-closed-3F","()","<p>Is the TarWriter closed?\n"],["closed?","IO","IO.html#method-i-closed-3F","()","<p>Returns <code>true</code> if <em>ios</em> is completely closed (for duplex streams, both reader and writer), <code>false</code> otherwise. …\n"],["closed?","Net::FTP","Net/FTP.html#method-i-closed-3F","()","<p>Returns <code>true</code> iff the connection is closed.\n"],["closed?","OpenSSL::SSL::SocketForwarder","OpenSSL/SSL/SocketForwarder.html#method-i-closed-3F","()",""],["closed?","Queue","Queue.html#method-i-closed-3F","()","<p>Returns <code>true</code> if the queue is closed.\n"],["closed?","SDBM","SDBM.html#method-i-closed-3F","()","<p>Returns <code>true</code> if the database is closed.\n"],["closed?","StringIO","StringIO.html#method-i-closed-3F","()","<p>Returns <code>true</code> if the stream is completely closed, <code>false</code> otherwise.\n"],["closed?","Zlib::GzipFile","Zlib/GzipFile.html#method-i-closed-3F","()","<p>Same as IO#closed?\n"],["closed?","Zlib::ZStream","Zlib/ZStream.html#method-i-closed-3F","()","<p>Returns true if the stream is closed.\n"],["closed_read?","StringIO","StringIO.html#method-i-closed_read-3F","()","<p>Returns <code>true</code> if the stream is not readable, <code>false</code> otherwise.\n"],["closed_write?","StringIO","StringIO.html#method-i-closed_write-3F","()","<p>Returns <code>true</code> if the stream is not writable, <code>false</code> otherwise.\n"],["cmds","OpenSSL::Engine","OpenSSL/Engine.html#method-i-cmds","()","<p>Returns an array of command definitions for the current engine\n"],["cmp","Bundler::FileUtils","Bundler/FileUtils.html#method-c-cmp","(a, b)",""],["cmp","Bundler::FileUtils","Bundler/FileUtils.html#method-i-cmp","(a, b)",""],["cmp","FileUtils","FileUtils.html#method-i-cmp","(a, b)",""],["cmp","FileUtils","FileUtils.html#method-c-cmp","(a, b)",""],["cmp","OpenSSL::BN","OpenSSL/BN.html#method-i-cmp","(p1)",""],["cmp","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-cmp","(p1)","<p>Compares this certificate id with <em>other</em> and returns <code>true</code> if they are the same.\n"],["cmp","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-cmp","(p1)","<p>Compares this Name with <em>other</em> and returns <code>0</code> if they are the same and <code>-1</code> or +<code>1</code> if they are greater or …\n"],["cmp_issuer","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-cmp_issuer","(p1)","<p>Compares this certificate id&#39;s issuer with <em>other</em> and returns <code>true</code> if they are the same.\n"],["cmsg_is?","Socket::AncillaryData","Socket/AncillaryData.html#method-i-cmsg_is-3F","(p1, p2)","<p>tests the level and type of <em>ancillarydata</em>.\n\n<pre>ancdata = Socket::AncillaryData.new(:INET6, :IPV6, :PKTINFO, ...</pre>\n"],["code","WEBrick::HTTPStatus::Status","WEBrick/HTTPStatus/Status.html#method-i-code","()","<p>Returns the HTTP status code\n"],["code_around_binding","IRB::WorkSpace","IRB/WorkSpace.html#method-i-code_around_binding","()",""],["codepage","WIN32OLE","WIN32OLE.html#method-c-codepage","()","<p>Returns current codepage.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">codepage</span> <span class=\"ruby-comment\"># =&gt; WIN32OLE::CP_ACP</span>\n</pre>\n"],["codepage=","WIN32OLE","WIN32OLE.html#method-c-codepage-3D","(p1)","<p>Sets current codepage. The WIN32OLE.codepage is initialized according to Encoding.default_internal.  …\n"],["codepoints","ARGF","ARGF.html#method-i-codepoints","()","<p>This is a deprecated alias for #each_codepoint.\n"],["codepoints","IO","IO.html#method-i-codepoints","()","<p>This is a deprecated alias for #each_codepoint.\n"],["codepoints","String","String.html#method-i-codepoints","()","<p>Returns an array of the Integer ordinals of the characters in <em>str</em>.  This is a shorthand for <code>str.each_codepoint.to_a</code> …\n"],["codepoints","StringIO","StringIO.html#method-i-codepoints","()","<p>This is a deprecated alias for #each_codepoint.\n"],["coerce","BigDecimal","BigDecimal.html#method-i-coerce","(p1)","<p>The coerce method provides support for Ruby type coercion. It is not enabled by default.\n<p>This means that …\n"],["coerce","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-coerce","(oth)","<p>Args\n<p><code>v</code> &mdash; Bundler::URI or String\n\n<p>Description\n"],["coerce","Float","Float.html#method-i-coerce","(p1)","<p>Returns an array with both <code>numeric</code> and <code>float</code> represented as Float objects.\n<p>This is achieved by converting …\n"],["coerce","Integer","Integer.html#method-i-coerce","(p1)","<p>Returns an array with both a <code>numeric</code> and a <code>big</code> represented as Bignum objects.\n<p>This is achieved by converting …\n"],["coerce","Matrix","Matrix.html#method-i-coerce","(other)","<p>The coerce method provides support for Ruby type coercion. This coercion mechanism is used by Ruby to …\n"],["coerce","Numeric","Numeric.html#method-i-coerce","(p1)","<p>If <code>numeric</code> is the same type as <code>num</code>, returns an array <code>[numeric, num]</code>. Otherwise, returns an array with …\n"],["coerce","OpenSSL::BN","OpenSSL/BN.html#method-i-coerce","(p1)",""],["coerce","URI::Generic","URI/Generic.html#method-i-coerce","(oth)","<p>Args\n<p><code>v</code> &mdash; URI or String\n\n<p>Description\n"],["coerce","Vector","Vector.html#method-i-coerce","(other)","<p>The coerce method provides support for Ruby type coercion. This coercion mechanism is used by Ruby to …\n"],["coerce_other","IPAddr","IPAddr.html#method-i-coerce_other","(other)",""],["cofactor","Matrix","Matrix.html#method-i-cofactor","(row, column)","<p>Returns the (row, column) cofactor which is obtained by multiplying the first minor by (-1)**(row + column). …\n"],["cofactor","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-cofactor","()","<p>Returns the cofactor of the group.\n<p>See the OpenSSL documentation for EC_GROUP_get_cofactor()\n"],["cofactor_expansion","Matrix","Matrix.html#method-i-cofactor_expansion","(row: nil, column: nil)",""],["col_sep","CSV","CSV.html#method-i-col_sep","()","<p>The encoded <code>:col_sep</code> used in parsing and writing. See CSV::new for details.\n"],["collect","Array","Array.html#method-i-collect","()","<p>Invokes the given block once for each element of <code>self</code>.\n<p>Creates a new array containing the values returned …\n"],["collect","Enumerable","Enumerable.html#method-i-collect","()","<p>Returns a new array with the results of running <em>block</em> once for every element in <em>enum</em>.\n<p>If no block is given, …\n"],["collect","Enumerator::Lazy","Enumerator/Lazy.html#method-i-collect","()","<p>Like Enumerable#map, but chains operation to be lazy-evaluated.\n\n<pre>(1..Float::INFINITY).lazy.map {|i| i**2 ...</pre>\n"],["collect","Matrix","Matrix.html#method-i-collect","(which = :all)","<p>Returns a matrix that is the result of iteration of the given block over all elements of the matrix. …\n"],["collect","REXML::Elements","REXML/Elements.html#method-i-collect","( xpath=nil )",""],["collect","Vector","Vector.html#method-i-collect","()","<p>Like Array#collect.\n"],["collect!","Array","Array.html#method-i-collect-21","()","<p>Invokes the given block once for each element of <code>self</code>, replacing the element with the value returned …\n"],["collect!","Matrix","Matrix.html#method-i-collect-21","(which = :all)","<p>Invokes the given block for each element of matrix, replacing the element with the value returned by …\n"],["collect!","Set","Set.html#method-i-collect-21","()","<p>Replaces the elements with ones returned by collect(). Returns an enumerator if no block is given.\n"],["collect!","Vector","Vector.html#method-i-collect-21","(&block)","<p>Like Array#collect!\n"],["collect2","Vector","Vector.html#method-i-collect2","(v)","<p>Collects (as in Enumerable#collect) over the elements of this vector and <code>v</code> in conjunction.\n"],["collect_attributes","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-collect_attributes","(tag_name, prefix, attrs, ns, klass)",""],["collect_attrs","RSS::Element","RSS/Element.html#method-i-collect_attrs","()",""],["collect_concat","Enumerable","Enumerable.html#method-i-collect_concat","()","<p>Returns a new array with the concatenated results of running <em>block</em> once for every element in <em>enum</em>.\n<p>If …\n"],["collect_concat","Enumerator::Lazy","Enumerator/Lazy.html#method-i-collect_concat","()","<p>Returns a new lazy enumerator with the concatenated results of running <code>block</code> once for every element in …\n"],["collect_first_comment","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-collect_first_comment","()","<p>Look for the first comment in a file that isn&#39;t a shebang line.\n"],["collect_method","Bundler::FileUtils","Bundler/FileUtils.html#method-c-collect_method","(opt)","<p>Returns an Array of methods names which have the option <code>opt</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">collect_method</span>(<span class=\"ruby-value\">:preserve</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["collect_method","FileUtils","FileUtils.html#method-c-collect_method","(opt)","<p>Returns an Array of methods names which have the option <code>opt</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">collect_method</span>(<span class=\"ruby-value\">:preserve</span>) <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["collect_tokens","RDoc::TokenStream","RDoc/TokenStream.html#method-i-collect_tokens","()","<p>Starts collecting tokens\n"],["colorable?","IRB::Color","IRB/Color.html#method-c-colorable-3F","()",""],["colorize","IRB::Color","IRB/Color.html#method-c-colorize","(text, seq)",""],["colorize_code","IRB::Color","IRB/Color.html#method-c-colorize_code","(code, complete: true)","<p>If `complete` is false (code is incomplete), this does not warn compile_error. This option is needed …\n"],["column","Matrix","Matrix.html#method-i-column","(j)","<p>Returns column vector number <code>j</code> of the matrix as a Vector (starting at 0 like an array).  When a block …\n"],["column","Ripper","Ripper.html#method-i-column","()","<p>Return column number of current parsing line. This number starts from 0.\n"],["column","Ripper::Filter","Ripper/Filter.html#method-i-column","()","<p>The column number of the current token. This value starts from 0. This method is valid only in event …\n"],["column_separator","CSV::Parser","CSV/Parser.html#method-i-column_separator","()",""],["column_vector","Matrix","Matrix.html#method-c-column_vector","(column)","<p>Creates a single-column matrix where the values of that column are as given in <code>column</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Matrix</span>.<span class=\"ruby-identifier\">column_vector</span>([<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>]) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["column_vectors","Matrix","Matrix.html#method-i-column_vectors","()","<p>Returns an array of the column vectors of the matrix.  See Vector.\n"],["columns","Matrix","Matrix.html#method-c-columns","(columns)","<p>Creates a matrix using <code>columns</code> as an array of column vectors.\n\n<pre>Matrix.columns([[25, 93], [-1, 66]])\n   ...</pre>\n"],["combination","Array","Array.html#method-i-combination","(p1)","<p>When invoked with a block, yields all combinations of length <code>n</code> of elements from the array and then returns …\n"],["combine","Matrix","Matrix.html#method-i-combine","(*matrices, &block)",""],["combine","Matrix","Matrix.html#method-c-combine","(*matrices)","<p>Create a matrix by combining matrices entrywise, using the given block\n\n<pre>x = Matrix[[6, 6], [4, 4]]\ny = ...</pre>\n"],["combine_rubygems_sources","Bundler::SourceList","Bundler/SourceList.html#method-i-combine_rubygems_sources","()",""],["comma_breakable","PP::PPMethods","PP/PPMethods.html#method-i-comma_breakable","()","<p>A convenience method which is same as follows:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">text</span> <span class=\"ruby-string\">&#39;,&#39;</span>\n<span class=\"ruby-identifier\">breakable</span>\n</pre>\n"],["command","Bundler::Plugin::API","Bundler/Plugin/API.html#method-c-command","(command, cls = self)","<p>The plugins should declare that they handle a command through this helper.\n<p>@param [String] command being …\n"],["command","DRb::ExtServManager","DRb/ExtServManager.html#method-c-command","()",""],["command=","DRb::ExtServManager","DRb/ExtServManager.html#method-c-command-3D","(cmd)",""],["command?","Bundler::Plugin","Bundler/Plugin.html#method-i-command-3F","(command)","<p>Checks if any plugin handles the command\n"],["command_help","Bundler::Thor","Bundler/Thor.html#method-c-command_help","(shell, command_name)","<p>Prints help information for the given command.\n<p>Parameters\n<p>shell&lt;Bundler::Thor::Shell&gt; command_name …\n"],["command_names","Gem::CommandManager","Gem/CommandManager.html#method-i-command_names","()","<p>Return a sorted list of all command names as strings.\n"],["command_plugin","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-command_plugin","(command)","<p>Fetch the name of plugin handling the command\n"],["commands","Bundler::FileUtils","Bundler/FileUtils.html#method-c-commands","()","<p>Returns an Array of names of high-level methods that accept any keyword arguments.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">commands</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["commands","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-commands","()","<p>Returns the commands for this Bundler::Thor class.\n<p>Returns\n<p>Hash &mdash; An ordered hash with commands names as …\n"],["commands","FileUtils","FileUtils.html#method-c-commands","()","<p>Returns an Array of names of high-level methods that accept any keyword arguments.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">commands</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["comment","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-comment","(comment)","<p>Called when a comment is encountered. @p comment The content of the comment\n"],["comment","REXML::StreamListener","REXML/StreamListener.html#method-i-comment","(comment)","<p>Called when a comment is encountered. @p comment The content of the comment\n"],["comment","Zlib::GzipFile","Zlib/GzipFile.html#method-i-comment","()","<p>Returns comments recorded in the gzip file header, or nil if the comments is not present.\n"],["comment=","RDoc::CodeObject","RDoc/CodeObject.html#method-i-comment-3D","(comment)","<p>Replaces our comment with <code>comment</code>, unless it is empty.\n"],["comment=","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-comment-3D","(p1)","<p>Specify the comment (<code>str</code>) in the gzip header.\n"],["comment?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-comment-3F","()","<p>Content: [ String text ]\n"],["comment_lines","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-comment_lines","(path, flag, *args)","<p>Comment all lines matching a given regex.  It will leave the space which existed before the beginning …\n"],["comments","REXML::Element","REXML/Element.html#method-i-comments","()","<p>Get an array of all Comment children. IMMUTABLE\n"],["commercial","Date","Date.html#method-c-commercial","(p1 = v1, p2 = v2, p3 = v3, p4 = v4)","<p>Creates a date object denoting the given week date.\n<p>The week and the day of week should be a negative …\n"],["commercial","DateTime","DateTime.html#method-c-commercial","(p1 = v1, p2 = v2, p3 = v3, p4 = v4, p5 = v5, p6 = v6, p7 = v7, p8 = v8)","<p>Creates a DateTime object denoting the given week date.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">commercial</span>(<span class=\"ruby-value\">2001</span>) <span class=\"ruby-comment\">#=&gt; #&lt;DateTime: 2001-01-01T00:00:00+00:00 ...</span>\n</pre>\n"],["commit","PStore","PStore.html#method-i-commit","()","<p>Ends the current PStore#transaction, committing any changes to the data store immediately.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["committed?","Bundler::GemHelper","Bundler/GemHelper.html#method-i-committed-3F","()",""],["common_installer_setup","Gem::TestCase","Gem/TestCase.html#method-i-common_installer_setup","()",""],["common_installer_teardown","Gem::TestCase","Gem/TestCase.html#method-i-common_installer_teardown","()",""],["common_options","Gem::Command","Gem/Command.html#method-c-common_options","()",""],["compact","Array","Array.html#method-i-compact","()","<p>Returns a copy of <code>self</code> with all <code>nil</code> elements removed.\n\n<pre>[ &quot;a&quot;, nil, &quot;b&quot;, nil, &quot;c&quot;, nil ].compact\n       ...</pre>\n"],["compact","Fiddle::CParser","Fiddle/CParser.html#method-i-compact","(signature)",""],["compact","GC","GC.html#method-c-compact","()",""],["compact","Hash","Hash.html#method-i-compact","()","<p>Returns a new hash with the nil values/key pairs removed\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-value\">a:</span> <span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">b:</span> <span class=\"ruby-keyword\">false</span>, <span class=\"ruby-value\">c:</span> <span class=\"ruby-keyword\">nil</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">compact</span>     <span class=\"ruby-operator\">...</span>\n</pre>\n"],["compact!","Array","Array.html#method-i-compact-21","()","<p>Removes <code>nil</code> elements from the array.\n<p>Returns <code>nil</code> if no changes were made, otherwise returns the array. …\n"],["compact!","Hash","Hash.html#method-i-compact-21","()","<p>Removes all nil values from the hash. Returns nil if no changes were made, otherwise returns the hash. …\n"],["compact_index_client","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-compact_index_client","()",""],["compact_index_request","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-c-compact_index_request","(method_name)",""],["compact_specs","Gem::Indexer","Gem/Indexer.html#method-i-compact_specs","(specs)","<p>Compacts Marshal output for the specs index data source by using identical objects as much as possible. …\n"],["compare","REXML::XPathParser","REXML/XPathParser.html#method-i-compare","(a, operator, b)",""],["compare_by_identity","Hash","Hash.html#method-i-compare_by_identity","()","<p>Makes <em>hsh</em> compare its keys by their identity, i.e. it will consider exact same objects as same keys. …\n"],["compare_by_identity","Set","Set.html#method-i-compare_by_identity","()","<p>Makes the set compare its elements by their identity and returns self.  This method may not be supported …\n"],["compare_by_identity?","Hash","Hash.html#method-i-compare_by_identity-3F","()","<p>Returns <code>true</code> if <em>hsh</em> will compare its keys by their identity.  Also see Hash#compare_by_identity.\n"],["compare_by_identity?","Set","Set.html#method-i-compare_by_identity-3F","()","<p>Returns true if the set will compare its elements by their identity.  Also see Set#compare_by_identity …\n"],["compare_file","Bundler::FileUtils","Bundler/FileUtils.html#method-i-compare_file","(a, b)","<p>Returns true if the contents of a file <code>a</code> and a file <code>b</code> are identical.\n\n<pre>Bundler::FileUtils.compare_file(&#39;somefile&#39;, ...</pre>\n"],["compare_file","Bundler::FileUtils","Bundler/FileUtils.html#method-c-compare_file","(a, b)","<p>Returns true if the contents of a file <code>a</code> and a file <code>b</code> are identical.\n\n<pre>Bundler::FileUtils.compare_file(&#39;somefile&#39;, ...</pre>\n"],["compare_file","FileUtils","FileUtils.html#method-i-compare_file","(a, b)","<p>Returns true if the contents of a file <code>a</code> and a file <code>b</code> are identical.\n\n<pre>FileUtils.compare_file(&#39;somefile&#39;, ...</pre>\n"],["compare_file","FileUtils","FileUtils.html#method-c-compare_file","(a, b)","<p>Returns true if the contents of a file <code>a</code> and a file <code>b</code> are identical.\n\n<pre>FileUtils.compare_file(&#39;somefile&#39;, ...</pre>\n"],["compare_language","REXML::Functions","REXML/Functions.html#method-c-compare_language","(lang1, lang2)",""],["compare_stream","Bundler::FileUtils","Bundler/FileUtils.html#method-i-compare_stream","(a, b)","<p>Returns true if the contents of a stream <code>a</code> and <code>b</code> are identical.\n"],["compare_stream","Bundler::FileUtils","Bundler/FileUtils.html#method-c-compare_stream","(a, b)","<p>Returns true if the contents of a stream <code>a</code> and <code>b</code> are identical.\n"],["compare_stream","FileUtils","FileUtils.html#method-i-compare_stream","(a, b)","<p>Returns true if the contents of a stream <code>a</code> and <code>b</code> are identical.\n"],["compare_stream","FileUtils","FileUtils.html#method-c-compare_stream","(a, b)","<p>Returns true if the contents of a stream <code>a</code> and <code>b</code> are identical.\n"],["compatible?","Encoding","Encoding.html#method-c-compatible-3F","(p1, p2)","<p>Checks the compatibility of two objects.\n<p>If the objects are both strings they are compatible when they …\n"],["compatible?","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-compatible-3F","(spec)",""],["compile","Regexp","Regexp.html#method-c-compile","(*args)","<p>Alias for Regexp.new\n"],["compile","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-compile","(p1, *args, p3 = {})","<p>Takes <code>source</code>, a String of Ruby code and compiles it to an InstructionSequence.\n<p>Optionally takes <code>file</code>, …\n"],["compile_error","Ripper","Ripper.html#method-i-compile_error","(msg)","<p>This method is called when the parser found syntax error.\n"],["compile_file","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-compile_file","(p1, *args, p3 = {})","<p>Takes <code>file</code>, a String with the location of a Ruby source file, reads, parses and compiles the file, and …\n"],["compile_option","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-compile_option","()","<p>Returns a hash of default options used by the Ruby iseq compiler.\n<p>For details, see InstructionSequence.compile_option= …\n"],["compile_option=","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-compile_option-3D","(p1)","<p>Sets the default values for various optimizations in the Ruby iseq compiler.\n<p>Possible values for <code>options</code> …\n"],["complain","Gem::Commands::LockCommand","Gem/Commands/LockCommand.html#method-i-complain","(message)",""],["complete","OptionParser","OptionParser.html#method-i-complete","(typ, opt, icase = false, *pat)","<p>Completes shortened long style option switch and returns pair of canonical switch and switch descriptor …\n"],["complete","OptionParser::Completion","OptionParser/Completion.html#method-i-complete","(key, icase = false, pat = nil)",""],["complete","OptionParser::List","OptionParser/List.html#method-i-complete","(id, opt, icase = false, *pat, &block)","<p>Searches list <code>id</code> for <code>opt</code> and the optional patterns for completion <code>pat</code>. If <code>icase</code> is true, the search is …\n"],["complete","RDoc::ClassModule","RDoc/ClassModule.html#method-i-complete","(min_visibility)","<p>Prepares this ClassModule for use by a generator.\n<p>See RDoc::Store#complete\n"],["complete","RDoc::Store","RDoc/Store.html#method-i-complete","(min_visibility)","<p>Prepares the RDoc code object tree for use by a generator.\n<p>It finds unique classes/modules defined, and …\n"],["completer_quote_characters","Readline","Readline.html#method-c-completer_quote_characters","()","<p>Gets a list of characters which can be used to quote a substring of the line.\n<p>Raises NotImplementedError …\n"],["completer_quote_characters=","Readline","Readline.html#method-c-completer_quote_characters-3D","(p1)","<p>Sets a list of characters which can be used to quote a substring of the line. Completion occurs on the …\n"],["completer_quote_characters=","Reline::Core","Reline/Core.html#method-i-completer_quote_characters-3D","(v)",""],["completer_word_break_characters","Readline","Readline.html#method-c-completer_word_break_characters","()","<p>Gets the basic list of characters that signal a break between words for rl_complete_internal().\n<p>Raises …\n"],["completer_word_break_characters=","Readline","Readline.html#method-c-completer_word_break_characters-3D","(p1)","<p>Sets the basic list of characters that signal a break between words for rl_complete_internal(). The default …\n"],["completer_word_break_characters=","Reline::Core","Reline/Core.html#method-i-completer_word_break_characters-3D","(v)",""],["completion_append_character","Readline","Readline.html#method-c-completion_append_character","()","<p>Returns a string containing a character to be appended on completion. The default is a space (“ …\n"],["completion_append_character=","Readline","Readline.html#method-c-completion_append_character-3D","(p1)","<p>Specifies a character to be appended on completion. Nothing will be appended if an empty string (“”) …\n"],["completion_append_character=","Reline::Core","Reline/Core.html#method-i-completion_append_character-3D","(val)",""],["completion_case_fold","Readline","Readline.html#method-c-completion_case_fold","()","<p>Returns true if completion ignores case. If no, returns false.\n<p>NOTE: Returns the same object that is specified …\n"],["completion_case_fold","Reline::Core","Reline/Core.html#method-i-completion_case_fold","()",""],["completion_case_fold=","Readline","Readline.html#method-c-completion_case_fold-3D","(p1)","<p>Sets whether or not to ignore case on completion.\n"],["completion_case_fold=","Reline::Core","Reline/Core.html#method-i-completion_case_fold-3D","(v)",""],["completion_options","Bundler::Thor::LineEditor::Readline","Bundler/Thor/LineEditor/Readline.html#method-i-completion_options","()",""],["completion_proc","Bundler::Thor::LineEditor::Readline","Bundler/Thor/LineEditor/Readline.html#method-i-completion_proc","()",""],["completion_proc","Readline","Readline.html#method-c-completion_proc","()","<p>Returns the completion Proc object.\n"],["completion_proc=","Readline","Readline.html#method-c-completion_proc-3D","(p1)","<p>Specifies a Proc object <code>proc</code> to determine completion behavior.  It should take input string and return …\n"],["completion_proc=","Reline::Core","Reline/Core.html#method-i-completion_proc-3D","(p)",""],["completion_quote_character","Readline","Readline.html#method-c-completion_quote_character","()","<p>When called during a completion (e.g. from within your completion_proc), it will return a string containing …\n"],["completion_quote_character","Reline::Core","Reline/Core.html#method-i-completion_quote_character","()",""],["component","Bundler::URI::Generic","Bundler/URI/Generic.html#method-c-component","()","<p>Components of the Bundler::URI in the order.\n"],["component","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-component","()","<p>Components of the Bundler::URI in the order.\n"],["component","Matrix","Matrix.html#method-i-component","(i, j)",""],["component","URI::Generic","URI/Generic.html#method-c-component","()","<p>Components of the URI in the order.\n"],["component","URI::Generic","URI/Generic.html#method-i-component","()","<p>Components of the URI in the order.\n"],["component","Vector","Vector.html#method-i-component","(i)",""],["component_ary","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-component_ary","()","<p>Returns an Array of the components defined from the COMPONENT Array.\n"],["component_ary","URI::Generic","URI/Generic.html#method-i-component_ary","()","<p>Returns an Array of the components defined from the COMPONENT Array.\n"],["compose_sets","Gem::Resolver","Gem/Resolver.html#method-c-compose_sets","(*sets)","<p>Combines <code>sets</code> into a ComposedSet that allows specification lookup in a uniform manner.  If one of the …\n"],["compress","Gem::Indexer","Gem/Indexer.html#method-i-compress","(filename, extension)","<p>Compress <code>filename</code> with <code>extension</code>.\n"],["compress_indices","Gem::Indexer","Gem/Indexer.html#method-i-compress_indices","()","<p>Compresses indices on disk\n"],["compute_dfa","Racc::States","Racc/States.html#method-i-compute_dfa","()",""],["compute_expand","Racc::Grammar","Racc/Grammar.html#method-i-compute_expand","(t)","<p>Sym#expand\n"],["compute_hash","Racc::Grammar","Racc/Grammar.html#method-i-compute_hash","()","<p>Rule#hash\n"],["compute_heads","Racc::Grammar","Racc/Grammar.html#method-i-compute_heads","()","<p>Sym#heads\n"],["compute_key","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-compute_key","(p1)","<p>Returns a String containing a shared secret computed from the other party&#39;s public value. See DH_compute_key …\n"],["compute_locate","Racc::Grammar","Racc/Grammar.html#method-i-compute_locate","()","<p>Sym#locate\n"],["compute_nfa","Racc::States","Racc/States.html#method-i-compute_nfa","()",""],["compute_nullable","Racc::Grammar","Racc/Grammar.html#method-i-compute_nullable","()","<p>Sym#nullable?, Rule#nullable?\n"],["compute_nullable_0","Racc::Grammar","Racc/Grammar.html#method-i-compute_nullable_0","()","<p>Sym#self_null?\n"],["compute_primes","Prime::EratosthenesSieve","Prime/EratosthenesSieve.html#method-i-compute_primes","()",""],["compute_requires","Bundler::Definition","Bundler/Definition.html#method-i-compute_requires","()",""],["compute_useless","Racc::Grammar","Racc/Grammar.html#method-i-compute_useless","()","<p>Sym#useless?, Rule#useless? FIXME: what means “useless”?\n"],["concat","Array","Array.html#method-i-concat","(*args)","<p>Appends the elements of <code>other_ary</code>s to <code>self</code>.\n\n<pre class=\"ruby\">[ <span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;b&quot;</span> ].<span class=\"ruby-identifier\">concat</span>( [<span class=\"ruby-string\">&quot;c&quot;</span>, <span class=\"ruby-string\">&quot;d&quot;</span>])   <span class=\"ruby-comment\">#=&gt; [ &quot;a&quot;, &quot;b&quot;, &quot;c&quot;, &quot;d&quot; ...</span>\n</pre>\n"],["concat","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-concat","(string)",""],["concat","Gem::Requirement","Gem/Requirement.html#method-i-concat","(new)","<p>Concatenates the <code>new</code> requirements onto this requirement.\n"],["concat","REXML::Functions","REXML/Functions.html#method-c-concat","( *objects )",""],["concat","String","String.html#method-i-concat","(*args)","<p>Concatenates the given object(s) to <em>str</em>. If an object is an Integer, it is considered a codepoint and …\n"],["concat","StringScanner","StringScanner.html#method-i-concat","(p1)","<p>Appends <code>str</code> to the string being scanned. This method does not affect scan pointer.\n\n<pre>s = StringScanner.new(&quot;Fri ...</pre>\n"],["concat_ruby_version_requirements","Bundler::Definition","Bundler/Definition.html#method-i-concat_ruby_version_requirements","(ruby_version, ruby_versions = [])",""],["conf","IRB","IRB.html#method-c-conf","()","<p>Displays current configuration.\n<p>Modifying the configuration is achieved by sending a message to IRB.conf …\n"],["config","DRb","DRb.html#method-c-config","()","<p>Get the configuration of the current server.\n<p>If there is no current server, this returns the default configuration. …\n"],["config","DRb","DRb.html#method-i-config","()","<p>Get the configuration of the current server.\n<p>If there is no current server, this returns the default configuration. …\n"],["config_file","Gem","Gem.html#method-c-config_file","()","<p>The path to standard location of the user&#39;s .gemrc file.\n"],["config_file_name","Gem::ConfigFile","Gem/ConfigFile.html#method-i-config_file_name","()","<p>The name of the configuration file.\n"],["configuration","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-configuration","()",""],["configuration","Gem","Gem.html#method-c-configuration","()","<p>The standard configuration object for gems.\n"],["configuration=","Gem","Gem.html#method-c-configuration-3D","(config)","<p>Use the given configuration object (which implements the ConfigFile protocol) as the standard configuration …\n"],["configure","Bundler","Bundler.html#method-c-configure","()",""],["configure","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-configure","(p1)","<p>Configure this State instance with the Hash <em>opts</em>, and return itself.\n"],["configure_connection_for_https","Gem::Request","Gem/Request.html#method-c-configure_connection_for_https","(connection, cert_files)",""],["configure_gem_home","Bundler","Bundler.html#method-c-configure_gem_home","()",""],["configure_gem_home_and_path","Bundler","Bundler.html#method-c-configure_gem_home_and_path","()",""],["configure_gem_path","Bundler","Bundler.html#method-c-configure_gem_path","(env = ENV)",""],["configure_gem_version_promoter","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-configure_gem_version_promoter","(definition, options)",""],["configure_options","Gem::Command","Gem/Command.html#method-i-configure_options","(header, option_list)",""],["configured_bundle_path","Bundler","Bundler.html#method-c-configured_bundle_path","()",""],["configured_uri_for","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-configured_uri_for","(uri)","<p>Adds credentials to the URI as Fetcher#configured_uri_for does\n"],["confirm","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-confirm","(name)",""],["confirm","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-confirm","(msg, newline = nil)",""],["confirm","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-confirm","(message, newline = nil)",""],["confirm_all","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-confirm_all","()",""],["conflict?","Racc::State","Racc/State.html#method-i-conflict-3F","()",""],["conflict_fixing_possibilities?","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-conflict_fixing_possibilities-3F","(state, binding_requirements)","<p>@param [DependencyState] state @param [Array] array of requirements @return [Boolean] whether or not …\n"],["conflicting_dependencies","Gem::DependencyResolutionError","Gem/DependencyResolutionError.html#method-i-conflicting_dependencies","()",""],["conflicting_dependencies","Gem::Resolver::Conflict","Gem/Resolver/Conflict.html#method-i-conflicting_dependencies","()","<p>Return the 2 dependency objects that conflicted\n"],["conflicts","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-conflicts","()","<p>(see Bundler::Molinillo::ResolutionState#conflicts)\n"],["conflicts","Gem::Resolver::Molinillo::Delegates::ResolutionState","Gem/Resolver/Molinillo/Delegates/ResolutionState.html#method-i-conflicts","()","<p>(see Gem::Resolver::Molinillo::ResolutionState#conflicts)\n"],["conflicts","Gem::Specification","Gem/Specification.html#method-i-conflicts","()","<p>Return any possible conflicts against the currently loaded specs.\n"],["confstr","Etc","Etc.html#method-c-confstr","(p1)","<p>Returns system configuration variable using confstr().\n<p><em>name</em> should be a constant under <code>Etc</code> which begins …\n"],["conftest_source","MakeMakefile","MakeMakefile.html#method-i-conftest_source","()",""],["conj","Complex","Complex.html#method-i-conj","()","<p>Returns the complex conjugate.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">conjugate</span>  <span class=\"ruby-comment\">#=&gt; (1-2i)</span>\n</pre>\n"],["conj","Matrix","Matrix.html#method-i-conj","()",""],["conj","Numeric","Numeric.html#method-i-conj","()","<p>Returns self.\n"],["conjugate","Complex","Complex.html#method-i-conjugate","()","<p>Returns the complex conjugate.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">conjugate</span>  <span class=\"ruby-comment\">#=&gt; (1-2i)</span>\n</pre>\n"],["conjugate","Matrix","Matrix.html#method-i-conjugate","()","<p>Returns the conjugate of the matrix.\n\n<pre>Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]\n  =&gt; 1+2i   i ...</pre>\n"],["conjugate","Numeric","Numeric.html#method-i-conjugate","()","<p>Returns self.\n"],["connect","Addrinfo","Addrinfo.html#method-i-connect","(timeout: nil, &block)","<p>creates a socket connected to the address of self.\n<p>The optional argument <em>opts</em> is options represented by …\n"],["connect","DRb::DRbSSLSocket::SSLConfig","DRb/DRbSSLSocket/SSLConfig.html#method-i-connect","(tcp)","<p>Connect to IO <code>tcp</code>, with context of the current certificate configuration\n"],["connect","Net::FTP","Net/FTP.html#method-i-connect","(host, port = FTP_PORT)","<p>Establishes an FTP connection to host, optionally overriding the default port. If the environment variable …\n"],["connect","Net::HTTP","Net/HTTP.html#method-i-connect","()",""],["connect","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-connect","()","<p>Initiates an SSL/TLS handshake with a server.  The handshake may be started after unencrypted data has …\n"],["connect","Socket","Socket.html#method-i-connect","(p1)","<p>Requests a connection to be made on the given <code>remote_sockaddr</code>. Returns 0 if successful, otherwise an …\n"],["connect","UDPSocket","UDPSocket.html#method-i-connect","(p1, p2)","<p>Connects <em>udpsocket</em> to <em>host</em>:<em>port</em>.\n<p>This makes possible to send without destination address.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">u1</span> = <span class=\"ruby-constant\">UDPSocket</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["connect","WIN32OLE","WIN32OLE.html#method-c-connect","(p1, *args)","<p>Returns running OLE Automation object or WIN32OLE object from moniker. 1st argument should be OLE program …\n"],["connect_address","BasicSocket","BasicSocket.html#method-i-connect_address","()","<p>Returns an address of the socket suitable for connect in the local machine.\n<p>This method returns <em>self</em>.local_address, …\n"],["connect_from","Addrinfo","Addrinfo.html#method-i-connect_from","(*args, timeout: nil, &block)","<p>creates a socket connected to the address of self.\n<p>If one or more arguments given as <em>local_addr_args</em>, …\n"],["connect_internal","Addrinfo","Addrinfo.html#method-i-connect_internal","(local_addrinfo, timeout=nil)","<p>creates a new Socket connected to the address of <code>local_addrinfo</code>.\n<p>If <em>local_addrinfo</em> is nil, the address …\n"],["connect_nonblock","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-connect_nonblock","(p1 = {})","<p>Initiates the SSL/TLS handshake as a client in non-blocking manner.\n\n<pre># emulates blocking connect\nbegin ...</pre>\n"],["connect_nonblock","Socket","Socket.html#method-i-connect_nonblock","(addr, exception: true)","<p>Requests a connection to be made on the given <code>remote_sockaddr</code> after O_NONBLOCK is set for the underlying …\n"],["connect_to","Addrinfo","Addrinfo.html#method-i-connect_to","(*args, timeout: nil, &block)","<p>creates a socket connected to <em>remote_addr_args</em> and bound to self.\n<p>The optional last argument <em>opts</em> is options …\n"],["connection","Bundler::Fetcher","Bundler/Fetcher.html#method-i-connection","()",""],["connection_close?","Net::HTTPHeader","Net/HTTPHeader.html#method-i-connection_close-3F","()",""],["connection_for","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-connection_for","(uri)","<p>Creates a new connection for <code>uri</code>\n"],["connection_for","Bundler::PersistentHTTP","Bundler/PersistentHTTP.html#method-i-connection_for","(uri)",""],["connection_for","Gem::Request","Gem/Request.html#method-i-connection_for","(uri)","<p>Creates or an HTTP connection based on <code>uri</code>, or retrieves an existing connection, using a proxy if needed. …\n"],["connection_keep_alive?","Net::HTTPHeader","Net/HTTPHeader.html#method-i-connection_keep_alive-3F","()",""],["connection_stored?","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-connection_stored-3F","(options = nil)","<p>This is an extension point for TimedStack and is called with a mutex.\n<p>This method must returns true if …\n"],["conservative_version","Bundler::Injector","Bundler/Injector.html#method-i-conservative_version","(spec)",""],["consider_local?","Gem::DependencyInstaller","Gem/DependencyInstaller.html#method-i-consider_local-3F","()","<p>Indicated, based on the requested domain, if local gems should be considered.\n"],["consider_remote?","Gem::DependencyInstaller","Gem/DependencyInstaller.html#method-i-consider_remote-3F","()","<p>Indicated, based on the requested domain, if remote gems should be considered.\n"],["console","Bundler::CLI","Bundler/CLI.html#method-i-console","(group = nil)",""],["console","IO","IO.html#method-c-console","(*args)","<p>Returns an File instance opened console.\n<p>If <code>sym</code> is given, it will be sent to the opened console with  …\n"],["console_mode","IO","IO.html#method-i-console_mode","()","<p>Returns a data represents the current console mode.\n<p>You must require &#39;io/console&#39; to use this …\n"],["console_mode=","IO","IO.html#method-i-console_mode-3D","(p1)","<p>Sets the console mode to <code>mode</code>.\n<p>You must require &#39;io/console&#39; to use this method.\n"],["const_defined?","Module","Module.html#method-i-const_defined-3F","(*args)","<p>Says whether <em>mod</em> or its ancestors have a constant with the given name:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Float</span>.<span class=\"ruby-identifier\">const_defined?</span>(<span class=\"ruby-value\">:EPSILON</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["const_get","Module","Module.html#method-i-const_get","(*args)","<p>Checks for a constant with the given name in <em>mod</em>. If <code>inherit</code> is set, the lookup will also search the …\n"],["const_get_safely","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-const_get_safely","(constant_name, namespace)",""],["const_load","WIN32OLE","WIN32OLE.html#method-c-const_load","(p1, p2 = v2)","<p>Defines the constants of OLE Automation server as mod&#39;s constants. The first argument is WIN32OLE …\n"],["const_missing","Module","Module.html#method-i-const_missing","(p1)","<p>Invoked when a reference is made to an undefined constant in <em>mod</em>. It is passed a symbol for the undefined …\n"],["const_set","Module","Module.html#method-i-const_set","(p1, p2)","<p>Sets the named constant to the given object, returning that object. Creates a new constant if no constant …\n"],["const_source_location","Module","Module.html#method-i-const_source_location","(*args)","<p>Returns the Ruby source filename and line number containing first definition of constant specified.  …\n"],["constants","Module","Module.html#method-i-constants","(*args)","<p>Returns an array of the names of the constants accessible in <em>mod</em>. This includes the names of constants …\n"],["constants","Module","Module.html#method-c-constants","(*args)","<p>In the first form, returns an array of the names of all constants accessible from the point of call. …\n"],["construct","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-c-construct","(hours, minutes, seconds)",""],["consume","REXML::IOSource","REXML/IOSource.html#method-i-consume","( pattern )",""],["consume","REXML::Source","REXML/Source.html#method-i-consume","( pattern )",""],["consume_rbuff","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-consume_rbuff","(size=nil)","<p>Consumes <em>size</em> bytes from the buffer\n"],["contains","REXML::Functions","REXML/Functions.html#method-c-contains","( string, test )","<p>Fixed by Mike Stok\n"],["contains?","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-contains-3F","(commit)",""],["contains_requirable_file?","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-contains_requirable_file-3F","(file)","<p>Return true if this spec can require <code>file</code>.\n"],["content","REXML::XMLDecl","REXML/XMLDecl.html#method-i-content","(enc)",""],["content=","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-content-3D","(value)",""],["content=","RSS::Maker::ITunesItemModel::ITunesDurationBase","RSS/Maker/ITunesItemModel/ITunesDurationBase.html#method-i-content-3D","(content)",""],["content_encoding","OpenURI::Meta","OpenURI/Meta.html#method-i-content_encoding","()","<p>Returns a list of encodings in Content-Encoding field as an array of strings.\n<p>The encodings are downcased …\n"],["content_is_set?","RSS::Element","RSS/Element.html#method-i-content_is_set-3F","()",""],["content_length","Net::HTTPHeader","Net/HTTPHeader.html#method-i-content_length","()","<p>Returns an Integer object which represents the HTTP Content-Length: header field, or <code>nil</code> if that field …\n"],["content_length","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-content_length","()","<p>The content-length header\n"],["content_length","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-content_length","()","<p>The content-length header\n"],["content_length=","Net::HTTPHeader","Net/HTTPHeader.html#method-i-content_length-3D","(len)",""],["content_length=","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-content_length-3D","(len)","<p>Sets the content-length header to <code>len</code>\n"],["content_range","Net::HTTPHeader","Net/HTTPHeader.html#method-i-content_range","()","<p>Returns a Range object which represents the value of the Content-Range: header field. For a partial entity …\n"],["content_setup","RSS::Element","RSS/Element.html#method-c-content_setup","(type=nil, disp_name=nil)",""],["content_type","Net::HTTPHeader","Net/HTTPHeader.html#method-i-content_type","()","<p>Returns a content type string such as “text/html”. This method returns nil if Content-Type: …\n"],["content_type","OpenURI::Meta","OpenURI/Meta.html#method-i-content_type","()","<p>returns “type/subtype” which is MIME Content-Type. It is downcased for canonicalization. Content-Type …\n"],["content_type","RSS::Atom::ContentModel::ClassMethods","RSS/Atom/ContentModel/ClassMethods.html#method-i-content_type","()",""],["content_type","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-content_type","()","<p>The content-type header\n"],["content_type","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-content_type","()","<p>The content-type header\n"],["content_type=","Net::HTTPHeader","Net/HTTPHeader.html#method-i-content_type-3D","(type, params = {})",""],["content_type=","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-content_type-3D","(type)","<p>Sets the content-type header to <code>type</code>\n"],["content_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-content_writer","(name, disp_name=name)",""],["contents","Bundler::Dsl::DSLError","Bundler/Dsl/DSLError.html#method-i-contents","()","<p>@return [String] the contents of the DSL that cause the exception to\n\n<pre>be raised.</pre>\n"],["contents","Gem::Package","Gem/Package.html#method-i-contents","()","<p>A list of file names contained in this gem\n"],["contents","Gem::Package::Old","Gem/Package/Old.html#method-i-contents","()","<p>A list of file names contained in this gem\n"],["context","DEBUGGER__","DEBUGGER__.html#method-c-context","(thread=Thread.current)",""],["context","REXML::DocType","REXML/DocType.html#method-i-context","()",""],["context","REXML::ParseException","REXML/ParseException.html#method-i-context","()",""],["context=","REXML::Functions","REXML/Functions.html#method-c-context-3D","(value)",""],["continue?","Net::SMTP::Response","Net/SMTP/Response.html#method-i-continue-3F","()","<p>Determines whether the response received was a Positive Intermediate reply (3xx reply code)\n"],["continue_entry_body","RDoc::Parser::ChangeLog","RDoc/Parser/ChangeLog.html#method-i-continue_entry_body","(entry_body, continuation)","<p>Attaches the <code>continuation</code> of the previous line to the <code>entry_body</code>.\n<p>Continued function listings are joined …\n"],["continue_timeout=","Net::HTTP","Net/HTTP.html#method-i-continue_timeout-3D","(sec)","<p>Setter for the continue_timeout attribute.\n"],["conv_arg","OptionParser::Switch","OptionParser/Switch.html#method-i-conv_arg","(arg, val = [])","<p>Parses argument, converts and returns <code>arg</code>, <code>block</code> and result of conversion. Yields at semi-error condition …\n"],["converge_dependencies","Bundler::Definition","Bundler/Definition.html#method-i-converge_dependencies","()",""],["converge_locals","Bundler::Definition","Bundler/Definition.html#method-i-converge_locals","()","<p>Get all locals and override their matching sources. Return true if any of the locals changed (for example, …\n"],["converge_locked_specs","Bundler::Definition","Bundler/Definition.html#method-i-converge_locked_specs","()","<p>Remove elements from the locked specs that are expired. This will most commonly happen if the Gemfile …\n"],["converge_path_source_to_gemspec_source","Bundler::Definition","Bundler/Definition.html#method-i-converge_path_source_to_gemspec_source","(source)",""],["converge_path_sources_to_gemspec_sources","Bundler::Definition","Bundler/Definition.html#method-i-converge_path_sources_to_gemspec_sources","()",""],["converge_paths","Bundler::Definition","Bundler/Definition.html#method-i-converge_paths","()",""],["converge_rubygems_sources","Bundler::Definition","Bundler/Definition.html#method-i-converge_rubygems_sources","()",""],["converge_sources","Bundler::Definition","Bundler/Definition.html#method-i-converge_sources","()",""],["convert","CSV","CSV.html#method-i-convert","(name = nil, &converter)","<p>You can use this method to install a CSV::Converters built-in, or provide a block that handles a custom …\n"],["convert","CSV::FieldsConverter","CSV/FieldsConverter.html#method-i-convert","(fields, headers, lineno)",""],["convert","Encoding::Converter","Encoding/Converter.html#method-i-convert","(p1)","<p>Convert source_string and return destination_string.\n<p>source_string is assumed as a part of source. i.e. …\n"],["convert","OptionParser::Completion","OptionParser/Completion.html#method-i-convert","(opt = nil, val = nil, *)",""],["convert","RDoc::Markup","RDoc/Markup.html#method-i-convert","(input, formatter)","<p>We take <code>input</code>, parse it if necessary, then invoke the output <code>formatter</code> using a Visitor to render the …\n"],["convert","RSS::Converter","RSS/Converter.html#method-i-convert","(value)",""],["convert","RSS::Element","RSS/Element.html#method-i-convert","(value)",""],["convert","WEBrick::HTTPVersion","WEBrick/HTTPVersion.html#method-c-convert","(version)","<p>Converts <code>version</code> into an HTTPVersion\n"],["convert_attr_reader","RSS::BaseModel","RSS/BaseModel.html#method-i-convert_attr_reader","(*attrs)",""],["convert_fields","CSV","CSV.html#method-i-convert_fields","(fields, headers = false)","<p>Processes <code>fields</code> with <code>@converters</code>, or <code>@header_converters</code> if <code>headers</code> is passed as <code>true</code>, returning the …\n"],["convert_to_backward_compatible_key","Bundler::YAMLSerializer","Bundler/YAMLSerializer.html#method-i-convert_to_backward_compatible_key","(key)","<p>for settings&#39; keys\n"],["convert_to_uri","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-convert_to_uri","(uri)",""],["convert_to_uri","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-convert_to_uri","(uri)",""],["convert_to_uri","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-convert_to_uri","(uri)",""],["convert_to_uri","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-convert_to_uri","(uri)",""],["converted_value","Bundler::Settings","Bundler/Settings.html#method-i-converted_value","(value, key)",""],["converter=","RSS::Element","RSS/Element.html#method-i-converter-3D","(converter)",""],["converters","CSV","CSV.html#method-i-converters","()","<p>Returns the current list of converters in effect. See CSV::new for details. Built-in converters will …\n"],["convertible_int","MakeMakefile","MakeMakefile.html#method-i-convertible_int","(type, headers = nil, opts = nil, &b)","<p>Returns the convertible integer type of the given <code>type</code>.  You may optionally specify additional <code>headers</code> …\n"],["convpath","Encoding::Converter","Encoding/Converter.html#method-i-convpath","()","<p>Returns the conversion path of ec.\n<p>The result is an array of conversions.\n\n<pre>ec = Encoding::Converter.new(&quot;ISO-8859-1&quot;, ...</pre>\n"],["cooked","IO","IO.html#method-i-cooked","()","<p>Yields <code>self</code> within cooked mode.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">STDIN</span>.<span class=\"ruby-identifier\">cooked</span>(<span class=\"ruby-operator\">&amp;</span><span class=\"ruby-value\">:gets</span>)\n</pre>\n<p>will read and return a line with echo back and line …\n"],["cooked!","IO","IO.html#method-i-cooked-21","()","<p>Enables cooked mode.\n<p>If the terminal mode needs to be back, use io.cooked { … }.\n<p>You must require &#39;io/console&#39; …\n"],["copy","Bundler::FileUtils","Bundler/FileUtils.html#method-c-copy","(src, dest, preserve: nil, noop: nil, verbose: nil)",""],["copy","Bundler::FileUtils","Bundler/FileUtils.html#method-i-copy","(src, dest, preserve: nil, noop: nil, verbose: nil)",""],["copy","FileUtils","FileUtils.html#method-i-copy","(src, dest, preserve: nil, noop: nil, verbose: nil)",""],["copy","FileUtils","FileUtils.html#method-c-copy","(src, dest, preserve: nil, noop: nil, verbose: nil)",""],["copy","Net::HTTP","Net/HTTP.html#method-i-copy","(path, initheader = nil)","<p>Sends a COPY request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["copy","Net::IMAP","Net/IMAP.html#method-i-copy","(set, mailbox)","<p>Sends a COPY command to copy the specified message(s) to the end of the specified destination <code>mailbox</code> …\n"],["copy","OpenSSL::BN","OpenSSL/BN.html#method-i-copy","(p1)",""],["copy_entry","Bundler::FileUtils","Bundler/FileUtils.html#method-c-copy_entry","(src, dest, preserve = false, dereference_root = false, remove_destination = false)","<p>Copies a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies its contents recursively. …\n"],["copy_entry","Bundler::FileUtils","Bundler/FileUtils.html#method-i-copy_entry","(src, dest, preserve = false, dereference_root = false, remove_destination = false)","<p>Copies a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies its contents recursively. …\n"],["copy_entry","FileUtils","FileUtils.html#method-i-copy_entry","(src, dest, preserve = false, dereference_root = false, remove_destination = false)","<p>Copies a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies its contents recursively. …\n"],["copy_entry","FileUtils","FileUtils.html#method-c-copy_entry","(src, dest, preserve = false, dereference_root = false, remove_destination = false)","<p>Copies a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies its contents recursively. …\n"],["copy_file","Bundler::FileUtils","Bundler/FileUtils.html#method-i-copy_file","(src, dest, preserve = false, dereference = true)","<p>Copies file contents of <code>src</code> to <code>dest</code>. Both of <code>src</code> and <code>dest</code> must be a path name.\n"],["copy_file","Bundler::FileUtils","Bundler/FileUtils.html#method-c-copy_file","(src, dest, preserve = false, dereference = true)","<p>Copies file contents of <code>src</code> to <code>dest</code>. Both of <code>src</code> and <code>dest</code> must be a path name.\n"],["copy_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-copy_file","(source, *args, &block)","<p>Examples\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">copy_file</span> <span class=\"ruby-string\">&quot;README&quot;</span>, <span class=\"ruby-string\">&quot;doc/README&quot;</span>\n\n<span class=\"ruby-identifier\">copy_file</span> <span class=\"ruby-string\">&quot;doc/README&quot;</span>\n</pre>\n"],["copy_file","FileUtils","FileUtils.html#method-c-copy_file","(src, dest, preserve = false, dereference = true)","<p>Copies file contents of <code>src</code> to <code>dest</code>. Both of <code>src</code> and <code>dest</code> must be a path name.\n"],["copy_file","FileUtils","FileUtils.html#method-i-copy_file","(src, dest, preserve = false, dereference = true)","<p>Copies file contents of <code>src</code> to <code>dest</code>. Both of <code>src</code> and <code>dest</code> must be a path name.\n"],["copy_internal","Net::IMAP","Net/IMAP.html#method-i-copy_internal","(cmd, set, mailbox)",""],["copy_nonce","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-copy_nonce","(p1)","<p>Copies the nonce from <em>request</em> into this response.  Returns 1 on success and 0 on failure.\n"],["copy_stream","Bundler::FileUtils","Bundler/FileUtils.html#method-c-copy_stream","(src, dest)","<p>Copies stream <code>src</code> to <code>dest</code>. <code>src</code> must respond to #read(n) and <code>dest</code> must respond to #write(str).\n"],["copy_stream","Bundler::FileUtils","Bundler/FileUtils.html#method-i-copy_stream","(src, dest)","<p>Copies stream <code>src</code> to <code>dest</code>. <code>src</code> must respond to #read(n) and <code>dest</code> must respond to #write(str).\n"],["copy_stream","FileUtils","FileUtils.html#method-i-copy_stream","(src, dest)","<p>Copies stream <code>src</code> to <code>dest</code>. <code>src</code> must respond to #read(n) and <code>dest</code> must respond to #write(str).\n"],["copy_stream","FileUtils","FileUtils.html#method-c-copy_stream","(src, dest)","<p>Copies stream <code>src</code> to <code>dest</code>. <code>src</code> must respond to #read(n) and <code>dest</code> must respond to #write(str).\n"],["copy_stream","IO","IO.html#method-c-copy_stream","(p1, p2, p3 = v3, p4 = v4)","<p>IO.copy_stream copies <em>src</em> to <em>dst</em>. <em>src</em> and <em>dst</em> is either a filename or an IO-like object. IO-like object …\n"],["copy_to","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-copy_to","(destination, submodules = false)",""],["copy_to","Gem::Installer::FakePackage","Gem/Installer/FakePackage.html#method-i-copy_to","(path)",""],["copy_to","Gem::Package","Gem/Package.html#method-i-copy_to","(path)","<p>Copies this package to <code>path</code> (if possible)\n"],["core","Reline","Reline.html#method-c-core","()",""],["core_to_state","Racc::States","Racc/States.html#method-i-core_to_state","(core)",""],["coredump?","Process::Status","Process/Status.html#method-i-coredump-3F","()","<p>Returns <code>true</code> if <em>stat</em> generated a coredump when it terminated. Not available on all platforms.\n"],["correct?","Gem::Version","Gem/Version.html#method-c-correct-3F","(version)","<p>True if the <code>version</code> string matches RubyGems&#39; requirements.\n"],["correct_error","DidYouMean","DidYouMean.html#method-c-correct_error","(error_class, spell_checker)","<p>Adds <code>DidYouMean</code> functionality to an error using a given spell checker\n"],["correct_for_windows_path","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-correct_for_windows_path","(path)",""],["correct_for_windows_path","Gem::Util","Gem/Util.html#method-c-correct_for_windows_path","(path)","<p>Corrects <code>path</code> (usually returned by `URI.parse().path` on Windows), that comes with a leading slash.\n"],["corrections","UndefinedCommandError::SpellChecker","UndefinedCommandError/SpellChecker.html#method-i-corrections","()",""],["corrections","UnknownArgumentError::SpellChecker","UnknownArgumentError/SpellChecker.html#method-i-corrections","()",""],["cos","BigMath","BigMath.html#method-i-cos","(x, prec)","<p>Computes the cosine of <code>decimal</code> to the specified number of digits of precision, <code>numeric</code>.\n<p>If <code>decimal</code> is …\n"],["cos","Math","Math.html#method-c-cos","(p1)","<p>Computes the cosine of <code>x</code> (expressed in radians). Returns a Float in the range -1.0..1.0.\n<p>Domain: (-INFINITY, …\n"],["cosh","Math","Math.html#method-c-cosh","(p1)","<p>Computes the hyperbolic cosine of <code>x</code> (expressed in radians).\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: [1, …\n"],["count","Array","Array.html#method-i-count","(*args)","<p>Returns the number of elements.\n<p>If an argument is given, counts the number of elements which equal <code>obj</code> …\n"],["count","Enumerable","Enumerable.html#method-i-count","(p1)","<p>Returns the number of items in <code>enum</code> through enumeration. If an argument is given, the number of items …\n"],["count","GC","GC.html#method-c-count","()","<p>The number of times GC occurred.\n<p>It returns the number of times GC occurred since the process started. …\n"],["count","REXML::Functions","REXML/Functions.html#method-c-count","( node_set )","<p>Returns the size of the given list of nodes.\n"],["count","Range","Range.html#method-i-count","(*args)","<p>Identical to Enumerable#count, except it returns Infinity for endless ranges.\n"],["count","String","String.html#method-i-count","(*args)","<p>Each <code>other_str</code> parameter defines a set of characters to count.  The intersection of these sets defines …\n"],["count_imemo_objects","ObjectSpace","ObjectSpace.html#method-c-count_imemo_objects","(*args)","<p>Counts objects for each <code>T_IMEMO</code> type.\n<p>This method is only for MRI developers interested in performance …\n"],["count_nodes","ObjectSpace","ObjectSpace.html#method-c-count_nodes","(*args)","<p>Counts nodes for each node type.\n<p>This method is only for MRI developers interested in performance and …\n"],["count_objects","ObjectSpace","ObjectSpace.html#method-c-count_objects","(*args)","<p>Counts all objects grouped by type.\n<p>It returns a hash, such as:\n\n<pre>{\n  :TOTAL=&gt;10000,\n  :FREE=&gt;3011,\n  :T_OBJECT=&gt;6, ...</pre>\n"],["count_objects_size","ObjectSpace","ObjectSpace.html#method-c-count_objects_size","(*args)","<p>Counts objects size (in bytes) for each type.\n<p>Note that this information is incomplete.  You need to deal …\n"],["count_observers","Observable","Observable.html#method-i-count_observers","()","<p>Return the number of observers associated with this object.\n"],["count_symbols","ObjectSpace","ObjectSpace.html#method-c-count_symbols","(*args)","<p>Counts symbols for each Symbol type.\n<p>This method is only for MRI developers interested in performance …\n"],["count_tdata_objects","ObjectSpace","ObjectSpace.html#method-c-count_tdata_objects","(*args)","<p>Counts objects for each <code>T_DATA</code> type.\n<p>This method is only for MRI developers interested in performance …\n"],["covector","Vector","Vector.html#method-i-covector","()","<p>Creates a single-row matrix from this vector.\n"],["cover?","Bundler::VersionRanges::ReqR","Bundler/VersionRanges/ReqR.html#method-i-cover-3F","(v)",""],["cover?","Range","Range.html#method-i-cover-3F","(p1)","<p>Returns <code>true</code> if <code>obj</code> is between the begin and end of the range.\n<p>This tests <code>begin &lt;= obj &lt;= end</code> when …\n"],["coverage_level=","RDoc::Stats","RDoc/Stats.html#method-i-coverage_level-3D","(level)","<p>Sets coverage report level.  Accepted values are:\n<p>false or nil &mdash; No report\n<p>0 &mdash; Classes, modules, constants, …\n"],["cp","Bundler::FileUtils","Bundler/FileUtils.html#method-i-cp","(src, dest, preserve: nil, noop: nil, verbose: nil)","<p>Copies a file content <code>src</code> to <code>dest</code>.  If <code>dest</code> is a directory, copies <code>src</code> to <code>dest/src</code>.\n<p>If <code>src</code> is a list of …\n"],["cp","Bundler::FileUtils","Bundler/FileUtils.html#method-c-cp","(src, dest, preserve: nil, noop: nil, verbose: nil)","<p>Copies a file content <code>src</code> to <code>dest</code>.  If <code>dest</code> is a directory, copies <code>src</code> to <code>dest/src</code>.\n<p>If <code>src</code> is a list of …\n"],["cp","FileUtils","FileUtils.html#method-i-cp","(src, dest, preserve: nil, noop: nil, verbose: nil)","<p>Copies a file content <code>src</code> to <code>dest</code>.  If <code>dest</code> is a directory, copies <code>src</code> to <code>dest/src</code>.\n<p>If <code>src</code> is a list of …\n"],["cp","FileUtils","FileUtils.html#method-c-cp","(src, dest, preserve: nil, noop: nil, verbose: nil)","<p>Copies a file content <code>src</code> to <code>dest</code>.  If <code>dest</code> is a directory, copies <code>src</code> to <code>dest/src</code>.\n<p>If <code>src</code> is a list of …\n"],["cp_lr","Bundler::FileUtils","Bundler/FileUtils.html#method-i-cp_lr","(src, dest, noop: nil, verbose: nil, dereference_root: true, remove_destination: false)","<p>Hard link <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links all its contents recursively. If <code>dest</code> …\n"],["cp_lr","Bundler::FileUtils","Bundler/FileUtils.html#method-c-cp_lr","(src, dest, noop: nil, verbose: nil, dereference_root: true, remove_destination: false)","<p>Hard link <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links all its contents recursively. If <code>dest</code> …\n"],["cp_lr","FileUtils","FileUtils.html#method-c-cp_lr","(src, dest, noop: nil, verbose: nil, dereference_root: true, remove_destination: false)","<p>Hard link <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links all its contents recursively. If <code>dest</code> …\n"],["cp_lr","FileUtils","FileUtils.html#method-i-cp_lr","(src, dest, noop: nil, verbose: nil, dereference_root: true, remove_destination: false)","<p>Hard link <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links all its contents recursively. If <code>dest</code> …\n"],["cp_r","Bundler::FileUtils","Bundler/FileUtils.html#method-c-cp_r","(src, dest, preserve: nil, noop: nil, verbose: nil, dereference_root: true, remove_destination: nil)","<p>Copies <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies all its contents recursively. If <code>dest</code> is …\n"],["cp_r","Bundler::FileUtils","Bundler/FileUtils.html#method-i-cp_r","(src, dest, preserve: nil, noop: nil, verbose: nil, dereference_root: true, remove_destination: nil)","<p>Copies <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies all its contents recursively. If <code>dest</code> is …\n"],["cp_r","FileUtils","FileUtils.html#method-c-cp_r","(src, dest, preserve: nil, noop: nil, verbose: nil, dereference_root: true, remove_destination: nil)","<p>Copies <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies all its contents recursively. If <code>dest</code> is …\n"],["cp_r","FileUtils","FileUtils.html#method-i-cp_r","(src, dest, preserve: nil, noop: nil, verbose: nil, dereference_root: true, remove_destination: nil)","<p>Copies <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method copies all its contents recursively. If <code>dest</code> is …\n"],["cpu_match","Bundler::GemHelpers::PlatformMatch","Bundler/GemHelpers/PlatformMatch.html#method-c-cpu_match","(spec_platform, user_platform)",""],["cram_md5_challenge","Net::SMTP::Response","Net/SMTP/Response.html#method-i-cram_md5_challenge","()","<p>Creates a CRAM-MD5 challenge. You can view more information on CRAM-MD5 on Wikipedia: en.wikipedia.org/wiki/CRAM-MD5 …\n"],["cram_md5_response","Net::SMTP","Net/SMTP.html#method-i-cram_md5_response","(secret, challenge)","<p>CRAM-MD5: [RFC2195]\n"],["cram_secret","Net::SMTP","Net/SMTP.html#method-i-cram_secret","(secret, mask)",""],["crc","Zlib::GzipFile","Zlib/GzipFile.html#method-i-crc","()","<p>Returns CRC value of the uncompressed data.\n"],["crc32","Zlib","Zlib.html#method-c-crc32","(*args)","<p>Calculates CRC checksum for <code>string</code>, and returns updated value of <code>crc</code>. If <code>string</code> is omitted, it returns …\n"],["crc32_combine","Zlib","Zlib.html#method-c-crc32_combine","(p1, p2, p3)","<p>Combine two CRC-32 check values in to one.  <code>crc1</code> is the first CRC-32 value, <code>crc2</code> is the second CRC-32 …\n"],["crc_table","Zlib","Zlib.html#method-c-crc_table","()","<p>Returns the table for calculating CRC checksum as an array.\n"],["creatable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-creatable-3F","()","<p>Returns <code>true</code> if files may be created in the directory by STOU, STOR, APPE, and RNTO.\n"],["create","Fiddle::CStructBuilder","Fiddle/CStructBuilder.html#method-c-create","(klass, types, members)","<p>Construct a new class given a C:\n<p>class <code>klass</code> (CUnion, CStruct, or other that provide an #entity_class …\n"],["create","Fiddle::CStructBuilder","Fiddle/CStructBuilder.html#method-i-create","(klass, types, members)","<p>Construct a new class given a C:\n<p>class <code>klass</code> (CUnion, CStruct, or other that provide an #entity_class …\n"],["create","Gem::NoAliasYAMLTree","Gem/NoAliasYAMLTree.html#method-c-create","()",""],["create","Gem::Requirement","Gem/Requirement.html#method-c-create","(*inputs)","<p>Factory method to create a Gem::Requirement object.  Input may be a Version, a String, or nil.  Intended …\n"],["create","Gem::Version","Gem/Version.html#method-c-create","(input)","<p>Factory method to create a Version object. Input may be a Version or a String. Intended to simplify client …\n"],["create","Net::IMAP","Net/IMAP.html#method-i-create","(mailbox)","<p>Sends a CREATE command to create a new <code>mailbox</code>.\n<p>A Net::IMAP::NoResponseError is raised if a mailbox with …\n"],["create","OpenSSL::OCSP::Response","OpenSSL/OCSP/Response.html#method-c-create","(p1, p2)","<p>Creates an OpenSSL::OCSP::Response from <em>status</em> and <em>basic_response</em>.\n"],["create","OpenSSL::PKCS12","OpenSSL/PKCS12.html#method-c-create","(p1, p2, p3, p4, p5 = v5, p6 = v6, p7 = v7, p8 = v8, p9 = v9, p10 = v10)","<p>Parameters\n<p><em>pass</em> - string\n<p><em>name</em> - A string describing the key.\n"],["create","Psych::Visitors::JSONTree","Psych/Visitors/JSONTree.html#method-c-create","(options = {})",""],["create","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-c-create","()",""],["create","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-c-create","(options = {})",""],["create","Resolv::DNS::Name","Resolv/DNS/Name.html#method-c-create","(arg)","<p>Creates a new DNS name from <code>arg</code>.  <code>arg</code> can be:\n<p>Name &mdash; returns <code>arg</code>.\n<p>String &mdash; Creates a new Name.\n"],["create","Resolv::IPv4","Resolv/IPv4.html#method-c-create","(arg)",""],["create","Resolv::IPv6","Resolv/IPv6.html#method-c-create","(arg)","<p>Creates a new IPv6 address from <code>arg</code> which may be:\n<p>IPv6 &mdash; returns <code>arg</code>.\n<p>String &mdash; <code>arg</code> must match one of the IPv6::Regex* …\n"],["create","Resolv::LOC::Alt","Resolv/LOC/Alt.html#method-c-create","(arg)","<p>Creates a new LOC::Alt from <code>arg</code> which may be:\n<p>LOC::Alt &mdash; returns <code>arg</code>.\n<p>String &mdash; <code>arg</code> must match the LOC::Alt::Regex …\n"],["create","Resolv::LOC::Coord","Resolv/LOC/Coord.html#method-c-create","(arg)","<p>Creates a new LOC::Coord from <code>arg</code> which may be:\n<p>LOC::Coord &mdash; returns <code>arg</code>.\n<p>String &mdash; <code>arg</code> must match the LOC::Coord::Regex …\n"],["create","Resolv::LOC::Size","Resolv/LOC/Size.html#method-c-create","(arg)","<p>Creates a new LOC::Size from <code>arg</code> which may be:\n<p>LOC::Size &mdash; returns <code>arg</code>.\n<p>String &mdash; <code>arg</code> must match the LOC::Size::Regex …\n"],["create","Tempfile","Tempfile.html#method-c-create","(basename=\"\", tmpdir=nil, mode: 0, **options)","<p>Creates a temporary file as usual File object (not Tempfile). It doesn&#39;t use finalizer and delegation. …\n"],["create_bundle_path","Bundler::Installer","Bundler/Installer.html#method-i-create_bundle_path","()",""],["create_cert","Gem::Security","Gem/Security.html#method-c-create_cert","(subject, key, age = ONE_YEAR, extensions = EXTENSIONS, serial = 1)","<p>Creates an unsigned certificate for <code>subject</code> and <code>key</code>.  The lifetime of the key is from the current time …\n"],["create_cert_email","Gem::Security","Gem/Security.html#method-c-create_cert_email","(email, key, age = ONE_YEAR, extensions = EXTENSIONS)","<p>Creates a self-signed certificate with an issuer and subject from <code>email</code>, a subject alternative name of …\n"],["create_cert_self_signed","Gem::Security","Gem/Security.html#method-c-create_cert_self_signed","(subject, key, age = ONE_YEAR, extensions = EXTENSIONS, serial = 1)","<p>Creates a self-signed certificate with an issuer and subject of <code>subject</code> and the given <code>extensions</code> for …\n"],["create_conflict","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-create_conflict","(underlying_error = nil)","<p>@return [Conflict] a {Conflict} that reflects the failure to activate\n\n<pre>the {#possibility} in conjunction ...</pre>\n"],["create_conflict","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-create_conflict","()","<p>@return [Conflict] a {Conflict} that reflects the failure to activate\n\n<pre>the {#possibility} in conjunction ...</pre>\n"],["create_document","RDoc::Parser::ChangeLog","RDoc/Parser/ChangeLog.html#method-i-create_document","(groups)","<p>Creates an RDoc::Markup::Document given the <code>groups</code> of ChangeLog entries.\n"],["create_entries","RDoc::Parser::ChangeLog","RDoc/Parser/ChangeLog.html#method-i-create_entries","(entries)","<p>Returns a list of ChangeLog entries an RDoc::Markup nodes for the given <code>entries</code>.\n"],["create_entry","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-create_entry","(tuple, sec)",""],["create_ext","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-create_ext","(p1, p2, p3 = v3)","<p>Creates a new X509::Extension with passed values. See also x509v3_config(5).\n"],["create_ext_from_array","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-create_ext_from_array","(ary)",""],["create_ext_from_hash","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-create_ext_from_hash","(hash)",""],["create_ext_from_string","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-create_ext_from_string","(str)",""],["create_extension","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-create_extension","(*arg)",""],["create_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-create_file","(destination, *args, &block)","<p>Create a new file relative to the destination root with the given data, which is the return value of …\n"],["create_from","REXML::SourceFactory","REXML/SourceFactory.html#method-c-create_from","(arg)","<p>Generates a Source object @param arg Either a String, or an IO @return a Source, or nil if a bad argument …\n"],["create_guid","WIN32OLE","WIN32OLE.html#method-c-create_guid","()","<p>Creates GUID.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">create_guid</span> <span class=\"ruby-comment\"># =&gt; {1CB530F1-F6B1-404D-BCE6-1959BF91F4A8}</span>\n</pre>\n"],["create_header","MakeMakefile","MakeMakefile.html#method-i-create_header","(header = \"extconf.h\")","<p>Generates a header file consisting of the various macro definitions generated by other methods such as …\n"],["create_items","RDoc::Parser::ChangeLog","RDoc/Parser/ChangeLog.html#method-i-create_items","(items)","<p>Returns an RDoc::Markup::List containing the given <code>items</code> in the ChangeLog\n"],["create_key","Gem::Security","Gem/Security.html#method-c-create_key","(length = KEY_LENGTH, algorithm = KEY_ALGORITHM)","<p>Creates a new key pair of the specified <code>length</code> and <code>algorithm</code>.  The default is a 3072 bit RSA key.\n"],["create_link","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-create_link","(destination, *args)","<p>Create a new file relative to the destination root from the given source.\n<p>Parameters\n<p>destination&lt;String&gt; … &mdash; "],["create_listeners","WEBrick::Utils","WEBrick/Utils.html#method-c-create_listeners","(address, port)","<p>Creates TCP server sockets bound to <code>address</code>:<code>port</code> and returns them.\n<p>It will create IPV4 and IPV6 sockets …\n"],["create_listeners","WEBrick::Utils","WEBrick/Utils.html#method-i-create_listeners","(address, port)","<p>Creates TCP server sockets bound to <code>address</code>:<code>port</code> and returns them.\n<p>It will create IPV4 and IPV6 sockets …\n"],["create_makefile","MakeMakefile","MakeMakefile.html#method-i-create_makefile","(target, srcprefix = nil)","<p>Generates the Makefile for your extension, passing along any options and preprocessor constants that …\n"],["create_new_id","CGI::Session","CGI/Session.html#method-i-create_new_id","()","<p>Create a new session id.\n<p>The session id is a secure random number by SecureRandom if possible, otherwise …\n"],["create_option_parser","Gem::Command","Gem/Command.html#method-i-create_option_parser","()","<p>Creates an option parser and fills it in with the help info for the command.\n"],["create_request","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-create_request","(with_webrick_config)","<p>Creates the HTTPRequest used when handling the HTTP request. Can be overridden by subclasses.\n"],["create_request_pool","Gem::S3URISigner","Gem/S3URISigner.html#method-i-create_request_pool","(uri)",""],["create_response","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-create_response","(with_webrick_config)","<p>Creates the HTTPResponse used when handling the HTTP request. Can be overridden by subclasses.\n"],["create_self_signed_cert","WEBrick::Utils","WEBrick/Utils.html#method-i-create_self_signed_cert","(bits, cn, comment)","<p>Creates a self-signed certificate with the given number of <code>bits</code>, the issuer <code>cn</code> and a <code>comment</code> to be stored …\n"],["create_self_signed_cert","WEBrick::Utils","WEBrick/Utils.html#method-c-create_self_signed_cert","(bits, cn, comment)","<p>Creates a self-signed certificate with the given number of <code>bits</code>, the issuer <code>cn</code> and a <code>comment</code> to be stored …\n"],["create_ssl_params","Net::IMAP","Net/IMAP.html#method-i-create_ssl_params","(certs = nil, verify = true)",""],["create_ssl_params","Net::POP3","Net/POP3.html#method-c-create_ssl_params","(verify_or_params = {}, certs = nil)","<p>Constructs proper parameters from arguments\n"],["create_threads","Bundler::Worker","Bundler/Worker.html#method-i-create_threads","()",""],["create_tmap","Racc::States","Racc/States.html#method-i-create_tmap","(size)",""],["create_value","Fiddle::Importer","Fiddle/Importer.html#method-i-create_value","(ty, val=nil)","<p>Creates a class to wrap the C struct with the value <code>ty</code>\n<p>See also Fiddle::Importer.struct\n"],["created_specs","Gem::TestCase::SpecFetcherSetup","Gem/TestCase/SpecFetcherSetup.html#method-i-created_specs","()","<p>Returns a Hash of created Specification full names and the corresponding Specification.\n"],["credential_filtered_string","Bundler::URICredentialsFilter","Bundler/URICredentialsFilter.html#method-i-credential_filtered_string","(str_to_filter, uri)",""],["credential_filtered_uri","Bundler::URICredentialsFilter","Bundler/URICredentialsFilter.html#method-i-credential_filtered_uri","(uri_to_anonymize)",""],["credentials_for","Bundler::Settings","Bundler/Settings.html#method-i-credentials_for","(uri)",""],["credentials_path","Gem::ConfigFile","Gem/ConfigFile.html#method-i-credentials_path","()","<p>Location of RubyGems.org credentials\n"],["credless_remotes","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-credless_remotes","()",""],["cref_pop","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-cref_pop","()",""],["cref_push","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-cref_push","(name)",""],["critical","Net::SMTP","Net/SMTP.html#method-i-critical","()",""],["critical=","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-critical-3D","(p1)",""],["critical?","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-critical-3F","()",""],["crl=","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-crl-3D","(p1)",""],["crls","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-crls","()",""],["crls=","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-crls-3D","(p1)",""],["cross","IRB::Vec","IRB/Vec.html#method-i-cross","(other)",""],["cross","Vector","Vector.html#method-i-cross","(*vs)",""],["cross_check_for_errors","Bundler::Injector","Bundler/Injector.html#method-i-cross_check_for_errors","(gemfile_path, original_deps, removed_deps, initial_gemfile)","<p>@param [Pathname] gemfile_path   The Gemfile from which to remove dependencies. @param [Array] original_deps …\n"],["cross_product","Vector","Vector.html#method-i-cross_product","(*vs)","<p>Returns the cross product of this vector with the others.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">0</span>, <span class=\"ruby-value\">0</span>].<span class=\"ruby-identifier\">cross_product</span> <span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">0</span>, <span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">0</span>] <span class=\"ruby-operator\">...</span>\n</pre>\n"],["crypt","String","String.html#method-i-crypt","(p1)","<p>Returns the string generated by calling <code>crypt(3)</code> standard library function with <code>str</code> and <code>salt_str</code>, in …\n"],["css","RDoc::Markdown","RDoc/Markdown.html#method-i-css","","<p>Allow style blocks\n"],["csv_attr_reader","RSS::BaseModel","RSS/BaseModel.html#method-i-csv_attr_reader","(*attrs)",""],["csv_integer_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-csv_integer_writer","(name, disp_name=name)",""],["csv_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-csv_writer","(name, disp_name=name)",""],["ctime","Date","Date.html#method-i-ctime","()","<p>Returns a string in asctime(3) format (but without “n0” at the end).  This method is equivalent …\n"],["ctime","File","File.html#method-i-ctime","()","<p>Returns the change time for <em>file</em> (that is, the time directory information about the file was changed, …\n"],["ctime","File","File.html#method-c-ctime","(p1)","<p>Returns the change time for the named file (the time at which directory information about the file was …\n"],["ctime","File::Stat","File/Stat.html#method-i-ctime","()","<p>Returns the change time for <em>stat</em> (that is, the time directory information about the file was changed, …\n"],["ctime","Pathname","Pathname.html#method-i-ctime","()","<p>Returns the last change time, using directory information, not the file itself.\n<p>See File.ctime.\n"],["ctime","Time","Time.html#method-i-ctime","()","<p>Returns a canonical string representation of <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>.<span class=\"ruby-identifier\">asctime</span>   <span class=\"ruby-comment\">#=&gt; &quot;Wed Apr  9 08:56:03 2003&quot;</span>\n<span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>.<span class=\"ruby-identifier\">ctime</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ctrl_cmd","OpenSSL::Engine","OpenSSL/Engine.html#method-i-ctrl_cmd","(p1, p2 = v2)","<p>Sends the given <em>command</em> to this engine.\n<p>Raises an EngineError if the command fails.\n"],["current","Fiber","Fiber.html#method-c-current","()","<p>Returns the current fiber. You need to <code>require &#39;fiber&#39;</code> before using this method. If you are not …\n"],["current","RDoc::RDoc","RDoc/RDoc.html#method-c-current","()","<p>Active RDoc::RDoc instance\n"],["current","Thread","Thread.html#method-c-current","()","<p>Returns the currently executing thread.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">current</span>   <span class=\"ruby-comment\">#=&gt; #&lt;Thread:0x401bdf4c run&gt;</span>\n</pre>\n"],["current=","RDoc::RDoc","RDoc/RDoc.html#method-c-current-3D","(rdoc)","<p>Sets the active RDoc::RDoc instance\n"],["current_cert","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-current_cert","()",""],["current_command","Bundler::CLI","Bundler/CLI.html#method-i-current_command","()",""],["current_command_chain","Bundler::Thor::Invocation","Bundler/Thor/Invocation.html#method-i-current_command_chain","()","<p>Make the current command chain accessible with in a Bundler::Thor-(sub)command\n"],["current_crl","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-current_crl","()",""],["current_dependencies","Bundler::Definition","Bundler/Definition.html#method-i-current_dependencies","()",""],["current_dependencies","Bundler::Gemdeps","Bundler/Gemdeps.html#method-i-current_dependencies","()",""],["current_element","RSS::Maker::Base","RSS/Maker/Base.html#method-i-current_element","(feed)",""],["current_env?","Bundler::Dependency","Bundler/Dependency.html#method-i-current_env-3F","()",""],["current_group","PrettyPrint","PrettyPrint.html#method-i-current_group","()","<p>Returns the group most recently added to the stack.\n<p>Contrived example:\n\n<pre>out = &quot;&quot;\n=&gt; &quot;&quot;\nq = PrettyPrint.new(out) ...</pre>\n"],["current_line","REXML::IOSource","REXML/IOSource.html#method-i-current_line","()","<p>@return the current line in the source\n"],["current_line","REXML::Source","REXML/Source.html#method-i-current_line","()","<p>@return the current line in the source\n"],["current_platform?","Bundler::Dependency","Bundler/Dependency.html#method-i-current_platform-3F","()",""],["current_platforms","Bundler::Definition","Bundler/Definition.html#method-i-current_platforms","()",""],["current_ruby","Bundler","Bundler.html#method-c-current_ruby","()","<p>Returns current version of Ruby\n<p>@return [CurrentRuby] Current version of Ruby\n"],["current_section","RDoc::Context","RDoc/Context.html#method-i-current_section","()","<p>The current documentation section that new items will be added to.  If temporary_section is available …\n"],["current_server","DRb","DRb.html#method-c-current_server","()","<p>Get the &#39;current&#39; server.\n<p>In the context of execution taking place within the main thread of a …\n"],["current_server","DRb","DRb.html#method-i-current_server","()","<p>Get the &#39;current&#39; server.\n<p>In the context of execution taking place within the main thread of a …\n"],["curry","Method","Method.html#method-i-curry","(*args)","<p>Returns a curried proc based on the method. When the proc is called with a number of arguments that is …\n"],["curry","Proc","Proc.html#method-i-curry","(*args)","<p>Returns a curried proc. If the optional <em>arity</em> argument is given, it determines the number of arguments. …\n"],["cursor","IO","IO.html#method-i-cursor","()",""],["cursor=","IO","IO.html#method-i-cursor-3D","(p1)",""],["cursor_down","IO","IO.html#method-i-cursor_down","(p1)",""],["cursor_left","IO","IO.html#method-i-cursor_left","(p1)",""],["cursor_right","IO","IO.html#method-i-cursor_right","(p1)",""],["cursor_up","IO","IO.html#method-i-cursor_up","(p1)",""],["curve_name","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-curve_name","()","<p>Returns the curve name (sn).\n<p>See the OpenSSL documentation for EC_GROUP_get_curve_name()\n"],["cwday","Date","Date.html#method-i-cwday","()","<p>Returns the day of calendar week (1-7, Monday is 1).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">cwday</span>          <span class=\"ruby-comment\">#=&gt; 6</span>\n</pre>\n"],["cweek","Date","Date.html#method-i-cweek","()","<p>Returns the calendar week number (1-53).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">cweek</span>          <span class=\"ruby-comment\">#=&gt; 5</span>\n</pre>\n"],["cwyear","Date","Date.html#method-i-cwyear","()","<p>Returns the calendar week based year.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">cwyear</span>         <span class=\"ruby-comment\">#=&gt; 2001</span>\n<span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>).<span class=\"ruby-identifier\">cwyear</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["cycle","Array","Array.html#method-i-cycle","(*args)","<p>Calls the given block for each element <code>n</code> times or forever if <code>nil</code> is given.\n<p>Does nothing if a non-positive …\n"],["cycle","Enumerable","Enumerable.html#method-i-cycle","(*args)","<p>Calls <em>block</em> for each element of <em>enum</em> repeatedly <em>n</em> times or forever if none or <code>nil</code> is given.  If a non-positive …\n"],["d","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-d","()",""],["daemon","Process","Process.html#method-c-daemon","(*args)","<p>Detach the process from controlling terminal and run in the background as system daemon.  Unless the …\n"],["data","Net::SMTP","Net/SMTP.html#method-i-data","(msgstr = nil)","<p>This method sends a message. If <code>msgstr</code> is given, sends it as a message. If block is given, yield a message …\n"],["data","Resolv::DNS::Resource::TXT","Resolv/DNS/Resource/TXT.html#method-i-data","()","<p>Returns the concatenated string from <code>strings</code>.\n"],["data","Socket::AncillaryData","Socket/AncillaryData.html#method-i-data","()","<p>returns the cmsg data as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AncillaryData</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:PKTINFO</span>, <span class=\"ruby-string\">&quot;&quot;</span>).<span class=\"ruby-identifier\">data</span>\n<span class=\"ruby-comment\">#=&gt; &quot;&quot;</span>\n</pre>\n"],["data","Socket::Option","Socket/Option.html#method-i-data","()","<p>returns the socket option data as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:RECVPKTINFO</span>, [<span class=\"ruby-value\">1</span>].<span class=\"ruby-identifier\">pack</span>(<span class=\"ruby-string\">&quot;i!&quot;</span>)).<span class=\"ruby-identifier\">data</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["data=","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-data-3D","(p1)",""],["data_type","Zlib::ZStream","Zlib/ZStream.html#method-i-data_type","()","<p>Guesses the type of the data which have been inputed into the stream. The returned value is either <code>BINARY</code> …\n"],["datadir","Gem","Gem.html#method-c-datadir","(gem_name)","<p>The path to the data directory specified by the gem name.  If the package is not available as a gem, …\n"],["datadir","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-datadir","()","<p>The path to the data directory for this gem.\n"],["date","Gem::Specification","Gem/Specification.html#method-i-date","()","<p>The date this gem was created.\n<p>If SOURCE_DATE_EPOCH is set as an environment variable, use that to support …\n"],["date=","Gem::Specification","Gem/Specification.html#method-i-date-3D","(date)","<p>The date this gem was created\n<p>DO NOT set this, it is set automatically when the gem is packaged.\n"],["date=","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-date-3D","(_date)",""],["date=","RSS::Maker::ItemsBase::ItemBase","RSS/Maker/ItemsBase/ItemBase.html#method-i-date-3D","(_date)",""],["date=","RSS::Maker::ItemsBase::ItemBase::SourceBase","RSS/Maker/ItemsBase/ItemBase/SourceBase.html#method-i-date-3D","(_date)",""],["date_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-date_writer","(name, type, disp_name=name)",""],["datetime_format","Logger","Logger.html#method-i-datetime_format","()","<p>Returns the date format being used.  See #datetime_format=\n"],["datetime_format=","Logger","Logger.html#method-i-datetime_format-3D","(datetime_format)","<p>Set date-time format.\n<p><code>datetime_format</code> &mdash; A string suitable for passing to <code>strftime</code>.\n\n"],["day","Date","Date.html#method-i-day","()","<p>Returns the day of the month (1-31).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">mday</span>           <span class=\"ruby-comment\">#=&gt; 3</span>\n</pre>\n"],["day","Time","Time.html#method-i-day","()","<p>Returns the day of the month (1..n) for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:27:03 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">day</span>      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["day_fraction","Date","Date.html#method-i-day_fraction","()","<p>Returns the fractional part of the day.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">12</span>).<span class=\"ruby-identifier\">day_fraction</span>    <span class=\"ruby-comment\">#=&gt; (1/2)</span>\n</pre>\n"],["dclone","Array","Array.html#method-i-dclone","()","<p>provides a unified <code>clone</code> operation, for REXML::XPathParser to use across multiple Object+ types\n"],["dclone","Float","Float.html#method-i-dclone","()","<p>provides a unified <code>clone</code> operation, for REXML::XPathParser to use across multiple Object types\n"],["dclone","Integer","Integer.html#method-i-dclone","()","<p>provides a unified <code>clone</code> operation, for REXML::XPathParser to use across multiple Object types\n"],["dclone","Object","Object.html#method-i-dclone","()","<p>provides a unified <code>clone</code> operation, for REXML::XPathParser to use across multiple Object types\n"],["dclone","Symbol","Symbol.html#method-i-dclone","()","<p>provides a unified <code>clone</code> operation, for REXML::XPathParser to use across multiple Object types\n"],["deafen","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-deafen","( listener=nil, &blok )",""],["debug","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-c-debug","()",""],["debug","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-debug","(depth = 0, &block)","<p>Calls the {#resolver_ui}&#39;s {UI#debug} method @param [Integer] depth the depth of the {#states} stack …\n"],["debug","Bundler::Molinillo::UI","Bundler/Molinillo/UI.html#method-i-debug","(depth = 0)","<p>Conveys debug information to the user.\n<p>@param [Integer] depth the current depth of the resolution process. …\n"],["debug","Bundler::Resolver","Bundler/Resolver.html#method-i-debug","(depth = 0)","<p>Conveys debug information to the user.\n<p>@param [Integer] depth the current depth of the resolution process. …\n"],["debug","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-debug","(msg, newline = nil)",""],["debug","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-debug","(message, newline = nil)",""],["debug","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-debug","(depth = 0, &block)","<p>Calls the {#resolver_ui}&#39;s {UI#debug} method @param [Integer] depth the depth of the {#states} stack …\n"],["debug","Gem::Resolver::Molinillo::UI","Gem/Resolver/Molinillo/UI.html#method-i-debug","(depth = 0)","<p>Conveys debug information to the user.\n<p>@param [Integer] depth the current depth of the resolution process. …\n"],["debug","Gem::StreamUI","Gem/StreamUI.html#method-i-debug","(statement)","<p>Display a debug message on the same location as error messages.\n"],["debug","Logger","Logger.html#method-i-debug","(progname = nil, &block)","<p>Log a <code>DEBUG</code> message.\n<p>See #info for more information.\n"],["debug","Net::IMAP","Net/IMAP.html#method-c-debug","()","<p>Returns the debug mode.\n"],["debug","OpenSSL","OpenSSL.html#method-c-debug","()",""],["debug","Syslog::Logger","Syslog/Logger.html#method-i-debug","","<p>Logs a <code>message</code> at the debug (syslog debug) log level, or logs the message returned from the block.\n"],["debug","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-debug","(msg)","<p>Shortcut for logging a DEBUG message\n"],["debug!","Logger","Logger.html#method-i-debug-21","()","<p>Sets the severity to DEBUG.\n"],["debug=","Net::IMAP","Net/IMAP.html#method-c-debug-3D","(val)","<p>Sets the debug mode.\n"],["debug=","OpenSSL","OpenSSL.html#method-c-debug-3D","(p1)","<p>Turns on or off debug mode. With debug mode, all erros added to the OpenSSL error queue will be printed …\n"],["debug?","Bundler::Molinillo::UI","Bundler/Molinillo/UI.html#method-i-debug-3F","()","<p>Whether or not debug messages should be printed. By default, whether or not the `MOLINILLO_DEBUG` environment …\n"],["debug?","Bundler::Resolver","Bundler/Resolver.html#method-i-debug-3F","()",""],["debug?","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-debug-3F","()",""],["debug?","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-debug-3F","()",""],["debug?","Gem::Resolver","Gem/Resolver.html#method-i-debug-3F","()",""],["debug?","Gem::Resolver::Molinillo::UI","Gem/Resolver/Molinillo/UI.html#method-i-debug-3F","()","<p>Whether or not debug messages should be printed. By default, whether or not the `MOLINILLO_DEBUG` environment …\n"],["debug?","Logger","Logger.html#method-i-debug-3F","()","<p>Returns <code>true</code> iff the current severity level allows for the printing of <code>DEBUG</code> messages.\n"],["debug?","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-debug-3F","()","<p>Will the logger output DEBUG messages?\n"],["debug_format_result","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-debug_format_result","(dep, spec_groups)",""],["debug_output","Ripper","Ripper.html#method-i-debug_output","()","<p>Get debug output.\n"],["debug_output=","Net::SMTP","Net/SMTP.html#method-i-debug_output-3D","(arg)","<p>WARNING: This method causes serious security holes. Use this method for only debugging.\n<p>Set an output …\n"],["debug_output=","Ripper","Ripper.html#method-i-debug_output-3D","(p1)","<p>Set debug output.\n"],["debug_thread_info","DEBUGGER__","DEBUGGER__.html#method-c-debug_thread_info","(input, binding)",""],["declare","Gem::TestCase::SpecFetcherSetup","Gem/TestCase/SpecFetcherSetup.html#method-c-declare","(test, repository)","<p>Executes a SpecFetcher setup block.  Yields an instance then creates the gems and specifications defined …\n"],["declare_precedence","Racc::Grammar","Racc/Grammar.html#method-i-declare_precedence","(assoc, syms)",""],["decode","Bundler::URI::Escape","Bundler/URI/Escape.html#method-i-decode","(*arg)",""],["decode","OpenSSL::ASN1","OpenSSL/ASN1.html#method-c-decode","(p1)","<p>Decodes a BER- or DER-encoded value and creates an ASN1Data instance. <em>der</em> may be a String or any object …\n"],["decode","REXML::Encoding","REXML/Encoding.html#method-i-decode","(string)",""],["decode","URI::Escape","URI/Escape.html#method-i-decode","(*arg)",""],["decode64","Base64","Base64.html#method-i-decode64","(str)","<p>Returns the Base64-decoded version of <code>str</code>. This method complies with RFC 2045. Characters outside the …\n"],["decode_all","OpenSSL::ASN1","OpenSSL/ASN1.html#method-c-decode_all","(p1)","<p>Similar to #decode with the difference that #decode expects one distinct value represented in <em>der</em>. #decode_all …\n"],["decode_utf7","Net::IMAP","Net/IMAP.html#method-c-decode_utf7","(s)","<p>Decode a string from modified UTF-7 format to UTF-8.\n<p>UTF-7 is a 7-bit encoding of Unicode [UTF7].  IMAP …\n"],["decode_www_form","Bundler::URI","Bundler/URI.html#method-c-decode_www_form","(str, enc=Encoding::UTF_8, separator: '&', use__charset_: false, isindex: false)","<p>Decodes URL-encoded form data from given <code>str</code>.\n<p>This decodes application/x-www-form-urlencoded data and …\n"],["decode_www_form","URI","URI.html#method-c-decode_www_form","(str, enc=Encoding::UTF_8, separator: '&', use__charset_: false, isindex: false)","<p>Decodes URL-encoded form data from given <code>str</code>.\n<p>This decodes application/x-www-form-urlencoded data and …\n"],["decode_www_form_component","Bundler::URI","Bundler/URI.html#method-c-decode_www_form_component","(str, enc=Encoding::UTF_8)","<p>Decodes given <code>str</code> of URL-encoded form data.\n<p>This decodes + to SP.\n<p>See Bundler::URI.encode_www_form_component …\n"],["decode_www_form_component","URI","URI.html#method-c-decode_www_form_component","(str, enc=Encoding::UTF_8)","<p>Decodes given <code>str</code> of URL-encoded form data.\n<p>This decodes + to SP.\n<p>See URI.encode_www_form_component, URI.decode_www_form …\n"],["deconstruct","Array","Array.html#method-i-deconstruct","()",""],["deconstruct","Struct","Struct.html#method-i-deconstruct","()","<p>Returns the values for this struct as an Array.\n\n<pre>Customer = Struct.new(:name, :address, :zip)\njoe = Customer.new(&quot;Joe ...</pre>\n"],["deconstruct_keys","Hash","Hash.html#method-i-deconstruct_keys","(p1)",""],["deconstruct_keys","Struct","Struct.html#method-i-deconstruct_keys","(p1)",""],["decref","Racc::Reduce","Racc/Reduce.html#method-i-decref","()",""],["decrypt","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-decrypt","(*args)","<p>Initializes the Cipher for decryption.\n<p>Make sure to call Cipher#encrypt or Cipher#decrypt before using …\n"],["decrypt","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-decrypt","(p1, p2, p3 = v3)",""],["dedent_string","Ripper","Ripper.html#method-i-dedent_string","(p1, p2)","<p>USE OF RIPPER LIBRARY ONLY.\n<p>Strips up to <code>width</code> leading whitespaces from <code>input</code>, and returns the stripped …\n"],["dedent_string","Ripper","Ripper.html#method-c-dedent_string","(p1, p2)","<p>USE OF RIPPER LIBRARY ONLY.\n<p>Strips up to <code>width</code> leading whitespaces from <code>input</code>, and returns the stripped …\n"],["deduplicate","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-deduplicate","(key)",""],["deduplicate_call_seq","RDoc::Parser::C","RDoc/Parser/C.html#method-i-deduplicate_call_seq","()","<p>Removes duplicate call-seq entries for methods using the same implementation.\n"],["deep_clone","REXML::Parent","REXML/Parent.html#method-i-deep_clone","()","<p>Deeply clones this object.  This creates a complete duplicate of this Parent, including all descendants. …\n"],["def_array_element","RSS::Maker::Base","RSS/Maker/Base.html#method-c-def_array_element","(name, plural=nil, klass_name=nil)",""],["def_atom_persons","RSS::Maker::AtomPersons","RSS/Maker/AtomPersons.html#method-i-def_atom_persons","(klass, name, maker_name, plural=nil)",""],["def_atom_text_construct","RSS::Maker::AtomTextConstruct","RSS/Maker/AtomTextConstruct.html#method-c-def_atom_text_construct","(klass, name, maker_name, klass_name=nil, atom_klass_name=nil)",""],["def_children_accessor","RSS::BaseModel","RSS/BaseModel.html#method-i-def_children_accessor","(accessor_name, plural_name)",""],["def_class","ERB","ERB.html#method-i-def_class","(superklass=Object, methodname='result')","<p>Define unnamed class which has <em>methodname</em> as instance method, and return it.\n<p>example:\n\n<pre>class MyClass_\n  ...</pre>\n"],["def_class_accessor","RSS::ITunesModelUtils","RSS/ITunesModelUtils.html#method-i-def_class_accessor","(klass, name, type, *args)",""],["def_class_accessor","RSS::Maker::ITunesBaseModel","RSS/Maker/ITunesBaseModel.html#method-i-def_class_accessor","(klass, name, type, *args)",""],["def_classed_element","RSS::Maker::Base","RSS/Maker/Base.html#method-c-def_classed_element","(name, class_name=nil, attribute_name=nil)",""],["def_classed_element_without_accessor","RSS::Maker::Base","RSS/Maker/Base.html#method-c-def_classed_element_without_accessor","(name, class_name=nil)",""],["def_classed_elements","RSS::Maker::Base","RSS/Maker/Base.html#method-c-def_classed_elements","(name, attribute, plural_class_name=nil, plural_name=nil, new_name=nil)",""],["def_convert","RSS::Converter","RSS/Converter.html#method-i-def_convert","(depth=0)",""],["def_corresponded_attr_reader","RSS::Element","RSS/Element.html#method-c-def_corresponded_attr_reader","(name, type=nil)",""],["def_corresponded_attr_writer","RSS::Element","RSS/Element.html#method-c-def_corresponded_attr_writer","(name, type=nil, disp_name=nil)",""],["def_csv_accessor","RSS::Maker::ITunesBaseModel","RSS/Maker/ITunesBaseModel.html#method-i-def_csv_accessor","(klass, full_name)",""],["def_csv_element","RSS::Maker::Base","RSS/Maker/Base.html#method-c-def_csv_element","(name, type=nil)",""],["def_delegator","Forwardable","Forwardable.html#method-i-def_delegator","(accessor, method, ali = method)",""],["def_delegator","SingleForwardable","SingleForwardable.html#method-i-def_delegator","(accessor, method, ali = method)",""],["def_delegators","Forwardable","Forwardable.html#method-i-def_delegators","(accessor, *methods)",""],["def_delegators","SingleForwardable","SingleForwardable.html#method-i-def_delegators","(accessor, *methods)",""],["def_element_class_accessor","RSS::ITunesModelUtils","RSS/ITunesModelUtils.html#method-i-def_element_class_accessor","(klass, name, full_name, klass_name, recommended_attribute_name=nil)",""],["def_elements_class_accessor","RSS::ITunesModelUtils","RSS/ITunesModelUtils.html#method-i-def_elements_class_accessor","(klass, name, full_name, klass_name, plural_name, recommended_attribute_name=nil)",""],["def_elements_class_accessor","RSS::Maker::ITunesBaseModel","RSS/Maker/ITunesBaseModel.html#method-i-def_elements_class_accessor","(klass, name, full_name, full_plural_name, klass_name, plural_klass_name, recommended_attribute_name=nil)",""],["def_else_enc","RSS::Converter","RSS/Converter.html#method-i-def_else_enc","(to_enc, from_enc)",""],["def_erb_method","ERB::DefMethod","ERB/DefMethod.html#method-c-def_erb_method","(methodname, erb_or_fname)","<p>define <em>methodname</em> as instance method of current module, using ERB object or eRuby file\n"],["def_erb_method","ERB::DefMethod","ERB/DefMethod.html#method-i-def_erb_method","(methodname, erb_or_fname)","<p>define <em>methodname</em> as instance method of current module, using ERB object or eRuby file\n"],["def_explicit_clean_other_accessor","RSS::Maker::ITunesBaseModel","RSS/Maker/ITunesBaseModel.html#method-i-def_explicit_clean_other_accessor","(klass, full_name)",""],["def_extend_command","IRB::ContextExtender","IRB/ContextExtender.html#method-c-def_extend_command","(cmd_name, load_file, *aliases)","<p>Evaluate the given <code>command</code> from the given <code>load_file</code> on the Context module.\n<p>Will also define any given …\n"],["def_extend_command","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-c-def_extend_command","(cmd_name, cmd_class, load_file = nil, *aliases)","<p>Evaluate the given <code>cmd_name</code> on the given <code>cmd_class</code> Class.\n<p>Will also define any given <code>aliases</code> for the method. …\n"],["def_get_text_element","RSS::BaseListener","RSS/BaseListener.html#method-c-def_get_text_element","(uri, element_name, file, line)",""],["def_head_option","OptionParser","OptionParser.html#method-i-def_head_option","(*opts, &block)",""],["def_iconv_convert","RSS::Converter","RSS/Converter.html#method-i-def_iconv_convert","(to_enc, from_enc, depth=0)",""],["def_inspector","IRB::Inspector","IRB/Inspector.html#method-c-def_inspector","(key, arg=nil, &block)","<p>Example\n\n<pre>Inspector.def_inspector(key, init_p=nil){|v| v.inspect}\nInspector.def_inspector([key1,..], init_p=nil){|v| ...</pre>\n"],["def_instance_delegator","Forwardable","Forwardable.html#method-i-def_instance_delegator","(accessor, method, ali = method)","<p>Define <code>method</code> as delegator instance method with an optional alias name <code>ali</code>. Method calls to <code>ali</code> will …\n"],["def_instance_delegators","Forwardable","Forwardable.html#method-i-def_instance_delegators","(accessor, *methods)","<p>Shortcut for defining multiple delegator methods, but with no provision for using a different name.  …\n"],["def_method","ERB","ERB.html#method-i-def_method","(mod, methodname, fname='(ERB)')","<p>Define <em>methodname</em> as instance method of <em>mod</em> from compiled Ruby source.\n<p>example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">filename</span> = <span class=\"ruby-string\">&#39;example.rhtml&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["def_module","ERB","ERB.html#method-i-def_module","(methodname='erb')","<p>Create unnamed module, define <em>methodname</em> as instance method of it, and return it.\n<p>example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">filename</span> = <span class=\"ruby-string\">&#39;example.rhtml&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["def_notifier","IRB::Notifier","IRB/Notifier.html#method-c-def_notifier","(prefix = \"\", output_method = StdioOutputMethod.new)","<p>Define a new Notifier output source, returning a new CompositeNotifier with the given <code>prefix</code> and <code>output_method</code> …\n"],["def_notifier","IRB::Notifier","IRB/Notifier.html#method-i-def_notifier","(prefix = \"\", output_method = StdioOutputMethod.new)","<p>Define a new Notifier output source, returning a new CompositeNotifier with the given <code>prefix</code> and <code>output_method</code> …\n"],["def_notifier","IRB::Notifier::CompositeNotifier","IRB/Notifier/CompositeNotifier.html#method-i-def_notifier","(level, prefix = \"\")","<p>Creates a new LeveledNotifier in the composite #notifiers group.\n<p>The given <code>prefix</code> will be assigned to …\n"],["def_option","OptionParser","OptionParser.html#method-i-def_option","(*opts, &block)",""],["def_other_element","RSS::Maker::Base","RSS/Maker/Base.html#method-c-def_other_element","(name)",""],["def_other_element_without_accessor","RSS::Maker::Base","RSS/Maker/Base.html#method-c-def_other_element_without_accessor","(name)",""],["def_post_proc","IRB::MethodExtender","IRB/MethodExtender.html#method-i-def_post_proc","(base_method, extend_method)","<p>Extends the given <code>base_method</code> with a postfix call to the given <code>extend_method</code>.\n"],["def_pre_proc","IRB::MethodExtender","IRB/MethodExtender.html#method-i-def_pre_proc","(base_method, extend_method)","<p>Extends the given <code>base_method</code> with a prefix call to the given <code>extend_method</code>.\n"],["def_same_enc","RSS::Converter","RSS/Converter.html#method-i-def_same_enc","()",""],["def_single_delegator","SingleForwardable","SingleForwardable.html#method-i-def_single_delegator","(accessor, method, ali = method)","<p>Defines a method <em>method</em> which delegates to <em>accessor</em> (i.e. it calls the method of the same name in <em>accessor</em> …\n"],["def_single_delegators","SingleForwardable","SingleForwardable.html#method-i-def_single_delegators","(accessor, *methods)","<p>Shortcut for defining multiple delegator methods, but with no provision for using a different name.  …\n"],["def_tail_option","OptionParser","OptionParser.html#method-i-def_tail_option","(*opts, &block)",""],["def_to_euc_jp_from_iso_2022_jp","RSS::Converter","RSS/Converter.html#method-i-def_to_euc_jp_from_iso_2022_jp","()",""],["def_to_euc_jp_from_shift_jis","RSS::Converter","RSS/Converter.html#method-i-def_to_euc_jp_from_shift_jis","()",""],["def_to_euc_jp_from_utf_8","RSS::Converter","RSS/Converter.html#method-i-def_to_euc_jp_from_utf_8","()",""],["def_to_iso_2022_jp_from_euc_jp","RSS::Converter","RSS/Converter.html#method-i-def_to_iso_2022_jp_from_euc_jp","()",""],["def_to_iso_8859_1_from_utf_8","RSS::Converter","RSS/Converter.html#method-i-def_to_iso_8859_1_from_utf_8","()",""],["def_to_shift_jis_from_euc_jp","RSS::Converter","RSS/Converter.html#method-i-def_to_shift_jis_from_euc_jp","()",""],["def_to_shift_jis_from_utf_8","RSS::Converter","RSS/Converter.html#method-i-def_to_shift_jis_from_utf_8","()",""],["def_to_utf_8_from_euc_jp","RSS::Converter","RSS/Converter.html#method-i-def_to_utf_8_from_euc_jp","()",""],["def_to_utf_8_from_iso_8859_1","RSS::Converter","RSS/Converter.html#method-i-def_to_utf_8_from_iso_8859_1","()",""],["def_to_utf_8_from_shift_jis","RSS::Converter","RSS/Converter.html#method-i-def_to_utf_8_from_shift_jis","()",""],["def_uconv_convert_if_can","RSS::Converter","RSS/Converter.html#method-i-def_uconv_convert_if_can","(meth, to_enc, from_enc, nkf_arg)",""],["def_yes_other_accessor","RSS::Maker::ITunesBaseModel","RSS/Maker/ITunesBaseModel.html#method-i-def_yes_other_accessor","(klass, full_name)",""],["default","Gem::Requirement","Gem/Requirement.html#method-c-default","()",""],["default","Hash","Hash.html#method-i-default","(*args)","<p>Returns the default value, the value that would be returned by <em>hsh</em> if <em>key</em> did not exist in <em>hsh</em>. See also …\n"],["default","REXML::XMLDecl","REXML/XMLDecl.html#method-c-default","()","<p>Only use this if you do not want the XML declaration to be written; this object is ignored by the XML …\n"],["default","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-default","()","<p>Returns default value. If the default value does not exist, this method returns nil.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["default=","Hash","Hash.html#method-i-default-3D","(p1)","<p>Sets the default value, the value returned for a key that does not exist in the hash. It is not possible …\n"],["default_acl","DRb::DRbServer","DRb/DRbServer.html#method-c-default_acl","(acl)","<p>Set the default access control list to <code>acl</code>.  The default ACL is <code>nil</code>.\n<p>See also DRb::ACL and #new()\n"],["default_argc_limit","DRb::DRbServer","DRb/DRbServer.html#method-c-default_argc_limit","(argc)","<p>Set the default value for the :argc_limit option.\n<p>See #new().  The initial default value is 256.\n"],["default_attempts","Bundler::Retry","Bundler/Retry.html#method-c-default_attempts","()",""],["default_bindir","Gem","Gem.html#method-c-default_bindir","()","<p>The default directory for binaries\n"],["default_bundle_dir","Bundler","Bundler.html#method-c-default_bundle_dir","()",""],["default_bundle_dir","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-default_bundle_dir","()",""],["default_cert_path","Gem","Gem.html#method-c-default_cert_path","()","<p>The default signing certificate chain path\n"],["default_command","Bundler::Thor","Bundler/Thor.html#method-c-default_command","(meth = nil)","<p>Sets the default command when thor is executed without an explicit command to be called.\n<p>Parameters\n<p>meth&lt;Symbol&gt; … &mdash; "],["default_dir","Gem","Gem.html#method-c-default_dir","()","<p>Default home directory path to be used if an alternate value is not specified in the environment\n"],["default_event_sources","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-default_event_sources","()","<p>Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE object and having …\n"],["default_exec_format","Gem","Gem.html#method-c-default_exec_format","()","<p>Deduce Ruby&#39;s –program-prefix and –program-suffix from its install name\n"],["default_ext_dir_for","Gem","Gem.html#method-c-default_ext_dir_for","(base_dir)","<p>Returns binary extensions dir for specified RubyGems base dir or nil if such directory cannot be determined. …\n"],["default_external","Encoding","Encoding.html#method-c-default_external","()","<p>Returns default external encoding.\n<p>The default external encoding is used by default for strings created …\n"],["default_external=","Encoding","Encoding.html#method-c-default_external-3D","(p1)","<p>Sets default external encoding.  You should not set Encoding::default_external in ruby code as strings …\n"],["default_gem","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-default_gem","()",""],["default_gem?","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-default_gem-3F","()",""],["default_gem_spec","Bundler::CLI::Info","Bundler/CLI/Info.html#method-i-default_gem_spec","(gem_name)",""],["default_gemfile","Bundler","Bundler.html#method-c-default_gemfile","()",""],["default_gemfile","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-default_gemfile","()",""],["default_id_conv","DRb::DRbServer","DRb/DRbServer.html#method-c-default_id_conv","(idconv)","<p>Set the default value for the :id_conv option.\n<p>See #new().  The initial default value is a DRbIdConv instance. …\n"],["default_imap_port","Net::IMAP","Net/IMAP.html#method-c-default_imap_port","()",""],["default_imaps_port","Net::IMAP","Net/IMAP.html#method-c-default_imaps_port","()",""],["default_internal","Encoding","Encoding.html#method-c-default_internal","()","<p>Returns default internal encoding.  Strings will be transcoded to the default internal encoding in the …\n"],["default_internal=","Encoding","Encoding.html#method-c-default_internal-3D","(p1)","<p>Sets default internal encoding or removes default internal encoding when passed nil.  You should not …\n"],["default_key_path","Gem","Gem.html#method-c-default_key_path","()","<p>The default signing key path\n"],["default_load_limit","DRb::DRbServer","DRb/DRbServer.html#method-c-default_load_limit","(sz)","<p>Set the default value for the :load_limit option.\n<p>See #new().  The initial default value is 25 MB.\n"],["default_lockfile","Bundler","Bundler.html#method-c-default_lockfile","()",""],["default_lockfile","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-default_lockfile","()",""],["default_ole_types","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-default_ole_types","()","<p>Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE object and having …\n"],["default_parser","RSS::Parser","RSS/Parser.html#method-c-default_parser","()",""],["default_parser=","RSS::Parser","RSS/Parser.html#method-c-default_parser-3D","(new_value)","<p>Set @@default_parser to new_value if it is one of the available parsers. Else raise NotValidXMLParser …\n"],["default_passive","Net::FTP","Net/FTP.html#method-c-default_passive","()","<p>When <code>true</code>, connections are in passive mode per default. Default: <code>true</code>.\n"],["default_passive=","Net::FTP","Net/FTP.html#method-c-default_passive-3D","(value)","<p>When <code>true</code>, connections are in passive mode per default. Default: <code>true</code>.\n"],["default_path","Gem","Gem.html#method-c-default_path","()","<p>Default gem load path\n"],["default_path","Gem::PathSupport","Gem/PathSupport.html#method-i-default_path","()","<p>Return the default Gem path\n"],["default_pop3_port","Net::POP3","Net/POP3.html#method-c-default_pop3_port","()","<p>The default port for POP3 connections, port 110\n"],["default_pop3s_port","Net::POP3","Net/POP3.html#method-c-default_pop3s_port","()","<p>The default port for POP3S connections, port 995\n"],["default_port","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-default_port","()","<p>Returns default port.\n"],["default_port","Bundler::URI::Generic","Bundler/URI/Generic.html#method-c-default_port","()","<p>Returns default port.\n"],["default_port","Net::HTTP","Net/HTTP.html#method-c-default_port","()","<p>The default port to use for HTTP requests; defaults to 80.\n"],["default_port","Net::IMAP","Net/IMAP.html#method-c-default_port","()","<p>The default port for IMAP connections, port 143\n"],["default_port","Net::POP3","Net/POP3.html#method-c-default_port","()","<p>returns the port for POP3\n"],["default_port","Net::SMTP","Net/SMTP.html#method-c-default_port","()","<p>The default SMTP port number, 25.\n"],["default_port","URI::Generic","URI/Generic.html#method-c-default_port","()","<p>Returns default port.\n"],["default_port","URI::Generic","URI/Generic.html#method-i-default_port","()","<p>Returns default port.\n"],["default_prerelease","Gem::Requirement","Gem/Requirement.html#method-c-default_prerelease","()",""],["default_proc","Hash","Hash.html#method-i-default_proc","()","<p>If Hash::new was invoked with a block, return that block, otherwise return <code>nil</code>.\n\n<pre>h = Hash.new {|h,k| h[k] ...</pre>\n"],["default_proc=","Hash","Hash.html#method-i-default_proc-3D","(p1)","<p>Sets the default proc to be executed on each failed key lookup.\n\n<pre>h.default_proc = proc do |hash, key|\n ...</pre>\n"],["default_retries","Bundler::Retry","Bundler/Retry.html#method-c-default_retries","()",""],["default_rubygems_dirs","Gem","Gem.html#method-c-default_rubygems_dirs","()","<p>Paths where RubyGems&#39; .rb files and bin files are installed\n"],["default_source","Bundler::SourceList","Bundler/SourceList.html#method-i-default_source","()",""],["default_sources","Gem","Gem.html#method-c-default_sources","()","<p>An Array of the default sources that come with RubyGems\n"],["default_spec_cache_dir","Gem","Gem.html#method-c-default_spec_cache_dir","()","<p>Default spec directory path to be used if an alternate value is not specified in the environment\n"],["default_spec_file","Gem::Installer","Gem/Installer.html#method-i-default_spec_file","()","<p>The location of the default spec file for default gems.\n"],["default_specifications_dir","Gem","Gem.html#method-c-default_specifications_dir","()","<p>Path to specification files of default gems.\n"],["default_specifications_dir","Gem::BasicSpecification","Gem/BasicSpecification.html#method-c-default_specifications_dir","()",""],["default_src_encoding","IRB","IRB.html#method-c-default_src_encoding","()",""],["default_ssl_context","Net::SMTP","Net/SMTP.html#method-c-default_ssl_context","()",""],["default_ssl_port","Net::IMAP","Net/IMAP.html#method-c-default_ssl_port","()",""],["default_ssl_port","Net::SMTP","Net/SMTP.html#method-c-default_ssl_port","()",""],["default_stubs","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-default_stubs","()",""],["default_stubs","Gem::Specification","Gem/Specification.html#method-c-default_stubs","(pattern = \"*.gemspec\")","<p>Returns a Gem::StubSpecification for default gems\n"],["default_submission_port","Net::SMTP","Net/SMTP.html#method-c-default_submission_port","()","<p>The default mail submission port number, 587.\n"],["default_task","Bundler::Thor","Bundler/Thor.html#method-c-default_task","(meth = nil)",""],["default_title=","RDoc::Options","RDoc/Options.html#method-i-default_title-3D","(string)","<p>Set the title, but only if not already set. Used to set the title from a source file, so that a title …\n"],["default_tls_port","Net::IMAP","Net/IMAP.html#method-c-default_tls_port","()","<p>The default port for IMAPS connections, port 993\n"],["default_tls_port","Net::SMTP","Net/SMTP.html#method-c-default_tls_port","()","<p>The default SMTPS port number, 465.\n"],["default_value","Gem::Specification","Gem/Specification.html#method-i-default_value","(name)","<p>The default value for specification attribute <code>name</code>\n"],["defaults","RDoc::Task","RDoc/Task.html#method-i-defaults","()","<p>Sets default task values\n"],["defaults","RDoc::Task","RDoc/Task.html#method-i-defaults","()","<p>Sets default task values\n"],["defaults_str","Gem::Command","Gem/Command.html#method-i-defaults_str","()","<p>Override to display the default values of the command options. (similar to <code>arguments</code>, but displays the …\n"],["defaults_str","Gem::Commands::InfoCommand","Gem/Commands/InfoCommand.html#method-i-defaults_str","()",""],["define","Bundler::Plugin::Events","Bundler/Plugin/Events.html#method-c-define","(const, event)",""],["define","Gem::PackageTask","Gem/PackageTask.html#method-i-define","()","<p>Create the Rake tasks and actions specified by this Gem::PackageTask. (<code>define</code> is automatically called …\n"],["define","OptionParser","OptionParser.html#method-i-define","(*opts, &block)",""],["define","RDoc::Task","RDoc/Task.html#method-i-define","()","<p>Create the tasks defined by this task lib.\n"],["define","RDoc::Task","RDoc/Task.html#method-i-define","()","<p>Create the tasks defined by this task lib.\n"],["define","Racc::Grammar","Racc/Grammar.html#method-c-define","(&block)","<p>Dynamic Generation Interface\n"],["define_actions","Racc::ParserClassGenerator","Racc/ParserClassGenerator.html#method-i-define_actions","(c)",""],["define_by_keywords","OptionParser","OptionParser.html#method-i-define_by_keywords","(options, meth, **opts)",""],["define_finalizer","ObjectSpace","ObjectSpace.html#method-c-define_finalizer","(p1, p2 = v2)","<p>Adds <em>aProc</em> as a finalizer, to be called after <em>obj</em> was destroyed. The object ID of the <em>obj</em> will be passed …\n"],["define_head","OptionParser","OptionParser.html#method-i-define_head","(*opts, &block)",""],["define_method","Module","Module.html#method-i-define_method","(*args)","<p>Defines an instance method in the receiver. The <em>method</em> parameter can be a <code>Proc</code>, a <code>Method</code> or an <code>UnboundMethod</code> …\n"],["define_singleton_method","Object","Object.html#method-i-define_singleton_method","(*args)","<p>Defines a singleton method in the receiver. The <em>method</em> parameter can be a <code>Proc</code>, a <code>Method</code> or an <code>UnboundMethod</code> …\n"],["define_tail","OptionParser","OptionParser.html#method-i-define_tail","(*opts, &block)",""],["define_task","Bundler::Deployment","Bundler/Deployment.html#method-c-define_task","(context, task_method = :task, opts = {})",""],["defined_class","TracePoint","TracePoint.html#method-i-defined_class","()","<p>Return class or module of the method being called.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">class</span> <span class=\"ruby-constant\">C</span>; <span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">foo</span>; <span class=\"ruby-keyword\">end</span>; <span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-identifier\">trace</span> = <span class=\"ruby-constant\">TracePoint</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:call</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["defined_event?","Bundler::Plugin::Events","Bundler/Plugin/Events.html#method-c-defined_event-3F","(event)","<p>Check if an event has been defined @param event [String] An event to check @return [Boolean] A boolean …\n"],["defined_in?","RDoc::Context","RDoc/Context.html#method-i-defined_in-3F","(file)","<p>Is part of this thing was defined in <code>file</code>?\n"],["definition","Bundler","Bundler.html#method-c-definition","(unlock = nil)","<p>Returns an instance of Bundler::Definition for given Gemfile and lockfile\n<p>@param unlock [Hash, Boolean …\n"],["definition","RDoc::Attr","RDoc/Attr.html#method-i-definition","()","<p>Returns attr_reader, attr_writer or attr_accessor as appropriate.\n"],["definition","RDoc::NormalClass","RDoc/NormalClass.html#method-i-definition","()","<p>The definition of this class, <code>class MyClassName</code>\n"],["definition","RDoc::NormalModule","RDoc/NormalModule.html#method-i-definition","()","<p>The definition of this module, <code>module MyModuleName</code>\n"],["definition","RDoc::SingleClass","RDoc/SingleClass.html#method-i-definition","()","<p>The definition of this singleton class, <code>class &lt;&lt; MyClassName</code>\n"],["definition_lists","RDoc::Markdown","RDoc/Markdown.html#method-i-definition_lists","","<p>Allow PHP Markdown Extras style definition lists\n"],["definition_method","Bundler::Runtime","Bundler/Runtime.html#method-c-definition_method","(meth)",""],["deflate","Gem","Gem.html#method-c-deflate","(data)","<p>A Zlib::Deflate.deflate wrapper\n"],["deflate","Zlib","Zlib.html#method-c-deflate","(p1, p2 = v2)","<p>Compresses the given <code>string</code>. Valid values of level are Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION …\n"],["deflate","Zlib::Deflate","Zlib/Deflate.html#method-i-deflate","(p1, p2 = v2)","<p>Inputs <code>string</code> into the deflate stream and returns the output from the stream.  On calling this method, …\n"],["deflate","Zlib::Deflate","Zlib/Deflate.html#method-c-deflate","(p1, p2 = v2)","<p>Compresses the given <code>string</code>. Valid values of level are Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION …\n"],["degree","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-degree","()","<p>See the OpenSSL documentation for EC_GROUP_get_degree()\n"],["delegate","Forwardable","Forwardable.html#method-i-delegate","(hash)",""],["delegate","SingleForwardable","SingleForwardable.html#method-i-delegate","(hash)",""],["deletable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-deletable-3F","()","<p>Returns <code>true</code> if the file or directory may be deleted by DELE/RMD.\n"],["delete","Array","Array.html#method-i-delete","(p1)","<p>Deletes all items from <code>self</code> that are equal to <code>obj</code>.\n<p>Returns the last deleted item, or <code>nil</code> if no matching …\n"],["delete","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-delete","(key)",""],["delete","CGI::Session","CGI/Session.html#method-i-delete","()","<p>Delete the session from storage.  Also closes the storage.\n<p>Note that the session&#39;s data is <em>not</em> automatically …\n"],["delete","CGI::Session::FileStore","CGI/Session/FileStore.html#method-i-delete","()","<p>Close and delete the session&#39;s FileStore file.\n"],["delete","CGI::Session::MemoryStore","CGI/Session/MemoryStore.html#method-i-delete","()","<p>Delete the session state.\n"],["delete","CGI::Session::NullStore","CGI/Session/NullStore.html#method-i-delete","()","<p>Delete the session state.\n<p>A no-op.\n"],["delete","CGI::Session::PStore","CGI/Session/PStore.html#method-i-delete","()","<p>Close and delete the session&#39;s PStore file.\n"],["delete","CSV::Row","CSV/Row.html#method-i-delete","(header_or_index, minimum_index = 0)","<p>Removes a pair from the row by <code>header</code> or <code>index</code>. The pair is located as described in CSV::Row.field() …\n"],["delete","CSV::Table","CSV/Table.html#method-i-delete","(*indexes_or_headers)","<p>Removes and returns the indicated columns or rows. In the default mixed mode indices refer to rows and …\n"],["delete","DBM","DBM.html#method-i-delete","(p1)","<p>Deletes an entry from the database.\n"],["delete","Dir","Dir.html#method-c-delete","(p1)","<p>Deletes the named directory. Raises a subclass of SystemCallError if the directory isn&#39;t empty.\n"],["delete","ENV","ENV.html#method-c-delete","(p1)","<p>Deletes the environment variable with <code>name</code> if it exists and returns its value:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>[<span class=\"ruby-string\">&#39;foo&#39;</span>] = <span class=\"ruby-string\">&#39;0&#39;</span>\n<span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">delete</span>(<span class=\"ruby-string\">&#39;foo&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["delete","File","File.html#method-c-delete","(*args)","<p>Deletes the named files, returning the number of names passed as arguments. Raises an exception on any …\n"],["delete","GDBM","GDBM.html#method-i-delete","(p1)","<p>Removes the key-value-pair with the specified <em>key</em> from this database and returns the corresponding <em>value</em> …\n"],["delete","Gem::SourceList","Gem/SourceList.html#method-i-delete","(source)","<p>Deletes <code>source</code> from the source list which may be a Gem::Source or a URI.\n"],["delete","Hash","Hash.html#method-i-delete","(p1)","<p>Deletes the key-value pair and returns the value from <em>hsh</em> whose key is equal to <em>key</em>. If the key is not …\n"],["delete","IRB::JobManager","IRB/JobManager.html#method-i-delete","(key)","<p>Deletes the job at the given <code>key</code>.\n"],["delete","Net::FTP","Net/FTP.html#method-i-delete","(filename)","<p>Deletes a file on the server.\n"],["delete","Net::HTTP","Net/HTTP.html#method-i-delete","(path, initheader = {'Depth' => 'Infinity'})","<p>Sends a DELETE request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["delete","Net::HTTPHeader","Net/HTTPHeader.html#method-i-delete","(key)","<p>Removes a header field, specified by case-insensitive key.\n"],["delete","Net::IMAP","Net/IMAP.html#method-i-delete","(mailbox)","<p>Sends a DELETE command to remove the <code>mailbox</code>.\n<p>A Net::IMAP::NoResponseError is raised if a mailbox with …\n"],["delete","Net::POPMail","Net/POPMail.html#method-i-delete","()","<p>Marks a message for deletion on the server.  Deletion does not actually occur until the end of the session; …\n"],["delete","PStore","PStore.html#method-i-delete","(name)","<p>Removes an object hierarchy from the data store, by <em>name</em>.\n<p><strong>WARNING</strong>:  This method is only valid in a PStore#transaction …\n"],["delete","Pathname","Pathname.html#method-i-delete","()","<p>Removes a file or directory, using File.unlink if <code>self</code> is a file, or Dir.unlink as necessary.\n"],["delete","REXML::Attributes","REXML/Attributes.html#method-i-delete","( attribute )","<p>Removes an attribute\n<p>attribute &mdash; either a String, which is the name of the attribute to remove – namespaces …\n"],["delete","REXML::Elements","REXML/Elements.html#method-i-delete","(element)","<p>Deletes a child Element\n<p>element &mdash; Either an Element, which is removed directly; an xpath, where the first …\n"],["delete","REXML::Parent","REXML/Parent.html#method-i-delete","( object )",""],["delete","Racc::ISet","Racc/ISet.html#method-i-delete","(key)",""],["delete","Racc::SymbolTable","Racc/SymbolTable.html#method-i-delete","(sym)",""],["delete","Rinda::TupleBag","Rinda/TupleBag.html#method-i-delete","(tuple)","<p>Removes <code>tuple</code> from the TupleBag.\n"],["delete","Rinda::TupleBag::TupleBin","Rinda/TupleBag/TupleBin.html#method-i-delete","(tuple)",""],["delete","SDBM","SDBM.html#method-i-delete","(p1)","<p>Deletes the key-value pair corresponding to the given <code>key</code>. If the <code>key</code> exists, the deleted value will …\n"],["delete","Set","Set.html#method-i-delete","(o)","<p>Deletes the given object from the set and returns self.  Use <code>subtract</code> to delete many items at once.\n"],["delete","String","String.html#method-i-delete","(*args)","<p>Returns a copy of <em>str</em> with all characters in the intersection of its arguments deleted. Uses the same …\n"],["delete","Tempfile","Tempfile.html#method-i-delete","()",""],["delete","YAML::DBM","YAML/DBM.html#method-i-delete","( key )","<p>Deletes value from database associated with <code>key</code>.\n<p>Returns value or <code>nil</code>.\n"],["delete!","Net::POPMail","Net/POPMail.html#method-i-delete-21","()",""],["delete!","String","String.html#method-i-delete-21","(*args)","<p>Performs a <code>delete</code> operation in place, returning <em>str</em>, or <code>nil</code> if <em>str</em> was not modified.\n"],["delete?","Set","Set.html#method-i-delete-3F","(o)","<p>Deletes the given object from the set and returns self.  If the object is not in the set, returns nil. …\n"],["delete_all","Net::POP3","Net/POP3.html#method-i-delete_all","()","<p>Deletes all messages on the server.\n<p>If called with a block, yields each message in turn before deleting …\n"],["delete_all","Net::POP3","Net/POP3.html#method-c-delete_all","(address, port = nil, account = nil, password = nil, isapop = false, &block)","<p>Starts a POP3 session and deletes all messages on the server. If a block is given, each POPMail object …\n"],["delete_all","REXML::Attributes","REXML/Attributes.html#method-i-delete_all","( name )","<p>Deletes all attributes matching a name.  Namespaces are significant.\n<p>name &mdash; A String; all attributes that …\n"],["delete_all","REXML::Elements","REXML/Elements.html#method-i-delete_all","( xpath )","<p>Removes multiple elements.  Filters for Element children, regardless of XPath matching.\n<p>xpath &mdash; all elements …\n"],["delete_at","Array","Array.html#method-i-delete_at","(p1)","<p>Deletes the element at the specified <code>index</code>, returning that element, or <code>nil</code> if the <code>index</code> is out of range. …\n"],["delete_at","REXML::Parent","REXML/Parent.html#method-i-delete_at","( index )",""],["delete_attribute","REXML::Element","REXML/Element.html#method-i-delete_attribute","(key)","<p>Removes an attribute\n<p>key &mdash; either an Attribute or a String.  In either case, the attribute is found by matching …\n"],["delete_edge","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-delete_edge","(edge)","<p>Deletes an {Edge} from the dependency graph @param [Edge] edge @return [Void]\n"],["delete_edge","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-delete_edge","(graph, origin_name, destination_name, requirement)","<p>{include:DependencyGraph#delete_edge} @param [Graph] graph the graph to perform the action on @param …\n"],["delete_edge","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-delete_edge","(edge)","<p>Deletes an {Edge} from the dependency graph @param [Edge] edge @return [Void]\n"],["delete_edge","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-delete_edge","(graph, origin_name, destination_name, requirement)","<p>{include:DependencyGraph#delete_edge} @param [Graph] graph the graph to perform the action on @param …\n"],["delete_element","REXML::Element","REXML/Element.html#method-i-delete_element","(element)","<p>Deletes a child element.\n<p>element &mdash; Must be an <code>Element</code>, <code>String</code>, or <code>Integer</code>.  If Element, the element is removed. …\n"],["delete_field","OpenStruct","OpenStruct.html#method-i-delete_field","(name)","<p>Removes the named field from the object. Returns the value that the field contained if it was defined. …\n"],["delete_first","Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular","Bundler/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-delete_first","(array, item)",""],["delete_first","Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular","Gem/Resolver/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-delete_first","(array, item)",""],["delete_if","Array","Array.html#method-i-delete_if","()","<p>Deletes every element of <code>self</code> for which block evaluates to <code>true</code>.\n<p>The array is changed instantly every …\n"],["delete_if","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-delete_if","()",""],["delete_if","CSV::Row","CSV/Row.html#method-i-delete_if","(&block)","<p>The provided <code>block</code> is passed a header and field for each pair in the row and expected to return <code>true</code> …\n"],["delete_if","CSV::Table","CSV/Table.html#method-i-delete_if","(&block)","<p>Removes any column or row for which the block returns <code>true</code>. In the default mixed mode or row mode, iteration …\n"],["delete_if","DBM","DBM.html#method-i-delete_if","()","<p>Deletes all entries for which the code block returns true. Returns self.\n"],["delete_if","ENV","ENV.html#method-c-delete_if","()","<p>Deletes every environment variable for which the block evaluates to <code>true</code>.\n<p>If no block is given an enumerator …\n"],["delete_if","GDBM","GDBM.html#method-i-delete_if","()","<p>Deletes every key-value pair from <em>gdbm</em> for which <em>block</em> evaluates to true.\n"],["delete_if","Hash","Hash.html#method-i-delete_if","()","<p>Deletes every key-value pair from <em>hsh</em> for which <em>block</em> evaluates to <code>true</code>.\n<p>If no block is given, an enumerator …\n"],["delete_if","REXML::Parent","REXML/Parent.html#method-i-delete_if","( &block )",""],["delete_if","SDBM","SDBM.html#method-i-delete_if","()","<p>Iterates over the key-value pairs in the database, deleting those for which the block returns <code>true</code>.\n"],["delete_if","Set","Set.html#method-i-delete_if","()","<p>Deletes every element of the set for which block evaluates to true, and returns self. Returns an enumerator …\n"],["delete_if","YAML::DBM","YAML/DBM.html#method-i-delete_if","()","<p>Calls the given block once for each <code>key</code>, <code>value</code> pair in the database. Deletes all entries for which the …\n"],["delete_legacy_args","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-delete_legacy_args","(args)","<p>Removes legacy rdoc arguments from <code>args</code>\n"],["delete_legacy_args","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-delete_legacy_args","(args)","<p>Removes legacy rdoc arguments from <code>args</code>\n"],["delete_namespace","REXML::Element","REXML/Element.html#method-i-delete_namespace","(namespace=\"xmlns\")","<p>Removes a namespace from this node.  This only works if the namespace is actually declared in this node. …\n"],["delete_observer","Observable","Observable.html#method-i-delete_observer","(observer)","<p>Remove <code>observer</code> as an observer on this object so that it will no longer receive notifications.\n<p><code>observer</code> … &mdash; "],["delete_observers","Observable","Observable.html#method-i-delete_observers","()","<p>Remove all observers associated with this object.\n"],["delete_passwd","WEBrick::HTTPAuth::Htdigest","WEBrick/HTTPAuth/Htdigest.html#method-i-delete_passwd","(realm, user)","<p>Removes a password from the database for <code>user</code> in <code>realm</code>.\n"],["delete_passwd","WEBrick::HTTPAuth::Htpasswd","WEBrick/HTTPAuth/Htpasswd.html#method-i-delete_passwd","(realm, user)","<p>Removes a password from the database for <code>user</code> in <code>realm</code>.\n"],["delete_prefix","String","String.html#method-i-delete_prefix","(p1)","<p>Returns a copy of <em>str</em> with leading <code>prefix</code> deleted.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">delete_prefix</span>(<span class=\"ruby-string\">&quot;hel&quot;</span>) <span class=\"ruby-comment\">#=&gt; &quot;lo&quot;</span>\n<span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">delete_prefix</span>(<span class=\"ruby-string\">&quot;llo&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["delete_prefix!","String","String.html#method-i-delete_prefix-21","(p1)","<p>Deletes leading <code>prefix</code> from <em>str</em>, returning <code>nil</code> if no change was made.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">delete_prefix!</span>(<span class=\"ruby-string\">&quot;hel&quot;</span>) <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["delete_suffix","CSV::DeleteSuffix","CSV/DeleteSuffix.html#method-i-delete_suffix","(suffix)",""],["delete_suffix","String","String.html#method-i-delete_suffix","(p1)","<p>Returns a copy of <em>str</em> with trailing <code>suffix</code> deleted.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">delete_suffix</span>(<span class=\"ruby-string\">&quot;llo&quot;</span>) <span class=\"ruby-comment\">#=&gt; &quot;he&quot;</span>\n<span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">delete_suffix</span>(<span class=\"ruby-string\">&quot;hel&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["delete_suffix!","String","String.html#method-i-delete_suffix-21","(p1)","<p>Deletes trailing <code>suffix</code> from <em>str</em>, returning <code>nil</code> if no change was made.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">delete_suffix!</span>(<span class=\"ruby-string\">&quot;llo&quot;</span>) <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["delete_text","Readline","Readline.html#method-c-delete_text","(*args)","<p>Delete text between start and end in the current line.\n<p>See GNU Readline&#39;s rl_delete_text function. …\n"],["delete_unless_alive","Rinda::TupleBag","Rinda/TupleBag.html#method-i-delete_unless_alive","()","<p>Delete tuples which dead tuples from the TupleBag, returning the deleted tuples.\n"],["deleted?","Net::POPMail","Net/POPMail.html#method-i-deleted-3F","()","<p>True if the mail has been deleted.\n"],["denominator","Complex","Complex.html#method-i-denominator","()","<p>Returns the denominator (lcm of both denominator - real and imag).\n<p>See numerator.\n"],["denominator","Float","Float.html#method-i-denominator","()","<p>Returns the denominator (always positive).  The result is machine dependent.\n<p>See also Float#numerator …\n"],["denominator","Integer","Integer.html#method-i-denominator","()","<p>Returns 1.\n"],["denominator","Numeric","Numeric.html#method-i-denominator","()","<p>Returns the denominator (always positive).\n"],["denominator","Rational","Rational.html#method-i-denominator","()","<p>Returns the denominator (always positive).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">denominator</span>             <span class=\"ruby-comment\">#=&gt; 1</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">7</span>, <span class=\"ruby-value\">1</span>).<span class=\"ruby-identifier\">denominator</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["depend_rules","MakeMakefile","MakeMakefile.html#method-i-depend_rules","(depend)","<p>Processes the data contents of the “depend” file.  Each line of this file is expected to be …\n"],["dependencies","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-dependencies","(names)",""],["dependencies","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-dependencies","(name)",""],["dependencies","Bundler::Gemdeps","Bundler/Gemdeps.html#method-i-dependencies","()",""],["dependencies","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-dependencies","()","<p>Represents only the non-development dependencies, the ones that are itself and are in the total list. …\n"],["dependencies","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-dependencies","()",""],["dependencies","Gem::Resolver::IndexSpecification","Gem/Resolver/IndexSpecification.html#method-i-dependencies","()","<p>The dependencies of the gem for this specification\n"],["dependencies","Gem::Resolver::SpecSpecification","Gem/Resolver/SpecSpecification.html#method-i-dependencies","()","<p>The dependencies of the gem for this specification\n"],["dependencies","Gem::Specification","Gem/Specification.html#method-i-dependencies","()","<p>A list of Gem::Dependency objects this gem depends on.\n<p>Use #add_dependency or #add_development_dependency …\n"],["dependencies_count_for","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-dependencies_count_for","(definition)",""],["dependencies_eql?","Bundler::Index","Bundler/Index.html#method-i-dependencies_eql-3F","(spec, other_spec)",""],["dependencies_for","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-dependencies_for","(specification)","<p>(see Bundler::Molinillo::SpecificationProvider#dependencies_for)\n"],["dependencies_for","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-dependencies_for","(specification)","<p>Returns the dependencies of `specification`. @note This method should be &#39;pure&#39;, i.e. the return …\n"],["dependencies_for","Bundler::Resolver","Bundler/Resolver.html#method-i-dependencies_for","(specification)",""],["dependencies_for","Gem::Resolver","Gem/Resolver.html#method-i-dependencies_for","(specification)",""],["dependencies_for","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-dependencies_for","(specification)","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#dependencies_for)\n"],["dependencies_for","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-dependencies_for","(specification)","<p>Returns the dependencies of `specification`. @note This method should be &#39;pure&#39;, i.e. the return …\n"],["dependencies_for_activated_platforms","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-dependencies_for_activated_platforms","()",""],["dependencies_for_source_changed?","Bundler::Definition","Bundler/Definition.html#method-i-dependencies_for_source_changed-3F","(source, locked_source = source)",""],["dependencies_installed?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-dependencies_installed-3F","(all_specs)","<p>Checks installed dependencies against spec&#39;s dependencies to make sure needed dependencies have been …\n"],["dependencies_to_gemfile","Gem::Specification","Gem/Specification.html#method-i-dependencies_to_gemfile","(dependencies, group = nil)",""],["dependency","Gem::ImpossibleDependenciesError","Gem/ImpossibleDependenciesError.html#method-i-dependency","()",""],["dependency_api_uri","Bundler::Fetcher::Dependency","Bundler/Fetcher/Dependency.html#method-i-dependency_api_uri","(gem_names = [])",""],["dependency_names","Bundler::Index","Bundler/Index.html#method-i-dependency_names","()",""],["dependency_names_to_double_check","Bundler::Source","Bundler/Source.html#method-i-dependency_names_to_double_check","()",""],["dependency_names_to_double_check","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-dependency_names_to_double_check","()",""],["dependency_order","Gem::DependencyList","Gem/DependencyList.html#method-i-dependency_order","()","<p>Return a list of the gem specifications in the dependency list, sorted in order so that no gemspec in …\n"],["dependency_specs","Bundler::Fetcher::Dependency","Bundler/Fetcher/Dependency.html#method-i-dependency_specs","(gem_names)",""],["dependent_gems","Gem::Specification","Gem/Specification.html#method-i-dependent_gems","()","<p>Return a list of all gems that have a dependency on this gemspec.  The list is structured with entries …\n"],["dependent_specs","Gem::Specification","Gem/Specification.html#method-i-dependent_specs","()","<p>Returns all specs that matches this spec&#39;s runtime dependencies.\n"],["deprecate","Gem::Deprecate","Gem/Deprecate.html#method-i-deprecate","(name, repl, year, month)","<p>Simple deprecation method that deprecates <code>name</code> by wrapping it up in a dummy method. It warns on each …\n"],["deprecate","Gem::Deprecate","Gem/Deprecate.html#method-c-deprecate","(name, repl, year, month)","<p>Simple deprecation method that deprecates <code>name</code> by wrapping it up in a dummy method. It warns on each …\n"],["deprecate_constant","Module","Module.html#method-i-deprecate_constant","(*args)","<p>Makes a list of existing constants deprecated. Attempt to refer to them will produce a warning.\n\n<pre>module ...</pre>\n"],["deprecate_option","Gem::Command","Gem/Command.html#method-i-deprecate_option","(name, version: nil, extra_msg: nil)","<p>Mark a command-line option as deprecated, and optionally specify a deprecation horizon.\n<p>Note that with …\n"],["depth","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-depth","()","<p>(see Bundler::Molinillo::ResolutionState#depth)\n"],["depth","Gem::Resolver::Molinillo::Delegates::ResolutionState","Gem/Resolver/Molinillo/Delegates/ResolutionState.html#method-i-depth","()","<p>(see Gem::Resolver::Molinillo::ResolutionState#depth)\n"],["depth","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-depth","()","<p>This integer returns the current depth of data structure nesting.\n"],["depth=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-depth-3D","(p1)","<p>This sets the maximum level of data structure nesting in the generated JSON to the integer depth, max_nesting …\n"],["deq","Bundler::Worker","Bundler/Worker.html#method-i-deq","()","<p>Retrieves results of job function being executed in worker pool\n"],["deq","Queue","Queue.html#method-i-deq","(*args)",""],["deq","SizedQueue","SizedQueue.html#method-i-deq","(*args)",""],["dequote","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-dequote","(str)","<p>Removes quotes and escapes from <code>str</code>\n"],["dequote","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-dequote","(str)","<p>Removes quotes and escapes from <code>str</code>\n"],["desc","Bundler::Thor","Bundler/Thor.html#method-c-desc","(usage, description, options = {})","<p>Defines the usage and the description of the next command.\n<p>Parameters\n<p>usage&lt;String&gt; description&lt;String&gt; …\n"],["desc","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-desc","(description = nil)","<p>The description for this Bundler::Thor::Group. If none is provided, but a source root exists, tries to …\n"],["descend","Pathname","Pathname.html#method-i-descend","()","<p>Iterates over and yields a new Pathname object for each element in the given path in descending order. …\n"],["descendant","REXML::XPathParser","REXML/XPathParser.html#method-i-descendant","(nodeset, include_self)",""],["descendant_recursive","REXML::XPathParser","REXML/XPathParser.html#method-i-descendant_recursive","(raw_node, new_nodeset, new_nodes, include_self)",""],["descendent?","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-descendent-3F","(other)",""],["descendent?","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-descendent-3F","(other)",""],["description","Gem::Command","Gem/Command.html#method-i-description","()","<p>Override to display a longer description of what this command does.\n"],["description","Gem::Commands::UnpackCommand","Gem/Commands/UnpackCommand.html#method-i-description","()",""],["description=","Gem::Specification","Gem/Specification.html#method-i-description-3D","(str)","<p>A detailed description of this gem.  See also #summary\n"],["deserialize","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-deserialize","(o)",""],["destination_encoding","Encoding::Converter","Encoding/Converter.html#method-i-destination_encoding","()","<p>Returns the destination encoding as an Encoding object.\n"],["destination_encoding","Encoding::InvalidByteSequenceError","Encoding/InvalidByteSequenceError.html#method-i-destination_encoding","()","<p>Returns the destination encoding as an encoding object.\n"],["destination_encoding","Encoding::UndefinedConversionError","Encoding/UndefinedConversionError.html#method-i-destination_encoding","()","<p>Returns the destination encoding as an encoding object.\n"],["destination_encoding_name","Encoding::InvalidByteSequenceError","Encoding/InvalidByteSequenceError.html#method-i-destination_encoding_name","()","<p>Returns the destination encoding name as a string.\n"],["destination_encoding_name","Encoding::UndefinedConversionError","Encoding/UndefinedConversionError.html#method-i-destination_encoding_name","()","<p>Returns the destination encoding name as a string.\n"],["destination_root","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-destination_root","()","<p>Returns the root for this thor class (also aliased as destination root).\n"],["destination_root=","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-destination_root-3D","(root)","<p>Sets the root for this thor class. Relatives path are added to the directory where the script was invoked …\n"],["det","Matrix","Matrix.html#method-i-det","()",""],["det","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-det","()","<p>Returns the determinant of <code>A</code>, calculated efficiently from the factorization.\n"],["det_e","Matrix","Matrix.html#method-i-det_e","()",""],["detab","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-detab","(str, ts = 8)",""],["detach","Process","Process.html#method-c-detach","(p1)","<p>Some operating systems retain the status of terminated child processes until the parent collects that …\n"],["detach_vertex_named","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-detach_vertex_named","(name)","<p>Detaches the {#vertex_named} `name` {Vertex} from the graph, recursively removing any non-root vertices …\n"],["detach_vertex_named","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-detach_vertex_named","(graph, name)","<p>@macro action\n"],["detach_vertex_named","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-detach_vertex_named","(name)","<p>Detaches the {#vertex_named} `name` {Vertex} from the graph, recursively removing any non-root vertices …\n"],["detach_vertex_named","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-detach_vertex_named","(graph, name)","<p>@macro action\n"],["detached","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-detached","()",""],["detached=","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-detached-3D","(p1)",""],["detached?","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-detached-3F","()",""],["detect","Enumerable","Enumerable.html#method-i-detect","(*args)","<p>Passes each entry in <em>enum</em> to <em>block</em>. Returns the first for which <em>block</em> is not false.  If no object matches, …\n"],["detect","Gem::SpecFetcher","Gem/SpecFetcher.html#method-i-detect","(type=:complete)","<p>Return all gem name tuples who&#39;s names match <code>obj</code>\n"],["detect_encoding","RDoc::Encoding","RDoc/Encoding.html#method-c-detect_encoding","(string)","<p>Detects the encoding of <code>string</code> based on the magic comment\n"],["detect_encoding","REXML::Source","REXML/Source.html#method-i-detect_encoding","()",""],["detect_gemdeps","Gem","Gem.html#method-c-detect_gemdeps","(path = nil)","<p>TODO remove with RubyGems 4.0\n"],["detect_idle_timeout","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-c-detect_idle_timeout","(uri, max = 10)","<p>Use this method to detect the idle timeout of the host at <code>uri</code>.  The value returned can be used to configure …\n"],["detect_row_separator","CSV::Parser","CSV/Parser.html#method-i-detect_row_separator","(sample, cr, lf)",""],["determinant","Matrix","Matrix.html#method-i-determinant","()","<p>Returns the determinant of the matrix.\n<p>Beware that using Float values can yield erroneous results because …\n"],["determinant","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-determinant","()",""],["determinant_bareiss","Matrix","Matrix.html#method-i-determinant_bareiss","()","<p>Private. Use Matrix#determinant\n<p>Returns the determinant of the matrix, using Bareiss&#39; multistep integer-preserving …\n"],["determinant_e","Matrix","Matrix.html#method-i-determinant_e","()","<p>deprecated; use Matrix#determinant\n"],["determine_encoding","CSV","CSV.html#method-i-determine_encoding","(encoding, internal_encoding)",""],["determine_terminals","Racc::Grammar","Racc/Grammar.html#method-i-determine_terminals","()","<p>Sym#terminal?\n"],["dev","File::Stat","File/Stat.html#method-i-dev","()","<p>Returns an integer representing the device on which <em>stat</em> resides.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">dev</span>   <span class=\"ruby-comment\">#=&gt; 774</span>\n</pre>\n"],["dev_major","File::Stat","File/Stat.html#method-i-dev_major","()","<p>Returns the major part of <code>File_Stat#dev</code> or <code>nil</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/fd1&quot;</span>).<span class=\"ruby-identifier\">dev_major</span>   <span class=\"ruby-comment\">#=&gt; 2</span>\n<span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/tty&quot;</span>).<span class=\"ruby-identifier\">dev_major</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["dev_minor","File::Stat","File/Stat.html#method-i-dev_minor","()","<p>Returns the minor part of <code>File_Stat#dev</code> or <code>nil</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/fd1&quot;</span>).<span class=\"ruby-identifier\">dev_minor</span>   <span class=\"ruby-comment\">#=&gt; 1</span>\n<span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/tty&quot;</span>).<span class=\"ruby-identifier\">dev_minor</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["development?","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-development-3F","()","<p>Is this activation request for a development dependency?\n"],["development?","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-development-3F","()","<p>Is this dependency a development dependency?\n"],["development_dependencies","Gem::Specification","Gem/Specification.html#method-i-development_dependencies","()","<p>List of dependencies that are used for development\n"],["dfa","Racc::Grammar","Racc/Grammar.html#method-i-dfa","()",""],["dfa","Racc::States","Racc/States.html#method-i-dfa","()","<p>DFA (Deterministic Finite Automaton) Generation\n"],["dfdxi","Jacobian","Jacobian.html#method-i-dfdxi","(f,fx,x,i)","<p>Computes the derivative of f at x. fx is the value of f at x.\n"],["dh_compute_key","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-dh_compute_key","(p1)","<p>See the OpenSSL documentation for ECDH_compute_key()\n"],["diagonal","Matrix","Matrix.html#method-c-diagonal","(*values)","<p>Creates a matrix where the diagonal elements are composed of <code>values</code>.\n\n<pre>Matrix.diagonal(9, 5, -3)\n  =&gt;  9 ...</pre>\n"],["diagonal?","Matrix","Matrix.html#method-i-diagonal-3F","()","<p>Returns <code>true</code> if this is a diagonal matrix. Raises an error if matrix is not square.\n"],["diagonalize","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-diagonalize","()","<p>Symmetric tridiagonal QL algorithm.\n"],["diff","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-diff","(other)","<p>Returns a tuple of these things:\n\n<pre class=\"ruby\">[<span class=\"ruby-identifier\">diff</span>, <span class=\"ruby-identifier\">this</span>, <span class=\"ruby-identifier\">other</span>]\n<span class=\"ruby-constant\">The</span> <span class=\"ruby-identifier\">priority</span> <span class=\"ruby-identifier\">of</span> <span class=\"ruby-identifier\">attributes</span> <span class=\"ruby-identifier\">are</span>\n<span class=\"ruby-value\">1</span>. <span class=\"ruby-identifier\">engine</span>\n<span class=\"ruby-value\">2</span>. <span class=\"ruby-identifier\">ruby_version</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["difference","Array","Array.html#method-i-difference","(*args)","<p>Array Difference\n<p>Returns a new array that is a copy of the original array, removing all occurrences of …\n"],["difference","Set","Set.html#method-i-difference","(enum)",""],["dig","Array","Array.html#method-i-dig","(*args)","<p>Extracts the nested value specified by the sequence of <em>idx</em> objects by calling <code>dig</code> at each step, returning …\n"],["dig","CSV::Row","CSV/Row.html#method-i-dig","(index_or_header, *indexes)","<p>Extracts the nested value specified by the sequence of <code>index</code> or <code>header</code> objects by calling dig at each …\n"],["dig","CSV::Table","CSV/Table.html#method-i-dig","(index_or_header, *index_or_headers)","<p>Extracts the nested value specified by the sequence of <code>index</code> or <code>header</code> objects by calling dig at each …\n"],["dig","Hash","Hash.html#method-i-dig","(*args)","<p>Extracts the nested value specified by the sequence of <em>key</em> objects by calling <code>dig</code> at each step, returning …\n"],["dig","OpenStruct","OpenStruct.html#method-i-dig","(name, *names)","<p>Extracts the nested value specified by the sequence of <code>name</code> objects by calling <code>dig</code> at each step, returning …\n"],["dig","Struct","Struct.html#method-i-dig","(*args)","<p>Extracts the nested value specified by the sequence of <code>key</code> objects by calling <code>dig</code> at each step, returning …\n"],["dig_perfect_match_proc=","Reline::Core","Reline/Core.html#method-i-dig_perfect_match_proc-3D","(p)",""],["digest","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-digest","(name)",""],["digest","Digest::Class","Digest/Class.html#method-c-digest","(*args)","<p>Returns the hash value of a given <em>string</em>.  This is equivalent to Digest::Class.new(*parameters).digest(string), …\n"],["digest","Digest::Instance","Digest/Instance.html#method-i-digest","(p1 = v1)","<p>If none is given, returns the resulting hash value of the digest, keeping the digest&#39;s state.\n<p>If a …\n"],["digest","OpenSSL::Digest","OpenSSL/Digest.html#method-c-digest","(name, data)","<p>Return the hash value computed with <em>name</em> Digest. <em>name</em> is either the long name or short name of a supported …\n"],["digest","OpenSSL::Engine","OpenSSL/Engine.html#method-i-digest","(p1)","<p>Returns a new instance of OpenSSL::Digest by <em>name</em>.\n<p>Will raise an EngineError if the digest is unavailable. …\n"],["digest","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-digest","()","<p>Returns the authentication code an instance represents as a binary string.\n<p>Example\n\n<pre>instance = OpenSSL::HMAC.new(&#39;key&#39;, ...</pre>\n"],["digest","OpenSSL::HMAC","OpenSSL/HMAC.html#method-c-digest","(p1, p2, p3)","<p>Returns the authentication code as a binary string. The <em>digest</em> parameter specifies the digest algorithm …\n"],["digest!","Digest::Instance","Digest/Instance.html#method-i-digest-21","()","<p>Returns the resulting hash value and resets the digest to the initial state.\n"],["digest_length","Digest::Base","Digest/Base.html#method-i-digest_length","()","<p>Return the length of the hash value in bytes.\n"],["digest_length","Digest::Instance","Digest/Instance.html#method-i-digest_length","()","<p>Returns the length of the hash value of the digest.\n<p>This method should be overridden by each implementation …\n"],["digest_length","OpenSSL::Digest","OpenSSL/Digest.html#method-i-digest_length","()","<p>Returns the output size of the digest, i.e. the length in bytes of the final message digest result.\n<p>Example …\n"],["digits","Integer","Integer.html#method-i-digits","(*args)","<p>Returns the digits of <code>int</code>&#39;s place-value representation with radix <code>base</code> (default: 10). The digits …\n"],["digraph","Racc::States","Racc/States.html#method-i-digraph","(map, relation)",""],["dir","Gem","Gem.html#method-c-dir","()","<p>The path where gems are to be installed.\n"],["dir","Gem::Installer","Gem/Installer.html#method-i-dir","()","<p>Return the target directory where the gem is to be installed. This directory is not guaranteed to be …\n"],["dir","Net::FTP","Net/FTP.html#method-i-dir","(*args)",""],["dir_config","MakeMakefile","MakeMakefile.html#method-i-dir_config","(target, idefault=nil, ldefault=nil)","<p>Sets a <code>target</code> name that the user can then use to configure various “with” options with on the …\n"],["direct_ancestors","RDoc::ClassModule","RDoc/ClassModule.html#method-i-direct_ancestors","()","<p>Ancestors of this class or module only\n"],["direct_ancestors","RDoc::NormalClass","RDoc/NormalClass.html#method-i-direct_ancestors","()",""],["directory","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-directory","(source, *args, &block)","<p>Copies recursively the files from source directory to root directory. If any of the files finishes with …\n"],["directory?","File","File.html#method-c-directory-3F","(p1)","<p>Returns <code>true</code> if the named file is a directory, or a symlink that points at a directory, and <code>false</code> otherwise. …\n"],["directory?","File::Stat","File/Stat.html#method-i-directory-3F","()","<p>Returns <code>true</code> if the named file is a directory, or a symlink that points at a directory, and <code>false</code> otherwise. …\n"],["directory?","FileTest","FileTest.html#method-i-directory-3F","(p1)","<p>Returns <code>true</code> if the named file is a directory, or a symlink that points at a directory, and <code>false</code> otherwise. …\n"],["directory?","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-directory-3F","()","<p>Is this tar entry a directory?\n"],["directory?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-directory-3F","()","<p>Returns <code>true</code> if the entry is a directory (i.e., the value of the type fact is dir, cdir, or pdir).\n"],["directory?","Pathname","Pathname.html#method-i-directory-3F","()","<p>See FileTest.directory?.\n"],["directory_makable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-directory_makable-3F","()","<p>Returns <code>true</code> if the MKD command may be used to create a new directory within the directory.\n"],["dirname","File","File.html#method-c-dirname","(p1)","<p>Returns all components of the filename given in <em>file_name</em> except the last one (after first stripping …\n"],["dirname","Pathname","Pathname.html#method-i-dirname","()","<p>Returns all but the last component of the path.\n<p>See File.dirname.\n"],["dirs","Gem::Specification","Gem/Specification.html#method-c-dirs","()","<p>Return the directories that Specification uses to find specs.\n"],["dirs=","Gem::Specification","Gem/Specification.html#method-c-dirs-3D","(dirs)","<p>Set the directories that Specification uses to find specs. Setting this resets the list of known specs. …\n"],["disable","GC","GC.html#method-c-disable","()","<p>Disables garbage collection, returning <code>true</code> if garbage collection was already disabled.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">GC</span>.<span class=\"ruby-identifier\">disable</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["disable","GC::Profiler","GC/Profiler.html#method-c-disable","()","<p>Stops the GC profiler.\n"],["disable","TracePoint","TracePoint.html#method-i-disable","()","<p>Deactivates the trace\n<p>Return true if trace was enabled. Return false if trace was disabled.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">trace</span>.<span class=\"ruby-identifier\">enabled?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["disable_close","Fiddle::Handle","Fiddle/Handle.html#method-i-disable_close","()","<p>Disable a call to dlclose() when this handle is garbage collected.\n"],["disable_required_check!","Bundler::Thor","Bundler/Thor.html#method-c-disable_required_check-21","(*command_names)","<p>Disable the check for required options for the given commands. This is useful if you have a command that …\n"],["disable_ssl","Net::POP3","Net/POP3.html#method-c-disable_ssl","()","<p>Disable SSL for all new instances.\n"],["disable_ssl","Net::POP3","Net/POP3.html#method-i-disable_ssl","()","<p>Disable SSL for all new instances.\n"],["disable_ssl","Net::SMTP","Net/SMTP.html#method-i-disable_ssl","()",""],["disable_starttls","Net::SMTP","Net/SMTP.html#method-i-disable_starttls","()","<p>Disables SMTP/TLS (STARTTLS) for this object.  Must be called before the connection is established to …\n"],["disable_tls","Net::SMTP","Net/SMTP.html#method-i-disable_tls","()","<p>Disables SMTP/TLS for this object.  Must be called before the connection is established to have any effect. …\n"],["disasm","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-disasm","()","<p>Returns the instruction sequence as a <code>String</code> in human readable form.\n\n<pre>puts RubyVM::InstructionSequence.compile(&#39;1 ...</pre>\n"],["disasm","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-disasm","(p1)","<p>Takes <code>body</code>, a Method or Proc object, and returns a String with the human readable instructions for <code>body</code> …\n"],["disassemble","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-disassemble","()","<p>Returns the instruction sequence as a <code>String</code> in human readable form.\n\n<pre>puts RubyVM::InstructionSequence.compile(&#39;1 ...</pre>\n"],["disassemble","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-disassemble","(p1)","<p>Takes <code>body</code>, a Method or Proc object, and returns a String with the human readable instructions for <code>body</code> …\n"],["disconnect","Net::IMAP","Net/IMAP.html#method-i-disconnect","()","<p>Disconnects from the server.\n"],["disconnected?","Net::IMAP","Net/IMAP.html#method-i-disconnected-3F","()","<p>Returns true if disconnected from the server.\n"],["disjoint?","Set","Set.html#method-i-disjoint-3F","(set)","<p>Returns true if the set and the given set have no element in common.  This method is the opposite of …\n"],["dispatch","Bundler::CLI","Bundler/CLI.html#method-c-dispatch","(*)",""],["dispatch_seq","IRB::Color","IRB/Color.html#method-c-dispatch_seq","(token, expr, str, in_symbol:)",""],["dispid","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-dispid","()","<p>Returns dispatch ID.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbooks&#39;</span>)\n<span class=\"ruby-identifier\">method</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["display","DEBUGGER__","DEBUGGER__.html#method-c-display","()","<p>Returns the display expression list\n<p>See DEBUGGER__ for more usage\n"],["display","Gem::Resolver::Stats","Gem/Resolver/Stats.html#method-i-display","()",""],["display","Object","Object.html#method-i-display","(*args)","<p>Prints <em>obj</em> on the given port (default <code>$&gt;</code>). Equivalent to:\n\n<pre>def display(port=$&gt;)\n  port.write self\n  ...</pre>\n"],["display?","RDoc::CodeObject","RDoc/CodeObject.html#method-i-display-3F","()","<p>Should this CodeObject be displayed in output?\n<p>A code object should be displayed if:\n<p>The item didn&#39;t …\n"],["display?","RDoc::TopLevel","RDoc/TopLevel.html#method-i-display-3F","()","<p>Only a TopLevel that contains text file) will be displayed.  See also RDoc::CodeObject#display?\n"],["display_header","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-display_header","(type)",""],["display_nothing_outdated_message","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-display_nothing_outdated_message","()",""],["div","BigDecimal","BigDecimal.html#method-i-div","(p1, p2 = v2)","<p>Divide by the specified value.\n<p>digits &mdash; If specified and less than the number of significant digits of the …\n"],["div","Integer","Integer.html#method-i-div","(p1)","<p>Performs integer division: returns the integer result of dividing <code>int</code> by <code>numeric</code>.\n"],["div","Numeric","Numeric.html#method-i-div","(p1)","<p>Uses <code>/</code> to perform division, then converts the result to an integer. Numeric does not define the <code>/</code> operator; …\n"],["divide","Set","Set.html#method-i-divide","(&func)","<p>Divides the set into a set of subsets according to the commonality defined by the given block.\n<p>If the …\n"],["divmod","BigDecimal","BigDecimal.html#method-i-divmod","(p1)","<p>Divides by the specified value, and returns the quotient and modulus as BigDecimal numbers. The quotient …\n"],["divmod","Float","Float.html#method-i-divmod","(p1)","<p>See Numeric#divmod.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">42.0</span>.<span class=\"ruby-identifier\">divmod</span>(<span class=\"ruby-value\">6</span>)   <span class=\"ruby-comment\">#=&gt; [7, 0.0]</span>\n<span class=\"ruby-value\">42.0</span>.<span class=\"ruby-identifier\">divmod</span>(<span class=\"ruby-value\">5</span>)   <span class=\"ruby-comment\">#=&gt; [8, 2.0]</span>\n</pre>\n"],["divmod","Integer","Integer.html#method-i-divmod","(p1)","<p>See Numeric#divmod.\n"],["divmod","Numeric","Numeric.html#method-i-divmod","(p1)","<p>Returns an array containing the quotient and modulus obtained by dividing <code>num</code> by <code>numeric</code>.\n<p>If <code>q, r = x.divmod</code> …\n"],["dlload","Fiddle::Importer","Fiddle/Importer.html#method-i-dlload","(*libs)","<p>Creates an array of handlers for the given <code>libs</code>, can be an instance of Fiddle::Handle, Fiddle::Importer …\n"],["dlopen","Fiddle","Fiddle.html#method-i-dlopen","(library)","<p>Creates a new handler that opens <code>library</code>, and returns an instance of Fiddle::Handle.\n<p>If <code>nil</code> is given for …\n"],["dlopen","Fiddle","Fiddle.html#method-c-dlopen","(library)","<p>Creates a new handler that opens <code>library</code>, and returns an instance of Fiddle::Handle.\n<p>If <code>nil</code> is given for …\n"],["dlunwrap","Fiddle","Fiddle.html#method-c-dlunwrap","(p1)","<p>Returns the hexadecimal representation of a memory pointer address <code>addr</code>\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">lib</span> = <span class=\"ruby-constant\">Fiddle</span>.<span class=\"ruby-identifier\">dlopen</span>(<span class=\"ruby-string\">&#39;/lib64/libc-2.15.so&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["dlwrap","Fiddle","Fiddle.html#method-c-dlwrap","(p1)","<p>Returns a memory pointer of a function&#39;s hexadecimal address location <code>val</code>\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">lib</span> = <span class=\"ruby-constant\">Fiddle</span>.<span class=\"ruby-identifier\">dlopen</span>(<span class=\"ruby-string\">&#39;/lib64/libc-2.15.so&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["dn","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-dn","()","<p>Returns dn.\n"],["dn","URI::LDAP","URI/LDAP.html#method-i-dn","()","<p>Returns dn.\n"],["dn=","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-dn-3D","(val)","<p>Setter for dn <code>val</code>.\n"],["dn=","URI::LDAP","URI/LDAP.html#method-i-dn-3D","(val)","<p>Setter for dn <code>val</code>.\n"],["do_GET","RDoc::Servlet","RDoc/Servlet.html#method-i-do_GET","(req, res)","<p>GET request entry point.  Fills in <code>res</code> for the path, etc. in <code>req</code>.\n"],["do_GET","WEBrick::HTTPServlet::AbstractServlet","WEBrick/HTTPServlet/AbstractServlet.html#method-i-do_GET","(req, res)","<p>Raises a NotFound exception\n"],["do_GET","WEBrick::HTTPServlet::ERBHandler","WEBrick/HTTPServlet/ERBHandler.html#method-i-do_GET","(req, res)","<p>Handles GET requests\n"],["do_HEAD","WEBrick::HTTPServlet::AbstractServlet","WEBrick/HTTPServlet/AbstractServlet.html#method-i-do_HEAD","(req, res)","<p>Dispatches to do_GET\n"],["do_OPTIONS","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-do_OPTIONS","(req, res)","<p>The default OPTIONS request handler says GET, HEAD, POST and OPTIONS requests are allowed.\n"],["do_OPTIONS","WEBrick::HTTPServlet::AbstractServlet","WEBrick/HTTPServlet/AbstractServlet.html#method-i-do_OPTIONS","(req, res)","<p>Returns the allowed HTTP request methods\n"],["do_POST","WEBrick::HTTPServlet::ERBHandler","WEBrick/HTTPServlet/ERBHandler.html#method-i-do_POST","(req, res)","<p>Handles POST requests\n"],["do_aliases","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_aliases","()","<p>Scans #content for rb_define_alias\n"],["do_attrs","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_attrs","()","<p>Scans #content for rb_attr and rb_define_attr\n"],["do_boot_defclass","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_boot_defclass","()","<p>Scans #content for boot_defclass\n"],["do_classes_and_modules","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_classes_and_modules","()","<p>Scans #content for rb_define_class, boot_defclass, rb_define_class_under and rb_singleton_class\n"],["do_configuration","Gem::GemRunner","Gem/GemRunner.html#method-i-do_configuration","(args)",""],["do_constants","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_constants","()","<p>Scans #content for rb_define_variable, rb_define_readonly_variable, rb_define_const and rb_define_global_const …\n"],["do_finish","Net::HTTP","Net/HTTP.html#method-i-do_finish","()",""],["do_finish","Net::SMTP","Net/SMTP.html#method-i-do_finish","()",""],["do_helo","Net::SMTP","Net/SMTP.html#method-i-do_helo","(helo_domain)",""],["do_includes","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_includes","()","<p>Scans #content for rb_include_module\n"],["do_install","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-do_install","(spec_install, worker_num)",""],["do_methods","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_methods","()","<p>Scans #content for rb_define_method, rb_define_singleton_method, rb_define_module_function, rb_define_private_method …\n"],["do_missing","RDoc::Parser::C","RDoc/Parser/C.html#method-i-do_missing","()","<p>Creates classes and module that were missing were defined due to the file order being different than …\n"],["do_not_reverse_lookup","BasicSocket","BasicSocket.html#method-i-do_not_reverse_lookup","()","<p>Gets the do_not_reverse_lookup flag of <em>basicsocket</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;socket&#39;</span>\n\n<span class=\"ruby-constant\">BasicSocket</span>.<span class=\"ruby-identifier\">do_not_reverse_lookup</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["do_not_reverse_lookup","BasicSocket","BasicSocket.html#method-c-do_not_reverse_lookup","()","<p>Gets the global do_not_reverse_lookup flag.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BasicSocket</span>.<span class=\"ruby-identifier\">do_not_reverse_lookup</span>  <span class=\"ruby-comment\">#=&gt; false</span>\n</pre>\n"],["do_not_reverse_lookup=","BasicSocket","BasicSocket.html#method-c-do_not_reverse_lookup-3D","(p1)","<p>Sets the global do_not_reverse_lookup flag.\n<p>The flag is used for initial value of do_not_reverse_lookup …\n"],["do_not_reverse_lookup=","BasicSocket","BasicSocket.html#method-i-do_not_reverse_lookup-3D","(p1)","<p>Sets the do_not_reverse_lookup flag of <em>basicsocket</em>.\n\n<pre>TCPSocket.open(&quot;www.ruby-lang.org&quot;, 80) {|sock|\n  ...</pre>\n"],["do_not_reverse_lookup=","OpenSSL::SSL::SocketForwarder","OpenSSL/SSL/SocketForwarder.html#method-i-do_not_reverse_lookup-3D","(flag)",""],["do_reply","Rinda::RingServer","Rinda/RingServer.html#method-i-do_reply","()","<p>Pulls lookup tuples out of the TupleSpace and sends their DRb object the address of the local TupleSpace …\n"],["do_resolve_sr","Racc::States","Racc/States.html#method-i-do_resolve_sr","(stok, rtok)",""],["do_start","Net::HTTP","Net/HTTP.html#method-i-do_start","()",""],["do_start","Net::SMTP","Net/SMTP.html#method-i-do_start","(helo_domain, user, secret, authtype)",""],["do_validate","RSS::BaseParser","RSS/BaseParser.html#method-i-do_validate","()",""],["do_validate=","RSS::BaseParser","RSS/BaseParser.html#method-i-do_validate-3D","(new_value)",""],["do_write","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-do_write","(s)","<p>Writes <em>s</em> to the buffer.  When the buffer is full or #sync is true the buffer is flushed to the underlying …\n"],["do_write","Rinda::RingServer","Rinda/RingServer.html#method-i-do_write","(msg)","<p>Extracts the response URI from <code>msg</code> and adds it to TupleSpace where it will be picked up by <code>reply_service</code> …\n"],["doc_dir","Gem::Specification","Gem/Specification.html#method-i-doc_dir","(type = nil)","<p>Returns the full path to this spec&#39;s documentation directory.  If <code>type</code> is given it will be appended …\n"],["doc_root","Gem::Server","Gem/Server.html#method-i-doc_root","(gem_name)",""],["doc_stats","RDoc::Stats","RDoc/Stats.html#method-i-doc_stats","(collection)","<p>Returns the length and number of undocumented items in <code>collection</code>.\n"],["doctor","Bundler::CLI","Bundler/CLI.html#method-i-doctor","()",""],["doctor","Bundler::CLI::Issue","Bundler/CLI/Issue.html#method-i-doctor","()",""],["doctor","Gem::Commands::CheckCommand","Gem/Commands/CheckCommand.html#method-i-doctor","()",""],["doctor","Gem::Doctor","Gem/Doctor.html#method-i-doctor","()","<p>Cleans up uninstalled files and invalid gem specifications\n"],["doctype","REXML::Attribute","REXML/Attribute.html#method-i-doctype","()",""],["doctype","REXML::Document","REXML/Document.html#method-i-doctype","()","<p>@return the DocType child of the document, if one exists, and nil otherwise.\n"],["doctype","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-doctype","(name, pub_sys, long_name, uri)","<p>Handles a doctype declaration. Any attributes of the doctype which are not supplied will be nil.  #  …\n"],["doctype","REXML::StreamListener","REXML/StreamListener.html#method-i-doctype","(name, pub_sys, long_name, uri)","<p>Handles a doctype declaration. Any attributes of the doctype which are not supplied will be nil.  #  …\n"],["doctype","REXML::Text","REXML/Text.html#method-i-doctype","()",""],["doctype?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-doctype-3F","()","<p>Content: [ String name, String pub_sys, String long_name, String uri ]\n"],["doctype_end","REXML::StreamListener","REXML/StreamListener.html#method-i-doctype_end","()","<p>Called when the doctype is done\n"],["document","RDoc::RDoc","RDoc/RDoc.html#method-i-document","(options)","<p>Generates documentation or a coverage report depending upon the settings in <code>options</code>.\n<p><code>options</code> can be either …\n"],["document","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-document","(generator, options, destination)","<p>Generates documentation using the named <code>generator</code> (“darkfish” or “ri”) and following …\n"],["document","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-document","(generator, options, destination)","<p>Generates documentation using the named <code>generator</code> (“darkfish” or “ri”) and following …\n"],["document","REXML::Child","REXML/Child.html#method-i-document","()","<p>Returns &mdash; the document this child belongs to, or nil if this child\n\n<p>belongs to no document\n"],["document","REXML::Document","REXML/Document.html#method-i-document","()",""],["document","REXML::Element","REXML/Element.html#method-i-document","()","<p>Evaluates to the document to which this element belongs, or nil if this element doesn&#39;t belong to …\n"],["document?","Psych::Nodes::Document","Psych/Nodes/Document.html#method-i-document-3F","()",""],["document?","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-document-3F","()",""],["document_children=","RDoc::CodeObject","RDoc/CodeObject.html#method-i-document_children-3D","(document_children)","<p>Enables or disables documentation of this CodeObject&#39;s children unless it has been turned off by …\n"],["document_self=","RDoc::CodeObject","RDoc/CodeObject.html#method-i-document_self-3D","(document_self)","<p>Enables or disables documentation of this CodeObject unless it has been turned off by :enddoc:.  If the …\n"],["document_self_or_methods","RDoc::ClassModule","RDoc/ClassModule.html#method-i-document_self_or_methods","()","<p>Does this ClassModule or any of its methods have document_self set?\n"],["documentation_page","RDoc::Servlet","RDoc/Servlet.html#method-i-documentation_page","(store, generator, path, req, res)","<p>Fills in <code>res</code> with the class, module or page for <code>req</code> from <code>store</code>.\n<p><code>path</code> is relative to the mount_path and …\n"],["documentation_search","RDoc::Servlet","RDoc/Servlet.html#method-i-documentation_search","(store, generator, req, res)","<p>Creates the JSON search index on <code>res</code> for the given <code>store</code>.  <code>generator</code> must respond to #json_index to build. …\n"],["documentation_source","RDoc::Servlet","RDoc/Servlet.html#method-i-documentation_source","(path)","<p>Returns the RDoc::Store and path relative to <code>mount_path</code> for documentation at <code>path</code>.\n"],["documented?","RDoc::ClassModule","RDoc/ClassModule.html#method-i-documented-3F","()","<p>Does this class or module have a comment with content or is #received_nodoc true?\n"],["documented?","RDoc::CodeObject","RDoc/CodeObject.html#method-i-documented-3F","()","<p>Does this object have a comment with content or is #received_nodoc true?\n"],["documented?","RDoc::Constant","RDoc/Constant.html#method-i-documented-3F","()","<p>A constant is documented if it has a comment, or is an alias for a documented class or module.\n"],["documented?","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-documented-3F","()","<p>A method/attribute is documented if any of the following is true:\n<p>it was marked with :nodoc:;\n<p>it has a …\n"],["domain=","CGI::Cookie","CGI/Cookie.html#method-i-domain-3D","(str)","<p>Set domain for which this cookie applies\n"],["done","Gem::StreamUI::SilentDownloadReporter","Gem/StreamUI/SilentDownloadReporter.html#method-i-done","()","<p>The silent download reporter won&#39;t tell you when the download is done. Because it is silent.\n"],["done","Gem::StreamUI::SilentProgressReporter","Gem/StreamUI/SilentProgressReporter.html#method-i-done","()","<p>Does not print anything when complete as this object has taken a vow of silence.\n"],["done","Gem::StreamUI::SimpleProgressReporter","Gem/StreamUI/SimpleProgressReporter.html#method-i-done","()","<p>Prints out the terminal message.\n"],["done","Gem::StreamUI::ThreadedDownloadReporter","Gem/StreamUI/ThreadedDownloadReporter.html#method-i-done","()","<p>Indicates the download is complete.\n"],["done","Gem::StreamUI::VerboseProgressReporter","Gem/StreamUI/VerboseProgressReporter.html#method-i-done","()","<p>Prints out the terminal message.\n"],["done?","REXML::Validation::Event","REXML/Validation/Event.html#method-i-done-3F","()",""],["done_adding","RDoc::Stats","RDoc/Stats.html#method-i-done_adding","()","<p>Call this to mark the end of parsing for display purposes\n"],["done_documenting=","RDoc::CodeObject","RDoc/CodeObject.html#method-i-done_documenting-3D","(value)","<p>Turns documentation on/off, and turns on/off #document_self and #document_children.\n<p>Once documentation …\n"],["done_installing","Gem","Gem.html#method-c-done_installing","(&hook)","<p>Adds a post-installs hook that will be passed a Gem::DependencyInstaller and a list of installed specifications …\n"],["dot","IRB::Vec","IRB/Vec.html#method-i-dot","(other)",""],["dot","Vector","Vector.html#method-i-dot","(v)",""],["dot_pat","ACL::ACLEntry","ACL/ACLEntry.html#method-i-dot_pat","(str)","<p>Creates a Regexp to match an address.\n"],["dot_pat_str","ACL::ACLEntry","ACL/ACLEntry.html#method-i-dot_pat_str","(str)","<p>Creates a regular expression to match IPv4 addresses\n"],["double_check_for","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-double_check_for","(*)","<p>@private This API on source might not be stable, and for now we expect plugins to download all specs …\n"],["double_check_for","Bundler::Source","Bundler/Source.html#method-i-double_check_for","(*)","<p>it&#39;s possible that gems from one source depend on gems from some other source, so now we download …\n"],["double_check_for","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-double_check_for","(unmet_dependency_names)",""],["double_check_for_index","Bundler::Definition","Bundler/Definition.html#method-i-double_check_for_index","(idx, dependency_names)","<p>Suppose the gem Foo depends on the gem Bar.  Foo exists in Source A.  Bar has some versions that exist …\n"],["double_fig","BigDecimal","BigDecimal.html#method-c-double_fig","()","<p>The BigDecimal.double_fig class method returns the number of digits a Float number is allowed to have. …\n"],["down","Bundler::Molinillo::DependencyGraph::Action","Bundler/Molinillo/DependencyGraph/Action.html#method-i-down","(graph)","<p>Reverses the action on the given graph. @param  [DependencyGraph] graph the graph to reverse the action …\n"],["down","Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular","Bundler/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-down","(graph)","<p>(see Action#down)\n"],["down","Bundler::Molinillo::DependencyGraph::DeleteEdge","Bundler/Molinillo/DependencyGraph/DeleteEdge.html#method-i-down","(graph)","<p>(see Action#down)\n"],["down","Bundler::Molinillo::DependencyGraph::DetachVertexNamed","Bundler/Molinillo/DependencyGraph/DetachVertexNamed.html#method-i-down","(graph)","<p>(see Action#down)\n"],["down","Bundler::Molinillo::DependencyGraph::Tag","Bundler/Molinillo/DependencyGraph/Tag.html#method-i-down","(_graph)","<p>(see Action#down)\n"],["down","Gem::Resolver::Molinillo::DependencyGraph::Action","Gem/Resolver/Molinillo/DependencyGraph/Action.html#method-i-down","(graph)","<p>Reverses the action on the given graph. @param  [DependencyGraph] graph the graph to reverse the action …\n"],["down","Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular","Gem/Resolver/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-down","(graph)","<p>(see Action#down)\n"],["down","Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge","Gem/Resolver/Molinillo/DependencyGraph/DeleteEdge.html#method-i-down","(graph)","<p>(see Action#down)\n"],["down","Gem::Resolver::Molinillo::DependencyGraph::DetachVertexNamed","Gem/Resolver/Molinillo/DependencyGraph/DetachVertexNamed.html#method-i-down","(graph)","<p>(see Action#down)\n"],["down","Gem::Resolver::Molinillo::DependencyGraph::Tag","Gem/Resolver/Molinillo/DependencyGraph/Tag.html#method-i-down","(_graph)","<p>(see Action#down)\n"],["downcase","String","String.html#method-i-downcase","(*args)","<p>Returns a copy of <em>str</em> with all uppercase letters replaced with their lowercase counterparts. Which letters …\n"],["downcase","Symbol","Symbol.html#method-i-downcase","(*args)","<p>Same as <code>sym.to_s.downcase.intern</code>.\n"],["downcase!","String","String.html#method-i-downcase-21","(*args)","<p>Downcases the contents of <em>str</em>, returning <code>nil</code> if no changes were made.\n<p>See String#downcase for meaning …\n"],["download","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-download","(spec, source_uri, install_dir = Gem.dir)",""],["download","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-download","(spec, source_uri, install_dir = Gem.dir)","<p>Moves the gem <code>spec</code> from <code>source_uri</code> to the cache dir unless it is already there.  If the source_uri is …\n"],["download","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-download","(path)","<p>Downloads a gem at <code>path</code> and returns the file path.\n"],["download","Gem::Resolver::Specification","Gem/Resolver/Specification.html#method-i-download","(options)",""],["download","Gem::Source","Gem/Source.html#method-i-download","(spec, dir=Dir.pwd)","<p>Downloads <code>spec</code> and writes it to <code>dir</code>.  See also Gem::RemoteFetcher#download.\n"],["download","Gem::Source::Installed","Gem/Source/Installed.html#method-i-download","(spec, path)","<p>We don&#39;t need to download an installed gem\n"],["download","Gem::TestCase::SpecFetcherSetup","Gem/TestCase/SpecFetcherSetup.html#method-i-download","(name, version, dependencies = nil, &block)","<p>Creates a gem with <code>name</code>, <code>version</code> and <code>deps</code>.  The created gem is downloaded in to the cache directory but …\n"],["download_cache_path","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-download_cache_path","(spec)","<p>Returns the global cache path of the calling Rubygems::Source object.\n<p>Note that the Source determines …\n"],["download_gem","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-download_gem","(spec, uri, path)",""],["download_gem","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-download_gem","(spec, download_path)","<p>Checks if the requested spec exists in the global cache. If it does, we copy it to the download path, …\n"],["download_reporter","Gem::StreamUI","Gem/StreamUI.html#method-i-download_reporter","(*args)","<p>Return a download reporter object chosen from the current verbosity\n"],["download_to_cache","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-download_to_cache","(dependency)",""],["download_to_cache","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-download_to_cache","(dependency)","<p>Given a name and requirement, downloads this gem into cache and returns the filename. Returns nil if …\n"],["downloader","Bundler::Fetcher","Bundler/Fetcher.html#method-i-downloader","()",""],["downto","Date","Date.html#method-i-downto","(p1)","<p>This method is equivalent to step(min, -1){|date| …}.\n"],["downto","Integer","Integer.html#method-i-downto","(p1)","<p>Iterates the given block, passing in decreasing values from <code>int</code> down to and including <code>limit</code>.\n<p>If no block …\n"],["dowrite","REXML::XMLDecl","REXML/XMLDecl.html#method-i-dowrite","()",""],["draw","IRB::Canvas","IRB/Canvas.html#method-i-draw","()",""],["drop","Array","Array.html#method-i-drop","(p1)","<p>Drops first <code>n</code> elements from <code>ary</code> and returns the rest of the elements in an array.\n<p>If a negative number …\n"],["drop","Enumerable","Enumerable.html#method-i-drop","(p1)","<p>Drops first n elements from <em>enum</em>, and returns rest elements in an array.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">4</span>, <span class=\"ruby-value\">5</span>, <span class=\"ruby-value\">0</span>]\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">drop</span>(<span class=\"ruby-value\">3</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["drop","Enumerator::Lazy","Enumerator/Lazy.html#method-i-drop","(p1)","<p>Like Enumerable#drop, but chains operation to be lazy-evaluated.\n"],["drop_while","Array","Array.html#method-i-drop_while","()","<p>Drops elements up to, but not including, the first element for which the block returns <code>nil</code> or <code>false</code> and …\n"],["drop_while","Enumerable","Enumerable.html#method-i-drop_while","()","<p>Drops elements up to, but not including, the first element for which the block returns <code>nil</code> or <code>false</code> and …\n"],["drop_while","Enumerator::Lazy","Enumerator/Lazy.html#method-i-drop_while","()","<p>Like Enumerable#drop_while, but chains operation to be lazy-evaluated.\n"],["dsa_sign_asn1","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-dsa_sign_asn1","(p1)","<p>See the OpenSSL documentation for ECDSA_sign()\n"],["dsa_verify_asn1","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-dsa_verify_asn1","(p1, p2)","<p>See the OpenSSL documentation for ECDSA_verify()\n"],["dst?","Time","Time.html#method-i-dst-3F","()","<p>Returns <code>true</code> if <em>time</em> occurs during Daylight Saving Time in its time zone.\n\n<pre># CST6CDT:\n  Time.local(2000, ...</pre>\n"],["dstaddr","Socket::Ifaddr","Socket/Ifaddr.html#method-i-dstaddr","()","<p>Returns the destination address of <em>ifaddr</em>. nil is returned if the flags doesn&#39;t have IFF_POINTOPOINT …\n"],["dummy?","Encoding","Encoding.html#method-i-dummy-3F","()","<p>Returns true for dummy encodings. A dummy encoding is an encoding for which character handling is not …\n"],["dummy?","Racc::Sym","Racc/Sym.html#method-i-dummy-3F","()",""],["dummy_makefile","MakeMakefile","MakeMakefile.html#method-i-dummy_makefile","(srcdir)","<p>creates a stub Makefile.\n"],["dump","Bundler::YAMLSerializer","Bundler/YAMLSerializer.html#method-i-dump","(hash)",""],["dump","JSON","JSON.html#method-i-dump","(obj, anIO = nil, limit = nil)","<p>Dumps <em>obj</em> as a JSON string, i.e. calls generate on the object and returns the result.\n<p>If anIO (an IO-like …\n"],["dump","JSON::GenericObject","JSON/GenericObject.html#method-c-dump","(obj, *args)",""],["dump","Marshal","Marshal.html#method-c-dump","(p1, p2 = v2, p3 = v3)","<p>Serializes obj and all descendant objects. If anIO is specified, the serialized data will be written …\n"],["dump","ObjectSpace","ObjectSpace.html#method-c-dump","(p1, p2 = {})","<p>Dump the contents of a ruby object as JSON.\n<p>This method is only expected to work with C Ruby. This is …\n"],["dump","Psych","Psych.html#method-c-dump","(o, io = nil, options = {})","<p>Dump Ruby object <code>o</code> to a YAML string.  Optional <code>options</code> may be passed in to control the output format. …\n"],["dump","REXML::Validation::Validator","REXML/Validation/Validator.html#method-i-dump","()",""],["dump","String","String.html#method-i-dump","()","<p>Returns a quoted version of the string with all non-printing characters replaced by <code>\\xHH</code> notation and …\n"],["dump_all","ObjectSpace","ObjectSpace.html#method-c-dump_all","(p1 = {})","<p>Dump the contents of the ruby heap as JSON.\n<p>This method is only expected to work with C Ruby. This is …\n"],["dump_coder","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-dump_coder","(o)",""],["dump_exception","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-dump_exception","(o, msg)",""],["dump_hash","Bundler::YAMLSerializer","Bundler/YAMLSerializer.html#method-i-dump_hash","(hash)",""],["dump_ivars","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-dump_ivars","(target)",""],["dump_list","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-dump_list","(o)",""],["dump_stream","Psych","Psych.html#method-c-dump_stream","(*objects)","<p>Dump a list of objects as separate documents to a document stream.\n<p>Example:\n\n<pre>Psych.dump_stream(&quot;foo\\n  &quot;, ...</pre>\n"],["dup","BigDecimal","BigDecimal.html#method-i-dup","()",""],["dup","Numeric","Numeric.html#method-i-dup","()","<p>Returns the receiver.\n"],["dup","Object","Object.html#method-i-dup","()","<p>Produces a shallow copy of <em>obj</em>—the instance variables of <em>obj</em> are copied, but not the objects they reference. …\n"],["dup","Racc::ISet","Racc/ISet.html#method-i-dup","()",""],["dup","Singleton","Singleton.html#method-i-dup","()","<p>Raises a TypeError to prevent duping.\n"],["dylibs","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-dylibs","(path)",""],["dylibs_darwin","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-dylibs_darwin","(path)",""],["dylibs_ldd","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-dylibs_ldd","(path)",""],["dynamic_prompt","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-dynamic_prompt","(&block)",""],["dynamic_width","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-dynamic_width","()","<p>Calculate the dynamic width of the terminal\n"],["dynamic_width_stty","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-dynamic_width_stty","()",""],["dynamic_width_tput","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-dynamic_width_tput","()",""],["each","ARGF","ARGF.html#method-i-each","(*args)","<p>Returns an enumerator which iterates over each line (separated by <em>sep</em>, which defaults to your platform&#39;s …\n"],["each","Array","Array.html#method-i-each","()","<p>Calls the given block once for each element in <code>self</code>, passing that element as a parameter.  Returns the …\n"],["each","Bundler::Index","Bundler/Index.html#method-i-each","(&blk)",""],["each","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-each","()","<p>Enumerates through the vertices of the graph. @return [Array&lt;Vertex&gt;] The graph&#39;s vertices. …\n"],["each","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-each","()","<p>@!visibility private Enumerates each action in the log @yield [Action]\n"],["each","Bundler::Settings::Mirrors","Bundler/Settings/Mirrors.html#method-i-each","()",""],["each","Bundler::SpecSet","Bundler/SpecSet.html#method-i-each","(&b)",""],["each","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-each","()",""],["each","CSV","CSV.html#method-i-each","(&block)","<p>Yields each row of the data source in turn.\n<p>Support for Enumerable.\n<p>The data source must be open for reading. …\n"],["each","CSV::FieldsConverter","CSV/FieldsConverter.html#method-i-each","(&block)",""],["each","CSV::Row","CSV/Row.html#method-i-each","(&block)","<p>Yields each pair of the row as header and field tuples (much like iterating over a Hash). This method …\n"],["each","CSV::Table","CSV/Table.html#method-i-each","(&block)","<p>In the default mixed mode or row mode, iteration is the standard row major walking of rows. In column …\n"],["each","DBM","DBM.html#method-i-each","()","<p>Calls the block once for each [key, value] pair in the database. Returns self.\n"],["each","Dir","Dir.html#method-i-each","()","<p>Calls the block once for each entry in this directory, passing the filename of each entry as a parameter …\n"],["each","ENV","ENV.html#method-c-each","()","<p>Yields each environment variable name and its value as a 2-element Array:\n\n<pre>h = {}\nENV.each_pair { |name, ...</pre>\n"],["each","Enumerator","Enumerator.html#method-i-each","(*args)","<p>Iterates over the block according to how this Enumerator was constructed. If no block and no arguments …\n"],["each","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-each","()",""],["each","Enumerator::Chain","Enumerator/Chain.html#method-i-each","(*args)","<p>Iterates over the elements of the first enumerable by calling the “each” method on it with …\n"],["each","GDBM","GDBM.html#method-i-each","()","<p>Executes <em>block</em> for each key in the database, passing the <em>key</em> and the corresponding <em>value</em> as a parameter. …\n"],["each","Gem::AvailableSet","Gem/AvailableSet.html#method-i-each","()","<p>Yields each Tuple in this AvailableSet\n"],["each","Gem::ConfigFile","Gem/ConfigFile.html#method-i-each","(&block)","<p>Delegates to @hash\n"],["each","Gem::DependencyList","Gem/DependencyList.html#method-i-each","(&block)","<p>Iterator over dependency_order\n"],["each","Gem::List","Gem/List.html#method-i-each","()",""],["each","Gem::Package::TarReader","Gem/Package/TarReader.html#method-i-each","()","<p>Iterates over files in the tarball yielding each entry\n"],["each","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-each","()","<p>Enumerates through the vertices of the graph. @return [Array&lt;Vertex&gt;] The graph&#39;s vertices. …\n"],["each","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-each","()","<p>@!visibility private Enumerates each action in the log @yield [Action]\n"],["each","Gem::SourceList","Gem/SourceList.html#method-i-each","()","<p>Yields each source URI in the list.\n"],["each","Gem::Specification","Gem/Specification.html#method-c-each","()","<p>Enumerate every known spec.  See ::dirs= and ::add_spec to set the list of specs.\n"],["each","GetoptLong","GetoptLong.html#method-i-each","()","<p>Iterator version of `get&#39;.\n<p>The block is called repeatedly with two arguments: The first is the option …\n"],["each","Hash","Hash.html#method-i-each","()","<p>Calls <em>block</em> once for each key in <em>hsh</em>, passing the key-value pair as parameters.\n<p>If no block is given, …\n"],["each","IO","IO.html#method-i-each","(*args)","<p>Executes the block for every line in <em>ios</em>, where lines are separated by <em>sep</em>. <em>ios</em> must be opened for reading …\n"],["each","Matrix","Matrix.html#method-i-each","(which = :all)","<p>Yields all elements of the matrix, starting with those of the first row, or returns an Enumerator if …\n"],["each","Net::HTTPHeader","Net/HTTPHeader.html#method-i-each","()",""],["each","Net::POP3","Net/POP3.html#method-i-each","()",""],["each","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-each","()","<p>Iterates over keys and objects in a weakly referenced object\n"],["each","OpenSSL::ASN1::Constructive","OpenSSL/ASN1/Constructive.html#method-i-each","()","<p>Calls the given block once for each element in self, passing that element as parameter <em>asn1</em>. If no block …\n"],["each","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-each","(eol=$/)","<p>Executes the block for every line in the stream where lines are separated by <em>eol</em>.\n<p>See also #gets\n"],["each","OpenSSL::Config","OpenSSL/Config.html#method-i-each","()","<p>For a block.\n<p>Receive the section and its pairs for the current configuration.\n\n<pre>config.each do |section, ...</pre>\n"],["each","Prime","Prime.html#method-i-each","(ubound = nil, generator = EratosthenesGenerator.new, &block)","<p>Iterates the given block over all prime numbers.\n<p>Parameters\n<p><code>ubound</code> &mdash; Optional. An arbitrary positive number. …\n"],["each","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-each","()","<p>Iterates the given block for each prime number.\n"],["each","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-each","(&block)","<p>Iterate over each node in the tree. Yields each node to <code>block</code> depth first.\n"],["each","REXML::AttlistDecl","REXML/AttlistDecl.html#method-i-each","(&block)","<p>Iterate over the key/value pairs:\n\n<pre>attlist_decl.each { |attribute_name, attribute_value| ... }</pre>\n"],["each","REXML::Attributes","REXML/Attributes.html#method-i-each","()","<p>Iterates over each attribute of an Element, yielding the expanded name and value as a pair of Strings …\n"],["each","REXML::Elements","REXML/Elements.html#method-i-each","( xpath=nil )","<p>Iterates through all of the child Elements, optionally filtering them by a given XPath\n<p>xpath &mdash; optional. …\n\n"],["each","REXML::Light::Node","REXML/Light/Node.html#method-i-each","()",""],["each","REXML::Parent","REXML/Parent.html#method-i-each","(&block)",""],["each","REXML::Parsers::PullParser","REXML/Parsers/PullParser.html#method-i-each","()",""],["each","REXML::QuickPath","REXML/QuickPath.html#method-c-each","(element, path, namespaces=EMPTY_HASH, &block)",""],["each","REXML::XPath","REXML/XPath.html#method-c-each","(element, path=nil, namespaces=nil, variables={}, options={}, &block)","<p>Iterates over nodes that match the given path, calling the supplied block with the match.\n<p>element &mdash; The …\n"],["each","RSS::XML::Element","RSS/XML/Element.html#method-i-each","(&block)",""],["each","Racc::Grammar","Racc/Grammar.html#method-i-each","(&block)",""],["each","Racc::ISet","Racc/ISet.html#method-i-each","(&block)",""],["each","Racc::Rule","Racc/Rule.html#method-i-each","(&block)",""],["each","Racc::States","Racc/States.html#method-i-each","(&block)",""],["each","Racc::SymbolTable","Racc/SymbolTable.html#method-i-each","(&block)",""],["each","Range","Range.html#method-i-each","()","<p>Iterates over the elements of range, passing each in turn to the block.\n<p>The <code>each</code> method can only be used …\n"],["each","Rinda::NotifyTemplateEntry","Rinda/NotifyTemplateEntry.html#method-i-each","()","<p>Yields event/tuple pairs until this NotifyTemplateEntry expires.\n"],["each","Rinda::RingFinger","Rinda/RingFinger.html#method-i-each","()","<p>Iterates over all discovered TupleSpaces starting with the primary.\n"],["each","Rinda::Tuple","Rinda/Tuple.html#method-i-each","()","<p>Iterate through the tuple, yielding the index or key, and the value, thus ensuring arrays are iterated …\n"],["each","SDBM","SDBM.html#method-i-each","()","<p>Iterates over each key-value pair in the database.\n<p>If no block is given, returns an Enumerator.\n"],["each","Set","Set.html#method-i-each","(&block)","<p>Calls the given block once for each element in the set, passing the element as parameter.  Returns an …\n"],["each","StringIO","StringIO.html#method-i-each","(*args)","<p>See IO#each.\n"],["each","Struct","Struct.html#method-i-each","()","<p>Yields the value of each struct member in order.  If no block is given an enumerator is returned.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Customer</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each","Vector","Vector.html#method-i-each","(&block)","<p>Iterate over the elements of this vector\n"],["each","WEBrick::HTTPAuth::Htdigest","WEBrick/HTTPAuth/Htdigest.html#method-i-each","()","<p>Iterate passwords in the database.\n"],["each","WEBrick::HTTPAuth::Htpasswd","WEBrick/HTTPAuth/Htpasswd.html#method-i-each","()","<p>Iterate passwords in the database.\n"],["each","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-each","()","<p>Iterates over the request headers\n"],["each","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-each","()","<p>Iterates over each header in the response\n"],["each","WIN32OLE","WIN32OLE.html#method-i-each","()","<p>Iterates over each item of OLE collection which has IEnumVARIANT interface.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">excel</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Excel.Application&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each","YAML::DBM","YAML/DBM.html#method-i-each","()",""],["each","Zlib::GzipReader","Zlib/GzipReader.html#method-i-each","(*args)","<p>See Zlib::GzipReader documentation for a description.\n"],["each2","Vector","Vector.html#method-i-each2","(v)","<p>Iterate over the elements of this vector and <code>v</code> in conjunction.\n"],["each_address","Resolv","Resolv.html#method-c-each_address","(name, &block)","<p>Iterates over all IP addresses for <code>name</code>.\n"],["each_address","Resolv","Resolv.html#method-i-each_address","(name)","<p>Iterates over all IP addresses for <code>name</code>.\n"],["each_address","Resolv::DNS","Resolv/DNS.html#method-i-each_address","(name)","<p>Iterates over all IP addresses for <code>name</code> retrieved from the DNS resolver.\n<p><code>name</code> can be a Resolv::DNS::Name …\n"],["each_address","Resolv::Hosts","Resolv/Hosts.html#method-i-each_address","(name, &proc)","<p>Iterates over all IP addresses for <code>name</code> retrieved from the hosts file.\n"],["each_address","Resolv::MDNS","Resolv/MDNS.html#method-i-each_address","(name)","<p>Iterates over all IP addresses for <code>name</code> retrieved from the mDNS resolver, provided name ends with “local”. …\n"],["each_ancestor","RDoc::ClassModule","RDoc/ClassModule.html#method-i-each_ancestor","()","<p>Iterates the ancestors of this class or module for which an RDoc::ClassModule exists.\n"],["each_attribute","RDoc::Context","RDoc/Context.html#method-i-each_attribute","()","<p>Iterator for attributes\n"],["each_attribute","REXML::Attributes","REXML/Attributes.html#method-i-each_attribute","()","<p>Iterates over the attributes of an Element.  Yields actual Attribute nodes, not String values.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">doc</span> = <span class=\"ruby-constant\">Document</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each_builtin","RubyVM","RubyVM.html#method-c-each_builtin","()",""],["each_byte","ARGF","ARGF.html#method-i-each_byte","()","<p>Iterates over each byte of each file in <code>ARGV</code>. A byte is returned as an <code>Integer</code> in the range 0..255.\n<p>This …\n"],["each_byte","IO","IO.html#method-i-each_byte","()","<p>Calls the given block once for each byte (0..255) in <em>ios</em>, passing the byte as an argument. The stream …\n"],["each_byte","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-each_byte","()","<p>Calls the given block once for each byte in the stream.\n"],["each_byte","String","String.html#method-i-each_byte","()","<p>Passes each byte in <em>str</em> to the given block, or returns an enumerator if no block is given.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">each_byte</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each_byte","StringIO","StringIO.html#method-i-each_byte","()","<p>See IO#each_byte.\n"],["each_byte","Zlib::GzipReader","Zlib/GzipReader.html#method-i-each_byte","()","<p>See Zlib::GzipReader documentation for a description.\n"],["each_capitalized","Net::HTTPHeader","Net/HTTPHeader.html#method-i-each_capitalized","()","<p>As for #each_header, except the keys are provided in capitalized form.\n<p>Note that header names are capitalized …\n"],["each_capitalized_name","Net::HTTPHeader","Net/HTTPHeader.html#method-i-each_capitalized_name","()","<p>Iterates through the header names in the header, passing capitalized header names to the code block. …\n"],["each_certificate","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-i-each_certificate","()","<p>Enumerates trusted certificates.\n"],["each_char","ARGF","ARGF.html#method-i-each_char","()","<p>Iterates over each character of each file in <code>ARGF</code>.\n<p>This method allows you to treat the files supplied …\n"],["each_char","IO","IO.html#method-i-each_char","()","<p>Calls the given block once for each character in <em>ios</em>, passing the character as an argument. The stream …\n"],["each_char","String","String.html#method-i-each_char","()","<p>Passes each character in <em>str</em> to the given block, or returns an enumerator if no block is given.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">each_char</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each_char","StringIO","StringIO.html#method-i-each_char","()","<p>See IO#each_char.\n"],["each_char","Zlib::GzipReader","Zlib/GzipReader.html#method-i-each_char","()","<p>See Zlib::GzipReader documentation for a description.\n"],["each_child","Dir","Dir.html#method-i-each_child","()","<p>Calls the block once for each entry except for “.” and “..” in this directory, passing …\n"],["each_child","Dir","Dir.html#method-c-each_child","(*args)","<p>Calls the block once for each entry except for “.” and “..” in the named directory, …\n"],["each_child","Pathname","Pathname.html#method-i-each_child","(with_directory=true, &b)","<p>Iterates over the children of the directory (files and subdirectories, not recursive).\n<p>It yields Pathname …\n"],["each_child","REXML::Parent","REXML/Parent.html#method-i-each_child","(&block)",""],["each_child","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-each_child","()","<p>Iterate all direct child instruction sequences. Iteration order is implementation/version defined so …\n"],["each_classmodule","RDoc::Context","RDoc/Context.html#method-i-each_classmodule","()","<p>Iterator for classes and modules\n"],["each_codepoint","ARGF","ARGF.html#method-i-each_codepoint","()","<p>Iterates over each codepoint of each file in <code>ARGF</code>.\n<p>This method allows you to treat the files supplied …\n"],["each_codepoint","IO","IO.html#method-i-each_codepoint","()","<p>Passes the Integer ordinal of each character in <em>ios</em>, passing the codepoint as an argument. The stream …\n"],["each_codepoint","String","String.html#method-i-each_codepoint","()","<p>Passes the Integer ordinal of each character in <em>str</em>, also known as a <em>codepoint</em> when applied to Unicode …\n"],["each_codepoint","StringIO","StringIO.html#method-i-each_codepoint","()","<p>See IO#each_codepoint.\n"],["each_cons","Enumerable","Enumerable.html#method-i-each_cons","(p1)","<p>Iterates the given block for each array of consecutive &lt;n&gt; elements.  If no block is given, returns …\n"],["each_const","OptionParser","OptionParser.html#method-c-each_const","(path, base = ::Object)",""],["each_constant","RDoc::Context","RDoc/Context.html#method-i-each_constant","()","<p>Iterator for constants\n"],["each_data","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-i-each_data","()","<p>Yields each entry in this FormData\n"],["each_element","REXML::Element","REXML/Element.html#method-i-each_element","( xpath=nil )","<p>Synonym for Element.elements.each\n"],["each_element_with_attribute","REXML::Element","REXML/Element.html#method-i-each_element_with_attribute","( key, value=nil, max=0, name=nil )","<p>Iterates through the child elements, yielding for each Element that has a particular attribute set.\n<p>key … &mdash; "],["each_element_with_text","REXML::Element","REXML/Element.html#method-i-each_element_with_text","( text=nil, max=0, name=nil )","<p>Iterates through the children, yielding for each Element that has a particular text set.\n<p>text &mdash; the text …\n"],["each_entry","Enumerable","Enumerable.html#method-i-each_entry","(*args)","<p>Calls <em>block</em> once for each element in <code>self</code>, passing that element as a parameter, converting multiple values …\n"],["each_entry","Gem::Package::TarReader","Gem/Package/TarReader.html#method-i-each_entry","()",""],["each_entry","Pathname","Pathname.html#method-i-each_entry","()","<p>Iterates over the entries (files and subdirectories) in the directory, yielding a Pathname object for …\n"],["each_entry","Rinda::TupleBag","Rinda/TupleBag.html#method-i-each_entry","(&blk)",""],["each_extend","RDoc::Context","RDoc/Context.html#method-i-each_extend","()","<p>Iterator for extension modules\n"],["each_filename","Pathname","Pathname.html#method-i-each_filename","()","<p>Iterates over each component of the path.\n\n<pre>Pathname.new(&quot;/usr/bin/ruby&quot;).each_filename {|filename| ... ...</pre>\n"],["each_grapheme_cluster","String","String.html#method-i-each_grapheme_cluster","()","<p>Passes each grapheme cluster in <em>str</em> to the given block, or returns an enumerator if no block is given. …\n"],["each_header","Net::HTTPHeader","Net/HTTPHeader.html#method-i-each_header","()","<p>Iterates through the header names and values, passing in the name and value to the code block supplied. …\n"],["each_include","RDoc::Context","RDoc/Context.html#method-i-each_include","()","<p>Iterator for included modules\n"],["each_index","Array","Array.html#method-i-each_index","()","<p>Same as Array#each, but passes the <code>index</code> of the element instead of the element itself.\n<p>An Enumerator is …\n"],["each_index","REXML::Parent","REXML/Parent.html#method-i-each_index","( &block )",""],["each_index","Racc::Grammar","Racc/Grammar.html#method-i-each_index","(&block)",""],["each_index","Racc::States","Racc/States.html#method-i-each_index","(&block)",""],["each_key","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-each_key","()",""],["each_key","DBM","DBM.html#method-i-each_key","()","<p>Calls the block once for each key string in the database. Returns self.\n"],["each_key","ENV","ENV.html#method-c-each_key","()","<p>Yields each environment variable name:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">replace</span>(<span class=\"ruby-string\">&#39;foo&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;0&#39;</span>, <span class=\"ruby-string\">&#39;bar&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;1&#39;</span>) <span class=\"ruby-comment\"># =&gt; ENV</span>\n<span class=\"ruby-identifier\">names</span> = []\n<span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">each_key</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each_key","GDBM","GDBM.html#method-i-each_key","()","<p>Executes <em>block</em> for each key in the database, passing the <em>key</em> as a parameter.\n"],["each_key","Hash","Hash.html#method-i-each_key","()","<p>Calls <em>block</em> once for each key in <em>hsh</em>, passing the key as a parameter.\n<p>If no block is given, an enumerator …\n"],["each_key","Net::HTTPHeader","Net/HTTPHeader.html#method-i-each_key","()",""],["each_key","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-each_key","()","<p>Iterates over keys and objects in a weakly referenced object\n"],["each_key","SDBM","SDBM.html#method-i-each_key","()","<p>Iterates over each <code>key</code> in the database.\n<p>If no block is given, returns an Enumerator.\n"],["each_la","Racc::Item","Racc/Item.html#method-i-each_la","(tbl)",""],["each_line","ARGF","ARGF.html#method-i-each_line","(*args)","<p>Returns an enumerator which iterates over each line (separated by <em>sep</em>, which defaults to your platform&#39;s …\n"],["each_line","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-each_line","(row_separator)",""],["each_line","CSV::Parser::Scanner","CSV/Parser/Scanner.html#method-i-each_line","(row_separator)",""],["each_line","CSV::Parser::UnoptimizedStringIO","CSV/Parser/UnoptimizedStringIO.html#method-i-each_line","(*args, &block)",""],["each_line","IO","IO.html#method-i-each_line","(*args)","<p>Executes the block for every line in <em>ios</em>, where lines are separated by <em>sep</em>. <em>ios</em> must be opened for reading …\n"],["each_line","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-each_line","(eol=$/)",""],["each_line","Pathname","Pathname.html#method-i-each_line","(p1 = v1, p2 = v2, p3 = v3)","<p>Iterates over each line in the file and yields a String object for each.\n"],["each_line","String","String.html#method-i-each_line","(*args)","<p>Splits <em>str</em> using the supplied parameter as the record separator (<code>$/</code> by default), passing each substring …\n"],["each_line","StringIO","StringIO.html#method-i-each_line","(*args)","<p>See IO#each.\n"],["each_line","Zlib::GzipReader","Zlib/GzipReader.html#method-i-each_line","(*args)","<p>See Zlib::GzipReader documentation for a description.\n"],["each_localized_path","IRB::Locale","IRB/Locale.html#method-i-each_localized_path","(dir, file)",""],["each_mail","Net::POP3","Net/POP3.html#method-i-each_mail","()","<p>Yields each message to the passed-in block in turn. Equivalent to:\n\n<pre>pop3.mails.each do |popmail|\n  .... ...</pre>\n"],["each_method","RDoc::Context","RDoc/Context.html#method-i-each_method","()","<p>Iterator for methods\n"],["each_name","Net::HTTPHeader","Net/HTTPHeader.html#method-i-each_name","()","<p>Iterates through the header names in the header, passing each header name to the code block.\n<p>Returns an …\n"],["each_name","Resolv","Resolv.html#method-i-each_name","(address)","<p>Iterates over all hostnames for <code>address</code>.\n"],["each_name","Resolv","Resolv.html#method-c-each_name","(address, &proc)","<p>Iterates over all hostnames for <code>address</code>.\n"],["each_name","Resolv::DNS","Resolv/DNS.html#method-i-each_name","(address)","<p>Iterates over all hostnames for <code>address</code> retrieved from the DNS resolver.\n<p><code>address</code> must be a Resolv::IPv4 …\n"],["each_name","Resolv::Hosts","Resolv/Hosts.html#method-i-each_name","(address, &proc)","<p>Iterates over all hostnames for <code>address</code> retrieved from the hosts file.\n"],["each_nonterminal","Racc::SymbolTable","Racc/SymbolTable.html#method-i-each_nonterminal","(&block)",""],["each_object","ObjectSpace","ObjectSpace.html#method-c-each_object","(*args)","<p>Calls the block once for each living, nonimmediate object in this Ruby process. If <em>module</em> is specified, …\n"],["each_option","GetoptLong","GetoptLong.html#method-i-each_option","()","<p>`each_option&#39; is an alias of `each&#39;.\n"],["each_option","OptionParser::List","OptionParser/List.html#method-i-each_option","(&block)","<p>Iterates over each option, passing the option to the <code>block</code>.\n"],["each_pair","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-each_pair","()",""],["each_pair","CSV::Row","CSV/Row.html#method-i-each_pair","(&block)",""],["each_pair","DBM","DBM.html#method-i-each_pair","()","<p>Calls the block once for each [key, value] pair in the database. Returns self.\n"],["each_pair","ENV","ENV.html#method-c-each_pair","()","<p>Yields each environment variable name and its value as a 2-element Array:\n\n<pre>h = {}\nENV.each_pair { |name, ...</pre>\n"],["each_pair","GDBM","GDBM.html#method-i-each_pair","()","<p>Executes <em>block</em> for each key in the database, passing the <em>key</em> and the corresponding <em>value</em> as a parameter. …\n"],["each_pair","Hash","Hash.html#method-i-each_pair","()","<p>Calls <em>block</em> once for each key in <em>hsh</em>, passing the key-value pair as parameters.\n<p>If no block is given, …\n"],["each_pair","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-each_pair","()","<p>Iterates over keys and objects in a weakly referenced object\n"],["each_pair","OpenStruct","OpenStruct.html#method-i-each_pair","()","<p>Yields all attributes (as symbols) along with the corresponding values or returns an enumerator if no …\n"],["each_pair","SDBM","SDBM.html#method-i-each_pair","()","<p>Iterates over each key-value pair in the database.\n<p>If no block is given, returns an Enumerator.\n"],["each_pair","Struct","Struct.html#method-i-each_pair","()","<p>Yields the name and value of each struct member in order.  If no block is given an enumerator is returned. …\n"],["each_pair","YAML::DBM","YAML/DBM.html#method-i-each_pair","()","<p>Calls the given block once for each <code>key</code>, <code>value</code> pair in the database.\n<p>Returns <code>self</code>.\n"],["each_parent","RDoc::CodeObject","RDoc/CodeObject.html#method-i-each_parent","()","<p>Yields each parent of this CodeObject.  See also RDoc::ClassModule#each_ancestor\n"],["each_prime","Integer","Integer.html#method-c-each_prime","(ubound)","<p>Iterates the given block over all prime numbers.\n<p>See <code>Prime</code>#each for more details.\n"],["each_recursive","REXML::Node","REXML/Node.html#method-i-each_recursive","()","<p>Visit all subnodes of <code>self</code> recursively\n"],["each_reduce","Racc::ActionTable","Racc/ActionTable.html#method-i-each_reduce","(&block)",""],["each_resource","Resolv::DNS","Resolv/DNS.html#method-i-each_resource","(name, typeclass, &proc)","<p>Iterates over all <code>typeclass</code> DNS resources for <code>name</code>.  See #getresource for argument details.\n"],["each_response_header","Net::HTTPResponse","Net/HTTPResponse.html#method-c-each_response_header","(sock)",""],["each_rule","Racc::Grammar","Racc/Grammar.html#method-i-each_rule","(&block)",""],["each_rule","Racc::Rule","Racc/Rule.html#method-i-each_rule","(&block)",""],["each_section","RDoc::Context","RDoc/Context.html#method-i-each_section","()","<p>Iterator for each section&#39;s contents sorted by title.  The <code>section</code>, the section&#39;s <code>constants</code> and …\n"],["each_shift","Racc::ActionTable","Racc/ActionTable.html#method-i-each_shift","(&block)",""],["each_slice","Enumerable","Enumerable.html#method-i-each_slice","(p1)","<p>Iterates the given block for each slice of &lt;n&gt; elements.  If no block is given, returns an enumerator. …\n"],["each_source","Gem::SourceList","Gem/SourceList.html#method-i-each_source","(&b)","<p>Yields each source in the list.\n"],["each_spec","Gem::AvailableSet","Gem/AvailableSet.html#method-i-each_spec","()","<p>Yields the Gem::Specification for each Tuple in this AvailableSet\n"],["each_state","Racc::States","Racc/States.html#method-i-each_state","(&block)",""],["each_strongly_connected_component","TSort","TSort.html#method-c-each_strongly_connected_component","(each_node, each_child)","<p>The iterator version of the TSort.strongly_connected_components method.\n<p>The graph is represented by <em>each_node</em> …\n"],["each_strongly_connected_component","TSort","TSort.html#method-i-each_strongly_connected_component","()","<p>The iterator version of the #strongly_connected_components method. <code><em>obj</em>.each_strongly_connected_component</code> …\n"],["each_strongly_connected_component_from","TSort","TSort.html#method-i-each_strongly_connected_component_from","(node, id_map={}, stack=[])","<p>Iterates over strongly connected component in the subgraph reachable from <em>node</em>.\n<p>Return value is unspecified. …\n"],["each_strongly_connected_component_from","TSort","TSort.html#method-c-each_strongly_connected_component_from","(node, each_child, id_map={}, stack=[])","<p>Iterates over strongly connected components in a graph. The graph is represented by <em>node</em> and <em>each_child</em> …\n"],["each_sublocale","IRB::Locale","IRB/Locale.html#method-i-each_sublocale","()",""],["each_t","Racc::States","Racc/States.html#method-i-each_t","(tbl, set)",""],["each_terminal","Racc::SymbolTable","Racc/SymbolTable.html#method-i-each_terminal","(&block)",""],["each_unnode","REXML::XPathParser","REXML/XPathParser.html#method-i-each_unnode","(nodeset)",""],["each_value","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-each_value","()",""],["each_value","DBM","DBM.html#method-i-each_value","()","<p>Calls the block once for each value string in the database. Returns self.\n"],["each_value","ENV","ENV.html#method-c-each_value","()","<p>Yields each environment variable value:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">replace</span>(<span class=\"ruby-string\">&#39;foo&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;0&#39;</span>, <span class=\"ruby-string\">&#39;bar&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;1&#39;</span>) <span class=\"ruby-comment\"># =&gt; ENV</span>\n<span class=\"ruby-identifier\">values</span> = []\n<span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">each_value</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each_value","GDBM","GDBM.html#method-i-each_value","()","<p>Executes <em>block</em> for each key in the database, passing the corresponding <em>value</em> as a parameter.\n"],["each_value","Hash","Hash.html#method-i-each_value","()","<p>Calls <em>block</em> once for each key in <em>hsh</em>, passing the value as a parameter.\n<p>If no block is given, an enumerator …\n"],["each_value","Net::HTTPHeader","Net/HTTPHeader.html#method-i-each_value","()","<p>Iterates through header values, passing each value to the code block.\n<p>Returns an enumerator if no block …\n"],["each_value","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-each_value","()","<p>Iterates over keys and objects in a weakly referenced object\n"],["each_value","SDBM","SDBM.html#method-i-each_value","()","<p>Iterates over each <code>value</code> in the database.\n<p>If no block is given, returns an Enumerator.\n"],["each_value","YAML::DBM","YAML/DBM.html#method-i-each_value","()","<p>Calls the given block for each value in database.\n<p>Returns <code>self</code>.\n"],["each_with_index","Enumerable","Enumerable.html#method-i-each_with_index","(*args)","<p>Calls <em>block</em> with two arguments, the item and its index, for each item in <em>enum</em>.  Given arguments are passed …\n"],["each_with_index","Enumerator","Enumerator.html#method-i-each_with_index","()","<p>Same as Enumerator#with_index(0), i.e. there is no starting offset.\n<p>If no block is given, a new Enumerator …\n"],["each_with_index","Matrix","Matrix.html#method-i-each_with_index","(which = :all)","<p>Same as #each, but the row index and column index in addition to the element\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Matrix</span>[ [<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">2</span>], [<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>] ].<span class=\"ruby-identifier\">each_with_index</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["each_with_index","Racc::Grammar","Racc/Grammar.html#method-i-each_with_index","(&block)",""],["each_with_object","Enumerable","Enumerable.html#method-i-each_with_object","(p1)","<p>Iterates the given block for each element with an arbitrary object given, and returns the initially given …\n"],["each_with_object","Enumerator","Enumerator.html#method-i-each_with_object","(p1)","<p>Iterates the given block for each element with an arbitrary object, <code>obj</code>, and returns <code>obj</code>\n<p>If no block is …\n"],["each_with_something","REXML::Element","REXML/Element.html#method-i-each_with_something","( test, max=0, name=nil )","<p>A private helper method\n"],["eager","Enumerator::Lazy","Enumerator/Lazy.html#method-i-eager","()","<p>Returns a non-lazy Enumerator converted from the lazy enumerator.\n"],["earlier_version?","Bundler::Source","Bundler/Source.html#method-i-earlier_version-3F","(spec_version, locked_spec_version)",""],["easter_egg","IRB","IRB.html#method-c-easter_egg","(type = nil)",""],["ec2_metadata_credentials_json","Gem::S3URISigner","Gem/S3URISigner.html#method-i-ec2_metadata_credentials_json","()",""],["ec2_metadata_request","Gem::S3URISigner","Gem/S3URISigner.html#method-i-ec2_metadata_request","(url)",""],["ecdh_curves=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-ecdh_curves-3D","(p1)","<p>Sets the list of “supported elliptic curves” for this context.\n<p>For a TLS client, the list is …\n"],["echo=","IO","IO.html#method-i-echo-3D","(p1)","<p>Enables/disables echo back. On some platforms, all combinations of this flags and raw/cooked mode may …\n"],["echo?","Bundler::Thor::LineEditor::Basic","Bundler/Thor/LineEditor/Basic.html#method-i-echo-3F","()",""],["echo?","IO","IO.html#method-i-echo-3F","()","<p>Returns <code>true</code> if echo back is enabled.\n<p>You must require &#39;io/console&#39; to use this method.\n"],["edit_path","Net::HTTP","Net/HTTP.html#method-i-edit_path","(path)",""],["egd","OpenSSL::Random","OpenSSL/Random.html#method-c-egd","(p1)","<p>Same as ::egd_bytes but queries 255 bytes by default.\n"],["egd_bytes","OpenSSL::Random","OpenSSL/Random.html#method-c-egd_bytes","(p1, p2)","<p>Queries the entropy gathering daemon EGD on socket path given by <em>filename</em>.\n<p>Fetches <em>length</em> number of bytes …\n"],["egid","Process","Process.html#method-c-egid","()","<p>Returns the effective group ID for this process. Not available on all platforms.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">egid</span>   <span class=\"ruby-comment\">#=&gt; 500</span>\n</pre>\n"],["egid=","Process","Process.html#method-c-egid-3D","(p1)","<p>Sets the effective group ID for this process. Not available on all platforms.\n"],["ehlo","Net::SMTP","Net/SMTP.html#method-i-ehlo","(domain)",""],["eid","Process::GID","Process/GID.html#method-c-eid","()","<p>Returns the effective group ID for this process. Not available on all platforms.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">egid</span>   <span class=\"ruby-comment\">#=&gt; 500</span>\n</pre>\n"],["eid","Process::UID","Process/UID.html#method-c-eid","()","<p>Returns the effective user ID for this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">euid</span>   <span class=\"ruby-comment\">#=&gt; 501</span>\n</pre>\n"],["eigen","Matrix","Matrix.html#method-i-eigen","()",""],["eigensystem","Matrix","Matrix.html#method-i-eigensystem","()","<p>Returns the Eigensystem of the matrix; see <code>EigenvalueDecomposition</code>.\n\n<pre>m = Matrix[[1, 2], [3, 4]]\nv, d, v_inv ...</pre>\n"],["eigenvalue_matrix","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-eigenvalue_matrix","()","<p>Returns the block diagonal eigenvalue matrix <code>D</code>\n"],["eigenvalues","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-eigenvalues","()","<p>Returns the eigenvalues in an array\n"],["eigenvector_matrix","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-eigenvector_matrix","()","<p>Returns the eigenvector matrix <code>V</code>\n"],["eigenvector_matrix_inv","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-eigenvector_matrix_inv","()","<p>Returns the inverse of the eigenvector matrix <code>V</code>\n"],["eigenvectors","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-eigenvectors","()","<p>Returns an array of the eigenvectors\n"],["either_version_older_than_locked","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-either_version_older_than_locked","()",""],["element","Matrix","Matrix.html#method-i-element","(i, j)",""],["element","Vector","Vector.html#method-i-element","(i)",""],["element=","REXML::Attribute","REXML/Attribute.html#method-i-element-3D","( element )","<p>Sets the element of which this object is an attribute.  Normally, this is not directly called.\n<p>Returns …\n"],["element_initialize_arguments?","RSS::Utils","RSS/Utils.html#method-i-element_initialize_arguments-3F","(args)","<p>This method is used inside of several different objects to determine if special behavior is needed in …\n"],["elementdecl","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-elementdecl","(content)","<p>&lt;!ELEMENT …&gt;\n"],["elementdecl","REXML::StreamListener","REXML/StreamListener.html#method-i-elementdecl","(content)","<p>&lt;!ELEMENT …&gt;\n"],["elementdecl?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-elementdecl-3F","()","<p>Content: [ String text ]\n"],["elements","Vector","Vector.html#method-c-elements","(array, copy = true)","<p>Creates a vector from an Array.  The optional second argument specifies whether the array itself or a …\n"],["elements_to_f","Matrix","Matrix.html#method-i-elements_to_f","()","<p>Deprecated.\n<p>Use map(&amp;:to_f)\n"],["elements_to_f","Vector","Vector.html#method-i-elements_to_f","()",""],["elements_to_i","Matrix","Matrix.html#method-i-elements_to_i","()","<p>Deprecated.\n<p>Use map(&amp;:to_i)\n"],["elements_to_i","Vector","Vector.html#method-i-elements_to_i","()",""],["elements_to_r","Matrix","Matrix.html#method-i-elements_to_r","()","<p>Deprecated.\n<p>Use map(&amp;:to_r)\n"],["elements_to_r","Vector","Vector.html#method-i-elements_to_r","()",""],["emacs_editing_mode","Readline","Readline.html#method-c-emacs_editing_mode","()","<p>Specifies Emacs editing mode. The default is this mode. See the manual of GNU Readline for details of …\n"],["emacs_editing_mode","Reline::Core","Reline/Core.html#method-i-emacs_editing_mode","()",""],["emacs_editing_mode?","Readline","Readline.html#method-c-emacs_editing_mode-3F","()","<p>Returns true if emacs mode is active. Returns false if not.\n<p>Raises NotImplementedError if the using readline …\n"],["emacs_editing_mode?","Reline::Core","Reline/Core.html#method-i-emacs_editing_mode-3F","()",""],["email_to_name","Gem::Security","Gem/Security.html#method-c-email_to_name","(email_address)","<p>Turns <code>email_address</code> into an OpenSSL::X509::Name\n"],["embed_library","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-embed_library","(src)",""],["embedded_action","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-embedded_action","(act)",""],["emit_coder","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-emit_coder","(c, o)",""],["emit_row","CSV::Parser","CSV/Parser.html#method-i-emit_row","(row, &block)",""],["emphasis","RDoc::Markdown","RDoc/Markdown.html#method-i-emphasis","(text)","<p>Wraps <code>text</code> in emphasis for rdoc inline formatting\n"],["empty","Bundler::Molinillo::ResolutionState","Bundler/Molinillo/ResolutionState.html#method-c-empty","()","<p>Returns an empty resolution state @return [ResolutionState] an empty state\n"],["empty","Gem::Resolver::Molinillo::ResolutionState","Gem/Resolver/Molinillo/ResolutionState.html#method-c-empty","()","<p>Returns an empty resolution state @return [ResolutionState] an empty state\n"],["empty","Matrix","Matrix.html#method-c-empty","(row_count = 0, column_count = 0)","<p>Creates a empty matrix of <code>row_count</code> x <code>column_count</code>. At least one of <code>row_count</code> or <code>column_count</code> must be …\n"],["empty","Psych::Handler","Psych/Handler.html#method-i-empty","()","<p>Called when an empty event happens. (Which, as far as I can tell, is never).\n"],["empty","Racc::UserAction","Racc/UserAction.html#method-c-empty","()",""],["empty?","Array","Array.html#method-i-empty-3F","()","<p>Returns <code>true</code> if <code>self</code> contains no elements.\n\n<pre class=\"ruby\">[].<span class=\"ruby-identifier\">empty?</span>   <span class=\"ruby-comment\">#=&gt; true</span>\n</pre>\n"],["empty?","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-empty-3F","()","<p>Returns <code>true</code> if there are no available connections.\n"],["empty?","Bundler::Index","Bundler/Index.html#method-i-empty-3F","()",""],["empty?","Bundler::SpecSet","Bundler/SpecSet.html#method-i-empty-3F","()",""],["empty?","Bundler::VersionRanges","Bundler/VersionRanges.html#method-c-empty-3F","(ranges, neqs)",""],["empty?","Bundler::VersionRanges::ReqR","Bundler/VersionRanges/ReqR.html#method-i-empty-3F","()",""],["empty?","CSV::FieldsConverter","CSV/FieldsConverter.html#method-i-empty-3F","()",""],["empty?","DBM","DBM.html#method-i-empty-3F","()","<p>Returns true if the database is empty, false otherwise.\n"],["empty?","Dir","Dir.html#method-c-empty-3F","(p1)","<p>Returns <code>true</code> if the named file is an empty directory, <code>false</code> if it is not a directory or non-empty.\n"],["empty?","ENV","ENV.html#method-c-empty-3F","()","<p>Returns true when there are no environment variables\n"],["empty?","File","File.html#method-c-empty-3F","(p1)","<p>Returns <code>true</code> if the named file exists and has a zero size.\n<p><em>file_name</em> can be an IO object.\n"],["empty?","FileTest","FileTest.html#method-i-empty-3F","(p1)","<p>Returns <code>true</code> if the named file exists and has a zero size.\n<p><em>file_name</em> can be an IO object.\n"],["empty?","GDBM","GDBM.html#method-i-empty-3F","()","<p>Returns true if the database is empty.\n"],["empty?","Gem::AvailableSet","Gem/AvailableSet.html#method-i-empty-3F","()",""],["empty?","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-i-empty-3F","()","<p>Is the tar entry empty?\n"],["empty?","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-empty-3F","()",""],["empty?","Gem::Resolver::RequirementList","Gem/Resolver/RequirementList.html#method-i-empty-3F","()","<p>Is the list empty?\n"],["empty?","Gem::SourceList","Gem/SourceList.html#method-i-empty-3F","()","<p>Returns true if there are no sources in this SourceList.\n"],["empty?","Hash","Hash.html#method-i-empty-3F","()","<p>Returns <code>true</code> if <em>hsh</em> contains no key-value pairs.\n\n<pre class=\"ruby\">{}.<span class=\"ruby-identifier\">empty?</span>   <span class=\"ruby-comment\">#=&gt; true</span>\n</pre>\n"],["empty?","Matrix","Matrix.html#method-i-empty-3F","()","<p>Returns <code>true</code> if this is an empty matrix, i.e. if the number of rows or the number of columns is 0.\n"],["empty?","Pathname","Pathname.html#method-i-empty-3F","()","<p>Tests the file is empty.\n<p>See Dir#empty? and FileTest.empty?.\n"],["empty?","Queue","Queue.html#method-i-empty-3F","()","<p>Returns <code>true</code> if the queue is empty.\n"],["empty?","RDoc::Comment","RDoc/Comment.html#method-i-empty-3F","()","<p>A comment is empty if its text String is empty.\n"],["empty?","REXML::Elements","REXML/Elements.html#method-i-empty-3F","()","<p>Returns <code>true</code> if there are no <code>Element</code> children, <code>false</code> otherwise\n"],["empty?","REXML::IOSource","REXML/IOSource.html#method-i-empty-3F","()",""],["empty?","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-empty-3F","()","<p>Returns true if there are no more events\n"],["empty?","REXML::Source","REXML/Source.html#method-i-empty-3F","()","<p>@return true if the Source is exhausted\n"],["empty?","REXML::Text","REXML/Text.html#method-i-empty-3F","()",""],["empty?","Racc::ISet","Racc/ISet.html#method-i-empty-3F","()",""],["empty?","Racc::Rule","Racc/Rule.html#method-i-empty-3F","()",""],["empty?","Racc::UserAction","Racc/UserAction.html#method-i-empty-3F","()",""],["empty?","SDBM","SDBM.html#method-i-empty-3F","()","<p>Returns <code>true</code> if the database is empty.\n"],["empty?","Set","Set.html#method-i-empty-3F","()","<p>Returns true if the set contains no elements.\n"],["empty?","SizedQueue","SizedQueue.html#method-i-empty-3F","()","<p>Returns <code>true</code> if the queue is empty.\n"],["empty?","String","String.html#method-i-empty-3F","()","<p>Returns <code>true</code> if <em>str</em> has a length of zero.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">empty?</span>   <span class=\"ruby-comment\">#=&gt; false</span>\n<span class=\"ruby-string\">&quot; &quot;</span>.<span class=\"ruby-identifier\">empty?</span>       <span class=\"ruby-comment\">#=&gt; false</span>\n<span class=\"ruby-string\">&quot;&quot;</span>.<span class=\"ruby-identifier\">empty?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["empty?","StringScanner","StringScanner.html#method-i-empty-3F","()","<p>Equivalent to #eos?. This method is obsolete, use #eos? instead.\n"],["empty?","Symbol","Symbol.html#method-i-empty-3F","()","<p>Returns whether <em>sym</em> is :“” or not.\n"],["empty_content?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-empty_content-3F","()",""],["empty_content?","RSS::Element","RSS/Element.html#method-i-empty_content-3F","()",""],["empty_directory","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-empty_directory","(destination, config = {})","<p>Creates an empty directory.\n<p>Parameters\n<p>destination&lt;String&gt; &mdash; the relative path to the destination root. …\n"],["empty_marshal_checksum","PStore","PStore.html#method-i-empty_marshal_checksum","()",""],["empty_marshal_data","PStore","PStore.html#method-i-empty_marshal_data","()",""],["enable","GC","GC.html#method-c-enable","()","<p>Enables garbage collection, returning <code>true</code> if garbage collection was previously disabled.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">GC</span>.<span class=\"ruby-identifier\">disable</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["enable","GC::Profiler","GC/Profiler.html#method-c-enable","()","<p>Starts the GC profiler.\n"],["enable","TracePoint","TracePoint.html#method-i-enable","(target: nil, target_line: nil, target_thread: nil)","<p>Activates the trace.\n<p>Returns <code>true</code> if trace was enabled. Returns <code>false</code> if trace was disabled.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">trace</span>.<span class=\"ruby-identifier\">enabled?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["enable_close","Fiddle::Handle","Fiddle/Handle.html#method-i-enable_close","()","<p>Enable a call to dlclose() when this handle is garbage collected.\n"],["enable_config","MakeMakefile","MakeMakefile.html#method-i-enable_config","(config, default=nil)","<p>Tests for the presence of an <code>--enable-</code><em>config</em> or <code>--disable-</code><em>config</em> option. Returns <code>true</code> if the enable option …\n"],["enable_fallback_scsv","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-enable_fallback_scsv","()","<p>Activate TLS_FALLBACK_SCSV for this context. See RFC 7507.\n"],["enable_shared","Gem::TestCase","Gem/TestCase.html#method-i-enable_shared","(value)","<p>Sets the ENABLE_SHARED entry in RbConfig::CONFIG to <code>value</code> and restores the original value when the block …\n"],["enable_ssl","Net::POP3","Net/POP3.html#method-i-enable_ssl","(verify_or_params = {}, certs = nil, port = nil)","<p>Enables SSL for this instance.  Must be called before the connection is established to have any effect. …\n"],["enable_ssl","Net::POP3","Net/POP3.html#method-c-enable_ssl","(*args)","<p>Enable SSL for all new instances. <code>params</code> is passed to OpenSSL::SSLContext#set_params.\n"],["enable_ssl","Net::SMTP","Net/SMTP.html#method-i-enable_ssl","(context = SMTP.default_ssl_context)",""],["enable_starttls","Net::SMTP","Net/SMTP.html#method-i-enable_starttls","(context = SMTP.default_ssl_context)","<p>Enables SMTP/TLS (STARTTLS) for this object. <code>context</code> is a OpenSSL::SSL::SSLContext object.\n"],["enable_starttls_auto","Net::SMTP","Net/SMTP.html#method-i-enable_starttls_auto","(context = SMTP.default_ssl_context)","<p>Enables SMTP/TLS (STARTTLS) for this object if server accepts. <code>context</code> is a OpenSSL::SSL::SSLContext …\n"],["enable_tls","Net::SMTP","Net/SMTP.html#method-i-enable_tls","(context = SMTP.default_ssl_context)","<p>Enables SMTP/TLS (SMTPS: SMTP over direct TLS connection) for this object.  Must be called before the …\n"],["enabled?","GC::Profiler","GC/Profiler.html#method-c-enabled-3F","()","<p>The current status of GC profile mode.\n"],["enabled?","RubyVM::MJIT","RubyVM/MJIT.html#method-c-enabled-3F","()","<p>Returns true if JIT is enabled\n"],["enabled?","TracePoint","TracePoint.html#method-i-enabled-3F","()","<p>The current status of the trace\n"],["enc_key","OpenSSL::PKCS7::RecipientInfo","OpenSSL/PKCS7/RecipientInfo.html#method-i-enc_key","()",""],["enclose","ThreadGroup","ThreadGroup.html#method-i-enclose","()","<p>Prevents threads from being added to or removed from the receiving ThreadGroup.\n<p>New threads can still …\n"],["enclosed?","ThreadGroup","ThreadGroup.html#method-i-enclosed-3F","()","<p>Returns <code>true</code> if the <code>thgrp</code> is enclosed. See also ThreadGroup#enclose.\n"],["encode","Bundler::URI::Escape","Bundler/URI/Escape.html#method-i-encode","(*arg)",""],["encode","REXML::Encoding","REXML/Encoding.html#method-i-encode","(string)",""],["encode","String","String.html#method-i-encode","(*args)","<p>The first form returns a copy of <code>str</code> transcoded to encoding <code>encoding</code>. The second form returns a copy …\n"],["encode","URI::Escape","URI/Escape.html#method-i-encode","(*arg)",""],["encode!","RDoc::Comment","RDoc/Comment.html#method-i-encode-21","(encoding)","<p>HACK dubious\n"],["encode!","String","String.html#method-i-encode-21","(*args)","<p>The first form transcodes the contents of <em>str</em> from str.encoding to <code>encoding</code>. The second form transcodes …\n"],["encode64","Base64","Base64.html#method-i-encode64","(bin)","<p>Returns the Base64-encoded version of <code>bin</code>. This method complies with RFC 2045. Line feeds are added to …\n"],["encode_fallback","RDoc::Text","RDoc/Text.html#method-c-encode_fallback","(character, encoding, fallback)","<p>Transcodes <code>character</code> to <code>encoding</code> with a <code>fallback</code> character.\n"],["encode_multipart_form_data","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-encode_multipart_form_data","(out, params, opt)",""],["encode_utf7","Net::IMAP","Net/IMAP.html#method-c-encode_utf7","(s)","<p>Encode a string from UTF-8 format to modified UTF-7.\n"],["encode_with","Gem::Dependency","Gem/Dependency.html#method-i-encode_with","(coder)",""],["encode_www_form","Bundler::URI","Bundler/URI.html#method-c-encode_www_form","(enum, enc=nil)","<p>Generates URL-encoded form data from given <code>enum</code>.\n<p>This generates application/x-www-form-urlencoded data …\n"],["encode_www_form","URI","URI.html#method-c-encode_www_form","(enum, enc=nil)","<p>Generates URL-encoded form data from given <code>enum</code>.\n<p>This generates application/x-www-form-urlencoded data …\n"],["encode_www_form_component","Bundler::URI","Bundler/URI.html#method-c-encode_www_form_component","(str, enc=nil)","<p>Encodes given <code>str</code> to URL-encoded form data.\n<p>This method doesn&#39;t convert *, -, ., 0-9, A-Z, _, a-z, …\n"],["encode_www_form_component","URI","URI.html#method-c-encode_www_form_component","(str, enc=nil)","<p>Encodes given <code>str</code> to URL-encoded form data.\n<p>This method doesn&#39;t convert *, -, ., 0-9, A-Z, _, a-z, …\n"],["encoding","IRB::FileInputMethod","IRB/FileInputMethod.html#method-i-encoding","()","<p>The external encoding for standard input.\n"],["encoding","IRB::Locale","IRB/Locale.html#method-i-encoding","()",""],["encoding","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-i-encoding","()","<p>The external encoding for standard input.\n"],["encoding","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-encoding","()","<p>The external encoding for standard input.\n"],["encoding","IRB::StdioInputMethod","IRB/StdioInputMethod.html#method-i-encoding","()","<p>The external encoding for standard input.\n"],["encoding","REXML::Document","REXML/Document.html#method-i-encoding","()","<p>@return the XMLDecl encoding of this document as an Encoding object. If no XMLDecl has been set, returns …\n"],["encoding","Regexp","Regexp.html#method-i-encoding","()","<p>Returns the Encoding object that represents the encoding of obj.\n"],["encoding","Reline::Core","Reline/Core.html#method-i-encoding","()",""],["encoding","Ripper","Ripper.html#method-i-encoding","()","<p>Return encoding of the source.\n"],["encoding","String","String.html#method-i-encoding","()","<p>Returns the Encoding object that represents the encoding of obj.\n"],["encoding","Symbol","Symbol.html#method-i-encoding","()","<p>Returns the Encoding object that represents the encoding of <em>sym</em>.\n"],["encoding=","REXML::Encoding","REXML/Encoding.html#method-i-encoding-3D","(encoding)",""],["encoding=","REXML::Source","REXML/Source.html#method-i-encoding-3D","(enc)","<p>Inherited from Encoding Overridden to support optimized en/decoding\n"],["encoding=","REXML::XMLDecl","REXML/XMLDecl.html#method-i-encoding-3D","( enc )",""],["encoding_system_needs","Reline","Reline.html#method-c-encoding_system_needs","()",""],["encoding_updated","REXML::IOSource","REXML/IOSource.html#method-i-encoding_updated","()",""],["encoding_updated","REXML::Source","REXML/Source.html#method-i-encoding_updated","()",""],["encrypt","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-encrypt","(*args)","<p>Initializes the Cipher for encryption.\n<p>Make sure to call Cipher#encrypt or Cipher#decrypt before using …\n"],["encrypt","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-c-encrypt","(p1, p2, p3 = v3, p4 = v4)",""],["end","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-end","()",""],["end","MatchData","MatchData.html#method-i-end","(p1)","<p>Returns the offset of the character immediately following the end of the <em>n</em>th element of the match array …\n"],["end","Range","Range.html#method-i-end","()","<p>Returns the object that defines the end of the range.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">end</span>    <span class=\"ruby-comment\">#=&gt; 10</span>\n(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">...</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">end</span>   <span class=\"ruby-comment\">#=&gt; 10</span>\n</pre>\n"],["end","Zlib::ZStream","Zlib/ZStream.html#method-i-end","()","<p>Closes the stream. All operations on the closed stream will raise an exception.\n"],["end?","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-c-end-3F","(token)",""],["endElement","RSS::REXMLLikeXMLParser","RSS/REXMLLikeXMLParser.html#method-i-endElement","(name)",""],["end_document","Psych::Emitter","Psych/Emitter.html#method-i-end_document","(p1)","<p>End a document emission with an <code>implicit</code> ending.\n<p>See Psych::Handler#end_document\n"],["end_document","Psych::Handler","Psych/Handler.html#method-i-end_document","(implicit)","<p>Called with the document ends.  <code>implicit</code> is a boolean value indicating whether or not the document has …\n"],["end_document","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-end_document","(implicit_end = !streaming?)","<p>Handles end_document events with <code>version</code>, <code>tag_directives</code>, and <code>implicit</code> styling.\n<p>See Psych::Handler#start_document …\n"],["end_document","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-end_document","()",""],["end_element","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-end_element","(uri, localname, qname)",""],["end_element?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-end_element-3F","()","<p>Content: [ String tag_name ]\n"],["end_mapping","Psych::Emitter","Psych/Emitter.html#method-i-end_mapping","()","<p>Emit the end of a mapping.\n<p>See Psych::Handler#end_mapping\n"],["end_mapping","Psych::Handler","Psych/Handler.html#method-i-end_mapping","()","<p>Called when a map ends\n"],["end_precedence_declaration","Racc::Grammar","Racc/Grammar.html#method-i-end_precedence_declaration","(reverse)",""],["end_prefix_mapping","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-end_prefix_mapping","(prefix)",""],["end_resolution","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-end_resolution","()","<p>Ends the resolution process @return [void]\n"],["end_resolution","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-end_resolution","()","<p>Ends the resolution process @return [void]\n"],["end_seen?","Ripper","Ripper.html#method-i-end_seen-3F","()","<p>Return true if parsed source ended by +_<em>END</em>_+.\n"],["end_sequence","Psych::Emitter","Psych/Emitter.html#method-i-end_sequence","()","<p>End sequence emission.\n<p>See Psych::Handler#end_sequence\n"],["end_sequence","Psych::Handler","Psych/Handler.html#method-i-end_sequence","()","<p>Called when a sequence ends.\n"],["end_stream","Psych::Emitter","Psych/Emitter.html#method-i-end_stream","()","<p>End a stream emission\n<p>See Psych::Handler#end_stream\n"],["end_stream","Psych::Handler","Psych/Handler.html#method-i-end_stream","()","<p>Called when the YAML stream ends\n"],["end_stream","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-end_stream","()",""],["end_transport","Net::HTTP","Net/HTTP.html#method-i-end_transport","(req, res)",""],["end_with?","String","String.html#method-i-end_with-3F","(*args)","<p>Returns true if <code>str</code> ends with one of the <code>suffixes</code> given.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">end_with?</span>(<span class=\"ruby-string\">&quot;ello&quot;</span>)               <span class=\"ruby-comment\">#=&gt; true ...</span>\n</pre>\n"],["end_with?","Symbol","Symbol.html#method-i-end_with-3F","(*args)","<p>Returns true if <code>sym</code> ends with one of the <code>suffixes</code> given.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">:hello</span>.<span class=\"ruby-identifier\">end_with?</span>(<span class=\"ruby-string\">&quot;ello&quot;</span>)               <span class=\"ruby-comment\">#=&gt; true ...</span>\n</pre>\n"],["ended?","Zlib::ZStream","Zlib/ZStream.html#method-i-ended-3F","()","<p>Returns true if the stream is closed.\n"],["endgrent","Etc","Etc.html#method-c-endgrent","()","<p>Ends the process of scanning through the /etc/group file begun by ::getgrent, and closes the file.\n"],["endpwent","Etc","Etc.html#method-c-endpwent","()","<p>Ends the process of scanning through the /etc/passwd file begun with ::getpwent, and closes the file. …\n"],["engines","OpenSSL::Engine","OpenSSL/Engine.html#method-c-engines","()","<p>Returns an array of currently loaded engines.\n"],["england","Date","Date.html#method-i-england","()","<p>This method is equivalent to new_start(Date::ENGLAND).\n"],["enq","Bundler::Worker","Bundler/Worker.html#method-i-enq","(obj)","<p>Enqueue a request to be executed in the worker pool\n<p>@param obj [String] mostly it is name of spec that …\n"],["enq","Queue","Queue.html#method-i-enq","(p1)",""],["enq","SizedQueue","SizedQueue.html#method-i-enq","(*args)",""],["enqueue_specs","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-enqueue_specs","()","<p>Keys in the remains hash represent uninstalled gems specs. We enqueue all gem specs that do not have …\n"],["enqueued?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-enqueued-3F","()",""],["ensure_all_gems_in_lockfile!","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-ensure_all_gems_in_lockfile-21","(names, locked_gems = Bundler.locked_gems)",""],["ensure_default_gem_subdirectories","Gem","Gem.html#method-c-ensure_default_gem_subdirectories","(dir = Gem.dir, mode = nil)","<p>Quietly ensure the Gem directory <code>dir</code> contains all the proper subdirectories for handling default gems. …\n"],["ensure_dependency","Gem::Installer","Gem/Installer.html#method-i-ensure_dependency","(spec, dependency)","<p>Ensure that the dependency is satisfied by the current installation of gem.  If it is not an exception …\n"],["ensure_equivalent_gemfile_and_lockfile","Bundler::Definition","Bundler/Definition.html#method-i-ensure_equivalent_gemfile_and_lockfile","(explicit_flag = false)",""],["ensure_gem_subdirectories","Gem","Gem.html#method-c-ensure_gem_subdirectories","(dir = Gem.dir, mode = nil)","<p>Quietly ensure the Gem directory <code>dir</code> contains all the proper subdirectories.  If we can&#39;t create …\n"],["ensure_loadable_spec","Gem::Installer","Gem/Installer.html#method-i-ensure_loadable_spec","()","<p>Ensures the Gem::Specification written out for this gem is loadable upon installation.\n"],["ensure_mod_sequence_value","Net::IMAP::NumValidator","Net/IMAP/NumValidator.html#method-c-ensure_mod_sequence_value","(num)","<p>Ensure argument is &#39;mod_sequence_value&#39; or raise DataFormatError\n"],["ensure_number","Net::IMAP::NumValidator","Net/IMAP/NumValidator.html#method-c-ensure_number","(num)","<p>Ensure argument is &#39;number&#39; or raise DataFormatError\n"],["ensure_nz_number","Net::IMAP::NumValidator","Net/IMAP/NumValidator.html#method-c-ensure_nz_number","(num)","<p>Ensure argument is &#39;nz_number&#39; or raise DataFormatError\n"],["ensure_safe_gem_name","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-ensure_safe_gem_name","(name, constant_array)",""],["ensure_same_dependencies","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-ensure_same_dependencies","(spec, old_deps, new_deps)",""],["ensure_specs_are_compatible!","Bundler::Installer","Bundler/Installer.html#method-i-ensure_specs_are_compatible-21","()",""],["ensure_xml_content","RSS::Maker::AtomTextConstructBase::EnsureXMLContent","RSS/Maker/AtomTextConstructBase/EnsureXMLContent.html#method-i-ensure_xml_content","(content)",""],["enter","Bundler::Thor::NestedContext","Bundler/Thor/NestedContext.html#method-i-enter","()",""],["enter","Monitor","Monitor.html#method-i-enter","()",""],["enter","REXML::XPathParser","REXML/XPathParser.html#method-i-enter","(tag, *args)",""],["enterable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-enterable-3F","()","<p>Returns <code>true</code> if the directory may be entered by CWD/CDUP.\n"],["entered?","Bundler::Thor::NestedContext","Bundler/Thor/NestedContext.html#method-i-entered-3F","()",""],["entity","Net::HTTPResponse","Net/HTTPResponse.html#method-i-entity","()",""],["entity","REXML::DocType","REXML/DocType.html#method-i-entity","( name )",""],["entity","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-entity","( reference, entities )",""],["entity","REXML::StreamListener","REXML/StreamListener.html#method-i-entity","(content)","<p>Called when %foo; is encountered in a doctype declaration. @p content “foo”\n"],["entity","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-entity","(ref)",""],["entity?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-entity-3F","()","<p>Content: [ String text ]\n"],["entity_class","Fiddle::CStruct","Fiddle/CStruct.html#method-c-entity_class","()","<p>accessor to Fiddle::CStructEntity\n"],["entity_class","Fiddle::CUnion","Fiddle/CUnion.html#method-c-entity_class","()","<p>accessor to Fiddle::CUnionEntity\n"],["entity_expansion_limit","REXML::Document","REXML/Document.html#method-c-entity_expansion_limit","()","<p>Get the entity expansion limit. By default the limit is set to 10000.\n<p>Deprecated. Use REXML::Security.entity_expansion_limit= …\n"],["entity_expansion_limit","REXML::Security","REXML/Security.html#method-c-entity_expansion_limit","()","<p>Get the entity expansion limit. By default the limit is set to 10000.\n"],["entity_expansion_limit=","REXML::Document","REXML/Document.html#method-c-entity_expansion_limit-3D","( val )","<p>Set the entity expansion limit. By default the limit is set to 10000.\n<p>Deprecated. Use REXML::Security.entity_expansion_limit= …\n"],["entity_expansion_limit=","REXML::Security","REXML/Security.html#method-c-entity_expansion_limit-3D","( val )","<p>Set the entity expansion limit. By default the limit is set to 10000.\n"],["entity_expansion_text_limit","REXML::Document","REXML/Document.html#method-c-entity_expansion_text_limit","()","<p>Get the entity expansion limit. By default the limit is set to 10240.\n<p>Deprecated. Use REXML::Security.entity_expansion_text_limit …\n"],["entity_expansion_text_limit","REXML::Security","REXML/Security.html#method-c-entity_expansion_text_limit","()","<p>Get the entity expansion limit. By default the limit is set to 10240.\n"],["entity_expansion_text_limit=","REXML::Document","REXML/Document.html#method-c-entity_expansion_text_limit-3D","( val )","<p>Set the entity expansion limit. By default the limit is set to 10240.\n<p>Deprecated. Use REXML::Security.entity_expansion_text_limit= …\n"],["entity_expansion_text_limit=","REXML::Security","REXML/Security.html#method-c-entity_expansion_text_limit-3D","( val )","<p>Set the entity expansion limit. By default the limit is set to 10240.\n"],["entitydecl","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-entitydecl","(declaration)","<p>&lt;!ENTITY …&gt; The argument passed to this method is an array of the entity declaration.  It can …\n"],["entitydecl","REXML::StreamListener","REXML/StreamListener.html#method-i-entitydecl","(content)","<p>&lt;!ENTITY …&gt; The argument passed to this method is an array of the entity declaration.  It can …\n"],["entitydecl?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-entitydecl-3F","()","<p>Due to the wonders of DTDs, an entity declaration can be just about anything.  There&#39;s no way to …\n"],["entries","Dir","Dir.html#method-c-entries","(*args)","<p>Returns an array containing all of the filenames in the given directory. Will raise a SystemCallError …\n"],["entries","Enumerable","Enumerable.html#method-i-entries","(*args)","<p>Returns an array containing the items in <em>enum</em>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">to_a</span>                       <span class=\"ruby-comment\">#=&gt; [1, 2, 3, 4, 5, 6, ...</span>\n</pre>\n"],["entries","Pathname","Pathname.html#method-i-entries","()","<p>Return the entries (files and subdirectories) in the directory, each as a Pathname object.\n<p>The results …\n"],["entries","Range","Range.html#method-i-entries","()","<p>Returns an array containing the items in the range.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">to_a</span>  <span class=\"ruby-comment\">#=&gt; [1, 2, 3, 4, 5, 6, 7]</span>\n(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span>).<span class=\"ruby-identifier\">to_a</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["entry_details","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-entry_details","(entry, detail_tuple, specs, platforms)",""],["entry_versions","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-entry_versions","(entry, name_tuples, platforms, specs)",""],["entrywise_product","Matrix","Matrix.html#method-i-entrywise_product","(m)",""],["enum_for","Enumerator::Lazy","Enumerator/Lazy.html#method-i-enum_for","(*args)","<p>Similar to Object#to_enum, except it returns a lazy enumerator. This makes it easy to define Enumerable …\n"],["enum_for","Object","Object.html#method-i-enum_for","(*args)","<p>Creates a new Enumerator which will enumerate by calling <code>method</code> on <code>obj</code>, passing <code>args</code> if any. What was …\n"],["env","Bundler::CLI","Bundler/CLI.html#method-i-env","()",""],["env","Bundler::Dsl","Bundler/Dsl.html#method-i-env","(name)",""],["env_requirement","Gem","Gem.html#method-c-env_requirement","(gem_name)",""],["env_table","CGI","CGI.html#method-i-env_table","()","<p>Synonym for ENV.\n"],["environment","Bundler","Bundler.html#method-c-environment","()",""],["environment","Bundler::Env","Bundler/Env.html#method-c-environment","()",""],["environment","OptionParser","OptionParser.html#method-i-environment","(env = File.basename($0, '.*'))","<p>Parses environment variable <code>env</code> or its uppercase with splitting like a shell.\n<p><code>env</code> defaults to the basename …\n"],["eof","ARGF","ARGF.html#method-i-eof","()","<p>Returns true if the current file in <code>ARGF</code> is at end of file, i.e. it has no data to read. The stream must …\n"],["eof","CSV","CSV.html#method-i-eof","()",""],["eof","IO","IO.html#method-i-eof","()","<p>Returns true if <em>ios</em> is at end of file that means there are no more data to read. The stream must be opened …\n"],["eof","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-eof","()",""],["eof","StringIO","StringIO.html#method-i-eof","()","<p>Returns true if the stream is at the end of the data (underlying string). The stream must be opened for …\n"],["eof","Zlib::GzipReader","Zlib/GzipReader.html#method-i-eof","()","<p>Returns <code>true</code> or <code>false</code> whether the stream has reached the end.\n"],["eof?","ARGF","ARGF.html#method-i-eof-3F","()","<p>Returns true if the current file in <code>ARGF</code> is at end of file, i.e. it has no data to read. The stream must …\n"],["eof?","CSV","CSV.html#method-i-eof-3F","()",""],["eof?","CSV::Parser::UnoptimizedStringIO","CSV/Parser/UnoptimizedStringIO.html#method-i-eof-3F","()",""],["eof?","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-eof-3F","()","<p>Are we at the end of the tar entry?\n"],["eof?","IO","IO.html#method-i-eof-3F","()","<p>Returns true if <em>ios</em> is at end of file that means there are no more data to read. The stream must be opened …\n"],["eof?","IRB::FileInputMethod","IRB/FileInputMethod.html#method-i-eof-3F","()","<p>Whether the end of this input method has been reached, returns <code>true</code> if there is no more data to read. …\n"],["eof?","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-i-eof-3F","()","<p>Whether the end of this input method has been reached, returns <code>true</code> if there is no more data to read. …\n"],["eof?","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-eof-3F","()","<p>Whether the end of this input method has been reached, returns <code>true</code> if there is no more data to read. …\n"],["eof?","IRB::StdioInputMethod","IRB/StdioInputMethod.html#method-i-eof-3F","()","<p>Whether the end of this input method has been reached, returns <code>true</code> if there is no more data to read. …\n"],["eof?","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-eof-3F","()","<p>Returns true if the stream is at file which means there is no more data to be read.\n"],["eof?","StringIO","StringIO.html#method-i-eof-3F","()","<p>Returns true if the stream is at the end of the data (underlying string). The stream must be opened for …\n"],["eof?","XMP::StringInputMethod","XMP/StringInputMethod.html#method-i-eof-3F","()","<p>Whether there are any expressions left in this printer.\n"],["eof?","Zlib::GzipReader","Zlib/GzipReader.html#method-i-eof-3F","()","<p>Returns <code>true</code> or <code>false</code> whether the stream has reached the end.\n"],["eos?","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-eos-3F","()",""],["eos?","StringScanner","StringScanner.html#method-i-eos-3F","()","<p>Returns <code>true</code> if the scan pointer is at the end of the string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">StringScanner</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;test string&#39;</span>)\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-identifier\">s</span>.<span class=\"ruby-identifier\">eos?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["eql?","Array","Array.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> if <code>self</code> and <code>other</code> are the same object, or are both arrays with the same content (according …\n"],["eql?","BigDecimal","BigDecimal.html#method-i-eql-3F","(p1)","<p>Tests for value equality; returns true if the values are equal.\n<p>The == and === operators and the eql? …\n"],["eql?","Bundler::DepProxy","Bundler/DepProxy.html#method-i-eql-3F","(other)",""],["eql?","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-eql-3F","(other)",""],["eql?","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-eql-3F","(other)","<p>When overriding `eql?` please preserve the behaviour as mentioned in docstring for `==` method.\n"],["eql?","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-eql-3F","(other)",""],["eql?","Bundler::Source::Git","Bundler/Source/Git.html#method-i-eql-3F","(other)",""],["eql?","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-eql-3F","(other)",""],["eql?","Bundler::Source::Path","Bundler/Source/Path.html#method-i-eql-3F","(other)",""],["eql?","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-eql-3F","(other)",""],["eql?","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-eql-3F","(oth)",""],["eql?","Delegator","Delegator.html#method-i-eql-3F","(obj)","<p>Returns true if two objects are considered of equal value.\n"],["eql?","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> only if <code>obj</code> is an Enumerator::ArithmeticSequence, has equivalent begin, end, step, and  …\n"],["eql?","Fiddle::Pointer","Fiddle/Pointer.html#method-i-eql-3F","(p1)","<p>Returns true if <code>other</code> wraps the same pointer, otherwise returns false.\n"],["eql?","Float","Float.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> only if <code>obj</code> is a Float with the same value as <code>float</code>. Contrast this with Float#==, which …\n"],["eql?","Gem::NameTuple","Gem/NameTuple.html#method-i-eql-3F","(other)",""],["eql?","Gem::Platform","Gem/Platform.html#method-i-eql-3F","(other)",""],["eql?","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-eql-3F","(other)",""],["eql?","Gem::Version","Gem/Version.html#method-i-eql-3F","(other)","<p>A Version is only eql? to another version if it&#39;s specified to the same precision. Version “1.0” …\n"],["eql?","Hash","Hash.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> if <em>hash</em> and <em>other</em> are both hashes with the same content. The orders of each hashes are not …\n"],["eql?","IPAddr","IPAddr.html#method-i-eql-3F","(other)","<p>Checks equality used by Hash.\n"],["eql?","MatchData","MatchData.html#method-i-eql-3F","(p1)","<p>Equality—Two matchdata are equal if their target strings, patterns, and matched positions are identical. …\n"],["eql?","Matrix","Matrix.html#method-i-eql-3F","(other)",""],["eql?","Method","Method.html#method-i-eql-3F","(p1)","<p>Two method objects are equal if they are bound to the same object and refer to the same method definition …\n"],["eql?","Numeric","Numeric.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> if <code>num</code> and <code>numeric</code> are the same type and have equal values.  Contrast this with Numeric#==, …\n"],["eql?","Object","Object.html#method-i-eql-3F","(p1)","<p>Equality — At the Object level, #== returns <code>true</code> only if <code>obj</code> and <code>other</code> are the same object.  Typically …\n"],["eql?","OpenSSL::BN","OpenSSL/BN.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> only if <em>obj</em> is a <code>OpenSSL::BN</code> with the same value as <em>bn</em>. Contrast this with OpenSSL::BN#==, …\n"],["eql?","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> if the two groups use the same curve and have the same parameters, <code>false</code> otherwise.\n"],["eql?","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-eql-3F","(p1)",""],["eql?","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-eql-3F","(p1)","<p>Returns true if <em>name</em> and <em>other</em> refer to the same hash key.\n"],["eql?","OpenStruct","OpenStruct.html#method-i-eql-3F","(other)","<p>Compares this object and <code>other</code> for equality.  An OpenStruct is eql? to <code>other</code> when <code>other</code> is an OpenStruct …\n"],["eql?","Pathname","Pathname.html#method-i-eql-3F","(p1)","<p>Compare this pathname with <code>other</code>.  The comparison is string-based. Be aware that two different paths …\n"],["eql?","RDoc::TopLevel","RDoc/TopLevel.html#method-i-eql-3F","(other)",""],["eql?","Racc::LocationPointer","Racc/LocationPointer.html#method-i-eql-3F","(ot)",""],["eql?","Racc::State","Racc/State.html#method-i-eql-3F","(oth)",""],["eql?","Range","Range.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> only if <code>obj</code> is a Range, has equivalent begin and end items (by comparing them with <code>eql?</code> …\n"],["eql?","Regexp","Regexp.html#method-i-eql-3F","(p1)","<p>Equality—Two regexps are equal if their patterns are identical, they have the same character set code, …\n"],["eql?","String","String.html#method-i-eql-3F","(p1)","<p>Two strings are equal if they have the same length and content.\n"],["eql?","Struct","Struct.html#method-i-eql-3F","(p1)","<p>Hash equality—<code>other</code> and <code>struct</code> refer to the same hash key if they have the same struct subclass and …\n"],["eql?","Time","Time.html#method-i-eql-3F","(p1)","<p>Returns <code>true</code> if <em>time</em> and <code>other_time</code> are both Time objects with the same seconds and fractional seconds. …\n"],["eql?","URI::Generic","URI/Generic.html#method-i-eql-3F","(oth)",""],["eql?","UnboundMethod","UnboundMethod.html#method-i-eql-3F","(p1)","<p>Two method objects are equal if they are bound to the same object and refer to the same method definition …\n"],["eql?","Vector","Vector.html#method-i-eql-3F","(other)",""],["equal?","BasicObject","BasicObject.html#method-i-equal-3F","(p1)","<p>Equality — At the Object level, #== returns <code>true</code> only if <code>obj</code> and <code>other</code> are the same object.  Typically …\n"],["equal_source?","Bundler::SourceList","Bundler/SourceList.html#method-i-equal_source-3F","(source, other_source)",""],["equal_sources?","Bundler::SourceList","Bundler/SourceList.html#method-i-equal_sources-3F","(lock_sources, replacement_sources)",""],["equality_relational_compare","REXML::XPathParser","REXML/XPathParser.html#method-i-equality_relational_compare","(set1, op, set2)",""],["equivalent_remotes?","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-equivalent_remotes-3F","(other_remotes)",""],["equivalent_rubygems_remotes?","Bundler::Definition","Bundler/Definition.html#method-i-equivalent_rubygems_remotes-3F","(source)",""],["equivalent_rubygems_sources?","Bundler::SourceList","Bundler/SourceList.html#method-i-equivalent_rubygems_sources-3F","(lock_sources, replacement_sources)",""],["equivalent_source?","Bundler::SourceList","Bundler/SourceList.html#method-i-equivalent_source-3F","(source, other_source)",""],["equivalent_sources?","Bundler::SourceList","Bundler/SourceList.html#method-i-equivalent_sources-3F","(lock_sources, replacement_sources)",""],["erase_line","IO","IO.html#method-i-erase_line","(p1)",""],["erase_screen","IO","IO.html#method-i-erase_screen","(p1)",""],["erf","Math","Math.html#method-c-erf","(p1)","<p>Calculates the error function of <code>x</code>.\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (-1, 1)\n"],["erfc","Math","Math.html#method-c-erfc","(p1)","<p>Calculates the complementary error function of x.\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (0, 2)\n"],["errno","SystemCallError","SystemCallError.html#method-i-errno","()","<p>Return this SystemCallError&#39;s error number.\n"],["error","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-error","(statement)","<p>Called if something goes wrong during the execution. This is used by Bundler::Thor internally and should …\n"],["error","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-error","(msg, newline = nil)",""],["error","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-error","(message, newline = nil)",""],["error","Gem::MockGemUi","Gem/MockGemUi.html#method-i-error","()",""],["error","Logger","Logger.html#method-i-error","(progname = nil, &block)","<p>Log an <code>ERROR</code> message.\n<p>See #info for more information.\n"],["error","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-error","()",""],["error","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-error","(msg)","<p>Aborts with <code>msg</code>\n"],["error","RDoc::RDoc","RDoc/RDoc.html#method-i-error","(msg)","<p>Report an error message and exit\n"],["error","RDoc::Servlet","RDoc/Servlet.html#method-i-error","(exception, req, res)","<p>Generates an error page for the <code>exception</code> while handling <code>req</code> on <code>res</code>.\n"],["error","Syslog::Logger","Syslog/Logger.html#method-i-error","","<p>Logs a <code>message</code> at the error (syslog warning) log level, or logs the message returned from the block. …\n"],["error","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-error","(msg)","<p>Shortcut for logging an ERROR message\n"],["error!","Logger","Logger.html#method-i-error-21","()","<p>Sets the severity to ERROR.\n"],["error=","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-error-3D","(p1)",""],["error?","Logger","Logger.html#method-i-error-3F","()","<p>Returns <code>true</code> iff the current severity level allows for the printing of <code>ERROR</code> messages.\n"],["error?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-error-3F","()",""],["error?","Ripper","Ripper.html#method-i-error-3F","()","<p>Return true if parsed source has errors.\n"],["error?","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-error-3F","()","<p>Will the logger output ERROR messages?\n"],["error?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-error-3F","(code)","<p>Is <code>code</code> an error status?\n"],["error?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-i-error-3F","(code)","<p>Is <code>code</code> an error status?\n"],["error_bytes","Encoding::InvalidByteSequenceError","Encoding/InvalidByteSequenceError.html#method-i-error_bytes","()","<p>Returns the discarded bytes when Encoding::InvalidByteSequenceError occurs.\n\n<pre>ec = Encoding::Converter.new(&quot;EUC-JP&quot;, ...</pre>\n"],["error_char","Encoding::UndefinedConversionError","Encoding/UndefinedConversionError.html#method-i-error_char","()","<p>Returns the one-character string which cause Encoding::UndefinedConversionError.\n\n<pre>ec = Encoding::Converter.new(&quot;ISO-8859-1&quot;, ...</pre>\n"],["error_depth","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-error_depth","()",""],["error_message","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-error_message","(connection)","<p>Returns an error message containing the number of requests performed on this connection\n"],["error_message","GetoptLong","GetoptLong.html#method-i-error_message","()","<p>Return the appropriate error message in POSIX-defined format. If no error has occurred, returns nil. …\n"],["error_print","DRb::DRbServer","DRb/DRbServer.html#method-i-error_print","(exception)",""],["error_string","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-error_string","()","<p>Returns the error string corresponding to the error code retrieved by #error.\n"],["errors","Gem::Resolver::ComposedSet","Gem/Resolver/ComposedSet.html#method-i-errors","()",""],["errors","Gem::Resolver::InstallerSet","Gem/Resolver/InstallerSet.html#method-i-errors","()","<p>Errors encountered while resolving gems\n"],["errors","OpenSSL","OpenSSL.html#method-c-errors","()","<p>See any remaining errors held in queue.\n<p>Any errors you see here are probably due to a bug in Ruby&#39;s …\n"],["escape","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-escape","(str)","<p>Bundler::URI::escape wrapper\n"],["escape","Bundler::URI::Escape","Bundler/URI/Escape.html#method-i-escape","(*arg)","<p>Synopsis\n\n<pre>Bundler::URI.escape(str [, unsafe])</pre>\n<p>Args\n"],["escape","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-escape","(str, unsafe = @regexp[:UNSAFE])","<p>Args\n<p><code>str</code> &mdash; String to make safe\n<p><code>unsafe</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["escape","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-escape","(str, unsafe = @regexp[:UNSAFE])","<p>Args\n<p><code>str</code> &mdash; String to make safe\n<p><code>unsafe</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["escape","CGI::Util","CGI/Util.html#method-i-escape","(string)","<p>URL-encode a string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">url_encoded_string</span> = <span class=\"ruby-constant\">CGI</span>.<span class=\"ruby-identifier\">escape</span>(<span class=\"ruby-string\">&quot;&#39;Stop!&#39; said Fred&quot;</span>)\n   <span class=\"ruby-comment\"># =&gt; &quot;%27Stop%21%27+said+Fred&quot;</span>\n</pre>\n"],["escape","Gem::UriFormatter","Gem/UriFormatter.html#method-i-escape","()","<p>Escapes the #uri for use as a CGI parameter\n"],["escape","Regexp","Regexp.html#method-c-escape","(p1)","<p>Escapes any characters that would have special meaning in a regular expression. Returns a new escaped …\n"],["escape","Shellwords","Shellwords.html#method-c-escape","(str)",""],["escape","URI::Escape","URI/Escape.html#method-i-escape","(*arg)","<p>Synopsis\n\n<pre>URI.escape(str [, unsafe])</pre>\n<p>Args\n"],["escape","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-escape","(str, unsafe = @regexp[:UNSAFE])","<p>Args\n<p><code>str</code> &mdash; String to make safe\n<p><code>unsafe</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["escape","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-escape","(str, unsafe = @regexp[:UNSAFE])","<p>Args\n<p><code>str</code> &mdash; String to make safe\n<p><code>unsafe</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["escape","WEBrick::AccessLog","WEBrick/AccessLog.html#method-i-escape","(data)","<p>Escapes control characters in <code>data</code>\n"],["escape","WEBrick::HTMLUtils","WEBrick/HTMLUtils.html#method-i-escape","(string)","<p>Escapes &amp;, “, &gt; and &lt; in <code>string</code>\n"],["escape","WEBrick::HTMLUtils","WEBrick/HTMLUtils.html#method-c-escape","(string)","<p>Escapes &amp;, “, &gt; and &lt; in <code>string</code>\n"],["escape","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-escape","(str)","<p>Escapes HTTP reserved and unwise characters in <code>str</code>\n"],["escape8bit","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-escape8bit","(str)","<p>Escapes 8 bit characters in <code>str</code>\n"],["escapeElement","CGI::Util","CGI/Util.html#method-i-escapeElement","(string, *elements)","<p>Escape only the tags of certain HTML elements in <code>string</code>.\n<p>Takes an element or elements or array of elements. …\n"],["escapeHTML","CGI::Util","CGI/Util.html#method-i-escapeHTML","(string)","<p>Escape special characters in HTML, namely &#39;&amp;&quot;&lt;&gt;\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">CGI</span>.<span class=\"ruby-identifier\">escapeHTML</span>(<span class=\"ruby-string\">&#39;Usage: foo &quot;bar&quot; &lt;baz&gt;&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["escape_element","CGI::Util","CGI/Util.html#method-i-escape_element","(string, *elements)","<p>Synonym for CGI.escapeElement(str)\n"],["escape_form","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-escape_form","(str)","<p>Escapes form reserved characters in <code>str</code>\n"],["escape_globs","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-escape_globs","(path)","<p>Returns a string that has had any glob characters escaped. The glob characters are `* ? { } [ ]`.\n<p>Examples …\n"],["escape_html","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-escape_html","(string)","<p>Returns a string that has had any HTML characters escaped.\n<p>Examples\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Thor</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Util</span>.<span class=\"ruby-identifier\">escape_html</span>(<span class=\"ruby-string\">&#39;&lt;div&gt;&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["escape_html","CGI::Util","CGI/Util.html#method-i-escape_html","(string)","<p>Synonym for CGI.escapeHTML(str)\n"],["escape_path","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-escape_path","(str)","<p>Escapes path <code>str</code>\n"],["escape_userpass","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-escape_userpass","(v)","<p>Escapes &#39;user:password&#39; <code>v</code> based on RFC 1738 section 3.1.\n"],["escape_userpass","URI::Generic","URI/Generic.html#method-i-escape_userpass","(v)","<p>Escapes &#39;user:password&#39; <code>v</code> based on RFC 1738 section 3.1.\n"],["etag_for","Bundler::CompactIndexClient::Updater","Bundler/CompactIndexClient/Updater.html#method-i-etag_for","(path)",""],["euid","Process","Process.html#method-c-euid","()","<p>Returns the effective user ID for this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">euid</span>   <span class=\"ruby-comment\">#=&gt; 501</span>\n</pre>\n"],["euid=","Process","Process.html#method-c-euid-3D","(p1)","<p>Sets the effective user ID for this process. Not available on all platforms.\n"],["eval","Binding","Binding.html#method-i-eval","(p1, p2 = v2, p3 = v3)","<p>Evaluates the Ruby expression(s) in <em>string</em>, in the <em>binding</em>&#39;s context.  If the optional <em>filename</em> and …\n"],["eval","Kernel","Kernel.html#method-i-eval","(p1, p2 = v2, p3 = v3, p4 = v4)","<p>Evaluates the Ruby expression(s) in <em>string</em>. If <em>binding</em> is given, which must be a Binding object, the …\n"],["eval","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-eval","()","<p>Evaluates the instruction sequence and returns the result.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">RubyVM</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">InstructionSequence</span>.<span class=\"ruby-identifier\">compile</span>(<span class=\"ruby-string\">&quot;1 + 2&quot;</span>).<span class=\"ruby-identifier\">eval</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["eval_gemfile","Bundler::Dsl","Bundler/Dsl.html#method-i-eval_gemfile","(gemfile, contents = nil)",""],["eval_gemspec","Bundler","Bundler.html#method-c-eval_gemspec","(path, contents)",""],["eval_history=","IRB::Context","IRB/Context.html#method-i-eval_history-3D","(no)","<p>Sets command result history limit. Default value is set from <code>IRB.conf[:EVAL_HISTORY]</code>.\n<p><code>no</code> is an Integer …\n"],["eval_input","IRB::Irb","IRB/Irb.html#method-i-eval_input","()","<p>Evaluates input for this session.\n"],["eval_script","TracePoint","TracePoint.html#method-i-eval_script","()","<p>Compiled source code (String) on *eval methods on the <code>:script_compiled</code> event. If loaded from a file, …\n"],["eval_yaml_gemspec","Bundler","Bundler.html#method-c-eval_yaml_gemspec","(path, contents)",""],["evaluate","Bundler::Dsl","Bundler/Dsl.html#method-c-evaluate","(gemfile, lockfile, unlock)",""],["evaluate","IRB::WorkSpace","IRB/WorkSpace.html#method-i-evaluate","(context, statements, file = nil, line = nil)","<p>Evaluate the context of this workspace and use the Tracer library to output the exact lines of code are …\n"],["evaluate","WEBrick::HTTPServlet::ERBHandler","WEBrick/HTTPServlet/ERBHandler.html#method-i-evaluate","(erb, servlet_request, servlet_response)","<p>Evaluates <code>erb</code> providing <code>servlet_request</code> and <code>servlet_response</code> as local variables.\n"],["evaluate_predicate","REXML::XPathParser","REXML/XPathParser.html#method-i-evaluate_predicate","(expression, nodesets)",""],["even?","Integer","Integer.html#method-i-even-3F","()","<p>Returns <code>true</code> if <code>int</code> is an even number.\n"],["event","TracePoint","TracePoint.html#method-i-event","()","<p>Type of event\n<p>See TracePoint@Events for more information.\n"],["event?","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-event-3F","()","<p>Returns true if the method is event.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbook&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["event_interface","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-event_interface","()","<p>Returns event interface name if the method is event.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object ...</pre>\n"],["event_location","Psych::Handler","Psych/Handler.html#method-i-event_location","(start_line, start_column, end_line, end_column)","<p>Called before each event with line/column information.\n"],["event_location","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-event_location","(start_line, start_column, end_line, end_column)",""],["event_type","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-event_type","()",""],["exact?","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-exact-3F","()",""],["exact?","Gem::Requirement","Gem/Requirement.html#method-i-exact-3F","()","<p>true if the requirement is for only an exact version\n"],["examine","Net::IMAP","Net/IMAP.html#method-i-examine","(mailbox)","<p>Sends a EXAMINE command to select a <code>mailbox</code> so that messages in the <code>mailbox</code> can be accessed.  Behaves …\n"],["exception","DRb::DRbUnknown","DRb/DRbUnknown.html#method-i-exception","()","<p>Create a DRbUnknownError exception containing this object.\n"],["exception","Exception","Exception.html#method-i-exception","(*args)","<p>With no argument, or if the argument is the same as the receiver, return the receiver. Otherwise, create …\n"],["exception","Exception","Exception.html#method-c-exception","(*args)","<p>With no argument, or if the argument is the same as the receiver, return the receiver. Otherwise, create …\n"],["exception","Timeout::Error","Timeout/Error.html#method-i-exception","(*)",""],["exception","Timeout::Error","Timeout/Error.html#method-i-exception","(*)",""],["exception","Timeout::Error","Timeout/Error.html#method-i-exception","(*)",""],["exception_class","Net::SMTP::Response","Net/SMTP/Response.html#method-i-exception_class","()","<p>Determines whether there was an error and raises the appropriate error based on the reply code of the …\n"],["exclude","RDoc::Options","RDoc/Options.html#method-i-exclude","()","<p>Create a regexp for #exclude\n"],["exclude_end?","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-exclude_end-3F","()",""],["exclude_end?","Range","Range.html#method-i-exclude_end-3F","()","<p>Returns <code>true</code> if the range excludes its end value.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">5</span>).<span class=\"ruby-identifier\">exclude_end?</span>     <span class=\"ruby-comment\">#=&gt; false</span>\n(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">...</span><span class=\"ruby-value\">5</span>).<span class=\"ruby-identifier\">exclude_end?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["exclusive","Thread","Thread.html#method-c-exclusive","(&block)","<p>Wraps the block in a single, VM-global Mutex.synchronize, returning the value of the block. A thread …\n"],["exec","Bundler::CLI","Bundler/CLI.html#method-i-exec","(*args)",""],["exec","Kernel","Kernel.html#method-i-exec","(*args)","<p>Replaces the current process by running the given external <em>command</em>, which can take one of the following …\n"],["exec","Process","Process.html#method-c-exec","(*args)","<p>Replaces the current process by running the given external <em>command</em>, which can take one of the following …\n"],["exec_command","Bundler::Plugin","Bundler/Plugin.html#method-i-exec_command","(command, args)","<p>To be called from Cli class to pass the command and argument to approriate plugin class\n"],["exec_format","Gem::Installer","Gem/Installer.html#method-c-exec_format","()","<p>Defaults to use Ruby&#39;s program prefix and suffix.\n"],["exec_if","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-exec_if","()","<p>Execute the given block if notifications are enabled.\n"],["executable","Gem::Specification","Gem/Specification.html#method-i-executable","()","<p>Singular accessor for #executables\n"],["executable=","Gem::Specification","Gem/Specification.html#method-i-executable-3D","(o)","<p>Singular accessor for #executables\n"],["executable?","File","File.html#method-c-executable-3F","(p1)","<p>Returns <code>true</code> if the named file is executable by the effective user and group id of this process. See …\n"],["executable?","File::Stat","File/Stat.html#method-i-executable-3F","()","<p>Returns <code>true</code> if <em>stat</em> is executable or if the operating system doesn&#39;t distinguish executable files …\n"],["executable?","FileTest","FileTest.html#method-i-executable-3F","(p1)","<p>Returns <code>true</code> if the named file is executable by the effective user and group id of this process. See …\n"],["executable?","Pathname","Pathname.html#method-i-executable-3F","()","<p>See FileTest.executable?.\n"],["executable_real?","File","File.html#method-c-executable_real-3F","(p1)","<p>Returns <code>true</code> if the named file is executable by the real user and group id of this process. See access(3). …\n"],["executable_real?","File::Stat","File/Stat.html#method-i-executable_real-3F","()","<p>Same as <code>executable?</code>, but tests using the real owner of the process.\n"],["executable_real?","FileTest","FileTest.html#method-i-executable_real-3F","(p1)","<p>Returns <code>true</code> if the named file is executable by the real user and group id of this process. See access(3). …\n"],["executable_real?","Pathname","Pathname.html#method-i-executable_real-3F","()","<p>See FileTest.executable_real?.\n"],["executables","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-executables","()","<p>needed for binstubs\n"],["executables","Gem::Specification","Gem/Specification.html#method-i-executables","()","<p>Executables included in the gem.\n<p>For example, the rake gem has rake as an executable. You don’t specify …\n"],["executables=","Gem::Specification","Gem/Specification.html#method-i-executables-3D","(value)","<p>Sets executables to <code>value</code>, ensuring it is an array. Don&#39;t use this, push onto the array instead. …\n"],["execute","Gem::Command","Gem/Command.html#method-i-execute","()","<p>Override to provide command handling.\n<p>#options will be filled in with your parsed options, unparsed options …\n"],["execute","Gem::Commands::BuildCommand","Gem/Commands/BuildCommand.html#method-i-execute","()",""],["execute","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-execute","()",""],["execute","Gem::Commands::CheckCommand","Gem/Commands/CheckCommand.html#method-i-execute","()",""],["execute","Gem::Commands::CleanupCommand","Gem/Commands/CleanupCommand.html#method-i-execute","()",""],["execute","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-execute","()",""],["execute","Gem::Commands::DependencyCommand","Gem/Commands/DependencyCommand.html#method-i-execute","()",""],["execute","Gem::Commands::EnvironmentCommand","Gem/Commands/EnvironmentCommand.html#method-i-execute","()",""],["execute","Gem::Commands::FetchCommand","Gem/Commands/FetchCommand.html#method-i-execute","()",""],["execute","Gem::Commands::GenerateIndexCommand","Gem/Commands/GenerateIndexCommand.html#method-i-execute","()",""],["execute","Gem::Commands::HelpCommand","Gem/Commands/HelpCommand.html#method-i-execute","()",""],["execute","Gem::Commands::InstallCommand","Gem/Commands/InstallCommand.html#method-i-execute","()",""],["execute","Gem::Commands::LockCommand","Gem/Commands/LockCommand.html#method-i-execute","()",""],["execute","Gem::Commands::MirrorCommand","Gem/Commands/MirrorCommand.html#method-i-execute","()",""],["execute","Gem::Commands::OpenCommand","Gem/Commands/OpenCommand.html#method-i-execute","()",""],["execute","Gem::Commands::OutdatedCommand","Gem/Commands/OutdatedCommand.html#method-i-execute","()",""],["execute","Gem::Commands::OwnerCommand","Gem/Commands/OwnerCommand.html#method-i-execute","()",""],["execute","Gem::Commands::PristineCommand","Gem/Commands/PristineCommand.html#method-i-execute","()",""],["execute","Gem::Commands::PushCommand","Gem/Commands/PushCommand.html#method-i-execute","()",""],["execute","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-execute","()",""],["execute","Gem::Commands::RdocCommand","Gem/Commands/RdocCommand.html#method-i-execute","()",""],["execute","Gem::Commands::ServerCommand","Gem/Commands/ServerCommand.html#method-i-execute","()",""],["execute","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-execute","()",""],["execute","Gem::Commands::SigninCommand","Gem/Commands/SigninCommand.html#method-i-execute","()",""],["execute","Gem::Commands::SignoutCommand","Gem/Commands/SignoutCommand.html#method-i-execute","()",""],["execute","Gem::Commands::SourcesCommand","Gem/Commands/SourcesCommand.html#method-i-execute","()",""],["execute","Gem::Commands::SpecificationCommand","Gem/Commands/SpecificationCommand.html#method-i-execute","()",""],["execute","Gem::Commands::StaleCommand","Gem/Commands/StaleCommand.html#method-i-execute","()",""],["execute","Gem::Commands::UninstallCommand","Gem/Commands/UninstallCommand.html#method-i-execute","()",""],["execute","Gem::Commands::UnpackCommand","Gem/Commands/UnpackCommand.html#method-i-execute","()",""],["execute","Gem::Commands::UpdateCommand","Gem/Commands/UpdateCommand.html#method-i-execute","()",""],["execute","Gem::Commands::WhichCommand","Gem/Commands/WhichCommand.html#method-i-execute","()",""],["execute","Gem::Commands::YankCommand","Gem/Commands/YankCommand.html#method-i-execute","()",""],["execution_mode","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-execution_mode","()","<p>@return [Lambda] A lambda that takes an array of inputs and a block, and\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">maps</span> <span class=\"ruby-identifier\">the</span> <span class=\"ruby-identifier\">inputs</span> <span class=\"ruby-identifier\">with</span> <span class=\"ruby-identifier\">the</span> <span class=\"ruby-identifier\">block</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["execution_mode=","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-execution_mode-3D","(block)",""],["exeext","Gem::TestCase","Gem/TestCase.html#method-i-exeext","(value)","<p>Sets the EXEEXT entry in RbConfig::CONFIG to <code>value</code> and restores the original value when the block ends …\n"],["exist?","Dir","Dir.html#method-c-exist-3F","(p1)","<p>Returns <code>true</code> if the named file is a directory, <code>false</code> otherwise.\n"],["exist?","File","File.html#method-c-exist-3F","(p1)","<p>Return <code>true</code> if the named file exists.\n<p><em>file_name</em> can be an IO object.\n<p>“file exists” means that …\n"],["exist?","FileTest","FileTest.html#method-i-exist-3F","(p1)","<p>Return <code>true</code> if the named file exists.\n<p><em>file_name</em> can be an IO object.\n<p>“file exists” means that …\n"],["exist?","Pathname","Pathname.html#method-i-exist-3F","()","<p>See FileTest.exist?.\n"],["exist?","StringScanner","StringScanner.html#method-i-exist-3F","(p1)","<p>Looks <em>ahead</em> to see if the <code>pattern</code> exists <em>anywhere</em> in the string, without advancing the scan pointer. …\n"],["exists?","Dir","Dir.html#method-c-exists-3F","(p1)","<p>Deprecated method. Don&#39;t use.\n"],["exists?","File","File.html#method-c-exists-3F","(p1)","<p>Deprecated method. Don&#39;t use.\n"],["exists?","FileTest","FileTest.html#method-i-exists-3F","(p1)","<p>Deprecated method. Don&#39;t use.\n"],["exit","IRB::Context","IRB/Context.html#method-i-exit","(ret = 0)","<p>Exits the current session, see IRB.irb_exit\n"],["exit","Kernel","Kernel.html#method-i-exit","(*args)","<p>Initiates the termination of the Ruby script by raising the SystemExit exception. This exception may …\n"],["exit","Monitor","Monitor.html#method-i-exit","()",""],["exit","Process","Process.html#method-c-exit","(*args)","<p>Initiates the termination of the Ruby script by raising the SystemExit exception. This exception may …\n"],["exit","Thread","Thread.html#method-i-exit","()","<p>Terminates <code>thr</code> and schedules another thread to be run, returning the terminated Thread.  If this is the …\n"],["exit","Thread","Thread.html#method-c-exit","()","<p>Terminates the currently running thread and schedules another thread to be run.\n<p>If this thread is already …\n"],["exit!","Kernel","Kernel.html#method-i-exit-21","(*args)","<p>Exits the process immediately. No exit handlers are run. <em>status</em> is returned to the underlying system …\n"],["exit!","Process","Process.html#method-c-exit-21","(*args)","<p>Exits the process immediately. No exit handlers are run. <em>status</em> is returned to the underlying system …\n"],["exit_on_failure?","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-exit_on_failure-3F","()","<p>A flag that makes the process exit with status 1 if any error happens.\n"],["exit_status","Bundler::FriendlyErrors","Bundler/FriendlyErrors.html#method-i-exit_status","(error)",""],["exit_value","LocalJumpError","LocalJumpError.html#method-i-exit_value","()","<p>Returns the exit value associated with this <code>LocalJumpError</code>.\n"],["exited?","Process::Status","Process/Status.html#method-i-exited-3F","()","<p>Returns <code>true</code> if <em>stat</em> exited normally (for example using an <code>exit()</code> call or finishing the program).\n"],["exitstatus","Process::Status","Process/Status.html#method-i-exitstatus","()","<p>Returns the least significant eight bits of the return code of <em>stat</em>. Only available if #exited? is <code>true</code> …\n"],["exp","BigMath","BigMath.html#method-c-exp","(p1, p2)","<p>Computes the value of e (the base of natural logarithms) raised to the power of <code>decimal</code>, to the specified …\n"],["exp","Math","Math.html#method-c-exp","(p1)","<p>Returns e**x.\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (0, INFINITY)\n"],["expand","Bundler::Source::Path","Bundler/Source/Path.html#method-i-expand","(somepath)",""],["expand","Gem::PathSupport","Gem/PathSupport.html#method-i-expand","(path)",""],["expand","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-expand","( path )",""],["expand","REXML::Text","REXML/Text.html#method-c-expand","(ref, doctype, filter)",""],["expand_dependencies","Bundler::Definition","Bundler/Definition.html#method-i-expand_dependencies","(dependencies, remote = false)",""],["expand_hexstring","OpenSSL::X509::Name::RFC2253DN","OpenSSL/X509/Name/RFC2253DN.html#method-i-expand_hexstring","(str)",""],["expand_pair","OpenSSL::X509::Name::RFC2253DN","OpenSSL/X509/Name/RFC2253DN.html#method-i-expand_pair","(str)",""],["expand_path","File","File.html#method-c-expand_path","(*args)","<p>Converts a pathname to an absolute pathname. Relative paths are referenced from the current working directory …\n"],["expand_path","Pathname","Pathname.html#method-i-expand_path","(p1 = v1)","<p>Returns the absolute path for the file.\n<p>See File.expand_path.\n"],["expand_ref_in","REXML::Validation::State","REXML/Validation/State.html#method-i-expand_ref_in","( arry, ind )",""],["expand_tabs","RDoc::Text","RDoc/Text.html#method-i-expand_tabs","(text)","<p>Expands tab characters in <code>text</code> to eight spaces\n"],["expand_value","OpenSSL::X509::Name::RFC2253DN","OpenSSL/X509/Name/RFC2253DN.html#method-i-expand_value","(str1, str2, str3)",""],["expanded_dependencies","Bundler::Definition","Bundler/Definition.html#method-i-expanded_dependencies","()","<p>This list of dependencies is only used in #resolve, so it&#39;s OK to add the metadata dependencies here …\n"],["expanded_name","REXML::Document","REXML/Document.html#method-i-expanded_name","()","<p>According to the XML spec, a root node has no expanded name\n"],["expanded_original_path","Bundler::Source::Path","Bundler/Source/Path.html#method-i-expanded_original_path","()",""],["expanded_path","Bundler::Source::Path","Bundler/Source/Path.html#method-i-expanded_path","()",""],["expanded_platforms","Bundler::Dependency","Bundler/Dependency.html#method-i-expanded_platforms","()",""],["expect","IO","IO.html#method-i-expect","(pat,timeout=9999999)","<p>Reads from the IO until the given <code>pattern</code> matches or the <code>timeout</code> is over.\n<p>It returns an array with the …\n"],["expected","REXML::Validation::Choice","REXML/Validation/Choice.html#method-i-expected","()",""],["expected","REXML::Validation::Interleave","REXML/Validation/Interleave.html#method-i-expected","()",""],["expected","REXML::Validation::OneOrMore","REXML/Validation/OneOrMore.html#method-i-expected","()",""],["expected","REXML::Validation::Optional","REXML/Validation/Optional.html#method-i-expected","()",""],["expected","REXML::Validation::State","REXML/Validation/State.html#method-i-expected","()",""],["expected","REXML::Validation::ZeroOrMore","REXML/Validation/ZeroOrMore.html#method-i-expected","()",""],["expired?","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-expired-3F","(connection)","<p>Returns true if the connection should be reset due to an idle timeout, or maximum request count, false …\n"],["expired?","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-expired-3F","()","<p>Has this tuple expired? (true/false).\n<p>A tuple has expired when its expiry timer based on the <code>sec</code> argument …\n"],["expires","WEBrick::Cookie","WEBrick/Cookie.html#method-i-expires","()","<p>Retrieves the expiration time as a Time\n"],["expires=","WEBrick::Cookie","WEBrick/Cookie.html#method-i-expires-3D","(t)","<p>Sets the cookie expiration to the time <code>t</code>.  The expiration time may be a false value to disable expiration …\n"],["explain","Gem::Resolver::Conflict","Gem/Resolver/Conflict.html#method-i-explain","()","<p>A string explanation of the conflict.\n"],["explanation","Gem::Resolver::Conflict","Gem/Resolver/Conflict.html#method-i-explanation","()","<p>Explanation of the conflict used by exceptions to print useful messages\n"],["explicit?","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-explicit-3F","()","<p>Indicate that the request is for a gem explicitly requested by the user\n"],["explicit_clean_other_attr_reader","RSS::BaseModel","RSS/BaseModel.html#method-i-explicit_clean_other_attr_reader","(*attrs)",""],["explicit_clean_other_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-explicit_clean_other_writer","(name, disp_name=name)",""],["explicit_scope?","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-explicit_scope-3F","()",""],["exponent","BigDecimal","BigDecimal.html#method-i-exponent","()","<p>Returns the exponent of the BigDecimal number, as an Integer.\n<p>If the number can be represented as 0.xxxxxx …\n"],["export","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-export","()","<p>Encodes this DH to its PEM encoding. Note that any existing per-session public/private keys will <strong>not</strong> …\n"],["export","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-export","(p1 = v1, p2 = v2)","<p>Encodes this DSA to its PEM encoding.\n<p>Parameters\n<p><em>cipher</em> is an OpenSSL::Cipher.\n"],["export","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-export","(p1 = v1, p2 = v2)","<p>Outputs the EC key in PEM encoding.  If <em>cipher</em> and <em>pass_phrase</em> are given they will be used to encrypt …\n"],["export","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-export","(p1 = v1, p2 = v2)","<p>Outputs this keypair in PEM encoding.  If <em>cipher</em> and <em>pass_phrase</em> are given they will be used to encrypt …\n"],["expr","REXML::XPathParser","REXML/XPathParser.html#method-i-expr","( path_stack, nodeset, context=nil )","<p>Expr takes a stack of path elements and a set of nodes (either a Parent or an Array and returns an Array …\n"],["expunge","Net::IMAP","Net/IMAP.html#method-i-expunge","()","<p>Sends a EXPUNGE command to permanently remove from the currently selected mailbox all messages that have …\n"],["ext_lock","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-ext_lock","()",""],["extend","Object","Object.html#method-i-extend","(*args)","<p>Adds to <em>obj</em> the instance methods from each module given as a parameter.\n\n<pre>module Mod\n  def hello\n    &quot;Hello ...</pre>\n"],["extend_object","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-c-extend_object","(obj)","<p>Installs alias methods for the default irb commands on the given object using #install_alias_method. …\n"],["extend_object","Module","Module.html#method-i-extend_object","(p1)","<p>Extends the specified object by adding this module&#39;s constants and methods (which are added as singleton …\n"],["extend_object","MonitorMixin","MonitorMixin.html#method-c-extend_object","(obj)",""],["extend_object","OptionParser::Arguable","OptionParser/Arguable.html#method-c-extend_object","(obj)","<p>Initializes instance variable.\n"],["extended","Module","Module.html#method-i-extended","(p1)","<p>The equivalent of <code>included</code>, but for extended modules.\n\n<pre>module A\n  def self.extended(mod)\n    puts &quot;#{self} ...</pre>\n"],["extension","RDoc::Markdown","RDoc/Markdown.html#method-c-extension","(name)","<p>Creates extension methods for the <code>name</code> extension to enable and disable\nthe extension and to query if ...\n"],["extension","RDoc::Markdown","RDoc/Markdown.html#method-i-extension","(name, enable)","<p>Enables or disables the extension with <code>name</code>\n"],["extension?","RDoc::Markdown","RDoc/Markdown.html#method-i-extension-3F","(name)","<p>Is the extension <code>name</code> enabled?\n"],["extension_cache_path","Bundler::Source","Bundler/Source.html#method-i-extension_cache_path","(spec)",""],["extension_cache_slug","Bundler::Source","Bundler/Source.html#method-i-extension_cache_slug","(_)",""],["extension_cache_slug","Bundler::Source::Git","Bundler/Source/Git.html#method-i-extension_cache_slug","(_)",""],["extension_cache_slug","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-extension_cache_slug","(spec)",""],["extension_dir","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-extension_dir","()","<p>Returns full path to the directory where gem&#39;s extensions are installed.\n"],["extension_dir","Gem::Specification","Gem/Specification.html#method-i-extension_dir","()",""],["extension_dir_name","Bundler::Source::Git","Bundler/Source/Git.html#method-i-extension_dir_name","()",""],["extensions","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-extensions","()","<p>needed for “with native extensions” during install\n"],["extensions","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-extensions","()","<p>Returns extensions.\n"],["extensions","Gem::Specification","Gem/Specification.html#method-i-extensions","()","<p>Extensions to build when installing the gem, specifically the paths to extconf.rb-style files used to …\n"],["extensions","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-extensions","()",""],["extensions","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-extensions","()","<p>Gets X509v3 extensions as array of X509Ext objects\n"],["extensions","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-extensions","()",""],["extensions","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-extensions","()","<p>Gets X509v3 extensions as array of X509Ext objects\n"],["extensions","URI::LDAP","URI/LDAP.html#method-i-extensions","()","<p>Returns extensions.\n"],["extensions=","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-extensions-3D","(val)","<p>Setter for extensions <code>val</code>.\n"],["extensions=","Gem::Specification","Gem/Specification.html#method-i-extensions-3D","(extensions)","<p>Sets extensions to <code>extensions</code>, ensuring it is an array. Don&#39;t use this, push onto the array instead. …\n"],["extensions=","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-extensions-3D","(p1)","<p>Sets X509_EXTENSIONs\n"],["extensions=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-extensions-3D","(p1)",""],["extensions=","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-extensions-3D","(p1)","<p>Sets X509_EXTENSIONs\n"],["extensions=","URI::LDAP","URI/LDAP.html#method-i-extensions-3D","(val)","<p>Setter for extensions <code>val</code>.\n"],["extensions_dir","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-extensions_dir","()","<p>Returns path to the extensions directory.\n"],["extern","Fiddle::Importer","Fiddle/Importer.html#method-i-extern","(signature, *opts)","<p>Creates a global method from the given C <code>signature</code>.\n"],["external_encoding","ARGF","ARGF.html#method-i-external_encoding","()","<p>Returns the external encoding for files read from <code>ARGF</code> as an <code>Encoding</code> object. The external encoding is …\n"],["external_encoding","IO","IO.html#method-i-external_encoding","()","<p>Returns the Encoding object that represents the encoding of the file. If <em>io</em> is in write mode and no encoding …\n"],["external_encoding","StringIO","StringIO.html#method-i-external_encoding","()","<p>Returns the Encoding object that represents the encoding of the file. If the stream is write mode and …\n"],["external_encoding","Zlib::GzipReader","Zlib/GzipReader.html#method-i-external_encoding","()","<p>See Zlib::GzipReader documentation for a description.\n"],["extname","File","File.html#method-c-extname","(p1)","<p>Returns the extension (the portion of file name in <code>path</code> starting from the last period).\n<p>If <code>path</code> is a dotfile, …\n"],["extname","Pathname","Pathname.html#method-i-extname","()","<p>Returns the file&#39;s extension.\n<p>See File.extname.\n"],["extra_args","Gem::Command","Gem/Command.html#method-c-extra_args","()",""],["extra_args=","Gem::Command","Gem/Command.html#method-c-extra_args-3D","(value)",""],["extra_rdoc_files","Gem::Specification","Gem/Specification.html#method-i-extra_rdoc_files","()","<p>Extra files to add to RDoc such as README or doc/examples.txt\n<p>When the user elects to generate the RDoc …\n"],["extra_rdoc_files=","Gem::Specification","Gem/Specification.html#method-i-extra_rdoc_files-3D","(files)","<p>Sets extra_rdoc_files to <code>files</code>, ensuring it is an array. Don&#39;t use this, push onto the array instead. …\n"],["extract","Bundler::URI","Bundler/URI.html#method-c-extract","(str, schemes = nil, &block)","<p>Synopsis\n\n<pre>Bundler::URI::extract(str[, schemes][,&amp;blk])</pre>\n<p>Args\n"],["extract","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-extract","(str, schemes = nil)","<p>Args\n<p><code>str</code> &mdash; String to search\n<p><code>schemes</code> &mdash; Patterns to apply to <code>str</code>\n"],["extract","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-extract","(str, schemes = nil)","<p>Args\n<p><code>str</code> &mdash; String to search\n<p><code>schemes</code> &mdash; Patterns to apply to <code>str</code>\n"],["extract","URI","URI.html#method-c-extract","(str, schemes = nil, &block)","<p>Synopsis\n\n<pre>URI::extract(str[, schemes][,&amp;blk])</pre>\n<p>Args\n"],["extract","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-extract","(str, schemes = nil)","<p>Args\n<p><code>str</code> &mdash; String to search\n<p><code>schemes</code> &mdash; Patterns to apply to <code>str</code>\n"],["extract","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-extract","(str, schemes = nil)","<p>Args\n<p><code>str</code> &mdash; String to search\n<p><code>schemes</code> &mdash; Patterns to apply to <code>str</code>\n"],["extract_bin","Gem::Installer","Gem/Installer.html#method-i-extract_bin","()","<p>Extracts only the bin/ files from the gem into the gem directory. This is used by default gems to allow …\n"],["extract_call_seq","RDoc::Comment","RDoc/Comment.html#method-i-extract_call_seq","(method)","<p>Look for a &#39;call-seq&#39; in the comment to override the normal parameter handling.  The :call-seq: …\n"],["extract_circular_gems","Bundler::SpecSet","Bundler/SpecSet.html#method-i-extract_circular_gems","(error)",""],["extract_files","Gem::Installer","Gem/Installer.html#method-i-extract_files","()","<p>Reads the file index and extracts each file into the gem directory.\n<p>Ensures that files can&#39;t be installed …\n"],["extract_files","Gem::Installer::FakePackage","Gem/Installer/FakePackage.html#method-i-extract_files","(destination_dir, pattern = '*')",""],["extract_files","Gem::Package","Gem/Package.html#method-i-extract_files","(destination_dir, pattern = \"*\")","<p>Extracts the files in this package into <code>destination_dir</code>\n<p>If <code>pattern</code> is specified, only entries matching …\n"],["extract_files","Gem::Package::Old","Gem/Package/Old.html#method-i-extract_files","(destination_dir)","<p>Extracts the files in this package into <code>destination_dir</code>\n"],["extract_gem_info","Bundler::Definition","Bundler/Definition.html#method-i-extract_gem_info","(error)",""],["extract_reference","OpenSSL::Config","OpenSSL/Config.html#method-c-extract_reference","(value)",""],["facility","Syslog","Syslog.html#method-c-facility","()","<p>Returns the facility number used in the last call to open()\n"],["fail","Kernel","Kernel.html#method-i-fail","(*args)","<p>With no arguments, raises the exception in <code>$!</code> or raises a RuntimeError if <code>$!</code> is <code>nil</code>.  With a single  …\n"],["fail!","Bundler::Settings::Validator::Rule","Bundler/Settings/Validator/Rule.html#method-i-fail-21","(key, value, *reasons)",""],["fail_attempt","Bundler::Retry","Bundler/Retry.html#method-i-fail_attempt","(e)",""],["failed?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-failed-3F","()",""],["failure_message","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-failure_message","()",""],["fallback_timeout=","Bundler::Settings::Mirror","Bundler/Settings/Mirror.html#method-i-fallback_timeout-3D","(timeout)",""],["false","REXML::Functions","REXML/Functions.html#method-c-false","( )","<p>UNTESTED\n"],["family","Socket::AncillaryData","Socket/AncillaryData.html#method-i-family","()","<p>returns the socket family as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AncillaryData</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:PKTINFO</span>, <span class=\"ruby-string\">&quot;&quot;</span>).<span class=\"ruby-identifier\">family</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["family","Socket::Option","Socket/Option.html#method-i-family","()","<p>returns the socket family as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:RECVPKTINFO</span>, [<span class=\"ruby-value\">1</span>].<span class=\"ruby-identifier\">pack</span>(<span class=\"ruby-string\">&quot;i!&quot;</span>)).<span class=\"ruby-identifier\">family</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["family_addrinfo","Addrinfo","Addrinfo.html#method-i-family_addrinfo","(*args)","<p>creates an Addrinfo object from the arguments.\n<p>The arguments are interpreted as similar to self.\n\n<pre>Addrinfo.tcp(&quot;0.0.0.0&quot;, ...</pre>\n"],["fast_generate","JSON","JSON.html#method-i-fast_generate","(obj, opts = nil)","<p>Generate a JSON document from the Ruby data structure <em>obj</em> and return it. This method disables the checks …\n"],["fastmode=","GDBM","GDBM.html#method-i-fastmode-3D","(p1)","<p>Turns the database&#39;s fast mode on or off. If fast mode is turned on, gdbm does not wait for writes …\n"],["fatal","Logger","Logger.html#method-i-fatal","(progname = nil, &block)","<p>Log a <code>FATAL</code> message.\n<p>See #info for more information.\n"],["fatal","Syslog::Logger","Syslog/Logger.html#method-i-fatal","","<p>Logs a <code>message</code> at the fatal (syslog err) log level, or logs the message returned from the block.\n"],["fatal","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-fatal","(msg)","<p>Shortcut for logging a FATAL message\n"],["fatal!","Logger","Logger.html#method-i-fatal-21","()","<p>Sets the severity to FATAL.\n"],["fatal?","Logger","Logger.html#method-i-fatal-3F","()","<p>Returns <code>true</code> iff the current severity level allows for the printing of <code>FATAL</code> messages.\n"],["fatal?","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-fatal-3F","()","<p>Will the logger output FATAL messages?\n"],["fcntl","IO","IO.html#method-i-fcntl","(p1, p2 = v2)","<p>Provides a mechanism for issuing low-level commands to control or query file-oriented I/O streams. Arguments …\n"],["fcntl","OpenSSL::SSL::SocketForwarder","OpenSSL/SSL/SocketForwarder.html#method-i-fcntl","(*args)",""],["fcntl","StringIO","StringIO.html#method-i-fcntl","(*args)","<p>Raises NotImplementedError.\n"],["fdatasync","IO","IO.html#method-i-fdatasync","()","<p>Immediately writes all buffered data in <em>ios</em> to disk.\n<p>If the underlying operating system does not support …\n"],["fdiv","Complex","Complex.html#method-i-fdiv","(p1)","<p>Performs division as each part is a float, never returns a float.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">11</span>, <span class=\"ruby-value\">22</span>).<span class=\"ruby-identifier\">fdiv</span>(<span class=\"ruby-value\">3</span>)  <span class=\"ruby-comment\">#=&gt; (3.6666666666666665+7.333333333333333i)</span>\n</pre>\n"],["fdiv","Float","Float.html#method-i-fdiv","(p1)","<p>Returns <code>float / numeric</code>, same as Float#/.\n"],["fdiv","Integer","Integer.html#method-i-fdiv","(p1)","<p>Returns the floating point result of dividing <code>int</code> by <code>numeric</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">654321</span>.<span class=\"ruby-identifier\">fdiv</span>(<span class=\"ruby-value\">13731</span>)      <span class=\"ruby-comment\">#=&gt; 47.652829364212366 ...</span>\n</pre>\n"],["fdiv","Numeric","Numeric.html#method-i-fdiv","(p1)","<p>Returns float division.\n"],["fdiv","Rational","Rational.html#method-i-fdiv","(p1)","<p>Performs division and returns the value as a Float.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">fdiv</span>(<span class=\"ruby-value\">1</span>)       <span class=\"ruby-comment\">#=&gt; 0.6666666666666666 ...</span>\n</pre>\n"],["feature_flag","Bundler","Bundler.html#method-c-feature_flag","()",""],["features","Net::FTP","Net/FTP.html#method-i-features","()","<p>Issues a FEAT command\n<p>Returns an array of supported optional features\n"],["feed","Enumerator","Enumerator.html#method-i-feed","(p1)","<p>Sets the value to be returned by the next yield inside <code>e</code>.\n<p>If the value is not set, the yield returns nil. …\n"],["feed_info","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-feed_info","()",""],["fetch","Array","Array.html#method-i-fetch","(p1, p2 = v2)","<p>Tries to return the element at position <code>index</code>, but throws an IndexError exception if the referenced  …\n"],["fetch","Bundler::Fetcher::Downloader","Bundler/Fetcher/Downloader.html#method-i-fetch","(uri, headers = {}, counter = 0)",""],["fetch","Bundler::Source::Git","Bundler/Source/Git.html#method-i-fetch","()",""],["fetch","CSV::Row","CSV/Row.html#method-i-fetch","(header, *varargs)","<p>This method will fetch the field value by <code>header</code>. It has the same behavior as Hash#fetch: if there is …\n"],["fetch","DBM","DBM.html#method-i-fetch","(p1, p2 = v2)","<p>Return a value from the database by locating the key string provided.  If the key is not found, returns …\n"],["fetch","DRb::WeakIdConv::WeakSet","DRb/WeakIdConv/WeakSet.html#method-i-fetch","(ref)",""],["fetch","ENV","ENV.html#method-c-fetch","(*args)","<p>If <code>name</code> is the name of an environment variable, returns its value:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>[<span class=\"ruby-string\">&#39;foo&#39;</span>] = <span class=\"ruby-string\">&#39;0&#39;</span>\n<span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">fetch</span>(<span class=\"ruby-string\">&#39;foo&#39;</span>) <span class=\"ruby-comment\"># ...</span>\n</pre>\n"],["fetch","GDBM","GDBM.html#method-i-fetch","(p1, p2 = v2)","<p>Retrieves the <em>value</em> corresponding to <em>key</em>. If there is no value associated with <em>key</em>, <em>default</em> will be returned …\n"],["fetch","Gem::Request","Gem/Request.html#method-i-fetch","()",""],["fetch","Gem::StreamUI::SilentDownloadReporter","Gem/StreamUI/SilentDownloadReporter.html#method-i-fetch","(filename, filesize)","<p>The silent download reporter does not display <code>filename</code> or care about <code>filesize</code> because it is silent.\n"],["fetch","Gem::StreamUI::ThreadedDownloadReporter","Gem/StreamUI/ThreadedDownloadReporter.html#method-i-fetch","(file_name, *args)","<p>Tells the download reporter that the <code>file_name</code> is being fetched. The other arguments are ignored.\n"],["fetch","Hash","Hash.html#method-i-fetch","(*args)","<p>Returns a value from the hash for the given key. If the key can&#39;t be found, there are several options: …\n"],["fetch","Net::HTTPHeader","Net/HTTPHeader.html#method-i-fetch","(key, *args)","<p>Returns the header field corresponding to the case-insensitive key. Returns the default value <code>args</code>, or …\n"],["fetch","Net::IMAP","Net/IMAP.html#method-i-fetch","(set, attr, mod = nil)","<p>Sends a FETCH command to retrieve data associated with a message in the mailbox.\n<p>The <code>set</code> parameter is …\n"],["fetch","PStore","PStore.html#method-i-fetch","(name, default=PStore::Error)","<p>This method is just like PStore#[], save that you may also provide a <em>default</em> value for the object.   …\n"],["fetch","Rinda::Tuple","Rinda/Tuple.html#method-i-fetch","(k)","<p>Fetches item <code>k</code> from the tuple.\n"],["fetch","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-fetch","(key)","<p>Fetches <code>key</code> from the tuple.\n"],["fetch","SDBM","SDBM.html#method-i-fetch","(p1, p2 = v2)","<p>Returns the <code>value</code> in the database associated with the given <code>key</code> string.\n<p>If a block is provided, the block …\n"],["fetch","Thread","Thread.html#method-i-fetch","(*args)","<p>Returns a fiber-local for the given key. If the key can&#39;t be found, there are several options: With …\n"],["fetch","YAML::DBM","YAML/DBM.html#method-i-fetch","( keystr, ifnone = nil )","<p>Return value associated with <code>key</code>.\n<p>If there is no value for <code>key</code> and no block is given, returns <code>ifnone</code>. …\n"],["fetch_all_remote_specs","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-fetch_all_remote_specs","(remote)",""],["fetch_connection","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-fetch_connection","(options = nil)","<p>This is an extension point for TimedStack and is called with a mutex.\n<p>This method must return a connection …\n"],["fetch_file","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-fetch_file","(uri, *_)","<p>File Fetcher. Dispatched by <code>fetch_path</code>. Use it instead.\n"],["fetch_gem","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-fetch_gem","(spec)",""],["fetch_gemspec_files","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-fetch_gemspec_files","()","<p>This is used by the default `spec` method to constructs the Specification objects for the gems and versions …\n"],["fetch_http","Bundler::GemRemoteFetcher","Bundler/GemRemoteFetcher.html#method-i-fetch_http","(uri, last_modified = nil, head = false, depth = 0)","<p>Extracted from RubyGems 2.4.\n"],["fetch_http","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-fetch_http","(uri, last_modified = nil, head = false, depth = 0)","<p>HTTP Fetcher. Dispatched by <code>fetch_path</code>. Use it instead.\n"],["fetch_https","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-fetch_https","(uri, last_modified = nil, head = false, depth = 0)",""],["fetch_internal","Net::IMAP","Net/IMAP.html#method-i-fetch_internal","(cmd, set, attr, mod = nil)",""],["fetch_latest_specs","Bundler::CLI::Show","Bundler/CLI/Show.html#method-i-fetch_latest_specs","()",""],["fetch_names","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-fetch_names","(fetchers, dependency_names, index, override_dupes)",""],["fetch_path","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-fetch_path","(path, mtime = nil, head = false)",""],["fetch_path","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-fetch_path","(uri, mtime = nil, head = false)","<p>Downloads <code>uri</code> and returns it as a String.\n"],["fetch_platform","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-fetch_platform","()",""],["fetch_platform","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-fetch_platform","()","<p>Needed before installs, since the arch matters then and quick specs don&#39;t bother to include the arch …\n"],["fetch_resource","Resolv::DNS","Resolv/DNS.html#method-i-fetch_resource","(name, typeclass)",""],["fetch_s3","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-fetch_s3","(uri, mtime = nil, head = false)",""],["fetch_s3_config","Gem::S3URISigner","Gem/S3URISigner.html#method-i-fetch_s3_config","()","<p>Extracts S3 configuration for S3 bucket\n"],["fetch_server","DRb","DRb.html#method-c-fetch_server","(uri)","<p>Retrieves the server with the given <code>uri</code>.\n<p>See also regist_server and remove_server.\n"],["fetch_server","DRb","DRb.html#method-i-fetch_server","(uri)","<p>Retrieves the server with the given <code>uri</code>.\n<p>See also regist_server and remove_server.\n"],["fetch_size","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-fetch_size","(path)",""],["fetch_size","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-fetch_size","(uri)","<p>Returns the size of <code>uri</code> in bytes.\n"],["fetch_spec","Bundler::Fetcher","Bundler/Fetcher.html#method-i-fetch_spec","(spec)","<p>fetch a gem specification\n"],["fetch_spec","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-fetch_spec","(spec)",""],["fetch_spec","Bundler::Fetcher::Index","Bundler/Fetcher/Index.html#method-i-fetch_spec","(spec)",""],["fetch_spec","Gem::Source","Gem/Source.html#method-i-fetch_spec","(name_tuple)","<p>Fetches a specification for the given <code>name_tuple</code>.\n"],["fetch_spec","Gem::Source::Lock","Gem/Source/Lock.html#method-i-fetch_spec","(name_tuple)","<p>Delegates to the wrapped source&#39;s fetch_spec method.\n"],["fetch_specs","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-fetch_specs","(remote, name)",""],["fetch_uri","Bundler::Fetcher::Base","Bundler/Fetcher/Base.html#method-i-fetch_uri","()",""],["fetch_valid_mirror_for","Bundler::Settings::Mirrors","Bundler/Settings/Mirrors.html#method-i-fetch_valid_mirror_for","(uri)",""],["fetch_values","Hash","Hash.html#method-i-fetch_values","(*args)","<p>Returns an array containing the values associated with the given keys but also raises KeyError when one …\n"],["fetcher","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-c-fetcher","()","<p>Cached RemoteFetcher instance.\n"],["fetcher","Gem::SpecFetcher","Gem/SpecFetcher.html#method-c-fetcher","()","<p>Default fetcher instance.  Use this instead of ::new to reduce object allocation.\n"],["fetcher=","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-c-fetcher-3D","(fetcher)",""],["fetchers","Bundler::Fetcher","Bundler/Fetcher.html#method-i-fetchers","()",""],["fetchers","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-fetchers","()",""],["field","CSV::Row","CSV/Row.html#method-i-field","(header_or_index, minimum_index = 0)","<p>This method will return the field value by <code>header</code> or <code>index</code>. If a field is not found, <code>nil</code> is returned. …\n"],["field?","CSV::Row","CSV/Row.html#method-i-field-3F","(data)","<p>Returns <code>true</code> if <code>data</code> matches a field in this row, and <code>false</code> otherwise.\n"],["field_row?","CSV::Row","CSV/Row.html#method-i-field_row-3F","()","<p>Returns <code>true</code> if this is a field row.\n"],["field_size_limit","CSV","CSV.html#method-i-field_size_limit","()","<p>The limit for field size, if any. See CSV::new for details.\n"],["field_size_limit","CSV::Parser","CSV/Parser.html#method-i-field_size_limit","()",""],["fields","CSV::Row","CSV/Row.html#method-i-fields","(*headers_and_or_indices)","<p>This method accepts any number of arguments which can be headers, indices, Ranges of either, or two-element …\n"],["file","ARGF","ARGF.html#method-i-file","()","<p>Returns the current file as an <code>IO</code> or <code>File</code> object. <code>$stdin</code> is returned when the current file is STDIN. …\n"],["file","Digest::Class","Digest/Class.html#method-c-file","(name, *args)","<p>Creates a digest object and reads a given file, <em>name</em>. Optional arguments are passed to the constructor …\n"],["file","Digest::Instance","Digest/Instance.html#method-i-file","(name)","<p>Updates the digest with the contents of a given file <em>name</em> and returns self.\n"],["file?","File","File.html#method-c-file-3F","(p1)","<p>Returns <code>true</code> if the named <code>file</code> exists and is a regular file.\n<p><code>file</code> can be an IO object.\n<p>If the <code>file</code> argument …\n"],["file?","File::Stat","File/Stat.html#method-i-file-3F","()","<p>Returns <code>true</code> if <em>stat</em> is a regular file (not a device file, pipe, socket, etc.).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">file?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["file?","FileTest","FileTest.html#method-i-file-3F","(p1)","<p>Returns <code>true</code> if the named <code>file</code> exists and is a regular file.\n<p><code>file</code> can be an IO object.\n<p>If the <code>file</code> argument …\n"],["file?","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-file-3F","()","<p>Is this tar entry a file?\n"],["file?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-file-3F","()","<p>Returns <code>true</code> if the entry is a file (i.e., the value of the type fact is file).\n"],["file?","Pathname","Pathname.html#method-i-file-3F","()","<p>See FileTest.file?.\n"],["file_collision","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-file_collision","(destination)","<p>Deals with file collision and returns true if the file should be overwritten and false otherwise. If …\n"],["file_field","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-file_field","(name = \"\", size = 20, maxlength = nil)","<p>Generate an File Upload Input element as a string.\n<p>The attributes of the element can be specified as three …\n"],["file_input?","IRB::Context","IRB/Context.html#method-i-file_input-3F","()","<p>Whether #io uses a File for the <code>input_method</code> passed when creating the current context, see ::new\n"],["file_name","Gem::Specification","Gem/Specification.html#method-i-file_name","()","<p>The default (generated) file name of the gem.  See also #spec_name.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">spec</span>.<span class=\"ruby-identifier\">file_name</span> <span class=\"ruby-comment\"># =&gt; &quot;example-1.0.gem&quot;</span>\n</pre>\n"],["file_name","RDoc::CodeObject","RDoc/CodeObject.html#method-i-file_name","()","<p>File name where this CodeObject was found.\n<p>See also RDoc::Context#in_files\n"],["filename","ARGF","ARGF.html#method-i-filename","()","<p>Returns the current filename. “-” is returned when the current file is STDIN.\n<p>For example:\n\n<pre>$ ...</pre>\n"],["filename","Ripper","Ripper.html#method-i-filename","()","<p>Return current parsing filename.\n"],["filename","Ripper::Filter","Ripper/Filter.html#method-i-filename","()","<p>The file name of the input.\n"],["filename_quote_characters","Readline","Readline.html#method-c-filename_quote_characters","()","<p>Gets a list of characters that cause a filename to be quoted by the completer when they appear in a completed …\n"],["filename_quote_characters=","Readline","Readline.html#method-c-filename_quote_characters-3D","(p1)","<p>Sets a list of characters that cause a filename to be quoted by the completer when they appear in a completed …\n"],["filename_quote_characters=","Reline::Core","Reline/Core.html#method-i-filename_quote_characters-3D","(v)",""],["fileno","ARGF","ARGF.html#method-i-fileno","()","<p>Returns an integer representing the numeric file descriptor for the current file. Raises an <code>ArgumentError</code> …\n"],["fileno","Dir","Dir.html#method-i-fileno","()","<p>Returns the file descriptor used in <em>dir</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;..&quot;</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">fileno</span>   <span class=\"ruby-comment\">#=&gt; 8</span>\n</pre>\n<p>This method uses dirfd() function …\n"],["fileno","IO","IO.html#method-i-fileno","()","<p>Returns an integer representing the numeric file descriptor for <em>ios</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">$stdin</span>.<span class=\"ruby-identifier\">fileno</span>    <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-identifier\">$stdout</span>.<span class=\"ruby-identifier\">fileno</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["fileno","StringIO","StringIO.html#method-i-fileno","()","<p>Returns <code>nil</code>.  Just for compatibility to IO.\n"],["files","Gem::Specification","Gem/Specification.html#method-i-files","()","<p>Files included in this gem.  You cannot append to this accessor, you must assign to it.\n<p>Only add files …\n"],["files=","Gem::Specification","Gem/Specification.html#method-i-files-3D","(files)","<p>Sets files to <code>files</code>, ensuring it is an array.\n"],["files_hash","RDoc::Store","RDoc/Store.html#method-i-files_hash","()","<p>Hash of all files known to RDoc\n"],["files_in","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-files_in","(spec)",""],["files_in_default_gem","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-files_in_default_gem","(spec)",""],["files_in_gem","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-files_in_gem","(spec)",""],["filesystem_access","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-filesystem_access","(path, action = :write, &block)","<p>Rescues permissions errors raised by file system operations (ie. Errno:EACCESS, Errno::EAGAIN) and raises …\n"],["fill","Array","Array.html#method-i-fill","(p1 = v1, p2 = v2)","<p>The first three forms set the selected elements of <code>self</code> (which may be the entire array) to <code>obj</code>.\n<p>A <code>start</code> …\n"],["fill","Date","Date.html#method-i-fill","()",""],["fill_breakable","PrettyPrint","PrettyPrint.html#method-i-fill_breakable","(sep=' ', width=sep.length)","<p>This is similar to #breakable except the decision to break or not is determined individually.\n<p>Two #fill_breakable …\n"],["fill_rbuff","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-fill_rbuff","()","<p>Fills the buffer from the underlying SSLSocket\n"],["filter","Array","Array.html#method-i-filter","()","<p>Returns a new array containing all elements of <code>ary</code> for which the given <code>block</code> returns a true value.\n<p>If …\n"],["filter","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-filter","()","<p>Returns filter.\n"],["filter","CSV","CSV.html#method-c-filter","(input=nil, output=nil, **options)","<p>This method is a convenience for building Unix-like filters for CSV data. Each row is yielded to the …\n"],["filter","ENV","ENV.html#method-c-filter","()","<p>Returns a copy of the environment for entries where the block returns true.\n<p>Returns an Enumerator if no …\n"],["filter","Enumerable","Enumerable.html#method-i-filter","()","<p>Returns an array containing all elements of <code>enum</code> for which the given <code>block</code> returns a true value.\n<p>The  …\n"],["filter","Enumerator::Lazy","Enumerator/Lazy.html#method-i-filter","()","<p>Like Enumerable#select, but chains operation to be lazy-evaluated.\n"],["filter","Hash","Hash.html#method-i-filter","()","<p>Returns a new hash consisting of entries for which the block returns true.\n<p>If no block is given, an enumerator …\n"],["filter","REXML::QuickPath","REXML/QuickPath.html#method-c-filter","(elements, path)","<p>Given an array of nodes it filters the array based on the path. The result is that when this method returns, …\n"],["filter","Struct","Struct.html#method-i-filter","(*args)","<p>Yields each member value from the struct to the block and returns an Array containing the member values …\n"],["filter","URI::LDAP","URI/LDAP.html#method-i-filter","()","<p>Returns filter.\n"],["filter!","Array","Array.html#method-i-filter-21","()","<p>Invokes the given block passing in successive elements from <code>self</code>, deleting elements for which the block …\n"],["filter!","ENV","ENV.html#method-c-filter-21","()","<p>Equivalent to ENV.keep_if but returns <code>nil</code> if no changes were made.\n<p>ENV.filter! is an alias for ENV.select! …\n"],["filter!","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-filter-21","(specs)",""],["filter!","Hash","Hash.html#method-i-filter-21","()","<p>Equivalent to Hash#keep_if, but returns <code>nil</code> if no changes were made.\n<p>Hash#filter! is an alias for Hash#select! …\n"],["filter!","Set","Set.html#method-i-filter-21","(&block)","<p>Equivalent to Set#select!\n"],["filter=","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-filter-3D","(val)","<p>Setter for filter <code>val</code>.\n"],["filter=","URI::LDAP","URI/LDAP.html#method-i-filter-3D","(val)","<p>Setter for filter <code>val</code>.\n"],["filter_backtrace","IRB::WorkSpace","IRB/WorkSpace.html#method-i-filter_backtrace","(bt)","<p>error message manipulator\n"],["filter_backtrace","OptionParser::ParseError","OptionParser/ParseError.html#method-c-filter_backtrace","(array)",""],["filter_dep_specs","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-filter_dep_specs","(spec_groups, locked_spec)",""],["filter_map","Enumerable","Enumerable.html#method-i-filter_map","()","<p>Returns a new array containing the truthy results (everything except <code>false</code> or <code>nil</code>) of running the <code>block</code> …\n"],["filter_map","Enumerator::Lazy","Enumerator/Lazy.html#method-i-filter_map","()","<p>Like Enumerable#filter_map, but chains operation to be lazy-evaluated.\n\n<pre>(1..).lazy.filter_map { |i| i * ...</pre>\n"],["filter_nodeset","REXML::XPathParser","REXML/XPathParser.html#method-i-filter_nodeset","(nodeset)",""],["filter_possibilities_after_unwind","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-filter_possibilities_after_unwind","(unwind_details)","<p>Filter&#39;s a state&#39;s possibilities to remove any that would not fix the conflict we&#39;ve just …\n"],["filter_possibilities_for_parent_unwind","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-filter_possibilities_for_parent_unwind","(unwind_details)","<p>Filter&#39;s a state&#39;s possibilities to remove any that would (eventually) create a requirement in …\n"],["filter_possibilities_for_primary_unwind","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-filter_possibilities_for_primary_unwind","(unwind_details)","<p>Filter&#39;s a state&#39;s possibilities to remove any that would not satisfy the requirements in the …\n"],["filter_uri","Bundler::HTTPError","Bundler/HTTPError.html#method-i-filter_uri","(uri)",""],["filtered_possibility_set","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-filtered_possibility_set","(vertex)","<p>Generates a filtered version of the existing vertex&#39;s `PossibilitySet` using the current state&#39;s …\n"],["filtered_specs_by_groups","Bundler::CLI::List","Bundler/CLI/List.html#method-i-filtered_specs_by_groups","()",""],["final","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-final","()","<p>Returns the remaining data held in the cipher object. Further calls to Cipher#update or Cipher#final …\n"],["find","Encoding","Encoding.html#method-c-find","(p1)","<p>Search the encoding with specified <em>name</em>. <em>name</em> should be a string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span>.<span class=\"ruby-identifier\">find</span>(<span class=\"ruby-string\">&quot;US-ASCII&quot;</span>)  <span class=\"ruby-comment\">#=&gt; #&lt;Encoding:US-ASCII&gt;</span>\n</pre>\n"],["find","Enumerable","Enumerable.html#method-i-find","(*args)","<p>Passes each entry in <em>enum</em> to <em>block</em>. Returns the first for which <em>block</em> is not false.  If no object matches, …\n"],["find","Find","Find.html#method-c-find","(*paths, ignore_error: true)","<p>Calls the associated block with the name of every file and directory listed as arguments, then recursively …\n"],["find","Find","Find.html#method-i-find","(*paths, ignore_error: true)","<p>Calls the associated block with the name of every file and directory listed as arguments, then recursively …\n"],["find","IRB::Locale","IRB/Locale.html#method-i-find","(file , paths = $:)",""],["find","Pathname","Pathname.html#method-i-find","(ignore_error: true)","<p>Iterates over the directory tree in a depth first manner, yielding a Pathname for each file under “this” …\n"],["find","Psych::ClassLoader::Restricted","Psych/ClassLoader/Restricted.html#method-i-find","(klassname)",""],["find","Rinda::TupleBag","Rinda/TupleBag.html#method-i-find","(template)","<p>Finds a live tuple that matches <code>template</code>.\n"],["find","Rinda::TupleBag::TupleBin","Rinda/TupleBag/TupleBin.html#method-i-find","()",""],["find_active_stub_by_path","Gem::Specification","Gem/Specification.html#method-c-find_active_stub_by_path","(path)",""],["find_alias_command","Gem::CommandManager","Gem/CommandManager.html#method-i-find_alias_command","(cmd_name)",""],["find_alias_comment","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_alias_comment","(class_name, new_name, old_name)","<p>Finds the comment for an alias on <code>class_name</code> from <code>new_name</code> to <code>old_name</code>\n"],["find_all","Enumerable","Enumerable.html#method-i-find_all","()","<p>Returns an array containing all elements of <code>enum</code> for which the given <code>block</code> returns a true value.\n<p>The  …\n"],["find_all","Enumerator::Lazy","Enumerator/Lazy.html#method-i-find_all","()","<p>Like Enumerable#select, but chains operation to be lazy-evaluated.\n"],["find_all","Gem::AvailableSet","Gem/AvailableSet.html#method-i-find_all","(req)","<p>Used by the Resolver, the protocol to use a AvailableSet as a search Set.\n"],["find_all","Gem::Resolver::APISet","Gem/Resolver/APISet.html#method-i-find_all","(req)","<p>Return an array of APISpecification objects matching DependencyRequest <code>req</code>.\n"],["find_all","Gem::Resolver::ComposedSet","Gem/Resolver/ComposedSet.html#method-i-find_all","(req)","<p>Finds all specs matching <code>req</code> in all sets.\n"],["find_all","Gem::Resolver::CurrentSet","Gem/Resolver/CurrentSet.html#method-i-find_all","(req)",""],["find_all","Gem::Resolver::GitSet","Gem/Resolver/GitSet.html#method-i-find_all","(req)","<p>Finds all git gems matching <code>req</code>\n"],["find_all","Gem::Resolver::IndexSet","Gem/Resolver/IndexSet.html#method-i-find_all","(req)","<p>Return an array of IndexSpecification objects matching DependencyRequest <code>req</code>.\n"],["find_all","Gem::Resolver::InstallerSet","Gem/Resolver/InstallerSet.html#method-i-find_all","(req)","<p>Returns an array of IndexSpecification objects matching DependencyRequest <code>req</code>.\n"],["find_all","Gem::Resolver::LockSet","Gem/Resolver/LockSet.html#method-i-find_all","(req)","<p>Returns an Array of IndexSpecification objects matching the DependencyRequest <code>req</code>.\n"],["find_all","Gem::Resolver::Set","Gem/Resolver/Set.html#method-i-find_all","(req)","<p>The find_all method must be implemented.  It returns all Resolver Specification objects matching the …\n"],["find_all","Gem::Resolver::VendorSet","Gem/Resolver/VendorSet.html#method-i-find_all","(req)","<p>Returns an Array of VendorSpecification objects matching the DependencyRequest <code>req</code>.\n"],["find_all","Gem::TestCase::StaticSet","Gem/TestCase/StaticSet.html#method-i-find_all","(dep)","<p>Finds all gems matching <code>dep</code> in this set.\n"],["find_all","Rinda::TupleBag","Rinda/TupleBag.html#method-i-find_all","(template)","<p>Finds all live tuples that match <code>template</code>.\n"],["find_all_by_full_name","Gem::Specification","Gem/Specification.html#method-c-find_all_by_full_name","(full_name)","<p>Returns every spec that has the given <code>full_name</code>\n"],["find_all_by_name","Gem::Specification","Gem/Specification.html#method-c-find_all_by_name","(name, *requirements)","<p>Returns every spec that matches <code>name</code> and optional <code>requirements</code>.\n"],["find_all_satisfiers","Gem::Specification","Gem/Specification.html#method-i-find_all_satisfiers","(dep)","<p>Finds all gems that satisfy <code>dep</code>\n"],["find_all_template","Rinda::TupleBag","Rinda/TupleBag.html#method-i-find_all_template","(tuple)","<p>Finds all tuples in the TupleBag which when treated as templates, match <code>tuple</code> and are alive.\n"],["find_ancestor_local_symbol","RDoc::ClassModule","RDoc/ClassModule.html#method-i-find_ancestor_local_symbol","(symbol)","<p>Looks for a symbol in the #ancestors. See Context#find_local_symbol.\n"],["find_attr_comment","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_attr_comment","(var_name, attr_name, read = nil, write = nil)","<p>Finds a comment for rb_define_attr, rb_attr or Document-attr.\n<p><code>var_name</code> is the C class variable the attribute …\n"],["find_attribute","RDoc::Context","RDoc/Context.html#method-i-find_attribute","(name, singleton)","<p>Finds an attribute <code>name</code> with singleton value <code>singleton</code>.\n"],["find_attribute_named","RDoc::Context","RDoc/Context.html#method-i-find_attribute_named","(name)","<p>Finds an attribute with <code>name</code> in this context\n"],["find_body","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_body","(class_name, meth_name, meth_obj, file_content, quiet = false)","<p>Find the C code corresponding to a Ruby method\n"],["find_by_name","Gem::Specification","Gem/Specification.html#method-c-find_by_name","(name, *requirements)","<p>Find the best specification matching a <code>name</code> and <code>requirements</code>. Raises if the dependency doesn&#39;t resolve …\n"],["find_by_name_and_platform","Bundler::SpecSet","Bundler/SpecSet.html#method-i-find_by_name_and_platform","(name, platform)",""],["find_by_namespace","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-find_by_namespace","(namespace)","<p>Receives a namespace and search for it in the Bundler::Thor::Base subclasses.\n<p>Parameters\n<p>namespace&lt;String&gt; … &mdash; "],["find_by_path","Gem::Specification","Gem/Specification.html#method-c-find_by_path","(path)","<p>Return the best specification that contains the file matching <code>path</code>.\n"],["find_c_enclosure","RDoc::Store","RDoc/Store.html#method-i-find_c_enclosure","(variable)","<p>Finds the enclosure (namespace) for the given C <code>variable</code>.\n"],["find_class","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_class","(raw_name, name)","<p>Finds a RDoc::NormalClass or RDoc::NormalModule for <code>raw_name</code>\n"],["find_class_and_command_by_namespace","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-find_class_and_command_by_namespace","(namespace, fallback = true)","<p>Receives a namespace and tries to retrieve a Bundler::Thor or Bundler::Thor::Group class from it. It …\n"],["find_class_and_task_by_namespace","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-find_class_and_task_by_namespace","(namespace, fallback = true)",""],["find_class_comment","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_class_comment","(class_name, class_mod)","<p>Look for class or module documentation above Init_+class_name+(void), in a Document-class <code>class_name</code> …\n"],["find_class_method_named","RDoc::Context","RDoc/Context.html#method-i-find_class_method_named","(name)","<p>Finds a class method with <code>name</code> in this context\n"],["find_class_named","RDoc::ClassModule","RDoc/ClassModule.html#method-i-find_class_named","(name)","<p>Finds a class or module with <code>name</code> in this namespace or its descendants\n"],["find_class_named","RDoc::Store","RDoc/Store.html#method-i-find_class_named","(name)","<p>Finds the class with <code>name</code> in all discovered classes\n"],["find_class_named_from","RDoc::Store","RDoc/Store.html#method-i-find_class_named_from","(name, from)","<p>Finds the class with <code>name</code> starting in namespace <code>from</code>\n"],["find_class_or_module","RDoc::Store","RDoc/Store.html#method-i-find_class_or_module","(name)","<p>Finds the class or module with <code>name</code>\n"],["find_class_or_module","RDoc::TopLevel","RDoc/TopLevel.html#method-i-find_class_or_module","(name)","<p>See RDoc::TopLevel::find_class_or_module\n"],["find_command","Gem::CommandManager","Gem/CommandManager.html#method-i-find_command","(cmd_name)",""],["find_command_possibilities","Bundler::Thor","Bundler/Thor.html#method-c-find_command_possibilities","(meth)","<p>this is the logic that takes the command name passed in by the user and determines whether it is an unambiguous …\n"],["find_command_possibilities","Gem::CommandManager","Gem/CommandManager.html#method-i-find_command_possibilities","(cmd_name)",""],["find_const_comment","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_const_comment","(type, const_name, class_name = nil)","<p>Finds a comment matching <code>type</code> and <code>const_name</code> either above the comment or in the matching Document- section. …\n"],["find_constant_named","RDoc::Context","RDoc/Context.html#method-i-find_constant_named","(name)","<p>Finds a constant with <code>name</code> in this context\n"],["find_data","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-find_data","(path, nargs = 3)",""],["find_directory","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-find_directory","(*names)",""],["find_enclosing_module_named","RDoc::Context","RDoc/Context.html#method-i-find_enclosing_module_named","(name)","<p>Find a module at a higher scope\n"],["find_encoding","REXML::Encoding","REXML/Encoding.html#method-i-find_encoding","(name)",""],["find_executable","MakeMakefile","MakeMakefile.html#method-i-find_executable","(bin, path = nil)","<p>Searches for the executable <code>bin</code> on <code>path</code>.  The default path is your <code>PATH</code> environment variable. If that …\n"],["find_external_alias","RDoc::Context","RDoc/Context.html#method-i-find_external_alias","(name, singleton)","<p>Finds an external alias <code>name</code> with singleton value <code>singleton</code>.\n"],["find_external_alias_named","RDoc::Context","RDoc/Context.html#method-i-find_external_alias_named","(name)","<p>Finds an external alias with <code>name</code> in this context\n"],["find_file","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-find_file","(*names)",""],["find_file_named","RDoc::Context","RDoc/Context.html#method-i-find_file_named","(name)","<p>Finds a file with <code>name</code> in this context\n"],["find_file_named","RDoc::Store","RDoc/Store.html#method-i-find_file_named","(name)","<p>Finds the file with <code>name</code> in all discovered files\n"],["find_files","Gem","Gem.html#method-c-find_files","(glob, check_load_path=true)","<p>Returns a list of paths matching <code>glob</code> that can be used by a gem to pick up features from other gems. …\n"],["find_files_for_gem","Gem::Validator","Gem/Validator.html#method-i-find_files_for_gem","(gem_directory)",""],["find_first_recursive","REXML::Node","REXML/Node.html#method-i-find_first_recursive","()","<p>Find (and return) first subnode (recursively) for which the block evaluates to true. Returns <code>nil</code> if none …\n"],["find_gem","Gem::Source::Local","Gem/Source/Local.html#method-i-find_gem","(gem_name, version = Gem::Requirement.default, prerelease = false)",""],["find_gemfile","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-find_gemfile","()",""],["find_gemspec","Gem::Commands::BuildCommand","Gem/Commands/BuildCommand.html#method-i-find_gemspec","()",""],["find_header","MakeMakefile","MakeMakefile.html#method-i-find_header","(header, *paths)","<p>Instructs mkmf to search for the given <code>header</code> in any of the <code>paths</code> provided, and returns whether or not …\n"],["find_home","Gem","Gem.html#method-c-find_home","()","<p>Finds the user&#39;s home directory.\n"],["find_in_cache","Gem::Commands::UnpackCommand","Gem/Commands/UnpackCommand.html#method-i-find_in_cache","(filename)","<p>Find cached filename in Gem.path. Returns nil if the file cannot be found.\n"],["find_in_source_paths","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-find_in_source_paths","(file)","<p>Receives a file or directory and search for it in the source paths.\n"],["find_in_unresolved","Gem::Specification","Gem/Specification.html#method-c-find_in_unresolved","(path)","<p>Return currently unresolved specs that contain the file matching <code>path</code>.\n"],["find_in_unresolved_tree","Gem::Specification","Gem/Specification.html#method-c-find_in_unresolved_tree","(path)","<p>Search through all unresolved deps and sub-dependencies and return specs that contain the file matching …\n"],["find_inactive_by_path","Gem::Specification","Gem/Specification.html#method-c-find_inactive_by_path","(path)","<p>Return the best specification that contains the file matching <code>path</code> amongst the specs that are not activated. …\n"],["find_index","Array","Array.html#method-i-find_index","(*args)","<p>Returns the <em>index</em> of the first object in <code>ary</code> such that the object is <code>==</code> to <code>obj</code>.\n<p>If a block is given instead …\n"],["find_index","Enumerable","Enumerable.html#method-i-find_index","(p1)","<p>Compares each entry in <em>enum</em> with <em>value</em> or passes to <em>block</em>.  Returns the index for the first for which …\n"],["find_index","Matrix","Matrix.html#method-i-find_index","(*args)",""],["find_indexed_specs","Bundler::Definition","Bundler/Definition.html#method-i-find_indexed_specs","(current_spec)",""],["find_instance_method_named","RDoc::Context","RDoc/Context.html#method-i-find_instance_method_named","(name)","<p>Finds an instance method with <code>name</code> in this context\n"],["find_latest_files","Gem","Gem.html#method-c-find_latest_files","(glob, check_load_path=true)","<p>Returns a list of paths matching <code>glob</code> from the latest gems that can be used by a gem to pick up features …\n"],["find_library","MakeMakefile","MakeMakefile.html#method-i-find_library","(lib, func, *paths, &b)","<p>Returns whether or not the entry point <code>func</code> can be found within the library <code>lib</code> in one of the <code>paths</code> specified, …\n"],["find_local_revision","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-find_local_revision","()",""],["find_local_symbol","RDoc::Context","RDoc/Context.html#method-i-find_local_symbol","(symbol)","<p>Finds a method, constant, attribute, external alias, module or file named <code>symbol</code> in this context.\n"],["find_local_symbol","RDoc::TopLevel","RDoc/TopLevel.html#method-i-find_local_symbol","(symbol)","<p>Finds a class or module named <code>symbol</code>\n"],["find_method","RDoc::Context","RDoc/Context.html#method-i-find_method","(name, singleton)","<p>Finds a method named <code>name</code> with singleton value <code>singleton</code>.\n"],["find_method_named","RDoc::Context","RDoc/Context.html#method-i-find_method_named","(name)","<p>Finds a instance or module method with <code>name</code> in this context\n"],["find_modifiers","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_modifiers","(comment, meth_obj)","<p>Handles modifiers in <code>comment</code> and updates <code>meth_obj</code> as appropriate.\n"],["find_module_named","RDoc::Context","RDoc/Context.html#method-i-find_module_named","(name)","<p>Find a module with <code>name</code> using ruby&#39;s scoping rules\n"],["find_module_named","RDoc::Store","RDoc/Store.html#method-i-find_module_named","(name)","<p>Finds the module with <code>name</code> in all discovered modules\n"],["find_module_named","RDoc::TopLevel","RDoc/TopLevel.html#method-i-find_module_named","(name)","<p>Finds a module or class with <code>name</code>\n"],["find_name","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-find_name","(name)",""],["find_name","Gem::DependencyList","Gem/DependencyList.html#method-i-find_name","(full_name)",""],["find_override_comment","RDoc::Parser::C","RDoc/Parser/C.html#method-i-find_override_comment","(class_name, meth_obj)","<p>Finds a <code>Document-method</code> override for <code>meth_obj</code> on <code>class_name</code>\n"],["find_paths","Gem::Commands::WhichCommand","Gem/Commands/WhichCommand.html#method-i-find_paths","(package_name, dirs)",""],["find_proxy","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-find_proxy","(env=ENV)","<p>Returns a proxy Bundler::URI. The proxy Bundler::URI is obtained from environment variables such as  …\n"],["find_proxy","URI::Generic","URI/Generic.html#method-i-find_proxy","(env=ENV)","<p>Returns a proxy URI. The proxy URI is obtained from environment variables such as http_proxy, ftp_proxy …\n"],["find_resolved_spec","Bundler::Definition","Bundler/Definition.html#method-i-find_resolved_spec","(current_spec)",""],["find_response","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-find_response","(p1)","<p>Returns a SingleResponse whose CertId matches with <em>certificate_id</em>, or <code>nil</code> if this BasicResponse does …\n"],["find_spec","Gem::TestCase::StaticSet","Gem/TestCase/StaticSet.html#method-i-find_spec","(dep)","<p>Finds <code>dep</code> in this set.\n"],["find_spec_by_name_and_version","Gem::DependencyInstaller","Gem/DependencyInstaller.html#method-i-find_spec_by_name_and_version","(gem_name, version = Gem::Requirement.default, prerelease = false)","<p>Finds a spec and the source_uri it came from for gem <code>gem_name</code> and <code>version</code>.  Returns an Array of specs …\n"],["find_spec_for_exe","Gem","Gem.html#method-c-find_spec_for_exe","(name, exec_name, requirements)",""],["find_state_for","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-find_state_for","(requirement)","<p>@return [ResolutionState] the state whose `requirement` is the given\n\n<pre>`requirement`.</pre>\n"],["find_state_for","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-find_state_for","(requirement)","<p>@return [ResolutionState] the state whose `requirement` is the given\n\n<pre>`requirement`.</pre>\n"],["find_symbol","RDoc::Context","RDoc/Context.html#method-i-find_symbol","(symbol)","<p>Look up <code>symbol</code>, first as a module, then as a local symbol.\n"],["find_symbol_module","RDoc::Context","RDoc/Context.html#method-i-find_symbol_module","(symbol)","<p>Look up a module named <code>symbol</code>.\n"],["find_task_possibilities","Bundler::Thor","Bundler/Thor.html#method-c-find_task_possibilities","(meth)",""],["find_text_page","RDoc::Store","RDoc/Store.html#method-i-find_text_page","(file_name)","<p>Returns the RDoc::TopLevel that is a text file and has the given <code>file_name</code>\n"],["find_type","MakeMakefile","MakeMakefile.html#method-i-find_type","(type, opt, *headers, &b)","<p>Returns where the static type <code>type</code> is defined.\n<p>You may also pass additional flags to <code>opt</code> which are then …\n"],["find_unique","RDoc::Store","RDoc/Store.html#method-i-find_unique","(all_hash)","<p>Finds unique classes/modules defined in <code>all_hash</code>, and returns them as an array. Performs the alias updates …\n"],["find_unresolved_default_spec","Gem","Gem.html#method-c-find_unresolved_default_spec","(path)","<p>Find a Gem::Specification of default gem from <code>path</code>\n"],["finger","Rinda::RingFinger","Rinda/RingFinger.html#method-c-finger","()","<p>Creates a singleton RingFinger and looks for a RingServer.  Returns the created RingFinger.\n"],["fingerprint","Racc::States","Racc/States.html#method-i-fingerprint","(arr)",""],["finish","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-finish","(connection)","<p>Finishes the Net::HTTP <code>connection</code>\n"],["finish","Digest::Instance","Digest/Instance.html#method-i-finish","()","<p>Finishes the digest and returns the resulting hash value.\n<p>This method is overridden by each implementation …\n"],["finish","Encoding::Converter","Encoding/Converter.html#method-i-finish","()","<p>Finishes the converter. It returns the last part of the converted string.\n\n<pre>ec = Encoding::Converter.new(&quot;utf-8&quot;, ...</pre>\n"],["finish","Net::HTTP","Net/HTTP.html#method-i-finish","()","<p>Finishes the HTTP session and closes the TCP connection. Raises IOError if the session has not been started. …\n"],["finish","Net::POP3","Net/POP3.html#method-i-finish","()","<p>Finishes a POP3 session and closes TCP connection.\n"],["finish","Net::SMTP","Net/SMTP.html#method-i-finish","()","<p>Finishes the SMTP session and closes TCP connection. Raises IOError if not started.\n"],["finish","OpenSSL::Digest","OpenSSL/Digest.html#method-i-finish","(p1 = v1)",""],["finish","OpenSSL::Engine","OpenSSL/Engine.html#method-i-finish","()","<p>Releases all internal structural references for this engine.\n<p>May raise an EngineError if the engine is …\n"],["finish","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-finish","()",""],["finish","RDoc::Options","RDoc/Options.html#method-i-finish","()","<p>Completes any unfinished option setup business such as filtering for existent files, creating a regexp …\n"],["finish","Zlib::GzipFile","Zlib/GzipFile.html#method-i-finish","()","<p>Closes the GzipFile object. Unlike Zlib::GzipFile#close, this method never calls the close method of …\n"],["finish","Zlib::ZStream","Zlib/ZStream.html#method-i-finish","()","<p>Finishes the stream and flushes output buffer.  If a block is given each chunk is yielded to the block …\n"],["finish_page_dir","RDoc::Options","RDoc/Options.html#method-i-finish_page_dir","()","<p>Fixes the page_dir to be relative to the root_dir and adds the page_dir to the files list.\n"],["finish_resolve","Gem","Gem.html#method-c-finish_resolve","(request_set=Gem::RequestSet.new)",""],["finished?","Zlib::ZStream","Zlib/ZStream.html#method-i-finished-3F","()","<p>Returns true if the stream is finished.\n"],["finished_installing?","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-finished_installing-3F","()",""],["finite?","BigDecimal","BigDecimal.html#method-i-finite-3F","()","<p>Returns True if the value is finite (not NaN or infinite).\n"],["finite?","Complex","Complex.html#method-i-finite-3F","()","<p>Returns <code>true</code> if <code>cmp</code>&#39;s real and imaginary parts are both finite numbers, otherwise returns <code>false</code>. …\n"],["finite?","Float","Float.html#method-i-finite-3F","()","<p>Returns <code>true</code> if <code>float</code> is a valid IEEE floating point number, i.e. it is not infinite and Float#nan? is …\n"],["finite?","Numeric","Numeric.html#method-i-finite-3F","()","<p>Returns <code>true</code> if <code>num</code> is a finite number, otherwise returns <code>false</code>.\n"],["fips_mode","OpenSSL","OpenSSL.html#method-c-fips_mode","()",""],["fips_mode=","OpenSSL","OpenSSL.html#method-c-fips_mode-3D","(p1)","<p>Turns FIPS mode on or off. Turning on FIPS mode will obviously only have an effect for FIPS-capable installations …\n"],["first","Array","Array.html#method-i-first","(*args)","<p>Returns the first element, or the first <code>n</code> elements, of the array. If the array is empty, the first form …\n"],["first","Enumerable","Enumerable.html#method-i-first","(*args)","<p>Returns the first element, or the first <code>n</code> elements, of the enumerable. If the enumerable is empty, the …\n"],["first","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-first","(*args)","<p>Returns the first number in this arithmetic sequence, or an array of the first <code>n</code> elements.\n"],["first","Gem::SourceList","Gem/SourceList.html#method-i-first","()","<p>Returns the first source in the list.\n"],["first","REXML::QuickPath","REXML/QuickPath.html#method-c-first","(element, path, namespaces=EMPTY_HASH)",""],["first","REXML::XPath","REXML/XPath.html#method-c-first","(element, path=nil, namespaces=nil, variables={}, options={})","<p>Finds and returns the first node that matches the supplied xpath.\n<p>element &mdash; The context element\n<p>path &mdash; The …\n"],["first","REXML::XPathParser","REXML/XPathParser.html#method-i-first","( path_stack, node )","<p>Performs a depth-first (document order) XPath search, and returns the first match.  This is the fastest, …\n"],["first","Range","Range.html#method-i-first","(p1)","<p>Returns the first object in the range, or an array of the first <code>n</code> elements.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">10</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">20</span>).<span class=\"ruby-identifier\">first</span>     <span class=\"ruby-comment\">#=&gt; 10 ...</span>\n</pre>\n"],["first?","PrettyPrint::SingleLine","PrettyPrint/SingleLine.html#method-i-first-3F","()","<p>This is used as a predicate, and ought to be called first.\n"],["first_column","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-first_column","()","<p>The column number in the source code where this AST&#39;s text began.\n"],["first_lineno","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-first_lineno","()","<p>The line number in the source code where this AST&#39;s text began.\n"],["first_lineno","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-first_lineno","()","<p>Returns the number of the first source line where the instruction sequence was loaded from.\n<p>For example, …\n"],["first_minor","Matrix","Matrix.html#method-i-first_minor","(row, column)","<p>Returns the submatrix obtained by deleting the specified row and column.\n\n<pre>Matrix.diagonal(9, 5, -3, 4).first_minor(1, ...</pre>\n"],["fix","BigDecimal","BigDecimal.html#method-i-fix","()","<p>Return the integer part of the number, as a BigDecimal.\n"],["fix","Racc::SymbolTable","Racc/SymbolTable.html#method-i-fix","()",""],["fix_basic_object_inheritance","RDoc::Store","RDoc/Store.html#method-i-fix_basic_object_inheritance","()","<p>Fixes the erroneous <code>BasicObject &lt; Object</code> in 1.9.\n<p>Because we assumed all classes without a stated superclass …\n"],["fix_ident","Racc::Grammar","Racc/Grammar.html#method-i-fix_ident","()","<p>Rule#ident LocationPointer#ident\n"],["fix_ident","Racc::SymbolTable","Racc/SymbolTable.html#method-i-fix_ident","()",""],["fixed_anchor?","StringScanner","StringScanner.html#method-i-fixed_anchor-3F","()","<p>Whether <code>scanner</code> uses fixed anchor mode or not.\n<p>If fixed anchor mode is used, <code>\\A</code> always matches the beginning …\n"],["fixed_encoding?","Regexp","Regexp.html#method-i-fixed_encoding-3F","()","<p>Returns false if rxp is applicable to a string with any ASCII compatible encoding. Returns true otherwise. …\n"],["fixup_swapped_children","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-fixup_swapped_children","(vertex)","<p>Ensures there are no orphaned successors to the given {vertex}. @param [DependencyGraph::Vertex] vertex …\n"],["flags","Socket::Ifaddr","Socket/Ifaddr.html#method-i-flags","()","<p>Returns the flags of <em>ifaddr</em>.\n"],["flags=","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-flags-3D","(p1)","<p>Sets <em>flags</em> to the Store. <em>flags</em> consists of zero or more of the constants defined in with name V_FLAG_ …\n"],["flags=","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-flags-3D","(p1)","<p>Sets the verification flags to the context. See Store#flags=.\n"],["flat_map","Bundler::Molinillo::Compatibility","Bundler/Molinillo/Compatibility.html#method-i-flat_map","(enum, &blk)","<p>Flat map @param [Enumerable] enum an enumerable object @block the block to flat-map with @return The …\n"],["flat_map","Enumerable","Enumerable.html#method-i-flat_map","()","<p>Returns a new array with the concatenated results of running <em>block</em> once for every element in <em>enum</em>.\n<p>If …\n"],["flat_map","Enumerator::Lazy","Enumerator/Lazy.html#method-i-flat_map","()","<p>Returns a new lazy enumerator with the concatenated results of running <code>block</code> once for every element in …\n"],["flatten","Array","Array.html#method-i-flatten","(*args)","<p>Returns a new array that is a one-dimensional flattening of <code>self</code> (recursively).\n<p>That is, for every element …\n"],["flatten","Hash","Hash.html#method-i-flatten","(*args)","<p>Returns a new array that is a one-dimensional flattening of this hash. That is, for every key or value …\n"],["flatten","Set","Set.html#method-i-flatten","()","<p>Returns a new set that is a copy of the set, flattening each containing set recursively.\n"],["flatten!","Array","Array.html#method-i-flatten-21","(*args)","<p>Flattens <code>self</code> in place.\n<p>Returns <code>nil</code> if no modifications were made (i.e., the array contains no subarrays.) …\n"],["flatten!","Set","Set.html#method-i-flatten-21","()","<p>Equivalent to Set#flatten, but replaces the receiver with the result in place.  Returns nil if no modifications …\n"],["flock","CSV","CSV.html#method-i-flock","(*args)",""],["flock","File","File.html#method-i-flock","(p1)","<p>Locks or unlocks a file according to <em>locking_constant</em> (a logical <em>or</em> of the values in the table below). …\n"],["floor","BigDecimal","BigDecimal.html#method-i-floor","(p1 = v1)","<p>Return the largest integer less than or equal to the value, as a BigDecimal.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;3.14159&#39;</span>).<span class=\"ruby-identifier\">floor</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["floor","Float","Float.html#method-i-floor","(*args)","<p>Returns the largest number less than or equal to <code>float</code> with a precision of <code>ndigits</code> decimal digits (default: …\n"],["floor","Integer","Integer.html#method-i-floor","(*args)","<p>Returns the largest number less than or equal to <code>int</code> with a precision of <code>ndigits</code> decimal digits (default: …\n"],["floor","Numeric","Numeric.html#method-i-floor","(*args)","<p>Returns the largest number less than or equal to <code>num</code> with a precision of <code>ndigits</code> decimal digits (default: …\n"],["floor","REXML::Functions","REXML/Functions.html#method-c-floor","( number )",""],["floor","Rational","Rational.html#method-i-floor","(*args)","<p>Returns the largest number less than or equal to <code>rat</code> with a precision of <code>ndigits</code> decimal digits (default: …\n"],["floor","Time","Time.html#method-i-floor","(*args)","<p>Floors sub seconds to a given precision in decimal digits (0 digits by default). It returns a new Time …\n"],["flush","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-flush","()","<p>Flushes the TarWriter&#39;s IO\n"],["flush","IO","IO.html#method-i-flush","()","<p>Flushes any buffered data within <em>ios</em> to the underlying operating system (note that this is Ruby internal …\n"],["flush","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-flush","()","<p>Flushes buffered data to the SSLSocket.\n"],["flush","PrettyPrint","PrettyPrint.html#method-i-flush","()","<p>outputs buffered data.\n"],["flush","StringIO","StringIO.html#method-i-flush","()","<p>Returns an object itself.  Just for compatibility to IO.\n"],["flush","WEBrick::HTTPAuth::Htdigest","WEBrick/HTTPAuth/Htdigest.html#method-i-flush","(output=nil)","<p>Flush the password database.  If <code>output</code> is given the database will be written there instead of to the …\n"],["flush","WEBrick::HTTPAuth::Htgroup","WEBrick/HTTPAuth/Htgroup.html#method-i-flush","(output=nil)","<p>Flush the group database.  If <code>output</code> is given the database will be written there instead of to the original …\n"],["flush","WEBrick::HTTPAuth::Htpasswd","WEBrick/HTTPAuth/Htpasswd.html#method-i-flush","(output=nil)","<p>Flush the password database.  If <code>output</code> is given the database will be written there instead of to the …\n"],["flush","Zlib::Deflate","Zlib/Deflate.html#method-i-flush","(p1 = v1)","<p>This method is equivalent to <code>deflate(&#39;&#39;, flush)</code>. This method is just provided to improve the …\n"],["flush","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-flush","(p1 = v1)","<p>Flushes all the internal buffers of the GzipWriter object.  The meaning of <code>flush</code> is same as in Zlib::Deflate#deflate …\n"],["flush_buffer","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-flush_buffer","(out, buf, chunked_p)",""],["flush_delayed","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-flush_delayed","()",""],["flush_left","RDoc::Text","RDoc/Text.html#method-i-flush_left","(text)","<p>Flush <code>text</code> left based on the shortest line\n"],["flush_next_in","Zlib::ZStream","Zlib/ZStream.html#method-i-flush_next_in","()",""],["flush_next_out","Zlib::ZStream","Zlib/ZStream.html#method-i-flush_next_out","()","<p>Flushes output buffer and returns all data in that buffer.  If a block is given each chunk is yielded …\n"],["flush_sessions","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-flush_sessions","(p1 = v1)","<p>Removes sessions in the internal cache that have expired at <em>time</em>.\n"],["fnmatch","File","File.html#method-c-fnmatch","(p1, p2, p3 = v3)","<p>Returns true if <code>path</code> matches against <code>pattern</code>.  The pattern is not a regular expression; instead it follows …\n"],["fnmatch","Pathname","Pathname.html#method-i-fnmatch","(p1, p2 = v2)","<p>Return <code>true</code> if the receiver matches the given pattern.\n<p>See File.fnmatch.\n"],["fnmatch?","File","File.html#method-c-fnmatch-3F","(p1, p2, p3 = v3)","<p>Returns true if <code>path</code> matches against <code>pattern</code>.  The pattern is not a regular expression; instead it follows …\n"],["fnmatch?","Pathname","Pathname.html#method-i-fnmatch-3F","(p1, p2 = v2)","<p>Return <code>true</code> if the receiver matches the given pattern.\n<p>See File.fnmatch.\n"],["following","REXML::XPathParser","REXML/XPathParser.html#method-i-following","(node)",""],["following_node_of","REXML::XPathParser","REXML/XPathParser.html#method-i-following_node_of","( node )",""],["footer","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-footer","()",""],["for","Bundler::Settings::Mirrors","Bundler/Settings/Mirrors.html#method-i-for","(uri)","<p>Returns a mirror for the given uri.\n<p>Depending on the uri having a valid mirror or not, it may be a\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">mirror</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["for","Bundler::SpecSet","Bundler/SpecSet.html#method-i-for","(dependencies, skip = [], check = false, match_current_platform = false, raise_on_missing = true)",""],["for","Bundler::VersionRanges","Bundler/VersionRanges.html#method-c-for","(requirement)",""],["for","RDoc::Parser","RDoc/Parser.html#method-c-for","(top_level, file_name, content, options, stats)","<p>Finds and instantiates the correct parser for the given <code>file_name</code> and <code>content</code>.\n"],["for?","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-for-3F","(platform)",""],["for_cache","Gem::Specification","Gem/Specification.html#method-i-for_cache","()","<p>Creates a duplicate spec without large blobs that aren&#39;t used at runtime.\n"],["for_current_gems","Gem::Resolver","Gem/Resolver.html#method-c-for_current_gems","(needed)","<p>Creates a Resolver that queries only against the already installed gems for the <code>needed</code> dependencies. …\n"],["for_fd","BasicSocket","BasicSocket.html#method-c-for_fd","(p1)","<p>Returns a socket object which contains the file descriptor, <em>fd</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-comment\"># If invoked by inetd, STDIN/STDOUT/STDERR ...</span>\n</pre>\n"],["for_fd","IO","IO.html#method-c-for_fd","(*args)","<p>Synonym for IO.new.\n"],["for_many","Bundler::VersionRanges","Bundler/VersionRanges.html#method-c-for_many","(requirements)",""],["for_spec","Gem::Installer","Gem/Installer.html#method-c-for_spec","(spec, options = {})","<p>Construct an installer object for an ephemeral gem (one where we don&#39;t actually have a .gem file, …\n"],["for_spec?","Gem::Resolver::Conflict","Gem/Resolver/Conflict.html#method-i-for_spec-3F","(spec)","<p>Returns true if the conflicting dependency&#39;s name matches <code>spec</code>.\n"],["force","Enumerator::Lazy","Enumerator/Lazy.html#method-i-force","()",""],["force_documentation=","RDoc::CodeObject","RDoc/CodeObject.html#method-i-force_documentation-3D","(value)","<p>Force the documentation of this object unless documentation has been turned off by :enddoc:\n"],["force_encoding","String","String.html#method-i-force_encoding","(p1)","<p>Changes the encoding to <code>encoding</code> and returns self.\n"],["force_quotes?","CSV","CSV.html#method-i-force_quotes-3F","()","<p>Returns <code>true</code> if all output fields are quoted. See CSV::new for details.\n"],["force_zone!","Time","Time.html#method-c-force_zone-21","(t, zone, offset=nil)",""],["foreach","Addrinfo","Addrinfo.html#method-c-foreach","(nodename, service, family=nil, socktype=nil, protocol=nil, flags=nil, timeout: nil, &block)","<p>iterates over the list of Addrinfo objects obtained by Addrinfo.getaddrinfo.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">foreach</span>(<span class=\"ruby-keyword\">nil</span>, <span class=\"ruby-value\">80</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["foreach","CSV","CSV.html#method-c-foreach","(path, mode=\"r\", **options, &block)","<p>This method is intended as the primary interface for reading CSV files. You pass a <code>path</code> and any <code>options</code> …\n"],["foreach","Dir","Dir.html#method-c-foreach","(*args)","<p>Calls the block once for each entry in the named directory, passing the filename of each entry as a parameter …\n"],["foreach","IO","IO.html#method-c-foreach","(p1, p2 = v2, p3 = v3, p4 = v4, p5 = {})","<p>Executes the block for every line in the named I/O port, where lines are separated by <em>sep</em>.\n<p>If no block …\n"],["foreach","Net::POP3","Net/POP3.html#method-c-foreach","(address, port = nil, account = nil, password = nil, isapop = false)","<p>Starts a POP3 session and iterates over each POPMail object, yielding it to the <code>block</code>. This method is …\n"],["fork","Kernel","Kernel.html#method-i-fork","()","<p>Creates a subprocess. If a block is specified, that block is run in the subprocess, and the subprocess …\n"],["fork","Process","Process.html#method-c-fork","()","<p>Creates a subprocess. If a block is specified, that block is run in the subprocess, and the subprocess …\n"],["fork","Thread","Thread.html#method-c-fork","(*args)","<p>Basically the same as ::new. However, if class Thread is subclassed, then calling <code>start</code> in that subclass …\n"],["form","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-form","(method = \"post\", action = script_name, enctype = \"application/x-www-form-urlencoded\")","<p>Generate a Form element as a string.\n<p><code>method</code> should be either “get” or “post”, and …\n"],["form_data=","Net::HTTPHeader","Net/HTTPHeader.html#method-i-form_data-3D","(params, sep = '&')",""],["format","Benchmark::Tms","Benchmark/Tms.html#method-i-format","(format = nil, *args)","<p>Returns the contents of this Tms object as a formatted string, according to a <code>format</code> string like that …\n"],["format","IRB::Locale","IRB/Locale.html#method-i-format","(*opts)",""],["format","Kernel","Kernel.html#method-i-format","(*args)","<p>Returns the string resulting from applying <em>format_string</em> to any additional arguments.  Within the format …\n"],["format","PrettyPrint","PrettyPrint.html#method-c-format","(output=''.dup, maxwidth=79, newline=\"\\n\", genspace=lambda {|n| ' ' * n})","<p>This is a convenience method which is same as follows:\n\n<pre>begin\n  q = PrettyPrint.new(output, maxwidth, newline, ...</pre>\n"],["format","WEBrick::AccessLog","WEBrick/AccessLog.html#method-i-format","(format_string, params)","<p>Formats <code>params</code> according to <code>format_string</code> which is described in setup_params.\n"],["format","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-format","(arg)","<p>Formats <code>arg</code> for the logger\n<p>If <code>arg</code> is an Exception, it will format the error message and the back trace. …\n"],["format=","RDoc::Comment","RDoc/Comment.html#method-i-format-3D","(format)","<p>Sets the format of this comment and resets any parsed document\n"],["format_date","Net::IMAP","Net/IMAP.html#method-c-format_date","(time)","<p>Formats <code>time</code> as an IMAP-style date.\n"],["format_datetime","Net::IMAP","Net/IMAP.html#method-c-format_datetime","(time)","<p>Formats <code>time</code> as an IMAP-style date-time.\n"],["format_message","Logger","Logger.html#method-i-format_message","(severity, datetime, progname, msg)",""],["format_severity","Logger","Logger.html#method-i-format_severity","(severity)",""],["format_text","Gem::Text","Gem/Text.html#method-i-format_text","(text, wrap, indent=0)","<p>Wraps <code>text</code> to <code>wrap</code> characters and optionally indents by <code>indent</code> characters\n"],["format_time","Gem::NoAliasYAMLTree","Gem/NoAliasYAMLTree.html#method-i-format_time","(time)","<p>This is ported over from the yaml_tree in 1.9.3\n"],["format_time","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-format_time","(time)",""],["formatted_program_filename","Gem::Installer","Gem/Installer.html#method-i-formatted_program_filename","(filename)","<p>Prefix and suffix the program filename the same as ruby.\n"],["formatted_usage","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-formatted_usage","(klass, namespace = true, subcommand = false)","<p>Returns the formatted usage by injecting given required arguments and required options into the given …\n"],["formatted_usage","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-formatted_usage","(klass, namespace = true, subcommand = false)","<p>Returns the formatted usage by injecting given required arguments and required options into the given …\n"],["formatted_versions_with_platforms","Bundler::Resolver","Bundler/Resolver.html#method-i-formatted_versions_with_platforms","(versions_with_platforms)",""],["formatter","DidYouMean","DidYouMean.html#method-c-formatter","()","<p>Returns the currenctly set formatter. By default, it is set to <code>DidYouMean::Formatter</code>.\n"],["formatter=","DidYouMean","DidYouMean.html#method-c-formatter-3D","(formatter)","<p>Updates the primary formatter used to format the suggestions.\n"],["frac","BigDecimal","BigDecimal.html#method-i-frac","()","<p>Return the fractional part of the number, as a BigDecimal.\n"],["fragment=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-fragment-3D","(v)","<p>Checks the fragment <code>v</code> component against the Bundler::URI::Parser Regexp for :FRAGMENT.\n<p>Args\n<p><code>v</code> &mdash; String\n"],["fragment=","URI::Generic","URI/Generic.html#method-i-fragment-3D","(v)","<p>Checks the fragment <code>v</code> component against the URI::Parser Regexp for :FRAGMENT.\n<p>Args\n<p><code>v</code> &mdash; String\n"],["free","Fiddle","Fiddle.html#method-c-free","(p1)","<p>Free the memory at address <code>addr</code>\n"],["free","Fiddle::Pointer","Fiddle/Pointer.html#method-i-free","()","<p>Get the free function for this pointer.\n<p>Returns a new instance of Fiddle::Function.\n<p>See Fiddle::Function.new …\n"],["free=","Fiddle::Pointer","Fiddle/Pointer.html#method-i-free-3D","(p1)","<p>Set the free function for this pointer to <code>function</code> in the given Fiddle::Function.\n"],["freeze","Delegator","Delegator.html#method-i-freeze","()","<p>:method: freeze Freeze both the object returned by _<em>getobj</em>_ and self.\n"],["freeze","ENV","ENV.html#method-c-freeze","()","<p>Ruby does not allow ENV to be frozen, so calling ENV.freeze raises TypeError.\n"],["freeze","Gem::Version","Gem/Version.html#method-i-freeze","()",""],["freeze","Matrix","Matrix.html#method-i-freeze","()",""],["freeze","Module","Module.html#method-i-freeze","()","<p>Prevents further modifications to <em>mod</em>.\n<p>This method returns self.\n"],["freeze","Object","Object.html#method-i-freeze","()","<p>Prevents further modifications to <em>obj</em>. A RuntimeError will be raised if modification is attempted. There …\n"],["freeze","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-freeze","()",""],["freeze","OpenStruct","OpenStruct.html#method-i-freeze","()",""],["freeze","Pathname","Pathname.html#method-i-freeze","()","<p>Freezes this Pathname.\n<p>See Object.freeze.\n"],["freeze","String","String.html#method-i-freeze","()",""],["freeze","Vector","Vector.html#method-i-freeze","()",""],["frexp","Math","Math.html#method-c-frexp","(p1)","<p>Returns a two-element array containing the normalized fraction (a Float) and exponent (an Integer) of …\n"],["friday?","Date","Date.html#method-i-friday-3F","()","<p>Returns true if the date is Friday.\n"],["friday?","Time","Time.html#method-i-friday-3F","()","<p>Returns <code>true</code> if <em>time</em> represents Friday.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">1987</span>, <span class=\"ruby-value\">12</span>, <span class=\"ruby-value\">18</span>)     <span class=\"ruby-comment\">#=&gt; 1987-12-18 00:00:00 -0600 ...</span>\n</pre>\n"],["friendly_path","RDoc::Store","RDoc/Store.html#method-i-friendly_path","()","<p>Friendly rendition of #path\n"],["from","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-c-from","(stream)","<p>Creates a tar header from IO <code>stream</code>\n"],["from","Gem::SourceList","Gem/SourceList.html#method-c-from","(ary)","<p>Creates a new SourceList from an array of sources.\n"],["from_file","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-c-from_file","(file)",""],["from_hash","JSON::GenericObject","JSON/GenericObject.html#method-c-from_hash","(object)",""],["from_list","Gem::NameTuple","Gem/NameTuple.html#method-c-from_list","(list)","<p>Turn an array of [name, version, platform] into an array of NameTuple objects.\n"],["from_lock","Bundler::Source::Git","Bundler/Source/Git.html#method-c-from_lock","(options)",""],["from_lock","Bundler::Source::Path","Bundler/Source/Path.html#method-c-from_lock","(options)",""],["from_lock","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-c-from_lock","(options)",""],["from_module","RDoc::ClassModule","RDoc/ClassModule.html#method-c-from_module","(class_type, mod)","<p>Return a RDoc::ClassModule of class <code>class_type</code> that is a copy of module <code>module</code>. Used to promote modules …\n"],["from_name","Process::GID","Process/GID.html#method-c-from_name","(p1)","<p>Get the group ID by the <em>name</em>. If the group is not found, <code>ArgumentError</code> will be raised.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">GID</span>.<span class=\"ruby-identifier\">from_name</span>(<span class=\"ruby-string\">&quot;wheel&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["from_name","Process::UID","Process/UID.html#method-c-from_name","(p1)","<p>Get the user ID by the <em>name</em>. If the user is not found, <code>ArgumentError</code> will be raised.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">UID</span>.<span class=\"ruby-identifier\">from_name</span>(<span class=\"ruby-string\">&quot;root&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["from_prime_division","Integer","Integer.html#method-c-from_prime_division","(pd)","<p>Re-composes a prime factorization and returns the product.\n<p>See Prime#int_from_prime_division for more …\n"],["from_specs","Gem::DependencyList","Gem/DependencyList.html#method-c-from_specs","()","<p>Creates a DependencyList from the current specs.\n"],["from_state","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-c-from_state","(p1)","<p>Creates a State object from <em>opts</em>, which ought to be Hash to create a new State instance configured by …\n"],["from_string","Bundler::RubyVersion","Bundler/RubyVersion.html#method-c-from_string","(string)","<p>Returns a RubyVersion from the given string. @param [String] the version string to match. @return [RubyVersion,Nil] …\n"],["from_stub","Bundler::StubSpecification","Bundler/StubSpecification.html#method-c-from_stub","(stub)",""],["from_superclass","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-from_superclass","(method, default = nil)","<p>Retrieves a value from superclass. If it reaches the baseclass, returns default.\n"],["from_yaml","Gem::Specification","Gem/Specification.html#method-c-from_yaml","(input)","<p>Special loader for YAML files.  When a Specification object is loaded from a YAML file, it bypasses the …\n"],["front","DRb","DRb.html#method-i-front","()","<p>Get the front object of the current server.\n<p>This raises a DRbServerNotFound error if there is no current …\n"],["front","DRb","DRb.html#method-c-front","()","<p>Get the front object of the current server.\n<p>This raises a DRbServerNotFound error if there is no current …\n"],["front","DRb::ExtServ","DRb/ExtServ.html#method-i-front","()",""],["frozen?","Object","Object.html#method-i-frozen-3F","()","<p>Returns the freeze status of <em>obj</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [ <span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;b&quot;</span>, <span class=\"ruby-string\">&quot;c&quot;</span> ]\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">freeze</span>    <span class=\"ruby-comment\">#=&gt; [&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">frozen?</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["frozen_bundle?","Bundler","Bundler.html#method-c-frozen_bundle-3F","()",""],["fsync","IO","IO.html#method-i-fsync","()","<p>Immediately writes all buffered data in <em>ios</em> to disk. Note that #fsync differs from using IO#sync=. The …\n"],["fsync","StringIO","StringIO.html#method-i-fsync","()","<p>Returns 0.  Just for compatibility to IO.\n"],["ftype","File","File.html#method-c-ftype","(p1)","<p>Identifies the type of the named file; the return string is one of “<code>file</code>&#39;&#39;, “<code>directory</code>&#39;&#39;, …\n"],["ftype","File::Stat","File/Stat.html#method-i-ftype","()","<p>Identifies the type of <em>stat</em>. The return string is one of: “<code>file</code>&#39;&#39;, “<code>directory</code>&#39;&#39;, “ …\n"],["ftype","Pathname","Pathname.html#method-i-ftype","()","<p>Returns “type” of file (“file”, “directory”, etc).\n<p>See File.ftype.\n"],["fu_blksize","Bundler::FileUtils::StreamUtils_","Bundler/FileUtils/StreamUtils_.html#method-i-fu_blksize","(st)",""],["fu_blksize","FileUtils::StreamUtils_","FileUtils/StreamUtils_.html#method-i-fu_blksize","(st)",""],["fu_default_blksize","Bundler::FileUtils::StreamUtils_","Bundler/FileUtils/StreamUtils_.html#method-i-fu_default_blksize","()",""],["fu_default_blksize","FileUtils::StreamUtils_","FileUtils/StreamUtils_.html#method-i-fu_default_blksize","()",""],["fu_stream_blksize","Bundler::FileUtils::StreamUtils_","Bundler/FileUtils/StreamUtils_.html#method-i-fu_stream_blksize","(*streams)",""],["fu_stream_blksize","FileUtils::StreamUtils_","FileUtils/StreamUtils_.html#method-i-fu_stream_blksize","(*streams)",""],["fu_windows?","Bundler::FileUtils::StreamUtils_","Bundler/FileUtils/StreamUtils_.html#method-i-fu_windows-3F","()",""],["fu_windows?","FileUtils::StreamUtils_","FileUtils/StreamUtils_.html#method-i-fu_windows-3F","()",""],["full_gem_path","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-full_gem_path","()",""],["full_gem_path","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-full_gem_path","()","<p>The full path to the gem (install path + full name).\n"],["full_gem_path","Gem::Specification","Gem/Specification.html#method-i-full_gem_path","()",""],["full_message","Exception","Exception.html#method-i-full_message","(p1 = {})","<p>Returns formatted string of <em>exception</em>. The returned string is formatted using the same format that Ruby …\n"],["full_name","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-full_name","()",""],["full_name","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-full_name","()",""],["full_name","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-full_name","()","<p>Returns the full name (name-version) of this Gem.  Platform information is included (name-version-platform) …\n"],["full_name","Gem::NameTuple","Gem/NameTuple.html#method-i-full_name","()","<p>Returns the full name (name-version) of this Gem.  Platform information is included if it is not the …\n"],["full_name","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-full_name","()","<p>Full name of the tar entry\n"],["full_name","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-full_name","()","<p>The full name of the specification to be activated.\n"],["full_name","Gem::Resolver::SpecSpecification","Gem/Resolver/SpecSpecification.html#method-i-full_name","()","<p>The name and version of the specification.\n<p>Unlike Gem::Specification#full_name, the platform is not included. …\n"],["full_name","Gem::Resolver::Specification","Gem/Resolver/Specification.html#method-i-full_name","()","<p>The name and version of the specification.\n<p>Unlike Gem::Specification#full_name, the platform is not included. …\n"],["full_name","Gem::Specification","Gem/Specification.html#method-i-full_name","()",""],["full_name","RDoc::ClassModule","RDoc/ClassModule.html#method-i-full_name","()","<p>Return the fully qualified name of this class or module\n"],["full_name","RDoc::Constant","RDoc/Constant.html#method-i-full_name","()","<p>Full constant name including namespace\n"],["full_name","RDoc::Context","RDoc/Context.html#method-i-full_name","()","<p>The full name for this context.  This method is overridden by subclasses.\n"],["full_name","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-full_name","()","<p>Full method/attribute name including namespace\n"],["full_name","RDoc::Mixin","RDoc/Mixin.html#method-i-full_name","()","<p>Full name based on #module\n"],["full_name","RDoc::TopLevel","RDoc/TopLevel.html#method-i-full_name","()","<p>Returns the relative name of this file\n"],["full_name","RSS::Element","RSS/Element.html#method-i-full_name","()",""],["full_name","RSS::ITunesChannelModel::ITunesCategory","RSS/ITunesChannelModel/ITunesCategory.html#method-i-full_name","()",""],["full_name","RSS::ITunesChannelModel::ITunesImage","RSS/ITunesChannelModel/ITunesImage.html#method-i-full_name","()",""],["full_name","RSS::ITunesChannelModel::ITunesOwner","RSS/ITunesChannelModel/ITunesOwner.html#method-i-full_name","()",""],["full_name","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-full_name","()",""],["full_name","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-i-full_name","()",""],["full_name","RSS::ImageItemModel::ImageItem","RSS/ImageItemModel/ImageItem.html#method-i-full_name","()",""],["full_name","RSS::RDF","RSS/RDF.html#method-i-full_name","()",""],["full_name","RSS::RDF::Bag","RSS/RDF/Bag.html#method-i-full_name","()",""],["full_name","RSS::RDF::Bag","RSS/RDF/Bag.html#method-i-full_name","()",""],["full_name","RSS::RDF::Li","RSS/RDF/Li.html#method-i-full_name","()",""],["full_name","RSS::RDF::Li","RSS/RDF/Li.html#method-i-full_name","()",""],["full_name","RSS::RDF::Li","RSS/RDF/Li.html#method-i-full_name","()",""],["full_name","RSS::RDF::Seq","RSS/RDF/Seq.html#method-i-full_name","()",""],["full_name","RSS::RDF::Seq","RSS/RDF/Seq.html#method-i-full_name","()",""],["full_name","RSS::TaxonomyTopicModel::TaxonomyTopic","RSS/TaxonomyTopicModel/TaxonomyTopic.html#method-i-full_name","()",""],["full_name","RSS::TaxonomyTopicsModel::TaxonomyTopics","RSS/TaxonomyTopicsModel/TaxonomyTopics.html#method-i-full_name","()",""],["full_name","RSS::XML::Element","RSS/XML/Element.html#method-i-full_name","()",""],["full_name=","RDoc::CodeObject","RDoc/CodeObject.html#method-i-full_name-3D","(full_name)","<p>Sets the full_name overriding any computed full name.\n<p>Set to <code>nil</code> to clear RDoc&#39;s cached value\n"],["full_old_name","RDoc::Alias","RDoc/Alias.html#method-i-full_old_name","()","<p>Full old name including namespace\n"],["full_require_paths","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-full_require_paths","()",""],["full_require_paths","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-full_require_paths","()","<p>Full paths in the gem to add to <code>$LOAD_PATH</code> when this gem is activated.\n"],["full_spec","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-full_spec","()","<p>The Gem::Specification for this activation request.\n"],["full_version","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-full_version","()",""],["fully_documented?","RDoc::Context","RDoc/Context.html#method-i-fully_documented-3F","()","<p>Does this context and its methods and constants all have documentation?\n<p>(Yes, fully documented doesn&#39;t …\n"],["fully_documented?","RDoc::Stats","RDoc/Stats.html#method-i-fully_documented-3F","()","<p>The documentation status of this project.  <code>true</code> when 100%, <code>false</code> when less than 100% and <code>nil</code> when unknown. …\n"],["fully_expanded_name","REXML::Namespace","REXML/Namespace.html#method-i-fully_expanded_name","()","<p>Fully expand the name, even if the prefix wasn&#39;t specified in the source file.\n"],["function","REXML::QuickPath","REXML/QuickPath.html#method-c-function","( elements, fname, rest )",""],["g","Bundler::Graph::GraphVizClient","Bundler/Graph/GraphVizClient.html#method-i-g","()",""],["gamma","Math","Math.html#method-c-gamma","(p1)","<p>Calculates the gamma function of x.\n<p>Note that gamma(n) is same as fact(n-1) for integer n &gt; 0. However …\n"],["garbage_collect","GC","GC.html#method-i-garbage_collect","(full_mark: true, immediate_mark: true, immediate_sweep: true)",""],["garbage_collect","ObjectSpace","ObjectSpace.html#method-i-garbage_collect","(full_mark: true, immediate_mark: true, immediate_sweep: true)",""],["garbage_collect","ObjectSpace","ObjectSpace.html#method-c-garbage_collect","(full_mark: true, immediate_mark: true, immediate_sweep: true)",""],["gather_files","RDoc::RDoc","RDoc/RDoc.html#method-i-gather_files","(files)","<p>Gathers a set of parseable files from the files and directories listed in <code>files</code>.\n"],["gcd","Integer","Integer.html#method-i-gcd","(p1)","<p>Returns the greatest common divisor of the two integers. The result is always positive. 0.gcd(x) and …\n"],["gcd","OpenSSL::BN","OpenSSL/BN.html#method-i-gcd","(p1)",""],["gcdlcm","Integer","Integer.html#method-i-gcdlcm","(p1)","<p>Returns an array with the greatest common divisor and the least common multiple of the two integers, …\n"],["gem","Bundler::CLI","Bundler/CLI.html#method-i-gem","(name)",""],["gem","Bundler::Dsl","Bundler/Dsl.html#method-i-gem","(name, *args)",""],["gem","Gem::RequestSet","Gem/RequestSet.html#method-i-gem","(name, *reqs)","<p>Declare that a gem of name <code>name</code> with <code>reqs</code> requirements is needed.\n"],["gem","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-gem","(name, *requirements)","<p>Specifies a gem dependency with the given <code>name</code> and <code>requirements</code>.  You may also supply <code>options</code> following …\n"],["gem","Gem::TestCase::SpecFetcherSetup","Gem/TestCase/SpecFetcherSetup.html#method-i-gem","(name, version, dependencies = nil, &block)","<p>Creates a gem with <code>name</code>, <code>version</code> and <code>deps</code>.  The created gem can be downloaded and installed.\n<p>The specification …\n"],["gem","Kernel","Kernel.html#method-i-gem","(gem_name, *requirements)","<p>Use Kernel#gem to activate a specific version of <code>gem_name</code>.\n<p><code>requirements</code> is a list of version requirements …\n"],["gem_bindir","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-gem_bindir","()",""],["gem_cache","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-gem_cache","()",""],["gem_command","Bundler::GemHelper","Bundler/GemHelper.html#method-i-gem_command","()",""],["gem_contents","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-gem_contents","(name)",""],["gem_dir","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-gem_dir","()",""],["gem_dir","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-gem_dir","()","<p>Returns the full path to this spec&#39;s gem directory. eg: /usr/local/lib/ruby/1.8/gems/mygem-1.0\n"],["gem_dir","Gem::Installer","Gem/Installer.html#method-i-gem_dir","()","<p>Lazy accessor for the spec&#39;s gem directory.\n"],["gem_dir","Gem::Specification","Gem/Specification.html#method-i-gem_dir","()",""],["gem_file_list","Gem::Indexer","Gem/Indexer.html#method-i-gem_file_list","()","<p>List of gem file names to index.\n"],["gem_from_path","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-gem_from_path","(path, policy = nil)",""],["gem_install_dir","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-gem_install_dir","()","<p>Note: Do not override if you don&#39;t know what you are doing.\n"],["gem_install_dir","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-gem_install_dir","(name)",""],["gem_install_message","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-gem_install_message","()",""],["gem_key","Bundler::GemHelper","Bundler/GemHelper.html#method-i-gem_key","()",""],["gem_mirrors","Bundler::Settings","Bundler/Settings.html#method-i-gem_mirrors","()",""],["gem_name?","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-gem_name-3F","()",""],["gem_not_found_message","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-gem_not_found_message","(missing_gem_name, alternatives)",""],["gem_original_require","Kernel","Kernel.html#method-i-gem_original_require","(path)",""],["gem_path","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-gem_path","()",""],["gem_path","Bundler::Standalone","Bundler/Standalone.html#method-i-gem_path","(path, spec)",""],["gem_platforms","Bundler::Dependency","Bundler/Dependency.html#method-i-gem_platforms","(valid_platforms)","<p>Returns the platforms this dependency is valid for, in the same order as passed in the `valid_platforms` …\n"],["gem_push?","Bundler::GemHelper","Bundler/GemHelper.html#method-i-gem_push-3F","()",""],["gem_push_host","Bundler::GemHelper","Bundler/GemHelper.html#method-i-gem_push_host","()",""],["gem_remote_fetcher","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-gem_remote_fetcher","()",""],["gem_repository?","Gem::Doctor","Gem/Doctor.html#method-i-gem_repository-3F","()","<p>Are we doctoring a gem repository?\n"],["gem_version_promoter","Bundler::Definition","Bundler/Definition.html#method-i-gem_version_promoter","()",""],["gemfile","Bundler::CLI::Init","Bundler/CLI/Init.html#method-i-gemfile","()",""],["gemfile","Object","Object.html#method-i-gemfile","(install = false, options = {}, &gemfile)","<p>Allows for declaring a Gemfile inline in a ruby script, optionally installing any gems that aren&#39;t …\n"],["gemfile_install","Bundler::Plugin","Bundler/Plugin.html#method-i-gemfile_install","(gemfile = nil, &inline)","<p>Evaluates the Gemfile with a limited DSL and installs the plugins specified by plugin method\n<p>@param [Pathname] …\n"],["gemfile_names","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-gemfile_names","()",""],["gemfile_root","Bundler::Dsl","Bundler/Dsl.html#method-i-gemfile_root","()",""],["gems_dir","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-gems_dir","()","<p>Returns the full path to the gems directory containing this spec&#39;s gem directory. eg: /usr/local/lib/ruby/1.8/gems …\n"],["gems_dir","Gem::Specification","Gem/Specification.html#method-i-gems_dir","()",""],["gems_installed_for","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-gems_installed_for","(definition)",""],["gemspec","Bundler::Dsl","Bundler/Dsl.html#method-i-gemspec","(opts = nil)",""],["gemspec","Bundler::GemHelper","Bundler/GemHelper.html#method-c-gemspec","(&block)",""],["gemspec","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-gemspec","(options = {})","<p>Loads dependencies from a gemspec file.\n<p><code>options</code> include:\n<p>name:  &mdash; The name portion of the gemspec file.  …\n"],["gemspec_cached_path","Bundler::Fetcher","Bundler/Fetcher.html#method-i-gemspec_cached_path","(spec_file_name)","<p>cached gem specification path, if one exists\n"],["gemspec_cached_path","Bundler::Fetcher::Index","Bundler/Fetcher/Index.html#method-i-gemspec_cached_path","(spec_file_name)","<p>cached gem specification path, if one exists\n"],["gemspec_stubs_in","Gem::Specification","Gem/Specification.html#method-c-gemspec_stubs_in","(dir, pattern)",""],["gen_action_tables","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-gen_action_tables","(t, states)",""],["gen_body_table","RDoc::Parser::C","RDoc/Parser/C.html#method-i-gen_body_table","(file_content)","<p>Generate a Ruby-method table\n"],["gen_const_table","RDoc::Parser::C","RDoc/Parser/C.html#method-i-gen_const_table","(file_content)","<p>Generate a const table\n"],["gen_goto_tables","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-gen_goto_tables","(t, grammar)",""],["gen_random","Random::Formatter","Random/Formatter.html#method-i-gen_random","(n)",""],["gen_random","SecureRandom","SecureRandom.html#method-c-gen_random","(n)",""],["gen_random_openssl","SecureRandom","SecureRandom.html#method-c-gen_random_openssl","(n)",""],["gen_random_urandom","SecureRandom","SecureRandom.html#method-c-gen_random_urandom","(n)",""],["generate","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-c-generate","(definition)",""],["generate","Bundler::Standalone","Bundler/Standalone.html#method-i-generate","()",""],["generate","CSV","CSV.html#method-c-generate","(str=nil, **options)","<p>This method wraps a String you provide, or an empty default String, in a CSV object which is passed to …\n"],["generate","JSON","JSON.html#method-i-generate","(obj, opts = nil)","<p>Generate a JSON document from the Ruby data structure <em>obj</em> and return it. <em>state</em> is * a JSON::State object, …\n"],["generate","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-generate","(p1)","<p>Generates a valid JSON document from object <code>obj</code> and returns the result. If no valid JSON document can …\n"],["generate","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-c-generate","(p1, p2 = v2)","<p>Creates a new DH instance from scratch by generating the private and public components alike.\n<p>Parameters …\n"],["generate","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-c-generate","(p1)","<p>Creates a new DSA instance by generating a private/public key pair from scratch.\n<p>Parameters\n<p><em>size</em> is an …\n"],["generate","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-c-generate","(p1)","<p>Creates a new EC instance with a new random private and public key.\n"],["generate","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-c-generate","(p1, p2 = v2)","<p>Generates an RSA keypair.  <em>size</em> is an integer representing the desired key size.  Keys smaller than 1024 …\n"],["generate","RDoc::RDoc","RDoc/RDoc.html#method-i-generate","()","<p>Generates documentation for <code>file_info</code> (from #parse_files) into the output dir using the generator selected …\n"],["generate","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-generate","()","<p>Generates RDoc and ri data\n"],["generate","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-generate","()","<p>Generates RDoc and ri data\n"],["generate","Racc::ParserClassGenerator","Racc/ParserClassGenerator.html#method-i-generate","()",""],["generate","Racc::StateTransitionTable","Racc/StateTransitionTable.html#method-c-generate","(states)",""],["generate","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-generate","()",""],["generate!","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-i-generate-21","()",""],["generate_bin","Bundler::Plugin::Installer::Git","Bundler/Plugin/Installer/Git.html#method-i-generate_bin","(spec, disable_extensions = false)",""],["generate_bin","Bundler::Source::Path","Bundler/Source/Path.html#method-i-generate_bin","(spec, options = {})",""],["generate_bin","Bundler::Source::Path::Installer","Bundler/Source/Path/Installer.html#method-i-generate_bin","()",""],["generate_bin_script","Gem::Installer","Gem/Installer.html#method-i-generate_bin_script","(filename, bindir)","<p>Creates the scripts to run the applications in the gem.\n"],["generate_bin_symlink","Gem::Installer","Gem/Installer.html#method-i-generate_bin_symlink","(filename, bindir)","<p>Creates the symlinks to run the applications in the gem.  Moves the symlink if the gem being installed …\n"],["generate_bundler_executable_stubs","Bundler::Installer","Bundler/Installer.html#method-i-generate_bundler_executable_stubs","(spec, options = {})",""],["generate_canonical_query_params","Gem::S3URISigner","Gem/S3URISigner.html#method-i-generate_canonical_query_params","(s3_config, date_time, credential_info, expiration)",""],["generate_canonical_request","Gem::S3URISigner","Gem/S3URISigner.html#method-i-generate_canonical_request","(canonical_host, query_params)",""],["generate_default_dirs","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-generate_default_dirs","(install_destdir)",""],["generate_event","REXML::Validation::State","REXML/Validation/State.html#method-i-generate_event","( event )",""],["generate_executable_stubs","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-generate_executable_stubs","()",""],["generate_index","Gem::Indexer","Gem/Indexer.html#method-i-generate_index","()","<p>Builds and installs indices.\n"],["generate_key","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-generate_key","()",""],["generate_key!","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-generate_key-21","()","<p>Generates a private and public key unless a private key already exists. If this DH instance was generated …\n"],["generate_key!","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-generate_key-21","()","<p>Generates a new random private and public key.\n<p>See also the OpenSSL documentation for EC_KEY_generate_key …\n"],["generate_line","CSV","CSV.html#method-c-generate_line","(row, **options)","<p>This method is a shortcut for converting a single row (Array) into a CSV String.\n<p>The <code>options</code> parameter …\n"],["generate_parser","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-generate_parser","()",""],["generate_parser_file","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-generate_parser_file","(destpath)",""],["generate_prime","OpenSSL::BN","OpenSSL/BN.html#method-c-generate_prime","(p1, p2 = v2, p3 = v3, p4 = v4)","<p>Generates a random prime number of bit length <em>bits</em>. If <em>safe</em> is set to <code>true</code>, generates a safe prime.  …\n"],["generate_signature","Gem::S3URISigner","Gem/S3URISigner.html#method-i-generate_signature","(s3_config, date, string_to_sign)",""],["generate_standalone_bundler_executable_stubs","Bundler::Installer","Bundler/Installer.html#method-i-generate_standalone_bundler_executable_stubs","(spec)",""],["generate_states","Racc::States","Racc/States.html#method-i-generate_states","(state)",""],["generate_string_to_sign","Gem::S3URISigner","Gem/S3URISigner.html#method-i-generate_string_to_sign","(date_time, credential_info, canonical_request)",""],["generate_tag","Net::IMAP","Net/IMAP.html#method-i-generate_tag","()",""],["generate_windows_script","Gem::Installer","Gem/Installer.html#method-i-generate_windows_script","(filename, bindir)","<p>Creates windows .bat files for easy running of commands\n"],["generation_hook","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-c-generation_hook","(installer, specs)","<p>Post installs hook that generates documentation for each specification in <code>specs</code>\n"],["generation_hook","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-c-generation_hook","(installer, specs)","<p>Post installs hook that generates documentation for each specification in <code>specs</code>\n"],["generator","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-generator","()","<p>Returns the generator of the group.\n<p>See the OpenSSL documentation for EC_GROUP_get0_generator()\n"],["generator_descriptions","RDoc::Options","RDoc/Options.html#method-i-generator_descriptions","()","<p>Returns a properly-space list of generators and their descriptions.\n"],["generator_for","RDoc::Servlet","RDoc/Servlet.html#method-i-generator_for","(store)","<p>Instantiates a Darkfish generator for <code>store</code>\n"],["generic","Bundler::GemHelpers","Bundler/GemHelpers.html#method-i-generic","(p)",""],["generic","Bundler::GemHelpers","Bundler/GemHelpers.html#method-c-generic","(p)",""],["generic_local_platform","Bundler::GemHelpers","Bundler/GemHelpers.html#method-i-generic_local_platform","()",""],["generic_local_platform","Bundler::GemHelpers","Bundler/GemHelpers.html#method-c-generic_local_platform","()",""],["get","Bundler::CLI::Config","Bundler/CLI/Config.html#method-i-get","(name)",""],["get","Bundler::SourceList","Bundler/SourceList.html#method-i-get","(source)",""],["get","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-get","(source, *args, &block)","<p>Gets the content at the given address and places it at the given relative destination. If a block is …\n"],["get","GetoptLong","GetoptLong.html#method-i-get","()","<p>Get next option name and its argument, as an Array of two elements.\n<p>The option name is always converted …\n"],["get","Net::FTP","Net/FTP.html#method-i-get","(remotefile, localfile = File.basename(remotefile), blocksize = DEFAULT_BLOCKSIZE)","<p>Retrieves <code>remotefile</code> in whatever mode the session is set (text or binary).  See #gettextfile and #getbinaryfile …\n"],["get","Net::HTTP","Net/HTTP.html#method-c-get","(uri_or_host, path = nil, port = nil)","<p>Sends a GET request to the target and returns the HTTP response as a string.  The target can either be …\n"],["get","Net::HTTP","Net/HTTP.html#method-i-get","(path, initheader = nil, dest = nil)","<p>Retrieves data from <code>path</code> on the connected-to host which may be an absolute path String or a URI to extract …\n"],["get2","Net::HTTP","Net/HTTP.html#method-i-get2","(path, initheader = nil)",""],["get_all_gem_names","Gem::Command","Gem/Command.html#method-i-get_all_gem_names","()","<p>Get all gem names from the command line.\n"],["get_all_gem_names_and_versions","Gem::Command","Gem/Command.html#method-i-get_all_gem_names_and_versions","()","<p>Get all [gem, version] from the command line.\n<p>An argument in the form gem:ver is pull apart into the gen …\n"],["get_attribute","REXML::Attributes","REXML/Attributes.html#method-i-get_attribute","( name )","<p>Fetches an attribute\n<p>name &mdash; the name by which to search for the attribute.  Can be a <code>prefix:name</code> namespace …\n"],["get_attribute_ns","REXML::Attributes","REXML/Attributes.html#method-i-get_attribute_ns","(namespace, name)","<p>The <code>get_attribute_ns</code> method retrieves a method by its namespace and name. Thus it is possible to reliably …\n"],["get_attributes","RSS::Element","RSS/Element.html#method-c-get_attributes","()",""],["get_bool","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-get_bool","()","<p>Looks for a true or false token.\n"],["get_byte","StringScanner","StringScanner.html#method-i-get_byte","()","<p>Scans one byte and returns it. This method is not multibyte character sensitive. See also: #getch.\n\n<pre>s = ...</pre>\n"],["get_candidate_gems","Gem::Commands::CleanupCommand","Gem/Commands/CleanupCommand.html#method-i-get_candidate_gems","()",""],["get_candidates","OptionParser::List","OptionParser/List.html#method-i-get_candidates","(id)",""],["get_cert_files","Gem::Request","Gem/Request.html#method-c-get_cert_files","()",""],["get_class_or_module","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-get_class_or_module","(container, ignore_constants = false)","<p>Look for the name of a class of module (optionally with a leading  &mdash; or\n<p>with  &mdash; separated named) and return …\n\n"],["get_class_specification","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-get_class_specification","()","<p>Return a superclass, which can be either a constant of an expression\n"],["get_console","Bundler::CLI::Console","Bundler/CLI/Console.html#method-i-get_console","(name)",""],["get_constant","Bundler::CLI::Console","Bundler/CLI/Console.html#method-i-get_constant","(name)",""],["get_constant","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-get_constant","()","<p>Parse a constant, which might be qualified by one or more class or module names\n"],["get_definition","OpenSSL::Config","OpenSSL/Config.html#method-c-get_definition","(io_stack)",""],["get_elements","REXML::Element","REXML/Element.html#method-i-get_elements","( xpath )","<p>Synonym for Element.to_a This is a little slower than calling elements.each directly.\n<p>xpath &mdash; any XPath …\n"],["get_embdoc_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_embdoc_tk","(tk)",""],["get_env_editor","Gem::Commands::OpenCommand","Gem/Commands/OpenCommand.html#method-i-get_env_editor","()",""],["get_fields","Net::HTTPHeader","Net/HTTPHeader.html#method-i-get_fields","(key)","<p>Ruby 1.8.3 &mdash; Returns an array of header field strings corresponding to the case-insensitive <code>key</code>.  This …\n"],["get_file_and_line_from_caller","RSS::Utils","RSS/Utils.html#method-i-get_file_and_line_from_caller","(i=0)","<p>Returns an array of two elements: the filename where the calling method is located, and the line number …\n"],["get_first","REXML::XPathParser","REXML/XPathParser.html#method-i-get_first","(path, nodeset)",""],["get_formatted_specs_and_deps","Bundler::Fetcher::Dependency","Bundler/Fetcher/Dependency.html#method-i-get_formatted_specs_and_deps","(gem_list)",""],["get_gems_to_cleanup","Gem::Commands::CleanupCommand","Gem/Commands/CleanupCommand.html#method-i-get_gems_to_cleanup","()",""],["get_group","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-get_group","(string)","<p>get_group( &#39;[foo]bar&#39; ) -&gt; [&#39;bar&#39;, &#39;[foo]&#39;]\n"],["get_heredoc_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_heredoc_tk","(heredoc_name, indent)",""],["get_hosts_for","Gem::Commands::PushCommand","Gem/Commands/PushCommand.html#method-i-get_hosts_for","(name)",""],["get_included_module_with_optional_parens","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-get_included_module_with_optional_parens","()","<p>Get an included module that may be surrounded by parens\n"],["get_input","Bundler::Thor::LineEditor::Basic","Bundler/Thor/LineEditor/Basic.html#method-i-get_input","()",""],["get_instance","WEBrick::HTTPServlet::AbstractServlet","WEBrick/HTTPServlet/AbstractServlet.html#method-c-get_instance","(server, *options)","<p>Factory for servlet instances that will handle a request from <code>server</code> using <code>options</code> from the mount point. …\n"],["get_key_string","OpenSSL::Config","OpenSSL/Config.html#method-i-get_key_string","(section, key)",""],["get_line","OpenSSL::Config","OpenSSL/Config.html#method-c-get_line","(io_stack)",""],["get_listeners","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-get_listeners","( symbol, name )",""],["get_namespace","REXML::Functions","REXML/Functions.html#method-c-get_namespace","( node_set = nil )","<p>Helper method.\n"],["get_namespace","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-get_namespace","( prefix )",""],["get_namespace","REXML::XPathParser","REXML/XPathParser.html#method-i-get_namespace","( node, prefix )","<p>Returns a String namespace for a node, given a prefix The rules are:\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1</span>. <span class=\"ruby-constant\">Use</span> <span class=\"ruby-identifier\">the</span> <span class=\"ruby-identifier\">supplied</span> <span class=\"ruby-identifier\">namespace</span> <span class=\"ruby-identifier\">mapping</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["get_nth_prime","Prime::EratosthenesSieve","Prime/EratosthenesSieve.html#method-i-get_nth_prime","(n)",""],["get_one_gem_name","Gem::Command","Gem/Command.html#method-i-get_one_gem_name","()","<p>Get a single gem name from the command line.  Fail if there is no gem name or if there is more than one …\n"],["get_one_optional_argument","Gem::Command","Gem/Command.html#method-i-get_one_optional_argument","()","<p>Get a single optional argument from the command line.  If more than one argument is given, return only …\n"],["get_op_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_op_tk","(tk)",""],["get_option","GetoptLong","GetoptLong.html#method-i-get_option","()","<p>`get_option&#39; is an alias of `get&#39;.\n"],["get_otp","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-get_otp","()",""],["get_passwd","WEBrick::HTTPAuth::Htdigest","WEBrick/HTTPAuth/Htdigest.html#method-i-get_passwd","(realm, user, reload_db)","<p>Retrieves a password from the database for <code>user</code> in <code>realm</code>.  If <code>reload_db</code> is true the database will be …\n"],["get_passwd","WEBrick::HTTPAuth::Htpasswd","WEBrick/HTTPAuth/Htpasswd.html#method-i-get_passwd","(realm, user, reload_db)","<p>Retrieves a password from the database for <code>user</code> in <code>realm</code>.  If <code>reload_db</code> is true the database will be …\n"],["get_passwd","WEBrick::HTTPAuth::UserDB","WEBrick/HTTPAuth/UserDB.html#method-i-get_passwd","(realm, user, reload_db=false)","<p>Retrieves a password in <code>realm</code> for <code>user</code> for the auth_type of this database.  <code>reload_db</code> is a dummy value. …\n"],["get_path","Gem::Commands::UnpackCommand","Gem/Commands/UnpackCommand.html#method-i-get_path","(dependency)","<p>Return the full path to the cached gem file matching the given name and version requirement.  Returns …\n"],["get_platform_from_requirements","Gem::Commands::YankCommand","Gem/Commands/YankCommand.html#method-i-get_platform_from_requirements","(requirements)",""],["get_primary_gems","Gem::Commands::CleanupCommand","Gem/Commands/CleanupCommand.html#method-i-get_primary_gems","()",""],["get_print","Net::HTTP","Net/HTTP.html#method-c-get_print","(uri_or_host, path = nil, port = nil)","<p>Gets the body text from the target and outputs it to $stdout.  The target can either be specified as …\n"],["get_procs","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-get_procs","( symbol, name )","<p>The following methods are duplicates, but it is faster than using a helper\n"],["get_proxy_from_env","Gem::Request","Gem/Request.html#method-c-get_proxy_from_env","(scheme = 'http')","<p>Returns a proxy URI for the given <code>scheme</code> if one is set in the environment variables.\n"],["get_quoted_re","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-get_quoted_re","(left)",""],["get_regexp_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_regexp_tk","(tk)",""],["get_relative_path","Gem::Ext::ExtConfBuilder","Gem/Ext/ExtConfBuilder.html#method-c-get_relative_path","(path)",""],["get_renewer","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-get_renewer","(it)","<p>Returns a valid argument to make_expires and the renewer or nil.\n<p>Given <code>true</code>, <code>nil</code>, or Numeric, returns …\n"],["get_response","Net::HTTP","Net/HTTP.html#method-c-get_response","(uri_or_host, path = nil, port = nil, &block)","<p>Sends a GET request to the target and returns the HTTP response as a Net::HTTPResponse object.  The target …\n"],["get_response","Net::IMAP","Net/IMAP.html#method-i-get_response","()",""],["get_response","Net::SMTP","Net/SMTP.html#method-i-get_response","(reqline)",""],["get_screen_size","Readline","Readline.html#method-c-get_screen_size","()","<p>Returns the terminal&#39;s rows and columns.\n<p>See GNU Readline&#39;s rl_get_screen_size function.\n<p>Raises …\n"],["get_screen_size","Reline::Core","Reline/Core.html#method-i-get_screen_size","()",""],["get_set","Gem::Resolver::SourceSet","Gem/Resolver/SourceSet.html#method-i-get_set","(name)",""],["get_squashed_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_squashed_tk","()",""],["get_string_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_string_tk","(tk)",""],["get_symbol_or_name","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-get_symbol_or_name","()","<p>Extracts a name or symbol from the token stream.\n"],["get_symbol_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_symbol_tk","(tk)",""],["get_tagged_response","Net::IMAP","Net/IMAP.html#method-i-get_tagged_response","(tag, cmd)",""],["get_text","REXML::Element","REXML/Element.html#method-i-get_text","(path = nil)","<p>Returns the first child Text node, if any, or <code>nil</code> otherwise. This method returns the actual <code>Text</code> node, …\n"],["get_thread","DEBUGGER__","DEBUGGER__.html#method-c-get_thread","(num)",""],["get_time","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-i-get_time","()","<p>@!visibility private\n"],["get_tk","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-get_tk","()","<p>Fetches the next token from the scanner\n"],["get_tk_until","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-get_tk_until","(*tokens)","<p>Reads and returns all tokens up to one of <code>tokens</code>.  Leaves the matched token in the token list.\n"],["get_tkread","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-get_tkread","()","<p>Retrieves a String representation of the read tokens\n"],["get_value","OpenSSL::Config","OpenSSL/Config.html#method-i-get_value","(section, key)","<p>Gets the value of <em>key</em> from the given <em>section</em>\n<p>Given the following configurating file being loaded:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">config</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["get_version_from_requirements","Gem::Commands::YankCommand","Gem/Commands/YankCommand.html#method-i-get_version_from_requirements","(requirements)",""],["get_version_semver_portion_value","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-get_version_semver_portion_value","(spec, version_portion_index)",""],["get_words_tk","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-get_words_tk","(tk)",""],["getacl","Net::IMAP","Net/IMAP.html#method-i-getacl","(mailbox)","<p>Send the GETACL command along with a specified <code>mailbox</code>. If this mailbox exists, an array containing objects …\n"],["getaddress","IPSocket","IPSocket.html#method-c-getaddress","(p1)","<p>Lookups the IP address of <em>host</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;socket&#39;</span>\n\n<span class=\"ruby-constant\">IPSocket</span>.<span class=\"ruby-identifier\">getaddress</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>)     <span class=\"ruby-comment\">#=&gt; &quot;127.0.0.1&quot; ...</span>\n</pre>\n"],["getaddress","Resolv","Resolv.html#method-i-getaddress","(name)","<p>Looks up the first IP address for <code>name</code>.\n"],["getaddress","Resolv","Resolv.html#method-c-getaddress","(name)","<p>Looks up the first IP address for <code>name</code>.\n"],["getaddress","Resolv::DNS","Resolv/DNS.html#method-i-getaddress","(name)","<p>Gets the IP address of <code>name</code> from the DNS resolver.\n<p><code>name</code> can be a Resolv::DNS::Name or a String.  Retrieved …\n"],["getaddress","Resolv::Hosts","Resolv/Hosts.html#method-i-getaddress","(name)","<p>Gets the IP address of <code>name</code> from the hosts file.\n"],["getaddress_orig","IPSocket","IPSocket.html#method-c-getaddress_orig","(p1)",""],["getaddresses","Resolv","Resolv.html#method-i-getaddresses","(name)","<p>Looks up all IP address for <code>name</code>.\n"],["getaddresses","Resolv","Resolv.html#method-c-getaddresses","(name)","<p>Looks up all IP address for <code>name</code>.\n"],["getaddresses","Resolv::DNS","Resolv/DNS.html#method-i-getaddresses","(name)","<p>Gets all IP addresses for <code>name</code> from the DNS resolver.\n<p><code>name</code> can be a Resolv::DNS::Name or a String.  Retrieved …\n"],["getaddresses","Resolv::Hosts","Resolv/Hosts.html#method-i-getaddresses","(name)","<p>Gets all IP addresses for <code>name</code> from the hosts file.\n"],["getaddrinfo","Addrinfo","Addrinfo.html#method-c-getaddrinfo","(p1, p2, p3 = v3, p4 = v4, p5 = v5, p6 = v6, p7 = {})","<p>returns a list of addrinfo objects as an array.\n<p>This method converts nodename (hostname) and service (port) …\n"],["getaddrinfo","Socket","Socket.html#method-c-getaddrinfo","(p1, p2, p3 = v3, p4 = v4, p5 = v5, p6 = v6, p7 = v7)","<p>Obtains address information for <em>nodename</em>:<em>servname</em>.\n<p>Note that Addrinfo.getaddrinfo provides the same functionality …\n"],["getbinaryfile","Net::FTP","Net/FTP.html#method-i-getbinaryfile","(remotefile, localfile = File.basename(remotefile), blocksize = DEFAULT_BLOCKSIZE)","<p>Retrieves <code>remotefile</code> in binary mode, storing the result in <code>localfile</code>. If <code>localfile</code> is nil, returns retrieved …\n"],["getbyte","ARGF","ARGF.html#method-i-getbyte","()","<p>Gets the next 8-bit byte (0..255) from <code>ARGF</code>. Returns <code>nil</code> if called at the end of the stream.\n<p>For example: …\n"],["getbyte","IO","IO.html#method-i-getbyte","()","<p>Gets the next 8-bit byte (0..255) from <em>ios</em>. Returns <code>nil</code> if called at end of file.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["getbyte","String","String.html#method-i-getbyte","(p1)","<p>returns the <em>index</em>th byte as an integer.\n"],["getbyte","StringIO","StringIO.html#method-i-getbyte","()","<p>See IO#getbyte.\n"],["getbyte","StringScanner","StringScanner.html#method-i-getbyte","()","<p>Equivalent to #get_byte. This method is obsolete; use #get_byte instead.\n"],["getbyte","Zlib::GzipReader","Zlib/GzipReader.html#method-i-getbyte","()","<p>See Zlib::GzipReader documentation for a description.\n"],["getc","ARGF","ARGF.html#method-i-getc","()","<p>Reads the next character from <code>ARGF</code> and returns it as a <code>String</code>. Returns <code>nil</code> at the end of the stream. …\n"],["getc","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-getc","()","<p>Read one byte from the tar entry\n"],["getc","IO","IO.html#method-i-getc","()","<p>Reads a one-character string from <em>ios</em>. Returns <code>nil</code> if called at end of file.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["getc","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-getc","()","<p>Reads one character from the stream.  Returns nil if called at end of file.\n"],["getc","StringIO","StringIO.html#method-i-getc","()","<p>See IO#getc.\n"],["getc","Zlib::GzipReader","Zlib/GzipReader.html#method-i-getc","()","<p>See Zlib::GzipReader documentation for a description.\n"],["getch","IO","IO.html#method-i-getch","(*args)","<p>Reads and returns a character in raw mode.\n<p>See IO#raw for details on the parameters.\n<p>You must require &#39;io/console&#39; …\n"],["getch","IO::generic_readable","IO/generic_readable.html#method-i-getch","(*args)","<p>See IO#getch.\n"],["getch","StringScanner","StringScanner.html#method-i-getch","()","<p>Scans one character and returns it. This method is multibyte character sensitive.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">StringScanner</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;ab&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["getdir","Net::FTP","Net/FTP.html#method-i-getdir","()",""],["getegid","Process::Sys","Process/Sys.html#method-c-getegid","()","<p>Returns the effective group ID for this process. Not available on all platforms.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">egid</span>   <span class=\"ruby-comment\">#=&gt; 500</span>\n</pre>\n"],["geteuid","Process::Sys","Process/Sys.html#method-c-geteuid","()","<p>Returns the effective user ID for this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">euid</span>   <span class=\"ruby-comment\">#=&gt; 501</span>\n</pre>\n"],["getgid","Process::Sys","Process/Sys.html#method-c-getgid","()","<p>Returns the (real) group ID for this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">gid</span>   <span class=\"ruby-comment\">#=&gt; 500</span>\n</pre>\n"],["getgm","Time","Time.html#method-i-getgm","()","<p>Returns a new Time object representing <em>time</em> in UTC.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">20</span>,<span class=\"ruby-value\">15</span>,<span class=\"ruby-value\">1</span>)   <span class=\"ruby-comment\">#=&gt; 2000-01-01 ...</span>\n</pre>\n"],["getgrent","Etc","Etc.html#method-c-getgrent","()","<p>Returns an entry from the /etc/group file.\n<p>The first time it is called it opens the file and returns the …\n"],["getgrgid","Etc","Etc.html#method-c-getgrgid","(p1 = v1)","<p>Returns information about the group with specified integer <code>group_id</code>, as found in /etc/group.\n<p>The information …\n"],["getgrnam","Etc","Etc.html#method-c-getgrnam","(p1)","<p>Returns information about the group with specified <code>name</code>, as found in /etc/group.\n<p>The information is returned …\n"],["gethostbyaddr","Socket","Socket.html#method-c-gethostbyaddr","(p1, p2 = v2)","<p>Use Addrinfo#getnameinfo instead. This method is deprecated for the following reasons:\n<p>Uncommon address …\n"],["gethostbyname","Socket","Socket.html#method-c-gethostbyname","(p1)","<p>Use Addrinfo.getaddrinfo instead. This method is deprecated for the following reasons:\n<p>The 3rd element …\n"],["gethostbyname","TCPSocket","TCPSocket.html#method-c-gethostbyname","(p1)","<p>Use Addrinfo.getaddrinfo instead. This method is deprecated for the following reasons:\n<p>The 3rd element …\n"],["gethostname","Socket","Socket.html#method-c-gethostname","()","<p>Returns the hostname.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">gethostname</span> <span class=\"ruby-comment\">#=&gt; &quot;hal&quot;</span>\n</pre>\n<p>Note that it is not guaranteed to be able to convert …\n"],["getifaddrs","Socket","Socket.html#method-c-getifaddrs","()","<p>Returns an array of interface addresses. An element of the array is an instance of Socket::Ifaddr.\n<p>This …\n"],["getlocal","Time","Time.html#method-i-getlocal","(*args)","<p>Returns a new Time object representing <em>time</em> in local time (using the local time zone in effect for this …\n"],["getlogin","Etc","Etc.html#method-c-getlogin","()","<p>Returns the short user name of the currently logged in user. Unfortunately, it is often rather easy to …\n"],["getname","Resolv","Resolv.html#method-c-getname","(address)","<p>Looks up the hostname of <code>address</code>.\n"],["getname","Resolv","Resolv.html#method-i-getname","(address)","<p>Looks up the hostname of <code>address</code>.\n"],["getname","Resolv::DNS","Resolv/DNS.html#method-i-getname","(address)","<p>Gets the hostname for <code>address</code> from the DNS resolver.\n<p><code>address</code> must be a Resolv::IPv4, Resolv::IPv6 or a …\n"],["getname","Resolv::Hosts","Resolv/Hosts.html#method-i-getname","(address)","<p>Gets the hostname of <code>address</code> from the hosts file.\n"],["getnameinfo","Addrinfo","Addrinfo.html#method-i-getnameinfo","(p1 = v1)","<p>returns nodename and service as a pair of strings. This converts struct sockaddr in addrinfo to textual …\n"],["getnameinfo","Socket","Socket.html#method-c-getnameinfo","(p1, p2 = v2)","<p>Obtains name information for <em>sockaddr</em>.\n<p><em>sockaddr</em> should be one of follows.\n<p>packed sockaddr string such as …\n"],["getnames","Resolv","Resolv.html#method-i-getnames","(address)","<p>Looks up all hostnames for <code>address</code>.\n"],["getnames","Resolv","Resolv.html#method-c-getnames","(address)","<p>Looks up all hostnames for <code>address</code>.\n"],["getnames","Resolv::DNS","Resolv/DNS.html#method-i-getnames","(address)","<p>Gets all hostnames for <code>address</code> from the DNS resolver.\n<p><code>address</code> must be a Resolv::IPv4, Resolv::IPv6 or …\n"],["getnames","Resolv::Hosts","Resolv/Hosts.html#method-i-getnames","(address)","<p>Gets all hostnames for <code>address</code> from the hosts file.\n"],["getok","Net::SMTP","Net/SMTP.html#method-i-getok","(reqline)",""],["getopts","OptionParser","OptionParser.html#method-i-getopts","(*args)","<p>Wrapper method for getopts.rb.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">params</span> = <span class=\"ruby-constant\">ARGV</span>.<span class=\"ruby-identifier\">getopts</span>(<span class=\"ruby-string\">&quot;ab:&quot;</span>, <span class=\"ruby-string\">&quot;foo&quot;</span>, <span class=\"ruby-string\">&quot;bar:&quot;</span>, <span class=\"ruby-string\">&quot;zot:Z;zot option&quot;</span>)\n<span class=\"ruby-comment\"># params[&quot;a&quot;] ...</span>\n</pre>\n"],["getopts","OptionParser","OptionParser.html#method-c-getopts","(*args)","<p>See #getopts.\n"],["getopts","OptionParser::Arguable","OptionParser/Arguable.html#method-i-getopts","(*args)","<p>Substitution of getopts is possible as follows. Also see OptionParser#getopts.\n\n<pre>def getopts(*args)\n  ($OPT ...</pre>\n"],["getpass","IO","IO.html#method-i-getpass","(*args)","<p>Reads and returns a line without echo back. Prints <code>prompt</code> unless it is <code>nil</code>.\n<p>You must require &#39;io/console&#39; …\n"],["getpass","IO::generic_readable","IO/generic_readable.html#method-i-getpass","(*args)","<p>See IO#getpass.\n"],["getpeereid","BasicSocket","BasicSocket.html#method-i-getpeereid","()","<p>Returns the user and group on the peer of the UNIX socket. The result is a two element array which contains …\n"],["getpeername","BasicSocket","BasicSocket.html#method-i-getpeername","()","<p>Returns the remote address of the socket as a sockaddr string.\n\n<pre>TCPServer.open(&quot;127.0.0.1&quot;, 1440) {|serv| ...</pre>\n"],["getpgid","Process","Process.html#method-c-getpgid","(p1)","<p>Returns the process group ID for the given process id. Not available on all platforms.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">getpgid</span>(<span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">ppid</span>()) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["getpgrp","Process","Process.html#method-c-getpgrp","()","<p>Returns the process group ID for this process. Not available on all platforms.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">getpgid</span>(<span class=\"ruby-value\">0</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["getpriority","Process","Process.html#method-c-getpriority","(p1, p2)","<p>Gets the scheduling priority for specified process, process group, or user. <em>kind</em> indicates the kind of …\n"],["getpty","PTY","PTY.html#method-c-getpty","(*args)","<p>Spawns the specified command on a newly allocated pty. You can also use the alias ::getpty.\n<p>The command&#39;s …\n"],["getpwent","Etc","Etc.html#method-c-getpwent","()","<p>Returns an entry from the /etc/passwd file.\n<p>The first time it is called it opens the file and returns …\n"],["getpwnam","Etc","Etc.html#method-c-getpwnam","(p1)","<p>Returns the /etc/passwd information for the user with specified login <code>name</code>.\n<p>The information is returned …\n"],["getpwuid","Etc","Etc.html#method-c-getpwuid","(p1 = v1)","<p>Returns the /etc/passwd information for the user with the given integer <code>uid</code>.\n<p>The information is returned …\n"],["getquota","Net::IMAP","Net/IMAP.html#method-i-getquota","(mailbox)","<p>Sends the GETQUOTA command along with specified <code>mailbox</code>. If this mailbox exists, then an array containing …\n"],["getquotaroot","Net::IMAP","Net/IMAP.html#method-i-getquotaroot","(mailbox)","<p>Sends the GETQUOTAROOT command along with the specified <code>mailbox</code>. This command is generally available …\n"],["getresource","Resolv::DNS","Resolv/DNS.html#method-i-getresource","(name, typeclass)","<p>Look up the <code>typeclass</code> DNS resource of <code>name</code>.\n<p><code>name</code> must be a Resolv::DNS::Name or a String.\n<p><code>typeclass</code> should …\n"],["getresources","Resolv::DNS","Resolv/DNS.html#method-i-getresources","(name, typeclass)","<p>Looks up all <code>typeclass</code> DNS resources for <code>name</code>.  See #getresource for argument details.\n"],["getrlimit","Process","Process.html#method-c-getrlimit","(p1)","<p>Gets the resource limit of the process. <em>cur_limit</em> means current (soft) limit and <em>max_limit</em> means maximum …\n"],["gets","ARGF","ARGF.html#method-i-gets","(*args)","<p>Returns the next line from the current file in <code>ARGF</code>.\n<p>By default lines are assumed to be separated by  …\n"],["gets","CSV","CSV.html#method-i-gets","()",""],["gets","CSV::Parser::UnoptimizedStringIO","CSV/Parser/UnoptimizedStringIO.html#method-i-gets","(*args)",""],["gets","IO","IO.html#method-i-gets","(*args)","<p>Reads the next “line&#39;&#39; from the I/O stream; lines are separated by <em>sep</em>. A separator of <code>nil</code> reads …\n"],["gets","IRB::FileInputMethod","IRB/FileInputMethod.html#method-i-gets","()","<p>Reads the next line from this input method.\n<p>See IO#gets for more information.\n"],["gets","IRB::InputMethod","IRB/InputMethod.html#method-i-gets","()","<p>Reads the next line from this input method.\n<p>See IO#gets for more information.\n"],["gets","IRB::Locale","IRB/Locale.html#method-i-gets","(*rs)",""],["gets","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-i-gets","()","<p>Reads the next line from this input method.\n<p>See IO#gets for more information.\n"],["gets","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-gets","()","<p>Reads the next line from this input method.\n<p>See IO#gets for more information.\n"],["gets","IRB::StdioInputMethod","IRB/StdioInputMethod.html#method-i-gets","()","<p>Reads the next line from this input method.\n<p>See IO#gets for more information.\n"],["gets","Kernel","Kernel.html#method-i-gets","(*args)","<p>Returns (and assigns to <code>$_</code>) the next line from the list of files in <code>ARGV</code> (or <code>$*</code>), or from standard input …\n"],["gets","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-gets","(eol=$/, limit=nil)","<p>Reads the next “line” from the stream.  Lines are separated by <em>eol</em>.  If <em>limit</em> is provided the …\n"],["gets","StringIO","StringIO.html#method-i-gets","(*args)","<p>See IO#gets.\n"],["gets","XMP::StringInputMethod","XMP/StringInputMethod.html#method-i-gets","()","<p>Reads the next expression from this printer.\n<p>See IO#gets for more information.\n"],["gets","Zlib::GzipReader","Zlib/GzipReader.html#method-i-gets","(*args)","<p>See Zlib::GzipReader documentation for a description.\n"],["getservbyname","Socket","Socket.html#method-c-getservbyname","(p1, p2 = v2)","<p>Obtains the port number for <em>service_name</em>.\n<p>If <em>protocol_name</em> is not given, “tcp” is assumed.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">getservbyname</span>(<span class=\"ruby-string\">&quot;smtp&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["getservbyport","Socket","Socket.html#method-c-getservbyport","(p1, p2 = v2)","<p>Obtains the port number for <em>port</em>.\n<p>If <em>protocol_name</em> is not given, “tcp” is assumed.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">getservbyport</span>(<span class=\"ruby-value\">80</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["getservername","WEBrick::Utils","WEBrick/Utils.html#method-i-getservername","()","<p>The server hostname\n"],["getservername","WEBrick::Utils","WEBrick/Utils.html#method-c-getservername","()","<p>The server hostname\n"],["getsid","Process","Process.html#method-c-getsid","(*args)","<p>Returns the session ID for the given process id. If not given, return current process sid. Not available …\n"],["getsockname","BasicSocket","BasicSocket.html#method-i-getsockname","()","<p>Returns the local address of the socket as a sockaddr string.\n\n<pre>TCPServer.open(&quot;127.0.0.1&quot;, 15120) {|serv| ...</pre>\n"],["getsockopt","BasicSocket","BasicSocket.html#method-i-getsockopt","(p1, p2)","<p>Gets a socket option. These are protocol and system specific, see your local system documentation for …\n"],["getsockopt","OpenSSL::SSL::SocketForwarder","OpenSSL/SSL/SocketForwarder.html#method-i-getsockopt","(level, optname)",""],["getter","RSS::BaseListener","RSS/BaseListener.html#method-c-getter","(uri, tag_name)",""],["gettextfile","Net::FTP","Net/FTP.html#method-i-gettextfile","(remotefile, localfile = File.basename(remotefile))","<p>Retrieves <code>remotefile</code> in ASCII (text) mode, storing the result in <code>localfile</code>. If <code>localfile</code> is nil, returns …\n"],["getuid","Process::Sys","Process/Sys.html#method-c-getuid","()","<p>Returns the (real) user ID of this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">uid</span>   <span class=\"ruby-comment\">#=&gt; 501</span>\n</pre>\n"],["getutc","Time","Time.html#method-i-getutc","()","<p>Returns a new Time object representing <em>time</em> in UTC.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">20</span>,<span class=\"ruby-value\">15</span>,<span class=\"ruby-value\">1</span>)   <span class=\"ruby-comment\">#=&gt; 2000-01-01 ...</span>\n</pre>\n"],["getwd","Bundler::FileUtils","Bundler/FileUtils.html#method-c-getwd","()",""],["getwd","Bundler::FileUtils","Bundler/FileUtils.html#method-i-getwd","()",""],["getwd","Dir","Dir.html#method-c-getwd","()","<p>Returns the path to the current working directory of this process as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">chdir</span>(<span class=\"ruby-string\">&quot;/tmp&quot;</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["getwd","FileUtils","FileUtils.html#method-c-getwd","()",""],["getwd","FileUtils","FileUtils.html#method-i-getwd","()",""],["getwd","Pathname","Pathname.html#method-c-getwd","()","<p>Returns the current working directory as a Pathname.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">getwd</span>\n    <span class=\"ruby-comment\">#=&gt; #&lt;Pathname:/home/zzak/projects/ruby&gt;</span>\n</pre>\n"],["gid","File::Stat","File/Stat.html#method-i-gid","()","<p>Returns the numeric group id of the owner of <em>stat</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">gid</span>   <span class=\"ruby-comment\">#=&gt; 500</span>\n</pre>\n"],["gid","Process","Process.html#method-c-gid","()","<p>Returns the (real) group ID for this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">gid</span>   <span class=\"ruby-comment\">#=&gt; 500</span>\n</pre>\n"],["gid=","Process","Process.html#method-c-gid-3D","(p1)","<p>Sets the group ID for this process.\n"],["git","Bundler::Dsl","Bundler/Dsl.html#method-i-git","(uri, options = {}, &blk)",""],["git","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-git","(command, check_errors = true, error_msg = nil)",""],["git","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-git","(repository)","<p>Block form for specifying gems from a git <code>repository</code>.\n\n<pre>git &#39;https://github.com/rails/rails.git&#39; do\n  gem ...</pre>\n"],["git_commit_sha","Bundler::BuildMetadata","Bundler/BuildMetadata.html#method-c-git_commit_sha","()","<p>The SHA for the git commit the bundler gem was built from.\n"],["git_gem","Gem::TestCase","Gem/TestCase.html#method-i-git_gem","(name = 'a', version = 1)","<p>A git_gem is used with a gem dependencies file.  The gem created here has no files, just a gem specification …\n"],["git_null","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-git_null","(command)",""],["git_path","Gem::Commands::EnvironmentCommand","Gem/Commands/EnvironmentCommand.html#method-i-git_path","()","<p>Git binary path\n"],["git_present?","Bundler","Bundler.html#method-c-git_present-3F","()",""],["git_proxy","Bundler::Source::Git","Bundler/Source/Git.html#method-i-git_proxy","()",""],["git_push","Bundler::GemHelper","Bundler/GemHelper.html#method-i-git_push","(remote = \"\")",""],["git_retry","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-git_retry","(command)",""],["git_scope","Bundler::Source::Git","Bundler/Source/Git.html#method-i-git_scope","()",""],["git_source","Bundler::Dsl","Bundler/Dsl.html#method-i-git_source","(name, &block)",""],["git_source","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-git_source","(name, &callback)","<p>Defines a custom git source that uses <code>name</code> to expand git repositories for use in gems built from git …\n"],["git_version","Bundler::Env","Bundler/Env.html#method-c-git_version","()",""],["git_version","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-git_version","()",""],["git_version","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-git_version","()",""],["git_version","Gem::Specification","Gem/Specification.html#method-i-git_version","()",""],["github","Bundler::Dsl","Bundler/Dsl.html#method-i-github","(repo, options = {})",""],["github","RDoc::Markdown","RDoc/Markdown.html#method-i-github","","<p>Allow Github Flavored Markdown\n"],["glob","Dir","Dir.html#method-c-glob","(p1, p2 = v2, p3 = {})","<p>Expands <code>pattern</code>, which is a pattern string or an Array of pattern strings, and returns an array containing …\n"],["glob","Pathname","Pathname.html#method-i-glob","(p1, p2 = v2)","<p>Returns or yields Pathname objects.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Pathname</span>(<span class=\"ruby-string\">&quot;ruby-2.4.2&quot;</span>).<span class=\"ruby-identifier\">glob</span>(<span class=\"ruby-string\">&quot;R*.md&quot;</span>)\n<span class=\"ruby-comment\">#=&gt; [#&lt;Pathname:ruby-2.4.2/README.md&gt;, ...</span>\n</pre>\n"],["glob","Pathname","Pathname.html#method-c-glob","(p1, p2 = v2, p3 = v3)","<p>Returns or yields Pathname objects.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">glob</span>(<span class=\"ruby-string\">&quot;lib/i*.rb&quot;</span>)\n    <span class=\"ruby-comment\">#=&gt; [#&lt;Pathname:lib/ipaddr.rb&gt;, #&lt;Pathname:lib/irb.rb&gt;]</span>\n</pre>\n"],["glob_files_in_dir","Gem::Util","Gem/Util.html#method-c-glob_files_in_dir","(glob, base_path)","<p>Globs for files matching <code>pattern</code> inside of <code>directory</code>, returning absolute paths to the matching files. …\n"],["glob_pattern","Bundler::Thor::LineEditor::Readline::PathCompletion","Bundler/Thor/LineEditor/Readline/PathCompletion.html#method-i-glob_pattern","()",""],["global_config_file","Bundler::Settings","Bundler/Settings.html#method-i-global_config_file","()",""],["global_index_file","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-global_index_file","()","<p>Path where the global index file is stored\n"],["global_root","Bundler::Plugin","Bundler/Plugin.html#method-i-global_root","()","<p>The global directory root for all plugin related data\n"],["global_rubygems_source=","Bundler::SourceList","Bundler/SourceList.html#method-i-global_rubygems_source-3D","(uri)",""],["global_variables","Kernel","Kernel.html#method-i-global_variables","()","<p>Returns an array of the names of global variables.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">global_variables</span>.<span class=\"ruby-identifier\">grep</span> <span class=\"ruby-regexp\">/std/</span>   <span class=\"ruby-comment\">#=&gt; [:$stdin, :$stdout, ...</span>\n</pre>\n"],["globs_for","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-globs_for","(path)","<p>Where to look for Bundler::Thor files.\n"],["gm","Time","Time.html#method-c-gm","(*args)","<p>Creates a Time object based on given values, interpreted as UTC (GMT). The year must be specified. Other …\n"],["gmt?","Time","Time.html#method-i-gmt-3F","()","<p>Returns <code>true</code> if <em>time</em> represents a time in UTC (GMT).\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>                        <span class=\"ruby-comment\">#=&gt; 2007-11-19 ...</span>\n</pre>\n"],["gmt_offset","Time","Time.html#method-i-gmt_offset","()","<p>Returns the offset in seconds between the timezone of <em>time</em> and UTC.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">gm</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">20</span>,<span class=\"ruby-value\">15</span>,<span class=\"ruby-value\">1</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["gmtime","Time","Time.html#method-i-gmtime","()","<p>Converts <em>time</em> to UTC (GMT), modifying the receiver.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:18:31 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">gmt?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["gmtoff","Time","Time.html#method-i-gmtoff","()","<p>Returns the offset in seconds between the timezone of <em>time</em> and UTC.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">gm</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">20</span>,<span class=\"ruby-value\">15</span>,<span class=\"ruby-value\">1</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["goto","IO","IO.html#method-i-goto","(p1, p2)",""],["goto_column","IO","IO.html#method-i-goto_column","(p1)",""],["goto_id","Racc::Shift","Racc/Shift.html#method-i-goto_id","()",""],["grammar","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-grammar","()",""],["grant_privilege","Process::GID","Process/GID.html#method-c-grant_privilege","(p1)","<p>Set the effective group ID, and if possible, the saved group ID of the process to the given <em>group</em>. Returns …\n"],["grant_privilege","Process::UID","Process/UID.html#method-c-grant_privilege","(p1)","<p>Set the effective user ID, and if possible, the saved user ID of the process to the given <em>user</em>. Returns …\n"],["grapheme_clusters","String","String.html#method-i-grapheme_clusters","()","<p>Returns an array of grapheme clusters in <em>str</em>.  This is a shorthand for <code>str.each_grapheme_cluster.to_a</code> …\n"],["great_job","RDoc::Stats","RDoc/Stats.html#method-i-great_job","()","<p>A report that says you did a great job!\n"],["gregorian","Date","Date.html#method-i-gregorian","()","<p>This method is equivalent to new_start(Date::GREGORIAN).\n"],["gregorian?","Date","Date.html#method-i-gregorian-3F","()","<p>Returns true if the date is on or after the day of calendar reform.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">1582</span>,<span class=\"ruby-value\">10</span>,<span class=\"ruby-value\">15</span>).<span class=\"ruby-identifier\">gregorian?</span>   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["gregorian_leap?","Date","Date.html#method-c-gregorian_leap-3F","(p1)","<p>Returns true if the given year is a leap year of the proleptic Gregorian calendar.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">gregorian_leap?</span>(<span class=\"ruby-value\">1900</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["grep","Enumerable","Enumerable.html#method-i-grep","(p1)","<p>Returns an array of every element in <em>enum</em> for which <code>Pattern === element</code>. If the optional <em>block</em> is supplied, …\n"],["grep","Enumerator::Lazy","Enumerator/Lazy.html#method-i-grep","(p1)","<p>Like Enumerable#grep, but chains operation to be lazy-evaluated.\n"],["grep_v","Enumerable","Enumerable.html#method-i-grep_v","(p1)","<p>Inverted version of Enumerable#grep. Returns an array of every element in <em>enum</em> for which not <code>Pattern</code> …\n"],["grep_v","Enumerator::Lazy","Enumerator/Lazy.html#method-i-grep_v","(p1)","<p>Like Enumerable#grep_v, but chains operation to be lazy-evaluated.\n"],["group","Bundler::Dsl","Bundler/Dsl.html#method-i-group","(*args, &blk)",""],["group","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-group","(name = nil)","<p>Defines the group. This is used when thor list is invoked so you can specify that only commands from …\n"],["group","Etc","Etc.html#method-c-group","()","<p>Provides a convenient Ruby iterator which executes a block for each entry in the /etc/group file.\n<p>The …\n"],["group","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-group","(*groups)","<p>Block form for placing a dependency in the given <code>groups</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">group</span> <span class=\"ruby-value\">:development</span> <span class=\"ruby-keyword\">do</span>\n  <span class=\"ruby-identifier\">gem</span> <span class=\"ruby-string\">&#39;debugger&#39;</span>\n<span class=\"ruby-keyword\">end</span>\n\n<span class=\"ruby-identifier\">group</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["group","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-group","()","<p>Returns the EC::Group that the key is associated with. Modifying the returned group does not affect  …\n"],["group","PrettyPrint","PrettyPrint.html#method-i-group","(indent=0, open_obj='', close_obj='', open_width=open_obj.length, close_width=close_obj.length)","<p>Groups line break hints added in the block. The line break hints are all to be used or not.\n<p>If <code>indent</code> …\n"],["group","PrettyPrint::SingleLine","PrettyPrint/SingleLine.html#method-i-group","(indent=nil, open_obj='', close_obj='', open_width=nil, close_width=nil)","<p>Opens a block for grouping objects to be pretty printed.\n<p>Arguments:\n<p><code>indent</code> - noop argument. Present for …\n"],["group","Thread","Thread.html#method-i-group","()","<p>Returns the ThreadGroup which contains the given thread, or returns <code>nil</code> if <code>thr</code> is not a member of any …\n"],["group=","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-group-3D","(p1)","<p>Sets the EC::Group for the key. The group structure is internally copied so modification to <em>group</em> after …\n"],["group_by","Enumerable","Enumerable.html#method-i-group_by","()","<p>Groups the collection by result of the block.  Returns a hash where the keys are the evaluated result …\n"],["group_entries","RDoc::Parser::ChangeLog","RDoc/Parser/ChangeLog.html#method-i-group_entries","(entries)","<p>Groups <code>entries</code> by date.\n"],["group_possibilities","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-group_possibilities","(possibilities)","<p>Build an array of PossibilitySets, with each element representing a group of dependency versions that …\n"],["group_sub","PrettyPrint","PrettyPrint.html#method-i-group_sub","()","<p>Takes a block and queues a new group that is indented 1 level further.\n"],["groups","Bundler::Definition","Bundler/Definition.html#method-i-groups","()",""],["groups","Gem::Specification","Gem/Specification.html#method-i-groups","()",""],["groups","Process","Process.html#method-c-groups","()","<p>Get an Array of the group IDs in the supplemental group access list for this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">groups</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["groups=","Process","Process.html#method-c-groups-3D","(p1)","<p>Set the supplemental group access list to the given Array of group IDs.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">groups</span>   <span class=\"ruby-comment\">#=&gt; [0, 1, 2, ...</span>\n</pre>\n"],["groups_text","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-groups_text","(group_text, groups)",""],["grpowned?","File","File.html#method-c-grpowned-3F","(p1)","<p>Returns <code>true</code> if the named file exists and the effective group id of the calling process is the owner …\n"],["grpowned?","File::Stat","File/Stat.html#method-i-grpowned-3F","()","<p>Returns true if the effective group id of the process is the same as the group id of <em>stat</em>. On Windows …\n"],["grpowned?","FileTest","FileTest.html#method-i-grpowned-3F","(p1)","<p>Returns <code>true</code> if the named file exists and the effective group id of the calling process is the owner …\n"],["grpowned?","Pathname","Pathname.html#method-i-grpowned-3F","()","<p>See FileTest.grpowned?.\n"],["gsub","Kernel","Kernel.html#method-i-gsub","(*args)","<p>Equivalent to <code>$_.gsub...</code>, except that <code>$_</code> will be updated if substitution occurs. Available only when …\n"],["gsub","String","String.html#method-i-gsub","(*args)","<p>Returns a copy of <em>str</em> with <em>all</em> occurrences of <em>pattern</em> substituted for the second argument. The <em>pattern</em> …\n"],["gsub!","String","String.html#method-i-gsub-21","(*args)","<p>Performs the substitutions of String#gsub in place, returning <em>str</em>, or <code>nil</code> if no substitutions were performed. …\n"],["gsub_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-gsub_file","(path, flag, *args, &block)","<p>Run a regular expression replacement on a file.\n<p>Parameters\n<p>path&lt;String&gt; &mdash; path of the file to be changed …\n"],["guard_clean","Bundler::GemHelper","Bundler/GemHelper.html#method-i-guard_clean","()",""],["guard_inspect_key","PP::PPMethods","PP/PPMethods.html#method-i-guard_inspect_key","()","<p>Yields to a block and preserves the previous set of objects being printed.\n"],["guess","Kconv","Kconv.html#method-i-guess","(str)","<p>Guess input encoding by NKF.guess\n"],["guess","Kconv","Kconv.html#method-c-guess","(str)","<p>Guess input encoding by NKF.guess\n"],["guess","NKF","NKF.html#method-c-guess","(p1)","<p>Returns guessed encoding of <em>str</em> by nkf routine.\n"],["guess","OptionParser::Switch","OptionParser/Switch.html#method-c-guess","(arg)","<p>Guesses argument style from <code>arg</code>.  Returns corresponding OptionParser::Switch class (OptionalArgument …\n"],["guess_type","RSS::XMLStyleSheet","RSS/XMLStyleSheet.html#method-i-guess_type","(filename)",""],["guess_type_if_need","RSS::Maker::XMLStyleSheets::XMLStyleSheet","RSS/Maker/XMLStyleSheets/XMLStyleSheet.html#method-i-guess_type_if_need","(xss)",""],["guid","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-guid","()","<p>Returns GUID.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Application&#39;</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-identifier\">tobj</span>.<span class=\"ruby-identifier\">guid</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["guid","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-guid","()","<p>Returns guid string which specifies type library.\n\n<pre>tlib = WIN32OLE_TYPELIB.new(&#39;Microsoft Excel 9.0 Object ...</pre>\n"],["gunzip","Gem","Gem.html#method-c-gunzip","(data)","<p>Zlib::GzipReader wrapper that unzips <code>data</code>.\n"],["gunzip","Gem::Util","Gem/Util.html#method-c-gunzip","(data)","<p>Zlib::GzipReader wrapper that unzips <code>data</code>.\n"],["gunzip","Zlib","Zlib.html#method-c-gunzip","(p1)","<p>Decode the given gzipped <code>string</code>.\n<p>This method is almost equivalent to the following code:\n\n<pre>def gunzip(string) ...</pre>\n"],["gzip","Gem","Gem.html#method-c-gzip","(data)","<p>Zlib::GzipWriter wrapper that zips <code>data</code>.\n"],["gzip","Gem::Indexer","Gem/Indexer.html#method-i-gzip","(filename)","<p>Zlib::GzipWriter wrapper that gzips <code>filename</code> on disk.\n"],["gzip","Gem::Util","Gem/Util.html#method-c-gzip","(data)","<p>Zlib::GzipWriter wrapper that zips <code>data</code>.\n"],["gzip","Zlib","Zlib.html#method-c-gzip","(p1)","<p>Gzip the given <code>string</code>. Valid values of level are Zlib::NO_COMPRESSION, Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION …\n"],["gzip_to","Gem::Package","Gem/Package.html#method-i-gzip_to","(io)","<p>Gzips content written to <code>gz_io</code> to <code>io</code>.\n"],["h","CGI::Util","CGI/Util.html#method-i-h","(string)",""],["h","ERB::Util","ERB/Util.html#method-c-h","(s)",""],["h","ERB::Util","ERB/Util.html#method-i-h","(s)",""],["h","RSS::Utils","RSS/Utils.html#method-i-h","(s)",""],["hadamard_product","Matrix","Matrix.html#method-i-hadamard_product","(m)","<p>Hadamard product\n\n<pre>Matrix[[1,2], [3,4]].hadamard_product(Matrix[[1,2], [3,2]])\n  =&gt; 1  4\n     9  8</pre>\n"],["handle","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-handle","( symbol, *arguments )",""],["handle_argument_error?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-handle_argument_error-3F","(instance, error, caller)",""],["handle_argument_error?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-handle_argument_error-3F","(instance, error, caller)",""],["handle_arguments","Gem::ConfigFile","Gem/ConfigFile.html#method-i-handle_arguments","(arg_list)","<p>Handle the command arguments.\n"],["handle_attr","RDoc::Parser::C","RDoc/Parser/C.html#method-i-handle_attr","(var_name, attr_name, read, write)","<p>Creates a new RDoc::Attr <code>attr_name</code> on class <code>var_name</code> that is either <code>read</code>, <code>write</code> or both\n"],["handle_class_module","RDoc::Parser::C","RDoc/Parser/C.html#method-i-handle_class_module","(var_name, type, class_name, parent, in_module)","<p>Creates a new RDoc::NormalClass or RDoc::NormalModule based on <code>type</code> named <code>class_name</code> in <code>parent</code> which …\n"],["handle_constants","RDoc::Parser::C","RDoc/Parser/C.html#method-i-handle_constants","(type, var_name, const_name, definition)","<p>Adds constants.  By providing some_value: at the start of the comment you can override the C value of …\n"],["handle_entitydecl","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-handle_entitydecl","( event )",""],["handle_error","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-handle_error","()",""],["handle_exception","IRB::Irb","IRB/Irb.html#method-i-handle_exception","(exc)",""],["handle_ifdefs_in","RDoc::Parser::C","RDoc/Parser/C.html#method-i-handle_ifdefs_in","(body)","<p>Removes #ifdefs that would otherwise confuse us\n"],["handle_interrupt","Thread","Thread.html#method-c-handle_interrupt","(p1)","<p>Changes asynchronous interrupt timing.\n<p><em>interrupt</em> means asynchronous event and corresponding procedure …\n"],["handle_method","RDoc::Parser::C","RDoc/Parser/C.html#method-i-handle_method","(type, var_name, meth_name, function, param_count, source_file = nil)","<p>Adds an RDoc::AnyMethod <code>meth_name</code> defined on a class or module assigned to <code>var_name</code>.  <code>type</code> is the type …\n"],["handle_missing_or_push_dependency_state","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-handle_missing_or_push_dependency_state","(state)","<p>Pushes a new {DependencyState}. If the {#specification_provider} says to {SpecificationProvider#allow_missing?} …\n"],["handle_missing_or_push_dependency_state","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-handle_missing_or_push_dependency_state","(state)","<p>Pushes a new {DependencyState}. If the {#specification_provider} says to {SpecificationProvider#allow_missing?} …\n"],["handle_no_command_error","Bundler::CLI","Bundler/CLI.html#method-c-handle_no_command_error","(command, has_namespace = $thor_runner)",""],["handle_no_method_error?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-handle_no_method_error-3F","(instance, error, caller)",""],["handle_no_method_error?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-handle_no_method_error-3F","(instance, error, caller)",""],["handle_options","Gem::Command","Gem/Command.html#method-i-handle_options","(args)","<p>Handle the given list of arguments by parsing them and recording the results.\n"],["handle_pipe","RDoc::RDoc","RDoc/RDoc.html#method-i-handle_pipe","()","<p>Turns RDoc from stdin into HTML\n"],["handle_singleton","RDoc::Parser::C","RDoc/Parser/C.html#method-i-handle_singleton","(sclass_var, class_var)","<p>Registers a singleton class <code>sclass_var</code> as a singleton of <code>class_var</code>\n"],["handle_tab_width","RDoc::Parser::C","RDoc/Parser/C.html#method-i-handle_tab_width","(body)","<p>Normalizes tabs in <code>body</code>\n"],["handler","Fiddle::Importer","Fiddle/Importer.html#method-i-handler","()","<p>The Fiddle::CompositeHandler instance\n<p>Will raise an error if no handlers are open.\n"],["handler","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-i-handler","()","<p>returns handler object.\n"],["handler=","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-i-handler-3D","(p1)","<p>sets event handler object. If handler object has onXXX method according to XXX event, then onXXX method …\n"],["handlers","Fiddle::CompositeHandler","Fiddle/CompositeHandler.html#method-i-handlers","()","<p>Array of the currently loaded libraries.\n"],["handles?","Gem::Command","Gem/Command.html#method-i-handles-3F","(args)","<p>True if the command handles the given argument list.\n"],["has_app_cache?","Bundler::Source::Git","Bundler/Source/Git.html#method-i-has_app_cache-3F","()",""],["has_app_cache?","Bundler::Source::Path","Bundler/Source/Path.html#method-i-has_app_cache-3F","()",""],["has_attributes?","REXML::Element","REXML/Element.html#method-i-has_attributes-3F","()","<p>Evaluates to <code>true</code> if this element has any attributes set, false otherwise.\n"],["has_conflicts?","Gem::Specification","Gem/Specification.html#method-i-has_conflicts-3F","()","<p>Return true if there are possible conflicts against the currently loaded specs.\n"],["has_elements?","REXML::Element","REXML/Element.html#method-i-has_elements-3F","()","<p>Evaluates to <code>true</code> if this element has at least one child Element\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">doc</span> = <span class=\"ruby-constant\">Document</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-string\">&quot;&lt;a&gt;&lt;b/&gt;&lt;c&gt;Text&lt;/c&gt;&lt;/a&gt;&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["has_expires?","Rinda::TupleBag","Rinda/TupleBag.html#method-i-has_expires-3F","()","<p><code>true</code> if the TupleBag to see if it has any expired entries.\n"],["has_key?","CGI::QueryExtension","CGI/QueryExtension.html#method-i-has_key-3F","(*args)","<p>Returns true if a given query string parameter exists.\n"],["has_key?","CSV::Row","CSV/Row.html#method-i-has_key-3F","(header)","<p>Returns <code>true</code> if there is a field with the given <code>header</code>.\n"],["has_key?","DBM","DBM.html#method-i-has_key-3F","(p1)","<p>Returns true if the database contains the specified key, false otherwise.\n"],["has_key?","ENV","ENV.html#method-c-has_key-3F","(p1)","<p>ENV.has_key?, ENV.member?, and ENV.key? are aliases for ENV.include?.\n<p>Returns <code>true</code> if there is an environment …\n"],["has_key?","GDBM","GDBM.html#method-i-has_key-3F","(p1)","<p>Returns true if the given key <em>k</em> exists within the database. Returns false otherwise.\n"],["has_key?","Hash","Hash.html#method-i-has_key-3F","(p1)","<p>Returns <code>true</code> if the given key is present in <em>hsh</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;b&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">200</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">has_key?</span>(<span class=\"ruby-string\">&quot;a&quot;</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["has_key?","SDBM","SDBM.html#method-i-has_key-3F","(p1)","<p>Returns <code>true</code> if the database contains the given <code>key</code>.\n"],["has_local_dependencies?","Bundler::Definition","Bundler/Definition.html#method-i-has_local_dependencies-3F","()",""],["has_name?","REXML::Light::Node","REXML/Light/Node.html#method-i-has_name-3F","( name, namespace = '' )",""],["has_name?","REXML::Namespace","REXML/Namespace.html#method-i-has_name-3F","( other, ns=nil )","<p>Compares names optionally WITH namespaces\n"],["has_next?","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-has_next-3F","()","<p>Returns true if there are more events.  Synonymous with !empty?\n"],["has_post_install_message?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-has_post_install_message-3F","()",""],["has_revision_cached?","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-has_revision_cached-3F","()",""],["has_rubygems_remotes?","Bundler::Definition","Bundler/Definition.html#method-i-has_rubygems_remotes-3F","()",""],["has_text?","REXML::Element","REXML/Element.html#method-i-has_text-3F","()","<p>Evaluates to <code>true</code> if this element has at least one Text child\n"],["has_value?","DBM","DBM.html#method-i-has_value-3F","(p1)","<p>Returns true if the database contains the specified string value, false otherwise.\n"],["has_value?","ENV","ENV.html#method-c-has_value-3F","(p1)","<p>Returns <code>true</code> if there is an environment variable with the given <code>value</code>.\n"],["has_value?","GDBM","GDBM.html#method-i-has_value-3F","(p1)","<p>Returns true if the given value <em>v</em> exists within the database. Returns false otherwise.\n"],["has_value?","Hash","Hash.html#method-i-has_value-3F","(p1)","<p>Returns <code>true</code> if the given value is present for some key in <em>hsh</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;b&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">200</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">value?</span>(<span class=\"ruby-value\">100</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["has_value?","SDBM","SDBM.html#method-i-has_value-3F","(p1)","<p>Returns <code>true</code> if the database contains the given <code>value</code>.\n"],["has_value?","YAML::DBM","YAML/DBM.html#method-i-has_value-3F","( val )","<p>Returns true if specified <code>value</code> is found in the database.\n"],["hash","Array","Array.html#method-i-hash","()","<p>Compute a hash-code for this array.\n<p>Two arrays with the same content will have the same hash code (and …\n"],["hash","BigDecimal","BigDecimal.html#method-i-hash","()","<p>Creates a hash for this BigDecimal.\n<p>Two BigDecimals with equal sign, fractional part and exponent have …\n"],["hash","Bundler::DepProxy","Bundler/DepProxy.html#method-i-hash","()",""],["hash","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-hash","()","<p>@return [Fixnum] a hash for the vertex based upon its {#name}\n"],["hash","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-hash","()","<p>When overriding `hash` please preserve the behaviour as mentioned in docstring for `==` method, i.e. …\n"],["hash","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-hash","()",""],["hash","Bundler::Source::Git","Bundler/Source/Git.html#method-i-hash","()",""],["hash","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-hash","()",""],["hash","Bundler::Source::Path","Bundler/Source/Path.html#method-i-hash","()",""],["hash","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-hash","()",""],["hash","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-hash","()",""],["hash","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-hash","()","<p>Compute a hash-value for this arithmetic sequence. Two arithmetic sequences with same begin, end, step, …\n"],["hash","Float","Float.html#method-i-hash","()","<p>Returns a hash code for this float.\n<p>See also Object#hash.\n"],["hash","Gem::NameTuple","Gem/NameTuple.html#method-i-hash","()",""],["hash","Gem::Platform","Gem/Platform.html#method-i-hash","()",""],["hash","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-hash","()","<p>@return [Fixnum] a hash for the vertex based upon its {#name}\n"],["hash","Hash","Hash.html#method-i-hash","()","<p>Compute a hash-code for this hash. Two hashes with the same content will have the same hash code (and …\n"],["hash","IPAddr","IPAddr.html#method-i-hash","()","<p>Returns a hash value used by Hash, Set, and Array classes\n"],["hash","MatchData","MatchData.html#method-i-hash","()","<p>Produce a hash based on the target string, regexp and matched positions of this matchdata.\n<p>See also Object#hash …\n"],["hash","Matrix","Matrix.html#method-i-hash","()","<p>Returns a hash-code for the matrix.\n"],["hash","Method","Method.html#method-i-hash","()","<p>Returns a hash value corresponding to the method object.\n<p>See also Object#hash.\n"],["hash","Object","Object.html#method-i-hash","()","<p>Generates an Integer hash value for this object.  This function must have the property that <code>a.eql?(b)</code> …\n"],["hash","OpenSSL::BN","OpenSSL/BN.html#method-i-hash","()","<p>Returns a hash code for this object.\n<p>See also Object#hash.\n"],["hash","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-hash","()","<p>The hash value returned is suitable for use as a certificate&#39;s filename in a CA path.\n"],["hash","OpenStruct","OpenStruct.html#method-i-hash","()","<p>Computes a hash code for this OpenStruct. Two OpenStruct objects with the same content will have the …\n"],["hash","Proc","Proc.html#method-i-hash","()","<p>Returns a hash value corresponding to proc body.\n<p>See also Object#hash.\n"],["hash","RDoc::TopLevel","RDoc/TopLevel.html#method-i-hash","()","<p>An RDoc::TopLevel has the same hash as another with the same relative_name\n"],["hash","REXML::Attribute","REXML/Attribute.html#method-i-hash","()","<p>Creates (and returns) a hash from both the name and value\n"],["hash","Range","Range.html#method-i-hash","()","<p>Compute a hash-code for this range. Two ranges with equal begin and end points (using <code>eql?</code>), and the …\n"],["hash","Regexp","Regexp.html#method-i-hash","()","<p>Produce a hash based on the text and options of this regular expression.\n<p>See also Object#hash.\n"],["hash","String","String.html#method-i-hash","()","<p>Returns a hash based on the string&#39;s length, content and encoding.\n<p>See also Object#hash.\n"],["hash","Struct","Struct.html#method-i-hash","()","<p>Returns a hash value based on this struct&#39;s contents.\n<p>See also Object#hash.\n"],["hash","Time","Time.html#method-i-hash","()","<p>Returns a hash code for this Time object.\n<p>See also Object#hash.\n"],["hash","URI::Generic","URI/Generic.html#method-i-hash","()",""],["hash","UnboundMethod","UnboundMethod.html#method-i-hash","()","<p>Returns a hash value corresponding to the method object.\n<p>See also Object#hash.\n"],["hash","Vector","Vector.html#method-i-hash","()","<p>Returns a hash-code for the vector.\n"],["hash=","Racc::Rule","Racc/Rule.html#method-i-hash-3D","(n)",""],["hash?","Rinda::Tuple","Rinda/Tuple.html#method-i-hash-3F","(ary_or_hash)",""],["hash_algorithm","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-hash_algorithm","()","<p>Returns the ln (long name) of the hash algorithm used to generate the issuerNameHash and the issuerKeyHash …\n"],["hash_old","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-hash_old","()","<p>Returns an MD5 based hash used in OpenSSL 0.9.X.\n"],["have_author?","RSS::Atom::Entry","RSS/Atom/Entry.html#method-i-have_author-3F","()","<p>Returns where there are any authors present or there is a source with an author.\n"],["have_author?","RSS::Atom::Feed","RSS/Atom/Feed.html#method-i-have_author-3F","()","<p>Returns true if there are any authors for the feed or any of the Entry child elements have an author …\n"],["have_author?","RSS::Atom::Feed::Entry","RSS/Atom/Feed/Entry.html#method-i-have_author-3F","(check_parent=true)","<p>Returns whether any of the following are true:\n<p>There are any authors in the feed\n<p>If the parent element …\n"],["have_author?","RSS::Atom::Feed::Entry::Source","RSS/Atom/Feed/Entry/Source.html#method-i-have_author-3F","()","<p>Returns true if the Source element has an author.\n"],["have_children_elements","RSS::Element","RSS/Element.html#method-c-have_children_elements","()",""],["have_const","MakeMakefile","MakeMakefile.html#method-i-have_const","(const, headers = nil, opt = \"\", &b)","<p>Returns whether or not the constant <code>const</code> is defined.  You may optionally pass the <code>type</code> of <code>const</code> as  …\n"],["have_content?","RSS::Element","RSS/Element.html#method-c-have_content-3F","()",""],["have_devel?","MakeMakefile","MakeMakefile.html#method-i-have_devel-3F","()",""],["have_extensions?","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-have_extensions-3F","()",""],["have_file?","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-have_file-3F","(file, suffixes)",""],["have_framework","MakeMakefile","MakeMakefile.html#method-i-have_framework","(fw, &b)","<p>Returns whether or not the given <code>framework</code> can be found on your system. If found, a macro is passed as …\n"],["have_func","MakeMakefile","MakeMakefile.html#method-i-have_func","(func, headers = nil, opt = \"\", &b)","<p>Returns whether or not the function <code>func</code> can be found in the common header files, or within any <code>headers</code> …\n"],["have_git?","Gem::TestCase","Gem/TestCase.html#method-i-have_git-3F","()","<p>Skips this test unless you have a git executable\n"],["have_header","MakeMakefile","MakeMakefile.html#method-i-have_header","(header, preheaders = nil, opt = \"\", &b)","<p>Returns whether or not the given <code>header</code> file can be found on your system. If found, a macro is passed …\n"],["have_library","MakeMakefile","MakeMakefile.html#method-i-have_library","(lib, func = nil, headers = nil, opt = \"\", &b)","<p>Returns whether or not the given entry point <code>func</code> can be found within <code>lib</code>.  If <code>func</code> is <code>nil</code>, the <code>main()</code> …\n"],["have_macro","MakeMakefile","MakeMakefile.html#method-i-have_macro","(macro, headers = nil, opt = \"\", &b)","<p>Returns whether or not <code>macro</code> is defined either in the common header files or within any <code>headers</code> you provide. …\n"],["have_option?","Bundler::FileUtils","Bundler/FileUtils.html#method-c-have_option-3F","(mid, opt)","<p>Returns true if the method <code>mid</code> have an option <code>opt</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">have_option?</span>(<span class=\"ruby-value\">:cp</span>, <span class=\"ruby-value\">:noop</span>)     <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["have_option?","FileUtils","FileUtils.html#method-c-have_option-3F","(mid, opt)","<p>Returns true if the method <code>mid</code> have an option <code>opt</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">have_option?</span>(<span class=\"ruby-value\">:cp</span>, <span class=\"ruby-value\">:noop</span>)     <span class=\"ruby-comment\">#=&gt; true</span>\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["have_rdoc_4_plus?","Gem::Server","Gem/Server.html#method-i-have_rdoc_4_plus-3F","()",""],["have_required_elements?","RSS::Atom::Entry","RSS/Atom/Entry.html#method-i-have_required_elements-3F","()",""],["have_required_elements?","RSS::Atom::Feed","RSS/Atom/Feed.html#method-i-have_required_elements-3F","()",""],["have_required_elements?","RSS::Atom::Feed::Entry","RSS/Atom/Feed/Entry.html#method-i-have_required_elements-3F","()",""],["have_required_elements?","RSS::Element","RSS/Element.html#method-i-have_required_elements-3F","()",""],["have_required_values?","RSS::Maker::Atom::Feed::Channel","RSS/Maker/Atom/Feed/Channel.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::Atom::Feed::Items::Item","RSS/Maker/Atom/Feed/Items/Item.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::Base","RSS/Maker/Base.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::ITunesChannelModel::ITunesCategoriesBase::ITunesCategoryBase","RSS/Maker/ITunesChannelModel/ITunesCategoriesBase/ITunesCategoryBase.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::ImageFaviconModel::ImageFaviconBase","RSS/Maker/ImageFaviconModel/ImageFaviconBase.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::ImageItemModel::ImageItemBase","RSS/Maker/ImageItemModel/ImageItemBase.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::RSS10::Image","RSS/Maker/RSS10/Image.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::RSS10::Textinput","RSS/Maker/RSS10/Textinput.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::TaxonomyTopicModel::TaxonomyTopicsBase::TaxonomyTopicBase","RSS/Maker/TaxonomyTopicModel/TaxonomyTopicsBase/TaxonomyTopicBase.html#method-i-have_required_values-3F","()",""],["have_required_values?","RSS::Maker::TrackBackModel::TrackBackAboutsBase::TrackBackAboutBase","RSS/Maker/TrackBackModel/TrackBackAboutsBase/TrackBackAboutBase.html#method-i-have_required_values-3F","()",""],["have_struct_member","MakeMakefile","MakeMakefile.html#method-i-have_struct_member","(type, member, headers = nil, opt = \"\", &b)","<p>Returns whether or not the struct of type <code>type</code> contains <code>member</code>.  If it does not, or the struct type can&#39;t …\n"],["have_type","MakeMakefile","MakeMakefile.html#method-i-have_type","(type, headers = nil, opt = \"\", &b)","<p>Returns whether or not the static type <code>type</code> is defined.  You may optionally pass additional <code>headers</code> to …\n"],["have_var","MakeMakefile","MakeMakefile.html#method-i-have_var","(var, headers = nil, opt = \"\", &b)","<p>Returns whether or not the variable <code>var</code> can be found in the common header files, or within any <code>headers</code> …\n"],["have_xml_content?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-have_xml_content-3F","()","<p>Returns true if the element has inline XML content.\n"],["have_xml_content?","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-i-have_xml_content-3F","()","<p>Returns true if type is “xhtml”.\n"],["have_xml_content?","RSS::Element","RSS/Element.html#method-i-have_xml_content-3F","()",""],["head","Net::HTTP","Net/HTTP.html#method-i-head","(path, initheader = nil)","<p>Gets only the header from <code>path</code> on the connected-to host. <code>header</code> is a Hash like { &#39;Accept&#39; =&gt; …\n"],["head2","Net::HTTP","Net/HTTP.html#method-i-head2","(path, initheader = nil, &block)",""],["head?","Racc::LocationPointer","Racc/LocationPointer.html#method-i-head-3F","()",""],["header","CGI","CGI.html#method-i-header","(options='text/html')","<p>This method is an alias for #http_header, when HTML5 tag maker is inactive.\n<p>NOTE: use #http_header to …\n"],["header","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-i-header","(checksum = @checksum)",""],["header","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-header","(type, fname, dname, length, mode, mtime, checksum = nil, linkname = \"\")",""],["header","Net::POPMail","Net/POPMail.html#method-i-header","(dest = +'')","<p>Fetches the message header.\n<p>The optional <code>dest</code> argument is obsolete.\n<p>This method raises a POPError if an …\n"],["header","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-header","()",""],["header?","CSV::Row","CSV/Row.html#method-i-header-3F","(header)",""],["header_convert","CSV","CSV.html#method-i-header_convert","(name = nil, &converter)","<p>Identical to CSV#convert(), but for header rows.\n<p>Note that this method must be called before header rows …\n"],["header_converters","CSV","CSV.html#method-i-header_converters","()","<p>Returns the current list of converters in effect for headers. See CSV::new for details. Built-in converters …\n"],["header_fields_converter","CSV","CSV.html#method-i-header_fields_converter","()",""],["header_group_message","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-header_group_message","(groups)",""],["header_outdated_message","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-header_outdated_message","()",""],["header_row?","CSV","CSV.html#method-i-header_row-3F","()","<p>Returns <code>true</code> if the next row read will be a header row.\n"],["header_row?","CSV::Parser","CSV/Parser.html#method-i-header_row-3F","()",""],["header_row?","CSV::Row","CSV/Row.html#method-i-header_row-3F","()","<p>Returns <code>true</code> if this is a header row.\n"],["headers","CSV","CSV.html#method-i-headers","()","<p>Returns <code>nil</code> if headers will not be used, <code>true</code> if they will but have not yet been read, or the actual …\n"],["headers","CSV::Parser","CSV/Parser.html#method-i-headers","()",""],["headers","CSV::Row","CSV/Row.html#method-i-headers","()","<p>Returns the headers of this row.\n"],["headers","CSV::Table","CSV/Table.html#method-i-headers","()","<p>Returns the headers for the first row of this table (assumed to match all other rows). The headers Array …\n"],["headers=","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-headers-3D","(v)","<p>Setter for headers <code>v</code>.\n"],["headers=","URI::MailTo","URI/MailTo.html#method-i-headers-3D","(v)","<p>Setter for headers <code>v</code>.\n"],["helo","Net::SMTP","Net/SMTP.html#method-i-helo","(domain)",""],["help","Bundler::CLI","Bundler/CLI.html#method-i-help","(cli = nil)",""],["help","Bundler::Thor","Bundler/Thor.html#method-c-help","(shell, subcommand = false)","<p>Prints help information for this class.\n<p>Parameters\n<p>shell&lt;Bundler::Thor::Shell&gt;\n"],["help","Bundler::Thor","Bundler/Thor.html#method-i-help","(command = nil, subcommand = false)",""],["help","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-help","(shell)","<p>Prints help information.\n<p>Options\n<p>short &mdash; When true, shows only usage.\n"],["help","Net::FTP","Net/FTP.html#method-i-help","(arg = nil)","<p>Issues the HELP command.\n"],["help","OptionParser","OptionParser.html#method-i-help","()","<p>Returns option summary string.\n"],["helpcontext","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-helpcontext","()","<p>Returns help context.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbooks&#39;</span>)\n<span class=\"ruby-identifier\">method</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["helpcontext","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-helpcontext","()","<p>Returns helpcontext. If helpcontext is not found, then returns nil.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["helpfile","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-helpfile","()","<p>Returns help file. If help file is not found, then the method returns nil.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["helpfile","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-helpfile","()","<p>Returns helpfile path. If helpfile is not found, then returns nil.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["helpstring","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-helpstring","()","<p>Returns help string of OLE method. If the help string is not found, then the method returns nil.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["helpstring","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-helpstring","()","<p>Returns help string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Internet Controls&#39;</span>, <span class=\"ruby-string\">&#39;IWebBrowser&#39;</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-identifier\">tobj</span>.<span class=\"ruby-identifier\">helpstring</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["here?","DRb","DRb.html#method-i-here-3F","(uri)","<p>Is <code>uri</code> the URI for the current local server?\n"],["here?","DRb","DRb.html#method-c-here-3F","(uri)","<p>Is <code>uri</code> the URI for the current local server?\n"],["here?","DRb::DRbServer","DRb/DRbServer.html#method-i-here-3F","(uri)","<p>Is <code>uri</code> the URI for this server?\n"],["heredoc_end?","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-heredoc_end-3F","(name, indent, tk)",""],["hermitian?","Matrix","Matrix.html#method-i-hermitian-3F","()","<p>Returns <code>true</code> if this is an hermitian matrix. Raises an error if matrix is not square.\n"],["hessenberg_to_real_schur","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-hessenberg_to_real_schur","()","<p>Nonsymmetric reduction from Hessenberg to real Schur form.\n"],["hex","Random::Formatter","Random/Formatter.html#method-i-hex","(n=nil)","<p>SecureRandom.hex generates a random hexadecimal string.\n<p>The argument <em>n</em> specifies the length, in bytes, …\n"],["hex","String","String.html#method-i-hex","()","<p>Treats leading characters from <em>str</em> as a string of hexadecimal digits (with an optional sign and an optional …\n"],["hexdigest","Digest::Class","Digest/Class.html#method-c-hexdigest","(*args)","<p>Returns the hex-encoded hash value of a given <em>string</em>.  This is almost equivalent to Digest.hexencode …\n"],["hexdigest","Digest::Instance","Digest/Instance.html#method-i-hexdigest","(p1 = v1)","<p>If none is given, returns the resulting hash value of the digest in a hex-encoded form, keeping the digest&#39;s …\n"],["hexdigest","OpenSSL::HMAC","OpenSSL/HMAC.html#method-c-hexdigest","(p1, p2, p3)","<p>Returns the authentication code as a hex-encoded string. The <em>digest</em> parameter specifies the digest algorithm …\n"],["hexdigest","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-hexdigest","()","<p>Returns the authentication code an instance represents as a hex-encoded string.\n"],["hexdigest!","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-i-hexdigest-21","(digest)",""],["hexdigest!","Digest::Instance","Digest/Instance.html#method-i-hexdigest-21","()","<p>Returns the resulting hash value in a hex-encoded form and resets the digest to the initial state.\n"],["hexencode","Digest","Digest.html#method-c-hexencode","(p1)","<p>Generates a hex-encoded version of a given <em>string</em>.\n"],["hidden","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-hidden","(name = \"\", value = nil)","<p>Generate a Hidden Input element as a string.\n<p>The attributes of the element can be specified as two arguments, …\n"],["hidden?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-hidden-3F","()",""],["hidden?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-hidden-3F","()",""],["hidden?","Bundler::Thor::HiddenCommand","Bundler/Thor/HiddenCommand.html#method-i-hidden-3F","()",""],["hidden?","Bundler::Thor::HiddenCommand","Bundler/Thor/HiddenCommand.html#method-i-hidden-3F","()",""],["hierarchical?","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-hierarchical-3F","()","<p>Returns true if Bundler::URI is hierarchical.\n<p>Description\n<p>Bundler::URI has components listed in order of …\n"],["hierarchical?","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-hierarchical-3F","()","<p>Checks if Bundler::URI has a path. For Bundler::URI::LDAP this will return <code>false</code>.\n"],["hierarchical?","URI::Generic","URI/Generic.html#method-i-hierarchical-3F","()","<p>Returns true if URI is hierarchical.\n<p>Description\n<p>URI has components listed in order of decreasing significance …\n"],["hierarchical?","URI::LDAP","URI/LDAP.html#method-i-hierarchical-3F","()","<p>Checks if URI has a path. For URI::LDAP this will return <code>false</code>.\n"],["higher","Racc::Grammar::PrecedenceDefinitionEnv","Racc/Grammar/PrecedenceDefinitionEnv.html#method-i-higher","()",""],["history_file","IRB::Context","IRB/Context.html#method-i-history_file","()","<p>A copy of the default <code>IRB.conf[:HISTORY_FILE]</code>\n"],["history_file=","IRB::Context","IRB/Context.html#method-i-history_file-3D","(hist)","<p>Set <code>IRB.conf[:HISTORY_FILE]</code> to the given <code>hist</code>.\n"],["hkdf","OpenSSL::KDF","OpenSSL/KDF.html#method-c-hkdf","(p1, p2 = {})","<p>HMAC-based Extract-and-Expand Key Derivation Function (HKDF) as specified in RFC 5869.\n<p>New in OpenSSL …\n"],["hmac_md5","Net::IMAP::CramMD5Authenticator","Net/IMAP/CramMD5Authenticator.html#method-i-hmac_md5","(text, key)",""],["home","Bundler","Bundler.html#method-c-home","()",""],["home","Dir","Dir.html#method-c-home","(*args)","<p>Returns the home directory of the current user or the named user if given.\n"],["home_workspace","IRB::Context","IRB/Context.html#method-i-home_workspace","()","<p>Inherited from <code>TOPLEVEL_BINDING</code>.\n"],["hook","Bundler::Plugin","Bundler/Plugin.html#method-i-hook","(event, *args, &arg_blk)","<p>Runs all the hooks that are registered for the passed event\n<p>It passes the passed arguments and block to …\n"],["hook","Bundler::Plugin::API","Bundler/Plugin/API.html#method-c-hook","(event, &block)",""],["hook_plugins","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-hook_plugins","(event)","<p>Returns the list of plugin names handling the passed event\n"],["host","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-host","()",""],["host","Gem","Gem.html#method-c-host","()","<p>Get the default RubyGems API host. This is normally <code>https://rubygems.org</code>.\n"],["host","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-host","()","<p>The host to connect to either from the RUBYGEMS_HOST environment variable or from the user&#39;s configuration …\n"],["host","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-host","()","<p>The host this request is for\n"],["host=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-host-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["host=","Gem","Gem.html#method-c-host-3D","(host)","<p>Set the default RubyGems API host.\n"],["host=","URI::Generic","URI/Generic.html#method-i-host-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["hostname","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-hostname","()","<p>Extract the host part of the Bundler::URI and unwrap brackets for IPv6 addresses.\n<p>This method is the same …\n"],["hostname","URI::Generic","URI/Generic.html#method-i-hostname","()","<p>Extract the host part of the URI and unwrap brackets for IPv6 addresses.\n<p>This method is the same as URI::Generic#host …\n"],["hostname=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-hostname-3D","(v)","<p>Sets the host part of the Bundler::URI as the argument with brackets for IPv6 addresses.\n<p>This method is …\n"],["hostname=","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-hostname-3D","(p1)","<p>Sets the server hostname used for SNI. This needs to be set before SSLSocket#connect.\n"],["hostname=","URI::Generic","URI/Generic.html#method-i-hostname-3D","(v)","<p>Sets the host part of the URI as the argument with brackets for IPv6 addresses.\n<p>This method is the same …\n"],["hour","Date","Date.html#method-i-hour","()",""],["hour","DateTime","DateTime.html#method-i-hour","()","<p>Returns the hour (0-23).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">hour</span>         <span class=\"ruby-comment\">#=&gt; 4</span>\n</pre>\n"],["hour","Time","Time.html#method-i-hour","()","<p>Returns the hour of the day (0..23) for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:26:20 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">hour</span>     <span class=\"ruby-operator\">...</span>\n</pre>\n"],["hour=","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-hour-3D","(hour)",""],["hour=","RSS::Maker::ITunesItemModel::ITunesDurationBase","RSS/Maker/ITunesItemModel/ITunesDurationBase.html#method-i-hour-3D","(hour)",""],["href=","RSS::XMLStyleSheet","RSS/XMLStyleSheet.html#method-i-href-3D","(value)",""],["hstack","Matrix","Matrix.html#method-c-hstack","(x, *matrices)","<p>Create a matrix by stacking matrices horizontally\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">x</span> = <span class=\"ruby-constant\">Matrix</span>[[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>], [<span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">4</span>]]\n<span class=\"ruby-identifier\">y</span> = <span class=\"ruby-constant\">Matrix</span>[[<span class=\"ruby-value\">5</span>, <span class=\"ruby-value\">6</span>], [<span class=\"ruby-value\">7</span>, <span class=\"ruby-value\">8</span>]] <span class=\"ruby-operator\">...</span>\n</pre>\n"],["hstack","Matrix","Matrix.html#method-i-hstack","(*matrices)","<p>Returns a new matrix resulting by stacking horizontally the receiver with the given matrices\n\n<pre>x = Matrix[[1, ...</pre>\n"],["html","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-html","(attributes = {})","<p>Generate a top-level HTML element as a string.\n<p>The attributes of the element are specified as a hash. …\n"],["html","RDoc::Markdown","RDoc/Markdown.html#method-i-html","","<p>Allow HTML\n"],["html_escape","ERB::Util","ERB/Util.html#method-c-html_escape","(s)","<p>A utility method for escaping HTML tag characters in <em>s</em>.\n\n<pre>require &quot;erb&quot;\ninclude ERB::Util\n\nputs html_escape(&quot;is ...</pre>\n"],["html_escape","ERB::Util","ERB/Util.html#method-i-html_escape","(s)","<p>A utility method for escaping HTML tag characters in <em>s</em>.\n\n<pre>require &quot;erb&quot;\ninclude ERB::Util\n\nputs html_escape(&quot;is ...</pre>\n"],["html_escape","RSS::Utils","RSS/Utils.html#method-i-html_escape","(s)","<p>Takes a string <code>s</code> with some HTML in it, and escapes &#39;&amp;&#39;, &#39;“&#39;, &#39;&lt;&#39; …\n"],["html_name","RDoc::Alias","RDoc/Alias.html#method-i-html_name","()","<p>HTML id-friendly version of <code>#new_name</code>.\n"],["html_name","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-html_name","()","<p>HTML id-friendly method/attribute name\n"],["hton","IPAddr","IPAddr.html#method-i-hton","()","<p>Returns a network byte ordered string form of the IP address.\n"],["http_default_port","Net::HTTP","Net/HTTP.html#method-c-http_default_port","()","<p>The default port to use for HTTP requests; defaults to 80.\n"],["http_header","CGI","CGI.html#method-i-http_header","(options='text/html')","<p>Create an HTTP header block as a string.\n<p>Includes the empty line that ends the header block.\n<p><code>content_type_string</code> … &mdash; "],["http_proxy","Bundler::Fetcher","Bundler/Fetcher.html#method-i-http_proxy","()",""],["http_url","RDoc::Context","RDoc/Context.html#method-i-http_url","(prefix)","<p>URL for this with a <code>prefix</code>\n"],["http_url","RDoc::TopLevel","RDoc/TopLevel.html#method-i-http_url","(prefix)","<p>URL for this with a <code>prefix</code>\n"],["http_version","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-http_version","(uri)","<p>Returns the HTTP protocol version for <code>uri</code>\n"],["httpdate","Date","Date.html#method-c-httpdate","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new Date object by parsing from a string according to some RFC 2616 format.\n\n<pre>Date.httpdate(&#39;Sat, ...</pre>\n"],["httpdate","Date","Date.html#method-i-httpdate","()","<p>This method is equivalent to strftime(&#39;%a, %d %b %Y %T GMT&#39;). See also RFC 2616.\n"],["httpdate","DateTime","DateTime.html#method-c-httpdate","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new DateTime object by parsing from a string according to some RFC 2616 format.\n\n<pre>DateTime.httpdate(&#39;Sat, ...</pre>\n"],["httpdate","Time","Time.html#method-c-httpdate","(date)","<p>Parses <code>date</code> as an HTTP-date defined by RFC 2616 and converts it to a Time object.\n<p>ArgumentError is raised …\n"],["httpdate","Time","Time.html#method-i-httpdate","()","<p>Returns a string which represents the time as RFC 1123 date of HTTP-date defined by RFC 2616:\n\n<pre>day-of-week, ...</pre>\n"],["httponly=","CGI::Cookie","CGI/Cookie.html#method-i-httponly-3D","(val)","<p>Set whether the Cookie is a httponly cookie or not.\n<p><code>val</code> must be a boolean.\n"],["https?","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-https-3F","(uri)",""],["https_default_port","Net::HTTP","Net/HTTP.html#method-c-https_default_port","()","<p>The default port to use for HTTPS requests; defaults to 443.\n"],["hypot","Math","Math.html#method-c-hypot","(p1, p2)","<p>Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with sides <code>x</code> and <code>y</code>.\n\n<pre>Math.hypot(3, ...</pre>\n"],["i","Numeric","Numeric.html#method-i-i","()","<p>Returns the corresponding imaginary number. Not available for complex numbers.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">-42</span>.<span class=\"ruby-identifier\">i</span>  <span class=\"ruby-comment\">#=&gt; (0-42i)</span>\n<span class=\"ruby-value\">2.0</span>.<span class=\"ruby-identifier\">i</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["i_i_sym_list","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-i_i_sym_list","(name, table)",""],["icon","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-icon","()",""],["icon=","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-icon-3D","(url)",""],["iconv","JSON","JSON.html#method-c-iconv","(to, from, string)","<p>Encodes string using Ruby&#39;s <em>String.encode</em>\n"],["id","OpenSSL::Engine","OpenSSL/Engine.html#method-i-id","()","<p>Gets the id for this engine.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Engine</span>.<span class=\"ruby-identifier\">load</span>\n<span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Engine</span>.<span class=\"ruby-identifier\">engines</span> <span class=\"ruby-comment\">#=&gt; [#&lt;OpenSSL::Engine#&gt;, ...] ...</span>\n</pre>\n"],["id","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-id","()","<p>Returns the Session ID.\n"],["id","REXML::Functions","REXML/Functions.html#method-c-id","( object )","<p>Since REXML is non-validating, this method is not implemented as it requires a DTD\n"],["id2name","Symbol","Symbol.html#method-i-id2name","()","<p>Returns the name or string corresponding to <em>sym</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">:fred</span>.<span class=\"ruby-identifier\">id2name</span>   <span class=\"ruby-comment\">#=&gt; &quot;fred&quot;</span>\n<span class=\"ruby-value\">:ginger</span>.<span class=\"ruby-identifier\">to_s</span>    <span class=\"ruby-comment\">#=&gt; &quot;ginger&quot;</span>\n</pre>\n"],["idempotent?","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-idempotent-3F","(req)","<p>Is <code>req</code> idempotent according to RFC 2616?\n"],["ident","Syslog","Syslog.html#method-c-ident","()","<p>Returns the identity string used in the last call to open()\n"],["identical?","Bundler::FileUtils","Bundler/FileUtils.html#method-i-identical-3F","(a, b)",""],["identical?","Bundler::FileUtils","Bundler/FileUtils.html#method-c-identical-3F","(a, b)",""],["identical?","File","File.html#method-c-identical-3F","(p1, p2)","<p>Returns <code>true</code> if the named files are identical.\n<p><em>file_1</em> and <em>file_2</em> can be an IO object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;w&quot;</span>) {} <span class=\"ruby-operator\">...</span>\n</pre>\n"],["identical?","FileTest","FileTest.html#method-i-identical-3F","(p1, p2)","<p>Returns <code>true</code> if the named files are identical.\n<p><em>file_1</em> and <em>file_2</em> can be an IO object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;w&quot;</span>) {} <span class=\"ruby-operator\">...</span>\n</pre>\n"],["identical?","FileUtils","FileUtils.html#method-c-identical-3F","(a, b)",""],["identical?","FileUtils","FileUtils.html#method-i-identical-3F","(a, b)",""],["identifier","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-identifier","()",""],["identity","Gem::Dependency","Gem/Dependency.html#method-i-identity","()",""],["identity","Matrix","Matrix.html#method-c-identity","(n)","<p>Creates an <code>n</code> by <code>n</code> identity matrix.\n\n<pre>Matrix.identity(2)\n  =&gt; 1 0\n     0 1</pre>\n"],["idle","Net::IMAP","Net/IMAP.html#method-i-idle","(timeout = nil, &response_handler)","<p>Sends an IDLE command that waits for notifications of new or expunged messages.  Yields responses from …\n"],["idle_done","Net::IMAP","Net/IMAP.html#method-i-idle_done","()","<p>Leaves IDLE.\n"],["if_modified_since","RDoc::Servlet","RDoc/Servlet.html#method-i-if_modified_since","(req, res, path = nil)","<p>Handles the If-Modified-Since HTTP header on <code>req</code> for <code>path</code>.  If the file has not been modified a Not  …\n"],["ifindex","Socket::Ifaddr","Socket/Ifaddr.html#method-i-ifindex","()","<p>Returns the interface index of <em>ifaddr</em>.\n"],["iflush","IO","IO.html#method-i-iflush","()","<p>Flushes input buffer in kernel.\n<p>You must require &#39;io/console&#39; to use this method.\n"],["ignorable_dependency?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-ignorable_dependency-3F","(dep)",""],["ignore","RDoc::CodeObject","RDoc/CodeObject.html#method-i-ignore","()","<p>Use this to ignore a CodeObject and all its children until found again (#record_location is called). …\n"],["ignore_broken_line","CSV::Parser","CSV/Parser.html#method-i-ignore_broken_line","()",""],["ignore_config?","Bundler::Settings","Bundler/Settings.html#method-i-ignore_config-3F","()",""],["ignore_unknown_element","RSS::BaseParser","RSS/BaseParser.html#method-i-ignore_unknown_element","()",""],["ignore_unknown_element=","RSS::BaseParser","RSS/BaseParser.html#method-i-ignore_unknown_element-3D","(new_value)",""],["ignore_whitespace_nodes","REXML::Element","REXML/Element.html#method-i-ignore_whitespace_nodes","()",""],["ignored?","RDoc::CodeObject","RDoc/CodeObject.html#method-i-ignored-3F","()","<p>Has this class been ignored?\n<p>See also #ignore\n"],["imag","Complex","Complex.html#method-i-imag","()","<p>Returns the imaginary part.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">imaginary</span>      <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">9</span>, <span class=\"ruby-value\">-4</span>).<span class=\"ruby-identifier\">imaginary</span>  <span class=\"ruby-comment\">#=&gt; -4</span>\n</pre>\n"],["imag","Matrix","Matrix.html#method-i-imag","()",""],["imag","Numeric","Numeric.html#method-i-imag","()","<p>Returns zero.\n"],["image","RSS::Rss","RSS/Rss.html#method-i-image","()",""],["image_button","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-image_button","(src = \"\", name = nil, alt = nil)","<p>Generate an Image Button Input element as a string.\n<p><code>src</code> is the URL of the image to use for the button. …\n"],["image_size=","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-i-image_size-3D","(new_value)",""],["imaginary","Complex","Complex.html#method-i-imaginary","()","<p>Returns the imaginary part.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">imaginary</span>      <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">9</span>, <span class=\"ruby-value\">-4</span>).<span class=\"ruby-identifier\">imaginary</span>  <span class=\"ruby-comment\">#=&gt; -4</span>\n</pre>\n"],["imaginary","Matrix","Matrix.html#method-i-imaginary","()","<p>Returns the imaginary part of the matrix.\n\n<pre>Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]\n  =&gt; 1+2i ...</pre>\n"],["imaginary","Numeric","Numeric.html#method-i-imaginary","()","<p>Returns zero.\n"],["img","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-img","(src = \"\", alt = \"\", width = nil, height = nil)","<p>Generate an Image element as a string.\n<p><code>src</code> is the URL of the image.  <code>alt</code> is the alternative text for the …\n"],["implemented_ole_types","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-implemented_ole_types","()","<p>Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE object.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["implicit?","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-implicit-3F","()","<p>Indicate that the request is for a gem requested as a dependency of another gem\n"],["import","Gem::RequestSet","Gem/RequestSet.html#method-i-import","(deps)","<p>Add <code>deps</code> Gem::Dependency objects to the set.\n"],["import_function","Fiddle::Importer","Fiddle/Importer.html#method-i-import_function","(name, ctype, argtype, call_type = nil)","<p>Returns a new Fiddle::Function instance at the memory address of the given <code>name</code> function.\n<p>Raises a DLError …\n"],["import_symbol","Fiddle::Importer","Fiddle/Importer.html#method-i-import_symbol","(name)","<p>Returns a new Fiddle::Pointer instance at the memory address of the given <code>name</code> symbol.\n<p>Raises a DLError …\n"],["import_value","Fiddle::Importer","Fiddle/Importer.html#method-i-import_value","(ty, addr)","<p>Returns a new instance of the C struct with the value <code>ty</code> at the <code>addr</code> address.\n"],["in6_addr","IPAddr","IPAddr.html#method-i-in6_addr","(left)",""],["in_addr","IPAddr","IPAddr.html#method-i-in_addr","(addr)",""],["in_bundle?","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-in_bundle-3F","()",""],["in_locked_deps?","Bundler::Definition","Bundler/Definition.html#method-i-in_locked_deps-3F","(dep, locked_dep)",""],["in_path","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-in_path","(&blk)",""],["in_root","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-in_root","()","<p>Goes to the root and execute the given block.\n"],["in_transaction","PStore","PStore.html#method-i-in_transaction","()","<p>Raises PStore::Error if the calling code is not in a PStore#transaction.\n"],["in_transaction_wr","PStore","PStore.html#method-i-in_transaction_wr","()","<p>Raises PStore::Error if the calling code is not in a PStore#transaction or if the code is in a read-only …\n"],["inc","OptionParser","OptionParser.html#method-c-inc","(arg, default = nil)","<p>Returns an incremented value of <code>default</code> according to <code>arg</code>.\n"],["inc","OptionParser","OptionParser.html#method-i-inc","(*args)",""],["include","Module","Module.html#method-i-include","(*args)","<p>Invokes Module.append_features on each parameter in reverse order.\n"],["include?","Array","Array.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if the given <code>object</code> is present in <code>self</code> (that is, if any element <code>==</code> <code>object</code>), otherwise returns …\n"],["include?","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-include-3F","(other)","<p>Note: Do not override if you don&#39;t know what you are doing.\n"],["include?","Bundler::Source","Bundler/Source.html#method-i-include-3F","(other)",""],["include?","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-include-3F","(o)",""],["include?","CGI::QueryExtension","CGI/QueryExtension.html#method-i-include-3F","(*args)",""],["include?","CSV::Row","CSV/Row.html#method-i-include-3F","(header)",""],["include?","DBM","DBM.html#method-i-include-3F","(p1)","<p>Returns true if the database contains the specified key, false otherwise.\n"],["include?","ENV","ENV.html#method-c-include-3F","(p1)","<p>ENV.has_key?, ENV.member?, and ENV.key? are aliases for ENV.include?.\n<p>Returns <code>true</code> if there is an environment …\n"],["include?","Enumerable","Enumerable.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if any member of <em>enum</em> equals <em>obj</em>. Equality is tested using <code>==</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">include?</span> <span class=\"ruby-value\">5</span>  <span class=\"ruby-comment\">#=&gt; true ...</span>\n</pre>\n"],["include?","GDBM","GDBM.html#method-i-include-3F","(p1)","<p>Returns true if the given key <em>k</em> exists within the database. Returns false otherwise.\n"],["include?","Gem::SourceList","Gem/SourceList.html#method-i-include-3F","(other)","<p>Returns true if this source list includes <code>other</code> which may be a Gem::Source or a source URI.\n"],["include?","Hash","Hash.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if the given key is present in <em>hsh</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;b&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">200</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">has_key?</span>(<span class=\"ruby-string\">&quot;a&quot;</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["include?","IPAddr","IPAddr.html#method-i-include-3F","(other)","<p>Returns true if the given ipaddr is in the range.\n<p>e.g.:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;ipaddr&#39;</span>\n<span class=\"ruby-identifier\">net1</span> = <span class=\"ruby-constant\">IPAddr</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;192.168.2.0/24&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["include?","Module","Module.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if <em>module</em> is included in <em>mod</em> or one of <em>mod</em>&#39;s ancestors.\n\n<pre>module A\nend\nclass B\n  include ...</pre>\n"],["include?","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if <code>key</code> is registered\n"],["include?","REXML::AttlistDecl","REXML/AttlistDecl.html#method-i-include-3F","(key)","<p>Whether an attlist declaration includes the given attribute definition\n\n<pre>if attlist_decl.include? &quot;xmlns:foobar&quot;</pre>\n"],["include?","Racc::ISet","Racc/ISet.html#method-i-include-3F","(key)",""],["include?","Range","Range.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if <code>obj</code> is an element of the range, <code>false</code> otherwise.\n\n<pre class=\"ruby\">(<span class=\"ruby-string\">&quot;a&quot;</span><span class=\"ruby-operator\">..</span><span class=\"ruby-string\">&quot;z&quot;</span>).<span class=\"ruby-identifier\">include?</span>(<span class=\"ruby-string\">&quot;g&quot;</span>)   <span class=\"ruby-comment\">#=&gt; true</span>\n(<span class=\"ruby-string\">&quot;a&quot;</span><span class=\"ruby-operator\">..</span><span class=\"ruby-string\">&quot;z&quot;</span>).<span class=\"ruby-identifier\">include?</span>(<span class=\"ruby-string\">&quot;A&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["include?","SDBM","SDBM.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if the database contains the given <code>key</code>.\n"],["include?","Set","Set.html#method-i-include-3F","(o)","<p>Returns true if the set contains the given object.\n<p>Note that <code>include?</code> and <code>member?</code> do not test member equality …\n"],["include?","String","String.html#method-i-include-3F","(p1)","<p>Returns <code>true</code> if <em>str</em> contains the given string or character.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">include?</span> <span class=\"ruby-string\">&quot;lo&quot;</span>   <span class=\"ruby-comment\">#=&gt; true</span>\n<span class=\"ruby-string\">&quot;hello&quot;</span>.<span class=\"ruby-identifier\">include?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["included","Bundler::Thor::RakeCompat","Bundler/Thor/RakeCompat.html#method-c-included","(base)",""],["included","JSON::Ext::Generator::GeneratorMethods::String","JSON/Ext/Generator/GeneratorMethods/String.html#method-c-included","(p1)","<p>Extends <em>modul</em> with the String::Extend module.\n"],["included","Module","Module.html#method-i-included","(p1)","<p>Callback invoked whenever the receiver is included in another module or class. This should be used in …\n"],["included","RSS::Maker::AtomTextConstructBase::EnsureXMLContent","RSS/Maker/AtomTextConstructBase/EnsureXMLContent.html#method-c-included","(base)",""],["included","Singleton","Singleton.html#method-c-included","(klass)",""],["included","Syslog::Constants","Syslog/Constants.html#method-c-included","(p1)",""],["included","Syslog::Macros","Syslog/Macros.html#method-c-included","(p1)",""],["included_modules","Module","Module.html#method-i-included_modules","()","<p>Returns the list of modules included in <em>mod</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">module</span> <span class=\"ruby-constant\">Mixin</span>\n<span class=\"ruby-keyword\">end</span>\n\n<span class=\"ruby-keyword\">module</span> <span class=\"ruby-constant\">Outer</span>\n  <span class=\"ruby-identifier\">include</span> <span class=\"ruby-constant\">Mixin</span>\n<span class=\"ruby-keyword\">end</span>\n\n<span class=\"ruby-constant\">Mixin</span>.<span class=\"ruby-identifier\">included_modules</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["incompatible_argument_styles","OptionParser::Switch","OptionParser/Switch.html#method-c-incompatible_argument_styles","(arg, t)",""],["incompatible_argument_styles","OptionParser::Switch::NoArgument","OptionParser/Switch/NoArgument.html#method-c-incompatible_argument_styles","(*)",""],["incomplete_input?","Encoding::InvalidByteSequenceError","Encoding/InvalidByteSequenceError.html#method-i-incomplete_input-3F","()","<p>Returns true if the invalid byte sequence error is caused by premature end of string.\n\n<pre>ec = Encoding::Converter.new(&quot;EUC-JP&quot;, ...</pre>\n"],["incref","Racc::Reduce","Racc/Reduce.html#method-i-incref","()",""],["increment","Racc::LocationPointer","Racc/LocationPointer.html#method-i-increment","()",""],["indent","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-indent","(count = 1)","<p>Sets the output padding while executing a block and resets it.\n"],["indent","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-indent","()","<p>Returns the string that is used to indent levels in the JSON text.\n"],["indent","REXML::Node","REXML/Node.html#method-i-indent","(to, ind)",""],["indent","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-indent","()",""],["indent=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-indent-3D","(p1)","<p>Sets the string that is used to indent levels in the JSON text.\n"],["indent_re","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-indent_re","(n)",""],["indent_text","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-i-indent_text","(string, level=1, style=\"\\t\", indentfirstline=true)",""],["indent_text","REXML::Text","REXML/Text.html#method-i-indent_text","(string, level=1, style=\"\\t\", indentfirstline=true)",""],["indentation","Psych::Emitter","Psych/Emitter.html#method-i-indentation","()","<p>Get the indentation level.\n"],["indentation=","Psych::Emitter","Psych/Emitter.html#method-i-indentation-3D","(p1)","<p>Set the indentation level to <code>level</code>.  The level must be less than 10 and greater than 1.\n"],["independent?","Vector","Vector.html#method-c-independent-3F","(*vs)","<p>Returns <code>true</code> iff all of vectors are linearly independent.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Vector</span>.<span class=\"ruby-identifier\">independent?</span>(<span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">0</span>], <span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">0</span>,<span class=\"ruby-value\">1</span>]) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["independent?","Vector","Vector.html#method-i-independent-3F","(*vs)","<p>Returns <code>true</code> iff all of vectors are linearly independent.\n\n<pre>Vector[1,0].independent?(Vector[0,1])\n  =&gt; true ...</pre>\n"],["index","Array","Array.html#method-i-index","(*args)","<p>Returns the <em>index</em> of the first object in <code>ary</code> such that the object is <code>==</code> to <code>obj</code>.\n<p>If a block is given instead …\n"],["index","Bundler::Definition","Bundler/Definition.html#method-i-index","()",""],["index","Bundler::Plugin","Bundler/Plugin.html#method-i-index","()","<p>The index object used to store the details about the plugin\n"],["index","CSV::Row","CSV/Row.html#method-i-index","(header, minimum_index = 0)","<p>This method will return the index of a field with the provided <code>header</code>. The <code>offset</code> can be used to locate …\n"],["index","ENV","ENV.html#method-c-index","(p1)","<p>Deprecated method that is equivalent to ENV.key\n"],["index","Matrix","Matrix.html#method-i-index","(*args)","<p>The index method is specialized to return the index as [row, column] It also accepts an optional <code>selector</code> …\n"],["index","REXML::Elements","REXML/Elements.html#method-i-index","(element)","<p>Returns the index of the supplied child (starting at 1), or -1 if the element is not a child\n<p>element &mdash; "],["index","REXML::Parent","REXML/Parent.html#method-i-index","( child )","<p>Fetches the index of a given child @param child the child to get the index of @return the index of the …\n"],["index","String","String.html#method-i-index","(p1, p2 = v2)","<p>Returns the index of the first occurrence of the given <em>substring</em> or pattern (<em>regexp</em>) in <em>str</em>. Returns …\n"],["index","YAML::DBM","YAML/DBM.html#method-i-index","( keystr )","<p>Deprecated, used YAML::DBM#key instead.\n<p>Note: YAML::DBM#index makes warning from internal of ::DBM#index …\n"],["index_file","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-index_file","()","<p>Path of default index file\n"],["index_for","Bundler::Resolver","Bundler/Resolver.html#method-i-index_for","(dependency)",""],["index_in_parent","REXML::Node","REXML/Node.html#method-i-index_in_parent","()","<p>Returns the position that <code>self</code> holds in its parent&#39;s array, indexed from 1.\n"],["indicate_progress","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-indicate_progress","()","<p>Indicates progress roughly once every second @return [void]\n"],["indicate_progress","Bundler::Molinillo::UI","Bundler/Molinillo/UI.html#method-i-indicate_progress","()","<p>Called roughly every {#progress_rate}, this method should convey progress to the user.\n<p>@return [void] …\n"],["indicate_progress","Bundler::Resolver","Bundler/Resolver.html#method-i-indicate_progress","()",""],["indicate_progress","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-indicate_progress","()","<p>Indicates progress roughly once every second @return [void]\n"],["indicate_progress","Gem::Resolver::Molinillo::UI","Gem/Resolver/Molinillo/UI.html#method-i-indicate_progress","()","<p>Called roughly every {#progress_rate}, this method should convey progress to the user.\n<p>@return [void] …\n"],["infinite?","BigDecimal","BigDecimal.html#method-i-infinite-3F","()","<p>Returns nil, -1, or +1 depending on whether the value is finite, -Infinity, or +Infinity.\n"],["infinite?","Complex","Complex.html#method-i-infinite-3F","()","<p>Returns <code>1</code> if <code>cmp</code>&#39;s real or imaginary part is an infinite number, otherwise returns <code>nil</code>.\n\n<pre>For example: ...</pre>\n"],["infinite?","Float","Float.html#method-i-infinite-3F","()","<p>Returns <code>nil</code>, -1, or 1 depending on whether the value is finite, <code>-Infinity</code>, or <code>+Infinity</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">0.0</span>).<span class=\"ruby-identifier\">infinite?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["infinite?","Numeric","Numeric.html#method-i-infinite-3F","()","<p>Returns <code>nil</code>, -1, or 1 depending on whether the value is finite, <code>-Infinity</code>, or <code>+Infinity</code>.\n"],["infinity?","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-infinity-3F","()",""],["inflate","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-inflate","(obj)",""],["inflate","Gem","Gem.html#method-c-inflate","(data)","<p>A Zlib::Inflate#inflate wrapper\n"],["inflate","Gem::Util","Gem/Util.html#method-c-inflate","(data)","<p>A Zlib::Inflate#inflate wrapper\n"],["inflate","Zlib","Zlib.html#method-c-inflate","(p1)","<p>Decompresses <code>string</code>. Raises a Zlib::NeedDict exception if a preset dictionary is needed for decompression. …\n"],["inflate","Zlib::Inflate","Zlib/Inflate.html#method-i-inflate","(p1)","<p>Inputs <code>deflate_string</code> into the inflate stream and returns the output from the stream.  Calling this method, …\n"],["inflate","Zlib::Inflate","Zlib/Inflate.html#method-c-inflate","(p1)","<p>Decompresses <code>string</code>. Raises a Zlib::NeedDict exception if a preset dictionary is needed for decompression. …\n"],["info","Bundler::CLI","Bundler/CLI.html#method-i-info","(gem_name)",""],["info","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-info","(msg, newline = nil)",""],["info","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-info","(message, newline = nil)",""],["info","Logger","Logger.html#method-i-info","(progname = nil, &block)","<p>Log an <code>INFO</code> message.\n<p><code>message</code> &mdash; The message to log; does not need to be a String.\n<p><code>progname</code> &mdash; In the block form, …\n"],["info","Syslog::Logger","Syslog/Logger.html#method-i-info","","<p>Logs a <code>message</code> at the info (syslog info) log level, or logs the message returned from the block.\n"],["info","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-info","(msg)","<p>Shortcut for logging an INFO message\n"],["info!","Logger","Logger.html#method-i-info-21","()","<p>Sets the severity to INFO.\n"],["info?","Logger","Logger.html#method-i-info-3F","()","<p>Returns <code>true</code> iff the current severity level allows for the printing of <code>INFO</code> messages.\n"],["info?","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-info-3F","()","<p>Will the logger output INFO messages?\n"],["info?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-i-info-3F","(code)","<p>Is <code>code</code> an informational status?\n"],["info?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-info-3F","(code)","<p>Is <code>code</code> an informational status?\n"],["info_path","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-info_path","(name)",""],["info_roots","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-info_roots","()",""],["inherit_convert_attr_reader","RSS::BaseModel","RSS/BaseModel.html#method-i-inherit_convert_attr_reader","(*attrs)",""],["inherited","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-inherited","(klass)","<p>Everytime someone inherits from a Bundler::Thor class, register the klass and file into baseclass.\n"],["inherited","Class","Class.html#method-i-inherited","(p1)","<p>Callback invoked whenever a subclass of the current class is created.\n<p>Example:\n\n<pre>class Foo\n  def self.inherited(subclass) ...</pre>\n"],["inherited","RSS::Element","RSS/Element.html#method-c-inherited","(klass)",""],["inherited","RSS::Maker::Base","RSS/Maker/Base.html#method-c-inherited","(subclass)",""],["inherited_array_reader","RSS::Utils::InheritedReader","RSS/Utils/InheritedReader.html#method-i-inherited_array_reader","(constant_name)",""],["inherited_base","RSS::Element","RSS/Element.html#method-c-inherited_base","()",""],["inherited_base","RSS::Maker::Base","RSS/Maker/Base.html#method-c-inherited_base","()",""],["inherited_hash_reader","RSS::Utils::InheritedReader","RSS/Utils/InheritedReader.html#method-i-inherited_hash_reader","(constant_name)",""],["inherited_reader","RSS::Utils::InheritedReader","RSS/Utils/InheritedReader.html#method-i-inherited_reader","(constant_name)",""],["init","Bundler::CLI","Bundler/CLI.html#method-i-init","()",""],["init","Gem::PackageTask","Gem/PackageTask.html#method-i-init","(gem)","<p>Initialization tasks without the “yield self” or define operations.\n"],["init","IRB::Inspector","IRB/Inspector.html#method-i-init","()","<p>Proc to call when the inspector is activated, good for requiring dependent libraries.\n"],["init","Racc::ActionTable","Racc/ActionTable.html#method-i-init","()",""],["init","Racc::Grammar","Racc/Grammar.html#method-i-init","()","<p>Computation\n"],["init_line_conversion_system","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-init_line_conversion_system","()",""],["init_ruby_model","IRB::RubyModel","IRB/RubyModel.html#method-i-init_ruby_model","()",""],["init_with","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-init_with","(o, h, node)",""],["init_with_ary","Rinda::Tuple","Rinda/Tuple.html#method-i-init_with_ary","(ary)","<p>Munges <code>ary</code> into a valid Tuple.\n"],["init_with_hash","Rinda::Tuple","Rinda/Tuple.html#method-i-init_with_hash","(hash)","<p>Ensures <code>hash</code> is a valid Tuple.\n"],["initgroups","Process","Process.html#method-c-initgroups","(p1, p2)","<p>Initializes the supplemental group access list by reading the system group database and using all groups …\n"],["initial_start_RDF","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-initial_start_RDF","(tag_name, prefix, attrs, ns)",""],["initial_start_entry","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-initial_start_entry","(tag_name, prefix, attrs, ns)",""],["initial_start_feed","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-initial_start_feed","(tag_name, prefix, attrs, ns)",""],["initial_start_rss","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-initial_start_rss","(tag_name, prefix, attrs, ns)",""],["initial_state","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-initial_state","()","<p>Creates the initial state for the resolution, based upon the {#requested} dependencies @return [DependencyState] …\n"],["initial_state","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-initial_state","()","<p>Creates the initial state for the resolution, based upon the {#requested} dependencies @return [DependencyState] …\n"],["initialize","Gem::Package","Gem/Package.html#method-i-initialize","(gem, security_policy)","<p>Creates a new package that will read or write to the file <code>gem</code>.\n"],["initialize_clone","Set","Set.html#method-i-initialize_clone","(orig)","<p>Clone internal hash.\n"],["initialize_copy","Array","Array.html#method-i-initialize_copy","(p1)","<p>Replaces the contents of <code>self</code> with the contents of <code>other_ary</code>, truncating or expanding if necessary.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["initialize_copy","Bundler::Index","Bundler/Index.html#method-i-initialize_copy","(o)",""],["initialize_copy","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-initialize_copy","(other)","<p>Initializes a copy of a {DependencyGraph}, ensuring that all {#vertices} are properly copied. @param …\n"],["initialize_copy","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-initialize_copy","(other)",""],["initialize_copy","CSV::Row","CSV/Row.html#method-i-initialize_copy","(other)",""],["initialize_copy","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-initialize_copy","(other)","<p>Initializes a copy of a {DependencyGraph}, ensuring that all {#vertices} are properly copied. @param …\n"],["initialize_copy","Gem::Specification","Gem/Specification.html#method-i-initialize_copy","(other_spec)","<p>Duplicates array_attributes from <code>other_spec</code> so state isn&#39;t shared.\n"],["initialize_copy","Hash","Hash.html#method-i-initialize_copy","(p1)","<p>Replaces the contents of <em>hsh</em> with the contents of <em>other_hash</em>.\n\n<pre>h = { &quot;a&quot; =&gt; 100, &quot;b&quot; =&gt; 200 }\nh.replace({ ...</pre>\n"],["initialize_copy","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-initialize_copy","(p1)","<p>Initializes this object from orig if it can be duplicated/cloned and returns it.\n"],["initialize_copy","Matrix","Matrix.html#method-i-initialize_copy","(m)","<p>Called for dup &amp; clone.\n"],["initialize_copy","OpenSSL::BN","OpenSSL/BN.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::Config","OpenSSL/Config.html#method-i-initialize_copy","(other)",""],["initialize_copy","OpenSSL::Digest","OpenSSL/Digest.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::OCSP::Response","OpenSSL/OCSP/Response.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKCS12","OpenSSL/PKCS12.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-initialize_copy","(p1)",""],["initialize_copy","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-initialize_copy","(p1)",""],["initialize_copy","String","String.html#method-i-initialize_copy","(p1)","<p>Replaces the contents of <em>str</em> with the corresponding values in <em>other_str</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-string\">&quot;hello&quot;</span>         <span class=\"ruby-comment\">#=&gt; &quot;hello&quot; ...</span>\n</pre>\n"],["initialize_copy","StringScanner","StringScanner.html#method-i-initialize_copy","(p1)","<p>Duplicates a StringScanner object.\n"],["initialize_copy","Vector","Vector.html#method-i-initialize_copy","(v)","<p>Called for dup &amp; clone.\n"],["initialize_copy","Zlib::Deflate","Zlib/Deflate.html#method-i-initialize_copy","(p1)","<p>Duplicates the deflate stream.\n"],["initialize_dup","Set","Set.html#method-i-initialize_dup","(orig)","<p>Dup internal hash.\n"],["initialize_have_children_elements","RSS::Element","RSS/Element.html#method-i-initialize_have_children_elements","()",""],["initialize_http_header","Net::HTTPHeader","Net/HTTPHeader.html#method-i-initialize_http_header","(initheader)",""],["initialize_methods_etc","RDoc::Context","RDoc/Context.html#method-i-initialize_methods_etc","()","<p>Sets the defaults for methods and so-forth\n"],["initialize_pattern","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-initialize_pattern","(opts = {})","<p>Constructs the default Hash of patterns.\n"],["initialize_pattern","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-initialize_pattern","(opts = {})","<p>Constructs the default Hash of patterns.\n"],["initialize_pattern","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-initialize_pattern","(opts = {})","<p>Constructs the default Hash of patterns.\n"],["initialize_pattern","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-initialize_pattern","(opts = {})","<p>Constructs the default Hash of patterns.\n"],["initialize_query","CGI::QueryExtension","CGI/QueryExtension.html#method-i-initialize_query","()","<p>A wrapper class to use a StringIO object as the body and switch to a TempFile when the passed threshold …\n"],["initialize_readline","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-c-initialize_readline","()",""],["initialize_regexp","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-initialize_regexp","(pattern)","<p>Constructs the default Hash of Regexp&#39;s.\n"],["initialize_regexp","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-initialize_regexp","(pattern)","<p>Constructs the default Hash of Regexp&#39;s.\n"],["initialize_regexp","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-initialize_regexp","(pattern)","<p>Constructs the default Hash of Regexp&#39;s.\n"],["initialize_regexp","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-initialize_regexp","(pattern)","<p>Constructs the default Hash of Regexp&#39;s.\n"],["initialize_tracer","IRB","IRB.html#method-c-initialize_tracer","()","<p>initialize tracing function\n"],["initialize_variables","RSS::Element","RSS/Element.html#method-i-initialize_variables","(attrs)",""],["initialize_variables","RSS::Maker::Base","RSS/Maker/Base.html#method-i-initialize_variables","()",""],["inject","Bundler::CLI","Bundler/CLI.html#method-i-inject","(name, version)",""],["inject","Bundler::Injector","Bundler/Injector.html#method-c-inject","(new_deps, options = {})",""],["inject","Bundler::Injector","Bundler/Injector.html#method-i-inject","(gemfile_path, lockfile_path)","<p>@param [Pathname] gemfile_path The Gemfile in which to inject the new dependency. @param [Pathname]  …\n"],["inject","Enumerable","Enumerable.html#method-i-inject","(p1 = v1, p2 = v2)","<p>Combines all elements of <em>enum</em> by applying a binary operation, specified by a block or a symbol that names …\n"],["inject","REXML::Elements","REXML/Elements.html#method-i-inject","( xpath=nil, initial=nil )",""],["inject_dependencies","Bundler::CLI::Add","Bundler/CLI/Add.html#method-i-inject_dependencies","()",""],["inject_into_class","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-inject_into_class","(path, klass, *args, &block)","<p>Injects text right after the class definition. Since it depends on insert_into_file, it&#39;s reversible. …\n"],["inject_into_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-inject_into_file","(destination, *args, &block)",""],["inject_into_list","Gem::AvailableSet","Gem/AvailableSet.html#method-i-inject_into_list","(dep_list)",""],["inject_into_module","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-inject_into_module","(path, module_name, *args, &block)","<p>Injects text right after the module definition. Since it depends on insert_into_file, it&#39;s reversible. …\n"],["inline_html?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-inline_html-3F","()","<p>Returns true if the element contains inline content that has a HTML media type.\n"],["inline_html?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-inline_html-3F","()",""],["inline_other?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-inline_other-3F","()","<p>Returns true if the element contains inline content that has a MIME media type.\n"],["inline_other?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-inline_other-3F","()",""],["inline_other_base64?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-inline_other_base64-3F","()","<p>Returns true if the element contains inline content encoded in base64.\n"],["inline_other_base64?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-inline_other_base64-3F","()",""],["inline_other_text?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-inline_other_text-3F","()","<p>Returns true if the element contains inline content that has a text media type.\n"],["inline_other_text?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-inline_other_text-3F","()",""],["inline_other_xml?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-inline_other_xml-3F","()","<p>Returns true if the element contains inline content that has a XML media type.\n"],["inline_other_xml?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-inline_other_xml-3F","()",""],["inline_text?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-inline_text-3F","()","<p>Returns true if the element contains inline content that has a text or HTML media type, or no media type …\n"],["inline_text?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-inline_text-3F","()",""],["inline_xhtml?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-inline_xhtml-3F","()","<p>Returns true if the element contains inline content that has a XHTML media type.\n"],["inline_xhtml?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-inline_xhtml-3F","()",""],["inner","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-inner","()",""],["inner_product","Vector","Vector.html#method-i-inner_product","(v)","<p>Returns the inner product of this vector with the other.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">7</span>].<span class=\"ruby-identifier\">inner_product</span> <span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">10</span>,<span class=\"ruby-value\">1</span>]  <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">47</span>\n</pre>\n"],["inner_readline","Reline::Core","Reline/Core.html#method-i-inner_readline","(prompt, add_hist, multiline, &confirm_multiline_termination)",""],["ino","File::Stat","File/Stat.html#method-i-ino","()","<p>Returns the inode number for <em>stat</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">ino</span>   <span class=\"ruby-comment\">#=&gt; 1083669</span>\n</pre>\n"],["inplace_mode","ARGF","ARGF.html#method-i-inplace_mode","()","<p>Returns the file extension appended to the names of modified files under in-place edit mode. This value …\n"],["inplace_mode=","ARGF","ARGF.html#method-i-inplace_mode-3D","(p1)","<p>Sets the filename extension for in-place editing mode to the given String. Each file being edited has …\n"],["input","Gem::MockGemUi","Gem/MockGemUi.html#method-i-input","()",""],["input=","Readline","Readline.html#method-c-input-3D","(p1)","<p>Specifies a File object <code>input</code> that is input stream for Readline.readline method.\n"],["input=","Reline::Core","Reline/Core.html#method-i-input-3D","(val)",""],["input?","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-input-3F","()","<p>Returns true if the parameter is input.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["insecure_method?","DRb::DRbServer","DRb/DRbServer.html#method-i-insecure_method-3F","(msg_id)","<p>Has a method been included in the list of insecure methods?\n"],["insert","Array","Array.html#method-i-insert","(*args)","<p>Inserts the given values before the element with the given <code>index</code>.\n<p>Negative indices count backwards from …\n"],["insert","IRB::JobManager","IRB/JobManager.html#method-i-insert","(irb)","<p>Add the given <code>irb</code> session to the jobs Array.\n"],["insert","String","String.html#method-i-insert","(p1, p2)","<p>Inserts <em>other_str</em> before the character at the given <em>index</em>, modifying <em>str</em>. Negative indices count from …\n"],["insert_after","REXML::Parent","REXML/Parent.html#method-i-insert_after","( child1, child2 )","<p>Inserts an child after another child @param child1 this is either an xpath or an Element.  If an Element …\n"],["insert_before","REXML::Parent","REXML/Parent.html#method-i-insert_before","( child1, child2 )","<p>Inserts an child before another child @param child1 this is either an xpath or an Element.  If an Element …\n"],["insert_into_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-insert_into_file","(destination, *args, &block)",""],["insert_output","Encoding::Converter","Encoding/Converter.html#method-i-insert_output","(p1)","<p>Inserts string into the encoding converter. The string will be converted to the destination encoding …\n"],["insert_text","Readline","Readline.html#method-c-insert_text","(p1)","<p>Insert text into the line at the current cursor position.\n<p>See GNU Readline&#39;s rl_insert_text function. …\n"],["insert_text","Reline","Reline.html#method-c-insert_text","(*args, &block)",""],["inside","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-inside","(dir = \"\", config = {}, &block)","<p>Do something in the root or on a provided subfolder. If a relative path is given it&#39;s referenced …\n"],["inspect","ARGF","ARGF.html#method-i-inspect","()",""],["inspect","Addrinfo","Addrinfo.html#method-i-inspect","()","<p>returns a string which shows addrinfo in human-readable form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">inspect</span> <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["inspect","Array","Array.html#method-i-inspect","()","<p>Creates a string representation of <code>self</code>, by calling #inspect on each element.\n\n<pre class=\"ruby\">[ <span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;b&quot;</span>, <span class=\"ruby-string\">&quot;c&quot;</span> ].<span class=\"ruby-identifier\">to_s</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["inspect","BigDecimal","BigDecimal.html#method-i-inspect","()","<p>Returns a string representation of self.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&quot;1234.5678&quot;</span>).<span class=\"ruby-identifier\">inspect</span>\n  <span class=\"ruby-comment\">#=&gt; &quot;0.12345678e4&quot;</span>\n</pre>\n"],["inspect","Bundler::Fetcher","Bundler/Fetcher.html#method-i-inspect","()",""],["inspect","Bundler::Index","Bundler/Index.html#method-i-inspect","()",""],["inspect","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-inspect","()","<p>@return [String] a string suitable for debugging\n"],["inspect","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-inspect","()","<p>@return [String] a string suitable for debugging\n"],["inspect","Bundler::Source","Bundler/Source.html#method-i-inspect","()",""],["inspect","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-inspect","()",""],["inspect","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-inspect","()",""],["inspect","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-inspect","()",""],["inspect","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-inspect","()",""],["inspect","CGI::Cookie","CGI/Cookie.html#method-i-inspect","()","<p>A summary of cookie string.\n"],["inspect","CSV","CSV.html#method-i-inspect","()","<p>Returns a simplified description of the key CSV attributes in an ASCII compatible String.\n"],["inspect","CSV::Row","CSV/Row.html#method-i-inspect","()","<p>A summary of fields, by header, in an ASCII compatible String.\n"],["inspect","CSV::Table","CSV/Table.html#method-i-inspect","()","<p>Shows the mode and size of this table in a US-ASCII String.\n"],["inspect","Complex","Complex.html#method-i-inspect","()","<p>Returns the value as a string for inspection.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">inspect</span>                       <span class=\"ruby-comment\">#=&gt; &quot;(2+0i)&quot;</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-string\">&#39;-8/6&#39;</span>).<span class=\"ruby-identifier\">inspect</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["inspect","Date","Date.html#method-i-inspect","()","<p>Returns the value as a string for inspection.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">inspect</span>\n          <span class=\"ruby-comment\">#=&gt; &quot;#&lt;Date: 2001-02-03&gt;&quot; ...</span>\n</pre>\n"],["inspect","Digest::Instance","Digest/Instance.html#method-i-inspect","()","<p>Creates a printable version of the digest object.\n"],["inspect","Dir","Dir.html#method-i-inspect","()","<p>Return a string describing this Dir object.\n"],["inspect","ENV","ENV.html#method-c-inspect","()","<p>Returns the contents of the environment as a String.\n"],["inspect","Encoding","Encoding.html#method-i-inspect","()","<p>Returns a string which represents the encoding for programmers.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">UTF_8</span>.<span class=\"ruby-identifier\">inspect</span>       <span class=\"ruby-comment\">#=&gt; &quot;#&lt;Encoding:UTF-8&gt;&quot; ...</span>\n</pre>\n"],["inspect","Encoding::Converter","Encoding/Converter.html#method-i-inspect","()","<p>Returns a printable version of <em>ec</em>\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ec</span> = <span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Converter</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;iso-8859-1&quot;</span>, <span class=\"ruby-string\">&quot;utf-8&quot;</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-identifier\">ec</span>.<span class=\"ruby-identifier\">inspect</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["inspect","Enumerator","Enumerator.html#method-i-inspect","()","<p>Creates a printable version of <em>e</em>.\n"],["inspect","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-inspect","()","<p>Convert this arithmetic sequence to a printable form.\n"],["inspect","Enumerator::Chain","Enumerator/Chain.html#method-i-inspect","()","<p>Returns a printable version of the enumerator chain.\n"],["inspect","Exception","Exception.html#method-i-inspect","()","<p>Return this exception&#39;s class name and message.\n"],["inspect","FalseClass","FalseClass.html#method-i-inspect","()",""],["inspect","Fiber","Fiber.html#method-i-inspect","()",""],["inspect","Fiddle::Pointer","Fiddle/Pointer.html#method-i-inspect","()","<p>Returns a string formatted with an easily readable representation of the internal state of the pointer. …\n"],["inspect","File::Stat","File/Stat.html#method-i-inspect","()","<p>Produce a nicely formatted description of <em>stat</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/etc/passwd&quot;</span>).<span class=\"ruby-identifier\">inspect</span>\n   <span class=\"ruby-comment\">#=&gt; &quot;#&lt;File::Stat ...</span>\n</pre>\n"],["inspect","Float","Float.html#method-i-inspect","()",""],["inspect","Gem::Platform","Gem/Platform.html#method-i-inspect","()",""],["inspect","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-inspect","()","<p>@return [String] a string suitable for debugging\n"],["inspect","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-inspect","()","<p>@return [String] a string suitable for debugging\n"],["inspect","Hash","Hash.html#method-i-inspect","()","<p>Return the contents of this hash as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;c&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">300</span>, <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;d&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">400</span>, <span class=\"ruby-string\">&quot;c&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">300</span>  } <span class=\"ruby-operator\">...</span>\n</pre>\n"],["inspect","IO","IO.html#method-i-inspect","()","<p>Return a string describing this IO object.\n"],["inspect","IPAddr","IPAddr.html#method-i-inspect","()","<p>Returns a string containing a human-readable representation of the ipaddr. (“#&lt;IPAddr: family:address/mask&gt;”) …\n"],["inspect","IPSocket","IPSocket.html#method-i-inspect","()","<p>Return a string describing this IPSocket object.\n"],["inspect","IRB::FileInputMethod","IRB/FileInputMethod.html#method-i-inspect","()","<p>For debug message\n"],["inspect","IRB::InputMethod","IRB/InputMethod.html#method-i-inspect","()","<p>For debug message\n"],["inspect","IRB::Irb","IRB/Irb.html#method-i-inspect","()","<p>Outputs the local variables to this current session, including #signal_status and #context, using IRB::Locale …\n"],["inspect","IRB::JobManager","IRB/JobManager.html#method-i-inspect","()","<p>Outputs a list of jobs, see the irb command <code>irb_jobs</code>, or <code>jobs</code>.\n"],["inspect","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-i-inspect","()","<p>For debug message\n"],["inspect","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-inspect","()","<p>For debug message\n"],["inspect","IRB::StdioInputMethod","IRB/StdioInputMethod.html#method-i-inspect","()","<p>For debug message\n"],["inspect","Integer","Integer.html#method-i-inspect","(*args)",""],["inspect","MatchData","MatchData.html#method-i-inspect","()","<p>Returns a printable version of <em>mtch</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">puts</span> <span class=\"ruby-regexp\">/.$/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;foo&quot;</span>).<span class=\"ruby-identifier\">inspect</span>\n<span class=\"ruby-comment\">#=&gt; #&lt;MatchData &quot;o&quot;&gt;</span>\n\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-regexp\">/(.)(.)(.)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;foo&quot;</span>).<span class=\"ruby-identifier\">inspect</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["inspect","Matrix","Matrix.html#method-i-inspect","()","<p>Overrides Object#inspect\n"],["inspect","Method","Method.html#method-i-inspect","()","<p>Returns a human-readable description of the underlying method.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;cat&quot;</span>.<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:count</span>).<span class=\"ruby-identifier\">inspect</span>   <span class=\"ruby-comment\">#=&gt; &quot;#&lt;Method: ...</span>\n</pre>\n"],["inspect","Module","Module.html#method-i-inspect","()",""],["inspect","Net::HTTP","Net/HTTP.html#method-i-inspect","()",""],["inspect","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-inspect","()",""],["inspect","Net::HTTPResponse","Net/HTTPResponse.html#method-i-inspect","()",""],["inspect","Net::POP3","Net/POP3.html#method-i-inspect","()","<p>Provide human-readable stringification of class state.\n"],["inspect","Net::POPMail","Net/POPMail.html#method-i-inspect","()","<p>Provide human-readable stringification of class state.\n"],["inspect","Net::SMTP","Net/SMTP.html#method-i-inspect","()","<p>Provide human-readable stringification of class state.\n"],["inspect","Net::WriteAdapter","Net/WriteAdapter.html#method-i-inspect","()",""],["inspect","NilClass","NilClass.html#method-i-inspect","()","<p>Always returns the string “nil”.\n"],["inspect","Object","Object.html#method-i-inspect","()","<p>Returns a string containing a human-readable representation of <em>obj</em>. The default #inspect shows the object&#39;s …\n"],["inspect","ObjectSpace::InternalObjectWrapper","ObjectSpace/InternalObjectWrapper.html#method-i-inspect","()","<p>See Object#inspect.\n"],["inspect","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-inspect","()",""],["inspect","OpenSSL::Config","OpenSSL/Config.html#method-i-inspect","()","<p>String representation of this configuration object, including the class name and its sections.\n"],["inspect","OpenSSL::Engine","OpenSSL/Engine.html#method-i-inspect","()","<p>Pretty prints this engine.\n"],["inspect","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-inspect","()",""],["inspect","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-inspect","()",""],["inspect","OpenStruct","OpenStruct.html#method-i-inspect","()","<p>Returns a string containing a detailed summary of the keys and values.\n"],["inspect","OptionParser::ParseError","OptionParser/ParseError.html#method-i-inspect","()",""],["inspect","Proc","Proc.html#method-i-inspect","()",""],["inspect","Process::Status","Process/Status.html#method-i-inspect","()","<p>Override the inspection method.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">system</span>(<span class=\"ruby-string\">&quot;false&quot;</span>)\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-identifier\">$?</span>.<span class=\"ruby-identifier\">inspect</span> <span class=\"ruby-comment\">#=&gt; &quot;#&lt;Process::Status: pid 12861 exit 1&gt;&quot;</span>\n</pre>\n"],["inspect","REXML::Attribute","REXML/Attribute.html#method-i-inspect","()",""],["inspect","REXML::Element","REXML/Element.html#method-i-inspect","()",""],["inspect","REXML::Instruction","REXML/Instruction.html#method-i-inspect","()",""],["inspect","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-inspect","()",""],["inspect","REXML::Text","REXML/Text.html#method-i-inspect","()",""],["inspect","REXML::Validation::Choice","REXML/Validation/Choice.html#method-i-inspect","()",""],["inspect","REXML::Validation::Event","REXML/Validation/Event.html#method-i-inspect","()",""],["inspect","REXML::Validation::Interleave","REXML/Validation/Interleave.html#method-i-inspect","()",""],["inspect","REXML::Validation::Ref","REXML/Validation/Ref.html#method-i-inspect","()",""],["inspect","REXML::Validation::State","REXML/Validation/State.html#method-i-inspect","()",""],["inspect","REXML::XMLDecl","REXML/XMLDecl.html#method-i-inspect","()",""],["inspect","Racc::Accept","Racc/Accept.html#method-i-inspect","()",""],["inspect","Racc::Error","Racc/Error.html#method-i-inspect","()",""],["inspect","Racc::Goto","Racc/Goto.html#method-i-inspect","()",""],["inspect","Racc::ISet","Racc/ISet.html#method-i-inspect","()",""],["inspect","Racc::LocationPointer","Racc/LocationPointer.html#method-i-inspect","()",""],["inspect","Racc::OrMark","Racc/OrMark.html#method-i-inspect","()",""],["inspect","Racc::Prec","Racc/Prec.html#method-i-inspect","()",""],["inspect","Racc::Reduce","Racc/Reduce.html#method-i-inspect","()",""],["inspect","Racc::Rule","Racc/Rule.html#method-i-inspect","()",""],["inspect","Racc::Shift","Racc/Shift.html#method-i-inspect","()",""],["inspect","Racc::State","Racc/State.html#method-i-inspect","()",""],["inspect","Racc::States","Racc/States.html#method-i-inspect","()",""],["inspect","Racc::Sym","Racc/Sym.html#method-i-inspect","()",""],["inspect","Racc::UserAction","Racc/UserAction.html#method-i-inspect","()",""],["inspect","Range","Range.html#method-i-inspect","()","<p>Convert this range object to a printable form (using #inspect to convert the begin and end objects). …\n"],["inspect","Rational","Rational.html#method-i-inspect","()","<p>Returns the value as a string for inspection.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">inspect</span>      <span class=\"ruby-comment\">#=&gt; &quot;(2/1)&quot;</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">-8</span>, <span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">inspect</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["inspect","Regexp","Regexp.html#method-i-inspect","()","<p>Produce a nicely formatted string-version of <em>rxp</em>. Perhaps surprisingly, <code>#inspect</code> actually produces the …\n"],["inspect","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-inspect","()","<p>Returns debugging information about this node as a string.\n"],["inspect","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-inspect","()","<p>Returns a human-readable string representation of this instruction sequence, including the #label and …\n"],["inspect","Set","Set.html#method-i-inspect","()","<p>Returns a string containing a human-readable representation of the set (“#&lt;Set: {element1, element2, …\n"],["inspect","Socket::AncillaryData","Socket/AncillaryData.html#method-i-inspect","()","<p>returns a string which shows ancillarydata in human-readable form.\n\n<pre>p Socket::AncillaryData.new(:INET6, ...</pre>\n"],["inspect","Socket::Ifaddr","Socket/Ifaddr.html#method-i-inspect","()","<p>Returns a string to show contents of <em>ifaddr</em>.\n"],["inspect","Socket::Option","Socket/Option.html#method-i-inspect","()","<p>Returns a string which shows sockopt in human-readable form.\n\n<pre>p Socket::Option.new(:INET, :SOCKET, :KEEPALIVE, ...</pre>\n"],["inspect","String","String.html#method-i-inspect","()","<p>Returns a printable version of <em>str</em>, surrounded by quote marks, with special characters escaped.\n\n<pre>str = ...</pre>\n"],["inspect","StringScanner","StringScanner.html#method-i-inspect","()","<p>Returns a string that represents the StringScanner object, showing:\n<p>the current position\n<p>the size of the …\n"],["inspect","Struct","Struct.html#method-i-inspect","()","<p>Returns a description of this struct as a string.\n"],["inspect","Symbol","Symbol.html#method-i-inspect","()","<p>Returns the representation of <em>sym</em> as a symbol literal.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">:fred</span>.<span class=\"ruby-identifier\">inspect</span>   <span class=\"ruby-comment\">#=&gt; &quot;:fred&quot;</span>\n</pre>\n"],["inspect","Syslog","Syslog.html#method-c-inspect","()","<p>Returns an inspect() string summarizing the object state.\n"],["inspect","Thread","Thread.html#method-i-inspect","()",""],["inspect","Thread::Backtrace::Location","Thread/Backtrace/Location.html#method-i-inspect","()","<p>Returns the same as calling <code>inspect</code> on the string representation of #to_str\n"],["inspect","Time","Time.html#method-i-inspect","()","<p>Returns a detailed string representing <em>time</em>. Unlike to_s, preserves nanoseconds in the representation …\n"],["inspect","TracePoint","TracePoint.html#method-i-inspect","()","<p>Return a string containing a human-readable TracePoint status.\n"],["inspect","TrueClass","TrueClass.html#method-i-inspect","()",""],["inspect","URI::Generic","URI/Generic.html#method-i-inspect","()",""],["inspect","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-inspect","()",""],["inspect","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-inspect","()",""],["inspect","UnboundMethod","UnboundMethod.html#method-i-inspect","()","<p>Returns a human-readable description of the underlying method.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;cat&quot;</span>.<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:count</span>).<span class=\"ruby-identifier\">inspect</span>   <span class=\"ruby-comment\">#=&gt; &quot;#&lt;Method: ...</span>\n</pre>\n"],["inspect","Vector","Vector.html#method-i-inspect","()","<p>Overrides Object#inspect\n"],["inspect","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-inspect","()","<p>Returns the method name with class name.\n"],["inspect","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-inspect","()","<p>Returns the parameter name with class name. If the parameter has default value, then returns name=value …\n"],["inspect","WIN32OLE_RECORD","WIN32OLE_RECORD.html#method-i-inspect","()","<p>Returns the OLE struct name and member name and the value of member\n<p>If COM server in VB.NET ComServer …\n"],["inspect","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-inspect","()","<p>Returns the type name with class name.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ie</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;InternetExplorer.Application&#39;</span>)\n<span class=\"ruby-identifier\">ie</span>.<span class=\"ruby-identifier\">ole_type</span>.<span class=\"ruby-identifier\">inspect</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["inspect","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-inspect","()","<p>Returns the type library name with class name.\n\n<pre>tlib = WIN32OLE_TYPELIB.new(&#39;Microsoft Excel 9.0 Object ...</pre>\n"],["inspect","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-inspect","()","<p>Returns the OLE variable name and the value with class name.\n"],["inspect","Zlib::GzipFile::Error","Zlib/GzipFile/Error.html#method-i-inspect","()","<p>Constructs a String of the GzipFile Error\n"],["inspect?","IRB::Context","IRB/Context.html#method-i-inspect-3F","()","<p>Whether #inspect_mode is set or not, see #inspect_mode= for more detail.\n"],["inspect_colorable?","IRB::Color","IRB/Color.html#method-c-inspect_colorable-3F","(obj, seen: {}.compare_by_identity)",""],["inspect_mode=","IRB::Context","IRB/Context.html#method-i-inspect_mode-3D","(opt)","<p>Specifies the inspect mode with <code>opt</code>:\n<p><code>true</code> &mdash; display <code>inspect</code>\n<p><code>false</code> &mdash; display <code>to_s</code>\n"],["inspect_raw","Date","Date.html#method-i-inspect_raw","()",""],["inspect_sockaddr","Addrinfo","Addrinfo.html#method-i-inspect_sockaddr","()","<p>returns a string which shows the sockaddr in <em>addrinfo</em> with human-readable form.\n\n<pre>Addrinfo.tcp(&quot;localhost&quot;, ...</pre>\n"],["inspect_value","IRB::Inspector","IRB/Inspector.html#method-i-inspect_value","(v)","<p>Proc to call when the input is evaluated and output in irb.\n"],["install","Bundler::CLI","Bundler/CLI.html#method-i-install","()",""],["install","Bundler::CLI::Cache","Bundler/CLI/Cache.html#method-i-install","()",""],["install","Bundler::CLI::Package","Bundler/CLI/Package.html#method-i-install","()",""],["install","Bundler::CLI::Plugin","Bundler/CLI/Plugin.html#method-i-install","(*plugins)",""],["install","Bundler::FileUtils","Bundler/FileUtils.html#method-i-install","(src, dest, mode: nil, owner: nil, group: nil, preserve: nil, noop: nil, verbose: nil)","<p>If <code>src</code> is not same as <code>dest</code>, copies it and changes the permission mode to <code>mode</code>.  If <code>dest</code> is a directory, …\n"],["install","Bundler::FileUtils","Bundler/FileUtils.html#method-c-install","(src, dest, mode: nil, owner: nil, group: nil, preserve: nil, noop: nil, verbose: nil)","<p>If <code>src</code> is not same as <code>dest</code>, copies it and changes the permission mode to <code>mode</code>.  If <code>dest</code> is a directory, …\n"],["install","Bundler::GemHelper","Bundler/GemHelper.html#method-i-install","()",""],["install","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-install","()",""],["install","Bundler::Installer","Bundler/Installer.html#method-c-install","(root, definition, options = {})","<p>Begins the installation process for Bundler. For more information see the #run method on this class. …\n"],["install","Bundler::Installer","Bundler/Installer.html#method-i-install","(options)","<p>the order that the resolver provides is significant, since dependencies might affect the installation …\n"],["install","Bundler::Plugin","Bundler/Plugin.html#method-i-install","(names, options)","<p>Installs a new plugin by the given name\n<p>@param [Array&lt;String&gt;] names the name of plugin to be installed …\n"],["install","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-install","(spec, opts)","<p>Install the gem specified by the spec at appropriate path. `install_path` provides a sufficient default, …\n"],["install","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-install","(names, options)",""],["install","Bundler::Source::Git","Bundler/Source/Git.html#method-i-install","(spec, options = {})",""],["install","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-install","(spec, _opts = {})",""],["install","Bundler::Source::Path","Bundler/Source/Path.html#method-i-install","(spec, options = {})",""],["install","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-install","(spec, opts = {})",""],["install","FileUtils","FileUtils.html#method-i-install","(src, dest, mode: nil, owner: nil, group: nil, preserve: nil, noop: nil, verbose: nil)","<p>If <code>src</code> is not same as <code>dest</code>, copies it and changes the permission mode to <code>mode</code>.  If <code>dest</code> is a directory, …\n"],["install","FileUtils","FileUtils.html#method-c-install","(src, dest, mode: nil, owner: nil, group: nil, preserve: nil, noop: nil, verbose: nil)","<p>If <code>src</code> is not same as <code>dest</code>, copies it and changes the permission mode to <code>mode</code>.  If <code>dest</code> is a directory, …\n"],["install","Gem","Gem.html#method-c-install","(name, version = Gem::Requirement.default, *options)","<p>Top level install helper method. Allows you to install gems interactively:\n\n<pre>% irb\n&gt;&gt; Gem.install &quot;minitest&quot; ...</pre>\n"],["install","Gem::DependencyInstaller","Gem/DependencyInstaller.html#method-i-install","(dep_or_name, version = Gem::Requirement.default)","<p>Installs the gem <code>dep_or_name</code> and all its dependencies.  Returns an Array of installed gem specifications. …\n"],["install","Gem::Installer","Gem/Installer.html#method-i-install","()","<p>Installs the gem and returns a loaded Gem::Specification for the installed gem.\n<p>The gem will be installed …\n"],["install","Gem::RequestSet","Gem/RequestSet.html#method-i-install","(options)","<p>Installs gems for this RequestSet using the Gem::Installer <code>options</code>.\n<p>If a <code>block</code> is given an activation …\n"],["install","Gem::Resolver::GitSpecification","Gem/Resolver/GitSpecification.html#method-i-install","(options = {})","<p>Installing a git gem only involves building the extensions and generating the executables.\n"],["install","Gem::Resolver::InstalledSpecification","Gem/Resolver/InstalledSpecification.html#method-i-install","(options = {})","<p>This is a null install as this specification is already installed. <code>options</code> are ignored.\n"],["install","Gem::Resolver::LockSpecification","Gem/Resolver/LockSpecification.html#method-i-install","(options = {})","<p>This is a null install as a locked specification is considered installed. <code>options</code> are ignored.\n"],["install","Gem::Resolver::Specification","Gem/Resolver/Specification.html#method-i-install","(options = {})","<p>Installs this specification using the Gem::Installer <code>options</code>.  The install method yields a Gem::Installer …\n"],["install","Gem::Resolver::VendorSpecification","Gem/Resolver/VendorSpecification.html#method-i-install","(options = {})","<p>This is a null install as this gem was unpacked into a directory. <code>options</code> are ignored.\n"],["install_accessor_base","RSS::BaseListener","RSS/BaseListener.html#method-c-install_accessor_base","(uri, tag_name, accessor_base)","<p>set the accessor for the uri, tag_name pair\n"],["install_acl","DRb","DRb.html#method-i-install_acl","(acl)","<p>Set the default ACL to <code>acl</code>.\n<p>See DRb::DRbServer.default_acl.\n"],["install_acl","DRb","DRb.html#method-c-install_acl","(acl)","<p>Set the default ACL to <code>acl</code>.\n<p>See DRb::DRbServer.default_acl.\n"],["install_alias_method","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-i-install_alias_method","(to, from, override = NO_OVERRIDE)","<p>Installs alias methods for the default irb commands, see ::install_extend_commands.\n"],["install_all_sources","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-install_all_sources","(names, version, git_source_options, rubygems_source)",""],["install_class_name","RSS::BaseListener","RSS/BaseListener.html#method-c-install_class_name","(uri, tag_name, class_name)","<p>record class_name for the supplied uri and tag_name\n"],["install_date_element","RSS::BaseModel","RSS/BaseModel.html#method-i-install_date_element","(tag_name, uri, occurs, name=nil, type=nil, disp_name=nil)",""],["install_default_bundler_gem","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-install_default_bundler_gem","(bin_dir)",""],["install_default_gems","Gem::TestCase","Gem/TestCase.html#method-i-install_default_gems","(*specs)","<p>Installs the provided default specs including writing the spec file\n"],["install_default_specs","Gem::TestCase","Gem/TestCase.html#method-i-install_default_specs","(*specs)","<p>Install the provided default specs\n"],["install_definition","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-install_definition","(definition)","<p>Installs the plugin from Definition object created by limited parsing of Gemfile searching for plugins …\n"],["install_dublin_core","RSS::Maker::DublinCoreModel","RSS/Maker/DublinCoreModel.html#method-c-install_dublin_core","(klass)",""],["install_element","RSS::BaseModel","RSS/BaseModel.html#method-i-install_element","(name, postfix=\"\")",""],["install_error_message","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-install_error_message","()",""],["install_executables","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-install_executables","(bin_dir)",""],["install_extend_commands","IRB::ContextExtender","IRB/ContextExtender.html#method-c-install_extend_commands","()","<p>Installs the default context extensions as irb commands:\n<p>Context#eval_history= &mdash; <code>irb/ext/history.rb</code>\n<p>Context#use_tracer= … &mdash; "],["install_extend_commands","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-c-install_extend_commands","()","<p>Installs the default irb commands:\n<p><code>irb_current_working_workspace</code> &mdash; Context#main\n<p><code>irb_change_workspace</code> &mdash; Context#change_workspace …\n"],["install_file","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-install_file","(file, dest_dir)",""],["install_from_gemdeps","Gem::RequestSet","Gem/RequestSet.html#method-i-install_from_gemdeps","(options, &block)","<p>Installs from the gem dependencies files in the <code>:gemdeps</code> option in <code>options</code>, yielding to the <code>block</code> as …\n"],["install_from_spec","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-install_from_spec","()",""],["install_from_specs","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-install_from_specs","(specs)","<p>Installs the plugins and deps from the provided specs and returns map of gems to their paths\n<p>@param specs …\n"],["install_gem","Bundler::GemHelper","Bundler/GemHelper.html#method-i-install_gem","(built_gem_path = nil, local = false)",""],["install_gem","Gem::TestCase","Gem/TestCase.html#method-i-install_gem","(spec, options = {})","<p>Builds and installs the Gem::Specification <code>spec</code>\n"],["install_gem_user","Gem::TestCase","Gem/TestCase.html#method-i-install_gem_user","(spec)","<p>Builds and installs the Gem::Specification <code>spec</code> into the user dir\n"],["install_get_attribute","RSS::Element","RSS/Element.html#method-c-install_get_attribute","(name, uri, required=true, type=nil, disp_name=nil, element_name=nil)",""],["install_get_text_element","RSS::BaseListener","RSS/BaseListener.html#method-c-install_get_text_element","(uri, name, accessor_base)",""],["install_git","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-install_git","(names, version, options)",""],["install_have_attribute_element","RSS::BaseModel","RSS/BaseModel.html#method-i-install_have_attribute_element","(tag_name, uri, occurs, name=nil, type=nil)",""],["install_have_child_element","RSS::BaseModel","RSS/BaseModel.html#method-i-install_have_child_element","(tag_name, uri, occurs, name=nil, type=nil)",""],["install_have_children_element","RSS::BaseModel","RSS/BaseModel.html#method-i-install_have_children_element","(tag_name, uri, occurs, name=nil, plural_name=nil)",""],["install_hooks","Gem::RequestSet","Gem/RequestSet.html#method-i-install_hooks","(requests, options)","<p>Call hooks on installed gems\n"],["install_id_conv","DRb","DRb.html#method-c-install_id_conv","(idconv)","<p>Set the default id conversion object.\n<p>This is expected to be an instance such as DRb::DRbIdConv that responds …\n"],["install_id_conv","DRb","DRb.html#method-i-install_id_conv","(idconv)","<p>Set the default id conversion object.\n<p>This is expected to be an instance such as DRb::DRbIdConv that responds …\n"],["install_if","Bundler::Dsl","Bundler/Dsl.html#method-i-install_if","(*args)",""],["install_image_favicon","RSS::Maker::ImageFaviconModel","RSS/Maker/ImageFaviconModel.html#method-c-install_image_favicon","(klass)",""],["install_image_item","RSS::Maker::ImageItemModel","RSS/Maker/ImageItemModel.html#method-c-install_image_item","(klass)",""],["install_in_parallel","Bundler::Installer","Bundler/Installer.html#method-i-install_in_parallel","(size, standalone, force = false)",""],["install_indices","Gem::Indexer","Gem/Indexer.html#method-i-install_indices","()","<p>Install generated indices into the destination directory.\n"],["install_into","Gem::RequestSet","Gem/RequestSet.html#method-i-install_into","(dir, force = true, options = {})",""],["install_lib","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-install_lib","(lib_dir)",""],["install_list","ACL","ACL.html#method-i-install_list","(list)","<p>Adds <code>list</code> of ACL entries to this ACL.\n"],["install_local_git","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-install_local_git","(names, version, options)",""],["install_model","RSS::Element","RSS/Element.html#method-c-install_model","(tag, uri, occurs=nil, getter=nil, plural=false)",""],["install_must_call_validator","RSS::Element","RSS/Element.html#method-c-install_must_call_validator","(prefix, uri)",""],["install_ns","RSS::Element","RSS/Element.html#method-c-install_ns","(prefix, uri)",""],["install_path","Bundler","Bundler.html#method-c-install_path","()",""],["install_path","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-install_path","()","<p>A default installation path to install a single gem. If the source servers multiple gems, it&#39;s not …\n"],["install_path","Bundler::Plugin::Installer::Git","Bundler/Plugin/Installer/Git.html#method-i-install_path","()",""],["install_path","Bundler::Source::Git","Bundler/Source/Git.html#method-i-install_path","()","<p>This is the path which is going to contain a specific checkout of the git repository. When using local …\n"],["install_rdoc","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-install_rdoc","()",""],["install_rubygems","Bundler::Plugin::Installer","Bundler/Plugin/Installer.html#method-i-install_rubygems","(names, version, sources)","<p>Installs the plugin from rubygems source and returns the path where the plugin was installed\n<p>@param [String] …\n"],["install_serially","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-install_serially","()",""],["install_siginfo_handler","RDoc::RDoc","RDoc/RDoc.html#method-i-install_siginfo_handler","()","<p>Installs a siginfo handler that prints the current filename.\n"],["install_specs","Gem::TestCase","Gem/TestCase.html#method-i-install_specs","(*specs)","<p>Install the provided specs\n"],["install_tasks","Bundler::GemHelper","Bundler/GemHelper.html#method-c-install_tasks","(opts = {})",""],["install_taxo_topic","RSS::Maker::TaxonomyTopicModel","RSS/Maker/TaxonomyTopicModel.html#method-c-install_taxo_topic","(klass)",""],["install_taxo_topics","RSS::Maker::TaxonomyTopicsModel","RSS/Maker/TaxonomyTopicsModel.html#method-c-install_taxo_topics","(klass)",""],["install_text_element","RSS::BaseModel","RSS/BaseModel.html#method-i-install_text_element","(tag_name, uri, occurs, name=nil, type=nil, disp_name=nil)",""],["install_update_defaults_str","Gem::InstallUpdateOptions","Gem/InstallUpdateOptions.html#method-i-install_update_defaults_str","()","<p>Default options for the gem install command.\n"],["install_with_build_args","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-install_with_build_args","(args)",""],["install_with_settings","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-install_with_settings","()",""],["install_with_worker","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-install_with_worker","()",""],["installable?","Gem::Platform","Gem/Platform.html#method-c-installable-3F","(spec)",""],["installable_platform?","Gem::Resolver::InstalledSpecification","Gem/Resolver/InstalledSpecification.html#method-i-installable_platform-3F","()","<p>Returns <code>true</code> if this gem is installable for the current platform.\n"],["installable_platform?","Gem::Resolver::LocalSpecification","Gem/Resolver/LocalSpecification.html#method-i-installable_platform-3F","()","<p>Returns <code>true</code> if this gem is installable for the current platform.\n"],["installable_platform?","Gem::Resolver::Specification","Gem/Resolver/Specification.html#method-i-installable_platform-3F","()","<p>Returns true if this specification is installable on this platform.\n"],["installation_attempted?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-installation_attempted-3F","()",""],["installation_parallelization","Bundler::Installer","Bundler/Installer.html#method-i-installation_parallelization","(options)",""],["installation_satisfies_dependency?","Gem::Installer","Gem/Installer.html#method-i-installation_satisfies_dependency-3F","(dependency)","<p>True if the gems in the system satisfy <code>dependency</code>.\n"],["installed?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-installed-3F","()",""],["installed?","Bundler::Plugin","Bundler/Plugin.html#method-i-installed-3F","(plugin)","<p>currently only intended for specs\n<p>@return [String, nil] installed path\n"],["installed?","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-installed-3F","()","<p>A helper method, not necessary if not used internally.\n"],["installed?","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-installed-3F","(name)",""],["installed?","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-installed-3F","(spec)",""],["installed?","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-installed-3F","(name, req = Gem::Requirement.default)","<p>Check if gem <code>name</code> version <code>version</code> is installed.\n"],["installed?","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-installed-3F","()","<p>True if the requested gem has already been installed.\n"],["installed_docs","RDoc::Servlet","RDoc/Servlet.html#method-i-installed_docs","()","<p>Returns an Array of installed documentation.\n<p>Each entry contains the documentation name (gem name, &#39;Ruby …\n"],["installed_plugins","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-installed_plugins","()",""],["installed_specs","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-installed_specs","()",""],["installed_specs","Gem::Installer","Gem/Installer.html#method-i-installed_specs","()","<p>Return an Array of Specifications contained within the gem_home we&#39;ll be installing into.\n"],["installed_stubs","Gem::Specification","Gem/Specification.html#method-c-installed_stubs","(dirs, pattern)",""],["instance","CSV","CSV.html#method-c-instance","(data = $stdout, **options)","<p>This method will return a CSV instance, just like CSV::new(), but the instance will be cached and returned …\n"],["instance","Gem::CommandManager","Gem/CommandManager.html#method-i-instance","()","<p>Returns self. Allows a CommandManager instance to stand in for the class itself.\n"],["instance","Gem::CommandManager","Gem/CommandManager.html#method-c-instance","()","<p>Return the authoritative instance of the command manager.\n"],["instance","Singleton","Singleton.html#method-c-instance","","<p>Returns the singleton instance.\n"],["instance","Syslog","Syslog.html#method-c-instance","()","<p>Returns self, for backward compatibility.\n"],["instance_attributes","RDoc::Context","RDoc/Context.html#method-i-instance_attributes","()","<p>Instance attributes\n"],["instance_delegate","Forwardable","Forwardable.html#method-i-instance_delegate","(hash)","<p>Takes a hash as its argument.  The key is a symbol or an array of symbols.  These symbols correspond …\n"],["instance_eval","BasicObject","BasicObject.html#method-i-instance_eval","(*args)","<p>Evaluates a string containing Ruby source code, or the given block, within the context of the receiver …\n"],["instance_exec","BasicObject","BasicObject.html#method-i-instance_exec","(*args)","<p>Executes the given block within the context of the receiver (<em>obj</em>). In order to set the context, the variable …\n"],["instance_method","Module","Module.html#method-i-instance_method","(p1)","<p>Returns an <code>UnboundMethod</code> representing the given instance method in <em>mod</em>.\n\n<pre>class Interpreter\n  def do_a() ...</pre>\n"],["instance_method_list","RDoc::Context","RDoc/Context.html#method-i-instance_method_list","()","<p>Instance methods\n"],["instance_methods","Module","Module.html#method-i-instance_methods","(*args)","<p>Returns an array containing the names of the public and protected instance methods in the receiver.  …\n"],["instance_methods","RDoc::Store","RDoc/Store.html#method-i-instance_methods","()","<p>Instance methods cache accessor.  Maps a class to an Array of its instance methods (not full name).\n"],["instance_of?","Object","Object.html#method-i-instance_of-3F","(p1)","<p>Returns <code>true</code> if <em>obj</em> is an instance of the given class. See also Object#kind_of?.\n\n<pre>class A;     end\nclass ...</pre>\n"],["instance_variable_defined?","Object","Object.html#method-i-instance_variable_defined-3F","(p1)","<p>Returns <code>true</code> if the given instance variable is defined in <em>obj</em>. String arguments are converted to symbols. …\n"],["instance_variable_get","Object","Object.html#method-i-instance_variable_get","(p1)","<p>Returns the value of the given instance variable, or nil if the instance variable is not set. The <code>@</code> part …\n"],["instance_variable_set","Object","Object.html#method-i-instance_variable_set","(p1, p2)","<p>Sets the instance variable named by <em>symbol</em> to the given object, thereby frustrating the efforts of the …\n"],["instance_variables","Object","Object.html#method-i-instance_variables","()","<p>Returns an array of instance variable names for the receiver. Note that simply defining an accessor does …\n"],["instruction","REXML::StreamListener","REXML/StreamListener.html#method-i-instruction","(name, instruction)","<p>Called when an instruction is encountered.  EG: &lt;?xsl sheet=&#39;foo&#39;?&gt; @p name the instruction …\n"],["instruction","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-instruction","(name, content)",""],["instruction?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-instruction-3F","()","<p>Content: [ String text ]\n"],["instruction_sequence","TracePoint","TracePoint.html#method-i-instruction_sequence","()","<p>Compiled instruction sequence represented by a RubyVM::InstructionSequence instance on the <code>:script_compiled</code> …\n"],["instructions","REXML::Element","REXML/Element.html#method-i-instructions","()","<p>Get an array of all Instruction children. IMMUTABLE\n"],["int","Socket::AncillaryData","Socket/AncillaryData.html#method-i-int","()","<p>Returns the data in <em>ancillarydata</em> as an int.\n<p>The size and endian is dependent on the host.\n\n<pre>ancdata = Socket::AncillaryData.int(:UNIX, ...</pre>\n"],["int","Socket::AncillaryData","Socket/AncillaryData.html#method-c-int","(p1, p2, p3, p4)","<p>Creates a new Socket::AncillaryData object which contains a int as data.\n<p>The size and endian is dependent …\n"],["int","Socket::Option","Socket/Option.html#method-c-int","(p1, p2, p3, p4)","<p>Creates a new Socket::Option object which contains an int as data.\n<p>The size and endian is dependent on …\n"],["int","Socket::Option","Socket/Option.html#method-i-int","()","<p>Returns the data in <em>sockopt</em> as an int.\n<p>The size and endian is dependent on the platform.\n\n<pre>sockopt = Socket::Option.int(:INET, ...</pre>\n"],["int_from_prime_division","Prime","Prime.html#method-i-int_from_prime_division","(pd)","<p>Re-composes a prime factorization and returns the product.\n<p>Parameters\n<p><code>pd</code> &mdash; Array of pairs of integers. The …\n"],["integer?","Integer","Integer.html#method-i-integer-3F","()","<p>Since <code>int</code> is already an Integer, this always returns <code>true</code>.\n"],["integer?","Numeric","Numeric.html#method-i-integer-3F","()","<p>Returns <code>true</code> if <code>num</code> is an Integer.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1.0</span>.<span class=\"ruby-identifier\">integer?</span>   <span class=\"ruby-comment\">#=&gt; false</span>\n<span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">integer?</span>     <span class=\"ruby-comment\">#=&gt; true</span>\n</pre>\n"],["integer_list","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-integer_list","(name, table)",""],["integer_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-integer_writer","(name, disp_name=name)",""],["intern","Racc::Grammar","Racc/Grammar.html#method-i-intern","(value, dummy = false)",""],["intern","Racc::SymbolTable","Racc/SymbolTable.html#method-i-intern","(val, dummy = false)",""],["intern","String","String.html#method-i-intern","()","<p>Returns the Symbol corresponding to <em>str</em>, creating the symbol if it did not previously exist. See Symbol#id2name …\n"],["intern","Symbol","Symbol.html#method-i-intern","()","<p>In general, <code>to_sym</code> returns the Symbol corresponding to an object. As <em>sym</em> is already a symbol, <code>self</code> is …\n"],["internal_class_of","ObjectSpace","ObjectSpace.html#method-c-internal_class_of","(p1)","<p>MRI specific feature &mdash; Return internal class of obj.\n\n<p>obj can be an instance of InternalObjectWrapper.\n<p>Note …\n"],["internal_encoding","ARGF","ARGF.html#method-i-internal_encoding","()","<p>Returns the internal encoding for strings read from <code>ARGF</code> as an <code>Encoding</code> object.\n<p>If <code>ARGF.set_encoding</code> has …\n"],["internal_encoding","IO","IO.html#method-i-internal_encoding","()","<p>Returns the Encoding of the internal string if conversion is specified.  Otherwise returns <code>nil</code>.\n"],["internal_encoding","StringIO","StringIO.html#method-i-internal_encoding","()","<p>Returns the Encoding of the internal string if conversion is specified.  Otherwise returns <code>nil</code>.\n"],["internal_object_id","ObjectSpace::InternalObjectWrapper","ObjectSpace/InternalObjectWrapper.html#method-i-internal_object_id","()","<p>Returns the Object#object_id of the internal object.\n"],["internal_super_of","ObjectSpace","ObjectSpace.html#method-c-internal_super_of","(p1)","<p>MRI specific feature &mdash; Return internal super class of cls (Class or Module).\n\n<p>obj can be an instance of  …\n"],["interpret_loosely","BigDecimal","BigDecimal.html#method-c-interpret_loosely","(p1)",""],["interrupt","DEBUGGER__","DEBUGGER__.html#method-c-interrupt","()",""],["intersect?","Set","Set.html#method-i-intersect-3F","(set)","<p>Returns true if the set and the given set have at least one element in common.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>].<span class=\"ruby-identifier\">intersect?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["intersection","Array","Array.html#method-i-intersection","(*args)","<p>Set Intersection — Returns a new array containing unique elements common to <code>self</code> and <code>other_ary</code>s. Order …\n"],["intersection","Set","Set.html#method-i-intersection","(enum)",""],["inv","Matrix","Matrix.html#method-i-inv","()",""],["invalidate_memoized_attributes","Gem::Specification","Gem/Specification.html#method-i-invalidate_memoized_attributes","()","<p>Expire memoized instance variables that can incorrectly generate, replace or miss files due changes in …\n"],["inverse","Matrix","Matrix.html#method-i-inverse","()","<p>Returns the inverse of the matrix.\n\n<pre>Matrix[[-1, -1], [0, -1]].inverse\n  =&gt; -1  1\n      0 -1</pre>\n"],["invert","DBM","DBM.html#method-i-invert","()","<p>Returns a Hash (not a DBM database) created by using each value in the database as a key, with the corresponding …\n"],["invert","ENV","ENV.html#method-c-invert","()","<p>Returns a new hash created by using environment variable names as values and values as names.\n"],["invert","GDBM","GDBM.html#method-i-invert","()","<p>Returns a hash created by using <em>gdbm</em>&#39;s values as keys, and the keys as values.\n"],["invert","Hash","Hash.html#method-i-invert","()","<p>Returns a new hash created by using <em>hsh</em>&#39;s values as keys, and the keys as values. If a key with the …\n"],["invert","SDBM","SDBM.html#method-i-invert","()","<p>Returns a Hash in which the key-value pairs have been inverted.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;sdbm&#39;</span>\n\n<span class=\"ruby-constant\">SDBM</span>.<span class=\"ruby-identifier\">open</span> <span class=\"ruby-string\">&#39;my_database&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["invert","YAML::DBM","YAML/DBM.html#method-i-invert","()","<p>Returns a Hash (not a DBM database) created by using each value in the database as a key, with the corresponding …\n"],["invert!","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-invert-21","()",""],["invkind","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-invkind","()","<p>Returns the method invoke kind.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbooks&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["invoke","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-invoke","(*names, &block)","<p>Invoke the given namespace or class given. It adds an instance method that will invoke the klass and …\n"],["invoke","Bundler::Thor::Invocation","Bundler/Thor/Invocation.html#method-i-invoke","(name = nil, *args)","<p>Receives a name and invokes it. The name can be a string (either “command” or “namespace:command”), …\n"],["invoke","Gem::Command","Gem/Command.html#method-i-invoke","(*args)","<p>Invoke the command with the given list of arguments.\n"],["invoke","WIN32OLE","WIN32OLE.html#method-i-invoke","(*args)","<p>Runs OLE method. The first argument specifies the method name of OLE Automation object. The others specify …\n"],["invoke_from_option","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-invoke_from_option","(*names, &block)","<p>Invoke a thor class based on the value supplied by the user to the given option named “name”. …\n"],["invoke_kind","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-invoke_kind","()","<p>Returns the method kind string. The string is “UNKNOWN” or “PROPERTY” or “PROPERTY” …\n"],["invoke_service","DRb::ExtServManager","DRb/ExtServManager.html#method-i-invoke_service","(name)",""],["invoke_service_command","DRb::ExtServManager","DRb/ExtServManager.html#method-i-invoke_service_command","(name, command)",""],["invoke_thread","DRb::ExtServManager","DRb/ExtServManager.html#method-i-invoke_thread","()",""],["invoke_with_build_args","Gem::Command","Gem/Command.html#method-i-invoke_with_build_args","(args, build_args)","<p>Invoke the command with the given list of normal arguments and additional build arguments.\n"],["invoke_with_padding","Bundler::Thor::Invocation","Bundler/Thor/Invocation.html#method-i-invoke_with_padding","(*args)","<p>Invokes using shell padding.\n"],["ioctl","CSV","CSV.html#method-i-ioctl","(*args)",""],["ioctl","IO","IO.html#method-i-ioctl","(p1, p2 = v2)","<p>Provides a mechanism for issuing low-level commands to control or query I/O devices. Arguments and results …\n"],["ioflush","IO","IO.html#method-i-ioflush","()","<p>Flushes input and output buffers in kernel.\n<p>You must require &#39;io/console&#39; to use this method. …\n"],["ip","Addrinfo","Addrinfo.html#method-c-ip","(p1)","<p>returns an addrinfo object for IP address.\n<p>The port, socktype, protocol of the result is filled by zero. …\n"],["ip6_arpa","IPAddr","IPAddr.html#method-i-ip6_arpa","()","<p>Returns a string for DNS reverse lookup compatible with RFC3172.\n"],["ip6_int","IPAddr","IPAddr.html#method-i-ip6_int","()","<p>Returns a string for DNS reverse lookup compatible with RFC1886.\n"],["ip?","Addrinfo","Addrinfo.html#method-i-ip-3F","()","<p>returns true if addrinfo is internet (IPv4/IPv6) address. returns false otherwise.\n\n<pre>Addrinfo.tcp(&quot;127.0.0.1&quot;, ...</pre>\n"],["ip_address","Addrinfo","Addrinfo.html#method-i-ip_address","()","<p>Returns the IP address as a string.\n\n<pre>Addrinfo.tcp(&quot;127.0.0.1&quot;, 80).ip_address    #=&gt; &quot;127.0.0.1&quot;\nAddrinfo.tcp(&quot;::1&quot;, ...</pre>\n"],["ip_address_list","Socket","Socket.html#method-c-ip_address_list","()","<p>Returns local IP addresses as an array.\n<p>The array contains Addrinfo objects.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">pp</span> <span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">ip_address_list</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ip_pktinfo","Socket::AncillaryData","Socket/AncillaryData.html#method-i-ip_pktinfo","()","<p>Extracts addr, ifindex and spec_dst from IP_PKTINFO ancillary data.\n<p>IP_PKTINFO is not standard.\n<p>Supported …\n"],["ip_pktinfo","Socket::AncillaryData","Socket/AncillaryData.html#method-c-ip_pktinfo","(p1, p2, p3 = v3)","<p>Returns new ancillary data for IP_PKTINFO.\n<p>If spec_dst is not given, addr is used.\n<p>IP_PKTINFO is not standard. …\n"],["ip_port","Addrinfo","Addrinfo.html#method-i-ip_port","()","<p>Returns the port number as an integer.\n\n<pre>Addrinfo.tcp(&quot;127.0.0.1&quot;, 80).ip_port    #=&gt; 80\nAddrinfo.tcp(&quot;::1&quot;, ...</pre>\n"],["ip_unpack","Addrinfo","Addrinfo.html#method-i-ip_unpack","()","<p>Returns the IP address and port number as 2-element array.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;127.0.0.1&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">ip_unpack</span>    <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipaddr","Net::HTTP","Net/HTTP.html#method-i-ipaddr","()","<p>The IP address to connect to/used to connect to\n"],["ipaddr=","Net::HTTP","Net/HTTP.html#method-i-ipaddr-3D","(addr)","<p>Set the IP address to connect to\n"],["ipv4?","Addrinfo","Addrinfo.html#method-i-ipv4-3F","()","<p>returns true if addrinfo is IPv4 address. returns false otherwise.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;127.0.0.1&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">ipv4?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv4?","IPAddr","IPAddr.html#method-i-ipv4-3F","()","<p>Returns true if the ipaddr is an IPv4 address.\n"],["ipv4_compat","IPAddr","IPAddr.html#method-i-ipv4_compat","()","<p>Returns a new ipaddr built by converting the native IPv4 address into an IPv4-compatible IPv6 address. …\n"],["ipv4_compat?","IPAddr","IPAddr.html#method-i-ipv4_compat-3F","()","<p>Returns true if the ipaddr is an IPv4-compatible IPv6 address.\n"],["ipv4_loopback?","Addrinfo","Addrinfo.html#method-i-ipv4_loopback-3F","()","<p>Returns true for IPv4 loopback address (127.0.0.0/8). It returns false otherwise.\n"],["ipv4_mapped","IPAddr","IPAddr.html#method-i-ipv4_mapped","()","<p>Returns a new ipaddr built by converting the native IPv4 address into an IPv4-mapped IPv6 address.\n"],["ipv4_mapped?","IPAddr","IPAddr.html#method-i-ipv4_mapped-3F","()","<p>Returns true if the ipaddr is an IPv4-mapped IPv6 address.\n"],["ipv4_multicast?","Addrinfo","Addrinfo.html#method-i-ipv4_multicast-3F","()","<p>Returns true for IPv4 multicast address (224.0.0.0/4). It returns false otherwise.\n"],["ipv4_multicast_loop","Socket::Option","Socket/Option.html#method-c-ipv4_multicast_loop","(p1)","<p>Creates a new Socket::Option object for IP_MULTICAST_LOOP.\n<p>The size is dependent on the platform.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">sockopt</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv4_multicast_loop","Socket::Option","Socket/Option.html#method-i-ipv4_multicast_loop","()","<p>Returns the ipv4_multicast_loop data in <em>sockopt</em> as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">sockopt</span> = <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">ipv4_multicast_loop</span>(<span class=\"ruby-value\">10</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv4_multicast_ttl","Socket::Option","Socket/Option.html#method-i-ipv4_multicast_ttl","()","<p>Returns the ipv4_multicast_ttl data in <em>sockopt</em> as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">sockopt</span> = <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">ipv4_multicast_ttl</span>(<span class=\"ruby-value\">10</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv4_multicast_ttl","Socket::Option","Socket/Option.html#method-c-ipv4_multicast_ttl","(p1)","<p>Creates a new Socket::Option object for IP_MULTICAST_TTL.\n<p>The size is dependent on the platform.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">ipv4_multicast_ttl</span>(<span class=\"ruby-value\">10</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv4_private?","Addrinfo","Addrinfo.html#method-i-ipv4_private-3F","()","<p>Returns true for IPv4 private address (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16). It returns false otherwise. …\n"],["ipv6?","Addrinfo","Addrinfo.html#method-i-ipv6-3F","()","<p>returns true if addrinfo is IPv6 address. returns false otherwise.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;127.0.0.1&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">ipv6?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv6?","IPAddr","IPAddr.html#method-i-ipv6-3F","()","<p>Returns true if the ipaddr is an IPv6 address.\n"],["ipv6_linklocal?","Addrinfo","Addrinfo.html#method-i-ipv6_linklocal-3F","()","<p>Returns true for IPv6 link local address (ff80::/10). It returns false otherwise.\n"],["ipv6_loopback?","Addrinfo","Addrinfo.html#method-i-ipv6_loopback-3F","()","<p>Returns true for IPv6 loopback address (::1). It returns false otherwise.\n"],["ipv6_mc_global?","Addrinfo","Addrinfo.html#method-i-ipv6_mc_global-3F","()","<p>Returns true for IPv6 multicast global scope address. It returns false otherwise.\n"],["ipv6_mc_linklocal?","Addrinfo","Addrinfo.html#method-i-ipv6_mc_linklocal-3F","()","<p>Returns true for IPv6 multicast link-local scope address. It returns false otherwise.\n"],["ipv6_mc_nodelocal?","Addrinfo","Addrinfo.html#method-i-ipv6_mc_nodelocal-3F","()","<p>Returns true for IPv6 multicast node-local scope address. It returns false otherwise.\n"],["ipv6_mc_orglocal?","Addrinfo","Addrinfo.html#method-i-ipv6_mc_orglocal-3F","()","<p>Returns true for IPv6 multicast organization-local scope address. It returns false otherwise.\n"],["ipv6_mc_sitelocal?","Addrinfo","Addrinfo.html#method-i-ipv6_mc_sitelocal-3F","()","<p>Returns true for IPv6 multicast site-local scope address. It returns false otherwise.\n"],["ipv6_multicast?","Addrinfo","Addrinfo.html#method-i-ipv6_multicast-3F","()","<p>Returns true for IPv6 multicast address (ff00::/8). It returns false otherwise.\n"],["ipv6_pktinfo","Socket::AncillaryData","Socket/AncillaryData.html#method-c-ipv6_pktinfo","(p1, p2)","<p>Returns new ancillary data for IPV6_PKTINFO.\n<p>IPV6_PKTINFO is defined by RFC 3542.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">addr</span> = <span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">ip</span>(<span class=\"ruby-string\">&quot;::1&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv6_pktinfo","Socket::AncillaryData","Socket/AncillaryData.html#method-i-ipv6_pktinfo","()","<p>Extracts addr and ifindex from IPV6_PKTINFO ancillary data.\n<p>IPV6_PKTINFO is defined by RFC 3542.\n\n<pre>addr = ...</pre>\n"],["ipv6_pktinfo_addr","Socket::AncillaryData","Socket/AncillaryData.html#method-i-ipv6_pktinfo_addr","()","<p>Extracts addr from IPV6_PKTINFO ancillary data.\n<p>IPV6_PKTINFO is defined by RFC 3542.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">addr</span> = <span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">ip</span>(<span class=\"ruby-string\">&quot;::1&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv6_pktinfo_ifindex","Socket::AncillaryData","Socket/AncillaryData.html#method-i-ipv6_pktinfo_ifindex","()","<p>Extracts ifindex from IPV6_PKTINFO ancillary data.\n<p>IPV6_PKTINFO is defined by RFC 3542.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">addr</span> = <span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">ip</span>(<span class=\"ruby-string\">&quot;::1&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ipv6_sitelocal?","Addrinfo","Addrinfo.html#method-i-ipv6_sitelocal-3F","()","<p>Returns true for IPv6 site local address (ffc0::/10). It returns false otherwise.\n"],["ipv6_to_ipv4","Addrinfo","Addrinfo.html#method-i-ipv6_to_ipv4","()","<p>Returns IPv4 address of IPv4 mapped/compatible IPv6 address. It returns nil if <code>self</code> is not IPv4 mapped/compatible …\n"],["ipv6_unique_local?","Addrinfo","Addrinfo.html#method-i-ipv6_unique_local-3F","()","<p>Returns true for IPv6 unique local address (fc00::/7, RFC4193). It returns false otherwise.\n"],["ipv6_unspecified?","Addrinfo","Addrinfo.html#method-i-ipv6_unspecified-3F","()","<p>Returns true for IPv6 unspecified address (::). It returns false otherwise.\n"],["ipv6_v4compat?","Addrinfo","Addrinfo.html#method-i-ipv6_v4compat-3F","()","<p>Returns true for IPv4-compatible IPv6 address (::/80). It returns false otherwise.\n"],["ipv6_v4mapped?","Addrinfo","Addrinfo.html#method-i-ipv6_v4mapped-3F","()","<p>Returns true for IPv4-mapped IPv6 address (::ffff:0:0/80). It returns false otherwise.\n"],["ipv6only!","Socket","Socket.html#method-i-ipv6only-21","()","<p>enable the socket option IPV6_V6ONLY if IPV6_V6ONLY is available.\n"],["irb","Binding","Binding.html#method-i-irb","()","<p>Opens an IRB session where <code>binding.irb</code> is called which allows for interactive debugging. You can call …\n"],["irb","IRB","IRB.html#method-c-irb","(file = nil, *main)","<p>Creates a new IRB session, see Irb.new.\n<p>The optional <code>file</code> argument is given to Context.new, along with …\n"],["irb","IRB::JobManager","IRB/JobManager.html#method-i-irb","(key)","<p>Returns the irb session for the given <code>key</code> object, see #search for more information.\n"],["irb_abort","IRB","IRB.html#method-c-irb_abort","(irb, exception = Abort)","<p>Aborts then interrupts irb.\n<p>Will raise an Abort exception, or the given <code>exception</code>.\n"],["irb_at_exit","IRB","IRB.html#method-c-irb_at_exit","()","<p>Calls each event hook of <code>IRB.conf[:TA_EXIT]</code> when the current session quits.\n"],["irb_context","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-i-irb_context","()","<p>Displays current configuration.\n<p>Modifying the configuration is achieved by sending a message to IRB.conf …\n"],["irb_exit","IRB","IRB.html#method-c-irb_exit","(irb, ret)","<p>Quits irb\n"],["irb_exit","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-i-irb_exit","(ret = 0)","<p>Quits the current irb context\n<p><code>ret</code> is the optional signal or message to send to Context#exit\n<p>Same as <code>IRB.CurrentContext.exit</code> …\n"],["irb_level","IRB::Context","IRB/Context.html#method-i-irb_level","()","<p>Size of the current WorkSpace stack\n"],["irb_load","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-i-irb_load","(*opts, &b)","<p>Loads the given file similarly to Kernel#load, see IrbLoader#irb_load\n"],["irb_load","IRB::IrbLoader","IRB/IrbLoader.html#method-i-irb_load","(fn, priv = nil)","<p>Loads the given file similarly to Kernel#load\n"],["irb_require","IRB::ExtendCommandBundle","IRB/ExtendCommandBundle.html#method-i-irb_require","(*opts, &b)","<p>Loads the given file similarly to Kernel#require\n"],["isEqual","Jacobian","Jacobian.html#method-i-isEqual","(a,b,zero=0.0,e=1.0e-8)","<p>Determines the equality of two numbers by comparing to zero, or using the epsilon value\n"],["is_a?","Object","Object.html#method-i-is_a-3F","(p1)","<p>Returns <code>true</code> if <em>class</em> is the class of <em>obj</em>, or if <em>class</em> is one of the superclasses of <em>obj</em> or modules included …\n"],["is_alias_for","RDoc::Constant","RDoc/Constant.html#method-i-is_alias_for","()","<p>The module or class this constant is an alias for\n"],["is_array","Bundler::Settings","Bundler/Settings.html#method-i-is_array","(key)",""],["is_bool","Bundler::Settings","Bundler/Settings.html#method-i-is_bool","(name)",""],["is_num","Bundler::Settings","Bundler/Settings.html#method-i-is_num","(key)",""],["is_reachable_from?","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-is_reachable_from-3F","(other)",""],["is_reachable_from?","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-is_reachable_from-3F","(other)",""],["is_version_1_2?","Net::HTTP","Net/HTTP.html#method-c-is_version_1_2-3F","()",""],["isatty","IO","IO.html#method-i-isatty","()","<p>Returns <code>true</code> if <em>ios</em> is associated with a terminal device (tty), <code>false</code> otherwise.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">isatty</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["isatty","StringIO","StringIO.html#method-i-isatty","()","<p>Returns <code>false</code>.  Just for compatibility to IO.\n"],["isdst","Time","Time.html#method-i-isdst","()","<p>Returns <code>true</code> if <em>time</em> occurs during Daylight Saving Time in its time zone.\n\n<pre># CST6CDT:\n  Time.local(2000, ...</pre>\n"],["iseuc","Kconv","Kconv.html#method-c-iseuc","(str)","<p>Returns whether input encoding is EUC-JP or not.\n<p><strong>Note</strong> don&#39;t expect this return value is MatchData …\n"],["iseuc","Kconv","Kconv.html#method-i-iseuc","(str)","<p>Returns whether input encoding is EUC-JP or not.\n<p><strong>Note</strong> don&#39;t expect this return value is MatchData …\n"],["iseuc","String","String.html#method-i-iseuc","()","<p>Returns whether <code>self</code>&#39;s encoding is EUC-JP or not.\n"],["isjis","Kconv","Kconv.html#method-i-isjis","(str)","<p>Returns whether input encoding is ISO-2022-JP or not.\n"],["isjis","Kconv","Kconv.html#method-c-isjis","(str)","<p>Returns whether input encoding is ISO-2022-JP or not.\n"],["isjis","String","String.html#method-i-isjis","()","<p>Returns whether <code>self</code>&#39;s encoding is ISO-2022-JP or not.\n"],["iso8601","Date","Date.html#method-i-iso8601","()","<p>This method is equivalent to strftime(&#39;%F&#39;).\n"],["iso8601","Date","Date.html#method-c-iso8601","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new Date object by parsing from a string according to some typical ISO 8601 formats.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">iso8601</span>(<span class=\"ruby-string\">&#39;2001-02-03&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["iso8601","DateTime","DateTime.html#method-i-iso8601","(*args)","<p>This method is equivalent to strftime(&#39;%FT%T%:z&#39;). The optional argument <code>n</code> is the number of digits …\n"],["iso8601","DateTime","DateTime.html#method-c-iso8601","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new DateTime object by parsing from a string according to some typical ISO 8601 formats.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">iso8601</span>(<span class=\"ruby-string\">&#39;2001-02-03T04:05:06+07:00&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["iso8601","Time","Time.html#method-i-iso8601","(fraction_digits=0)",""],["iso8601","Time","Time.html#method-c-iso8601","(date)",""],["issetugid","Process::Sys","Process/Sys.html#method-c-issetugid","()","<p>Returns <code>true</code> if the process was created as a result of an execve(2) system call which had either of the …\n"],["issjis","Kconv","Kconv.html#method-c-issjis","(str)","<p>Returns whether input encoding is Shift_JIS or not.\n"],["issjis","Kconv","Kconv.html#method-i-issjis","(str)","<p>Returns whether input encoding is Shift_JIS or not.\n"],["issjis","String","String.html#method-i-issjis","()","<p>Returns whether <code>self</code>&#39;s encoding is Shift_JIS or not.\n"],["issue","Bundler::CLI","Bundler/CLI.html#method-i-issue","()",""],["issuer","OpenSSL::PKCS7::RecipientInfo","OpenSSL/PKCS7/RecipientInfo.html#method-i-issuer","()",""],["issuer","OpenSSL::PKCS7::SignerInfo","OpenSSL/PKCS7/SignerInfo.html#method-i-issuer","()",""],["issuer","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-issuer","()",""],["issuer","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-issuer","()",""],["issuer=","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-issuer-3D","(p1)",""],["issuer=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-issuer-3D","(p1)",""],["issuer_certificate=","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-issuer_certificate-3D","(p1)",""],["issuer_key_hash","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-issuer_key_hash","()","<p>Returns the issuerKeyHash of this certificate ID, the hash of the issuer&#39;s public key.\n"],["issuer_name_hash","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-issuer_name_hash","()","<p>Returns the issuerNameHash of this certificate ID, the hash of the issuer&#39;s distinguished name calculated …\n"],["issuer_of","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-i-issuer_of","(certificate)","<p>Returns the issuer certificate of the given <code>certificate</code> if it exists in the trust directory.\n"],["issues_url","Bundler::FriendlyErrors","Bundler/FriendlyErrors.html#method-i-issues_url","(exception)",""],["isutf8","Kconv","Kconv.html#method-c-isutf8","(str)","<p>Returns whether input encoding is UTF-8 or not.\n"],["isutf8","Kconv","Kconv.html#method-i-isutf8","(str)","<p>Returns whether input encoding is UTF-8 or not.\n"],["isutf8","String","String.html#method-i-isutf8","()","<p>Returns whether <code>self</code>&#39;s encoding is UTF-8 or not.\n"],["italy","Date","Date.html#method-i-italy","()","<p>This method is equivalent to new_start(Date::ITALY).\n"],["items","RSS::Atom::Entry","RSS/Atom/Entry.html#method-i-items","()","<p>Returns the Entry in an array.\n"],["items","RSS::Rss","RSS/Rss.html#method-i-items","()",""],["iteration!","Gem::Resolver::Stats","Gem/Resolver/Stats.html#method-i-iteration-21","()",""],["iterator?","Kernel","Kernel.html#method-i-iterator-3F","()","<p>Returns <code>true</code> if <code>yield</code> would execute a block in the current context. The <code>iterator?</code> form is mildly deprecated. …\n"],["itself","Object","Object.html#method-i-itself","()","<p>Returns the receiver.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">string</span> = <span class=\"ruby-string\">&quot;my string&quot;</span>\n<span class=\"ruby-identifier\">string</span>.<span class=\"ruby-identifier\">itself</span>.<span class=\"ruby-identifier\">object_id</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-identifier\">string</span>.<span class=\"ruby-identifier\">object_id</span>   <span class=\"ruby-comment\">#=&gt; true</span>\n</pre>\n"],["iv=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-iv-3D","(p1)","<p>Sets the cipher IV. Please note that since you should never be using ECB mode, an IV is always explicitly …\n"],["iv_len","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-iv_len","()","<p>Returns the expected length in bytes for an IV for this Cipher.\n"],["iv_len=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-iv_len-3D","(p1)","<p>Sets the IV/nonce length of the Cipher. Normally block ciphers don&#39;t allow changing the IV length, …\n"],["j","Kernel","Kernel.html#method-i-j","(*objs)","<p>Outputs <em>objs</em> to STDOUT as JSON strings in the shortest form, that is in one line.\n"],["jacobian","Jacobian","Jacobian.html#method-i-jacobian","(f,fx,x)","<p>Computes the Jacobian of f at x. fx is the value of f at x.\n"],["java_platform?","Gem","Gem.html#method-c-java_platform-3F","()","<p>Is this a java platform?\n"],["java_platform?","Gem::TestCase","Gem/TestCase.html#method-i-java_platform-3F","()","<p>Is this test being run on a Java platform?\n"],["java_platform?","Gem::TestCase","Gem/TestCase.html#method-c-java_platform-3F","()","<p>Is this test being run on a Java platform?\n"],["jd","Date","Date.html#method-c-jd","(p1 = v1, p2 = v2)","<p>Creates a date object denoting the given chronological Julian day number.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">jd</span>(<span class=\"ruby-value\">2451944</span>)          <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["jd","Date","Date.html#method-i-jd","()","<p>Returns the Julian day number.  This is a whole number, which is adjusted by the offset as the local …\n"],["jd","DateTime","DateTime.html#method-c-jd","(p1 = v1, p2 = v2, p3 = v3, p4 = v4, p5 = v5, p6 = v6)","<p>Creates a DateTime object denoting the given chronological Julian day number.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">jd</span>(<span class=\"ruby-value\">2451944</span>)    <span class=\"ruby-operator\">...</span>\n</pre>\n"],["jisx0301","Date","Date.html#method-i-jisx0301","()","<p>Returns a string in a JIS X 0301 format.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">jisx0301</span>       <span class=\"ruby-comment\">#=&gt; &quot;H13.02.03&quot;</span>\n</pre>\n"],["jisx0301","Date","Date.html#method-c-jisx0301","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new Date object by parsing from a string according to some typical JIS X 0301 formats.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">jisx0301</span>(<span class=\"ruby-string\">&#39;H13.02.03&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["jisx0301","DateTime","DateTime.html#method-c-jisx0301","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new DateTime object by parsing from a string according to some typical JIS X 0301 formats. …\n"],["jisx0301","DateTime","DateTime.html#method-i-jisx0301","(*args)","<p>Returns a string in a JIS X 0301 format. The optional argument <code>n</code> is the number of digits for fractional …\n"],["jj","Kernel","Kernel.html#method-i-jj","(*objs)","<p>Outputs <em>objs</em> to STDOUT as JSON strings in a pretty format, with indentation and over many lines.\n"],["join","Array","Array.html#method-i-join","(*args)","<p>Returns a string created by converting each element of the array to a string, separated by the given …\n"],["join","Bundler::URI","Bundler/URI.html#method-c-join","(*str)","<p>Synopsis\n\n<pre>Bundler::URI::join(str[, str, ...])</pre>\n<p>Args\n"],["join","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-join","(*uris)","<p>Args\n<p><code>uris</code> &mdash; an Array of Strings\n\n<p>Description\n"],["join","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-join","(*uris)","<p>Args\n<p><code>uris</code> &mdash; an Array of Strings\n\n<p>Description\n"],["join","File","File.html#method-c-join","(*args)","<p>Returns a new string formed by joining the strings using <code>&quot;/&quot;</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">join</span>(<span class=\"ruby-string\">&quot;usr&quot;</span>, <span class=\"ruby-string\">&quot;mail&quot;</span>, <span class=\"ruby-string\">&quot;gumby&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["join","Pathname","Pathname.html#method-i-join","(*args)","<p>Joins the given pathnames onto <code>self</code> to create a new Pathname object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">path0</span> = <span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/usr&quot;</span>)     <span class=\"ruby-operator\">...</span>\n</pre>\n"],["join","Shellwords","Shellwords.html#method-c-join","(array)",""],["join","Thread","Thread.html#method-i-join","(*args)","<p>The calling thread will suspend execution and run this <code>thr</code>.\n<p>Does not return until <code>thr</code> exits or until the …\n"],["join","URI","URI.html#method-c-join","(*str)","<p>Synopsis\n\n<pre>URI::join(str[, str, ...])</pre>\n<p>Args\n"],["join","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-join","(*uris)","<p>Args\n<p><code>uris</code> &mdash; an Array of Strings\n\n<p>Description\n"],["join","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-join","(*uris)","<p>Args\n<p><code>uris</code> &mdash; an Array of Strings\n\n<p>Description\n"],["jruby?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-jruby-3F","()",""],["json_creatable?","Class","Class.html#method-i-json_creatable-3F","()","<p>Returns true if this class can be used to create an instance from a serialised JSON string. The class …\n"],["json_creatable?","JSON::GenericObject","JSON/GenericObject.html#method-c-json_creatable-3F","()",""],["json_create","BigDecimal","BigDecimal.html#method-c-json_create","(object)","<p>Import a JSON Marshalled object.\n<p>method used for JSON marshalling support.\n"],["json_create","Complex","Complex.html#method-c-json_create","(object)","<p>Deserializes JSON string by converting Real value <code>r</code>, imaginary value <code>i</code>, to a Complex object.\n"],["json_create","Date","Date.html#method-c-json_create","(object)","<p>Deserializes JSON string by converting Julian year <code>y</code>, month <code>m</code>, day <code>d</code> and Day of Calendar Reform <code>sg</code> to …\n"],["json_create","DateTime","DateTime.html#method-c-json_create","(object)","<p>Deserializes JSON string by converting year <code>y</code>, month <code>m</code>, day <code>d</code>, hour <code>H</code>, minute <code>M</code>, second <code>S</code>, offset <code>of</code> …\n"],["json_create","Exception","Exception.html#method-c-json_create","(object)","<p>Deserializes JSON string by constructing new Exception object with message <code>m</code> and backtrace <code>b</code> serialized …\n"],["json_create","JSON::Ext::Generator::GeneratorMethods::String::Extend","JSON/Ext/Generator/GeneratorMethods/String/Extend.html#method-i-json_create","(p1)","<p>Raw Strings are JSON Objects (the raw bytes are stored in an array for the key “raw”). The …\n"],["json_create","JSON::GenericObject","JSON/GenericObject.html#method-c-json_create","(data)",""],["json_create","OpenStruct","OpenStruct.html#method-c-json_create","(object)","<p>Deserializes JSON string by constructing new Struct object with values <code>t</code> serialized by <code>to_json</code>.\n"],["json_create","Range","Range.html#method-c-json_create","(object)","<p>Deserializes JSON string by constructing new Range object with arguments <code>a</code> serialized by <code>to_json</code>.\n"],["json_create","Rational","Rational.html#method-c-json_create","(object)","<p>Deserializes JSON string by converting numerator value <code>n</code>, denominator value <code>d</code>, to a Rational object. …\n"],["json_create","Regexp","Regexp.html#method-c-json_create","(object)","<p>Deserializes JSON string by constructing new Regexp object with source <code>s</code> (Regexp or String) and options …\n"],["json_create","Set","Set.html#method-c-json_create","(object)","<p>Import a JSON Marshalled object.\n<p>method used for JSON marshalling support.\n"],["json_create","Struct","Struct.html#method-c-json_create","(object)","<p>Deserializes JSON string by constructing new Struct object with values <code>v</code> serialized by <code>to_json</code>.\n"],["json_create","Symbol","Symbol.html#method-c-json_create","(o)","<p>Deserializes JSON string by converting the <code>string</code> value stored in the object to a Symbol\n"],["json_create","Time","Time.html#method-c-json_create","(object)","<p>Deserializes JSON string by converting time since epoch to Time\n"],["julian","Date","Date.html#method-i-julian","()","<p>This method is equivalent to new_start(Date::JULIAN).\n"],["julian?","Date","Date.html#method-i-julian-3F","()","<p>Returns true if the date is before the day of calendar reform.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">1582</span>,<span class=\"ruby-value\">10</span>,<span class=\"ruby-value\">15</span>).<span class=\"ruby-identifier\">julian?</span>           <span class=\"ruby-operator\">...</span>\n</pre>\n"],["julian_leap?","Date","Date.html#method-c-julian_leap-3F","(p1)","<p>Returns true if the given year is a leap year of the proleptic Julian calendar.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">julian_leap?</span>(<span class=\"ruby-value\">1900</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["k","Bundler::Settings::Validator::Rule","Bundler/Settings/Validator/Rule.html#method-i-k","(key)",""],["kconv","Kconv","Kconv.html#method-i-kconv","(str, to_enc, from_enc=nil)","<p>Convert <code>str</code> to <code>to_enc</code>. <code>to_enc</code> and <code>from_enc</code> are given as constants of Kconv or Encoding objects.\n"],["kconv","Kconv","Kconv.html#method-c-kconv","(str, to_enc, from_enc=nil)","<p>Convert <code>str</code> to <code>to_enc</code>. <code>to_enc</code> and <code>from_enc</code> are given as constants of Kconv or Encoding objects.\n"],["kconv","String","String.html#method-i-kconv","(to_enc, from_enc=nil)","<p>Convert <code>self</code> to <code>to_enc</code>. <code>to_enc</code> and <code>from_enc</code> are given as constants of Kconv or Encoding objects.\n"],["keep_alive?","Net::HTTP","Net/HTTP.html#method-i-keep_alive-3F","(req, res)",""],["keep_alive?","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-keep_alive-3F","()","<p>Should the connection this request was made on be kept alive?\n"],["keep_alive?","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-keep_alive-3F","()","<p>Will this response&#39;s connection be kept alive?\n"],["keep_back","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-keep_back","()",""],["keep_back","CSV::Parser::Scanner","CSV/Parser/Scanner.html#method-i-keep_back","()",""],["keep_clean","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-keep_clean","()","<p>Removes dead tuples.\n"],["keep_drop","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-keep_drop","()",""],["keep_drop","CSV::Parser::Scanner","CSV/Parser/Scanner.html#method-i-keep_drop","()",""],["keep_end","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-keep_end","()",""],["keep_end","CSV::Parser::Scanner","CSV/Parser/Scanner.html#method-i-keep_end","()",""],["keep_if","Array","Array.html#method-i-keep_if","()","<p>Deletes every element of <code>self</code> for which the given block evaluates to <code>false</code>, and returns <code>self</code>.\n<p>If no block …\n"],["keep_if","ENV","ENV.html#method-c-keep_if","()","<p>Deletes every environment variable where the block evaluates to <code>false</code>.\n<p>Returns an enumerator if no block …\n"],["keep_if","Hash","Hash.html#method-i-keep_if","()","<p>Deletes every key-value pair from <em>hsh</em> for which <em>block</em> evaluates to <code>false</code>.\n<p>If no block is given, an enumerator …\n"],["keep_if","Set","Set.html#method-i-keep_if","()","<p>Deletes every element of the set for which block evaluates to false, and returns self. Returns an enumerator …\n"],["keep_only_files_and_directories","Gem::Specification","Gem/Specification.html#method-i-keep_only_files_and_directories","()",""],["keep_start","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-keep_start","()",""],["keep_start","CSV::Parser::Scanner","CSV/Parser/Scanner.html#method-i-keep_start","()",""],["keep_trying?","Bundler::Retry","Bundler/Retry.html#method-i-keep_trying-3F","()",""],["kernel_exec","Bundler::CLI::Exec","Bundler/CLI/Exec.html#method-i-kernel_exec","(*args)",""],["kernel_load","Bundler::CLI::Exec","Bundler/CLI/Exec.html#method-i-kernel_load","(file, *args)",""],["key","DBM","DBM.html#method-i-key","(p1)","<p>Returns the key for the specified value.\n"],["key","ENV","ENV.html#method-c-key","(p1)","<p>Returns the name of the first environment variable with <code>value</code> if it exists:\n\n<pre>ENV.replace(&#39;foo&#39; =&gt; &#39;0&#39;, ...</pre>\n"],["key","GDBM","GDBM.html#method-i-key","(p1)","<p>Returns the <em>key</em> for a given <em>value</em>. If several keys may map to the same value, the key that is found first …\n"],["key","Hash","Hash.html#method-i-key","(p1)","<p>Returns the key of an occurrence of a given value. If the value is not found, returns <code>nil</code>.\n\n<pre>h = { &quot;a&quot; =&gt; ...</pre>\n"],["key","KeyError","KeyError.html#method-i-key","()","<p>Return the key caused this KeyError exception.\n"],["key","SDBM","SDBM.html#method-i-key","(p1)","<p>Returns the <code>key</code> associated with the given <code>value</code>. If more than one <code>key</code> corresponds to the given <code>value</code> …\n"],["key","YAML::DBM","YAML/DBM.html#method-i-key","( keystr )","<p>Returns the key for the specified value.\n"],["key=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-key-3D","(key)","<p>For Net::HTTP parity\n"],["key=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-key-3D","(p1)","<p>Sets the cipher key. To generate a key, you should either use a secure random byte string or, if the …\n"],["key?","CGI::QueryExtension","CGI/QueryExtension.html#method-i-key-3F","(*args)",""],["key?","CSV::Row","CSV/Row.html#method-i-key-3F","(header)",""],["key?","DBM","DBM.html#method-i-key-3F","(p1)","<p>Returns true if the database contains the specified key, false otherwise.\n"],["key?","ENV","ENV.html#method-c-key-3F","(p1)","<p>ENV.has_key?, ENV.member?, and ENV.key? are aliases for ENV.include?.\n<p>Returns <code>true</code> if there is an environment …\n"],["key?","GDBM","GDBM.html#method-i-key-3F","(p1)","<p>Returns true if the given key <em>k</em> exists within the database. Returns false otherwise.\n"],["key?","Hash","Hash.html#method-i-key-3F","(p1)","<p>Returns <code>true</code> if the given key is present in <em>hsh</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;b&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">200</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">has_key?</span>(<span class=\"ruby-string\">&quot;a&quot;</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["key?","Net::HTTPHeader","Net/HTTPHeader.html#method-i-key-3F","(key)","<p>true if <code>key</code> header exists.\n"],["key?","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-key-3F","(p1)","<p>Returns <code>true</code> if <code>key</code> is registered\n"],["key?","Racc::ISet","Racc/ISet.html#method-i-key-3F","(key)",""],["key?","SDBM","SDBM.html#method-i-key-3F","(p1)","<p>Returns <code>true</code> if the database contains the given <code>key</code>.\n"],["key?","Thread","Thread.html#method-i-key-3F","(p1)","<p>Returns <code>true</code> if the given string (or symbol) exists as a fiber-local variable.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">me</span> = <span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">current</span>\n<span class=\"ruby-identifier\">me</span>[<span class=\"ruby-value\">:oliver</span>] <span class=\"ruby-operator\">...</span>\n</pre>\n"],["key_for","Bundler::Settings","Bundler/Settings.html#method-i-key_for","(key)",""],["key_len","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-key_len","()","<p>Returns the key length in bytes of the Cipher.\n"],["key_len=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-key_len-3D","(p1)","<p>Sets the key length of the cipher.  If the cipher is a fixed length cipher then attempting to set the …\n"],["keys","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-keys","()",""],["keys","CGI::QueryExtension","CGI/QueryExtension.html#method-i-keys","(*args)","<p>Return all query parameter names as an array of String.\n"],["keys","DBM","DBM.html#method-i-keys","()","<p>Returns an array of all the string keys in the database.\n"],["keys","ENV","ENV.html#method-c-keys","()","<p>Returns all variable names in an Array:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">replace</span>(<span class=\"ruby-string\">&#39;foo&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;0&#39;</span>, <span class=\"ruby-string\">&#39;bar&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;1&#39;</span>)\n<span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">keys</span> <span class=\"ruby-comment\"># =&gt; [&#39;bar&#39;, ...</span>\n</pre>\n"],["keys","GDBM","GDBM.html#method-i-keys","()","<p>Returns an array of all keys of this database.\n"],["keys","Hash","Hash.html#method-i-keys","()","<p>Returns a new array populated with the keys from this hash. See also Hash#values.\n\n<pre>h = { &quot;a&quot; =&gt; 100, &quot;b&quot; ...</pre>\n"],["keys","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-keys","()","<p>Iterates over keys and objects in a weakly referenced object\n"],["keys","SDBM","SDBM.html#method-i-keys","()","<p>Returns a new Array containing the keys in the database.\n"],["keys","Thread","Thread.html#method-i-keys","()","<p>Returns an array of the names of the fiber-local variables (as Symbols).\n\n<pre>thr = Thread.new do\n  Thread.current[:cat] ...</pre>\n"],["keys_with_inspector","IRB::Inspector","IRB/Inspector.html#method-c-keys_with_inspector","(inspector)","<p>Determines the inspector to use where <code>inspector</code> is one of the keys passed during inspector definition. …\n"],["kill","DRb::ThreadObject","DRb/ThreadObject.html#method-i-kill","()",""],["kill","IRB::JobManager","IRB/JobManager.html#method-i-kill","(*keys)","<p>Terminates the irb sessions specified by the given <code>keys</code>.\n<p>Raises an IrbAlreadyDead exception if one of …\n"],["kill","Process","Process.html#method-c-kill","(*args)","<p>Sends the given signal to the specified process id(s) if <em>pid</em> is positive. If <em>pid</em> is zero, <em>signal</em> is sent …\n"],["kill","Thread","Thread.html#method-i-kill","()","<p>Terminates <code>thr</code> and schedules another thread to be run, returning the terminated Thread.  If this is the …\n"],["kill","Thread","Thread.html#method-c-kill","(p1)","<p>Causes the given <code>thread</code> to exit, see also Thread::exit.\n\n<pre>count = 0\na = Thread.new { loop { count += 1 } ...</pre>\n"],["kind_of?","Object","Object.html#method-i-kind_of-3F","(p1)","<p>Returns <code>true</code> if <em>class</em> is the class of <em>obj</em>, or if <em>class</em> is one of the superclasses of <em>obj</em> or modules included …\n"],["known_class?","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-known_class-3F","(target_class, class_name)",""],["l","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-l","()",""],["la=","Racc::State","Racc/State.html#method-i-la-3D","(la)",""],["label","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-label","()","<p>Returns the label of this instruction sequence.\n<p><code>&lt;main&gt;</code> if it&#39;s at the top level, <code>&lt;compiled&gt;</code> …\n"],["label","Thread::Backtrace::Location","Thread/Backtrace/Location.html#method-i-label","()","<p>Returns the label of this frame.\n<p>Usually consists of method, class, module, etc names with decoration. …\n"],["lambda","Kernel","Kernel.html#method-i-lambda","()","<p>Equivalent to Proc.new, except the resulting Proc objects check the number of parameters passed when …\n"],["lambda?","Proc","Proc.html#method-i-lambda-3F","()","<p>Returns <code>true</code> if a Proc object is lambda. <code>false</code> if non-lambda.\n<p>The lambda-ness affects argument handling …\n"],["lang","REXML::Functions","REXML/Functions.html#method-c-lang","( language )","<p>UNTESTED\n"],["laplace_expansion","Matrix","Matrix.html#method-i-laplace_expansion","(row: nil, column: nil)","<p>Returns the Laplace expansion along given row or column.\n\n<pre>Matrix[[7,6], [3,9]].laplace_expansion(column: ...</pre>\n"],["last","Array","Array.html#method-i-last","(*args)","<p>Returns the last element(s) of <code>self</code>. If the array is empty, the first form returns <code>nil</code>.\n<p>See also Array#first …\n"],["last","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-last","(p1)","<p>Returns the last number in this arithmetic sequence, or an array of the last <code>n</code> elements.\n"],["last","REXML::Functions","REXML/Functions.html#method-c-last","( )","<p>Returns the last node of the given list of nodes.\n"],["last","Range","Range.html#method-i-last","(*args)","<p>Returns the last object in the range, or an array of the last <code>n</code> elements.\n<p>Note that with no arguments …\n"],["lastBuildDate=","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-lastBuildDate-3D","(_date)",""],["last_attempt?","Bundler::Retry","Bundler/Retry.html#method-i-last_attempt-3F","()",""],["last_column","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-last_column","()","<p>The column number in the source code where this AST&#39;s text ended.\n"],["last_error","Encoding::Converter","Encoding/Converter.html#method-i-last_error","()","<p>Returns an exception object for the last conversion. Returns nil if the last conversion did not produce …\n"],["last_error","Fiddle","Fiddle.html#method-c-last_error","()","<p>Returns the last <code>Error</code> of the current executing <code>Thread</code> or nil if none\n"],["last_error=","Fiddle","Fiddle.html#method-c-last_error-3D","(error)","<p>Sets the last <code>Error</code> of the current executing <code>Thread</code> to <code>error</code>\n"],["last_line","CSV::Parser","CSV/Parser.html#method-i-last_line","()",""],["last_lineno","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-last_lineno","()","<p>The line number in the source code where this AST&#39;s text ended.\n"],["last_match","Regexp","Regexp.html#method-c-last_match","(*args)","<p>The first form returns the MatchData object generated by the last successful pattern match.  Equivalent …\n"],["last_modified","OpenURI::Meta","OpenURI/Meta.html#method-i-last_modified","()","<p>returns a Time that represents the Last-Modified field.\n"],["last_modified","RDoc::TopLevel","RDoc/TopLevel.html#method-i-last_modified","()","<p>Time this file was last modified, if known\n"],["last_status","Process","Process.html#method-c-last_status","()","<p>Returns the status of the last executed child process in the current thread.\n\n<pre>Process.wait Process.spawn(&quot;ruby&quot;, ...</pre>\n"],["last_update","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-last_update","()",""],["last_update=","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-last_update-3D","(p1)",""],["last_version_number","Bundler::CLI::Inject","Bundler/CLI/Inject.html#method-i-last_version_number","()",""],["latest_gc_info","GC","GC.html#method-c-latest_gc_info","(hash_or_key = nil)","<p>Returns information about the most recent garbage collection.\n"],["latest_rubygems_version","Gem","Gem.html#method-c-latest_rubygems_version","()","<p>Returns the latest release version of RubyGems.\n"],["latest_spec_for","Gem","Gem.html#method-c-latest_spec_for","(name)","<p>Returns the latest release-version specification for the gem <code>name</code>.\n"],["latest_specs","Gem::Server","Gem/Server.html#method-i-latest_specs","(req, res)",""],["latest_specs","Gem::Specification","Gem/Specification.html#method-c-latest_specs","(prerelease = false)","<p>Return the latest specs, optionally including prerelease specs if <code>prerelease</code> is true.\n"],["latest_version","Bundler::Molinillo::Resolver::Resolution::PossibilitySet","Bundler/Molinillo/Resolver/Resolution/PossibilitySet.html#method-i-latest_version","()","<p>@return [Object] most up-to-date dependency in the possibility set\n"],["latest_version?","Gem::Dependency","Gem/Dependency.html#method-i-latest_version-3F","()","<p>Is this dependency simply asking for the latest version of a gem?\n"],["latest_version_for","Gem","Gem.html#method-c-latest_version_for","(name)","<p>Returns the version of the latest release-version of gem <code>name</code>\n"],["launch","Gem::Server","Gem/Server.html#method-i-launch","()",""],["lazy","Enumerable","Enumerable.html#method-i-lazy","()","<p>Returns an Enumerator::Lazy, which redefines most Enumerable methods to postpone enumeration and enumerate …\n"],["lazy","Enumerator::Lazy","Enumerator/Lazy.html#method-i-lazy","()","<p>Returns self.\n"],["lchmod","File","File.html#method-c-lchmod","(*args)","<p>Equivalent to File::chmod, but does not follow symbolic links (so it will change the permissions associated …\n"],["lchmod","Pathname","Pathname.html#method-i-lchmod","(p1)","<p>Same as Pathname.chmod, but does not follow symbolic links.\n<p>See File.lchmod.\n"],["lchown","File","File.html#method-c-lchown","(*args)","<p>Equivalent to File::chown, but does not follow symbolic links (so it will change the owner associated …\n"],["lchown","Pathname","Pathname.html#method-i-lchown","(p1, p2)","<p>Same as Pathname.chown, but does not follow symbolic links.\n<p>See File.lchown.\n"],["lcm","Integer","Integer.html#method-i-lcm","(p1)","<p>Returns the least common multiple of the two integers. The result is always positive. 0.lcm(x) and x.lcm …\n"],["ld","Date","Date.html#method-i-ld","()","<p>Returns the Lilian day number.  This is a whole number, which is adjusted by the offset as the local …\n"],["ldd_available?","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-ldd_available-3F","()",""],["ldexp","Math","Math.html#method-c-ldexp","(p1, p2)","<p>Returns the value of <code>fraction</code>*(2**<code>exponent</code>).\n\n<pre>fraction, exponent = Math.frexp(1234)\nMath.ldexp(fraction, ...</pre>\n"],["leap?","Date","Date.html#method-i-leap-3F","()","<p>Returns true if the year is a leap year.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2000</span>).<span class=\"ruby-identifier\">leap?</span>      <span class=\"ruby-comment\">#=&gt; true</span>\n<span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>).<span class=\"ruby-identifier\">leap?</span>      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["leap?","Date","Date.html#method-c-leap-3F","(p1)","<p>Returns true if the given year is a leap year of the proleptic Gregorian calendar.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">gregorian_leap?</span>(<span class=\"ruby-value\">1900</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["leave","REXML::XPathParser","REXML/XPathParser.html#method-i-leave","(tag, *args)",""],["left","Racc::Grammar::PrecedenceDefinitionEnv","Racc/Grammar/PrecedenceDefinitionEnv.html#method-i-left","(*syms)",""],["legacy_platform","Gem::TestCase::SpecFetcherSetup","Gem/TestCase/SpecFetcherSetup.html#method-i-legacy_platform","()","<p>Creates a legacy platform spec with the name &#39;pl&#39; and version 1\n"],["length","Array","Array.html#method-i-length","()","<p>Returns the number of elements in <code>self</code>. May be zero.\n\n<pre class=\"ruby\">[ <span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">4</span>, <span class=\"ruby-value\">5</span> ].<span class=\"ruby-identifier\">length</span>   <span class=\"ruby-comment\">#=&gt; 5</span>\n[].<span class=\"ruby-identifier\">length</span>       <span class=\"ruby-operator\">...</span>\n</pre>\n"],["length","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-length","()","<p>The number of connections available on the stack.\n"],["length","Bundler::SpecSet","Bundler/SpecSet.html#method-i-length","()",""],["length","DBM","DBM.html#method-i-length","()","<p>Returns the number of entries in the database.\n"],["length","Digest::Instance","Digest/Instance.html#method-i-length","()","<p>Returns digest_obj.digest_length().\n"],["length","ENV","ENV.html#method-c-length","()","<p>Returns the number of environment variables.\n"],["length","GDBM","GDBM.html#method-i-length","()","<p>Returns the number of key-value pairs in this database.\n"],["length","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-length","()",""],["length","Hash","Hash.html#method-i-length","()","<p>Returns the number of key-value pairs in the hash.\n\n<pre>h = { &quot;d&quot; =&gt; 100, &quot;a&quot; =&gt; 200, &quot;v&quot; =&gt; 300, &quot;e&quot; =&gt; 400 ...</pre>\n"],["length","MatchData","MatchData.html#method-i-length","()","<p>Returns the number of elements in the match array.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> = <span class=\"ruby-regexp\">/(.)(.)(\\d+)(\\d)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;THX1138.&quot;</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">length</span>   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["length","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-length","()","<p>Returns the number of referenced objects\n"],["length","Queue","Queue.html#method-i-length","()","<p>Returns the length of the queue.\n"],["length","REXML::Attributes","REXML/Attributes.html#method-i-length","()","<p>Returns the number of attributes the owning Element contains.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">doc</span> = <span class=\"ruby-constant\">Document</span> <span class=\"ruby-string\">&quot;&lt;a x=&#39;1&#39; y=&#39;2&#39; foo:x=&#39;3&#39;/&gt;&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["length","REXML::Parent","REXML/Parent.html#method-i-length","()",""],["length","SDBM","SDBM.html#method-i-length","()","<p>Returns the number of keys in the database.\n"],["length","Set","Set.html#method-i-length","()",""],["length","SizedQueue","SizedQueue.html#method-i-length","()","<p>Returns the length of the queue.\n"],["length","String","String.html#method-i-length","()","<p>Returns the character length of <em>str</em>.\n"],["length","StringIO","StringIO.html#method-i-length","()","<p>Returns the size of the buffer string.\n"],["length","Struct","Struct.html#method-i-length","()","<p>Returns the number of struct members.\n\n<pre>Customer = Struct.new(:name, :address, :zip)\njoe = Customer.new(&quot;Joe ...</pre>\n"],["length","Symbol","Symbol.html#method-i-length","()","<p>Same as <code>sym.to_s.length</code>.\n"],["length","Tempfile","Tempfile.html#method-i-length","()",""],["level","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-level","(name = nil)",""],["level","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-level","(name = nil)",""],["level","Socket::AncillaryData","Socket/AncillaryData.html#method-i-level","()","<p>returns the cmsg level as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AncillaryData</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:PKTINFO</span>, <span class=\"ruby-string\">&quot;&quot;</span>).<span class=\"ruby-identifier\">level</span>\n<span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["level","Socket::Option","Socket/Option.html#method-i-level","()","<p>returns the socket level as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:RECVPKTINFO</span>, [<span class=\"ruby-value\">1</span>].<span class=\"ruby-identifier\">pack</span>(<span class=\"ruby-string\">&quot;i!&quot;</span>)).<span class=\"ruby-identifier\">level</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["level","Zlib::GzipFile","Zlib/GzipFile.html#method-i-level","()","<p>Returns compression level.\n"],["level=","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-level-3D","(value)","<p>@param value [Symbol] One of three Symbols: :major, :minor or :patch.\n"],["level=","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-level-3D","(level)",""],["level=","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-level-3D","(name)",""],["level=","IRB::Notifier::CompositeNotifier","IRB/Notifier/CompositeNotifier.html#method-i-level-3D","(value)",""],["level=","Logger","Logger.html#method-i-level-3D","(severity)","<p>Set logging severity threshold.\n<p><code>severity</code> &mdash; The Severity of the log message.\n\n"],["level_notifier=","IRB::Notifier::CompositeNotifier","IRB/Notifier/CompositeNotifier.html#method-i-level_notifier-3D","(value)","<p>Sets the leveled notifier for this object.\n<p>When the given <code>value</code> is an instance of AbstractNotifier, #level_notifier …\n"],["levenshtein_distance","Bundler::SimilarityDetector","Bundler/SimilarityDetector.html#method-i-levenshtein_distance","(this, that, ins = 2, del = 2, sub = 1)","<p>www.informit.com/articles/article.aspx?p=683059&seqNum=36\n"],["levenshtein_distance","Gem::Text","Gem/Text.html#method-i-levenshtein_distance","(str1, str2)","<p>This code is based directly on the Text gem implementation Returns a value representing the “cost” …\n"],["lex","Ripper","Ripper.html#method-c-lex","(src, filename = '-', lineno = 1)","<p>Tokenizes the Ruby program and returns an array of an array, which is formatted like <code>[[lineno, column],</code> …\n"],["lex_state_name","Ripper","Ripper.html#method-c-lex_state_name","(p1)","<p>Returns a string representation of lex_state.\n"],["lgamma","Math","Math.html#method-c-lgamma","(p1)","<p>Calculates the logarithmic gamma of <code>x</code> and the sign of gamma of <code>x</code>.\n<p>Math.lgamma(x) is same as\n\n<pre>[Math.log(Math.gamma(x).abs), ...</pre>\n"],["lib_dirs_glob","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-lib_dirs_glob","()","<p>Returns a string usable in Dir.glob to match all requirable paths for this spec.\n"],["lib_files","Gem::Specification","Gem/Specification.html#method-i-lib_files","()","<p>Files in the Gem under one of the require_paths\n"],["liberal_parsing?","CSV","CSV.html#method-i-liberal_parsing-3F","()","<p>Returns <code>true</code> if illegal input is handled. See CSV::new for details.\n"],["liberal_parsing?","CSV::Parser","CSV/Parser.html#method-i-liberal_parsing-3F","()",""],["library_name","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-library_name","()","<p>Returns library name. If the method fails to access library name, WIN32OLERuntimeError is raised.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlib</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["libyaml_version","Psych","Psych.html#method-c-libyaml_version","()","<p>Returns the version of libyaml being used\n"],["license","Gem::Specification","Gem/Specification.html#method-i-license","()","<p>Singular accessor for #licenses\n"],["license=","Gem::Specification","Gem/Specification.html#method-i-license-3D","(o)","<p>The license for this gem.\n<p>The license must be no more than 64 characters.\n<p>This should just be the name …\n"],["licenses","Bundler::CLI","Bundler/CLI.html#method-i-licenses","()",""],["licenses","Gem::Specification","Gem/Specification.html#method-i-licenses","()","<p>Plural accessor for setting licenses\n<p>See #license= for details\n"],["licenses=","Gem::Specification","Gem/Specification.html#method-i-licenses-3D","(licenses)","<p>The license(s) for the library.\n<p>Each license must be a short name, no more than 64 characters.\n<p>This should …\n"],["limit","BigDecimal","BigDecimal.html#method-c-limit","(p1 = v1)","<p>Limit the number of significant digits in newly created BigDecimal numbers to the specified value. Rounding …\n"],["line","CSV","CSV.html#method-i-line","()","<p>The last row read from this file.\n"],["line","CSV::Parser","CSV/Parser.html#method-i-line","()",""],["line","IRB::Canvas","IRB/Canvas.html#method-i-line","((x1, y1), (x2, y2))",""],["line","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-i-line","(line_no)","<p>Returns the current line number for #io.\n<p>#line counts the number of times #gets is called.\n<p>See IO#lineno …\n"],["line","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-line","(line_no)","<p>Returns the current line number for #io.\n<p>#line counts the number of times #gets is called.\n<p>See IO#lineno …\n"],["line","IRB::StdioInputMethod","IRB/StdioInputMethod.html#method-i-line","(line_no)","<p>Returns the current line number for #io.\n<p>#line counts the number of times #gets is called.\n<p>See IO#lineno …\n"],["line","REXML::ParseException","REXML/ParseException.html#method-i-line","()",""],["line","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-line","(str = '')",""],["line0","IRB::Canvas","IRB/Canvas.html#method-i-line0","(p1, p2)",""],["line_buffer","Readline","Readline.html#method-c-line_buffer","()","<p>Returns the full line that is being edited. This is useful from within the complete_proc for determining …\n"],["line_editor","Reline","Reline.html#method-c-line_editor","()",""],["line_width","Psych::Emitter","Psych/Emitter.html#method-i-line_width","()","<p>Get the preferred line width.\n"],["line_width=","Psych::Emitter","Psych/Emitter.html#method-i-line_width-3D","(p1)","<p>Set the preferred line with to <code>width</code>.\n"],["lineno","ARGF","ARGF.html#method-i-lineno","()","<p>Returns the current line number of ARGF as a whole. This value can be set manually with <code>ARGF.lineno=</code> …\n"],["lineno","CSV","CSV.html#method-i-lineno","()","<p>The line number of the last row read from this file. Fields with nested line-end characters will not …\n"],["lineno","CSV::Parser","CSV/Parser.html#method-i-lineno","()",""],["lineno","IO","IO.html#method-i-lineno","()","<p>Returns the current line number in <em>ios</em>.  The stream must be opened for reading. #lineno counts the number …\n"],["lineno","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-lineno","()",""],["lineno","Ripper","Ripper.html#method-i-lineno","()","<p>Return line number of current parsing line. This number starts from 1.\n"],["lineno","Ripper::Filter","Ripper/Filter.html#method-i-lineno","()","<p>The line number of the current token. This value starts from 1. This method is valid only in event handlers. …\n"],["lineno","StringIO","StringIO.html#method-i-lineno","()","<p>Returns the current line number. The stream must be opened for reading. <code>lineno</code> counts the number of times …\n"],["lineno","Thread::Backtrace::Location","Thread/Backtrace/Location.html#method-i-lineno","()","<p>Returns the line number of this frame.\n<p>For example, using <code>caller_locations.rb</code> from Thread::Backtrace::Location …\n"],["lineno","TracePoint","TracePoint.html#method-i-lineno","()","<p>Line number of the event\n"],["lineno","Zlib::GzipReader","Zlib/GzipReader.html#method-i-lineno","()","<p>The line number of the last row read from this file.\n"],["lineno=","ARGF","ARGF.html#method-i-lineno-3D","(p1)","<p>Sets the line number of <code>ARGF</code> as a whole to the given <code>Integer</code>.\n<p><code>ARGF</code> sets the line number automatically …\n"],["lineno=","IO","IO.html#method-i-lineno-3D","(p1)","<p>Manually sets the current line number to the given value. <code>$.</code> is updated only on the next read.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["lineno=","StringIO","StringIO.html#method-i-lineno-3D","(p1)","<p>Manually sets the current line number to the given value. <code>$.</code> is updated only on the next read.\n"],["lineno=","Zlib::GzipReader","Zlib/GzipReader.html#method-i-lineno-3D","(p1)","<p>Specify line number of the last row read from this file.\n"],["lines","ARGF","ARGF.html#method-i-lines","(*args)","<p>This is a deprecated alias for #each_line.\n"],["lines","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-lines","(path)",""],["lines","IO","IO.html#method-i-lines","(*args)","<p>This is a deprecated alias for #each_line.\n"],["lines","String","String.html#method-i-lines","(*args)","<p>Returns an array of lines in <em>str</em> split using the supplied record separator (<code>$/</code> by default).  This is …\n"],["lines","StringIO","StringIO.html#method-i-lines","(*args)","<p>This is a deprecated alias for #each_line.\n"],["lines","Zlib::GzipReader","Zlib/GzipReader.html#method-i-lines","(*args)","<p>This is a deprecated alias for <code>each_line</code>.\n"],["linger","Socket::Option","Socket/Option.html#method-i-linger","()","<p>Returns the linger data in <em>sockopt</em> as a pair of boolean and integer.\n\n<pre>sockopt = Socket::Option.linger(true, ...</pre>\n"],["linger","Socket::Option","Socket/Option.html#method-c-linger","(p1, p2)","<p>Creates a new Socket::Option object for SOL_SOCKET/SO_LINGER.\n<p><em>onoff</em> should be an integer or a boolean. …\n"],["link","Bundler::FileUtils","Bundler/FileUtils.html#method-i-link","(src, dest, force: nil, noop: nil, verbose: nil)",""],["link","Bundler::FileUtils","Bundler/FileUtils.html#method-c-link","(src, dest, force: nil, noop: nil, verbose: nil)",""],["link","File","File.html#method-c-link","(p1, p2)","<p>Creates a new name for an existing file using a hard link. Will not overwrite <em>new_name</em> if it already …\n"],["link","FileUtils","FileUtils.html#method-c-link","(src, dest, force: nil, noop: nil, verbose: nil)",""],["link","FileUtils","FileUtils.html#method-i-link","(src, dest, force: nil, noop: nil, verbose: nil)",""],["link","RSS::Maker::ImageBase","RSS/Maker/ImageBase.html#method-i-link","()",""],["link_command","MakeMakefile","MakeMakefile.html#method-i-link_command","(ldflags, *opts)",""],["link_entry","Bundler::FileUtils","Bundler/FileUtils.html#method-i-link_entry","(src, dest, dereference_root = false, remove_destination = false)","<p>Hard links a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links its contents recursively. …\n"],["link_entry","Bundler::FileUtils","Bundler/FileUtils.html#method-c-link_entry","(src, dest, dereference_root = false, remove_destination = false)","<p>Hard links a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links its contents recursively. …\n"],["link_entry","FileUtils","FileUtils.html#method-c-link_entry","(src, dest, dereference_root = false, remove_destination = false)","<p>Hard links a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links its contents recursively. …\n"],["link_entry","FileUtils","FileUtils.html#method-i-link_entry","(src, dest, dereference_root = false, remove_destination = false)","<p>Hard links a file system entry <code>src</code> to <code>dest</code>. If <code>src</code> is a directory, this method links its contents recursively. …\n"],["link_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-link_file","(source, *args)","<p>Links the file from the relative source to the relative destination. If the destination is not given …\n"],["link_local?","IPAddr","IPAddr.html#method-i-link_local-3F","()","<p>Returns true if the ipaddr is a link-local address.  IPv4 addresses in 169.254.0.0/16 reserved by RFC …\n"],["link_to","RDoc::Markdown","RDoc/Markdown.html#method-i-link_to","(content, label = content, text = nil)","<p>Finds a link reference for <code>label</code> and creates a new link to it with\n<code>content</code> as the link text. If <code>label</code> ...\n"],["list","Bundler::CLI","Bundler/CLI.html#method-i-list","()",""],["list","Bundler::CLI::Config","Bundler/CLI/Config.html#method-i-list","()",""],["list","Bundler::CLI::Plugin","Bundler/CLI/Plugin.html#method-i-list","()",""],["list","Bundler::Plugin","Bundler/Plugin.html#method-i-list","()","<p>List installed plugins and commands\n"],["list","Encoding","Encoding.html#method-c-list","()","<p>Returns the list of loaded encodings.\n\n<pre>Encoding.list\n#=&gt; [#&lt;Encoding:ASCII-8BIT&gt;, #&lt;Encoding:UTF-8&gt;,\n  ...</pre>\n"],["list","Net::FTP","Net/FTP.html#method-i-list","(*args)","<p>Returns an array of file information in the directory (the output is like `ls -l`).  If a block is given, …\n"],["list","Net::IMAP","Net/IMAP.html#method-i-list","(refname, mailbox)","<p>Sends a LIST command, and returns a subset of names from the complete set of all names available to the …\n"],["list","Signal","Signal.html#method-c-list","()","<p>Returns a list of signal names mapped to the corresponding underlying signal numbers.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Signal</span>.<span class=\"ruby-identifier\">list</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["list","Thread","Thread.html#method-c-list","()","<p>Returns an array of Thread objects for all threads that are either runnable or stopped.\n\n<pre>Thread.new { sleep(200) ...</pre>\n"],["list","ThreadGroup","ThreadGroup.html#method-i-list","()","<p>Returns an array of all existing Thread objects that belong to this group.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ThreadGroup</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Default</span>.<span class=\"ruby-identifier\">list</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["list","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-i-list","()","<p>Returns all the FormData as an Array\n"],["list_files_in_directory","RDoc::RDoc","RDoc/RDoc.html#method-i-list_files_in_directory","(dir)","<p>Return a list of the files to be processed in a directory. We know that this directory doesn&#39;t have …\n"],["list_item_from","RDoc::Markdown","RDoc/Markdown.html#method-i-list_item_from","(unparsed)","<p>Creates an RDoc::Markup::ListItem by parsing the <code>unparsed</code> content from\nthe first parsing pass.\n"],["listable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-listable-3F","()","<p>Returns <code>true</code> if the listing commands, LIST, NLST, and MLSD are applied to the directory.\n"],["listen","Addrinfo","Addrinfo.html#method-i-listen","(backlog=Socket::SOMAXCONN)","<p>creates a listening socket bound to self.\n"],["listen","Gem::Server","Gem/Server.html#method-i-listen","(addresses = @addresses)","<p>Creates server sockets based on the addresses option.  If no addresses were given a server socket for …\n"],["listen","OpenSSL::SSL::SSLServer","OpenSSL/SSL/SSLServer.html#method-i-listen","(backlog=5)","<p>See TCPServer#listen for details.\n"],["listen","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-listen","( *args, &blok )","<p>Listen arguments:\n<p>Symbol, Array, Block\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Listen</span> <span class=\"ruby-identifier\">to</span> <span class=\"ruby-constant\">Symbol</span> <span class=\"ruby-identifier\">events</span> <span class=\"ruby-identifier\">on</span> <span class=\"ruby-constant\">Array</span> <span class=\"ruby-identifier\">elements</span>\n</pre>\n"],["listen","Socket","Socket.html#method-i-listen","(p1)","<p>Listens for connections, using the specified <code>int</code> as the backlog. A call to <em>listen</em> only applies if the …\n"],["listen","TCPServer","TCPServer.html#method-i-listen","(p1)","<p>Listens for connections, using the specified <code>int</code> as the backlog. A call to <em>listen</em> only applies if the …\n"],["listen","UNIXServer","UNIXServer.html#method-i-listen","(p1)","<p>Listens for connections, using the specified <code>int</code> as the backlog. A call to <em>listen</em> only applies if the …\n"],["listen","WEBrick::GenericServer","WEBrick/GenericServer.html#method-i-listen","(address, port)","<p>Adds listeners from <code>address</code> and <code>port</code> to the server.  See WEBrick::Utils::create_listeners for details. …\n"],["listener","RSS::REXMLParser","RSS/REXMLParser.html#method-c-listener","()",""],["listener","RSS::XMLParserParser","RSS/XMLParserParser.html#method-c-listener","()",""],["listener","RSS::XMLScanParser","RSS/XMLScanParser.html#method-c-listener","()",""],["listener=","RSS::REXMLLikeXMLParser","RSS/REXMLLikeXMLParser.html#method-i-listener-3D","(listener)",""],["literal_head?","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-literal_head-3F","(pre, post)",""],["literalize","REXML::Elements","REXML/Elements.html#method-i-literalize","(name)","<p>Private helper class.  Removes quotes from quoted strings\n"],["ljust","String","String.html#method-i-ljust","(*args)","<p>If <em>integer</em> is greater than the length of <em>str</em>, returns a new String of length <em>integer</em> with <em>str</em> left justified …\n"],["ln","Bundler::FileUtils","Bundler/FileUtils.html#method-i-ln","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a hard link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises Errno::EEXIST …\n"],["ln","Bundler::FileUtils","Bundler/FileUtils.html#method-c-ln","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a hard link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises Errno::EEXIST …\n"],["ln","FileUtils","FileUtils.html#method-c-ln","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a hard link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises Errno::EEXIST …\n"],["ln","FileUtils","FileUtils.html#method-i-ln","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a hard link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises Errno::EEXIST …\n"],["ln","OpenSSL::ASN1::ObjectId","OpenSSL/ASN1/ObjectId.html#method-i-ln","()","<p>The long name of the ObjectId, as defined in &lt;openssl/objects.h&gt;.\n"],["ln_s","Bundler::FileUtils","Bundler/FileUtils.html#method-i-ln_s","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a symbolic link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises …\n"],["ln_s","Bundler::FileUtils","Bundler/FileUtils.html#method-c-ln_s","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a symbolic link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises …\n"],["ln_s","FileUtils","FileUtils.html#method-c-ln_s","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a symbolic link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises …\n"],["ln_s","FileUtils","FileUtils.html#method-i-ln_s","(src, dest, force: nil, noop: nil, verbose: nil)","<p>In the first form, creates a symbolic link <code>link</code> which points to <code>target</code>. If <code>link</code> already exists, raises …\n"],["ln_sf","Bundler::FileUtils","Bundler/FileUtils.html#method-i-ln_sf","(src, dest, noop: nil, verbose: nil)","<p>Same as\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">ln_s</span>(<span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["ln_sf","Bundler::FileUtils","Bundler/FileUtils.html#method-c-ln_sf","(src, dest, noop: nil, verbose: nil)","<p>Same as\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">ln_s</span>(<span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["ln_sf","FileUtils","FileUtils.html#method-c-ln_sf","(src, dest, noop: nil, verbose: nil)","<p>Same as\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">ln_s</span>(<span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["ln_sf","FileUtils","FileUtils.html#method-i-ln_sf","(src, dest, noop: nil, verbose: nil)","<p>Same as\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">ln_s</span>(<span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">args</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["load","Bundler","Bundler.html#method-c-load","()",""],["load","Bundler::YAMLSerializer","Bundler/YAMLSerializer.html#method-i-load","(str)",""],["load","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-load","()","<p>Loads the gem dependency file and returns self.\n"],["load","Gem::SafeYAML","Gem/SafeYAML.html#method-c-load","(input)",""],["load","Gem::Specification","Gem/Specification.html#method-c-load","(file)","<p>Loads Ruby format gemspec from <code>file</code>.\n"],["load","IRB::Locale","IRB/Locale.html#method-i-load","(file, priv=nil)",""],["load","JSON","JSON.html#method-i-load","(source, proc = nil, options = {})","<p>Load a ruby data structure from a JSON <em>source</em> and return it. A source can either be a string-like object, …\n"],["load","JSON::GenericObject","JSON/GenericObject.html#method-c-load","(source, proc = nil, opts = {})",""],["load","Kernel","Kernel.html#method-i-load","(p1, p2 = v2)","<p>Loads and executes the Ruby program in the file <em>filename</em>. If the filename does not resolve to an absolute …\n"],["load","Marshal","Marshal.html#method-c-load","(*args)","<p>Returns the result of converting the serialized data in source into a Ruby object (possibly with associated …\n"],["load","OpenSSL::Engine","OpenSSL/Engine.html#method-c-load","(p1 = v1)","<p>This method loads engines. If <em>name</em> is nil, then all builtin engines are loaded. Otherwise, the given …\n"],["load","OptionParser","OptionParser.html#method-i-load","(filename = nil)","<p>Loads options from file names as <code>filename</code>. Does nothing when the file is not present. Returns whether …\n"],["load","Psych","Psych.html#method-c-load","(yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: false, symbolize_names: false)","<p>Load <code>yaml</code> in to a Ruby data structure.  If multiple documents are provided, the object contained in the …\n"],["load_all","RDoc::Store","RDoc/Store.html#method-i-load_all","()","<p>Loads all items from this store into memory.  This recreates a documentation tree for use by a generator …\n"],["load_and_instantiate","Gem::CommandManager","Gem/CommandManager.html#method-i-load_and_instantiate","(command_name)",""],["load_api_keys","Gem::ConfigFile","Gem/ConfigFile.html#method-i-load_api_keys","()",""],["load_cache","RDoc::Store","RDoc/Store.html#method-i-load_cache","()","<p>Loads cache file for this store\n"],["load_certificate","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-i-load_certificate","(certificate_file)","<p>Loads the given <code>certificate_file</code>\n"],["load_class","RDoc::Store","RDoc/Store.html#method-i-load_class","(klass_name)","<p>Loads ri data for <code>klass_name</code> and hooks it up to this store.\n"],["load_class_data","RDoc::Store","RDoc/Store.html#method-i-load_class_data","(klass_name)","<p>Loads ri data for <code>klass_name</code>\n"],["load_config","Bundler::Settings","Bundler/Settings.html#method-i-load_config","(config_file)",""],["load_data","PStore","PStore.html#method-i-load_data","(file, read_only)","<p>Load the given PStore file. If <code>read_only</code> is true, the unmarshalled Hash will be returned. If <code>read_only</code> …\n"],["load_default_cert","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-load_default_cert","()",""],["load_default_key","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-load_default_key","()",""],["load_defaults","Gem::Specification","Gem/Specification.html#method-c-load_defaults","()","<p>Loads the default specifications. It should be called only once.\n"],["load_env_plugins","Gem","Gem.html#method-c-load_env_plugins","()","<p>Find all &#39;rubygems_plugin&#39; files in $LOAD_PATH and load them\n"],["load_file","Gem::ConfigFile","Gem/ConfigFile.html#method-i-load_file","(filename)",""],["load_file","IRB::IrbLoader","IRB/IrbLoader.html#method-i-load_file","(path, priv = nil)","<p>Loads the given file in the current session&#39;s context and evaluates it.\n<p>See Irb#suspend_input_method …\n"],["load_file","Psych","Psych.html#method-c-load_file","(filename, fallback: false)","<p>Load the document contained in <code>filename</code>.  Returns the yaml contained in <code>filename</code> as a Ruby object, or …\n"],["load_from_binary","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-load_from_binary","(p1)","<p>Load an iseq object from binary format String object created by RubyVM::InstructionSequence.to_binary …\n"],["load_from_binary_extra_data","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-load_from_binary_extra_data","(p1)","<p>Load extra data embed into binary format String object.\n"],["load_gemdeps","Gem::RequestSet","Gem/RequestSet.html#method-i-load_gemdeps","(path, without_groups = [], installing = false)","<p>Load a dependency management file.\n"],["load_gemspec","Bundler","Bundler.html#method-c-load_gemspec","(file, validate = false)",""],["load_gemspec","Bundler::Source::Git","Bundler/Source/Git.html#method-i-load_gemspec","(file)",""],["load_gemspec","Bundler::Source::Path","Bundler/Source/Path.html#method-i-load_gemspec","(file)",""],["load_gemspec_uncached","Bundler","Bundler.html#method-c-load_gemspec_uncached","(file, validate = false)",""],["load_index","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-load_index","(index_file, global = false)","<p>Reads the index file from the directory and initializes the instance variables.\n<p>It skips the sources if …\n"],["load_marshal","Bundler","Bundler.html#method-c-load_marshal","(data)",""],["load_method","RDoc::Store","RDoc/Store.html#method-i-load_method","(klass_name, method_name)","<p>Loads ri data for <code>method_name</code> in <code>klass_name</code>\n"],["load_mime_types","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-load_mime_types","(file)","<p>Loads Apache-compatible mime.types in <code>file</code>.\n"],["load_mime_types","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-load_mime_types","(file)","<p>Loads Apache-compatible mime.types in <code>file</code>.\n"],["load_options","RDoc::RDoc","RDoc/RDoc.html#method-i-load_options","()","<p>Loads options from .rdoc_options if the file exists, otherwise creates a new RDoc::Options instance. …\n"],["load_page","RDoc::Store","RDoc/Store.html#method-i-load_page","(page_name)","<p>Loads ri data for <code>page_name</code>\n"],["load_path_insert_index","Gem","Gem.html#method-c-load_path_insert_index","()","<p>The index to insert activated gem paths into the $LOAD_PATH. The activated gem&#39;s paths are inserted …\n"],["load_paths","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-load_paths","()","<p>needed for inline\n"],["load_paths","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-load_paths","(name)",""],["load_paths","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-load_paths","()",""],["load_paths","Gem::Specification","Gem/Specification.html#method-i-load_paths","()",""],["load_plugin","Bundler::Plugin","Bundler/Plugin.html#method-i-load_plugin","(name)","<p>Executes the plugins.rb file\n<p>@param [String] name of the plugin\n"],["load_plugin_files","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-load_plugin_files","(files)",""],["load_plugins","Bundler::Installer","Bundler/Installer.html#method-i-load_plugins","()",""],["load_plugins","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-load_plugins","()",""],["load_plugins","Gem","Gem.html#method-c-load_plugins","()","<p>Find the &#39;rubygems_plugin&#39; files in the latest installed gems and load them\n"],["load_private_key","OpenSSL::Engine","OpenSSL/Engine.html#method-i-load_private_key","(p1 = v1, p2 = v2)","<p>Loads the given private key identified by <em>id</em> and <em>data</em>.\n<p>An EngineError is raised of the OpenSSL::PKey is …\n"],["load_public_key","OpenSSL::Engine","OpenSSL/Engine.html#method-i-load_public_key","(p1 = v1, p2 = v2)","<p>Loads the given public key identified by <em>id</em> and <em>data</em>.\n<p>An EngineError is raised of the OpenSSL::PKey is …\n"],["load_random_file","OpenSSL::Random","OpenSSL/Random.html#method-c-load_random_file","(p1)","<p>Reads bytes from <em>filename</em> and adds them to the PRNG.\n"],["load_rdoc","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-c-load_rdoc","()","<p>Loads the RDoc generator\n"],["load_rdoc","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-c-load_rdoc","()","<p>Loads the RDoc generator\n"],["load_spec","Gem::TestCase::StaticSet","Gem/TestCase/StaticSet.html#method-i-load_spec","(name, ver, platform, source)","<p>Loads a Gem::Specification from this set which has the given <code>name</code>, version <code>ver</code>, <code>platform</code>.  The <code>source</code> …\n"],["load_spec_files","Bundler::Source::Git","Bundler/Source/Git.html#method-i-load_spec_files","()",""],["load_spec_files","Bundler::Source::Path","Bundler/Source/Path.html#method-i-load_spec_files","()",""],["load_specs","Gem::Source","Gem/Source.html#method-i-load_specs","(type)","<p>Loads <code>type</code> kind of specs fetching from +@uri+ if the on-disk cache is out of date.\n<p><code>type</code> is one of the …\n"],["load_stream","Psych","Psych.html#method-c-load_stream","(yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: [])","<p>Load multiple documents given in <code>yaml</code>.  Returns the parsed documents as a list.  If a block is given, …\n"],["load_thorfile","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-load_thorfile","(path, content = nil, debug = false)","<p>Receives a path and load the thor file in the path. The file is evaluated inside the sandbox to avoid …\n"],["load_variable_map","RDoc::Parser::C","RDoc/Parser/C.html#method-i-load_variable_map","(map_name)","<p>Loads the variable map with the given <code>name</code> from the RDoc::Store, if present.\n"],["load_yaml","Gem","Gem.html#method-c-load_yaml","()","<p>Loads YAML, preferring Psych\n"],["load_yaml","RDoc","RDoc.html#method-c-load_yaml","()","<p>Loads the best available YAML library.\n"],["loaded_from","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-loaded_from","(spec)",""],["loaded_from","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-loaded_from","()",""],["loaded_from","Gem::Specification","Gem/Specification.html#method-i-loaded_from","()",""],["loaded_gem_paths","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-loaded_gem_paths","()",""],["loaded_spec_names","Gem::TestCase","Gem/TestCase.html#method-i-loaded_spec_names","()",""],["loaded_specs","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-loaded_specs","(name)",""],["local","Gem::Platform","Gem/Platform.html#method-c-local","()",""],["local","Time","Time.html#method-c-local","(*args)","<p>Same as Time::gm, but interprets the values in the local time zone.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-string\">&quot;jan&quot;</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">20</span>,<span class=\"ruby-value\">15</span>,<span class=\"ruby-value\">1</span>)  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["local?","Bundler::Source::Git","Bundler/Source/Git.html#method-i-local-3F","()",""],["local?","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-local-3F","()","<p>Is local fetching enabled?\n"],["local_address","BasicSocket","BasicSocket.html#method-i-local_address","()","<p>Returns an Addrinfo object for local address obtained by getsockname.\n<p>Note that addrinfo.protocol is filled …\n"],["local_config_file","Bundler::Settings","Bundler/Settings.html#method-i-local_config_file","()",""],["local_index_file","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-local_index_file","()","<p>Path where the local index file is stored\n"],["local_method?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-local_method-3F","(instance, name)",""],["local_method?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-local_method-3F","(instance, name)",""],["local_name","REXML::Functions","REXML/Functions.html#method-c-local_name","(node_set=nil)",""],["local_name","REXML::Light::Node","REXML/Light/Node.html#method-i-local_name","()",""],["local_name=","REXML::Light::Node","REXML/Light/Node.html#method-i-local_name-3D","( name_str )",""],["local_override!","Bundler::Source::Git","Bundler/Source/Git.html#method-i-local_override-21","(path)",""],["local_overrides","Bundler::Settings","Bundler/Settings.html#method-i-local_overrides","()",""],["local_platform","Bundler","Bundler.html#method-c-local_platform","()",""],["local_root","Bundler::Plugin","Bundler/Plugin.html#method-i-local_root","()",""],["local_search","Bundler::Index","Bundler/Index.html#method-i-local_search","(query, base = nil)",""],["local_specification_path","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-local_specification_path","()",""],["local_specs","Bundler::Source::Path","Bundler/Source/Path.html#method-i-local_specs","(*)",""],["local_variable_defined?","Binding","Binding.html#method-i-local_variable_defined-3F","(p1)","<p>Returns <code>true</code> if a local variable <code>symbol</code> exists.\n\n<pre>def foo\n  a = 1\n  binding.local_variable_defined?(:a) ...</pre>\n"],["local_variable_get","Binding","Binding.html#method-i-local_variable_get","(p1)","<p>Returns the value of the local variable <code>symbol</code>.\n\n<pre>def foo\n  a = 1\n  binding.local_variable_get(:a) #=&gt; 1 ...</pre>\n"],["local_variable_get","IRB::WorkSpace","IRB/WorkSpace.html#method-i-local_variable_get","(name)",""],["local_variable_set","Binding","Binding.html#method-i-local_variable_set","(p1, p2)","<p>Set local variable named <code>symbol</code> as <code>obj</code>.\n\n<pre>def foo\n  a = 1\n  bind = binding\n  bind.local_variable_set(:a, ...</pre>\n"],["local_variable_set","IRB::WorkSpace","IRB/WorkSpace.html#method-i-local_variable_set","(name, value)",""],["local_variables","Binding","Binding.html#method-i-local_variables","()","<p>Returns the names of the binding&#39;s local variables as symbols.\n\n<pre>def foo\n  a = 1\n  2.times do |n|\n  ...</pre>\n"],["local_variables","Kernel","Kernel.html#method-i-local_variables","()","<p>Returns the names of the current local variables.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">fred</span> = <span class=\"ruby-value\">1</span>\n<span class=\"ruby-keyword\">for</span> <span class=\"ruby-identifier\">i</span> <span class=\"ruby-keyword\">in</span> <span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>\n   <span class=\"ruby-comment\"># ...</span>\n<span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-identifier\">local_variables</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["local_variables","NameError","NameError.html#method-i-local_variables","()","<p>Return a list of the local variable names defined where this NameError exception was raised.\n<p>Internal …\n"],["locale","WIN32OLE","WIN32OLE.html#method-c-locale","()","<p>Returns current locale id (lcid). The default locale is WIN32OLE::LOCALE_SYSTEM_DEFAULT.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">lcid</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">locale</span>\n</pre>\n"],["locale=","WIN32OLE","WIN32OLE.html#method-c-locale-3D","(p1)","<p>Sets current locale id (lcid).\n\n<pre>WIN32OLE.locale = 1033 # set locale English(U.S)\nobj = WIN32OLE_VARIANT.new(&quot;$100,000&quot;, ...</pre>\n"],["locale_charmap","Encoding","Encoding.html#method-c-locale_charmap","()","<p>Returns the locale charmap name. It returns nil if no appropriate information.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Debian</span> <span class=\"ruby-constant\">GNU</span><span class=\"ruby-operator\">/</span><span class=\"ruby-constant\">Linux</span>\n  <span class=\"ruby-constant\">LANG</span>=<span class=\"ruby-constant\">C</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["localtime","Time","Time.html#method-i-localtime","(*args)","<p>Converts <em>time</em> to local time (using the local time zone in effect at the creation time of <em>time</em>) modifying …\n"],["location","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-location","()",""],["location","Racc::SourceText","Racc/SourceText.html#method-i-location","()",""],["location=","ERB","ERB.html#method-i-location-3D","((filename, lineno))","<p>Sets optional filename and line number that will be used in ERB code evaluation and error reporting. …\n"],["location_of_caller","Gem","Gem.html#method-c-location_of_caller","(depth = 1)","<p>The file name and line number of the caller of the caller of this method.\n<p><code>depth</code> is how many layers up …\n"],["locations","Bundler::Settings","Bundler/Settings.html#method-i-locations","(key)",""],["lock","Bundler::CLI","Bundler/CLI.html#method-i-lock","()",""],["lock","Bundler::Definition","Bundler/Definition.html#method-i-lock","(file, preserve_unknown_sections = false)",""],["lock","Bundler::Installer","Bundler/Installer.html#method-i-lock","(opts = {})",""],["lock","Bundler::ProcessLock","Bundler/ProcessLock.html#method-c-lock","(bundle_path = Bundler.bundle_path)",""],["lock","Bundler::Runtime","Bundler/Runtime.html#method-i-lock","(opts = {})",""],["lock","Mutex","Mutex.html#method-i-lock","()","<p>Attempts to grab the lock and waits if it isn&#39;t available. Raises <code>ThreadError</code> if <code>mutex</code> was locked …\n"],["lock","Net::HTTP","Net/HTTP.html#method-i-lock","(path, body, initheader = nil)","<p>Sends a LOCK request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["lock_sources","Bundler::SourceList","Bundler/SourceList.html#method-i-lock_sources","()",""],["locked?","Mutex","Mutex.html#method-i-locked-3F","()","<p>Returns <code>true</code> if this lock is currently held by some thread.\n"],["locked_bundler_version","Bundler::Definition","Bundler/Definition.html#method-i-locked_bundler_version","()",""],["locked_gems","Bundler","Bundler.html#method-c-locked_gems","()",""],["locked_puts","Gem::StreamUI::ThreadedDownloadReporter","Gem/StreamUI/ThreadedDownloadReporter.html#method-i-locked_puts","(message)",""],["locked_requirement_named","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-locked_requirement_named","(requirement_name)","<p>@param [String] requirement_name the spec name to search for @return [Object] the locked spec named `requirement_name`, …\n"],["locked_requirement_named","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-locked_requirement_named","(requirement_name)","<p>@param [String] requirement_name the spec name to search for @return [Object] the locked spec named `requirement_name`, …\n"],["locked_requirement_possibility_set","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-locked_requirement_possibility_set","(requirement, activated = self.activated)","<p>@param [Object] the proposed requirement @return [Array] possibility set containing only the locked requirement, …\n"],["locked_ruby_version","Bundler::Definition","Bundler/Definition.html#method-i-locked_ruby_version","()",""],["locked_ruby_version_object","Bundler::Definition","Bundler/Definition.html#method-i-locked_ruby_version_object","()",""],["lockfile_contents","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-lockfile_contents","()",""],["lockfile_path","Bundler::Source::Path","Bundler/Source/Path.html#method-i-lockfile_path","()",""],["lockfile_version","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-lockfile_version","()",""],["lockfiles_equal?","Bundler::Definition","Bundler/Definition.html#method-i-lockfiles_equal-3F","(current, proposed, preserve_unknown_sections)",""],["log","BigMath","BigMath.html#method-c-log","(p1, p2)","<p>Computes the natural logarithm of <code>decimal</code> to the specified number of digits of precision, <code>numeric</code>.\n<p>If …\n"],["log","Logger","Logger.html#method-i-log","(severity, message = nil, progname = nil)",""],["log","Math","Math.html#method-c-log","(*args)",""],["log","Syslog","Syslog.html#method-c-log","(*args)","<p>Log a message with the specified priority. Example:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Syslog</span>.<span class=\"ruby-identifier\">log</span>(<span class=\"ruby-constant\">Syslog</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">LOG_CRIT</span>, <span class=\"ruby-string\">&quot;Out of disk space&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["log","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-log","(level, data)","<p>Logs <code>data</code> at <code>level</code> if the given level is above the current log level.\n"],["log","WEBrick::Log","WEBrick/Log.html#method-i-log","(level, data)","<p>Same as BasicLog#log\n"],["log10","Math","Math.html#method-c-log10","(p1)","<p>Returns the base 10 logarithm of <code>x</code>.\n<p>Domain: (0, INFINITY)\n<p>Codomain: (-INFINITY, INFINITY)\n"],["log2","Math","Math.html#method-c-log2","(p1)","<p>Returns the base 2 logarithm of <code>x</code>.\n<p>Domain: (0, INFINITY)\n<p>Codomain: (-INFINITY, INFINITY)\n"],["log_error","Bundler::FriendlyErrors","Bundler/FriendlyErrors.html#method-i-log_error","(error)",""],["log_specs","Bundler::Fetcher::Base","Bundler/Fetcher/Base.html#method-i-log_specs","(debug_msg)",""],["logging","Net::POP3","Net/POP3.html#method-i-logging","(msg)","<p>debugging output for <code>msg</code>\n"],["logging","Net::SMTP","Net/SMTP.html#method-i-logging","(msg)",""],["login","Net::FTP","Net/FTP.html#method-i-login","(user = \"anonymous\", passwd = nil, acct = nil)","<p>Logs in to the remote host.  The session must have been previously connected.  If <code>user</code> is the string …\n"],["login","Net::IMAP","Net/IMAP.html#method-i-login","(user, password)","<p>Sends a LOGIN command to identify the client and carries the plaintext <code>password</code> authenticating this  …\n"],["logo","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-logo","()",""],["logo=","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-logo-3D","(url)",""],["logout","Net::IMAP","Net/IMAP.html#method-i-logout","()","<p>Sends a LOGOUT command to inform the server that the client is done with the connection.\n"],["long_desc","Bundler::Thor","Bundler/Thor.html#method-c-long_desc","(long_description, options = {})","<p>Defines the long description of the next command.\n<p>Parameters\n<p>long description&lt;String&gt;\n"],["long_name","OpenSSL::ASN1::ObjectId","OpenSSL/ASN1/ObjectId.html#method-i-long_name","()",""],["look_for_directives_in","RDoc::Parser::C","RDoc/Parser/C.html#method-i-look_for_directives_in","(context, comment)","<p>Look for directives in a normal comment block:\n\n<pre>/*\n * :title: My Awesome Project\n */</pre>\n<p>This method modifies …\n"],["look_for_directives_in","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-look_for_directives_in","(container, comment)","<p>Look for directives in a normal comment block:\n\n<pre class=\"ruby\"><span class=\"ruby-comment\"># :stopdoc:</span>\n<span class=\"ruby-comment\"># Don&#39;t display comment from this point forward</span>\n</pre>\n"],["lookahead","Racc::States","Racc/States.html#method-i-lookahead","()",""],["lookup","Bundler::SpecSet","Bundler/SpecSet.html#method-i-lookup","()",""],["lookup_color","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-lookup_color","(color)",""],["lookup_ring","Rinda::RingFinger","Rinda/RingFinger.html#method-i-lookup_ring","(timeout=5, &block)","<p>Looks up RingServers waiting <code>timeout</code> seconds.  RingServers will be given <code>block</code> as a callback, which will …\n"],["lookup_ring_any","Rinda::RingFinger","Rinda/RingFinger.html#method-i-lookup_ring_any","(timeout=5)","<p>Returns the first found remote TupleSpace.  Any further recovered TupleSpaces can be found by calling …\n"],["lookup_server","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-lookup_server","(req)","<p>Finds the appropriate virtual host to handle <code>req</code>\n"],["loop","Kernel","Kernel.html#method-i-loop","()","<p>Repeatedly executes the block.\n<p>If no block is given, an enumerator is returned instead.\n\n<pre>loop do\n  print ...</pre>\n"],["loopback?","IPAddr","IPAddr.html#method-i-loopback-3F","()","<p>Returns true if the ipaddr is a loopback address.\n"],["lower","Racc::Grammar::PrecedenceDefinitionEnv","Racc/Grammar/PrecedenceDefinitionEnv.html#method-i-lower","()",""],["lower_triangular?","Matrix","Matrix.html#method-i-lower_triangular-3F","()","<p>Returns <code>true</code> if this is a lower triangular matrix.\n"],["ls","Net::FTP","Net/FTP.html#method-i-ls","(*args)",""],["lshift!","OpenSSL::BN","OpenSSL/BN.html#method-i-lshift-21","(p1)",""],["lstat","File","File.html#method-i-lstat","()","<p>Same as IO#stat, but does not follow the last symbolic link. Instead, reports on the link itself.\n\n<pre>File.symlink(&quot;testfile&quot;, ...</pre>\n"],["lstat","File","File.html#method-c-lstat","(p1)","<p>Same as File::stat, but does not follow the last symbolic link. Instead, reports on the link itself. …\n"],["lstat","Pathname","Pathname.html#method-i-lstat","()","<p>See File.lstat.\n"],["lstrip","String","String.html#method-i-lstrip","()","<p>Returns a copy of the receiver with leading whitespace removed. See also String#rstrip and String#strip …\n"],["lstrip!","String","String.html#method-i-lstrip-21","()","<p>Removes leading whitespace from the receiver. Returns the altered receiver, or <code>nil</code> if no change was made. …\n"],["lsub","Net::IMAP","Net/IMAP.html#method-i-lsub","(refname, mailbox)","<p>Sends a LSUB command, and returns a subset of names from the set of names that the user has declared …\n"],["ludecomp","LUSolve","LUSolve.html#method-i-ludecomp","(a,n,zero=0,one=1)","<p>Performs LU decomposition of the n by n matrix a.\n"],["lup","Matrix","Matrix.html#method-i-lup","()","<p>Returns the LUP decomposition of the matrix; see <code>LUPDecomposition</code>.\n\n<pre>a = Matrix[[1, 2], [3, 4]]\nl, u, p ...</pre>\n"],["lup_decomposition","Matrix","Matrix.html#method-i-lup_decomposition","()",""],["lusolve","LUSolve","LUSolve.html#method-i-lusolve","(a,b,ps,zero=0.0)","<p>Solves a*x = b for x, using LU decomposition.\n<p>a is a matrix, b is a constant vector, x is the solution …\n"],["lutime","File","File.html#method-c-lutime","(*args)","<p>Sets the access and modification times of each named file to the first two arguments. If a file is a …\n"],["maglev?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-maglev-3F","()",""],["magnitude","Complex","Complex.html#method-i-magnitude","()","<p>Returns the absolute part of its polar form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">-1</span>).<span class=\"ruby-identifier\">abs</span>         <span class=\"ruby-comment\">#=&gt; 1</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">3.0</span>, <span class=\"ruby-value\">-4.0</span>).<span class=\"ruby-identifier\">abs</span>  <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["magnitude","Float","Float.html#method-i-magnitude","()","<p>Returns the absolute value of <code>float</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">-34.56</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; 34.56</span>\n<span class=\"ruby-value\">-34.56</span>.<span class=\"ruby-identifier\">abs</span>     <span class=\"ruby-comment\">#=&gt; 34.56</span>\n<span class=\"ruby-value\">34.56</span>.<span class=\"ruby-identifier\">abs</span>      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["magnitude","Integer","Integer.html#method-i-magnitude","()","<p>Returns the absolute value of <code>int</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">-12345</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; 12345</span>\n<span class=\"ruby-value\">-12345</span>.<span class=\"ruby-identifier\">abs</span>     <span class=\"ruby-comment\">#=&gt; 12345</span>\n<span class=\"ruby-value\">12345</span>.<span class=\"ruby-identifier\">abs</span>      <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["magnitude","Numeric","Numeric.html#method-i-magnitude","()","<p>Returns the absolute value of <code>num</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">12</span>.<span class=\"ruby-identifier\">abs</span>         <span class=\"ruby-comment\">#=&gt; 12</span>\n(<span class=\"ruby-value\">-34.56</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; 34.56</span>\n<span class=\"ruby-value\">-34.56</span>.<span class=\"ruby-identifier\">abs</span>     <span class=\"ruby-comment\">#=&gt; 34.56</span>\n</pre>\n"],["magnitude","Rational","Rational.html#method-i-magnitude","()","<p>Returns the absolute value of <code>rat</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2r</span>).<span class=\"ruby-identifier\">abs</span>    <span class=\"ruby-comment\">#=&gt; (1/2)</span>\n(<span class=\"ruby-value\">-1</span><span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2r</span>).<span class=\"ruby-identifier\">abs</span>   <span class=\"ruby-comment\">#=&gt; (1/2)</span>\n</pre>\n<p>Rational#magnitude is …\n"],["magnitude","Vector","Vector.html#method-i-magnitude","()","<p>Returns the modulus (Pythagorean distance) of the vector.\n\n<pre>Vector[5,8,2].r =&gt; 9.643650761</pre>\n"],["mail","Net::POPMail","Net/POPMail.html#method-i-mail","( dest = +'' )",""],["mailfrom","Net::SMTP","Net/SMTP.html#method-i-mailfrom","(from_addr)",""],["mails","Net::POP3","Net/POP3.html#method-i-mails","()","<p>Returns an array of Net::POPMail objects, representing all the messages on the server.  This array is …\n"],["main","IRB::Context","IRB/Context.html#method-i-main","()","<p>The top-level workspace, see WorkSpace#main\n"],["main","RDoc::Store","RDoc/Store.html#method-i-main","()","<p>Gets the main page for this RDoc store.  This page is used as the root of the RDoc server.\n"],["main","Thread","Thread.html#method-c-main","()","<p>Returns the main thread.\n"],["main=","RDoc::Store","RDoc/Store.html#method-i-main-3D","(page)","<p>Sets the main page for this RDoc store.\n"],["main_irb","IRB::JobManager","IRB/JobManager.html#method-i-main_irb","()","<p>Returns the top level irb session.\n"],["main_loop","DRb::DRbServer","DRb/DRbServer.html#method-i-main_loop","()","<p>The main loop performed by a DRbServer&#39;s internal thread.\n<p>Accepts a connection from a client, and …\n"],["main_thread","IRB::JobManager","IRB/JobManager.html#method-i-main_thread","()","<p>Returns the top level thread.\n"],["main_type","Net::HTTPHeader","Net/HTTPHeader.html#method-i-main_type","()","<p>Returns a content type string such as “text”. This method returns nil if Content-Type: header …\n"],["major?","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-major-3F","()","<p>@return [bool] Convenience method for testing value of level variable.\n"],["major_deprecation","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-major_deprecation","(major_version, message, print_caller_location: false)",""],["major_version","Bundler::FeatureFlag","Bundler/FeatureFlag.html#method-i-major_version","()",""],["major_version","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-major_version","()","<p>Returns major version.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Word 10.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Documents&#39;</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["major_version","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-major_version","()","<p>Returns the type library major version.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlib</span> = <span class=\"ruby-constant\">WIN32OLE_TYPELIB</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["make","Gem::Ext::Builder","Gem/Ext/Builder.html#method-c-make","(dest_path, results)",""],["make","RSS::Maker","RSS/Maker.html#method-c-make","(version, &block)","<p>Builder for an RSS object Creates an object of the type passed in <code>args</code>\n<p>Executes the <code>block</code> to populate …\n"],["make","RSS::Maker::RSSBase","RSS/Maker/RSSBase.html#method-c-make","(*args, &block)",""],["make","RSS::Maker::RSSBase","RSS/Maker/RSSBase.html#method-i-make","()",""],["make_affine!","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-make_affine-21","()",""],["make_closure","Racc::State","Racc/State.html#method-i-make_closure","(core)",""],["make_command","Gem::TestCase","Gem/TestCase.html#method-c-make_command","()","<p>Returns the make command for the current platform. For versions of Ruby built on MS Windows with VC++ …\n"],["make_command","Gem::TestCase","Gem/TestCase.html#method-i-make_command","()","<p>Returns the make command for the current platform. For versions of Ruby built on MS Windows with VC++ …\n"],["make_compiler","ERB","ERB.html#method-i-make_compiler","(trim_mode)","<p>Creates a new compiler for ERB.  See ERB::Compiler.new for details\n"],["make_delimiter","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-make_delimiter","(body)",""],["make_destination_dirs","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-make_destination_dirs","(install_destdir)",""],["make_edge","Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular","Bundler/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-make_edge","(graph)","<p>@param  [DependencyGraph] graph the graph to find vertices from @return [Edge] The edge this action adds …\n"],["make_edge","Bundler::Molinillo::DependencyGraph::DeleteEdge","Bundler/Molinillo/DependencyGraph/DeleteEdge.html#method-i-make_edge","(graph)","<p>@param  [DependencyGraph] graph the graph to find vertices from @return [Edge] The edge this action adds …\n"],["make_edge","Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular","Gem/Resolver/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-make_edge","(graph)","<p>@param  [DependencyGraph] graph the graph to find vertices from @return [Edge] The edge this action adds …\n"],["make_edge","Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge","Gem/Resolver/Molinillo/DependencyGraph/DeleteEdge.html#method-i-make_edge","(graph)","<p>@param  [DependencyGraph] graph the graph to find vertices from @return [Edge] The edge this action adds …\n"],["make_entry","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-make_entry","(entry_tuples, platforms)",""],["make_expires","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-make_expires","(sec=nil)","<p>Returns an expiry Time based on <code>sec</code> which can be one of:\n<p>Numeric &mdash; <code>sec</code> seconds into the future\n<p><code>true</code> &mdash; the expiry …\n"],["make_feed","RSS::Maker::Atom::Entry","RSS/Maker/Atom/Entry.html#method-i-make_feed","()",""],["make_feed","RSS::Maker::Atom::Feed","RSS/Maker/Atom/Feed.html#method-i-make_feed","()",""],["make_feed","RSS::Maker::RSS09","RSS/Maker/RSS09.html#method-i-make_feed","()",""],["make_feed","RSS::Maker::RSS10","RSS/Maker/RSS10.html#method-i-make_feed","()",""],["make_link","Pathname","Pathname.html#method-i-make_link","(p1)","<p>Creates a hard link at <em>pathname</em>.\n<p>See File.link.\n"],["make_message","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-make_message","(message)","<p>Adds useful info about the parser to <code>message</code>\n"],["make_methods","Syslog::Logger","Syslog/Logger.html#method-c-make_methods","(meth)","<p>Builds a methods for level <code>meth</code>.\n"],["make_parser","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-make_parser","(set, platforms)",""],["make_passwd","WEBrick::HTTPAuth::BasicAuth","WEBrick/HTTPAuth/BasicAuth.html#method-c-make_passwd","(realm, user, pass)","<p>Used by UserDB to create a basic password entry\n"],["make_passwd","WEBrick::HTTPAuth::DigestAuth","WEBrick/HTTPAuth/DigestAuth.html#method-c-make_passwd","(realm, user, pass)","<p>Used by UserDB to create a digest password entry\n"],["make_passwd","WEBrick::HTTPAuth::UserDB","WEBrick/HTTPAuth/UserDB.html#method-i-make_passwd","(realm, user, pass)","<p>Creates an obscured password in <code>realm</code> with <code>user</code> and <code>password</code> using the auth_type of this database.\n"],["make_pool","DRb::DRbConn","DRb/DRbConn.html#method-c-make_pool","()",""],["make_regexp","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-make_regexp","(schemes = nil)","<p>Returns Regexp that is default self.regexp, unless <code>schemes</code> is provided. Then it is a Regexp.union with …\n"],["make_regexp","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-make_regexp","(schemes = nil)","<p>Returns Regexp that is default self.regexp, unless <code>schemes</code> is provided. Then it is a Regexp.union with …\n"],["make_regexp","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-make_regexp","(schemes = nil)","<p>Returns Regexp that is default self.regexp, unless <code>schemes</code> is provided. Then it is a Regexp.union with …\n"],["make_regexp","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-make_regexp","(schemes = nil)","<p>Returns Regexp that is default self.regexp, unless <code>schemes</code> is provided. Then it is a Regexp.union with …\n"],["make_separator","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-make_separator","(src)",""],["make_socket","Rinda::RingServer","Rinda/RingServer.html#method-i-make_socket","(address, interface_address=nil, multicast_interface=0)","<p>Creates a socket at <code>address</code>\n<p>If <code>address</code> is multicast address then <code>interface_address</code> and <code>multicast_interface</code> …\n"],["make_start_tag","RSS::Element","RSS/Element.html#method-i-make_start_tag","(indent, next_indent, attrs)",""],["make_switch","OptionParser","OptionParser.html#method-i-make_switch","(opts, block = nil)","<p>Creates an OptionParser::Switch from the parameters. The parsed argument value is passed to the given …\n"],["make_symlink","Pathname","Pathname.html#method-i-make_symlink","(p1)","<p>Creates a symbolic link.\n<p>See File.symlink.\n"],["make_temp_directories","Gem::Indexer","Gem/Indexer.html#method-i-make_temp_directories","()","<p>Make directories for index generation\n"],["make_thread_list","DEBUGGER__","DEBUGGER__.html#method-c-make_thread_list","()",""],["make_time","Time","Time.html#method-c-make_time","(date, year, yday, mon, day, hour, min, sec, sec_fraction, zone, now)",""],["make_tuple","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-make_tuple","(ary)","<p>Creates a Rinda::Tuple for <code>ary</code>.\n"],["make_variable_map","RDoc::Store","RDoc/Store.html#method-i-make_variable_map","(variables)","<p>Converts the variable =&gt; ClassModule map <code>variables</code> from a C parser into a variable =&gt; class name …\n"],["make_xml_stylesheets","RSS::Maker::RSSBase","RSS/Maker/RSSBase.html#method-i-make_xml_stylesheets","()",""],["makedirs","Bundler::FileUtils","Bundler/FileUtils.html#method-i-makedirs","(list, mode: nil, noop: nil, verbose: nil)",""],["makedirs","Bundler::FileUtils","Bundler/FileUtils.html#method-c-makedirs","(list, mode: nil, noop: nil, verbose: nil)",""],["makedirs","FileUtils","FileUtils.html#method-i-makedirs","(list, mode: nil, noop: nil, verbose: nil)",""],["makedirs","FileUtils","FileUtils.html#method-c-makedirs","(list, mode: nil, noop: nil, verbose: nil)",""],["maker","RSS::Maker","RSS/Maker.html#method-c-maker","(version)","<p>Can I remove this method?\n"],["maker_target","RSS::Atom::ContentModel","RSS/Atom/ContentModel.html#method-i-maker_target","(target)",""],["maker_target","RSS::Atom::Entry","RSS/Atom/Entry.html#method-i-maker_target","(maker)",""],["maker_target","RSS::Atom::Feed","RSS/Atom/Feed.html#method-i-maker_target","(maker)",""],["maker_target","RSS::Atom::Feed::Category","RSS/Atom/Feed/Category.html#method-i-maker_target","(target)",""],["maker_target","RSS::Atom::Feed::Entry","RSS/Atom/Feed/Entry.html#method-i-maker_target","(items)",""],["maker_target","RSS::Atom::Feed::Link","RSS/Atom/Feed/Link.html#method-i-maker_target","(target)",""],["maker_target","RSS::Atom::Feed::Logo","RSS/Atom/Feed/Logo.html#method-i-maker_target","(target)",""],["maker_target","RSS::Atom::PersonConstruct","RSS/Atom/PersonConstruct.html#method-i-maker_target","(target)",""],["maker_target","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-i-maker_target","(target)",""],["maker_target","RSS::ITunesChannelModel::ITunesCategory","RSS/ITunesChannelModel/ITunesCategory.html#method-i-maker_target","(categories)",""],["maker_target","RSS::ITunesChannelModel::ITunesImage","RSS/ITunesChannelModel/ITunesImage.html#method-i-maker_target","(target)",""],["maker_target","RSS::ITunesChannelModel::ITunesOwner","RSS/ITunesChannelModel/ITunesOwner.html#method-i-maker_target","(target)",""],["maker_target","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-maker_target","(target)",""],["maker_target","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-i-maker_target","(target)",""],["maker_target","RSS::ImageItemModel::ImageItem","RSS/ImageItemModel/ImageItem.html#method-i-maker_target","(target)",""],["maker_target","RSS::RDF::Channel","RSS/RDF/Channel.html#method-i-maker_target","(maker)",""],["maker_target","RSS::RDF::Image","RSS/RDF/Image.html#method-i-maker_target","(maker)",""],["maker_target","RSS::RDF::Item","RSS/RDF/Item.html#method-i-maker_target","(items)",""],["maker_target","RSS::RDF::Textinput","RSS/RDF/Textinput.html#method-i-maker_target","(maker)",""],["maker_target","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-maker_target","(target)",""],["maker_target","RSS::Rss::Channel","RSS/Rss/Channel.html#method-i-maker_target","(maker)",""],["maker_target","RSS::Rss::Channel::Image","RSS/Rss/Channel/Image.html#method-i-maker_target","(maker)",""],["maker_target","RSS::Rss::Channel::Item","RSS/Rss/Channel/Item.html#method-i-maker_target","(items)",""],["maker_target","RSS::Rss::Channel::Item::Category","RSS/Rss/Channel/Item/Category.html#method-i-maker_target","(item)",""],["maker_target","RSS::Rss::Channel::Item::Enclosure","RSS/Rss/Channel/Item/Enclosure.html#method-i-maker_target","(item)",""],["maker_target","RSS::Rss::Channel::Item::Guid","RSS/Rss/Channel/Item/Guid.html#method-i-maker_target","(item)",""],["maker_target","RSS::Rss::Channel::Item::Source","RSS/Rss/Channel/Item/Source.html#method-i-maker_target","(item)",""],["maker_target","RSS::Rss::Channel::TextInput","RSS/Rss/Channel/TextInput.html#method-i-maker_target","(maker)",""],["maker_target","RSS::SetupMaker","RSS/SetupMaker.html#method-i-maker_target","(maker)",""],["maker_target","RSS::TaxonomyTopicModel::TaxonomyTopic","RSS/TaxonomyTopicModel/TaxonomyTopic.html#method-i-maker_target","(target)",""],["maker_target","RSS::TaxonomyTopicsModel::TaxonomyTopics","RSS/TaxonomyTopicsModel/TaxonomyTopics.html#method-i-maker_target","(target)",""],["makers","RSS::Maker","RSS/Maker.html#method-c-makers","()","<p>Returns collection of supported makers\n"],["malloc","Fiddle","Fiddle.html#method-c-malloc","(p1)","<p>Allocate <code>size</code> bytes of memory and return the integer memory address for the allocated memory.\n"],["malloc","Fiddle::CStructEntity","Fiddle/CStructEntity.html#method-c-malloc","(types, func = nil)","<p>Allocates a C struct with the <code>types</code> provided.\n<p>When the instance is garbage collected, the C function  …\n"],["malloc","Fiddle::CUnionEntity","Fiddle/CUnionEntity.html#method-c-malloc","(types, func=nil)","<p>Allocates a C union the <code>types</code> provided.\n<p>When the instance is garbage collected, the C function <code>func</code> is …\n"],["malloc","Fiddle::Pointer","Fiddle/Pointer.html#method-c-malloc","(p1, p2 = v2)","<p>Allocate <code>size</code> bytes of memory and associate it with an optional <code>freefunc</code> that will be called when the …\n"],["malloc_allocated_size","GC","GC.html#method-c-malloc_allocated_size","()","<p>Returns the size of memory allocated by malloc().\n<p>Only available if ruby was built with <code>CALC_EXACT_MALLOC_SIZE</code> …\n"],["malloc_allocations","GC","GC.html#method-c-malloc_allocations","()","<p>Returns the number of malloc() allocations.\n<p>Only available if ruby was built with <code>CALC_EXACT_MALLOC_SIZE</code> …\n"],["manage_owners","Gem::Commands::OwnerCommand","Gem/Commands/OwnerCommand.html#method-i-manage_owners","(method, name, owners)",""],["many","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-many","(sym, &block)",""],["many1","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-many1","(sym, &block)",""],["map","Array","Array.html#method-i-map","()","<p>Invokes the given block once for each element of <code>self</code>.\n<p>Creates a new array containing the values returned …\n"],["map","Bundler::Thor","Bundler/Thor.html#method-c-map","(mappings = nil, **kw)","<p>Maps an input to a command. If you define:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">map</span> <span class=\"ruby-string\">&quot;-T&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&quot;list&quot;</span>\n</pre>\n<p>Running:\n"],["map","Enumerable","Enumerable.html#method-i-map","()","<p>Returns a new array with the results of running <em>block</em> once for every element in <em>enum</em>.\n<p>If no block is given, …\n"],["map","Enumerator::Lazy","Enumerator/Lazy.html#method-i-map","()","<p>Like Enumerable#map, but chains operation to be lazy-evaluated.\n\n<pre>(1..Float::INFINITY).lazy.map {|i| i**2 ...</pre>\n"],["map","Matrix","Matrix.html#method-i-map","(which = :all)",""],["map","Psych::Coder","Psych/Coder.html#method-i-map","(tag = @tag, style = @style)","<p>Emit a map.  The coder will be yielded to the block.\n"],["map","Vector","Vector.html#method-i-map","()",""],["map!","Array","Array.html#method-i-map-21","()","<p>Invokes the given block once for each element of <code>self</code>, replacing the element with the value returned …\n"],["map!","Matrix","Matrix.html#method-i-map-21","(which = :all)",""],["map!","Set","Set.html#method-i-map-21","()",""],["map!","Vector","Vector.html#method-i-map-21","(&block)",""],["map2","Vector","Vector.html#method-i-map2","(v)","<p>Like Vector#collect2, but returns a Vector instead of an Array.\n"],["map=","Psych::Coder","Psych/Coder.html#method-i-map-3D","(map)","<p>Emit a map with <code>value</code>\n"],["map_gems_to_specs","Gem::Indexer","Gem/Indexer.html#method-i-map_gems_to_specs","(gems)",""],["mapping?","Psych::Nodes::Mapping","Psych/Nodes/Mapping.html#method-i-mapping-3F","()",""],["mapping?","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-mapping-3F","()",""],["mark","Psych::Parser","Psych/Parser.html#method-i-mark","()","<p>Returns a Psych::Parser::Mark object that contains line, column, and index information.\n"],["mark_loaded","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-mark_loaded","(spec)",""],["mark_version","Gem::Specification","Gem/Specification.html#method-i-mark_version","()","<p>Sets the rubygems_version to the current RubyGems version.\n"],["markup","RDoc::Text","RDoc/Text.html#method-i-markup","(text)","<p>Convert a string in markup format into HTML.\n<p>Requires the including class to implement #formatter\n"],["marshal_dump","Delegator","Delegator.html#method-i-marshal_dump","()","<p>Serialization support for the object returned by _<em>getobj</em>_.\n"],["marshal_dump","Gem::Version","Gem/Version.html#method-i-marshal_dump","()","<p>Dump only the raw version string, not the complete object. It&#39;s a string for backwards (RubyGems …\n"],["marshal_dump","OpenStruct","OpenStruct.html#method-i-marshal_dump","()","<p>Provides marshalling support for use by the Marshal library.\n"],["marshal_dump","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-marshal_dump","()","<p>Dumps this AnyMethod for use by ri.  See also #marshal_load\n"],["marshal_dump","RDoc::Attr","RDoc/Attr.html#method-i-marshal_dump","()","<p>Dumps this Attr for use by ri.  See also #marshal_load\n"],["marshal_dump","RDoc::Constant","RDoc/Constant.html#method-i-marshal_dump","()","<p>Dumps this Constant for use by ri.  See also #marshal_load\n"],["marshal_dump","RDoc::TopLevel","RDoc/TopLevel.html#method-i-marshal_dump","()","<p>Dumps this TopLevel for use by ri.  See also #marshal_load\n"],["marshal_dump_old","Date","Date.html#method-i-marshal_dump_old","()",""],["marshal_load","Delegator","Delegator.html#method-i-marshal_load","(data)","<p>Reinitializes delegation from a serialized object.\n"],["marshal_load","Gem::Version","Gem/Version.html#method-i-marshal_load","(array)","<p>Load custom marshal format. It&#39;s a string for backwards (RubyGems 1.3.5 and earlier) compatibility. …\n"],["marshal_load","OpenStruct","OpenStruct.html#method-i-marshal_load","(x)","<p>Provides marshalling support for use by the Marshal library.\n"],["marshal_load","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-marshal_load","(array)","<p>Loads this AnyMethod from <code>array</code>.  For a loaded AnyMethod the following methods will return cached values: …\n"],["marshal_load","RDoc::Attr","RDoc/Attr.html#method-i-marshal_load","(array)","<p>Loads this Attr from <code>array</code>.  For a loaded Attr the following methods will return cached values:\n<p>#full_name …\n"],["marshal_load","RDoc::Constant","RDoc/Constant.html#method-i-marshal_load","(array)","<p>Loads this Constant from <code>array</code>.  For a loaded Constant the following methods will return cached values: …\n"],["marshal_spec_dir","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-marshal_spec_dir","()",""],["marshal_version","Gem","Gem.html#method-c-marshal_version","()","<p>The version of the Marshal format for your Ruby.\n"],["mask","IPAddr","IPAddr.html#method-i-mask","(prefixlen)","<p>Returns a new ipaddr built by masking IP address with the given prefixlen/netmask. (e.g. 8, 64, “255.255.255.0”, …\n"],["mask","Syslog","Syslog.html#method-c-mask","()","<p>Returns the log priority mask in effect. The mask is not reset by opening or closing syslog.\n"],["mask!","IPAddr","IPAddr.html#method-i-mask-21","(mask)","<p>Set current netmask to given mask.\n"],["mask=","Syslog","Syslog.html#method-c-mask-3D","(p1)","<p>Sets the log priority mask. A method LOG_UPTO is defined to make it easier to set mask values. Example: …\n"],["match","ACL::ACLEntry","ACL/ACLEntry.html#method-i-match","(addr)","<p>Matches <code>addr</code> against this entry.\n"],["match","ACL::ACLList","ACL/ACLList.html#method-i-match","(addr)","<p>Matches <code>addr</code> against each ACLEntry in this list.\n"],["match","Gem::Platform","Gem/Platform.html#method-c-match","(platform)",""],["match","OptionParser::CompletingHash","OptionParser/CompletingHash.html#method-i-match","(key)","<p>Completion for hash key.\n"],["match","REXML::IOSource","REXML/IOSource.html#method-i-match","( pattern, cons=false )",""],["match","REXML::QuickPath","REXML/QuickPath.html#method-c-match","(element, path, namespaces=EMPTY_HASH)",""],["match","REXML::Source","REXML/Source.html#method-i-match","(pattern, cons=false)",""],["match","REXML::XPath","REXML/XPath.html#method-c-match","(element, path=nil, namespaces=nil, variables={}, options={})","<p>Returns an array of nodes matching a given XPath.\n"],["match","REXML::XPathParser","REXML/XPathParser.html#method-i-match","(path_stack, nodeset)",""],["match","Regexp","Regexp.html#method-i-match","(p1, p2 = v2)","<p>Returns a MatchData object describing the match, or <code>nil</code> if there was no match. This is equivalent to …\n"],["match","Rinda::Template","Rinda/Template.html#method-i-match","(tuple)","<p>Matches this template against <code>tuple</code>.  The <code>tuple</code> must be the same size as the template.  An element with …\n"],["match","Rinda::TemplateEntry","Rinda/TemplateEntry.html#method-i-match","(tuple)","<p>Matches this TemplateEntry against <code>tuple</code>.  See Template#match for details on how a Template matches a …\n"],["match","String","String.html#method-i-match","(*args)","<p>Converts <em>pattern</em> to a Regexp (if it isn&#39;t already one), then invokes its <code>match</code> method on <em>str</em>.  If …\n"],["match","Symbol","Symbol.html#method-i-match","(*args)","<p>Returns <code>sym.to_s.match</code>.\n"],["match?","CSV::MatchP","CSV/MatchP.html#method-i-match-3F","(pattern)",""],["match?","Gem::Dependency","Gem/Dependency.html#method-i-match-3F","(obj, version=nil, allow_prerelease=false)","<p>Does this dependency match the specification described by <code>name</code> and <code>version</code> or match <code>spec</code>?\n<p>NOTE:  Unlike …\n"],["match?","Gem::Licenses","Gem/Licenses.html#method-c-match-3F","(license)",""],["match?","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-match-3F","(spec, allow_prerelease = false)","<p>Does this dependency request match <code>spec</code>?\n<p>NOTE:  #match? only matches prerelease versions when #dependency …\n"],["match?","Regexp","Regexp.html#method-i-match-3F","(*args)","<p>Returns a <code>true</code> or <code>false</code> indicates whether the regexp is matched or not without updating $~ and other …\n"],["match?","String","String.html#method-i-match-3F","(*args)","<p>Converts <em>pattern</em> to a <code>Regexp</code> (if it isn&#39;t already one), then returns a <code>true</code> or <code>false</code> indicates whether …\n"],["match?","StringScanner","StringScanner.html#method-i-match-3F","(p1)","<p>Tests whether the given <code>pattern</code> is matched from the current scan pointer. Returns the length of the match, …\n"],["match?","Symbol","Symbol.html#method-i-match-3F","(*args)","<p>Returns <code>sym.to_s.match?</code>.\n"],["match_platform","Bundler::MatchPlatform","Bundler/MatchPlatform.html#method-i-match_platform","(p)",""],["match_platform!","Gem::AvailableSet","Gem/AvailableSet.html#method-i-match_platform-21","()",""],["match_platform?","Gem::NameTuple","Gem/NameTuple.html#method-i-match_platform-3F","()","<p>Indicate if this NameTuple matches the current platform.\n"],["match_to","REXML::Source","REXML/Source.html#method-i-match_to","( char, pattern )",""],["match_to_consume","REXML::Source","REXML/Source.html#method-i-match_to_consume","( char, pattern )",""],["matched","StringScanner","StringScanner.html#method-i-matched","()","<p>Returns the last matched string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">StringScanner</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;test string&#39;</span>)\n<span class=\"ruby-identifier\">s</span>.<span class=\"ruby-identifier\">match?</span>(<span class=\"ruby-regexp\">/\\w+/</span>)     <span class=\"ruby-comment\"># -&gt; 4</span>\n<span class=\"ruby-identifier\">s</span>.<span class=\"ruby-identifier\">matched</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["matched?","StringScanner","StringScanner.html#method-i-matched-3F","()","<p>Returns <code>true</code> iff the last match was successful.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">StringScanner</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;test string&#39;</span>)\n<span class=\"ruby-identifier\">s</span>.<span class=\"ruby-identifier\">match?</span>(<span class=\"ruby-regexp\">/\\w+/</span>)  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["matched_size","StringScanner","StringScanner.html#method-i-matched_size","()","<p>Returns the size of the most recent match (see #matched), or <code>nil</code> if there was no recent match.\n\n<pre>s = StringScanner.new(&#39;test ...</pre>\n"],["matches","Bundler::Thor::LineEditor::Readline::PathCompletion","Bundler/Thor/LineEditor/Readline/PathCompletion.html#method-i-matches","()",""],["matches?","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-matches-3F","(requirements, version)",""],["matches?","REXML::Entity","REXML/Entity.html#method-c-matches-3F","(string)","<p>Evaluates whether the given string matches an entity definition, returning true if so, and false otherwise. …\n"],["matches?","REXML::Validation::Choice","REXML/Validation/Choice.html#method-i-matches-3F","( event )",""],["matches?","REXML::Validation::Event","REXML/Validation/Event.html#method-i-matches-3F","( event )",""],["matches?","REXML::Validation::Interleave","REXML/Validation/Interleave.html#method-i-matches-3F","( event )",""],["matches?","REXML::Validation::OneOrMore","REXML/Validation/OneOrMore.html#method-i-matches-3F","( event )",""],["matches?","REXML::Validation::Optional","REXML/Validation/Optional.html#method-i-matches-3F","(event)",""],["matches?","REXML::Validation::Sequence","REXML/Validation/Sequence.html#method-i-matches-3F","(event)",""],["matches_for_glob","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-matches_for_glob","(glob)",""],["matches_for_glob","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-matches_for_glob","(glob)","<p>Return all files in this gem that match for <code>glob</code>.\n"],["matches_spec?","Gem::Dependency","Gem/Dependency.html#method-i-matches_spec-3F","(spec)","<p>Does this dependency match <code>spec</code>?\n<p>NOTE:  This is not a convenience method.  Unlike #match? this method …\n"],["matches_spec?","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-matches_spec-3F","(spec)","<p>Does this dependency request match <code>spec</code>?\n<p>NOTE:  #matches_spec? matches prerelease versions.  See also …\n"],["matching_specs","Gem::Dependency","Gem/Dependency.html#method-i-matching_specs","(platform_only = false)",""],["materialize","Bundler::SpecSet","Bundler/SpecSet.html#method-i-materialize","(deps, missing_specs = nil)",""],["materialized_for_all_platforms","Bundler::SpecSet","Bundler/SpecSet.html#method-i-materialized_for_all_platforms","()","<p>Materialize for all the specs in the spec set, regardless of what platform they&#39;re for This is in …\n"],["max","Array","Array.html#method-i-max","(*args)","<p>Returns the object in <em>ary</em> with the maximum value. The first form assumes all objects implement Comparable …\n"],["max","Enumerable","Enumerable.html#method-i-max","(*args)","<p>Returns the object in <em>enum</em> with the maximum value. The first form assumes all objects implement Comparable …\n"],["max","Range","Range.html#method-i-max","(*args)","<p>Returns the maximum value in the range. Returns <code>nil</code> if the begin value of the range larger than the end …\n"],["max","SizedQueue","SizedQueue.html#method-i-max","()","<p>Returns the maximum size of the queue.\n"],["max=","SizedQueue","SizedQueue.html#method-i-max-3D","(p1)","<p>Sets the maximum size of the queue to the given <code>number</code>.\n"],["max_by","Enumerable","Enumerable.html#method-i-max_by","(*args)","<p>Returns the object in <em>enum</em> that gives the maximum value from the given block.\n<p>If no block is given, an …\n"],["max_flag_count","Net::IMAP","Net/IMAP.html#method-c-max_flag_count","()","<p>Returns the max number of flags interned to symbols.\n"],["max_flag_count=","Net::IMAP","Net/IMAP.html#method-c-max_flag_count-3D","(count)","<p>Sets the max number of flags interned to symbols.\n"],["max_nesting","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-max_nesting","()","<p>This integer returns the maximum level of data structure nesting in the generated JSON, max_nesting = …\n"],["max_nesting=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-max_nesting-3D","(p1)","<p>This sets the maximum level of data structure nesting in the generated JSON to the integer depth, max_nesting …\n"],["max_retries=","Net::HTTP","Net/HTTP.html#method-i-max_retries-3D","(retries)","<p>Maximum number of times to retry an idempotent request in case of Net::ReadTimeout, IOError, EOFError …\n"],["max_version=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-max_version-3D","(max_version)","<p>maximum SSL version to use\n"],["max_version=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-max_version-3D","(version)","<p>Sets the upper bound of the supported SSL/TLS protocol version. See #min_version= for the possible values. …\n"],["maxgroups","Process","Process.html#method-c-maxgroups","()","<p>Returns the maximum number of gids allowed in the supplemental group access list.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">maxgroups</span>   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["maxgroups=","Process","Process.html#method-c-maxgroups-3D","(p1)","<p>Sets the maximum number of gids allowed in the supplemental group access list.\n"],["may_quoted?","CSV::Parser","CSV/Parser.html#method-i-may_quoted-3F","()",""],["may_req_ambiguous_char_width","Reline::Core","Reline/Core.html#method-i-may_req_ambiguous_char_width","()",""],["maybe_xml?","RSS::Parser","RSS/Parser.html#method-i-maybe_xml-3F","(source)","<p>maybe_xml? tests if source is a string that looks like XML.\n"],["md5_available?","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-md5_available-3F","()",""],["mday","Date","Date.html#method-i-mday","()","<p>Returns the day of the month (1-31).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">mday</span>           <span class=\"ruby-comment\">#=&gt; 3</span>\n</pre>\n"],["mday","Time","Time.html#method-i-mday","()","<p>Returns the day of the month (1..n) for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:27:03 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">day</span>      <span class=\"ruby-operator\">...</span>\n</pre>\n"],["mdtm","Net::FTP","Net/FTP.html#method-i-mdtm","(filename)","<p>Returns the raw last modification time of the (remote) file in the format “YYYYMMDDhhmmss” …\n"],["measure","Benchmark","Benchmark.html#method-i-measure","(label = \"\")","<p>Returns the time used to execute the given block as a Benchmark::Tms object. Takes <code>label</code> option.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["measure","Benchmark","Benchmark.html#method-c-measure","(label = \"\")","<p>Returns the time used to execute the given block as a Benchmark::Tms object. Takes <code>label</code> option.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["media_subtype","Net::IMAP::BodyTypeBasic","Net/IMAP/BodyTypeBasic.html#method-i-media_subtype","()","<p>Obsolete: use <code>subtype</code> instead.  Calling this will generate a warning message to <code>stderr</code>, then return the …\n"],["media_subtype","Net::IMAP::BodyTypeMessage","Net/IMAP/BodyTypeMessage.html#method-i-media_subtype","()","<p>Obsolete: use <code>subtype</code> instead.  Calling this will generate a warning message to <code>stderr</code>, then return the …\n"],["media_subtype","Net::IMAP::BodyTypeMultipart","Net/IMAP/BodyTypeMultipart.html#method-i-media_subtype","()","<p>Obsolete: use <code>subtype</code> instead.  Calling this will generate a warning message to <code>stderr</code>, then return the …\n"],["media_subtype","Net::IMAP::BodyTypeText","Net/IMAP/BodyTypeText.html#method-i-media_subtype","()","<p>Obsolete: use <code>subtype</code> instead.  Calling this will generate a warning message to <code>stderr</code>, then return the …\n"],["mem_check_start","OpenSSL","OpenSSL.html#method-c-mem_check_start","()","<p>Calls CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON). Starts tracking memory allocations. See also OpenSSL.print_mem_leaks …\n"],["member?","CSV::Row","CSV/Row.html#method-i-member-3F","(header)",""],["member?","DBM","DBM.html#method-i-member-3F","(p1)","<p>Returns true if the database contains the specified key, false otherwise.\n"],["member?","ENV","ENV.html#method-c-member-3F","(p1)","<p>ENV.has_key?, ENV.member?, and ENV.key? are aliases for ENV.include?.\n<p>Returns <code>true</code> if there is an environment …\n"],["member?","Enumerable","Enumerable.html#method-i-member-3F","(p1)","<p>Returns <code>true</code> if any member of <em>enum</em> equals <em>obj</em>. Equality is tested using <code>==</code>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">10</span>).<span class=\"ruby-identifier\">include?</span> <span class=\"ruby-value\">5</span>  <span class=\"ruby-comment\">#=&gt; true ...</span>\n</pre>\n"],["member?","GDBM","GDBM.html#method-i-member-3F","(p1)","<p>Returns true if the given key <em>k</em> exists within the database. Returns false otherwise.\n"],["member?","Hash","Hash.html#method-i-member-3F","(p1)","<p>Returns <code>true</code> if the given key is present in <em>hsh</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;b&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">200</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">has_key?</span>(<span class=\"ruby-string\">&quot;a&quot;</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["member?","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-member-3F","(p1)","<p>Returns <code>true</code> if <code>key</code> is registered\n"],["member?","Range","Range.html#method-i-member-3F","(p1)","<p>Returns <code>true</code> if <code>obj</code> is an element of the range, <code>false</code> otherwise.\n\n<pre class=\"ruby\">(<span class=\"ruby-string\">&quot;a&quot;</span><span class=\"ruby-operator\">..</span><span class=\"ruby-string\">&quot;z&quot;</span>).<span class=\"ruby-identifier\">include?</span>(<span class=\"ruby-string\">&quot;g&quot;</span>)   <span class=\"ruby-comment\">#=&gt; true</span>\n(<span class=\"ruby-string\">&quot;a&quot;</span><span class=\"ruby-operator\">..</span><span class=\"ruby-string\">&quot;z&quot;</span>).<span class=\"ruby-identifier\">include?</span>(<span class=\"ruby-string\">&quot;A&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["member?","SDBM","SDBM.html#method-i-member-3F","(p1)","<p>Returns <code>true</code> if the database contains the given <code>key</code>.\n"],["member?","Set","Set.html#method-i-member-3F","(o)",""],["members","Struct","Struct.html#method-i-members","()","<p>Returns the struct members as an array of symbols:\n\n<pre>Customer = Struct.new(:name, :address, :zip)\njoe = ...</pre>\n"],["members","WEBrick::HTTPAuth::Htgroup","WEBrick/HTTPAuth/Htgroup.html#method-i-members","(group)","<p>Retrieve the list of members from <code>group</code>\n"],["memberwise","Benchmark::Tms","Benchmark/Tms.html#method-i-memberwise","(op, x)","<p>Returns a new Tms object obtained by memberwise operation <code>op</code> of the individual times for this Tms object …\n"],["memsize_of","ObjectSpace","ObjectSpace.html#method-c-memsize_of","(p1)","<p>Return consuming memory size of obj.\n<p>Note that the return size is incomplete.  You need to deal with this …\n"],["memsize_of_all","ObjectSpace","ObjectSpace.html#method-c-memsize_of_all","(p1 = v1)","<p>Return consuming memory size of all living objects.\n<p>If <code>klass</code> (should be Class object) is given, return …\n"],["merge","Bundler::SpecSet","Bundler/SpecSet.html#method-i-merge","(set)",""],["merge","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-merge","(other_hash, &block)",""],["merge","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-merge","(oth)","<p>Args\n<p><code>oth</code> &mdash; Bundler::URI or String\n\n<p>Description\n"],["merge","Gem::Dependency","Gem/Dependency.html#method-i-merge","(other)","<p>Merges the requirements of <code>other</code> into this dependency\n"],["merge","Hash","Hash.html#method-i-merge","(*args)","<p>Returns a new hash that combines the contents of the receiver and the contents of the given hashes.\n<p>If …\n"],["merge","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-merge","(p1)",""],["merge","RDoc::ClassModule","RDoc/ClassModule.html#method-i-merge","(class_module)","<p>Merges <code>class_module</code> into this ClassModule.\n<p>The data in <code>class_module</code> is preferred over the receiver.\n"],["merge","Set","Set.html#method-i-merge","(enum)","<p>Merges the elements of the given enumerable object to the set and returns self.\n"],["merge","URI::Generic","URI/Generic.html#method-i-merge","(oth)","<p>Args\n<p><code>oth</code> &mdash; URI or String\n\n<p>Description\n"],["merge!","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-merge-21","(other_hash)",""],["merge!","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-merge-21","(oth)","<p>Args\n<p><code>oth</code> &mdash; Bundler::URI or String\n\n<p>Description\n"],["merge!","ENV","ENV.html#method-c-merge-21","(p1)","<p>Adds the contents of <code>hash</code> to the environment variables.  If no block is specified entries with duplicate …\n"],["merge!","Hash","Hash.html#method-i-merge-21","(*args)","<p>Adds the contents of the given hashes to the receiver.\n<p>If no block is given, entries with duplicate keys …\n"],["merge!","URI::Generic","URI/Generic.html#method-i-merge-21","(oth)","<p>Args\n<p><code>oth</code> &mdash; URI or String\n\n<p>Description\n"],["merge_key","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-merge_key","(hash, key, val)",""],["merge_options","Gem::Command","Gem/Command.html#method-i-merge_options","(new_options)","<p>Merge a set of command options with the set of default options (without modifying the default option …\n"],["merge_path","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-merge_path","(base, rel)","<p>Merges a base path <code>base</code>, with relative path <code>rel</code>, returns a modified base path.\n"],["merge_path","URI::Generic","URI/Generic.html#method-i-merge_path","(base, rel)","<p>Merges a base path <code>base</code>, with relative path <code>rel</code>, returns a modified base path.\n"],["message","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-message","()",""],["message","Bundler::CompactIndexClient::Updater::MisMatchedChecksumError","Bundler/CompactIndexClient/Updater/MisMatchedChecksumError.html#method-i-message","()",""],["message","Bundler::Molinillo::NoSuchDependencyError","Bundler/Molinillo/NoSuchDependencyError.html#method-i-message","()","<p>The error message for the missing dependency, including the specifications that had this dependency. …\n"],["message","Bundler::NoSpaceOnDeviceError","Bundler/NoSpaceOnDeviceError.html#method-i-message","()",""],["message","Bundler::OperationNotSupportedError","Bundler/OperationNotSupportedError.html#method-i-message","()",""],["message","Bundler::PermissionError","Bundler/PermissionError.html#method-i-message","()",""],["message","Bundler::TemporaryResourceError","Bundler/TemporaryResourceError.html#method-i-message","()",""],["message","Bundler::VirtualProtocolError","Bundler/VirtualProtocolError.html#method-i-message","()",""],["message","Exception","Exception.html#method-i-message","()","<p>Returns the result of invoking <code>exception.to_s</code>. Normally this returns the exception&#39;s message or name. …\n"],["message","Gem::Resolver::Molinillo::NoSuchDependencyError","Gem/Resolver/Molinillo/NoSuchDependencyError.html#method-i-message","()","<p>The error message for the missing dependency, including the specifications that had this dependency. …\n"],["message","Gem::RuntimeRequirementNotMetError","Gem/RuntimeRequirementNotMetError.html#method-i-message","()",""],["message","Net::ReadTimeout","Net/ReadTimeout.html#method-i-message","()",""],["message","Net::SMTP::Response","Net/SMTP/Response.html#method-i-message","()","<p>The first line of the human readable reply text\n"],["message","Net::WriteTimeout","Net/WriteTimeout.html#method-i-message","()",""],["message","OptionParser::ParseError","OptionParser/ParseError.html#method-i-message","()","<p>Default stringizing method to emit standard error message.\n"],["message_loop","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-c-message_loop","()","<p>Translates and dispatches Windows message.\n"],["message_with_trees","Bundler::Molinillo::VersionConflict","Bundler/Molinillo/VersionConflict.html#method-i-message_with_trees","(opts = {})","<p>@return [String] An error message that includes requirement trees,\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">which</span> <span class=\"ruby-identifier\">is</span> <span class=\"ruby-identifier\">much</span> <span class=\"ruby-identifier\">more</span> <span class=\"ruby-identifier\">detailed</span> <span class=\"ruby-operator\">&amp;</span> <span class=\"ruby-identifier\">customizable</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["meta_vars","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-meta_vars","()","<p>This method provides the metavariables defined by the revision 3 of “The WWW Common Gateway Interface …\n"],["metadata_dependencies","Bundler::Definition","Bundler/Definition.html#method-i-metadata_dependencies","()",""],["metadata_dependencies","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-metadata_dependencies","(spec, platform)",""],["method","Object","Object.html#method-i-method","(p1)","<p>Looks up the named method as a receiver in <em>obj</em>, returning a Method object (or raising NameError). The …\n"],["method_added","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-method_added","(meth)","<p>Fire this callback whenever a method is added. Added methods are tracked as commands by invoking the …\n"],["method_added","Module","Module.html#method-i-method_added","(p1)","<p>Invoked as a callback whenever an instance method is added to the receiver.\n\n<pre>module Chatty\n  def self.method_added(method_name) ...</pre>\n"],["method_defined?","Module","Module.html#method-i-method_defined-3F","(*args)","<p>Returns <code>true</code> if the named method is defined by <em>mod</em>.  If <em>inherit</em> is set, the lookup will also search  …\n"],["method_file","RDoc::Store","RDoc/Store.html#method-i-method_file","(klass_name, method_name)","<p>Path to the ri data for <code>method_name</code> in <code>klass_name</code>\n"],["method_id","TracePoint","TracePoint.html#method-i-method_id","()","<p>Return the name at the definition of the method being called\n"],["method_missing","BasicObject","BasicObject.html#method-i-method_missing","(*args)","<p>Invoked by Ruby when <em>obj</em> is sent a message it cannot handle. <em>symbol</em> is the symbol for the method called, …\n"],["method_missing","Bundler::ConnectionPool::Wrapper","Bundler/ConnectionPool/Wrapper.html#method-i-method_missing","(name, *args, &block)",""],["method_missing","Bundler::DepProxy","Bundler/DepProxy.html#method-i-method_missing","(*args, &blk)",""],["method_missing","Bundler::Dsl","Bundler/Dsl.html#method-i-method_missing","(name, *args)",""],["method_missing","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-method_missing","(method, *args, &blk)",""],["method_missing","Bundler::Plugin::API","Bundler/Plugin/API.html#method-i-method_missing","(name, *args, &blk)",""],["method_missing","Bundler::Plugin::DSL","Bundler/Plugin/DSL.html#method-i-method_missing","(name, *args)",""],["method_missing","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-method_missing","(method, *args, &blk)",""],["method_missing","DRb::DRbObject","DRb/DRbObject.html#method-i-method_missing","(msg_id, *a, &b)",""],["method_missing","DRb::DRbObject","DRb/DRbObject.html#method-i-method_missing","(msg_id, *a, &b)",""],["method_missing","DRb::ThreadObject","DRb/ThreadObject.html#method-i-method_missing","(msg, *arg, &blk)",""],["method_missing","Delegator","Delegator.html#method-i-method_missing","(m, *args, &block)",""],["method_missing","REXML::QuickPath","REXML/QuickPath.html#method-c-method_missing","( id, *args )",""],["method_missing","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-method_missing","(mid, *args, &block)",""],["method_missing","WIN32OLE","WIN32OLE.html#method-i-method_missing","(*args)","<p>Calls WIN32OLE#invoke method.\n"],["method_missing","WIN32OLE_RECORD","WIN32OLE_RECORD.html#method-i-method_missing","(*args)","<p>Returns value specified by the member name of VT_RECORD OLE variable. Or sets value specified by the …\n"],["method_option","Bundler::Thor","Bundler/Thor.html#method-c-method_option","(name, options = {})","<p>Adds an option to the set of method options. If :for is given as option, it allows you to change the …\n"],["method_options","Bundler::Thor","Bundler/Thor.html#method-c-method_options","(options = nil)","<p>Declares the options for the next command to be declared.\n<p>Parameters\n<p>Hash[Symbol =&gt; Object] &mdash; The hash …\n"],["method_removed","Module","Module.html#method-i-method_removed","(p1)","<p>Invoked as a callback whenever an instance method is removed from the receiver.\n\n<pre>module Chatty\n  def self.method_removed(method_name) ...</pre>\n"],["method_undefined","Module","Module.html#method-i-method_undefined","(p1)",""],["method_visibility","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-method_visibility","(klass, method)",""],["methods","Delegator","Delegator.html#method-i-methods","(all=true)","<p>Returns the methods available to this delegate object as the union of this object&#39;s and _<em>getobj</em> …\n"],["methods","Object","Object.html#method-i-methods","(*args)","<p>Returns a list of the names of public and protected methods of <em>obj</em>. This will include all the methods …\n"],["methods","WIN32OLE","WIN32OLE.html#method-i-methods","(*args)","<p>By overriding Object#methods, WIN32OLE might work well with did_you_mean gem. This is experimental.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["methods_by_type","RDoc::Context","RDoc/Context.html#method-i-methods_by_type","(section = nil)","<p>Breaks method_list into a nested hash by type (<code>&#39;class&#39;</code> or <code>&#39;instance&#39;</code>) and visibility …\n"],["methods_matching","RDoc::Context","RDoc/Context.html#method-i-methods_matching","(methods, singleton = false, &block)","<p>Yields AnyMethod and Attr entries matching the list of names in <code>methods</code>.\n"],["mfa_unauthorized?","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-mfa_unauthorized-3F","(response)",""],["mime_split","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-mime_split","()","<p>Splits the type attribute into an array, e.g. [“text”, “xml”]\n"],["mime_type","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-mime_type","(filename, mime_tab)","<p>Returns the mime type of <code>filename</code> from the list in <code>mime_tab</code>.  If no mime type was found application/octet-stream …\n"],["mime_type","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-mime_type","(filename, mime_tab)","<p>Returns the mime type of <code>filename</code> from the list in <code>mime_tab</code>.  If no mime type was found application/octet-stream …\n"],["min","Array","Array.html#method-i-min","(*args)","<p>Returns the object in <em>ary</em> with the minimum value. The first form assumes all objects implement Comparable …\n"],["min","Date","Date.html#method-i-min","()",""],["min","DateTime","DateTime.html#method-i-min","()","<p>Returns the minute (0-59).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">min</span>          <span class=\"ruby-comment\">#=&gt; 5</span>\n</pre>\n"],["min","Enumerable","Enumerable.html#method-i-min","(*args)","<p>Returns the object in <em>enum</em> with the minimum value. The first form assumes all objects implement Comparable …\n"],["min","Range","Range.html#method-i-min","(*args)","<p>Returns the minimum value in the range. Returns <code>nil</code> if the begin value of the range is larger than the …\n"],["min","Time","Time.html#method-i-min","()","<p>Returns the minute of the hour (0..59) for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:25:51 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">min</span>   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["min_by","Enumerable","Enumerable.html#method-i-min_by","(*args)","<p>Returns the object in <em>enum</em> that gives the minimum value from the given block.\n<p>If no block is given, an …\n"],["min_version=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-min_version-3D","(min_version)","<p>Minimum SSL version to use\n"],["min_version=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-min_version-3D","(version)","<p>Sets the lower bound on the supported SSL/TLS protocol version. The version may be specified by an integer …\n"],["mingw?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-mingw-3F","()",""],["minimum_indent","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-minimum_indent","(lines)",""],["minmax","Array","Array.html#method-i-minmax","()","<p>Returns a two element array which contains the minimum and the maximum value in the array.\n<p>Can be given …\n"],["minmax","Enumerable","Enumerable.html#method-i-minmax","()","<p>Returns a two element array which contains the minimum and the maximum value in the enumerable.  The …\n"],["minmax","Range","Range.html#method-i-minmax","()","<p>Returns a two element array which contains the minimum and the maximum value in the range.\n<p>Can be given …\n"],["minmax_by","Enumerable","Enumerable.html#method-i-minmax_by","()","<p>Returns a two element array containing the objects in <em>enum</em> that correspond to the minimum and maximum …\n"],["minor","Matrix","Matrix.html#method-i-minor","(*param)","<p>Returns a section of the matrix.  The parameters are either:\n<p>start_row, nrows, start_col, ncols; OR\n<p>row_range …\n"],["minor?","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-minor-3F","()","<p>@return [bool] Convenience method for testing value of level variable.\n"],["minor_version","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-minor_version","()","<p>Returns minor version.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Word 10.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Documents&#39;</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["minor_version","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-minor_version","()","<p>Returns the type library minor version.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlib</span> = <span class=\"ruby-constant\">WIN32OLE_TYPELIB</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["minute","Date","Date.html#method-i-minute","()",""],["minute","DateTime","DateTime.html#method-i-minute","()","<p>Returns the minute (0-59).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">min</span>          <span class=\"ruby-comment\">#=&gt; 5</span>\n</pre>\n"],["minute=","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-minute-3D","(minute)",""],["minute=","RSS::Maker::ITunesItemModel::ITunesDurationBase","RSS/Maker/ITunesItemModel/ITunesDurationBase.html#method-i-minute-3D","(minute)",""],["mirror_for","Bundler::Settings","Bundler/Settings.html#method-i-mirror_for","(uri)",""],["missing_extensions?","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-missing_extensions-3F","()","<p>This is defined directly to avoid having to load every installed spec\n"],["missing_extensions?","Gem::Specification","Gem/Specification.html#method-i-missing_extensions-3F","()","<p>Is this specification missing its extensions?  When this returns true you probably want to build_extensions …\n"],["missing_lockfile_dependencies","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-missing_lockfile_dependencies","(all_spec_names)",""],["missing_specs","Bundler::Definition","Bundler/Definition.html#method-i-missing_specs","()",""],["missing_specs?","Bundler::Definition","Bundler/Definition.html#method-i-missing_specs-3F","()",""],["missing_version_message","Gem::BundlerVersionFinder","Gem/BundlerVersionFinder.html#method-c-missing_version_message","()",""],["mjd","Date","Date.html#method-i-mjd","()","<p>Returns the modified Julian day number.  This is a whole number, which is adjusted by the offset as the …\n"],["mkcol","Net::HTTP","Net/HTTP.html#method-i-mkcol","(path, body = nil, initheader = nil)","<p>Sends a MKCOL request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["mkdir","Bundler::FileUtils","Bundler/FileUtils.html#method-c-mkdir","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates one or more directories.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir</span> <span class=\"ruby-string\">&#39;test&#39;</span>\n<span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir</span> <span class=\"ruby-node\">%w(tmp data)</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["mkdir","Bundler::FileUtils","Bundler/FileUtils.html#method-i-mkdir","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates one or more directories.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir</span> <span class=\"ruby-string\">&#39;test&#39;</span>\n<span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir</span> <span class=\"ruby-node\">%w(tmp data)</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["mkdir","Dir","Dir.html#method-c-mkdir","(p1, p2 = v2)","<p>Makes a new directory named by <em>string</em>, with permissions specified by the optional parameter <em>anInteger</em> …\n"],["mkdir","FileUtils","FileUtils.html#method-c-mkdir","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates one or more directories.\n\n<pre>FileUtils.mkdir &#39;test&#39;\nFileUtils.mkdir %w(tmp data)\nFileUtils.mkdir &#39;notexist&#39;, ...</pre>\n"],["mkdir","FileUtils","FileUtils.html#method-i-mkdir","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates one or more directories.\n\n<pre>FileUtils.mkdir &#39;test&#39;\nFileUtils.mkdir %w(tmp data)\nFileUtils.mkdir &#39;notexist&#39;, ...</pre>\n"],["mkdir","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-i-mkdir","(name, mode)","<p>Creates a new directory in the tar file <code>name</code> with <code>mode</code>\n"],["mkdir","Net::FTP","Net/FTP.html#method-i-mkdir","(dirname)","<p>Creates a remote directory.\n"],["mkdir","Pathname","Pathname.html#method-i-mkdir","(p1 = v1)","<p>Create the referenced directory.\n<p>See Dir.mkdir.\n"],["mkdir_p","Bundler","Bundler.html#method-c-mkdir_p","(path, options = {})",""],["mkdir_p","Bundler::FileUtils","Bundler/FileUtils.html#method-c-mkdir_p","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates a directory and all its parent directories. For example,\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir_p</span> <span class=\"ruby-string\">&#39;/usr/local/lib/ruby&#39;</span>\n</pre>\n"],["mkdir_p","Bundler::FileUtils","Bundler/FileUtils.html#method-i-mkdir_p","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates a directory and all its parent directories. For example,\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir_p</span> <span class=\"ruby-string\">&#39;/usr/local/lib/ruby&#39;</span>\n</pre>\n"],["mkdir_p","FileUtils","FileUtils.html#method-c-mkdir_p","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates a directory and all its parent directories. For example,\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir_p</span> <span class=\"ruby-string\">&#39;/usr/local/lib/ruby&#39;</span>\n</pre>\n"],["mkdir_p","FileUtils","FileUtils.html#method-i-mkdir_p","(list, mode: nil, noop: nil, verbose: nil)","<p>Creates a directory and all its parent directories. For example,\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">mkdir_p</span> <span class=\"ruby-string\">&#39;/usr/local/lib/ruby&#39;</span>\n</pre>\n"],["mkdir_p","Gem::Commands::SetupCommand::MakeDirs","Gem/Commands/SetupCommand/MakeDirs.html#method-i-mkdir_p","(path, **opts)",""],["mkdir_p_safe","Gem::Package","Gem/Package.html#method-i-mkdir_p_safe","(mkdir, mkdir_options, destination_dir, file_name)",""],["mkfifo","File","File.html#method-c-mkfifo","(*args)","<p>Creates a FIFO special file with name <em>file_name</em>.  <em>mode</em> specifies the FIFO&#39;s permissions. It is modified …\n"],["mkmapexp","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-mkmapexp","(arr)",""],["mkpath","Bundler::FileUtils","Bundler/FileUtils.html#method-i-mkpath","(list, mode: nil, noop: nil, verbose: nil)",""],["mkpath","Bundler::FileUtils","Bundler/FileUtils.html#method-c-mkpath","(list, mode: nil, noop: nil, verbose: nil)",""],["mkpath","FileUtils","FileUtils.html#method-i-mkpath","(list, mode: nil, noop: nil, verbose: nil)",""],["mkpath","FileUtils","FileUtils.html#method-c-mkpath","(list, mode: nil, noop: nil, verbose: nil)",""],["mkpath","Pathname","Pathname.html#method-i-mkpath","()","<p>Creates a full path, including any intermediate directories that don&#39;t yet exist.\n<p>See FileUtils.mkpath …\n"],["mktime","Time","Time.html#method-c-mktime","(*args)","<p>Same as Time::gm, but interprets the values in the local time zone.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-string\">&quot;jan&quot;</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">20</span>,<span class=\"ruby-value\">15</span>,<span class=\"ruby-value\">1</span>)  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["mktmpdir","Dir","Dir.html#method-c-mktmpdir","(prefix_suffix=nil, *rest, **options)","<p>Dir.mktmpdir creates a temporary directory.\n<p>The directory is created with 0700 permission. Application …\n"],["mlsd","Net::FTP","Net/FTP.html#method-i-mlsd","(pathname = nil)","<p>Returns an array of the entries of the directory specified by <code>pathname</code>. Each entry has the facts (e.g. …\n"],["mlst","Net::FTP","Net/FTP.html#method-i-mlst","(pathname = nil)","<p>Returns data (e.g., size, last modification time, entry type, etc.) about the file or directory specified …\n"],["mod_add","OpenSSL::BN","OpenSSL/BN.html#method-i-mod_add","(p1, p2)",""],["mod_exp","OpenSSL::BN","OpenSSL/BN.html#method-i-mod_exp","(p1, p2)",""],["mod_inverse","OpenSSL::BN","OpenSSL/BN.html#method-i-mod_inverse","(p1)",""],["mod_mul","OpenSSL::BN","OpenSSL/BN.html#method-i-mod_mul","(p1, p2)",""],["mod_sqr","OpenSSL::BN","OpenSSL/BN.html#method-i-mod_sqr","(p1)",""],["mod_sub","OpenSSL::BN","OpenSSL/BN.html#method-i-mod_sub","(p1, p2)",""],["mode","BigDecimal","BigDecimal.html#method-c-mode","(p1, p2 = v2)","<p>Controls handling of arithmetic exceptions and rounding. If no value is supplied, the current value is …\n"],["mode","File::Stat","File/Stat.html#method-i-mode","()","<p>Returns an integer representing the permission bits of <em>stat</em>. The meaning of the bits is platform dependent; …\n"],["models","RSS::Element","RSS/Element.html#method-c-models","()",""],["module","RDoc::Mixin","RDoc/Mixin.html#method-i-module","()","<p>Attempts to locate the included module object.  Returns the name if not known.\n<p>The scoping rules of Ruby …\n"],["module?","RDoc::ClassModule","RDoc/ClassModule.html#method-i-module-3F","()","<p>Does this object represent a module?\n"],["module?","RDoc::NormalModule","RDoc/NormalModule.html#method-i-module-3F","()","<p>This is a module, returns true\n"],["module_eval","Module","Module.html#method-i-module_eval","(*args)","<p>Evaluates the string or block in the context of <em>mod</em>, except that when a block is given, constant/class …\n"],["module_exec","Module","Module.html#method-i-module_exec","(*args)","<p>Evaluates the given block in the context of the class/module. The method defined in the block will belong …\n"],["module_function","Module","Module.html#method-i-module_function","(*args)","<p>Creates module functions for the named methods. These functions may be called with the module as a receiver, …\n"],["module_names","RDoc::Store","RDoc/Store.html#method-i-module_names","()","<p>Modules cache accessor.  An Array of all the module (and class) names in the store.\n"],["modules","RDoc::Context","RDoc/Context.html#method-i-modules","()","<p>Array of modules in this context\n"],["modules_hash","RDoc::Context","RDoc/Context.html#method-i-modules_hash","()","<p>Hash of modules keyed by module name\n"],["modules_hash","RDoc::Store","RDoc/Store.html#method-i-modules_hash","()","<p>Hash of all modules known to RDoc\n"],["modulo","BigDecimal","BigDecimal.html#method-i-modulo","(p1)","<p>Returns the modulus from dividing by b.\n<p>See BigDecimal#divmod.\n"],["modulo","Float","Float.html#method-i-modulo","(p1)","<p>Returns the modulo after division of <code>float</code> by <code>other</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">6543.21</span>.<span class=\"ruby-identifier\">modulo</span>(<span class=\"ruby-value\">137</span>)      <span class=\"ruby-comment\">#=&gt; 104.21000000000004</span>\n<span class=\"ruby-value\">6543.21</span>.<span class=\"ruby-identifier\">modulo</span>(<span class=\"ruby-value\">137.24</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["modulo","Integer","Integer.html#method-i-modulo","(p1)","<p>Returns <code>int</code> modulo <code>other</code>.\n<p>See Numeric#divmod for more information.\n"],["modulo","Numeric","Numeric.html#method-i-modulo","(p1)","<p><code>x.modulo(y)</code> means <code>x-y*(x/y).floor</code>.\n<p>Equivalent to <code>num.divmod(numeric)[1]</code>.\n<p>See Numeric#divmod.\n"],["mon","Date","Date.html#method-i-mon","()","<p>Returns the month (1-12).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">mon</span>            <span class=\"ruby-comment\">#=&gt; 2</span>\n</pre>\n"],["mon","Time","Time.html#method-i-mon","()","<p>Returns the month of the year (1..12) for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:27:30 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">mon</span>    <span class=\"ruby-operator\">...</span>\n</pre>\n"],["mon_check_owner","Monitor","Monitor.html#method-i-mon_check_owner","()",""],["mon_check_owner","MonitorMixin","MonitorMixin.html#method-i-mon_check_owner","()",""],["mon_enter","Monitor","Monitor.html#method-i-mon_enter","()",""],["mon_enter","MonitorMixin","MonitorMixin.html#method-i-mon_enter","()","<p>Enters exclusive section.\n"],["mon_exit","Monitor","Monitor.html#method-i-mon_exit","()",""],["mon_exit","MonitorMixin","MonitorMixin.html#method-i-mon_exit","()","<p>Leaves exclusive section.\n"],["mon_initialize","MonitorMixin","MonitorMixin.html#method-i-mon_initialize","()","<p>Initializes the MonitorMixin after being included in a class or when an object has been extended with …\n"],["mon_locked?","Monitor","Monitor.html#method-i-mon_locked-3F","()",""],["mon_locked?","MonitorMixin","MonitorMixin.html#method-i-mon_locked-3F","()","<p>Returns true if this monitor is locked by any thread\n"],["mon_owned?","Monitor","Monitor.html#method-i-mon_owned-3F","()",""],["mon_owned?","MonitorMixin","MonitorMixin.html#method-i-mon_owned-3F","()","<p>Returns true if this monitor is locked by current thread.\n"],["mon_synchronize","Monitor","Monitor.html#method-i-mon_synchronize","()",""],["mon_synchronize","MonitorMixin","MonitorMixin.html#method-i-mon_synchronize","(&b)","<p>Enters exclusive section and executes the block.  Leaves the exclusive section automatically when the …\n"],["mon_try_enter","Monitor","Monitor.html#method-i-mon_try_enter","()",""],["mon_try_enter","MonitorMixin","MonitorMixin.html#method-i-mon_try_enter","()","<p>Attempts to enter exclusive section.  Returns <code>false</code> if lock fails.\n"],["monday?","Date","Date.html#method-i-monday-3F","()","<p>Returns true if the date is Monday.\n"],["monday?","Time","Time.html#method-i-monday-3F","()","<p>Returns <code>true</code> if <em>time</em> represents Monday.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">2003</span>, <span class=\"ruby-value\">8</span>, <span class=\"ruby-value\">4</span>)       <span class=\"ruby-comment\">#=&gt; 2003-08-04 00:00:00 -0500 ...</span>\n</pre>\n"],["monotonic_time","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-c-monotonic_time","()","<p>Returns the current time a tracked by the application monotonic clock.\n<p>@return [Float] The current monotonic …\n"],["month","Date","Date.html#method-i-month","()","<p>Returns the month (1-12).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">mon</span>            <span class=\"ruby-comment\">#=&gt; 2</span>\n</pre>\n"],["month","Time","Time.html#method-i-month","()","<p>Returns the month of the year (1..12) for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:27:30 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">mon</span>    <span class=\"ruby-operator\">...</span>\n</pre>\n"],["month_days","Time","Time.html#method-c-month_days","(y, m)",""],["mount","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-mount","(dir, servlet, *options)","<p>Mounts <code>servlet</code> on <code>dir</code> passing <code>options</code> to the servlet at creation time\n"],["mount_proc","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-mount_proc","(dir, proc=nil, &block)","<p>Mounts <code>proc</code> or <code>block</code> on <code>dir</code> and calls it with a WEBrick::HTTPRequest and WEBrick::HTTPResponse\n"],["mountpoint?","Pathname","Pathname.html#method-i-mountpoint-3F","()","<p>Returns <code>true</code> if <code>self</code> points to a mountpoint.\n"],["move","Bundler::FileUtils","Bundler/FileUtils.html#method-c-move","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)",""],["move","Bundler::FileUtils","Bundler/FileUtils.html#method-i-move","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)",""],["move","FileUtils","FileUtils.html#method-c-move","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)",""],["move","FileUtils","FileUtils.html#method-i-move","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)",""],["move","Net::HTTP","Net/HTTP.html#method-i-move","(path, initheader = nil)","<p>Sends a MOVE request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["move","Net::IMAP","Net/IMAP.html#method-i-move","(set, mailbox)","<p>Sends a MOVE command to move the specified message(s) to the end of the specified destination <code>mailbox</code> …\n"],["move","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-move","(port, tuple, sec=nil)","<p>Moves <code>tuple</code> to <code>port</code>.\n"],["move_version_to_end","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-move_version_to_end","(result, version)",""],["mri?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-mri-3F","()",""],["mswin64?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-mswin64-3F","()",""],["mswin?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-mswin-3F","()",""],["mtime","File","File.html#method-c-mtime","(p1)","<p>Returns the modification time for the named file as a Time object.\n<p><em>file_name</em> can be an IO object.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">mtime</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["mtime","File","File.html#method-i-mtime","()","<p>Returns the modification time for <em>file</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">mtime</span>   <span class=\"ruby-comment\">#=&gt; Wed Apr 09 08:53:14 CDT 2003</span>\n</pre>\n"],["mtime","File::Stat","File/Stat.html#method-i-mtime","()","<p>Returns the modification time of <em>stat</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">mtime</span>   <span class=\"ruby-comment\">#=&gt; Wed Apr 09 08:53:14 CDT 2003</span>\n</pre>\n"],["mtime","Net::FTP","Net/FTP.html#method-i-mtime","(filename, local = false)","<p>Returns the last modification time of the (remote) file.  If <code>local</code> is <code>true</code>, it is returned as a local …\n"],["mtime","Pathname","Pathname.html#method-i-mtime","()","<p>Returns the last modified time of the file.\n<p>See File.mtime.\n"],["mtime","Zlib::GzipFile","Zlib/GzipFile.html#method-i-mtime","()","<p>Returns last modification time recorded in the gzip file header.\n"],["mtime=","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-mtime-3D","(p1)","<p>Specify the modification time (<code>mtime</code>) in the gzip header. Using an Integer.\n<p>Setting the mtime in the gzip …\n"],["mu_lock","Mutex_m","Mutex_m.html#method-i-mu_lock","()","<p>See Mutex#lock\n"],["mu_locked?","Mutex_m","Mutex_m.html#method-i-mu_locked-3F","()","<p>See Mutex#locked?\n"],["mu_pp","Gem::TestCase","Gem/TestCase.html#method-i-mu_pp","(obj)","<p>Enables pretty-print for all tests\n"],["mu_synchronize","Mutex_m","Mutex_m.html#method-i-mu_synchronize","(&block)","<p>See Mutex#synchronize\n"],["mu_try_lock","Mutex_m","Mutex_m.html#method-i-mu_try_lock","()","<p>See Mutex#try_lock\n"],["mu_unlock","Mutex_m","Mutex_m.html#method-i-mu_unlock","()","<p>See Mutex#unlock\n"],["mul","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-mul","(p1, p2 = v2, p3 = v3)","<p>Performs elliptic curve point multiplication.\n<p>The first form calculates <code>bn1 * point + bn2 * G</code>, where  …\n"],["mult","BigDecimal","BigDecimal.html#method-i-mult","(p1, p2)","<p>Multiply by the specified value.\n<p>e.g.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">mult</span>(<span class=\"ruby-identifier\">b</span>,<span class=\"ruby-identifier\">n</span>)\n<span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">*</span> <span class=\"ruby-identifier\">b</span>\n</pre>\n"],["multipart?","CGI::QueryExtension","CGI/QueryExtension.html#method-i-multipart-3F","()","<p>Returns whether the form contained multipart/form-data\n"],["multipart?","Net::IMAP::BodyTypeAttachment","Net/IMAP/BodyTypeAttachment.html#method-i-multipart-3F","()",""],["multipart?","Net::IMAP::BodyTypeBasic","Net/IMAP/BodyTypeBasic.html#method-i-multipart-3F","()",""],["multipart?","Net::IMAP::BodyTypeExtension","Net/IMAP/BodyTypeExtension.html#method-i-multipart-3F","()",""],["multipart?","Net::IMAP::BodyTypeMessage","Net/IMAP/BodyTypeMessage.html#method-i-multipart-3F","()",""],["multipart?","Net::IMAP::BodyTypeMultipart","Net/IMAP/BodyTypeMultipart.html#method-i-multipart-3F","()",""],["multipart?","Net::IMAP::BodyTypeText","Net/IMAP/BodyTypeText.html#method-i-multipart-3F","()",""],["multipart_form","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-multipart_form","(action = nil, enctype = \"multipart/form-data\")","<p>Generate a Form element with multipart encoding as a String.\n<p>Multipart encoding is used for forms that …\n"],["must_C_version","StringScanner","StringScanner.html#method-c-must_C_version","()","<p>This method is defined for backward compatibility.\n"],["must_call_validators","RSS::Element","RSS/Element.html#method-c-must_call_validators","()",""],["mute","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-mute","()","<p>Mute everything that&#39;s inside given block\n"],["mute?","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-mute-3F","()","<p>Check if base is muted\n"],["mv","Bundler::FileUtils","Bundler/FileUtils.html#method-c-mv","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)","<p>Moves file(s) <code>src</code> to <code>dest</code>.  If <code>file</code> and <code>dest</code> exist on the different disk partition, the file is copied …\n"],["mv","Bundler::FileUtils","Bundler/FileUtils.html#method-i-mv","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)","<p>Moves file(s) <code>src</code> to <code>dest</code>.  If <code>file</code> and <code>dest</code> exist on the different disk partition, the file is copied …\n"],["mv","FileUtils","FileUtils.html#method-i-mv","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)","<p>Moves file(s) <code>src</code> to <code>dest</code>.  If <code>file</code> and <code>dest</code> exist on the different disk partition, the file is copied …\n"],["mv","FileUtils","FileUtils.html#method-c-mv","(src, dest, force: nil, noop: nil, verbose: nil, secure: nil)","<p>Moves file(s) <code>src</code> to <code>dest</code>.  If <code>file</code> and <code>dest</code> exist on the different disk partition, the file is copied …\n"],["n_bytes","Net::POP3","Net/POP3.html#method-i-n_bytes","()","<p>Returns the total size in bytes of all the messages on the POP server.\n"],["n_indent","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-n_indent","(line)",""],["n_jobs","IRB::JobManager","IRB/JobManager.html#method-i-n_jobs","()","<p>The total number of irb sessions, used to set <code>irb_name</code> of the current Context.\n"],["n_mails","Net::POP3","Net/POP3.html#method-i-n_mails","()","<p>Returns the number of messages on the POP server.\n"],["n_rrconflicts","Racc::State","Racc/State.html#method-i-n_rrconflicts","()",""],["n_rrconflicts","Racc::States","Racc/States.html#method-i-n_rrconflicts","()",""],["n_srconflicts","Racc::State","Racc/State.html#method-i-n_srconflicts","()",""],["n_srconflicts","Racc::States","Racc/States.html#method-i-n_srconflicts","()",""],["n_useless_nonterminals","Racc::Grammar","Racc/Grammar.html#method-i-n_useless_nonterminals","()",""],["n_useless_rules","Racc::Grammar","Racc/Grammar.html#method-i-n_useless_rules","()",""],["name","Bundler::DepProxy","Bundler/DepProxy.html#method-i-name","()",""],["name","Bundler::GemHelper","Bundler/GemHelper.html#method-i-name","()",""],["name","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-name","()","<p>(see Bundler::Molinillo::ResolutionState#name)\n"],["name","Bundler::Source::Git","Bundler/Source/Git.html#method-i-name","()",""],["name","Bundler::Source::Path","Bundler/Source/Path.html#method-i-name","()",""],["name","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-name","()",""],["name","Encoding","Encoding.html#method-i-name","()","<p>Returns the name of the encoding.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">UTF_8</span>.<span class=\"ruby-identifier\">name</span>      <span class=\"ruby-comment\">#=&gt; &quot;UTF-8&quot;</span>\n</pre>\n"],["name","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-name","()","<p>Name of the gem\n"],["name","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-name","()","<p>The name of this activation request&#39;s specification\n"],["name","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-name","()","<p>The name of the gem this dependency request is requesting.\n"],["name","Gem::Resolver::Molinillo::Delegates::ResolutionState","Gem/Resolver/Molinillo/Delegates/ResolutionState.html#method-i-name","()","<p>(see Gem::Resolver::Molinillo::ResolutionState#name)\n"],["name","Gem::Resolver::SpecSpecification","Gem/Resolver/SpecSpecification.html#method-i-name","()","<p>The name of the gem for this specification\n"],["name","Gem::UnsatisfiableDependencyError","Gem/UnsatisfiableDependencyError.html#method-i-name","()","<p>The name of the unresolved dependency\n"],["name","Method","Method.html#method-i-name","()","<p>Returns the name of the method.\n"],["name","Module","Module.html#method-i-name","()","<p>Returns the name of the module <em>mod</em>.  Returns nil for anonymous modules.\n"],["name","NameError","NameError.html#method-i-name","()","<p>Return the name associated with this NameError exception.\n"],["name","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-name","()","<p>Returns the name of the cipher which may differ slightly from the original name provided.\n"],["name","OpenSSL::Digest","OpenSSL/Digest.html#method-i-name","()","<p>Returns the sn of this Digest algorithm.\n<p>Example\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">digest</span> = <span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Digest</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">SHA512</span>.<span class=\"ruby-identifier\">new</span>\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-identifier\">digest</span>.<span class=\"ruby-identifier\">name</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["name","OpenSSL::Engine","OpenSSL/Engine.html#method-i-name","()","<p>Get the descriptive name for this engine.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Engine</span>.<span class=\"ruby-identifier\">load</span>\n<span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Engine</span>.<span class=\"ruby-identifier\">engines</span> <span class=\"ruby-comment\">#=&gt; [#&lt;OpenSSL::Engine#&gt;, ...</span>\n</pre>\n"],["name","OpenSSL::PKCS7::SignerInfo","OpenSSL/PKCS7/SignerInfo.html#method-i-name","()",""],["name","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-name","()","<p>Method name\n<p>If the method has no assigned name, it extracts it from #call_seq.\n"],["name","REXML::Document","REXML/Document.html#method-i-name","()",""],["name","REXML::Functions","REXML/Functions.html#method-c-name","( node_set=nil )",""],["name","REXML::Light::Node","REXML/Light/Node.html#method-i-name","()",""],["name","REXML::NotationDecl","REXML/NotationDecl.html#method-i-name","()","<p>This method retrieves the name of the notation.\n<p>Method contributed by Henrik Martensson\n"],["name","REXML::QuickPath","REXML/QuickPath.html#method-c-name","()",""],["name","Racc::OrMark","Racc/OrMark.html#method-i-name","()",""],["name","Racc::Prec","Racc/Prec.html#method-i-name","()",""],["name","Racc::UserAction","Racc/UserAction.html#method-i-name","()",""],["name","Socket::Ifaddr","Socket/Ifaddr.html#method-i-name","()","<p>Returns the interface name of <em>ifaddr</em>.\n"],["name","Thread","Thread.html#method-i-name","()","<p>show the name of the thread.\n"],["name","UnboundMethod","UnboundMethod.html#method-i-name","()","<p>Returns the name of the method.\n"],["name","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-name","()","<p>Returns the name of the method.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbook&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["name","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-name","()","<p>Returns name.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, &#39;Workbook&#39;)\nmethod = WIN32OLE_METHOD.new(tobj, ...</pre>\n"],["name","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-name","()","<p>Returns OLE type name.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Application&#39;</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["name","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-name","()","<p>Returns the type library name.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlib</span> = <span class=\"ruby-constant\">WIN32OLE_TYPELIB</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>)\n<span class=\"ruby-identifier\">name</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["name","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-name","()","<p>Returns the name of variable.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;XlSheetType&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["name=","CGI::Cookie","CGI/Cookie.html#method-i-name-3D","(str)","<p>Set name of this cookie\n"],["name=","RDoc::ClassModule","RDoc/ClassModule.html#method-i-name-3D","(new_name)","<p>Allows overriding the initial name.\n<p>Used for modules and classes that are constant aliases.\n"],["name=","REXML::Light::Node","REXML/Light/Node.html#method-i-name-3D","( name_str, ns=nil )",""],["name=","REXML::Namespace","REXML/Namespace.html#method-i-name-3D","( name )","<p>Sets the name and the expanded name\n"],["name=","Thread","Thread.html#method-i-name-3D","(p1)","<p>set given name to the ruby thread. On some platform, it may set the name to pthread and/or kernel.\n"],["name_for","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-name_for","(dependency)","<p>(see Bundler::Molinillo::SpecificationProvider#name_for)\n"],["name_for","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-name_for","(dependency)","<p>Returns the name for the given `dependency`. @note This method should be &#39;pure&#39;, i.e. the return …\n"],["name_for","Bundler::Resolver","Bundler/Resolver.html#method-i-name_for","(dependency)",""],["name_for","Gem::Resolver","Gem/Resolver.html#method-i-name_for","(dependency)",""],["name_for","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-name_for","(dependency)","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#name_for)\n"],["name_for","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-name_for","(dependency)","<p>Returns the name for the given `dependency`. @note This method should be &#39;pure&#39;, i.e. the return …\n"],["name_for_explicit_dependency_source","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-name_for_explicit_dependency_source","()","<p>(see Bundler::Molinillo::SpecificationProvider#name_for_explicit_dependency_source)\n"],["name_for_explicit_dependency_source","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-name_for_explicit_dependency_source","()","<p>@return [String] the name of the source of explicit dependencies, i.e.\n\n<pre>those passed to {Resolver#resolve} ...</pre>\n"],["name_for_explicit_dependency_source","Bundler::Resolver","Bundler/Resolver.html#method-i-name_for_explicit_dependency_source","()",""],["name_for_explicit_dependency_source","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-name_for_explicit_dependency_source","()","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#name_for_explicit_dependency_source)\n"],["name_for_explicit_dependency_source","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-name_for_explicit_dependency_source","()","<p>@return [String] the name of the source of explicit dependencies, i.e.\n\n<pre>those passed to {Resolver#resolve} ...</pre>\n"],["name_for_locking_dependency_source","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-name_for_locking_dependency_source","()","<p>(see Bundler::Molinillo::SpecificationProvider#name_for_locking_dependency_source)\n"],["name_for_locking_dependency_source","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-name_for_locking_dependency_source","()","<p>@return [String] the name of the source of &#39;locked&#39; dependencies, i.e.\n\n<pre>those passed to {Resolver#resolve} ...</pre>\n"],["name_for_locking_dependency_source","Bundler::Resolver","Bundler/Resolver.html#method-i-name_for_locking_dependency_source","()",""],["name_for_locking_dependency_source","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-name_for_locking_dependency_source","()","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#name_for_locking_dependency_source)\n"],["name_for_locking_dependency_source","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-name_for_locking_dependency_source","()","<p>@return [String] the name of the source of &#39;locked&#39; dependencies, i.e.\n\n<pre>those passed to {Resolver#resolve} ...</pre>\n"],["name_for_path","RDoc::ClassModule","RDoc/ClassModule.html#method-i-name_for_path","()","<p>Name to use to generate the url: modules and classes that are aliases for another module or class return …\n"],["name_for_path","RDoc::Context","RDoc/Context.html#method-i-name_for_path","()","<p>Name to use to generate the url. <code>#full_name</code> by default.\n"],["name_list","Encoding","Encoding.html#method-c-name_list","()","<p>Returns the list of available encoding names.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span>.<span class=\"ruby-identifier\">name_list</span>\n<span class=\"ruby-comment\">#=&gt; [&quot;US-ASCII&quot;, &quot;ASCII-8BIT&quot;, &quot;UTF-8&quot;, ...</span>\n</pre>\n"],["name_path","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-i-name_path","(name)","<p>Returns the path to the trusted certificate with the given ASN.1 <code>name</code>\n"],["name_pattern","Gem::Commands::DependencyCommand","Gem/Commands/DependencyCommand.html#method-i-name_pattern","(args)",""],["name_prefix","RDoc::Alias","RDoc/Alias.html#method-i-name_prefix","()","<p>&#39;::&#39; for the alias of a singleton method/attribute, &#39;#&#39; for instance-level.\n"],["name_prefix","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-name_prefix","()","<p>&#39;::&#39; for a class method/attribute, &#39;#&#39; for an instance method.\n"],["name_tuple","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-name_tuple","()",""],["name_tuple","Gem::Specification","Gem/Specification.html#method-i-name_tuple","()","<p>Return a NameTuple that represents this Specification\n"],["named_captures","MatchData","MatchData.html#method-i-named_captures","()","<p>Returns a Hash using named capture.\n<p>A key of the hash is a name of the named captures. A value of the …\n"],["named_captures","Regexp","Regexp.html#method-i-named_captures","()","<p>Returns a hash representing information about named captures of <em>rxp</em>.\n<p>A key of the hash is a name of the …\n"],["names","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-names","()",""],["names","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-names","()",""],["names","Encoding","Encoding.html#method-i-names","()","<p>Returns the list of name and aliases of the encoding.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">WINDOWS_31J</span>.<span class=\"ruby-identifier\">names</span>  <span class=\"ruby-comment\">#=&gt; [&quot;Windows-31J&quot;, ...</span>\n</pre>\n"],["names","MatchData","MatchData.html#method-i-names","()","<p>Returns a list of names of captures as an array of strings. It is same as mtch.regexp.names.\n\n<pre class=\"ruby\"><span class=\"ruby-regexp\">/(?&lt;foo&gt;.)(?&lt;bar&gt;.)(?&lt;baz&gt;.)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;hoge&quot;</span>).<span class=\"ruby-identifier\">names</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["names","Regexp","Regexp.html#method-i-names","()","<p>Returns a list of names of captures as an array of strings.\n\n<pre class=\"ruby\"><span class=\"ruby-regexp\">/(?&lt;foo&gt;.)(?&lt;bar&gt;.)(?&lt;baz&gt;.)/</span>.<span class=\"ruby-identifier\">names</span>\n<span class=\"ruby-comment\">#=&gt; [&quot;foo&quot;, ...</span>\n</pre>\n"],["names_path","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-names_path","()",""],["namespace","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-namespace","(name = nil)","<p>Sets the namespace for the Bundler::Thor or Bundler::Thor::Group class. By default the namespace is retrieved …\n"],["namespace","Object","Object.html#method-i-namespace","(name)",""],["namespace","REXML::Attribute","REXML/Attribute.html#method-i-namespace","(arg=nil)","<p>Returns the namespace URL, if defined, or nil otherwise\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">e</span> = <span class=\"ruby-constant\">Element</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;el&quot;</span>)\n<span class=\"ruby-identifier\">e</span>.<span class=\"ruby-identifier\">add_namespace</span>(<span class=\"ruby-string\">&quot;ns&quot;</span>, <span class=\"ruby-string\">&quot;http://url&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["namespace","REXML::Element","REXML/Element.html#method-i-namespace","(prefix=nil)","<p>Evaluates to the URI for a prefix, or the empty string if no such namespace is declared for this element. …\n"],["namespace","REXML::Light::Node","REXML/Light/Node.html#method-i-namespace","( prefix=prefix() )",""],["namespace=","REXML::Light::Node","REXML/Light/Node.html#method-i-namespace-3D","( namespace )",""],["namespace_context","REXML::Functions","REXML/Functions.html#method-c-namespace_context","()",""],["namespace_context=","REXML::Functions","REXML/Functions.html#method-c-namespace_context-3D","(x)",""],["namespace_from_thor_class","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-namespace_from_thor_class","(constant)","<p>Receives a constant and converts it to a Bundler::Thor namespace. Since Bundler::Thor commands can be …\n"],["namespace_of","REXML::Light::Node","REXML/Light/Node.html#method-i-namespace_of","( node, prefix=nil )",""],["namespace_uri","REXML::Functions","REXML/Functions.html#method-c-namespace_uri","( node_set=nil )",""],["namespaces","REXML::Attributes","REXML/Attributes.html#method-i-namespaces","()",""],["namespaces","REXML::Element","REXML/Element.html#method-i-namespaces","()",""],["namespaces=","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-namespaces-3D","( namespaces )",""],["namespaces=","REXML::XPathParser","REXML/XPathParser.html#method-i-namespaces-3D","( namespaces={} )",""],["namespaces_in_content","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-namespaces_in_content","(contents, file = __FILE__)","<p>Given the contents, evaluate it inside the sandbox and returns the namespaces defined in the sandbox. …\n"],["namesplit","REXML::Light::Node","REXML/Light/Node.html#method-i-namesplit","()",""],["nan?","BigDecimal","BigDecimal.html#method-i-nan-3F","()","<p>Returns True if the value is Not a Number.\n"],["nan?","Float","Float.html#method-i-nan-3F","()","<p>Returns <code>true</code> if <code>float</code> is an invalid IEEE floating point number.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-value\">-1.0</span>      <span class=\"ruby-comment\">#=&gt; -1.0</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">nan?</span>        <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["nary","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-nary","(o)",""],["native","IPAddr","IPAddr.html#method-i-native","()","<p>Returns a new ipaddr built by converting the IPv6 address into a native IPv4 address.  If the IP address …\n"],["nc","Net::IMAP::DigestMD5Authenticator","Net/IMAP/DigestMD5Authenticator.html#method-i-nc","(nonce)",""],["need_base64_encode?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-need_base64_encode-3F","()","<p>Returns true if the content needs to be encoded in base64.\n"],["need_base64_encode?","RSS::Element","RSS/Element.html#method-i-need_base64_encode-3F","()",""],["need_convert?","CSV::FieldsConverter","CSV/FieldsConverter.html#method-i-need_convert-3F","()",""],["need_initialize_variables","RSS::Element","RSS/Element.html#method-c-need_initialize_variables","()",""],["need_initialize_variables","RSS::Maker::Base","RSS/Maker/Base.html#method-c-need_initialize_variables","()",""],["need_keeper?","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-need_keeper-3F","()","<p>Checks the tuplespace to see if it needs cleaning.\n"],["need_parent?","RSS::Atom::CommonModel","RSS/Atom/CommonModel.html#method-c-need_parent-3F","()","<p>Returns true\n"],["need_parent?","RSS::Element","RSS/Element.html#method-c-need_parent-3F","()",""],["need_source_encoding_update?","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-need_source_encoding_update-3F","(xml_declaration_encoding)",""],["need_static_convert?","CSV::FieldsConverter","CSV/FieldsConverter.html#method-i-need_static_convert-3F","()",""],["needs","Gem","Gem.html#method-c-needs","()",""],["negative?","Float","Float.html#method-i-negative-3F","()","<p>Returns <code>true</code> if <code>float</code> is less than 0.\n"],["negative?","Numeric","Numeric.html#method-i-negative-3F","()","<p>Returns <code>true</code> if <code>num</code> is less than 0.\n"],["negative?","OpenSSL::BN","OpenSSL/BN.html#method-i-negative-3F","()",""],["negative?","Rational","Rational.html#method-i-negative-3F","()","<p>Returns <code>true</code> if <code>rat</code> is less than 0.\n"],["nest","PrettyPrint","PrettyPrint.html#method-i-nest","(indent)","<p>Increases left margin after newline with <code>indent</code> for line breaks added in the block.\n"],["nesting","Module","Module.html#method-c-nesting","()","<p>Returns the list of <code>Modules</code> nested at the point of call.\n\n<pre>module M1\n  module M2\n    $a = Module.nesting ...</pre>\n"],["netmask","Socket::Ifaddr","Socket/Ifaddr.html#method-i-netmask","()","<p>Returns the netmask address of <em>ifaddr</em>. nil is returned if netmask is not available in <em>ifaddr</em>.\n"],["new","ACL","ACL.html#method-c-new","(list=nil, order = DENY_ALLOW)","<p>Creates a new ACL from <code>list</code> with an evaluation <code>order</code> of DENY_ALLOW or ALLOW_DENY.\n<p>An ACL <code>list</code> is an Array …\n"],["new","ACL::ACLEntry","ACL/ACLEntry.html#method-c-new","(str)","<p>Creates a new entry using <code>str</code>.\n<p><code>str</code> may be “*” or “all” to match any address, an IP …\n"],["new","ACL::ACLList","ACL/ACLList.html#method-c-new","()","<p>Creates an empty ACLList\n"],["new","Addrinfo","Addrinfo.html#method-c-new","(p1, p2 = v2, p3 = v3, p4 = v4)","<p>returns a new instance of Addrinfo. The instance contains sockaddr, family, socktype, protocol. sockaddr …\n"],["new","Array","Array.html#method-c-new","(p1 = v1, p2 = v2)","<p>Returns a new array.\n<p>In the first form, if no arguments are sent, the new array will be empty. When a …\n"],["new","BasicObject","BasicObject.html#method-c-new","()",""],["new","Benchmark::Tms","Benchmark/Tms.html#method-c-new","(utime = 0.0, stime = 0.0, cutime = 0.0, cstime = 0.0, real = 0.0, label = nil)","<p>Returns an initialized Tms object which has <code>utime</code> as the user CPU time, <code>stime</code> as the system CPU time, …\n"],["new","Bundler::CLI","Bundler/CLI.html#method-c-new","(*args)",""],["new","Bundler::CLI::Add","Bundler/CLI/Add.html#method-c-new","(options, gems)",""],["new","Bundler::CLI::Binstubs","Bundler/CLI/Binstubs.html#method-c-new","(options, gems)",""],["new","Bundler::CLI::Cache","Bundler/CLI/Cache.html#method-c-new","(options)",""],["new","Bundler::CLI::Check","Bundler/CLI/Check.html#method-c-new","(options)",""],["new","Bundler::CLI::Clean","Bundler/CLI/Clean.html#method-c-new","(options)",""],["new","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-c-new","(options, name, value, thor)",""],["new","Bundler::CLI::Console","Bundler/CLI/Console.html#method-c-new","(options, group)",""],["new","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-c-new","(options)",""],["new","Bundler::CLI::Exec","Bundler/CLI/Exec.html#method-c-new","(options, args)",""],["new","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-c-new","(options, gem_name, thor)",""],["new","Bundler::CLI::Info","Bundler/CLI/Info.html#method-c-new","(options, gem_name)",""],["new","Bundler::CLI::Init","Bundler/CLI/Init.html#method-c-new","(options)",""],["new","Bundler::CLI::Inject","Bundler/CLI/Inject.html#method-c-new","(options, name, version)",""],["new","Bundler::CLI::Install","Bundler/CLI/Install.html#method-c-new","(options)",""],["new","Bundler::CLI::List","Bundler/CLI/List.html#method-c-new","(options)",""],["new","Bundler::CLI::Lock","Bundler/CLI/Lock.html#method-c-new","(options)",""],["new","Bundler::CLI::Open","Bundler/CLI/Open.html#method-c-new","(options, name)",""],["new","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-c-new","(options, gems)",""],["new","Bundler::CLI::Package","Bundler/CLI/Package.html#method-c-new","(options)",""],["new","Bundler::CLI::Platform","Bundler/CLI/Platform.html#method-c-new","(options)",""],["new","Bundler::CLI::Pristine","Bundler/CLI/Pristine.html#method-c-new","(gems)",""],["new","Bundler::CLI::Remove","Bundler/CLI/Remove.html#method-c-new","(gems, options)",""],["new","Bundler::CLI::Show","Bundler/CLI/Show.html#method-c-new","(options, gem_name)",""],["new","Bundler::CLI::Update","Bundler/CLI/Update.html#method-c-new","(options, gems)",""],["new","Bundler::CLI::Viz","Bundler/CLI/Viz.html#method-c-new","(options)",""],["new","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-c-new","(directory, fetcher)",""],["new","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-c-new","(directory)",""],["new","Bundler::CompactIndexClient::Updater","Bundler/CompactIndexClient/Updater.html#method-c-new","(fetcher)",""],["new","Bundler::CompactIndexClient::Updater::MisMatchedChecksumError","Bundler/CompactIndexClient/Updater/MisMatchedChecksumError.html#method-c-new","(path, server_checksum, local_checksum)",""],["new","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-c-new","(options = {}, &block)",""],["new","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-c-new","(size = 0, &block)","<p>Creates a new pool with <code>size</code> connections that are created from the given <code>block</code>.\n"],["new","Bundler::ConnectionPool::Wrapper","Bundler/ConnectionPool/Wrapper.html#method-c-new","(options = {}, &block)",""],["new","Bundler::Definition","Bundler/Definition.html#method-c-new","(lockfile, dependencies, sources, unlock, ruby_version = nil, optional_groups = [], gemfiles = [])","<p>How does the new system work?\n<p>Load information from Gemfile and Lockfile\n<p>Invalidate stale locked specs …\n"],["new","Bundler::DepProxy","Bundler/DepProxy.html#method-c-new","(dep, platform)",""],["new","Bundler::Dependency","Bundler/Dependency.html#method-c-new","(name, version, options = {}, &blk)",""],["new","Bundler::Dsl","Bundler/Dsl.html#method-c-new","()",""],["new","Bundler::Dsl::DSLError","Bundler/Dsl/DSLError.html#method-c-new","(description, dsl_path, backtrace, contents = nil)","<p>@param [Exception] backtrace @see backtrace @param [String]    dsl_path  @see dsl_path\n"],["new","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-c-new","(name, version, platform, dependencies, metadata = nil)",""],["new","Bundler::EnvironmentPreserver","Bundler/EnvironmentPreserver.html#method-c-new","(env, keys)","<p>@param env [ENV] @param keys [Array&lt;String&gt;]\n"],["new","Bundler::FeatureFlag","Bundler/FeatureFlag.html#method-c-new","(bundler_version)",""],["new","Bundler::Fetcher","Bundler/Fetcher.html#method-c-new","(remote)",""],["new","Bundler::Fetcher::AuthenticationRequiredError","Bundler/Fetcher/AuthenticationRequiredError.html#method-c-new","(remote_uri)",""],["new","Bundler::Fetcher::BadAuthenticationError","Bundler/Fetcher/BadAuthenticationError.html#method-c-new","(remote_uri)",""],["new","Bundler::Fetcher::Base","Bundler/Fetcher/Base.html#method-c-new","(downloader, remote, display_uri)",""],["new","Bundler::Fetcher::CertificateFailureError","Bundler/Fetcher/CertificateFailureError.html#method-c-new","(remote_uri)",""],["new","Bundler::Fetcher::Downloader","Bundler/Fetcher/Downloader.html#method-c-new","(connection, redirect_limit)",""],["new","Bundler::Fetcher::SSLError","Bundler/Fetcher/SSLError.html#method-c-new","(msg = nil)",""],["new","Bundler::GemHelper","Bundler/GemHelper.html#method-c-new","(base = nil, name = nil)",""],["new","Bundler::GemInstaller","Bundler/GemInstaller.html#method-c-new","(spec, installer, standalone = false, worker = 0, force = false)",""],["new","Bundler::GemRequireError","Bundler/GemRequireError.html#method-c-new","(orig_exception, msg)",""],["new","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-c-new","(locked_specs = SpecSet.new([]), unlock_gems = [])","<p>Given a list of locked_specs and a list of gems to unlock creates a GemVersionPromoter instance.\n<p>@param …\n"],["new","Bundler::Gemdeps","Bundler/Gemdeps.html#method-c-new","(runtime)",""],["new","Bundler::GenericSystemCallError","Bundler/GenericSystemCallError.html#method-c-new","(underlying_error, message)",""],["new","Bundler::Graph","Bundler/Graph.html#method-c-new","(env, output_file, show_version = false, show_requirements = false, output_format = \"png\", without = [])",""],["new","Bundler::Graph::GraphVizClient","Bundler/Graph/GraphVizClient.html#method-c-new","(graph_instance)",""],["new","Bundler::Index","Bundler/Index.html#method-c-new","()",""],["new","Bundler::Injector","Bundler/Injector.html#method-c-new","(deps, options = {})",""],["new","Bundler::Installer","Bundler/Installer.html#method-c-new","(root, definition)",""],["new","Bundler::LazySpecification","Bundler/LazySpecification.html#method-c-new","(name, version, platform, source = nil)",""],["new","Bundler::LockfileGenerator","Bundler/LockfileGenerator.html#method-c-new","(definition)","<p>@private\n"],["new","Bundler::LockfileParser","Bundler/LockfileParser.html#method-c-new","(lockfile)",""],["new","Bundler::MirrorSockets","Bundler/MirrorSockets.html#method-c-new","(mirror)",""],["new","Bundler::Molinillo::CircularDependencyError","Bundler/Molinillo/CircularDependencyError.html#method-c-new","(vertices)","<p>Initializes a new error with the given circular vertices. @param [Array&lt;DependencyGraph::Vertex&gt;] …\n"],["new","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-c-new","()","<p>Initializes an empty dependency graph\n"],["new","Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular","Bundler/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-c-new","(origin, destination, requirement)","<p>Initialize an action to add an edge to a dependency graph @param [String] origin the name of the origin …\n"],["new","Bundler::Molinillo::DependencyGraph::DeleteEdge","Bundler/Molinillo/DependencyGraph/DeleteEdge.html#method-c-new","(origin_name, destination_name, requirement)","<p>Initialize an action to add an edge to a dependency graph @param [String] origin_name the name of the …\n"],["new","Bundler::Molinillo::DependencyGraph::DetachVertexNamed","Bundler/Molinillo/DependencyGraph/DetachVertexNamed.html#method-c-new","(name)","<p>Initialize an action to detach a vertex from a dependency graph @param [String] name the name of the …\n"],["new","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-c-new","()","<p>Initializes an empty log\n"],["new","Bundler::Molinillo::DependencyGraph::Tag","Bundler/Molinillo/DependencyGraph/Tag.html#method-c-new","(tag)","<p>Initialize an action to tag a state of a dependency graph @param [Object] tag an opaque tag\n"],["new","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-c-new","(name, payload)","<p>Initializes a vertex with the given name and payload. @param [String] name see {#name} @param [Object] …\n"],["new","Bundler::Molinillo::NoSuchDependencyError","Bundler/Molinillo/NoSuchDependencyError.html#method-c-new","(dependency, required_by = [])","<p>Initializes a new error with the given missing dependency. @param [Object] dependency @see {#dependency} …\n"],["new","Bundler::Molinillo::Resolver","Bundler/Molinillo/Resolver.html#method-c-new","(specification_provider, resolver_ui)","<p>Initializes a new resolver. @param  [SpecificationProvider] specification_provider\n\n<pre>see {#specification_provider}</pre>\n"],["new","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-c-new","(specification_provider, resolver_ui, requested, base)","<p>Initializes a new resolution. @param [SpecificationProvider] specification_provider\n\n<pre>see {#specification_provider}</pre>\n"],["new","Bundler::Molinillo::VersionConflict","Bundler/Molinillo/VersionConflict.html#method-c-new","(conflicts, specification_provider)","<p>Initializes a new error with the given version conflicts. @param [{String =&gt; Resolution::Conflict}] …\n"],["new","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-c-new","(installer, all_specs, size, standalone, force)",""],["new","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-c-new","(spec)",""],["new","Bundler::PermissionError","Bundler/PermissionError.html#method-c-new","(path, permission_type = :write)",""],["new","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-c-new","(name: nil, proxy: nil, pool_size: DEFAULT_POOL_SIZE)","<p>Creates a new Bundler::Persistent::Net::HTTP::Persistent.\n<p>Set <code>name</code> to keep your connections apart from …\n"],["new","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-c-new","(opts)",""],["new","Bundler::Plugin::DSL","Bundler/Plugin/DSL.html#method-c-new","()",""],["new","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-c-new","()",""],["new","Bundler::Plugin::Index::CommandConflict","Bundler/Plugin/Index/CommandConflict.html#method-c-new","(plugin, commands)",""],["new","Bundler::Plugin::Index::SourceConflict","Bundler/Plugin/Index/SourceConflict.html#method-c-new","(plugin, sources)",""],["new","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-c-new","(name, version, platform, spec_fetcher)",""],["new","Bundler::Resolver","Bundler/Resolver.html#method-c-new","(index, source_requirements, base, gem_version_promoter, additional_base_requirements, platforms)",""],["new","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-c-new","(all_specs)",""],["new","Bundler::Retry","Bundler/Retry.html#method-c-new","(name, exceptions = nil, retries = self.class.default_retries)",""],["new","Bundler::RubyVersion","Bundler/RubyVersion.html#method-c-new","(versions, patchlevel, engine, engine_version)",""],["new","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-c-new","()",""],["new","Bundler::Runtime","Bundler/Runtime.html#method-c-new","(root, definition)",""],["new","Bundler::Settings","Bundler/Settings.html#method-c-new","(root = nil)",""],["new","Bundler::Settings::Mirror","Bundler/Settings/Mirror.html#method-c-new","(uri = nil, fallback_timeout = 0)",""],["new","Bundler::Settings::MirrorConfig","Bundler/Settings/MirrorConfig.html#method-c-new","(config_line, value)",""],["new","Bundler::Settings::Mirrors","Bundler/Settings/Mirrors.html#method-c-new","(prober = nil)",""],["new","Bundler::Settings::Validator::Rule","Bundler/Settings/Validator/Rule.html#method-c-new","(keys, description, &validate)",""],["new","Bundler::SimilarityDetector","Bundler/SimilarityDetector.html#method-c-new","(corpus)","<p>initialize with an array of words to be matched against\n"],["new","Bundler::SocketAddress","Bundler/SocketAddress.html#method-c-new","(type, host, port)",""],["new","Bundler::Source::Gemspec","Bundler/Source/Gemspec.html#method-c-new","(options)",""],["new","Bundler::Source::Git","Bundler/Source/Git.html#method-c-new","(options)",""],["new","Bundler::Source::Git::GitCommandError","Bundler/Source/Git/GitCommandError.html#method-c-new","(command, path = nil, extra_info = nil)",""],["new","Bundler::Source::Git::GitNotAllowedError","Bundler/Source/Git/GitNotAllowedError.html#method-c-new","(command)",""],["new","Bundler::Source::Git::GitNotInstalledError","Bundler/Source/Git/GitNotInstalledError.html#method-c-new","()",""],["new","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-c-new","(path, uri, ref, revision = nil, git = nil)",""],["new","Bundler::Source::Git::MissingGitRevisionError","Bundler/Source/Git/MissingGitRevisionError.html#method-c-new","(command, path, ref, repo)",""],["new","Bundler::Source::Path","Bundler/Source/Path.html#method-c-new","(options)",""],["new","Bundler::Source::Path::Installer","Bundler/Source/Path/Installer.html#method-c-new","(spec, options = {})",""],["new","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-c-new","(options = {})",""],["new","Bundler::Source::Rubygems::Remote","Bundler/Source/Rubygems/Remote.html#method-c-new","(uri)",""],["new","Bundler::SourceList","Bundler/SourceList.html#method-c-new","()",""],["new","Bundler::SpecSet","Bundler/SpecSet.html#method-c-new","(specs)",""],["new","Bundler::Standalone","Bundler/Standalone.html#method-c-new","(groups, definition)",""],["new","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-c-new","(args = [], options = {}, config = {})","<p>Extends initializer to add more configuration options.\n<p>Configuration\n<p>behavior&lt;Symbol&gt; &mdash; The actions …\n"],["new","Bundler::Thor::Base","Bundler/Thor/Base.html#method-c-new","(args = [], local_options = {}, config = {})","<p>It receives arguments in an Array and two hashes, one for options and other for configuration.\n<p>Notice …\n"],["new","Bundler::Thor::Command","Bundler/Thor/Command.html#method-c-new","(name, description, long_description, usage, options = nil)",""],["new","Bundler::Thor::Command","Bundler/Thor/Command.html#method-c-new","(name, description, long_description, usage, options = nil)",""],["new","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-c-new","(*args, &block)",""],["new","Bundler::Thor::DynamicCommand","Bundler/Thor/DynamicCommand.html#method-c-new","(name, options = nil)",""],["new","Bundler::Thor::DynamicCommand","Bundler/Thor/DynamicCommand.html#method-c-new","(name, options = nil)",""],["new","Bundler::Thor::LineEditor::Basic","Bundler/Thor/LineEditor/Basic.html#method-c-new","(prompt, options)",""],["new","Bundler::Thor::LineEditor::Readline::PathCompletion","Bundler/Thor/LineEditor/Readline/PathCompletion.html#method-c-new","(text)",""],["new","Bundler::Thor::NestedContext","Bundler/Thor/NestedContext.html#method-c-new","()",""],["new","Bundler::Thor::Shell","Bundler/Thor/Shell.html#method-c-new","(args = [], options = {}, config = {})","<p>Add shell to initialize config values.\n<p>Configuration\n<p>shell&lt;Object&gt; &mdash; An instance of the shell to be …\n"],["new","Bundler::UI::RGProxy","Bundler/UI/RGProxy.html#method-c-new","(ui)",""],["new","Bundler::UI::Shell","Bundler/UI/Shell.html#method-c-new","(options = {})",""],["new","Bundler::UI::Silent","Bundler/UI/Silent.html#method-c-new","()",""],["new","Bundler::URI::FTP","Bundler/URI/FTP.html#method-c-new","(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = nil, arg_check = false)","<p>Description\n<p>Creates a new Bundler::URI::FTP object from generic URL components with no syntax checking. …\n"],["new","Bundler::URI::Generic","Bundler/URI/Generic.html#method-c-new","(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = DEFAULT_PARSER, arg_check = false)","<p>Args\n<p><code>scheme</code> &mdash; Protocol scheme, i.e. &#39;http&#39;,&#39;ftp&#39;,&#39;mailto&#39; and so on.\n<p><code>userinfo</code> &mdash; User …\n"],["new","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-c-new","(*arg)","<p>Description\n<p>Creates a new Bundler::URI::LDAP object from generic Bundler::URI components as per RFC 2396. …\n"],["new","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-c-new","(*arg)","<p>Description\n<p>Creates a new Bundler::URI::MailTo object from generic URL components with no syntax checking. …\n"],["new","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-c-new","(opts = {})","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Parser</span>.<span class=\"ruby-identifier\">new</span>([<span class=\"ruby-identifier\">opts</span>])\n</pre>\n<p>Args\n"],["new","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-c-new","(opts = {})","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Parser</span>.<span class=\"ruby-identifier\">new</span>([<span class=\"ruby-identifier\">opts</span>])\n</pre>\n<p>Args\n"],["new","Bundler::VersionConflict","Bundler/VersionConflict.html#method-c-new","(conflicts, msg = nil)",""],["new","Bundler::Worker","Bundler/Worker.html#method-c-new","(size, name, func)","<p>Creates a worker pool of specified size\n<p>@param size [Integer] Size of pool @param name [String] name the …\n"],["new","Bundler::Worker::WrappedException","Bundler/Worker/WrappedException.html#method-c-new","(exn)",""],["new","Bundler::YamlSyntaxError","Bundler/YamlSyntaxError.html#method-c-new","(orig_exception, msg)",""],["new","CGI","CGI.html#method-c-new","(options = {})","<p>Create a new CGI instance.\n<p><code>tag_maker</code> &mdash; This is the same as using the <code>options_hash</code> form with the value <code>{</code> …\n"],["new","CGI::Cookie","CGI/Cookie.html#method-c-new","(name = \"\", *value)","<p>Create a new CGI::Cookie object.\n<p><code>name_string</code> &mdash; The name of the cookie; in this form, there is no #domain …\n"],["new","CGI::Session","CGI/Session.html#method-c-new","(request, option={})","<p>Create a new CGI::Session object for <code>request</code>.\n<p><code>request</code> is an instance of the <code>CGI</code> class (see cgi.rb). <code>option</code> …\n"],["new","CGI::Session::FileStore","CGI/Session/FileStore.html#method-c-new","(session, option={})","<p>Create a new FileStore instance.\n<p>This constructor is used internally by CGI::Session.  The user does not …\n"],["new","CGI::Session::MemoryStore","CGI/Session/MemoryStore.html#method-c-new","(session, option=nil)","<p>Create a new MemoryStore instance.\n<p><code>session</code> is the session this instance is associated with. <code>option</code> is …\n"],["new","CGI::Session::NullStore","CGI/Session/NullStore.html#method-c-new","(session, option=nil)","<p>Create a new NullStore instance.\n<p><code>session</code> is the session this instance is associated with. <code>option</code> is a …\n"],["new","CGI::Session::PStore","CGI/Session/PStore.html#method-c-new","(session, option={})","<p>Create a new CGI::Session::PStore instance\n<p>This constructor is used internally by CGI::Session.  The user …\n"],["new","CSV","CSV.html#method-c-new","(data, col_sep: \",\", row_sep: :auto, quote_char: '\"', field_size_limit: nil, converters: nil, unconverted_fields: nil, headers: false, return_headers: false, write_headers: nil, header_converters: nil, skip_blanks: false, force_quotes: false, skip_lines: nil, liberal_parsing: false, internal_encoding: nil, external_encoding: nil, encoding: nil, nil_value: nil, empty_value: \"\", quote_empty: true, write_converters: nil, write_nil_value: nil, write_empty_value: \"\", strip: false)","<p>This constructor will wrap either a String or IO object passed in <code>data</code> for reading and/or writing. In …\n"],["new","CSV::FieldsConverter","CSV/FieldsConverter.html#method-c-new","(options={})","<p>A CSV::FieldsConverter is a data structure for storing the fields converter properties to be passed as …\n"],["new","CSV::MalformedCSVError","CSV/MalformedCSVError.html#method-c-new","(message, line_number)",""],["new","CSV::Parser","CSV/Parser.html#method-c-new","(input, options)",""],["new","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-c-new","(inputs, encoding, chunk_size: 8192)",""],["new","CSV::Parser::Scanner","CSV/Parser/Scanner.html#method-c-new","(*args)",""],["new","CSV::Parser::UnoptimizedStringIO","CSV/Parser/UnoptimizedStringIO.html#method-c-new","(string)",""],["new","CSV::Row","CSV/Row.html#method-c-new","(headers, fields, header_row = false)","<p>Constructs a new CSV::Row from <code>headers</code> and <code>fields</code>, which are expected to be Arrays. If one Array is shorter …\n"],["new","CSV::Table","CSV/Table.html#method-c-new","(array_of_rows, headers: nil)","<p>Constructs a new CSV::Table from <code>array_of_rows</code>, which are expected to be CSV::Row objects. All rows are …\n"],["new","CSV::Writer","CSV/Writer.html#method-c-new","(output, options)",""],["new","Class","Class.html#method-c-new","(*args)","<p>Creates a new anonymous (unnamed) class with the given superclass (or Object if no parameter is given). …\n"],["new","Class","Class.html#method-i-new","(*args)","<p>Calls #allocate to create a new object of <em>class</em>&#39;s class, then invokes that object&#39;s #initialize …\n"],["new","ConditionVariable","ConditionVariable.html#method-c-new","()","<p>Creates a new condition variable instance.\n"],["new","DBM","DBM.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Open a dbm database with the specified name, which can include a directory path. Any file extensions …\n"],["new","DRb::DRbArray","DRb/DRbArray.html#method-c-new","(ary)","<p>Creates a new DRbArray that either dumps or wraps all the items in the Array <code>ary</code> so they can be loaded …\n"],["new","DRb::DRbObject","DRb/DRbObject.html#method-c-new","(obj, uri=nil)","<p>Create a new remote object stub.\n<p><code>obj</code> is the (local) object we want to create a stub for.  Normally this …\n"],["new","DRb::DRbObject","DRb/DRbObject.html#method-c-new","(obj, uri=nil)","<p>Create a new remote object stub.\n<p><code>obj</code> is the (local) object we want to create a stub for.  Normally this …\n"],["new","DRb::DRbRemoteError","DRb/DRbRemoteError.html#method-c-new","(error)","<p>Creates a new remote error that wraps the Exception <code>error</code>\n"],["new","DRb::DRbSSLSocket","DRb/DRbSSLSocket.html#method-c-new","(uri, soc, config, is_established)","<p>Create a DRb::DRbSSLSocket instance.\n<p><code>uri</code> is the URI we are connected to. <code>soc</code> is the tcp socket we are …\n"],["new","DRb::DRbSSLSocket::SSLConfig","DRb/DRbSSLSocket/SSLConfig.html#method-c-new","(config)","<p>Create a new DRb::DRbSSLSocket::SSLConfig instance\n<p>The DRb::DRbSSLSocket will take either a <code>config</code> Hash …\n"],["new","DRb::DRbServer","DRb/DRbServer.html#method-c-new","(uri=nil, front=nil, config_or_acl=nil)","<p>Create a new DRbServer instance.\n<p><code>uri</code> is the URI to bind to.  This is normally of the form &#39;druby://&lt;hostname&gt;:&lt;port&gt;&#39; …\n"],["new","DRb::DRbUnknown","DRb/DRbUnknown.html#method-c-new","(err, buf)","<p>Create a new DRbUnknown object.\n<p><code>buf</code> is a string containing a marshalled object that could not be unmarshalled. …\n"],["new","DRb::DRbUnknownError","DRb/DRbUnknownError.html#method-c-new","(unknown)","<p>Create a new DRbUnknownError for the DRb::DRbUnknown object <code>unknown</code>\n"],["new","DRb::ExtServ","DRb/ExtServ.html#method-c-new","(there, name, server=nil)",""],["new","DRb::ExtServManager","DRb/ExtServManager.html#method-c-new","()",""],["new","DRb::GW","DRb/GW.html#method-c-new","()","<p>Creates a new GW\n"],["new","DRb::ThreadObject","DRb/ThreadObject.html#method-c-new","(&blk)",""],["new","DRb::TimerIdConv","DRb/TimerIdConv.html#method-c-new","(keeping=600)","<p>Creates a new TimerIdConv which will hold objects for <code>keeping</code> seconds.\n"],["new","DRb::WeakIdConv","DRb/WeakIdConv.html#method-c-new","()",""],["new","DRb::WeakIdConv::WeakSet","DRb/WeakIdConv/WeakSet.html#method-c-new","()",""],["new","Date","Date.html#method-c-new","(p1 = v1, p2 = v2, p3 = v3, p4 = v4)",""],["new","DateTime","DateTime.html#method-c-new","(*args)","<p>Creates a DateTime object denoting the given calendar date.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>)    <span class=\"ruby-comment\">#=&gt; #&lt;DateTime: ...</span>\n</pre>\n"],["new","Delegator","Delegator.html#method-c-new","(obj)","<p>Pass in the <em>obj</em> to delegate method calls to.  All methods supported by <em>obj</em> will be delegated to.\n"],["new","Digest::Instance","Digest/Instance.html#method-i-new","()","<p>Returns a new, initialized copy of the digest object.  Equivalent to digest_obj.clone().reset().\n"],["new","Dir","Dir.html#method-c-new","(p1, p2 = {})","<p>Returns a new directory object for the named directory.\n<p>The optional <em>encoding</em> keyword argument specifies …\n"],["new","ERB","ERB.html#method-c-new","(str, safe_level=NOT_GIVEN, legacy_trim_mode=NOT_GIVEN, legacy_eoutvar=NOT_GIVEN, trim_mode: nil, eoutvar: '_erbout')","<p>Constructs a new ERB object with the template specified in <em>str</em>.\n<p>An ERB object works by building a chunk …\n"],["new","Encoding::Converter","Encoding/Converter.html#method-c-new","(*args)","<p>possible options elements:\n\n<pre>hash form:\n  :invalid =&gt; nil            # raise error on invalid byte sequence ...</pre>\n"],["new","Enumerator","Enumerator.html#method-c-new","(*args)","<p>Creates a new Enumerator object, which can be used as an Enumerable.\n<p>In the first form, iteration is defined …\n"],["new","Enumerator::Chain","Enumerator/Chain.html#method-c-new","(*args)","<p>Generates a new enumerator object that iterates over the elements of given enumerable objects in sequence. …\n"],["new","Enumerator::Lazy","Enumerator/Lazy.html#method-c-new","(*args)","<p>Creates a new Lazy enumerator. When the enumerator is actually enumerated (e.g. by calling #force),  …\n"],["new","Exception","Exception.html#method-c-new","(*args)","<p>Construct a new Exception object, optionally passing in a message.\n"],["new","ExceptionForMatrix::ErrDimensionMismatch","ExceptionForMatrix/ErrDimensionMismatch.html#method-c-new","(val = nil)",""],["new","ExceptionForMatrix::ErrNotRegular","ExceptionForMatrix/ErrNotRegular.html#method-c-new","(val = nil)",""],["new","ExceptionForMatrix::ErrOperationNotDefined","ExceptionForMatrix/ErrOperationNotDefined.html#method-c-new","(vals)",""],["new","ExceptionForMatrix::ErrOperationNotImplemented","ExceptionForMatrix/ErrOperationNotImplemented.html#method-c-new","(vals)",""],["new","Fiddle::CStructEntity","Fiddle/CStructEntity.html#method-c-new","(addr, types, func = nil)","<p>Wraps the C pointer <code>addr</code> as a C struct with the given <code>types</code>.\n<p>When the instance is garbage collected, the …\n"],["new","Fiddle::Closure","Fiddle/Closure.html#method-c-new","(p1, p2, p3 = v3)","<p>Construct a new Closure object.\n<p><code>ret</code> is the C type to be returned\n<p><code>args</code> is an Array of arguments, passed …\n"],["new","Fiddle::Closure::BlockCaller","Fiddle/Closure/BlockCaller.html#method-c-new","(ctype, args, abi = Fiddle::Function::DEFAULT, &block)","<p>Description\n<p>Construct a new BlockCaller object.\n<p><code>ctype</code> is the C type to be returned\n"],["new","Fiddle::CompositeHandler","Fiddle/CompositeHandler.html#method-c-new","(handlers)","<p>Create a new handler with the open <code>handlers</code>\n<p>Used internally by Fiddle::Importer.dlload\n"],["new","Fiddle::Function","Fiddle/Function.html#method-c-new","(p1, p2, p3, p4 = v4, p5 = {})","<p>Constructs a Function object.\n<p><code>ptr</code> is a referenced function, of a Fiddle::Handle\n<p><code>args</code> is an Array of arguments, …\n"],["new","Fiddle::Handle","Fiddle/Handle.html#method-c-new","(p1 = v1, p2 = v2)","<p>Create a new handler that opens <code>library</code> with <code>flags</code>.\n<p>If no <code>library</code> is specified or <code>nil</code> is given, DEFAULT …\n"],["new","Fiddle::Pointer","Fiddle/Pointer.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Create a new pointer to <code>address</code> with an optional <code>size</code> and <code>freefunc</code>.\n<p><code>freefunc</code> will be called when the instance …\n"],["new","File","File.html#method-c-new","(*args)","<p>Opens the file named by <code>filename</code> according to the given <code>mode</code> and returns a new File object.\n<p>See IO.new …\n"],["new","File::Stat","File/Stat.html#method-c-new","(p1)","<p>Create a File::Stat object for the given file name (raising an exception if the file doesn&#39;t exist). …\n"],["new","FrozenError","FrozenError.html#method-c-new","(*args, p2 = {})","<p>Construct a new FrozenError exception. If given the <em>receiver</em> parameter may subsequently be examined using …\n"],["new","GDBM","GDBM.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Creates a new GDBM instance by opening a gdbm file named <em>filename</em>. If the file does not exist, a new …\n"],["new","Gem::AvailableSet","Gem/AvailableSet.html#method-c-new","()",""],["new","Gem::BasicSpecification","Gem/BasicSpecification.html#method-c-new","()",""],["new","Gem::Command","Gem/Command.html#method-c-new","(command, summary=nil, defaults={})","<p>Initializes a generic gem command named <code>command</code>.  <code>summary</code> is a short description displayed in `gem help …\n"],["new","Gem::CommandManager","Gem/CommandManager.html#method-c-new","()","<p>Register all the subcommands supported by the gem command.\n"],["new","Gem::Commands::BuildCommand","Gem/Commands/BuildCommand.html#method-c-new","()",""],["new","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-c-new","()",""],["new","Gem::Commands::CheckCommand","Gem/Commands/CheckCommand.html#method-c-new","()",""],["new","Gem::Commands::CleanupCommand","Gem/Commands/CleanupCommand.html#method-c-new","()",""],["new","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-c-new","()",""],["new","Gem::Commands::DependencyCommand","Gem/Commands/DependencyCommand.html#method-c-new","()",""],["new","Gem::Commands::EnvironmentCommand","Gem/Commands/EnvironmentCommand.html#method-c-new","()",""],["new","Gem::Commands::FetchCommand","Gem/Commands/FetchCommand.html#method-c-new","()",""],["new","Gem::Commands::GenerateIndexCommand","Gem/Commands/GenerateIndexCommand.html#method-c-new","()",""],["new","Gem::Commands::HelpCommand","Gem/Commands/HelpCommand.html#method-c-new","()",""],["new","Gem::Commands::InfoCommand","Gem/Commands/InfoCommand.html#method-c-new","()",""],["new","Gem::Commands::InstallCommand","Gem/Commands/InstallCommand.html#method-c-new","()",""],["new","Gem::Commands::ListCommand","Gem/Commands/ListCommand.html#method-c-new","()",""],["new","Gem::Commands::LockCommand","Gem/Commands/LockCommand.html#method-c-new","()",""],["new","Gem::Commands::MirrorCommand","Gem/Commands/MirrorCommand.html#method-c-new","()",""],["new","Gem::Commands::OpenCommand","Gem/Commands/OpenCommand.html#method-c-new","()",""],["new","Gem::Commands::OutdatedCommand","Gem/Commands/OutdatedCommand.html#method-c-new","()",""],["new","Gem::Commands::OwnerCommand","Gem/Commands/OwnerCommand.html#method-c-new","()",""],["new","Gem::Commands::PristineCommand","Gem/Commands/PristineCommand.html#method-c-new","()",""],["new","Gem::Commands::PushCommand","Gem/Commands/PushCommand.html#method-c-new","()",""],["new","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-c-new","(name = 'query', summary = 'Query gem information in local or remote repositories')",""],["new","Gem::Commands::RdocCommand","Gem/Commands/RdocCommand.html#method-c-new","()",""],["new","Gem::Commands::SearchCommand","Gem/Commands/SearchCommand.html#method-c-new","()",""],["new","Gem::Commands::ServerCommand","Gem/Commands/ServerCommand.html#method-c-new","()",""],["new","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-c-new","()",""],["new","Gem::Commands::SigninCommand","Gem/Commands/SigninCommand.html#method-c-new","()",""],["new","Gem::Commands::SignoutCommand","Gem/Commands/SignoutCommand.html#method-c-new","()",""],["new","Gem::Commands::SourcesCommand","Gem/Commands/SourcesCommand.html#method-c-new","()",""],["new","Gem::Commands::SpecificationCommand","Gem/Commands/SpecificationCommand.html#method-c-new","()",""],["new","Gem::Commands::StaleCommand","Gem/Commands/StaleCommand.html#method-c-new","()",""],["new","Gem::Commands::UninstallCommand","Gem/Commands/UninstallCommand.html#method-c-new","()",""],["new","Gem::Commands::UnpackCommand","Gem/Commands/UnpackCommand.html#method-c-new","()",""],["new","Gem::Commands::UpdateCommand","Gem/Commands/UpdateCommand.html#method-c-new","()",""],["new","Gem::Commands::WhichCommand","Gem/Commands/WhichCommand.html#method-c-new","()",""],["new","Gem::Commands::YankCommand","Gem/Commands/YankCommand.html#method-c-new","()",""],["new","Gem::ConfigFile","Gem/ConfigFile.html#method-c-new","(args)","<p>Create the config file object.  <code>args</code> is the list of arguments from the command line.\n<p>The following command …\n"],["new","Gem::ConflictError","Gem/ConflictError.html#method-c-new","(target, conflicts)",""],["new","Gem::ConsoleUI","Gem/ConsoleUI.html#method-c-new","()","<p>The Console UI has no arguments as it defaults to reading input from stdin, output to stdout and warnings …\n"],["new","Gem::Dependency","Gem/Dependency.html#method-c-new","(name, *requirements)","<p>Constructs a dependency with <code>name</code> and <code>requirements</code>. The last argument can optionally be the dependency …\n"],["new","Gem::DependencyInstaller","Gem/DependencyInstaller.html#method-c-new","(options = {})","<p>Creates a new installer instance.\n<p>Options are:\n<p>:cache_dir &mdash; Alternate repository path to store .gem files …\n"],["new","Gem::DependencyList","Gem/DependencyList.html#method-c-new","(development = false)","<p>Creates a new DependencyList.  If <code>development</code> is true, development dependencies will be included.\n"],["new","Gem::DependencyResolutionError","Gem/DependencyResolutionError.html#method-c-new","(conflict)",""],["new","Gem::Doctor","Gem/Doctor.html#method-c-new","(gem_repository, dry_run = false)","<p>Creates a new Gem::Doctor that will clean up <code>gem_repository</code>.  Only one gem repository may be cleaned …\n"],["new","Gem::Ext::Builder","Gem/Ext/Builder.html#method-c-new","(spec, build_args = spec.build_args)","<p>Creates a new extension builder for <code>spec</code>.  If the <code>spec</code> does not yet have build arguments, saved, set …\n"],["new","Gem::FakeFetcher","Gem/FakeFetcher.html#method-c-new","()",""],["new","Gem::FilePermissionError","Gem/FilePermissionError.html#method-c-new","(directory)",""],["new","Gem::GemRunner","Gem/GemRunner.html#method-c-new","(options={})",""],["new","Gem::ImpossibleDependenciesError","Gem/ImpossibleDependenciesError.html#method-c-new","(request, conflicts)",""],["new","Gem::Indexer","Gem/Indexer.html#method-c-new","(directory, options = {})","<p>Create an indexer that will index the gems in <code>directory</code>.\n"],["new","Gem::Installer","Gem/Installer.html#method-c-new","(package, options={})","<p>Constructs an Installer instance that will install the gem at <code>package</code> which can either be a path or an …\n"],["new","Gem::Installer::FakePackage","Gem/Installer/FakePackage.html#method-c-new","(spec)",""],["new","Gem::List","Gem/List.html#method-c-new","(value = nil, tail = nil)",""],["new","Gem::MissingSpecError","Gem/MissingSpecError.html#method-c-new","(name, requirement)",""],["new","Gem::MissingSpecVersionError","Gem/MissingSpecVersionError.html#method-c-new","(name, requirement, specs)",""],["new","Gem::MockGemUi","Gem/MockGemUi.html#method-c-new","(input = \"\")",""],["new","Gem::MockGemUi::InputEOFError","Gem/MockGemUi/InputEOFError.html#method-c-new","(question)",""],["new","Gem::MockGemUi::TermError","Gem/MockGemUi/TermError.html#method-c-new","(exit_code)",""],["new","Gem::NameTuple","Gem/NameTuple.html#method-c-new","(name, version, platform=\"ruby\")",""],["new","Gem::Package","Gem/Package.html#method-c-new","(gem, security_policy = nil)","<p>Creates a new Gem::Package for the file at <code>gem</code>. <code>gem</code> can also be provided as an IO object.\n<p>If <code>gem</code> is an …\n"],["new","Gem::Package::DigestIO","Gem/Package/DigestIO.html#method-c-new","(io, digests)","<p>Creates a new DigestIO instance.  Using ::wrap is recommended, see the ::wrap documentation for documentation …\n"],["new","Gem::Package::FormatError","Gem/Package/FormatError.html#method-c-new","(message, source = nil)",""],["new","Gem::Package::Old","Gem/Package/Old.html#method-c-new","(gem, security_policy)","<p>Creates a new old-format package reader for <code>gem</code>.  Old-format packages cannot be written.\n"],["new","Gem::Package::PathError","Gem/Package/PathError.html#method-c-new","(destination, destination_dir)",""],["new","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-c-new","(vals)","<p>Creates a new TarHeader using <code>vals</code>\n"],["new","Gem::Package::TarReader","Gem/Package/TarReader.html#method-c-new","(io)","<p>Creates a new TarReader on <code>io</code> and yields it to the block, if given.\n"],["new","Gem::Package::TarReader","Gem/Package/TarReader.html#method-c-new","(io)","<p>Creates a new tar file reader on <code>io</code> which needs to respond to #pos, #eof?, #read, #getc and #pos=\n"],["new","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-c-new","(header, io)","<p>Creates a new tar entry for <code>header</code> that will be read from <code>io</code>\n"],["new","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-c-new","(io)","<p>Creates a new TarWriter that will write to <code>io</code>\n"],["new","Gem::Package::TarWriter","Gem/Package/TarWriter.html#method-c-new","(io)","<p>Creates a new TarWriter, yielding it if a block is given\n"],["new","Gem::Package::TarWriter::BoundedStream","Gem/Package/TarWriter/BoundedStream.html#method-c-new","(io, limit)","<p>Wraps <code>io</code> and allows up to <code>limit</code> bytes to be written\n"],["new","Gem::Package::TarWriter::RestrictedStream","Gem/Package/TarWriter/RestrictedStream.html#method-c-new","(io)","<p>Creates a new RestrictedStream wrapping <code>io</code>\n"],["new","Gem::PackageTask","Gem/PackageTask.html#method-c-new","(gem_spec)","<p>Create a Gem Package task library.  Automatically define the gem if a block is given.  If no block is …\n"],["new","Gem::PathSupport","Gem/PathSupport.html#method-c-new","(env)","<p>Constructor. Takes a single argument which is to be treated like a hashtable, or defaults to ENV, the …\n"],["new","Gem::Platform","Gem/Platform.html#method-c-new","(arch)",""],["new","Gem::PlatformMismatch","Gem/PlatformMismatch.html#method-c-new","(name, version)",""],["new","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-c-new","(proxy=nil, dns=nil, headers={})","<p>Initialize a remote fetcher using the source URI and possible proxy information.\n<p><code>proxy</code>\n<p>[String]: explicit …\n"],["new","Gem::RemoteFetcher::FetchError","Gem/RemoteFetcher/FetchError.html#method-c-new","(message, uri)",""],["new","Gem::Request","Gem/Request.html#method-c-new","(uri, request_class, last_modified, pool)",""],["new","Gem::RequestSet","Gem/RequestSet.html#method-c-new","(*deps)","<p>Creates a RequestSet for a list of Gem::Dependency objects, <code>deps</code>.  You can then #resolve and #install …\n"],["new","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-c-new","(set, path)","<p>Creates a new GemDependencyAPI that will add dependencies to the Gem::RequestSet <code>set</code> based on the dependency …\n"],["new","Gem::RequestSet::Lockfile","Gem/RequestSet/Lockfile.html#method-c-new","(request_set, gem_deps_file, dependencies)",""],["new","Gem::RequestSet::Lockfile::ParseError","Gem/RequestSet/Lockfile/ParseError.html#method-c-new","(message, column, line, path)","<p>Raises a ParseError with the given <code>message</code> which was encountered at a <code>line</code> and <code>column</code> while parsing. …\n"],["new","Gem::RequestSet::Lockfile::Parser","Gem/RequestSet/Lockfile/Parser.html#method-c-new","(tokenizer, set, platforms, filename = nil)","<p>Parses lockfiles\n"],["new","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-c-new","(input, filename = nil, line = 0, pos = 0)",""],["new","Gem::Requirement","Gem/Requirement.html#method-c-new","(*requirements)","<p>Constructs a requirement from <code>requirements</code>. Requirements can be Strings, Gem::Versions, or Arrays of …\n"],["new","Gem::Resolver","Gem/Resolver.html#method-c-new","(needed, set = nil)","<p>Create Resolver object which will resolve the tree starting with <code>needed</code> Dependency objects.\n<p><code>set</code> is an …\n"],["new","Gem::Resolver::APISet","Gem/Resolver/APISet.html#method-c-new","(dep_uri = 'https://rubygems.org/api/v1/dependencies')","<p>Creates a new APISet that will retrieve gems from <code>uri</code> using the RubyGems API URL <code>dep_uri</code> which is described …\n"],["new","Gem::Resolver::APISpecification","Gem/Resolver/APISpecification.html#method-c-new","(set, api_data)","<p>Creates an APISpecification for the given <code>set</code> from the rubygems.org <code>api_data</code>.\n<p>See guides.rubygems.org/rubygems-org-api/#misc_methods …\n"],["new","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-c-new","(spec, request)","<p>Creates a new ActivationRequest that will activate <code>spec</code>.  The parent <code>request</code> is used to provide diagnostics …\n"],["new","Gem::Resolver::BestSet","Gem/Resolver/BestSet.html#method-c-new","(sources = Gem.sources)","<p>Creates a BestSet for the given <code>sources</code> or Gem::sources if none are specified.  <code>sources</code> must be a Gem::SourceList …\n"],["new","Gem::Resolver::ComposedSet","Gem/Resolver/ComposedSet.html#method-c-new","(*sets)","<p>Creates a new ComposedSet containing <code>sets</code>.  Use Gem::Resolver::compose_sets instead.\n"],["new","Gem::Resolver::Conflict","Gem/Resolver/Conflict.html#method-c-new","(dependency, activated, failed_dep=dependency)","<p>Creates a new resolver conflict when <code>dependency</code> is in conflict with an already <code>activated</code> specification. …\n"],["new","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-c-new","(dependency, requester)","<p>Creates a new DependencyRequest for <code>dependency</code> from <code>requester</code>. +requester may be nil if the request came …\n"],["new","Gem::Resolver::IndexSpecification","Gem/Resolver/IndexSpecification.html#method-c-new","(set, name, version, source, platform)","<p>An IndexSpecification is created from the index format described in `gem help generate_index`.\n<p>The <code>set</code> …\n"],["new","Gem::Resolver::InstallerSet","Gem/Resolver/InstallerSet.html#method-c-new","(domain)","<p>Creates a new InstallerSet that will look for gems in <code>domain</code>.\n"],["new","Gem::Resolver::LockSet","Gem/Resolver/LockSet.html#method-c-new","(sources)","<p>Creates a new LockSet from the given <code>sources</code>\n"],["new","Gem::Resolver::LockSpecification","Gem/Resolver/LockSpecification.html#method-c-new","(set, name, version, sources, platform)",""],["new","Gem::Resolver::Molinillo::CircularDependencyError","Gem/Resolver/Molinillo/CircularDependencyError.html#method-c-new","(nodes)","<p>Initializes a new error with the given circular vertices. @param [Array&lt;DependencyGraph::Vertex&gt;] …\n"],["new","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-c-new","()","<p>Initializes an empty dependency graph\n"],["new","Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular","Gem/Resolver/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-c-new","(origin, destination, requirement)","<p>Initialize an action to add an edge to a dependency graph @param [String] origin the name of the origin …\n"],["new","Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge","Gem/Resolver/Molinillo/DependencyGraph/DeleteEdge.html#method-c-new","(origin_name, destination_name, requirement)","<p>Initialize an action to add an edge to a dependency graph @param [String] origin_name the name of the …\n"],["new","Gem::Resolver::Molinillo::DependencyGraph::DetachVertexNamed","Gem/Resolver/Molinillo/DependencyGraph/DetachVertexNamed.html#method-c-new","(name)","<p>Initialize an action to detach a vertex from a dependency graph @param [String] name the name of the …\n"],["new","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-c-new","()","<p>Initializes an empty log\n"],["new","Gem::Resolver::Molinillo::DependencyGraph::Tag","Gem/Resolver/Molinillo/DependencyGraph/Tag.html#method-c-new","(tag)","<p>Initialize an action to tag a state of a dependency graph @param [Object] tag an opaque tag\n"],["new","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-c-new","(name, payload)","<p>Initializes a vertex with the given name and payload. @param [String] name see {#name} @param [Object] …\n"],["new","Gem::Resolver::Molinillo::NoSuchDependencyError","Gem/Resolver/Molinillo/NoSuchDependencyError.html#method-c-new","(dependency, required_by = [])","<p>Initializes a new error with the given missing dependency. @param [Object] dependency @see {#dependency} …\n"],["new","Gem::Resolver::Molinillo::Resolver","Gem/Resolver/Molinillo/Resolver.html#method-c-new","(specification_provider, resolver_ui)","<p>Initializes a new resolver. @param  [SpecificationProvider] specification_provider\n\n<pre>see {#specification_provider}</pre>\n"],["new","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-c-new","(specification_provider, resolver_ui, requested, base)","<p>Initializes a new resolution. @param [SpecificationProvider] specification_provider\n\n<pre>see {#specification_provider}</pre>\n"],["new","Gem::Resolver::Molinillo::VersionConflict","Gem/Resolver/Molinillo/VersionConflict.html#method-c-new","(conflicts)","<p>Initializes a new error with the given version conflicts. @param [{String =&gt; Resolution::Conflict}] …\n"],["new","Gem::Resolver::RequirementList","Gem/Resolver/RequirementList.html#method-c-new","()","<p>Creates a new RequirementList.\n"],["new","Gem::Resolver::SourceSet","Gem/Resolver/SourceSet.html#method-c-new","()","<p>Creates a SourceSet for the given <code>sources</code> or Gem::sources if none are specified.  <code>sources</code> must be a  …\n"],["new","Gem::Resolver::SpecSpecification","Gem/Resolver/SpecSpecification.html#method-c-new","(set, spec, source = nil)","<p>A SpecSpecification is created for a <code>set</code> for a Gem::Specification in <code>spec</code>.  The <code>source</code> is either where …\n"],["new","Gem::Resolver::Specification","Gem/Resolver/Specification.html#method-c-new","()","<p>Sets default instance variables for the specification.\n"],["new","Gem::Resolver::Stats","Gem/Resolver/Stats.html#method-c-new","()",""],["new","Gem::S3URISigner","Gem/S3URISigner.html#method-c-new","(uri)",""],["new","Gem::S3URISigner::ConfigurationError","Gem/S3URISigner/ConfigurationError.html#method-c-new","(message)",""],["new","Gem::S3URISigner::InstanceProfileError","Gem/S3URISigner/InstanceProfileError.html#method-c-new","(message)",""],["new","Gem::Security::Policy","Gem/Security/Policy.html#method-c-new","(name, policy = {}, opt = {})","<p>Create a new Gem::Security::Policy object with the given mode and options.\n"],["new","Gem::Security::Signer","Gem/Security/Signer.html#method-c-new","(key, cert_chain, passphrase = nil, options = {})","<p>Creates a new signer with an RSA <code>key</code> or path to a key, and a certificate <code>chain</code> containing X509 certificates, …\n"],["new","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-c-new","(dir, permissions = DEFAULT_PERMISSIONS)","<p>Creates a new TrustDir using <code>dir</code> where the directory and file permissions will be checked according to …\n"],["new","Gem::Server","Gem/Server.html#method-c-new","(gem_dirs, port, daemon, launch = nil, addresses = nil)",""],["new","Gem::SilentUI","Gem/SilentUI.html#method-c-new","()","<p>The SilentUI has no arguments as it does not use any stream.\n"],["new","Gem::Source","Gem/Source.html#method-c-new","(uri)","<p>Creates a new Source which will use the index located at <code>uri</code>.\n"],["new","Gem::Source::Git","Gem/Source/Git.html#method-c-new","(name, repository, reference, submodules = false)","<p>Creates a new git gem source for a gems from loaded from <code>repository</code> at the given <code>reference</code>.  The <code>name</code> …\n"],["new","Gem::Source::Lock","Gem/Source/Lock.html#method-c-new","(source)","<p>Creates a new Lock source that wraps <code>source</code> and moves it earlier in the sort list.\n"],["new","Gem::Source::SpecificFile","Gem/Source/SpecificFile.html#method-c-new","(file)","<p>Creates a new SpecificFile for the gem in <code>file</code>\n"],["new","Gem::Source::Vendor","Gem/Source/Vendor.html#method-c-new","(path)","<p>Creates a new Vendor source for a gem that was unpacked at <code>path</code>.\n"],["new","Gem::SourceFetchProblem","Gem/SourceFetchProblem.html#method-c-new","(source, error)","<p>Creates a new SourceFetchProblem for the given <code>source</code> and <code>error</code>.\n"],["new","Gem::SourceList","Gem/SourceList.html#method-c-new","()","<p>Creates a new SourceList\n"],["new","Gem::SpecFetcher","Gem/SpecFetcher.html#method-c-new","(sources = nil)","<p>Creates a new SpecFetcher.  Ordinarily you want to use the default fetcher from Gem::SpecFetcher::fetcher …\n"],["new","Gem::SpecificGemNotFoundException","Gem/SpecificGemNotFoundException.html#method-c-new","(name, version, errors=nil)","<p>Creates a new SpecificGemNotFoundException for a gem with the given <code>name</code> and <code>version</code>.  Any <code>errors</code> encountered …\n"],["new","Gem::Specification","Gem/Specification.html#method-c-new","(name = nil, version = nil)","<p>Specification constructor. Assigns the default values to the attributes and yields itself for further …\n"],["new","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-c-new","(specification)",""],["new","Gem::StreamUI","Gem/StreamUI.html#method-c-new","(in_stream, out_stream, err_stream=STDERR, usetty=true)","<p>Creates a new StreamUI wrapping <code>in_stream</code> for user input, <code>out_stream</code> for standard output, <code>err_stream</code> …\n"],["new","Gem::StreamUI::SilentDownloadReporter","Gem/StreamUI/SilentDownloadReporter.html#method-c-new","(out_stream, *args)","<p>The silent download reporter ignores all arguments\n"],["new","Gem::StreamUI::SilentProgressReporter","Gem/StreamUI/SilentProgressReporter.html#method-c-new","(out_stream, size, initial_message, terminal_message = nil)","<p>Creates a silent progress reporter that ignores all input arguments.\n"],["new","Gem::StreamUI::SimpleProgressReporter","Gem/StreamUI/SimpleProgressReporter.html#method-c-new","(out_stream, size, initial_message, terminal_message = \"complete\")","<p>Creates a new progress reporter that will write to <code>out_stream</code> for <code>size</code> items.  Shows the given <code>initial_message</code> …\n"],["new","Gem::StreamUI::ThreadedDownloadReporter","Gem/StreamUI/ThreadedDownloadReporter.html#method-c-new","(out_stream, *args)","<p>Creates a new threaded download reporter that will display on <code>out_stream</code>.  The other arguments are ignored. …\n"],["new","Gem::StreamUI::VerboseProgressReporter","Gem/StreamUI/VerboseProgressReporter.html#method-c-new","(out_stream, size, initial_message, terminal_message = 'complete')","<p>Creates a new progress reporter that will write to <code>out_stream</code> for <code>size</code> items.  Shows the given <code>initial_message</code> …\n"],["new","Gem::SystemExitException","Gem/SystemExitException.html#method-c-new","(exit_code)","<p>Creates a new SystemExitException with the given <code>exit_code</code>\n"],["new","Gem::TestCase::StaticSet","Gem/TestCase/StaticSet.html#method-c-new","(specs)","<p>Creates a new StaticSet for the given <code>specs</code>\n"],["new","Gem::Uninstaller","Gem/Uninstaller.html#method-c-new","(gem, options = {})","<p>Constructs an uninstaller that will uninstall <code>gem</code>\n"],["new","Gem::UnsatisfiableDependencyError","Gem/UnsatisfiableDependencyError.html#method-c-new","(dep, platform_mismatch=nil)","<p>Creates a new UnsatisfiableDependencyError for the unsatisfiable Gem::Resolver::DependencyRequest <code>dep</code> …\n"],["new","Gem::UriFormatter","Gem/UriFormatter.html#method-c-new","(uri)","<p>Creates a new URI formatter for <code>uri</code>.\n"],["new","Gem::Version","Gem/Version.html#method-c-new","(version)","<p>Constructs a Version from the <code>version</code> string.  A version string is a series of digits or ASCII letters …\n"],["new","GetoptLong","GetoptLong.html#method-c-new","(*arguments)","<p>Set up option processing.\n<p>The options to support are passed to new() as an array of arrays. Each sub-array …\n"],["new","Hash","Hash.html#method-c-new","(*args)","<p>Returns a new, empty hash. If this hash is subsequently accessed by a key that doesn&#39;t correspond …\n"],["new","IO","IO.html#method-c-new","(p1, p2 = v2, p3 = {})","<p>Returns a new IO object (a stream) for the given integer file descriptor <code>fd</code> and <code>mode</code> string.  <code>opt</code> may …\n"],["new","IPAddr","IPAddr.html#method-c-new","(addr = '::', family = Socket::AF_UNSPEC)","<p>Creates a new ipaddr object either from a human readable IP address representation in string, or from …\n"],["new","IRB::Canvas","IRB/Canvas.html#method-c-new","((h, w))",""],["new","IRB::Color::SymbolState","IRB/Color/SymbolState.html#method-c-new","()",""],["new","IRB::Context","IRB/Context.html#method-c-new","(irb, workspace = nil, input_method = nil)","<p>Creates a new IRB context.\n<p>The optional <code>input_method</code> argument:\n<p><code>nil</code> &mdash; uses stdin or Reidline or Readline\n"],["new","IRB::FileInputMethod","IRB/FileInputMethod.html#method-c-new","(file)","<p>Creates a new input method object\n"],["new","IRB::Frame","IRB/Frame.html#method-c-new","()","<p>Creates a new stack frame\n"],["new","IRB::Frame::FrameOverflow","IRB/Frame/FrameOverflow.html#method-c-new","()",""],["new","IRB::Frame::FrameUnderflow","IRB/Frame/FrameUnderflow.html#method-c-new","()",""],["new","IRB::InputMethod","IRB/InputMethod.html#method-c-new","(file = STDIN_FILE_NAME)","<p>Creates a new input method object\n"],["new","IRB::Inspector","IRB/Inspector.html#method-c-new","(inspect_proc, init_proc = nil)","<p>Creates a new inspector object, using the given <code>inspect_proc</code> when output return values in irb.\n"],["new","IRB::Irb","IRB/Irb.html#method-c-new","(workspace = nil, input_method = nil)","<p>Creates a new irb session\n"],["new","IRB::JobManager","IRB/JobManager.html#method-c-new","()","<p>Creates a new JobManager object\n"],["new","IRB::Locale","IRB/Locale.html#method-c-new","(locale = nil)",""],["new","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-c-new","(prefix, base_notifier)","<p>Creates a new Notifier object\n"],["new","IRB::Notifier::CompositeNotifier","IRB/Notifier/CompositeNotifier.html#method-c-new","(prefix, base_notifier)","<p>Create a new composite notifier object with the given <code>prefix</code>, and <code>base_notifier</code> to use for output.\n"],["new","IRB::Notifier::ErrUndefinedNotifier","IRB/Notifier/ErrUndefinedNotifier.html#method-c-new","(val)",""],["new","IRB::Notifier::ErrUnrecognizedLevel","IRB/Notifier/ErrUnrecognizedLevel.html#method-c-new","(val)",""],["new","IRB::Notifier::LeveledNotifier","IRB/Notifier/LeveledNotifier.html#method-c-new","(base, level, prefix)","<p>Create a new leveled notifier with the given <code>base</code>, and <code>prefix</code> to send to AbstractNotifier.new\n<p>The given …\n"],["new","IRB::Notifier::NoMsgNotifier","IRB/Notifier/NoMsgNotifier.html#method-c-new","()","<p>Creates a new notifier that should not be used to output messages.\n"],["new","IRB::OutputMethod::NotImplementedError","IRB/OutputMethod/NotImplementedError.html#method-c-new","(val)",""],["new","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-c-new","()","<p>Creates a new input method object using Readline\n"],["new","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-c-new","()","<p>Creates a new input method object using Readline\n"],["new","IRB::RubyModel","IRB/RubyModel.html#method-c-new","()",""],["new","IRB::StdioInputMethod","IRB/StdioInputMethod.html#method-c-new","()","<p>Creates a new input method object\n"],["new","IRB::Vec","IRB/Vec.html#method-c-new","(x, y, z)",""],["new","IRB::WorkSpace","IRB/WorkSpace.html#method-c-new","(*main)","<p>Creates a new workspace.\n<p>set self to main if specified, otherwise inherit main from TOPLEVEL_BINDING. …\n"],["new","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-c-new","(p1 = v1)","<p>Instantiates a new State object, configured by <em>opts</em>.\n<p><em>opts</em> can have the following keys:\n<p><strong>indent</strong>: a string …\n"],["new","JSON::Ext::Parser","JSON/Ext/Parser.html#method-c-new","(p1, p2 = {})","<p>Creates a new JSON::Ext::Parser instance for the string <em>source</em>.\n<p>Creates a new JSON::Ext::Parser instance …\n"],["new","KeyError","KeyError.html#method-c-new","(p1 = v1, p2 = {})","<p>Construct a new <code>KeyError</code> exception with the given message, receiver and key.\n"],["new","Logger","Logger.html#method-c-new","(logdev, shift_age = 0, shift_size = 1048576, level: DEBUG, progname: nil, formatter: nil, datetime_format: nil, binmode: false, shift_period_suffix: '%Y%m%d')","<p>Args\n<p><code>logdev</code> &mdash; The log device.  This is a filename (String) or IO object (typically <code>STDOUT</code>, <code>STDERR</code>, or an …\n"],["new","Matrix","Matrix.html#method-c-new","(rows, column_count = rows[0].size)","<p>Matrix.new is private; use Matrix.rows, columns, [], etc… to create.\n"],["new","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-c-new","(a)","<p>Constructs the eigenvalue decomposition for a square matrix <code>A</code>\n"],["new","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-c-new","(a)",""],["new","Module","Module.html#method-c-new","()","<p>Creates a new anonymous module. If a block is given, it is passed the module object, and the block is …\n"],["new","MonitorMixin","MonitorMixin.html#method-c-new","(*args)","<p>Use <code>extend MonitorMixin</code> or <code>include MonitorMixin</code> instead of this constructor.  Have look at the examples …\n"],["new","MonitorMixin::ConditionVariable","MonitorMixin/ConditionVariable.html#method-c-new","(monitor)",""],["new","Mutex","Mutex.html#method-c-new","()","<p>Creates a new Mutex\n"],["new","NameError","NameError.html#method-c-new","(*args, p2 = {})","<p>Construct a new NameError exception. If given the <em>name</em> parameter may subsequently be examined using the …\n"],["new","Net::FTP","Net/FTP.html#method-c-new","(host = nil, user_or_options = {}, passwd = nil, acct = nil)","<p>Creates and returns a new <code>FTP</code> object. If a <code>host</code> is given, a connection is made.\n<p><code>options</code> is an option hash, …\n"],["new","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-c-new","(facts, pathname)",""],["new","Net::HTTP","Net/HTTP.html#method-c-new","(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil, p_no_proxy = nil)","<p>Creates a new Net::HTTP object without opening a TCP connection or HTTP session.\n<p>The <code>address</code> should be …\n"],["new","Net::HTTP","Net/HTTP.html#method-c-new","(address, port = nil)","<p>Creates a new Net::HTTP object for the specified server address, without opening the TCP connection or …\n"],["new","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-c-new","(m, reqbody, resbody, uri_or_path, initheader = nil)",""],["new","Net::HTTPRequest","Net/HTTPRequest.html#method-c-new","(path, initheader = nil)","<p>Creates an HTTP request object for <code>path</code>.\n<p><code>initheader</code> are the default headers to use.  Net::HTTP adds Accept-Encoding …\n"],["new","Net::IMAP","Net/IMAP.html#method-c-new","(host, port_or_options = {}, usessl = false, certs = nil, verify = true)","<p>Creates a new Net::IMAP object and connects it to the specified <code>host</code>.\n<p><code>options</code> is an option hash, each …\n"],["new","Net::IMAP::CramMD5Authenticator","Net/IMAP/CramMD5Authenticator.html#method-c-new","(user, password)",""],["new","Net::IMAP::DigestMD5Authenticator","Net/IMAP/DigestMD5Authenticator.html#method-c-new","(user, password, authname = nil)",""],["new","Net::IMAP::LoginAuthenticator","Net/IMAP/LoginAuthenticator.html#method-c-new","(user, password)",""],["new","Net::IMAP::PlainAuthenticator","Net/IMAP/PlainAuthenticator.html#method-c-new","(user, password)",""],["new","Net::IMAP::ResponseError","Net/IMAP/ResponseError.html#method-c-new","(response)",""],["new","Net::POP3","Net/POP3.html#method-c-new","(addr, port = nil, isapop = false)","<p>Creates a new POP3 object.\n<p><code>address</code> is the hostname or ip address of your POP3 server.\n<p>The optional <code>port</code> …\n"],["new","Net::ReadTimeout","Net/ReadTimeout.html#method-c-new","(io = nil)",""],["new","Net::SMTP","Net/SMTP.html#method-c-new","(address, port = nil)","<p>Creates a new Net::SMTP object.\n<p><code>address</code> is the hostname or ip address of your SMTP server.  <code>port</code> is the …\n"],["new","Net::SMTP::Response","Net/SMTP/Response.html#method-c-new","(status, string)","<p>Creates a new instance of the Response class and sets the status and string attributes\n"],["new","Net::WriteAdapter","Net/WriteAdapter.html#method-c-new","(socket, method)",""],["new","Net::WriteTimeout","Net/WriteTimeout.html#method-c-new","(io = nil)",""],["new","NoMethodError","NoMethodError.html#method-c-new","(*args, p2 = {})","<p>Construct a NoMethodError exception for a method of the given name called with the given arguments.  …\n"],["new","OLEProperty","OLEProperty.html#method-c-new","(obj, dispid, gettypes, settypes)",""],["new","OpenSSL::ASN1::ASN1Data","OpenSSL/ASN1/ASN1Data.html#method-c-new","(p1, p2, p3)","<p><em>value</em>: Please have a look at Constructive and Primitive to see how Ruby types are mapped to ASN.1 types …\n"],["new","OpenSSL::ASN1::Constructive","OpenSSL/ASN1/Constructive.html#method-c-new","(p1, p2 = v2, p3 = v3, p4 = v4)","<p><em>value</em>: is mandatory.\n<p><em>tag</em>: optional, may be specified for tagged values. If no <em>tag</em> is specified, the UNIVERSAL …\n"],["new","OpenSSL::ASN1::Primitive","OpenSSL/ASN1/Primitive.html#method-c-new","(p1, p2 = v2, p3 = v3, p4 = v4)","<p><em>value</em>: is mandatory.\n<p><em>tag</em>: optional, may be specified for tagged values. If no <em>tag</em> is specified, the UNIVERSAL …\n"],["new","OpenSSL::BN","OpenSSL/BN.html#method-c-new","(p1, p2 = v2)","<p>Construct a new OpenSSL BIGNUM object.\n"],["new","OpenSSL::Buffering","OpenSSL/Buffering.html#method-c-new","(*)","<p>Creates an instance of OpenSSL&#39;s buffering IO module.\n"],["new","OpenSSL::Cipher","OpenSSL/Cipher.html#method-c-new","(p1)","<p>The string must be a valid cipher name like “AES-128-CBC” or “3DES”.\n<p>A list of cipher …\n"],["new","OpenSSL::Config","OpenSSL/Config.html#method-c-new","(filename = nil)","<p>Creates an instance of OpenSSL&#39;s configuration class.\n<p>This can be used in contexts like OpenSSL::X509::ExtensionFactory.config= …\n"],["new","OpenSSL::Digest","OpenSSL/Digest.html#method-c-new","(p1, p2 = v2)","<p>Creates a Digest instance based on <em>string</em>, which is either the ln (long name) or sn (short name) of a …\n"],["new","OpenSSL::HMAC","OpenSSL/HMAC.html#method-c-new","(p1, p2)","<p>Returns an instance of OpenSSL::HMAC set with the key and digest algorithm to be used. The instance represents …\n"],["new","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-c-new","(p1 = v1)","<p>Parameters\n<p><em>request</em> - optional raw request, either in PEM or DER format.\n\n"],["new","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-c-new","(p1 = v1)","<p>Creates a new BasicResponse. If <em>der_string</em> is given, decodes <em>der_string</em> as DER.\n"],["new","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Creates a new OpenSSL::OCSP::CertificateId for the given <em>subject</em> and <em>issuer</em> X509 certificates.  The  …\n"],["new","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-c-new","(p1 = v1)","<p>Creates a new OpenSSL::OCSP::Request.  The request may be created empty or from a <em>request_der</em> string. …\n"],["new","OpenSSL::OCSP::Response","OpenSSL/OCSP/Response.html#method-c-new","(p1 = v1)","<p>Creates a new OpenSSL::OCSP::Response.  The response may be created empty or from a <em>response_der</em> string. …\n"],["new","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-c-new","(p1)","<p>Creates a new SingleResponse from <em>der_string</em>.\n"],["new","OpenSSL::PKCS12","OpenSSL/PKCS12.html#method-c-new","(p1 = v1, p2 = v2)","<p>Parameters\n<p><em>str</em> - Must be a DER encoded PKCS12 string.\n<p><em>pass</em> - string\n"],["new","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-c-new","(p1 = v1)","<p>Many methods in this class aren&#39;t documented.\n"],["new","OpenSSL::PKCS7::RecipientInfo","OpenSSL/PKCS7/RecipientInfo.html#method-c-new","(p1)",""],["new","OpenSSL::PKCS7::SignerInfo","OpenSSL/PKCS7/SignerInfo.html#method-c-new","(p1, p2, p3)",""],["new","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-c-new","(p1 = v1, p2 = v2)","<p>Either generates a DH instance from scratch or by reading already existing DH parameters from <em>string</em> …\n"],["new","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-c-new","(p1 = v1, p2 = v2)","<p>Creates a new DSA instance by reading an existing key from <em>string</em>.\n<p>Parameters\n<p><em>size</em> is an integer representing …\n"],["new","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-c-new","(p1 = v1, p2 = v2)","<p>Creates a new EC object from given arguments.\n"],["new","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-c-new","(p1, p2 = v2, p3 = v3, p4 = v4)","<p>Creates a new EC::Group object.\n<p><em>ec_method</em> is a symbol that represents an EC_METHOD. Currently the following …\n"],["new","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-c-new","(p1, p2 = v2)","<p>Creates a new instance of OpenSSL::PKey::EC::Point. If the only argument is an instance of EC::Point …\n"],["new","OpenSSL::PKey::PKey","OpenSSL/PKey/PKey.html#method-c-new","()","<p>Because PKey is an abstract class, actually calling this method explicitly will raise a NotImplementedError …\n"],["new","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-c-new","(p1 = v1, p2 = v2)","<p>Generates or loads an RSA keypair.  If an integer <em>key_size</em> is given it represents the desired key size. …\n"],["new","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-c-new","(version = nil)","<p>Creates a new SSL context.\n<p>If an argument is given, #ssl_version= is called with the value. Note that …\n"],["new","OpenSSL::SSL::SSLServer","OpenSSL/SSL/SSLServer.html#method-c-new","(svr, ctx)","<p>Creates a new instance of SSLServer.\n<p><em>srv</em> is an instance of TCPServer.\n<p><em>ctx</em> is an instance of OpenSSL::SSL::SSLContext …\n"],["new","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-c-new","(p1, p2 = v2)","<p>Creates a new SSL socket from <em>io</em> which must be a real IO object (not an IO-like object that responds …\n"],["new","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-c-new","(p1)","<p>Creates a new Session object from an instance of SSLSocket or DER/PEM encoded String.\n"],["new","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-c-new","(p1, p2 = v2)",""],["new","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-c-new","(p1 = v1)",""],["new","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-c-new","(p1 = v1)",""],["new","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Creates an X509 extension.\n<p>The extension may be created from <em>der</em> data or from an extension <em>oid</em> and <em>value</em> …\n"],["new","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-c-new","(p1 = v1, p2 = v2, p3 = v3, p4 = v4)",""],["new","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-c-new","(p1 = v1, p2 = v2)","<p>Creates a new Name.\n<p>A name may be created from a DER encoded string <em>der</em>, an Array representing a <em>distinguished_name</em> …\n"],["new","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-c-new","(p1 = v1)",""],["new","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-c-new","(*args)",""],["new","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-c-new","(*args)","<p>Creates a new X509::Store.\n"],["new","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Sets up a StoreContext for a verification of the X.509 certificate <em>cert</em>.\n"],["new","OpenStruct","OpenStruct.html#method-c-new","(hash=nil)","<p>Creates a new OpenStruct object.  By default, the resulting OpenStruct object will have no attributes. …\n"],["new","OpenURI::HTTPError","OpenURI/HTTPError.html#method-c-new","(message, io)",""],["new","OpenURI::HTTPRedirect","OpenURI/HTTPRedirect.html#method-c-new","(message, io, uri)",""],["new","OptionParser","OptionParser.html#method-i-new","()","<p>Pushes a new List.\n"],["new","OptionParser","OptionParser.html#method-c-new","(banner = nil, width = 32, indent = ' ' * 4)","<p>Initializes the instance and yields itself if called with a block.\n<p><code>banner</code> &mdash; Banner message.\n<p><code>width</code> &mdash; Summary …\n"],["new","OptionParser::Arguable","OptionParser/Arguable.html#method-c-new","(*args)",""],["new","OptionParser::List","OptionParser/List.html#method-c-new","()","<p>Just initializes all instance variables.\n"],["new","OptionParser::ParseError","OptionParser/ParseError.html#method-c-new","(*args, additional: nil)",""],["new","OptionParser::Switch","OptionParser/Switch.html#method-c-new","(pattern = nil, conv = nil, short = nil, long = nil, arg = nil, desc = ([] if short or long), block = nil, &_block)",""],["new","PStore","PStore.html#method-c-new","(file, thread_safe = false)","<p>To construct a PStore object, pass in the <em>file</em> path where you would like the data to be stored.\n<p>PStore …\n"],["new","Pathname","Pathname.html#method-c-new","(p1)","<p>Create a Pathname object from the given String (or String-like object). If <code>path</code> contains a NULL character …\n"],["new","Pool","Pool.html#method-c-new","(p1 = v1, p2 = v2, p3 = v3)",""],["new","PrettyPrint","PrettyPrint.html#method-c-new","(output=''.dup, maxwidth=79, newline=\"\\n\", &genspace)","<p>Creates a buffer for pretty printing.\n<p><code>output</code> is an output target. If it is not specified, &#39;&#39; is …\n"],["new","PrettyPrint::SingleLine","PrettyPrint/SingleLine.html#method-c-new","(output, maxwidth=nil, newline=nil)","<p>Create a PrettyPrint::SingleLine object\n<p>Arguments:\n<p><code>output</code> - String (or similar) to store rendered text. …\n"],["new","Prime::EratosthenesGenerator","Prime/EratosthenesGenerator.html#method-c-new","()",""],["new","Prime::EratosthenesSieve","Prime/EratosthenesSieve.html#method-c-new","()",""],["new","Prime::Generator23","Prime/Generator23.html#method-c-new","()",""],["new","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-c-new","(ubound = nil)",""],["new","Prime::TrialDivisionGenerator","Prime/TrialDivisionGenerator.html#method-c-new","()",""],["new","Proc","Proc.html#method-c-new","(*args)","<p>Creates a new Proc object, bound to the current context. Proc::new may be called without a block only …\n"],["new","Psych::ClassLoader::Restricted","Psych/ClassLoader/Restricted.html#method-c-new","(classes, symbols)",""],["new","Psych::Coder","Psych/Coder.html#method-c-new","(tag)",""],["new","Psych::DisallowedClass","Psych/DisallowedClass.html#method-c-new","(klass_name)",""],["new","Psych::Emitter","Psych/Emitter.html#method-c-new","(p1, p2 = v2)","<p>Create a new Psych::Emitter that writes to <code>io</code>.\n"],["new","Psych::Handler::DumperOptions","Psych/Handler/DumperOptions.html#method-c-new","()",""],["new","Psych::Handlers::Recorder","Psych/Handlers/Recorder.html#method-c-new","()",""],["new","Psych::Nodes::Alias","Psych/Nodes/Alias.html#method-c-new","(anchor)","<p>Create a new Alias that points to an <code>anchor</code>\n"],["new","Psych::Nodes::Document","Psych/Nodes/Document.html#method-c-new","(version = [], tag_directives = [], implicit = false)","<p>Create a new Psych::Nodes::Document object.\n<p><code>version</code> is a list indicating the YAML version. <code>tags_directives</code> …\n"],["new","Psych::Nodes::Mapping","Psych/Nodes/Mapping.html#method-c-new","(anchor = nil, tag = nil, implicit = true, style = BLOCK)","<p>Create a new Psych::Nodes::Mapping object.\n<p><code>anchor</code> is the anchor associated with the map or <code>nil</code>. <code>tag</code> is …\n"],["new","Psych::Nodes::Node","Psych/Nodes/Node.html#method-c-new","()","<p>Create a new Psych::Nodes::Node\n"],["new","Psych::Nodes::Scalar","Psych/Nodes/Scalar.html#method-c-new","(value, anchor = nil, tag = nil, plain = true, quoted = false, style = ANY)","<p>Create a new Psych::Nodes::Scalar object.\n<p><code>value</code> is the string value of the scalar <code>anchor</code> is an associated …\n"],["new","Psych::Nodes::Sequence","Psych/Nodes/Sequence.html#method-c-new","(anchor = nil, tag = nil, implicit = true, style = BLOCK)","<p>Create a new object representing a YAML sequence.\n<p><code>anchor</code> is the anchor associated with the sequence or …\n"],["new","Psych::Nodes::Stream","Psych/Nodes/Stream.html#method-c-new","(encoding = UTF8)","<p>Create a new Psych::Nodes::Stream node with an <code>encoding</code> that defaults to Psych::Nodes::Stream::UTF8. …\n"],["new","Psych::Parser","Psych/Parser.html#method-c-new","(handler = Handler.new)","<p>Creates a new Psych::Parser instance with <code>handler</code>.  YAML events will be called on <code>handler</code>.  See Psych::Parser …\n"],["new","Psych::ScalarScanner","Psych/ScalarScanner.html#method-c-new","(class_loader)","<p>Create a new scanner\n"],["new","Psych::Streaming::ClassMethods","Psych/Streaming/ClassMethods.html#method-i-new","(io)","<p>Create a new streaming emitter.  Emitter will print to <code>io</code>.  See Psych::Stream for an example.\n"],["new","Psych::SyntaxError","Psych/SyntaxError.html#method-c-new","(file, line, col, offset, problem, context)",""],["new","Psych::SyntaxError","Psych/SyntaxError.html#method-c-new","(file, line, col, offset, problem, context)",""],["new","Psych::TreeBuilder","Psych/TreeBuilder.html#method-c-new","()","<p>Create a new TreeBuilder instance\n"],["new","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-c-new","(block)",""],["new","Psych::Visitors::Emitter","Psych/Visitors/Emitter.html#method-c-new","(io, options = {})",""],["new","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-c-new","(ss, class_loader)",""],["new","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-c-new","(emitter, ss, options)",""],["new","Queue","Queue.html#method-c-new","()","<p>Creates a new queue instance.\n"],["new","RDoc::Alias","RDoc/Alias.html#method-c-new","(text, old_name, new_name, comment, singleton = false)","<p>Creates a new Alias with a token stream of <code>text</code> that aliases <code>old_name</code> to <code>new_name</code>, has <code>comment</code> and is …\n"],["new","RDoc::AnyMethod","RDoc/AnyMethod.html#method-c-new","(text, name)","<p>Creates a new AnyMethod with a token stream <code>text</code> and <code>name</code>\n"],["new","RDoc::Attr","RDoc/Attr.html#method-c-new","(text, name, rw, comment, singleton = false)","<p>Creates a new Attr with body <code>text</code>, <code>name</code>, read/write status <code>rw</code> and <code>comment</code>.  <code>singleton</code> marks this as a …\n"],["new","RDoc::ClassModule","RDoc/ClassModule.html#method-c-new","(name, superclass = nil)","<p>Creates a new ClassModule with <code>name</code> with optional <code>superclass</code>\n<p>This is a constructor for subclasses, and …\n"],["new","RDoc::CodeObject","RDoc/CodeObject.html#method-c-new","()","<p>Creates a new CodeObject that will document itself and its children\n"],["new","RDoc::Comment","RDoc/Comment.html#method-c-new","(text = nil, location = nil, language = nil)","<p>Creates a new comment with <code>text</code> that is found in the RDoc::TopLevel <code>location</code>.\n"],["new","RDoc::Constant","RDoc/Constant.html#method-c-new","(name, value, comment)","<p>Creates a new constant with <code>name</code>, <code>value</code> and <code>comment</code>\n"],["new","RDoc::Context","RDoc/Context.html#method-c-new","()","<p>Creates an unnamed empty context with public current visibility\n"],["new","RDoc::CrossReference","RDoc/CrossReference.html#method-c-new","(context)","<p>Allows cross-references to be created based on the given <code>context</code> (RDoc::Context).\n"],["new","RDoc::ERBIO","RDoc/ERBIO.html#method-c-new","(str, safe_level = nil, trim_mode = nil, eoutvar = 'io')","<p>Defaults <code>eoutvar</code> to &#39;io&#39;, otherwise is identical to ERB&#39;s initialize\n"],["new","RDoc::Markdown","RDoc/Markdown.html#method-c-new","(extensions = DEFAULT_EXTENSIONS, debug = false)","<p>Creates a new markdown parser that enables the given <code>extensions</code>.\n"],["new","RDoc::Markup","RDoc/Markup.html#method-c-new","(attribute_manager = nil)","<p>Take a block of text and use various heuristics to determine its structure (paragraphs, lists, and so …\n"],["new","RDoc::MethodAttr","RDoc/MethodAttr.html#method-c-new","(text, name)","<p>Creates a new MethodAttr from token stream <code>text</code> and method or attribute name <code>name</code>.\n<p>Usually this is called …\n"],["new","RDoc::Mixin","RDoc/Mixin.html#method-c-new","(name, comment)","<p>Creates a new Mixin for <code>name</code> with <code>comment</code>\n"],["new","RDoc::Parser","RDoc/Parser.html#method-c-new","(top_level, file_name, content, options, stats)","<p>Creates a new Parser storing <code>top_level</code>, <code>file_name</code>, <code>content</code>, <code>options</code> and <code>stats</code> in instance variables. …\n"],["new","RDoc::Parser::C","RDoc/Parser/C.html#method-c-new","(top_level, file_name, content, options, stats)","<p>Prepares for parsing a C file.  See RDoc::Parser#initialize for details on the arguments.\n"],["new","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-c-new","(code)",""],["new","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-c-new","(code)",""],["new","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-c-new","(top_level, file_name, content, options, stats)","<p>Creates a new Ruby parser.\n"],["new","RDoc::Parser::Simple","RDoc/Parser/Simple.html#method-c-new","(top_level, file_name, content, options, stats)","<p>Prepare to parse a plain file\n"],["new","RDoc::RDoc","RDoc/RDoc.html#method-c-new","()","<p>Creates a new RDoc::RDoc instance.  Call #document to parse files and generate documentation.\n"],["new","RDoc::Require","RDoc/Require.html#method-c-new","(name, comment)","<p>Creates a new Require that loads <code>name</code> with <code>comment</code>\n"],["new","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-c-new","(spec, generate_rdoc = false, generate_ri = true)","<p>Creates a new documentation generator for <code>spec</code>.  RDoc and ri data generation can be enabled or disabled …\n"],["new","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-c-new","(spec, generate_rdoc = false, generate_ri = true)","<p>Creates a new documentation generator for <code>spec</code>.  RDoc and ri data generation can be enabled or disabled …\n"],["new","RDoc::Servlet","RDoc/Servlet.html#method-c-new","(server, stores, cache, mount_path = nil, extra_doc_dirs = [])","<p>Creates a new WEBrick servlet.\n<p>Use <code>mount_path</code> when mounting the servlet somewhere other than /.\n<p>Use <code>extra_doc_dirs</code> …\n"],["new","RDoc::Stats","RDoc/Stats.html#method-c-new","(store, num_files, verbosity = 1)","<p>Creates a new Stats that will have <code>num_files</code>.  <code>verbosity</code> defaults to 1 which will create an RDoc::Stats::Normal …\n"],["new","RDoc::Store","RDoc/Store.html#method-c-new","(path = nil, type = nil)","<p>Creates a new Store of <code>type</code> that will load or save to <code>path</code>\n"],["new","RDoc::Store::MissingFileError","RDoc/Store/MissingFileError.html#method-c-new","(store, file, name)","<p>Creates a new MissingFileError for the missing <code>file</code> for the given <code>name</code> that should have been in the  …\n"],["new","RDoc::Task","RDoc/Task.html#method-c-new","(name = :rdoc)","<p>Create an RDoc task with the given name. See the RDoc::Task class overview for documentation.\n"],["new","RDoc::Task","RDoc/Task.html#method-c-new","(name = :rdoc)","<p>Create an RDoc task with the given name. See the RDoc::Task class overview for documentation.\n"],["new","RDoc::TomDoc","RDoc/TomDoc.html#method-c-new","()","<p>Creates a new TomDoc parser.  See also RDoc::Markup::parse\n"],["new","RDoc::TopLevel","RDoc/TopLevel.html#method-c-new","(absolute_name, relative_name = absolute_name)","<p>Creates a new TopLevel for the file at <code>absolute_name</code>.  If documentation is being generated outside the …\n"],["new","REXML::AttlistDecl","REXML/AttlistDecl.html#method-c-new","(source)","<p>Create an AttlistDecl, pulling the information from a Source.  Notice that this isn&#39;t very convenient; …\n"],["new","REXML::Attribute","REXML/Attribute.html#method-c-new","( first, second=nil, parent=nil )","<p>Constructor. FIXME: The parser doesn&#39;t catch illegal characters in attributes\n<p>first &mdash; Either: an Attribute …\n"],["new","REXML::Attributes","REXML/Attributes.html#method-c-new","(element)","<p>Constructor\n<p>element &mdash; the Element of which this is an Attribute\n\n"],["new","REXML::CData","REXML/CData.html#method-c-new","( first, whitespace=true, parent=nil )","\n<pre>Constructor.  CData is data between &lt;![CDATA[ ... ]]&gt;</pre>\n<p><em>Examples</em>\n\n<pre>CData.new( source )\nCData.new( &quot;Here is ...</pre>\n"],["new","REXML::Child","REXML/Child.html#method-c-new","( parent = nil )","<p>Constructor.  Any inheritors of this class should call super to make sure this method is called.\n<p>parent … &mdash; "],["new","REXML::Comment","REXML/Comment.html#method-c-new","( first, second = nil )","<p>Constructor.  The first argument can be one of three types: @param first If String, the contents of this …\n"],["new","REXML::DTD::ElementDecl","REXML/DTD/ElementDecl.html#method-c-new","(match)","<p>s*(((([“‘]).*?5)|*)*?)(/)?&gt;/um, true)\n"],["new","REXML::DTD::EntityDecl","REXML/DTD/EntityDecl.html#method-c-new","(src)","<p>&lt;!ENTITY name SYSTEM “…”&gt; &lt;!ENTITY name “…”&gt;\n"],["new","REXML::DTD::NotationDecl","REXML/DTD/NotationDecl.html#method-c-new","(src)",""],["new","REXML::Declaration","REXML/Declaration.html#method-c-new","(src)",""],["new","REXML::DocType","REXML/DocType.html#method-c-new","( first, parent=nil )","<p>Constructor\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">dt</span> = <span class=\"ruby-constant\">DocType</span>.<span class=\"ruby-identifier\">new</span>( <span class=\"ruby-string\">&#39;foo&#39;</span>, <span class=\"ruby-string\">&#39;-//I/Hate/External/IDs&#39;</span> )\n<span class=\"ruby-comment\"># &lt;!DOCTYPE foo &#39;-//I/Hate/External/IDs&#39;&gt; ...</span>\n</pre>\n"],["new","REXML::Document","REXML/Document.html#method-c-new","( source = nil, context = {} )","<p>Constructor @param source if supplied, must be a Document, String, or IO. Documents have their context …\n"],["new","REXML::Element","REXML/Element.html#method-c-new","( arg = UNDEFINED, parent=nil, context=nil )","<p>Constructor\n<p>arg &mdash; if not supplied, will be set to the default value. If a String, the name of this object …\n"],["new","REXML::ElementDecl","REXML/ElementDecl.html#method-c-new","( src )",""],["new","REXML::Elements","REXML/Elements.html#method-c-new","(parent)","<p>Constructor\n<p>parent &mdash; the parent Element\n\n"],["new","REXML::Entity","REXML/Entity.html#method-c-new","(stream, value=nil, parent=nil, reference=false)","<p>Create a new entity.  Simple entities can be constructed by passing a name, value to the constructor; …\n"],["new","REXML::ExternalEntity","REXML/ExternalEntity.html#method-c-new","( src )",""],["new","REXML::Formatters::Default","REXML/Formatters/Default.html#method-c-new","( ie_hack=false )","<p>Prints out the XML document with no formatting – except if ie_hack is set.\n<p>ie_hack &mdash; If set to true, then …\n\n"],["new","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-c-new","( indentation=2, ie_hack=false )","<p>Create a new pretty printer.\n<p>output &mdash; An object implementing &#39;&lt;&lt;(String)&#39;, to which the output …\n"],["new","REXML::Formatters::Transitive","REXML/Formatters/Transitive.html#method-c-new","( indentation=2, ie_hack=false )",""],["new","REXML::IOSource","REXML/IOSource.html#method-c-new","(arg, block_size=500, encoding=nil)","<p>block_size has been deprecated\n"],["new","REXML::Instruction","REXML/Instruction.html#method-c-new","(target, content=nil)","<p>Constructs a new Instruction @param target can be one of a number of things.  If String, then the target …\n"],["new","REXML::Light::Node","REXML/Light/Node.html#method-c-new","(node=nil)","<p>Create a new element.\n"],["new","REXML::NotationDecl","REXML/NotationDecl.html#method-c-new","(name, middle, pub, sys)",""],["new","REXML::Output","REXML/Output.html#method-c-new","(real_IO, encd=\"iso-8859-1\")",""],["new","REXML::Parent","REXML/Parent.html#method-c-new","(parent=nil)","<p>Constructor @param parent if supplied, will be set as the parent of this object\n"],["new","REXML::ParseException","REXML/ParseException.html#method-c-new","( message, source=nil, parser=nil, exception=nil )",""],["new","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-c-new","( source )",""],["new","REXML::Parsers::LightParser","REXML/Parsers/LightParser.html#method-c-new","(stream)",""],["new","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-c-new","(arg)","<p>The type of this event.  Will be one of :tag_start, :tag_end, :text, :processing_instruction, :comment, …\n"],["new","REXML::Parsers::PullParser","REXML/Parsers/PullParser.html#method-c-new","(stream)",""],["new","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-c-new","(source)",""],["new","REXML::Parsers::StreamParser","REXML/Parsers/StreamParser.html#method-c-new","(source, listener)",""],["new","REXML::Parsers::TreeParser","REXML/Parsers/TreeParser.html#method-c-new","( source, build_context = Document.new )",""],["new","REXML::Parsers::UltraLightParser","REXML/Parsers/UltraLightParser.html#method-c-new","(stream)",""],["new","REXML::ReferenceWriter","REXML/ReferenceWriter.html#method-c-new","(id_type, public_id_literal, system_literal, context=nil)",""],["new","REXML::Source","REXML/Source.html#method-c-new","(arg, encoding=nil)","<p>Constructor @param arg must be a String, and should be a valid XML document @param encoding if non-null, …\n"],["new","REXML::Text","REXML/Text.html#method-c-new","(arg, respect_whitespace=false, parent=nil, raw=nil, entity_filter=nil, illegal=NEEDS_A_SECOND_CHECK )","<p>Constructor <code>arg</code> if a String, the content is set to the String.  If a Text, the object is shallowly cloned. …\n"],["new","REXML::UndefinedNamespaceException","REXML/UndefinedNamespaceException.html#method-c-new","( prefix, source, parser )",""],["new","REXML::Validation::Choice","REXML/Validation/Choice.html#method-c-new","(context)",""],["new","REXML::Validation::Event","REXML/Validation/Event.html#method-c-new","(event_type, event_arg=nil )",""],["new","REXML::Validation::Interleave","REXML/Validation/Interleave.html#method-c-new","(context)",""],["new","REXML::Validation::OneOrMore","REXML/Validation/OneOrMore.html#method-c-new","(context)",""],["new","REXML::Validation::Ref","REXML/Validation/Ref.html#method-c-new","(value)",""],["new","REXML::Validation::RelaxNG","REXML/Validation/RelaxNG.html#method-c-new","(source)","<p>FIXME: Namespaces\n"],["new","REXML::Validation::State","REXML/Validation/State.html#method-c-new","( context )",""],["new","REXML::Validation::ValidationException","REXML/Validation/ValidationException.html#method-c-new","(msg)",""],["new","REXML::XMLDecl","REXML/XMLDecl.html#method-c-new","(version=DEFAULT_VERSION, encoding=nil, standalone=nil)",""],["new","REXML::XPathNode","REXML/XPathNode.html#method-c-new","(node, context=nil)",""],["new","REXML::XPathParser","REXML/XPathParser.html#method-c-new","(strict: false)",""],["new","RSS::Atom::Entry","RSS/Atom/Entry.html#method-c-new","(version=nil, encoding=nil, standalone=nil)","<p>Creates a new Atom Entry element.\n"],["new","RSS::Atom::Feed","RSS/Atom/Feed.html#method-c-new","(version=nil, encoding=nil, standalone=nil)","<p>Creates a new Atom feed\n"],["new","RSS::BaseParser","RSS/BaseParser.html#method-c-new","(rss)",""],["new","RSS::ConversionError","RSS/ConversionError.html#method-c-new","(string, to, from)",""],["new","RSS::Converter","RSS/Converter.html#method-c-new","(to_enc, from_enc=nil)",""],["new","RSS::Element","RSS/Element.html#method-c-new","(do_validate=true, attrs=nil)",""],["new","RSS::ITunesChannelModel::ITunesCategory","RSS/ITunesChannelModel/ITunesCategory.html#method-c-new","(*args)",""],["new","RSS::ITunesChannelModel::ITunesImage","RSS/ITunesChannelModel/ITunesImage.html#method-c-new","(*args)",""],["new","RSS::ITunesChannelModel::ITunesOwner","RSS/ITunesChannelModel/ITunesOwner.html#method-c-new","(*args)",""],["new","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-c-new","(*args)",""],["new","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-c-new","(*args)",""],["new","RSS::ImageItemModel::ImageItem","RSS/ImageItemModel/ImageItem.html#method-c-new","(*args)",""],["new","RSS::ListenerMixin","RSS/ListenerMixin.html#method-c-new","()",""],["new","RSS::Maker::Atom::Entry","RSS/Maker/Atom/Entry.html#method-c-new","(feed_version=\"1.0\")",""],["new","RSS::Maker::Atom::Feed","RSS/Maker/Atom/Feed.html#method-c-new","(feed_version=\"1.0\")",""],["new","RSS::Maker::Base","RSS/Maker/Base.html#method-c-new","(maker)",""],["new","RSS::Maker::ItemsBase","RSS/Maker/ItemsBase.html#method-c-new","(maker)",""],["new","RSS::Maker::RSS09","RSS/Maker/RSS09.html#method-c-new","(feed_version)",""],["new","RSS::Maker::RSS091","RSS/Maker/RSS091.html#method-c-new","(feed_version=\"0.91\")",""],["new","RSS::Maker::RSS092","RSS/Maker/RSS092.html#method-c-new","(feed_version=\"0.92\")",""],["new","RSS::Maker::RSS10","RSS/Maker/RSS10.html#method-c-new","(feed_version=\"1.0\")",""],["new","RSS::Maker::RSS20","RSS/Maker/RSS20.html#method-c-new","(feed_version=\"2.0\")",""],["new","RSS::Maker::RSSBase","RSS/Maker/RSSBase.html#method-c-new","(feed_version)",""],["new","RSS::MissingAttributeError","RSS/MissingAttributeError.html#method-c-new","(tag, attribute)",""],["new","RSS::MissingTagError","RSS/MissingTagError.html#method-c-new","(tag, parent)",""],["new","RSS::NSError","RSS/NSError.html#method-c-new","(tag, prefix, require_uri)",""],["new","RSS::NotAvailableValueError","RSS/NotAvailableValueError.html#method-c-new","(tag, value, attribute=nil)",""],["new","RSS::NotExpectedTagError","RSS/NotExpectedTagError.html#method-c-new","(tag, uri, parent)",""],["new","RSS::NotSetError","RSS/NotSetError.html#method-c-new","(name, variables)",""],["new","RSS::NotValidXMLParser","RSS/NotValidXMLParser.html#method-c-new","(parser)",""],["new","RSS::NotWellFormedError","RSS/NotWellFormedError.html#method-c-new","(line=nil, element=nil)","<p>Create a new NotWellFormedError for an error at <code>line</code> in <code>element</code>.  If a block is given the return value …\n"],["new","RSS::OverlappedPrefixError","RSS/OverlappedPrefixError.html#method-c-new","(prefix)",""],["new","RSS::Parser","RSS/Parser.html#method-c-new","(rss, parser_class=self.class.default_parser)",""],["new","RSS::RDF","RSS/RDF.html#method-c-new","(version=nil, encoding=nil, standalone=nil)",""],["new","RSS::RDF::Bag","RSS/RDF/Bag.html#method-c-new","(*args)",""],["new","RSS::RDF::Bag","RSS/RDF/Bag.html#method-c-new","(*args)",""],["new","RSS::RDF::Channel","RSS/RDF/Channel.html#method-c-new","(*args)",""],["new","RSS::RDF::Channel::Image","RSS/RDF/Channel/Image.html#method-c-new","(*args)",""],["new","RSS::RDF::Channel::Items","RSS/RDF/Channel/Items.html#method-c-new","(*args)",""],["new","RSS::RDF::Channel::Textinput","RSS/RDF/Channel/Textinput.html#method-c-new","(*args)",""],["new","RSS::RDF::Image","RSS/RDF/Image.html#method-c-new","(*args)",""],["new","RSS::RDF::Item","RSS/RDF/Item.html#method-c-new","(*args)",""],["new","RSS::RDF::Li","RSS/RDF/Li.html#method-c-new","(*args)",""],["new","RSS::RDF::Li","RSS/RDF/Li.html#method-c-new","(*args)",""],["new","RSS::RDF::Li","RSS/RDF/Li.html#method-c-new","(*args)",""],["new","RSS::RDF::Seq","RSS/RDF/Seq.html#method-c-new","(*args)",""],["new","RSS::RDF::Seq","RSS/RDF/Seq.html#method-c-new","(*args)",""],["new","RSS::RDF::Textinput","RSS/RDF/Textinput.html#method-c-new","(*args)",""],["new","RSS::RootElementMixin","RSS/RootElementMixin.html#method-c-new","(feed_version, version=nil, encoding=nil, standalone=nil)",""],["new","RSS::Rss","RSS/Rss.html#method-c-new","(feed_version, version=nil, encoding=nil, standalone=nil)",""],["new","RSS::Rss::Channel::Cloud","RSS/Rss/Channel/Cloud.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::Image","RSS/Rss/Channel/Image.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::Item::Category","RSS/Rss/Channel/Item/Category.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::Item::Enclosure","RSS/Rss/Channel/Item/Enclosure.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::Item::Guid","RSS/Rss/Channel/Item/Guid.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::Item::Source","RSS/Rss/Channel/Item/Source.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::SkipDays::Day","RSS/Rss/Channel/SkipDays/Day.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::SkipHours::Hour","RSS/Rss/Channel/SkipHours/Hour.html#method-c-new","(*args)",""],["new","RSS::Rss::Channel::TextInput","RSS/Rss/Channel/TextInput.html#method-c-new","(*args)",""],["new","RSS::TaxonomyTopicModel::TaxonomyTopic","RSS/TaxonomyTopicModel/TaxonomyTopic.html#method-c-new","(*args)",""],["new","RSS::TaxonomyTopicsModel::TaxonomyTopics","RSS/TaxonomyTopicsModel/TaxonomyTopics.html#method-c-new","(*args)",""],["new","RSS::TooMuchTagError","RSS/TooMuchTagError.html#method-c-new","(tag, parent)",""],["new","RSS::UnknownConversionMethodError","RSS/UnknownConversionMethodError.html#method-c-new","(to, from)",""],["new","RSS::UnknownTagError","RSS/UnknownTagError.html#method-c-new","(tag, uri)",""],["new","RSS::UnsupportedMakerVersionError","RSS/UnsupportedMakerVersionError.html#method-c-new","(version)",""],["new","RSS::XML::Element","RSS/XML/Element.html#method-c-new","(name, prefix=nil, uri=nil, attributes={}, children=[])",""],["new","RSS::XMLParserNotFound","RSS/XMLParserNotFound.html#method-c-new","()",""],["new","RSS::XMLStyleSheet","RSS/XMLStyleSheet.html#method-c-new","(*attrs)",""],["new","RSS::XMLStyleSheetMixin","RSS/XMLStyleSheetMixin.html#method-c-new","(*args)",""],["new","Racc::ActionTable","Racc/ActionTable.html#method-c-new","(rt, st)",""],["new","Racc::DebugFlags","Racc/DebugFlags.html#method-c-new","(parse = false, rule = false, token = false, state = false, la = false, prec = false, conf = false)",""],["new","Racc::Goto","Racc/Goto.html#method-c-new","(ident, sym, from, to)",""],["new","Racc::Grammar","Racc/Grammar.html#method-c-new","(debug_flags = DebugFlags.new)",""],["new","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-c-new","()",""],["new","Racc::Grammar::PrecedenceDefinitionEnv","Racc/Grammar/PrecedenceDefinitionEnv.html#method-c-new","(g)",""],["new","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-c-new","(debug_flags = DebugFlags.new)",""],["new","Racc::GrammarFileParser::Result","Racc/GrammarFileParser/Result.html#method-c-new","(grammar)",""],["new","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-c-new","(str, filename = '-')",""],["new","Racc::ISet","Racc/ISet.html#method-c-new","(a = [])",""],["new","Racc::Item","Racc/Item.html#method-c-new","(rule, la)",""],["new","Racc::LocationPointer","Racc/LocationPointer.html#method-c-new","(rule, i, sym)",""],["new","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-c-new","(states, debug_flags = DebugFlags.new)",""],["new","Racc::OrMark","Racc/OrMark.html#method-c-new","(lineno)",""],["new","Racc::ParserClassGenerator","Racc/ParserClassGenerator.html#method-c-new","(states)",""],["new","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-c-new","(states, params)",""],["new","Racc::ParserFileGenerator::Params","Racc/ParserFileGenerator/Params.html#method-c-new","()",""],["new","Racc::Prec","Racc/Prec.html#method-c-new","(symbol, lineno)",""],["new","Racc::RRconflict","Racc/RRconflict.html#method-c-new","(sid, high, low, tok)",""],["new","Racc::Reduce","Racc/Reduce.html#method-c-new","(rule)",""],["new","Racc::Rule","Racc/Rule.html#method-c-new","(target, syms, act)",""],["new","Racc::SRconflict","Racc/SRconflict.html#method-c-new","(sid, shift, reduce)",""],["new","Racc::Shift","Racc/Shift.html#method-c-new","(goto)",""],["new","Racc::SourceText","Racc/SourceText.html#method-c-new","(text, filename, lineno)",""],["new","Racc::State","Racc/State.html#method-c-new","(ident, core)",""],["new","Racc::StateTransitionTable","Racc/StateTransitionTable.html#method-c-new","(states)",""],["new","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-c-new","(states)",""],["new","Racc::States","Racc/States.html#method-c-new","(grammar, debug_flags = DebugFlags.new)",""],["new","Racc::Sym","Racc/Sym.html#method-c-new","(value, dummyp)",""],["new","Racc::SymbolTable","Racc/SymbolTable.html#method-c-new","()",""],["new","Racc::UserAction","Racc/UserAction.html#method-c-new","(src, proc)",""],["new","Random","Random.html#method-c-new","(*args)","<p>Creates a new PRNG using <code>seed</code> to set the initial state. If <code>seed</code> is omitted, the generator is initialized …\n"],["new","Range","Range.html#method-c-new","(p1, p2, p3 = v3)","<p>Constructs a range using the given <code>begin</code> and <code>end</code>. If the <code>exclude_end</code> parameter is omitted or is <code>false</code> …\n"],["new","Regexp","Regexp.html#method-c-new","(*args)","<p>Constructs a new regular expression from <code>pattern</code>, which can be either a String or a Regexp (in which …\n"],["new","Reline::Core","Reline/Core.html#method-c-new","()",""],["new","Resolv","Resolv.html#method-c-new","(resolvers=[Hosts.new, DNS.new])","<p>Creates a new Resolv using <code>resolvers</code>.\n"],["new","Resolv::DNS","Resolv/DNS.html#method-c-new","(config_info=nil)","<p>Creates a new DNS resolver.\n<p><code>config_info</code> can be:\n<p>nil &mdash; Uses /etc/resolv.conf.\n"],["new","Resolv::DNS::Resource::DomainName","Resolv/DNS/Resource/DomainName.html#method-c-new","(name)","<p>Creates a new DomainName from <code>name</code>.\n"],["new","Resolv::DNS::Resource::Generic","Resolv/DNS/Resource/Generic.html#method-c-new","(data)","<p>Creates a new generic resource.\n"],["new","Resolv::DNS::Resource::HINFO","Resolv/DNS/Resource/HINFO.html#method-c-new","(cpu, os)","<p>Creates a new HINFO running <code>os</code> on <code>cpu</code>.\n"],["new","Resolv::DNS::Resource::IN::A","Resolv/DNS/Resource/IN/A.html#method-c-new","(address)","<p>Creates a new A for <code>address</code>.\n"],["new","Resolv::DNS::Resource::IN::AAAA","Resolv/DNS/Resource/IN/AAAA.html#method-c-new","(address)","<p>Creates a new AAAA for <code>address</code>.\n"],["new","Resolv::DNS::Resource::IN::SRV","Resolv/DNS/Resource/IN/SRV.html#method-c-new","(priority, weight, port, target)","<p>Create a SRV resource record.\n<p>See the documentation for #priority, #weight, #port and #target for <code>priority</code> …\n"],["new","Resolv::DNS::Resource::IN::WKS","Resolv/DNS/Resource/IN/WKS.html#method-c-new","(address, protocol, bitmap)",""],["new","Resolv::DNS::Resource::LOC","Resolv/DNS/Resource/LOC.html#method-c-new","(version, ssize, hprecision, vprecision, latitude, longitude, altitude)",""],["new","Resolv::DNS::Resource::MINFO","Resolv/DNS/Resource/MINFO.html#method-c-new","(rmailbx, emailbx)",""],["new","Resolv::DNS::Resource::MX","Resolv/DNS/Resource/MX.html#method-c-new","(preference, exchange)","<p>Creates a new MX record with <code>preference</code>, accepting mail at <code>exchange</code>.\n"],["new","Resolv::DNS::Resource::SOA","Resolv/DNS/Resource/SOA.html#method-c-new","(mname, rname, serial, refresh, retry_, expire, minimum)","<p>Creates a new SOA record.  See the attr documentation for the details of each argument.\n"],["new","Resolv::DNS::Resource::TXT","Resolv/DNS/Resource/TXT.html#method-c-new","(first_string, *rest_strings)",""],["new","Resolv::Hosts","Resolv/Hosts.html#method-c-new","(filename = DefaultFileName)","<p>Creates a new Resolv::Hosts, using <code>filename</code> for its data source.\n"],["new","Resolv::LOC::Alt","Resolv/LOC/Alt.html#method-c-new","(altitude)",""],["new","Resolv::LOC::Coord","Resolv/LOC/Coord.html#method-c-new","(coordinates,orientation)",""],["new","Resolv::LOC::Size","Resolv/LOC/Size.html#method-c-new","(scalar)",""],["new","Resolv::MDNS","Resolv/MDNS.html#method-c-new","(config_info=nil)","<p>Creates a new one-shot Multicast DNS (mDNS) resolver.\n<p><code>config_info</code> can be:\n<p>nil &mdash; Uses the default mDNS addresses …\n"],["new","Rinda::DRbObjectTemplate","Rinda/DRbObjectTemplate.html#method-c-new","(uri=nil, ref=nil)","<p>Creates a new DRbObjectTemplate that will match against <code>uri</code> and <code>ref</code>.\n"],["new","Rinda::NotifyTemplateEntry","Rinda/NotifyTemplateEntry.html#method-c-new","(place, event, tuple, expires=nil)","<p>Creates a new NotifyTemplateEntry that watches <code>place</code> for +event+s that match <code>tuple</code>.\n"],["new","Rinda::RingFinger","Rinda/RingFinger.html#method-c-new","(broadcast_list=@@broadcast_list, port=Ring_PORT)","<p>Creates a new RingFinger that will look for RingServers at <code>port</code> on the addresses in <code>broadcast_list</code>.\n<p>If …\n"],["new","Rinda::RingProvider","Rinda/RingProvider.html#method-c-new","(klass, front, desc, renewer = nil)","<p>Creates a RingProvider that will provide a <code>klass</code> service running on <code>front</code>, with a <code>description</code>.  <code>renewer</code> …\n"],["new","Rinda::RingServer","Rinda/RingServer.html#method-c-new","(ts, addresses=[Socket::INADDR_ANY], port=Ring_PORT)","<p>Advertises <code>ts</code> on the given <code>addresses</code> at <code>port</code>.\n<p>If <code>addresses</code> is omitted only the UDP broadcast address is …\n"],["new","Rinda::SimpleRenewer","Rinda/SimpleRenewer.html#method-c-new","(sec=180)","<p>Creates a new SimpleRenewer that keeps an object alive for another <code>sec</code> seconds.\n"],["new","Rinda::Tuple","Rinda/Tuple.html#method-c-new","(ary_or_hash)","<p>Creates a new Tuple from <code>ary_or_hash</code> which must be an Array or Hash.\n"],["new","Rinda::TupleBag::TupleBin","Rinda/TupleBag/TupleBin.html#method-c-new","()",""],["new","Rinda::TupleEntry","Rinda/TupleEntry.html#method-c-new","(ary, sec=nil)","<p>Creates a TupleEntry based on <code>ary</code> with an optional renewer or expiry time <code>sec</code>.\n<p>A renewer must implement …\n"],["new","Rinda::TupleSpace","Rinda/TupleSpace.html#method-c-new","(period=60)","<p>Creates a new TupleSpace.  <code>period</code> is used to control how often to look for dead tuples after modifications …\n"],["new","Rinda::TupleSpaceProxy","Rinda/TupleSpaceProxy.html#method-c-new","(ts)","<p>Creates a new TupleSpaceProxy to wrap <code>ts</code>.\n"],["new","Rinda::WaitTemplateEntry","Rinda/WaitTemplateEntry.html#method-c-new","(place, ary, expires=nil)",""],["new","Ripper","Ripper.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Create a new Ripper object. <em>src</em> must be a String, an IO, or an Object which has #gets method.\n<p>This method …\n"],["new","Ripper::Filter","Ripper/Filter.html#method-c-new","(src, filename = '-', lineno = 1)","<p>Creates a new Ripper::Filter instance, passes parameters <code>src</code>, <code>filename</code>, and <code>lineno</code> to Ripper::Lexer.new …\n"],["new","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-new","(p1, *args, p3 = {})","<p>Takes <code>source</code>, a String of Ruby code and compiles it to an InstructionSequence.\n<p>Optionally takes <code>file</code>, …\n"],["new","SDBM","SDBM.html#method-c-new","(p1, p2 = v2)","<p>Creates a new database handle by opening the given <code>filename</code>. SDBM actually uses two physical files, with …\n"],["new","SOCKSSocket","SOCKSSocket.html#method-c-new","(host, serv)",""],["new","SOCKSSocket","SOCKSSocket.html#method-c-new","(p1, p2)","<p>Opens a SOCKS connection to <code>host</code> via the SOCKS server.\n<p>The SOCKS server configuration varies by implementation …\n"],["new","Set","Set.html#method-c-new","(enum = nil)","<p>Creates a new set containing the elements of the given enumerable object.\n<p>If a block is given, the elements …\n"],["new","SignalException","SignalException.html#method-c-new","(*args)","<p>Construct a new SignalException object.  <code>sig_name</code> should be a known signal name.\n"],["new","SizedQueue","SizedQueue.html#method-c-new","(p1)","<p>Creates a fixed-length queue with a maximum size of <code>max</code>.\n"],["new","Socket","Socket.html#method-c-new","(p1, p2, p3 = v3)","<p>Creates a new socket object.\n<p><em>domain</em> should be a communications domain such as: :INET, :INET6, :UNIX, etc. …\n"],["new","Socket::AncillaryData","Socket/AncillaryData.html#method-c-new","(p1, p2, p3, p4)","<p><em>family</em> should be an integer, a string or a symbol.\n<p>Socket::AF_INET, “AF_INET”, “INET”, …\n"],["new","Socket::Option","Socket/Option.html#method-c-new","(p1, p2, p3, p4)","<p>Returns a new Socket::Option object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">sockopt</span> = <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET</span>, <span class=\"ruby-value\">:SOCKET</span>, <span class=\"ruby-value\">:KEEPALIVE</span>, [<span class=\"ruby-value\">1</span>].<span class=\"ruby-identifier\">pack</span>(<span class=\"ruby-string\">&quot;i&quot;</span>)) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["new","Socket::UDPSource","Socket/UDPSource.html#method-c-new","(remote_address, local_address, &reply_proc)","<p><code>remote_address</code> is an Addrinfo object.\n<p><code>local_address</code> is an Addrinfo object.\n<p><code>reply_proc</code> is a Proc used to …\n"],["new","String","String.html#method-c-new","(p1 = v1, p2 = {})","<p>Returns a new string object containing a copy of <em>str</em>.\n<p>The optional <em>encoding</em> keyword argument specifies …\n"],["new","StringIO","StringIO.html#method-c-new","(*args)","<p>Creates new StringIO instance from with <em>string</em> and <em>mode</em>.\n"],["new","StringScanner","StringScanner.html#method-c-new","(p1, p2 = v2)","<p>Creates a new StringScanner object to scan over the given <code>string</code>.\n<p>If <code>fixed_anchor</code> is <code>true</code>, <code>\\A</code> always matches …\n"],["new","Struct","Struct.html#method-c-new","(*args)","<p>The first two forms are used to create a new Struct subclass <code>class_name</code> that can contain a value for …\n"],["new","SyntaxError","SyntaxError.html#method-c-new","(*args)","<p>Construct a SyntaxError exception.\n"],["new","Syslog::Logger","Syslog/Logger.html#method-c-new","(program_name = 'ruby', facility = nil)","<p>Fills in variables for Logger compatibility.  If this is the first instance of Syslog::Logger, <code>program_name</code> …\n"],["new","SystemCallError","SystemCallError.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>If <em>errno</em> corresponds to a known system error code, constructs the appropriate Errno class for that error, …\n"],["new","SystemExit","SystemExit.html#method-c-new","(*args)","<p>Create a new <code>SystemExit</code> exception with the given status and message. Status is true, false, or an integer. …\n"],["new","TCPServer","TCPServer.html#method-c-new","(p1 = v1, p2)","<p>Creates a new server socket bound to <em>port</em>.\n<p>If <em>hostname</em> is given, the socket is bound to it.\n\n<pre>serv = TCPServer.new(&quot;127.0.0.1&quot;, ...</pre>\n"],["new","TCPSocket","TCPSocket.html#method-c-new","(p1, p2, p3 = v3, p4 = v4)","<p>Opens a TCP connection to <code>remote_host</code> on <code>remote_port</code>.  If <code>local_host</code> and <code>local_port</code> are specified, then …\n"],["new","TCPSocket","TCPSocket.html#method-c-new","(host, serv, *rest)",""],["new","TempIO","TempIO.html#method-c-new","(string = '')","<p>Creates a new TempIO that will be initialized to contain <code>string</code>.\n"],["new","Tempfile","Tempfile.html#method-c-new","(basename=\"\", tmpdir=nil, mode: 0, **options)","<p>Creates a temporary file with permissions 0600 (= only readable and writable by the owner) and opens …\n"],["new","Thread","Thread.html#method-c-new","(*args)","<p>Creates a new thread executing the given block.\n<p>Any <code>args</code> given to ::new will be passed to the block:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">arr</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["new","Time","Time.html#method-c-new","(*args)","<p>Returns a Time object.\n<p>It is initialized to the current system time if no argument is given.\n<p><strong>Note:</strong> The …\n"],["new","TracePoint","TracePoint.html#method-c-new","(*events)","<p>Returns a new TracePoint object, not enabled by default.\n<p>Next, in order to activate the trace, you must …\n"],["new","UDPSocket","UDPSocket.html#method-c-new","(p1 = v1)","<p>Creates a new UDPSocket object.\n<p><em>address_family</em> should be an integer, a string or a symbol: Socket::AF_INET …\n"],["new","UNIXServer","UNIXServer.html#method-c-new","(p1)","<p>Creates a new UNIX server socket bound to <em>path</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;socket&#39;</span>\n\n<span class=\"ruby-identifier\">serv</span> = <span class=\"ruby-constant\">UNIXServer</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>)\n<span class=\"ruby-identifier\">s</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["new","UNIXSocket","UNIXSocket.html#method-c-new","(p1)","<p>Creates a new UNIX client socket connected to <em>path</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;socket&#39;</span>\n\n<span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">UNIXSocket</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["new","URI::FTP","URI/FTP.html#method-c-new","(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = nil, arg_check = false)","<p>Description\n<p>Creates a new URI::FTP object from generic URL components with no syntax checking.\n<p>Unlike build(), …\n"],["new","URI::Generic","URI/Generic.html#method-c-new","(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser = DEFAULT_PARSER, arg_check = false)","<p>Args\n<p><code>scheme</code> &mdash; Protocol scheme, i.e. &#39;http&#39;,&#39;ftp&#39;,&#39;mailto&#39; and so on.\n<p><code>userinfo</code> &mdash; User …\n"],["new","URI::LDAP","URI/LDAP.html#method-c-new","(*arg)","<p>Description\n<p>Creates a new URI::LDAP object from generic URI components as per RFC 2396. No LDAP-specific …\n"],["new","URI::MailTo","URI/MailTo.html#method-c-new","(*arg)","<p>Description\n<p>Creates a new URI::MailTo object from generic URL components with no syntax checking.\n<p>This …\n"],["new","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-c-new","(opts = {})","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Parser</span>.<span class=\"ruby-identifier\">new</span>([<span class=\"ruby-identifier\">opts</span>])\n</pre>\n<p>Args\n"],["new","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-c-new","(opts = {})","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Parser</span>.<span class=\"ruby-identifier\">new</span>([<span class=\"ruby-identifier\">opts</span>])\n</pre>\n<p>Args\n"],["new","UncaughtThrowError","UncaughtThrowError.html#method-c-new","(*args)","<p>Document-class: UncaughtThrowError\n<p>Raised when <code>throw</code> is called with a <em>tag</em> which does not have corresponding …\n"],["new","UndefinedCommandError","UndefinedCommandError.html#method-c-new","(command, all_commands, namespace)",""],["new","UndefinedCommandError","UndefinedCommandError.html#method-c-new","(command, all_commands, namespace)",""],["new","UndefinedCommandError::SpellChecker","UndefinedCommandError/SpellChecker.html#method-c-new","(error)",""],["new","UnknownArgumentError","UnknownArgumentError.html#method-c-new","(switches, unknown)",""],["new","UnknownArgumentError::SpellChecker","UnknownArgumentError/SpellChecker.html#method-c-new","(error)",""],["new","Vector","Vector.html#method-c-new","(array)","<p>Vector.new is private; use Vector[] or Vector.elements to create.\n"],["new","WEBrick::BasicLog","WEBrick/BasicLog.html#method-c-new","(log_file=nil, level=nil)","<p>Initializes a new logger for <code>log_file</code> that outputs messages at <code>level</code> or higher.  <code>log_file</code> can be a filename, …\n"],["new","WEBrick::CGI","WEBrick/CGI.html#method-c-new","(*args)","<p>Creates a new CGI interface.\n<p>The first argument in <code>args</code> is a configuration hash which would update WEBrick::Config::HTTP …\n"],["new","WEBrick::Cookie","WEBrick/Cookie.html#method-c-new","(name, value)","<p>Creates a new cookie with the given <code>name</code> and <code>value</code>\n"],["new","WEBrick::GenericServer","WEBrick/GenericServer.html#method-c-new","(config={}, default=Config::General)","<p>Creates a new generic server from <code>config</code>.  The default configuration comes from <code>default</code>.\n"],["new","WEBrick::HTTPAuth::BasicAuth","WEBrick/HTTPAuth/BasicAuth.html#method-c-new","(config, default=Config::BasicAuth)","<p>Creates a new BasicAuth instance.\n<p>See WEBrick::Config::BasicAuth for default configuration entries\n<p>You …\n"],["new","WEBrick::HTTPAuth::DigestAuth","WEBrick/HTTPAuth/DigestAuth.html#method-c-new","(config, default=Config::DigestAuth)","<p>Creates a new DigestAuth instance.  Be sure to use the same DigestAuth instance for multiple requests …\n"],["new","WEBrick::HTTPAuth::Htdigest","WEBrick/HTTPAuth/Htdigest.html#method-c-new","(path)","<p>Open a digest password database at <code>path</code>\n"],["new","WEBrick::HTTPAuth::Htgroup","WEBrick/HTTPAuth/Htgroup.html#method-c-new","(path)","<p>Open a group database at <code>path</code>\n"],["new","WEBrick::HTTPAuth::Htpasswd","WEBrick/HTTPAuth/Htpasswd.html#method-c-new","(path, password_hash: nil)","<p>Open a password database at <code>path</code>\n"],["new","WEBrick::HTTPProxyServer","WEBrick/HTTPProxyServer.html#method-c-new","(config={}, default=Config::HTTP)","<p>Proxy server configurations.  The proxy server handles the following configuration items in addition …\n"],["new","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-c-new","(config)","<p>Creates a new HTTP request.  WEBrick::Config::HTTP is the default configuration.\n"],["new","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-c-new","(config)","<p>Creates a new HTTP response object.  WEBrick::Config::HTTP is the default configuration.\n"],["new","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-c-new","(config={}, default=Config::HTTP)","<p>Creates a new HTTP server according to <code>config</code>\n<p>An HTTP server uses the following attributes:\n<p>:AccessLog … &mdash; "],["new","WEBrick::HTTPServlet::AbstractServlet","WEBrick/HTTPServlet/AbstractServlet.html#method-c-new","(server, *options)","<p>Initializes a new servlet for <code>server</code> using <code>options</code> which are stored as-is in +@options+.  +@logger+ is …\n"],["new","WEBrick::HTTPServlet::CGIHandler","WEBrick/HTTPServlet/CGIHandler.html#method-c-new","(server, name)","<p>Creates a new CGI script servlet for the script at <code>name</code>\n"],["new","WEBrick::HTTPServlet::DefaultFileHandler","WEBrick/HTTPServlet/DefaultFileHandler.html#method-c-new","(server, local_path)","<p>Creates a DefaultFileHandler instance for the file at <code>local_path</code>.\n"],["new","WEBrick::HTTPServlet::ERBHandler","WEBrick/HTTPServlet/ERBHandler.html#method-c-new","(server, name)","<p>Creates a new ERBHandler on <code>server</code> that will evaluate and serve the ERB file <code>name</code>\n"],["new","WEBrick::HTTPServlet::FileHandler","WEBrick/HTTPServlet/FileHandler.html#method-c-new","(server, root, options={}, default=Config::FileHandler)","<p>Creates a FileHandler servlet on <code>server</code> that serves files starting at directory <code>root</code>\n<p><code>options</code> may be a …\n"],["new","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-c-new","(*args)","<p>Creates a new FormData object.\n<p><code>args</code> is an Array of form data entries.  One FormData will be created for …\n"],["new","WEBrick::HTTPVersion","WEBrick/HTTPVersion.html#method-c-new","(version)","<p>Creates a new HTTPVersion from <code>version</code>.\n"],["new","WEBrick::Log","WEBrick/Log.html#method-c-new","(log_file=nil, level=nil)","<p>Same as BasicLog#initialize\n<p>You can set the timestamp format through #time_format\n"],["new","WEBrick::SNIRequest","WEBrick/SNIRequest.html#method-c-new","(sslsocket, hostname)","<p>Creates a new SNIRequest.\n"],["new","WEBrick::Utils::TimeoutHandler","WEBrick/Utils/TimeoutHandler.html#method-c-new","()","<p>Creates a new TimeoutHandler.  You should use ::register and ::cancel instead of creating the timeout …\n"],["new","WIN32OLE","WIN32OLE.html#method-c-new","(p1, p2 = v2, *args, p4 = {})","<p>Returns a new WIN32OLE object(OLE Automation object). The first argument server specifies OLE Automation …\n"],["new","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-c-new","(*args)","<p>Returns OLE event object. The first argument specifies WIN32OLE object. The second argument specifies …\n"],["new","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-c-new","(p1, p2)","<p>Returns a new WIN32OLE_METHOD object which represents the information about OLE method. The first argument …\n"],["new","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-c-new","(p1, p2)","<p>Returns WIN32OLE_PARAM object which represents OLE parameter information. 1st argument should be WIN32OLE_METHOD …\n"],["new","WIN32OLE_RECORD","WIN32OLE_RECORD.html#method-c-new","(p1, p2)","<p>Returns WIN32OLE_RECORD object. The first argument is struct name (String or Symbol). The second parameter …\n"],["new","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-c-new","(p1, p2)","<p>Returns a new WIN32OLE_TYPE object. The first argument <em>typelib</em> specifies OLE type library name. The second …\n"],["new","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-c-new","(*args)","<p>Returns a new WIN32OLE_TYPELIB object.\n<p>The first argument <em>typelib</em>  specifies OLE type library name or …\n"],["new","WIN32OLE_VARIANT","WIN32OLE_VARIANT.html#method-c-new","(*args)","<p>Returns Ruby object wrapping OLE variant. The first argument specifies Ruby object to convert OLE variant …\n"],["new","WeakRef","WeakRef.html#method-c-new","(orig)","<p>Creates a weak reference to <code>orig</code>\n<p>Raises an ArgumentError if the given <code>orig</code> is immutable, such as Symbol …\n"],["new","XMP","XMP.html#method-c-new","(bind = nil)","<p>Creates a new XMP object.\n<p>The top-level binding or, optional <code>bind</code> parameter will be used when creating …\n"],["new","XMP::StringInputMethod","XMP/StringInputMethod.html#method-c-new","()","<p>Creates a new StringInputMethod object\n"],["new","YAML::Store","YAML/Store.html#method-c-new","( *o )","<p>Creates a new YAML::Store object, which will store data in <code>file_name</code>. If the file does not already exist, …\n"],["new","Zlib::Deflate","Zlib/Deflate.html#method-c-new","(p1 = v1, p2 = v2, p3 = v3, p4 = v4)","<p>Creates a new deflate stream for compression. If a given argument is nil, the default value of that argument …\n"],["new","Zlib::GzipReader","Zlib/GzipReader.html#method-c-new","(p1, p2 = {})","<p>Creates a GzipReader object associated with <code>io</code>. The GzipReader object reads gzipped data from <code>io</code>, and …\n"],["new","Zlib::GzipWriter","Zlib/GzipWriter.html#method-c-new","(p1, p2 = v2, p3 = v3)","<p>Creates a GzipWriter object associated with <code>io</code>. <code>level</code> and <code>strategy</code> should be the same as the arguments …\n"],["new","Zlib::Inflate","Zlib/Inflate.html#method-c-new","(p1 = v1)","<p>Creates a new inflate stream for decompression.  <code>window_bits</code> sets the size of the history buffer and …\n"],["new!","Date","Date.html#method-c-new-21","(p1 = v1, p2 = v2, p3 = v3)",""],["new_alias_name","IRB::MethodExtender","IRB/MethodExtender.html#method-i-new_alias_name","(name, prefix = \"__alias_of__\", postfix = \"__\")","<p>Returns a unique method name to use as an alias for the given <code>name</code>.\n<p>Usually returns <code>#{prefix}#{name}#{postfix}&lt;num&gt;</code> …\n"],["new_comment","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-new_comment","(comment, line_no = nil)","<p>Creates a comment with the correct format\n"],["new_cond","Monitor","Monitor.html#method-i-new_cond","()",""],["new_cond","MonitorMixin","MonitorMixin.html#method-i-new_cond","()","<p>Creates a new MonitorMixin::ConditionVariable associated with the Monitor object.\n"],["new_default_spec","Gem::TestCase","Gem/TestCase.html#method-i-new_default_spec","(name, version, deps = nil, *files)",""],["new_internet_message_io","Net::SMTP","Net/SMTP.html#method-i-new_internet_message_io","(s)",""],["new_ntoh","IPAddr","IPAddr.html#method-c-new_ntoh","(addr)","<p>Creates a new ipaddr containing the given network byte ordered string form of an IP address.\n"],["new_offset","DateTime","DateTime.html#method-i-new_offset","(p1 = v1)","<p>Duplicates self and resets its offset.\n\n<pre>d = DateTime.new(2001,2,3,4,5,6,&#39;-02:00&#39;)\n                     ...</pre>\n"],["new_platform?","Bundler::Definition","Bundler/Definition.html#method-i-new_platform-3F","()",""],["new_seed","Random","Random.html#method-c-new_seed","()","<p>Returns an arbitrary seed value. This is used by Random.new when no seed value is specified as an argument. …\n"],["new_spec_satisfied?","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-new_spec_satisfied-3F","()","<p>@return [Boolean] whether the current spec is satisfied as a new possibility.\n"],["new_specs","Bundler::Definition","Bundler/Definition.html#method-i-new_specs","()",""],["new_start","Date","Date.html#method-i-new_start","(p1 = v1)","<p>Duplicates self and resets its day of calendar reform.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">1582</span>,<span class=\"ruby-value\">10</span>,<span class=\"ruby-value\">15</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">new_start</span>(<span class=\"ruby-constant\">Date</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">JULIAN</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["new_toplevel","ERB","ERB.html#method-i-new_toplevel","(vars = nil)","<p>Returns a new binding each time <strong>near</strong> TOPLEVEL_BINDING for runs that do not specify a binding.\n"],["new_value","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-new_value","()",""],["new_with","DRb::DRbObject","DRb/DRbObject.html#method-c-new_with","(uri, ref)","<p>Creates a DRb::DRbObject given the reference information to the remote host <code>uri</code> and object <code>ref</code>.\n"],["new_with","DRb::DRbObject","DRb/DRbObject.html#method-c-new_with","(uri, ref)","<p>Creates a DRb::DRbObject given the reference information to the remote host <code>uri</code> and object <code>ref</code>.\n"],["new_with_uri","DRb::DRbObject","DRb/DRbObject.html#method-c-new_with_uri","(uri)","<p>Create a new DRbObject from a URI alone.\n"],["new_with_uri","DRb::DRbObject","DRb/DRbObject.html#method-c-new_with_uri","(uri)","<p>Create a new DRbObject from a URI alone.\n"],["new_with_value_if_need","RSS::Utils","RSS/Utils.html#method-i-new_with_value_if_need","(klass, value)","<p>If <code>value</code> is an instance of class <code>klass</code>, return it, else create a new instance of <code>klass</code> with value <code>value</code> …\n"],["newobj","Net::HTTP","Net/HTTP.html#method-c-newobj","(address, port = nil, p_addr = :ENV, p_port = nil, p_user = nil, p_pass = nil, p_no_proxy = nil)",""],["next","Date","Date.html#method-i-next","()","<p>Returns a date object denoting the following day.\n"],["next","Enumerator","Enumerator.html#method-i-next","()","<p>Returns the next object in the enumerator, and move the internal position forward.  When the position …\n"],["next","Integer","Integer.html#method-i-next","()","<p>Returns the successor of <code>int</code>, i.e. the Integer equal to <code>int+1</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">next</span>      <span class=\"ruby-comment\">#=&gt; 2</span>\n(<span class=\"ruby-value\">-1</span>).<span class=\"ruby-identifier\">next</span>   <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">succ</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["next","Prime::EratosthenesGenerator","Prime/EratosthenesGenerator.html#method-i-next","()",""],["next","Prime::Generator23","Prime/Generator23.html#method-i-next","()",""],["next","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-next","()","<p>alias of <code>succ</code>.\n"],["next","Prime::TrialDivisionGenerator","Prime/TrialDivisionGenerator.html#method-i-next","()",""],["next","REXML::Validation::Choice","REXML/Validation/Choice.html#method-i-next","( event )",""],["next","REXML::Validation::Interleave","REXML/Validation/Interleave.html#method-i-next","( event )",""],["next","REXML::Validation::OneOrMore","REXML/Validation/OneOrMore.html#method-i-next","( event )",""],["next","REXML::Validation::Optional","REXML/Validation/Optional.html#method-i-next","( event )",""],["next","REXML::Validation::State","REXML/Validation/State.html#method-i-next","( event )",""],["next","REXML::Validation::ZeroOrMore","REXML/Validation/ZeroOrMore.html#method-i-next","( event )",""],["next","Racc::LocationPointer","Racc/LocationPointer.html#method-i-next","()",""],["next","String","String.html#method-i-next","()","<p>Returns the successor to <em>str</em>. The successor is calculated by incrementing characters starting from the …\n"],["next","Symbol","Symbol.html#method-i-next","()","<p>Same as <code>sym.to_s.succ.intern</code>.\n"],["next!","String","String.html#method-i-next-21","()","<p>Equivalent to String#succ, but modifies the receiver in place.\n"],["next5","Gem::Resolver::RequirementList","Gem/Resolver/RequirementList.html#method-i-next5","()","<p>Returns the oldest five entries from the list.\n"],["next_current","REXML::Validation::Interleave","REXML/Validation/Interleave.html#method-i-next_current","( event )",""],["next_day","Date","Date.html#method-i-next_day","(p1 = v1)","<p>This method is equivalent to d + n.\n"],["next_element","REXML::Element","REXML/Element.html#method-i-next_element","()","<p>Returns the next sibling that is an element, or nil if there is no Element sibling after this one\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">doc</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["next_float","Float","Float.html#method-i-next_float","()","<p>Returns the next representable floating point number.\n<p>Float::MAX.next_float and Float::INFINITY.next_float …\n"],["next_line","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-next_line","()",""],["next_month","Date","Date.html#method-i-next_month","(p1 = v1)","<p>This method is equivalent to d &gt;&gt; n.\n<p>See Date#>> for examples.\n"],["next_sibling=","REXML::Child","REXML/Child.html#method-i-next_sibling-3D","( other )","<p>Sets the next sibling of this child.  This can be used to insert a child after some other child.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-constant\">Element</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;a&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["next_sibling_node","REXML::Node","REXML/Node.html#method-i-next_sibling_node","()","<p>@return the next sibling (nil if unset)\n"],["next_sibling_node","REXML::XPathParser","REXML/XPathParser.html#method-i-next_sibling_node","(node)",""],["next_token","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-next_token","()",""],["next_token","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-next_token","()",""],["next_token","Racc::Parser","Racc/Parser.html#method-i-next_token","()","<p>The method to fetch next token. If you use #do_parse method, you must implement #next_token.\n<p>The format …\n"],["next_update","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-next_update","()",""],["next_update","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-next_update","()",""],["next_update=","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-next_update-3D","(p1)",""],["next_values","Enumerator","Enumerator.html#method-i-next_values","()","<p>Returns the next object as an array in the enumerator, and move the internal position forward.  When …\n"],["next_year","Date","Date.html#method-i-next_year","(p1 = v1)","<p>This method is equivalent to d &gt;&gt; (n * 12).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">next_year</span>      <span class=\"ruby-comment\">#=&gt; #&lt;Date: 2002-02-03 ...</span>\n</pre>\n"],["nfa","Racc::Grammar","Racc/Grammar.html#method-i-nfa","()",""],["nfa","Racc::States","Racc/States.html#method-i-nfa","()","<p>NFA (Non-deterministic Finite Automaton) Computation\n"],["nil?","NilClass","NilClass.html#method-i-nil-3F","()","<p>Only the object <em>nil</em> responds <code>true</code> to <code>nil?</code>.\n"],["nil?","Object","Object.html#method-i-nil-3F","()","<p>Only the object <em>nil</em> responds <code>true</code> to <code>nil?</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Object</span>.<span class=\"ruby-identifier\">new</span>.<span class=\"ruby-identifier\">nil?</span>   <span class=\"ruby-comment\">#=&gt; false</span>\n<span class=\"ruby-keyword\">nil</span>.<span class=\"ruby-identifier\">nil?</span>          <span class=\"ruby-comment\">#=&gt; true</span>\n</pre>\n"],["nkf","NKF","NKF.html#method-c-nkf","(p1, p2)","<p>Convert <em>str</em> and return converted result. Conversion details are specified by <em>opt</em> as String.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;nkf&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["nlink","File::Stat","File/Stat.html#method-i-nlink","()","<p>Returns the number of hard links to <em>stat</em>.\n\n<pre>File.stat(&quot;testfile&quot;).nlink             #=&gt; 1\nFile.link(&quot;testfile&quot;, ...</pre>\n"],["nlsolve","Newton","Newton.html#method-i-nlsolve","(f,x)","<p>See also Newton\n"],["nlst","Net::FTP","Net/FTP.html#method-i-nlst","(dir = nil)","<p>Returns an array of filenames in the remote directory.\n"],["nmake_found?","Gem::TestCase","Gem/TestCase.html#method-i-nmake_found-3F","()","<p>Returns whether or not the nmake command could be found.\n"],["no?","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-no-3F","(statement, color = nil)","<p>Make a question the to user and returns true if the user replies “n” or “no”.\n"],["no?","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-no-3F","()",""],["no?","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-no-3F","()",""],["no_commands","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-no_commands","(&block)","<p>All methods defined inside the given block are not added as commands.\n<p>So you can do:\n\n<pre>class MyScript &lt; Bundler::Thor ...</pre>\n"],["no_commands?","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-no_commands-3F","()",""],["no_commands_context","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-no_commands_context","()",""],["no_tasks","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-no_tasks","(&block)",""],["nobits?","Integer","Integer.html#method-i-nobits-3F","(p1)","<p>Returns <code>true</code> if no bits of <code>int &amp; mask</code> are 1.\n"],["node_test","REXML::XPathParser","REXML/XPathParser.html#method-i-node_test","(path_stack, nodesets, any_type: :element)",""],["node_type","REXML::AttlistDecl","REXML/AttlistDecl.html#method-i-node_type","()",""],["node_type","REXML::Attribute","REXML/Attribute.html#method-i-node_type","()",""],["node_type","REXML::Comment","REXML/Comment.html#method-i-node_type","()",""],["node_type","REXML::DocType","REXML/DocType.html#method-i-node_type","()",""],["node_type","REXML::Document","REXML/Document.html#method-i-node_type","()",""],["node_type","REXML::Element","REXML/Element.html#method-i-node_type","()",""],["node_type","REXML::Instruction","REXML/Instruction.html#method-i-node_type","()",""],["node_type","REXML::Light::Node","REXML/Light/Node.html#method-i-node_type","()",""],["node_type","REXML::Text","REXML/Text.html#method-i-node_type","()",""],["node_type","REXML::XMLDecl","REXML/XMLDecl.html#method-i-node_type","()",""],["noecho","Gem::MockGemUi::TTY","Gem/MockGemUi/TTY.html#method-i-noecho","()",""],["noecho","IO","IO.html#method-i-noecho","()","<p>Yields <code>self</code> with disabling echo back.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">STDIN</span>.<span class=\"ruby-identifier\">noecho</span>(<span class=\"ruby-operator\">&amp;</span><span class=\"ruby-value\">:gets</span>)\n</pre>\n<p>will read and return a line without echo back. …\n"],["non_aliases","RDoc::ClassModule","RDoc/ClassModule.html#method-i-non_aliases","()","<p>Returns the classes and modules that are not constants aliasing another class or module. For use by formatters …\n"],["non_nil_attributes","Gem::Specification","Gem/Specification.html#method-c-non_nil_attributes","()","<p>Specification attributes that must be non-nil\n"],["nonassoc","Racc::Grammar::PrecedenceDefinitionEnv","Racc/Grammar/PrecedenceDefinitionEnv.html#method-i-nonassoc","(*syms)",""],["nonblock","IO","IO.html#method-i-nonblock","(p1 = v1)","<p>Yields <code>self</code> in non-blocking mode.\n<p>When <code>false</code> is given as an argument, <code>self</code> is yielded in blocking mode. …\n"],["nonblock=","IO","IO.html#method-i-nonblock-3D","(p1)","<p>Enables non-blocking mode on a stream when set to <code>true</code>, and blocking mode when set to <code>false</code>.\n"],["nonblock?","IO","IO.html#method-i-nonblock-3F","()","<p>Returns <code>true</code> if an IO object is in non-blocking mode.\n"],["nondevelopment_dependencies","Gem::Specification","Gem/Specification.html#method-i-nondevelopment_dependencies","()",""],["none?","Array","Array.html#method-i-none-3F","(*args)","<p>See also Enumerable#none?\n"],["none?","Enumerable","Enumerable.html#method-i-none-3F","(*args)","<p>Passes each element of the collection to the given block. The method returns <code>true</code> if the block never …\n"],["none?","Gem::Requirement","Gem/Requirement.html#method-i-none-3F","()","<p>true if this gem has no requirements.\n"],["nonterminal?","Racc::Sym","Racc/Sym.html#method-i-nonterminal-3F","()",""],["nonterminal_base","Racc::Grammar","Racc/Grammar.html#method-i-nonterminal_base","()",""],["nonterminals","Racc::SymbolTable","Racc/SymbolTable.html#method-i-nonterminals","()",""],["nonzero?","BigDecimal","BigDecimal.html#method-i-nonzero-3F","()","<p>Returns self if the value is non-zero, nil otherwise.\n"],["nonzero?","Numeric","Numeric.html#method-i-nonzero-3F","()","<p>Returns <code>self</code> if <code>num</code> is not zero, <code>nil</code> otherwise.\n<p>This behavior is useful when chaining comparisons:\n\n<pre>a = ...</pre>\n"],["noop","Net::FTP","Net/FTP.html#method-i-noop","()","<p>Issues a NOOP command.\n<p>Does nothing except return a response.\n"],["noop","Net::IMAP","Net/IMAP.html#method-i-noop","()","<p>Sends a NOOP command to the server. It does nothing.\n"],["norm","REXML::XPathParser","REXML/XPathParser.html#method-i-norm","(b)",""],["norm","Vector","Vector.html#method-i-norm","()",""],["normal?","Matrix","Matrix.html#method-i-normal-3F","()","<p>Returns <code>true</code> if this is a normal matrix. Raises an error if matrix is not square.\n"],["normalize","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-normalize","()","<p>Returns normalized Bundler::URI.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bundler/vendor/uri/lib/uri&#39;</span>\n\n<span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">URI</span>(<span class=\"ruby-string\">&quot;HTTP://my.EXAMPLE.com&quot;</span>).<span class=\"ruby-identifier\">normalize</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["normalize","Gem::Specification","Gem/Specification.html#method-i-normalize","()","<p>Normalize the list of files so that:\n<p>All file lists have redundancies removed.\n<p>Files referenced in the …\n"],["normalize","Gem::UriFormatter","Gem/UriFormatter.html#method-i-normalize","()","<p>Normalize the URI by adding “http://” if it is missing.\n"],["normalize","IRB::Vec","IRB/Vec.html#method-i-normalize","()",""],["normalize","RDoc::Comment","RDoc/Comment.html#method-i-normalize","()","<p>Normalizes the text.  See RDoc::Text#normalize_comment for details\n"],["normalize","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-normalize","( input, entities=nil, entity_filter=nil )","<p>Escapes all possible entities\n"],["normalize","REXML::Text","REXML/Text.html#method-c-normalize","( input, doctype=nil, entity_filter=nil )","<p>Escapes all possible entities\n"],["normalize","RSS::Maker::ItemsBase","RSS/Maker/ItemsBase.html#method-i-normalize","()",""],["normalize","URI::Generic","URI/Generic.html#method-i-normalize","()","<p>Returns normalized URI.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;uri&#39;</span>\n\n<span class=\"ruby-constant\">URI</span>(<span class=\"ruby-string\">&quot;HTTP://my.EXAMPLE.com&quot;</span>).<span class=\"ruby-identifier\">normalize</span>\n<span class=\"ruby-comment\">#=&gt; #&lt;URI::HTTP http://my.example.com/&gt;</span>\n</pre>\n"],["normalize","Vector","Vector.html#method-i-normalize","()","<p>Returns a new vector with the same direction but with norm 1.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">v</span> = <span class=\"ruby-constant\">Vector</span>[<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">8</span>,<span class=\"ruby-value\">2</span>].<span class=\"ruby-identifier\">normalize</span>\n<span class=\"ruby-comment\"># =&gt; Vector[0.5184758473652127, ...</span>\n</pre>\n"],["normalize!","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-normalize-21","()","<p>Destructive version of #normalize.\n"],["normalize!","URI::Generic","URI/Generic.html#method-i-normalize-21","()","<p>Destructive version of #normalize.\n"],["normalize_comment","RDoc::Text","RDoc/Text.html#method-i-normalize_comment","(text)","<p>Strips hashes, expands tabs then flushes <code>text</code> to the left\n"],["normalize_compare_values","REXML::XPathParser","REXML/XPathParser.html#method-i-normalize_compare_values","(a, operator, b)",""],["normalize_converters","CSV","CSV.html#method-i-normalize_converters","(converters)",""],["normalize_group_options","Bundler::Dsl","Bundler/Dsl.html#method-i-normalize_group_options","(opts, groups)",""],["normalize_groups","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-normalize_groups","()",""],["normalize_hash","Bundler::Dsl","Bundler/Dsl.html#method-i-normalize_hash","(opts)",""],["normalize_options","Bundler::Dsl","Bundler/Dsl.html#method-i-normalize_options","(name, version, opts)",""],["normalize_path","Gem::Package","Gem/Package.html#method-i-normalize_path","(pathname)",""],["normalize_path","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-normalize_path","(path)","<p>Normalizes a request path.  Raises an exception if the path cannot be normalized.\n"],["normalize_path","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-normalize_path","(path)","<p>Normalizes a request path.  Raises an exception if the path cannot be normalized.\n"],["normalize_rss","RSS::Parser","RSS/Parser.html#method-i-normalize_rss","(rss)","<p>Try to get the XML associated with <code>rss</code>. Return <code>rss</code> if it already looks like XML, or treat it as a URI …\n"],["normalize_searching_criteria","Net::IMAP","Net/IMAP.html#method-i-normalize_searching_criteria","(keys)",""],["normalize_settings","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-normalize_settings","()",""],["normalize_source","Bundler::Dsl","Bundler/Dsl.html#method-i-normalize_source","(source)",""],["normalize_space","REXML::Functions","REXML/Functions.html#method-c-normalize_space","( string=nil )","<p>UNTESTED\n"],["normalize_uri","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-normalize_uri","(uri)","<p>Adds “http://” to the String <code>uri</code> if it is missing.\n"],["normalize_uri","Bundler::Settings","Bundler/Settings.html#method-c-normalize_uri","(uri)","<p>TODO: duplicates Rubygems#normalize_uri TODO: is this the correct place to validate mirror URIs?\n"],["normalize_uri","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-normalize_uri","(uri)",""],["normalize_yaml_input","Gem::Specification","Gem/Specification.html#method-c-normalize_yaml_input","(input)","<p>Make sure the YAML specification is properly formatted with dashes\n"],["normalized","REXML::Entity","REXML/Entity.html#method-i-normalized","()","<p>Returns the value of this entity unprocessed – raw.  This is the normalized value; that is, with all …\n"],["normalized_file_list","RDoc::RDoc","RDoc/RDoc.html#method-i-normalized_file_list","(relative_files, force_doc = false, exclude_pattern = nil)","<p>Given a list of files and directories, create a list of all the Ruby files they contain.\n<p>If <code>force_doc</code> …\n"],["not","REXML::Functions","REXML/Functions.html#method-c-not","( object )","<p>UNTESTED\n"],["not_after","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-not_after","()",""],["not_after=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-not_after-3D","(p1)",""],["not_before","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-not_before","()",""],["not_before=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-not_before-3D","(p1)",""],["not_debugging?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-not_debugging-3F","(instance)",""],["not_debugging?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-not_debugging-3F","(instance)",""],["not_found","RDoc::Servlet","RDoc/Servlet.html#method-i-not_found","(generator, req, res, message = nil)","<p>Returns a 404 page built by <code>generator</code> for <code>req</code> on <code>res</code>.\n"],["not_need_to_call_setup_maker_variables","RSS::Rss::Channel","RSS/Rss/Channel.html#method-i-not_need_to_call_setup_maker_variables","()",""],["not_need_to_call_setup_maker_variables","RSS::SetupMaker","RSS/SetupMaker.html#method-i-not_need_to_call_setup_maker_variables","()",""],["not_set_name","RSS::Maker::Atom::Entry::Channel::Generator","RSS/Maker/Atom/Entry/Channel/Generator.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Channel::Categories::Category","RSS/Maker/Atom/Feed/Channel/Categories/Category.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Channel::Generator","RSS/Maker/Atom/Feed/Channel/Generator.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Channel::Links::Link","RSS/Maker/Atom/Feed/Channel/Links/Link.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Items::Item::Categories::Category","RSS/Maker/Atom/Feed/Items/Item/Categories/Category.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Items::Item::Links::Link","RSS/Maker/Atom/Feed/Items/Item/Links/Link.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Items::Item::Source::Categories::Category","RSS/Maker/Atom/Feed/Items/Item/Source/Categories/Category.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Items::Item::Source::Generator","RSS/Maker/Atom/Feed/Items/Item/Source/Generator.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Items::Item::Source::Links::Link","RSS/Maker/Atom/Feed/Items/Item/Source/Links/Link.html#method-c-not_set_name","()",""],["not_set_name","RSS::Maker::Atom::Feed::Items::Item::Source::Logo","RSS/Maker/Atom/Feed/Items/Item/Source/Logo.html#method-c-not_set_name","()",""],["not_set_required_variables","RSS::Maker::Atom::Entry::Items::Item","RSS/Maker/Atom/Entry/Items/Item.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::Atom::Feed::Channel","RSS/Maker/Atom/Feed/Channel.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::Atom::Feed::Items::Item","RSS/Maker/Atom/Feed/Items/Item.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::Base","RSS/Maker/Base.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::RSS09::Channel","RSS/Maker/RSS09/Channel.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::RSS09::Items::Item","RSS/Maker/RSS09/Items/Item.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::RSS10::Channel","RSS/Maker/RSS10/Channel.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::RSS10::Items::Item","RSS/Maker/RSS10/Items/Item.html#method-i-not_set_required_variables","()",""],["not_set_required_variables","RSS::Maker::RSS20::Items::Item","RSS/Maker/RSS20/Items/Item.html#method-i-not_set_required_variables","()",""],["notation","REXML::DocType","REXML/DocType.html#method-i-notation","(name)","<p>Retrieves a named notation. Only notations declared in the internal DTD subset can be retrieved.\n<p>Method …\n"],["notationdecl","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-notationdecl","(name, public_or_system, public_id, system_id)","<p>&lt;!NOTATION …&gt;\n"],["notationdecl","REXML::StreamListener","REXML/StreamListener.html#method-i-notationdecl","(content)","<p>&lt;!NOTATION …&gt;\n"],["notationdecl?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-notationdecl-3F","()","<p>Content: [ String text ]\n"],["notations","REXML::DocType","REXML/DocType.html#method-i-notations","()","<p>This method returns a list of notations that have been declared in the <em>internal</em> DTD subset. Notations …\n"],["note","RDoc::Markdown","RDoc/Markdown.html#method-i-note","(label)","<p>Stores <code>label</code> as a note and fills in previously unknown note references.\n"],["note_for","RDoc::Markdown","RDoc/Markdown.html#method-i-note_for","(ref)","<p>Creates a new link for the footnote <code>reference</code> and adds the reference to\nthe note order list for proper ...\n"],["notes","RDoc::Markdown","RDoc/Markdown.html#method-i-notes","","<p>Enables the notes extension\n"],["nothing_changed?","Bundler::Definition","Bundler/Definition.html#method-i-nothing_changed-3F","()",""],["nothing_outdated_message","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-nothing_outdated_message","()",""],["notice","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-notice","()",""],["notify","Rinda::NotifyTemplateEntry","Rinda/NotifyTemplateEntry.html#method-i-notify","(ev)","<p>Called by TupleSpace to notify this NotifyTemplateEntry of a new event.\n"],["notify","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-notify","(event, tuple, sec=nil)","<p>Registers for notifications of <code>event</code>.  Returns a NotifyTemplateEntry. See NotifyTemplateEntry for examples …\n"],["notify","Rinda::TupleSpaceProxy","Rinda/TupleSpaceProxy.html#method-i-notify","(ev, tuple, sec=nil)","<p>Registers for notifications of event <code>ev</code> on the proxied TupleSpace. See TupleSpace#notify\n"],["notify?","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-notify-3F","()","<p>A wrapper method used to determine whether notifications are enabled.\n<p>Defaults to <code>true</code>.\n"],["notify?","IRB::Notifier::LeveledNotifier","IRB/Notifier/LeveledNotifier.html#method-i-notify-3F","()","<p>Whether to output messages to the output method, depending on the level of this notifier object.\n"],["notify?","IRB::Notifier::NoMsgNotifier","IRB/Notifier/NoMsgNotifier.html#method-i-notify-3F","()","<p>Ensures notifications are ignored, see AbstractNotifier#notify? for more information.\n"],["notify_event","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-notify_event","(event, tuple)","<p>Notifies all registered listeners for <code>event</code> of a status change of <code>tuple</code>.\n"],["notify_observers","DRb::DRbObservable","DRb/DRbObservable.html#method-i-notify_observers","(*arg)","<p>Notifies observers of a change in state.  See also Observable#notify_observers\n"],["notify_observers","Observable","Observable.html#method-i-notify_observers","(*arg)","<p>Notify observers of a change in state <strong>if</strong> this object&#39;s changed state is <code>true</code>.\n<p>This will invoke the …\n"],["notwice","OptionParser","OptionParser.html#method-i-notwice","(obj, prv, msg)","<p>Checks if an argument is given twice, in which case an ArgumentError is raised. Called from OptionParser#switch …\n"],["now","DateTime","DateTime.html#method-c-now","(p1 = v1)","<p>Creates a DateTime object denoting the present time.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">now</span>              <span class=\"ruby-comment\">#=&gt; #&lt;DateTime: 2011-06-11T21:20:44+09:00 ...</span>\n</pre>\n"],["now","Time","Time.html#method-c-now","(p1 = {})","<p>Creates a new Time object for the current time. This is same as Time.new without arguments.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["nowrite","REXML::XMLDecl","REXML/XMLDecl.html#method-i-nowrite","()",""],["npn_protocol","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-npn_protocol","()","<p>Returns the protocol string that was finally selected by the client during the handshake.\n"],["nprocessors","Etc","Etc.html#method-c-nprocessors","()","<p>Returns the number of online processors.\n<p>The result is intended as the number of processes to use all …\n"],["nread","IO","IO.html#method-i-nread","()","<p>Returns number of bytes that can be read without blocking. Returns zero if no information available. …\n"],["ns_declarations","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-ns_declarations","()",""],["nsec","Time","Time.html#method-i-nsec","()","<p>Returns the number of nanoseconds for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>        <span class=\"ruby-comment\">#=&gt; 2007-11-17 15:18:03 +0900</span>\n<span class=\"ruby-string\">&quot;%10.9f&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["nt_max","Racc::SymbolTable","Racc/SymbolTable.html#method-i-nt_max","()",""],["nth_kday","Date","Date.html#method-c-nth_kday","(p1 = v1, p2 = v2, p3 = v3, p4 = v4, p5 = v5)",""],["nth_kday","DateTime","DateTime.html#method-c-nth_kday","(p1 = v1, p2 = v2, p3 = v3, p4 = v4, p5 = v5, p6 = v6, p7 = v7, p8 = v8, p9 = v9)",""],["nth_kday?","Date","Date.html#method-i-nth_kday-3F","(p1, p2)",""],["ntop","IPAddr","IPAddr.html#method-c-ntop","(addr)","<p>Convert a network byte ordered string form of an IP address into human readable form.\n"],["null","Gem::NameTuple","Gem/NameTuple.html#method-c-null","()","<p>A null NameTuple, ie name=nil, version=0\n"],["null","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-null","(&block)",""],["null=","Racc::Rule","Racc/Rule.html#method-i-null-3D","(n)",""],["null=","Racc::Sym","Racc/Sym.html#method-i-null-3D","(n)",""],["null?","Fiddle::Pointer","Fiddle/Pointer.html#method-i-null-3F","()","<p>Returns <code>true</code> if this is a null pointer.\n"],["nullable?","Racc::Rule","Racc/Rule.html#method-i-nullable-3F","()",""],["nullable?","Racc::Sym","Racc/Sym.html#method-i-nullable-3F","()",""],["num_bits","OpenSSL::BN","OpenSSL/BN.html#method-i-num_bits","()",""],["num_bytes","OpenSSL::BN","OpenSSL/BN.html#method-i-num_bytes","()",""],["num_waiting","Queue","Queue.html#method-i-num_waiting","()","<p>Returns the number of threads waiting on the queue.\n"],["num_waiting","SizedQueue","SizedQueue.html#method-i-num_waiting","()","<p>Returns the number of threads waiting on the queue.\n"],["number","REXML::Functions","REXML/Functions.html#method-c-number","(object=@@context[:node])","<p>a string that consists of optional whitespace followed by an optional minus sign followed by a Number …\n"],["numerator","Complex","Complex.html#method-i-numerator","()","<p>Returns the numerator.\n\n<pre>    1   2       3+4i  &lt;-  numerator\n    - + -i  -&gt;  ----\n    2   3        6    ...</pre>\n"],["numerator","Float","Float.html#method-i-numerator","()","<p>Returns the numerator.  The result is machine dependent.\n\n<pre>n = 0.3.numerator    #=&gt; 5404319552844595\nd = ...</pre>\n"],["numerator","Integer","Integer.html#method-i-numerator","()","<p>Returns self.\n"],["numerator","Numeric","Numeric.html#method-i-numerator","()","<p>Returns the numerator.\n"],["numerator","Rational","Rational.html#method-i-numerator","()","<p>Returns the numerator.\n\n<pre>Rational(7).numerator        #=&gt; 7\nRational(7, 1).numerator     #=&gt; 7\nRational(9, ...</pre>\n"],["object_address_group","PP::PPMethods","PP/PPMethods.html#method-i-object_address_group","(obj, &block)","<p>A convenience method, like object_group, but also reformats the Object&#39;s object_id.\n"],["object_class","RDoc::TopLevel","RDoc/TopLevel.html#method-i-object_class","()","<p>Returns the NormalClass “Object”, creating it if not found.\n<p>Records <code>self</code> as a location in “Object”. …\n"],["object_group","PP::PPMethods","PP/PPMethods.html#method-i-object_group","(obj)","<p>A convenience method which is same as follows:\n\n<pre>group(1, &#39;#&lt;&#39; + obj.class.name, &#39;&gt;&#39;) { ... }</pre>\n"],["object_id","Object","Object.html#method-i-object_id","()","<p>Returns an integer identifier for <code>obj</code>.\n<p>The same number will be returned on all calls to <code>object_id</code> for …\n"],["object_nl","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-object_nl","()","<p>This string is put at the end of a line that holds a JSON object (or Hash).\n"],["object_nl=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-object_nl-3D","(p1)","<p>This string is put at the end of a line that holds a JSON object (or Hash).\n"],["oct","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-i-oct","(num, len)",""],["oct","String","String.html#method-i-oct","()","<p>Treats leading characters of <em>str</em> as a string of octal digits (with an optional sign) and returns the …\n"],["oct_or_256based","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-c-oct_or_256based","(str)",""],["odd?","Integer","Integer.html#method-i-odd-3F","()","<p>Returns <code>true</code> if <code>int</code> is an odd number.\n"],["odd?","OpenSSL::BN","OpenSSL/BN.html#method-i-odd-3F","()",""],["of","RubyVM::AbstractSyntaxTree","RubyVM/AbstractSyntaxTree.html#method-c-of","(body)","<p>Returns AST nodes of the given <em>proc</em> or <em>method</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">RubyVM</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AbstractSyntaxTree</span>.<span class=\"ruby-identifier\">of</span>(<span class=\"ruby-identifier\">proc</span> {<span class=\"ruby-value\">1</span> <span class=\"ruby-operator\">+</span> <span class=\"ruby-value\">2</span>})\n<span class=\"ruby-comment\"># =&gt; #&lt;RubyVM::AbstractSyntaxTree::Node:SCOPE@1:35-1:42&gt; ...</span>\n</pre>\n"],["of","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-c-of","(p1)","<p>Returns the instruction sequence containing the given proc or method.\n<p>For example, using irb:\n\n<pre class=\"ruby\"><span class=\"ruby-comment\"># a proc ...</span>\n</pre>\n"],["off","Tracer","Tracer.html#method-c-off","()","<p>Disable tracing\n"],["off_event","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-i-off_event","(p1 = v1)","<p>removes the callback of event.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ie</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;InternetExplorer.Application&#39;</span>)\n<span class=\"ruby-identifier\">ev</span> = <span class=\"ruby-constant\">WIN32OLE_EVENT</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-identifier\">ie</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["offset","DateTime","DateTime.html#method-i-offset","()","<p>Returns the offset.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-string\">&#39;04pm+0730&#39;</span>).<span class=\"ruby-identifier\">offset</span>        <span class=\"ruby-comment\">#=&gt; (5/16)</span>\n</pre>\n"],["offset","MatchData","MatchData.html#method-i-offset","(p1)","<p>Returns a two-element array containing the beginning and ending offsets of the <em>n</em>th match. <em>n</em> can be a …\n"],["offset_vtbl","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-offset_vtbl","()","<p>Returns the offset ov VTBL.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbooks&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["oflush","IO","IO.html#method-i-oflush","()","<p>Flushes output buffer in kernel.\n<p>You must require &#39;io/console&#39; to use this method.\n"],["oid","OpenSSL::ASN1::ObjectId","OpenSSL/ASN1/ObjectId.html#method-i-oid","()","<p>Returns a String representing the Object Identifier in the dot notation, e.g. “1.2.3.4.5”\n"],["oid","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-i-oid","()",""],["oid","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-oid","()",""],["oid=","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-i-oid-3D","(p1)",""],["oid=","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-oid-3D","(p1)",""],["ok?","Gem::DependencyList","Gem/DependencyList.html#method-i-ok-3F","()","<p>Are all the dependencies in the list satisfied?\n"],["ok_to_remove?","Gem::DependencyList","Gem/DependencyList.html#method-i-ok_to_remove-3F","(full_name, check_dev=true)","<p>It is ok to remove a gemspec from the dependency list?\n<p>If removing the gemspec creates breaks a currently …\n"],["old_enc=","REXML::XMLDecl","REXML/XMLDecl.html#method-i-old_enc-3D","( enc )",""],["ole_activex_initialize","WIN32OLE","WIN32OLE.html#method-i-ole_activex_initialize","()","<p>Initialize WIN32OLE object(ActiveX Control) by calling IPersistMemory::InitNew.\n<p>Before calling OLE method, …\n"],["ole_classes","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-c-ole_classes","(p1)","<p>Returns array of WIN32OLE_TYPE objects defined by the <em>typelib</em> type library. This method will be OBSOLETE …\n"],["ole_classes","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-ole_classes","()",""],["ole_free","WIN32OLE","WIN32OLE.html#method-i-ole_free","()","<p>invokes Release method of Dispatch interface of WIN32OLE object. Usually, you do not need to call this …\n"],["ole_free","WIN32OLE","WIN32OLE.html#method-c-ole_free","(p1)","<p>Invokes Release method of Dispatch interface of WIN32OLE object. You should not use this method because …\n"],["ole_func_methods","WIN32OLE","WIN32OLE.html#method-i-ole_func_methods","()","<p>Returns the array of WIN32OLE_METHOD object . The element of the array is property (settable) of WIN32OLE …\n"],["ole_get_methods","WIN32OLE","WIN32OLE.html#method-i-ole_get_methods","()","<p>Returns the array of WIN32OLE_METHOD object . The element of the array is property (gettable) of WIN32OLE …\n"],["ole_instance_variable_get","WIN32OLE_RECORD","WIN32OLE_RECORD.html#method-i-ole_instance_variable_get","(p1)","<p>Returns value specified by the member name of VT_RECORD OLE object. If the member name is not correct, …\n"],["ole_instance_variable_set","WIN32OLE_RECORD","WIN32OLE_RECORD.html#method-i-ole_instance_variable_set","(p1, p2)","<p>Sets value specified by the member name of VT_RECORD OLE object. If the member name is not correct,  …\n"],["ole_method","WIN32OLE","WIN32OLE.html#method-i-ole_method","(p1)","<p>Returns WIN32OLE_METHOD object corresponding with method specified by 1st argument.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">excel</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Excel.Application&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ole_method_help","WIN32OLE","WIN32OLE.html#method-i-ole_method_help","(p1)",""],["ole_methods","WIN32OLE","WIN32OLE.html#method-i-ole_methods","()","<p>Returns the array of WIN32OLE_METHOD object. The element is OLE method of WIN32OLE object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">excel</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Excel.Application&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ole_methods","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-ole_methods","()","<p>Returns array of WIN32OLE_METHOD objects which represent OLE method defined in OLE type library.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ole_methods_safely","WIN32OLE","WIN32OLE.html#method-i-ole_methods_safely","()",""],["ole_obj_help","WIN32OLE","WIN32OLE.html#method-i-ole_obj_help","()",""],["ole_put_methods","WIN32OLE","WIN32OLE.html#method-i-ole_put_methods","()","<p>Returns the array of WIN32OLE_METHOD object . The element of the array is property (settable) of WIN32OLE …\n"],["ole_query_interface","WIN32OLE","WIN32OLE.html#method-i-ole_query_interface","(p1)","<p>Returns WIN32OLE object for a specific dispatch or dual interface specified by iid.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ie</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;InternetExplorer.Application&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ole_reference_count","WIN32OLE","WIN32OLE.html#method-c-ole_reference_count","(p1)","<p>Returns reference counter of Dispatch interface of WIN32OLE object. You should not use this method because …\n"],["ole_respond_to?","WIN32OLE","WIN32OLE.html#method-i-ole_respond_to-3F","(p1)","<p>Returns true when OLE object has OLE method, otherwise returns false.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ie</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;InternetExplorer.Application&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ole_show_help","WIN32OLE","WIN32OLE.html#method-c-ole_show_help","(p1, p2 = v2)","<p>Displays helpfile. The 1st argument specifies WIN32OLE_TYPE object or WIN32OLE_METHOD object or helpfile. …\n"],["ole_type","WIN32OLE","WIN32OLE.html#method-i-ole_type","()","<p>Returns WIN32OLE_TYPE object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">excel</span> = <span class=\"ruby-constant\">WIN32OLE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Excel.Application&#39;</span>)\n<span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-identifier\">excel</span>.<span class=\"ruby-identifier\">ole_type</span>\n</pre>\n"],["ole_type","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-ole_type","()","<p>Returns OLE type of WIN32OLE_PARAM object(parameter of OLE method).\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["ole_type","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-ole_type","()","<p>returns type of OLE class.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Application&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ole_type","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-ole_type","()","<p>Returns OLE type string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;XlSheetType&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ole_type_detail","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-ole_type_detail","()","<p>Returns detail information of type of argument.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["ole_type_detail","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-ole_type_detail","()","<p>Returns detail information of type. The information is array of type.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;DirectX ...</pre>\n"],["ole_typelib","WIN32OLE","WIN32OLE.html#method-i-ole_typelib","()","<p>Returns the WIN32OLE_TYPELIB object. The object represents the type library which contains the WIN32OLE …\n"],["ole_typelib","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-ole_typelib","()","<p>Returns the WIN32OLE_TYPELIB object which is including the WIN32OLE_TYPE object. If it is not found, …\n"],["ole_types","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-ole_types","()","<p>Returns the type library file path.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlib</span> = <span class=\"ruby-constant\">WIN32OLE_TYPELIB</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["on","OptionParser","OptionParser.html#method-i-on","(*opts, &block)","<p>Add option switch and handler. See #make_switch for an explanation of parameters.\n"],["on","Tracer","Tracer.html#method-c-on","()","<p>Start tracing\n<p>Example\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Tracer</span>.<span class=\"ruby-identifier\">on</span>\n<span class=\"ruby-comment\"># code to trace here</span>\n<span class=\"ruby-constant\">Tracer</span>.<span class=\"ruby-identifier\">off</span>\n</pre>\n"],["on_CHAR","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_CHAR","(tok, data)",""],["on_attr_charref","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_attr_charref","(code)",""],["on_attr_charref_hex","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_attr_charref_hex","(code)",""],["on_attr_entityref","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_attr_entityref","(ref)",""],["on_attr_value","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_attr_value","(str)",""],["on_attribute","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_attribute","(name)",""],["on_backref","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_backref","(tok, data)",""],["on_charref","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_charref","(code)",""],["on_charref_hex","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_charref_hex","(code)",""],["on_comma","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_comma","(tok, data)",""],["on_comment","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_comment","(tok, data)",""],["on_connect","Net::HTTP","Net/HTTP.html#method-i-on_connect","()",""],["on_const","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_const","(tok, data)",""],["on_curve?","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-on_curve-3F","()",""],["on_cvar","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_cvar","(tok, data)",""],["on_default","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_default","(event, tok, data)",""],["on_default","Ripper::Filter","Ripper/Filter.html#method-i-on_default","(event, token, data)","<p>This method is called when some event handler is undefined. <code>event</code> is :on_XXX, <code>token</code> is the scanned token, …\n"],["on_entityref","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_entityref","(ref)",""],["on_error","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-on_error","(tok, val, _values)",""],["on_error","Racc::Parser","Racc/Parser.html#method-i-on_error","(t, val, vstack)","<p>This method is called when a parse error is found.\n<p>ERROR_TOKEN_ID is an internal ID of token which caused …\n"],["on_etag","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_etag","(name)",""],["on_event","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-i-on_event","(*args)","<p>Defines the callback event. If argument is omitted, this method defines the callback of all events.  …\n"],["on_event_with_outargs","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-i-on_event_with_outargs","(*args)","<p>Defines the callback of event. If you want modify argument in callback, you could use this method instead …\n"],["on_float","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_float","(tok, data)",""],["on_gvar","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_gvar","(tok, data)",""],["on_head","OptionParser","OptionParser.html#method-i-on_head","(*opts, &block)","<p>Add option switch like with #on, but at head of summary.\n"],["on_heredoc_beg","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_heredoc_beg","(tok, data)",""],["on_heredoc_end","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_heredoc_end","(tok, data)",""],["on_ident","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_ident","(tok, data)",""],["on_ignored_nl","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_ignored_nl","(tok, data)",""],["on_ignored_sp","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_ignored_sp","(tok, data)",""],["on_imaginary","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_imaginary","(tok, data)",""],["on_int","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_int","(tok, data)",""],["on_ivar","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_ivar","(tok, data)",""],["on_kw","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_kw","(tok, data)",""],["on_lbrace","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_lbrace","(tok, data)",""],["on_lbracket","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_lbracket","(tok, data)",""],["on_lparen","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_lparen","(tok, data)",""],["on_nl","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_nl","(tok, data)",""],["on_op","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_op","(tok, data)",""],["on_period","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_period","(tok, data)",""],["on_rational","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_rational","(tok, data)",""],["on_rbrace","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_rbrace","(tok, data)",""],["on_rbracket","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_rbracket","(tok, data)",""],["on_rparen","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_rparen","(tok, data)",""],["on_sp","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_sp","(tok, data)",""],["on_stag","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_stag","(name)",""],["on_stag_end","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_stag_end","(name)",""],["on_stag_end_empty","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_stag_end_empty","(name)",""],["on_symbeg","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_symbeg","(tok, data)",""],["on_tail","OptionParser","OptionParser.html#method-i-on_tail","(*opts, &block)","<p>Add option switch like with #on, but at tail of summary.\n"],["on_tstring_beg","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_tstring_beg","(tok, data)",""],["on_tstring_end","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_tstring_end","(tok, data)",""],["on_variables","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-on_variables","(event, tok, data)",""],["on_windows?","PStore","PStore.html#method-i-on_windows-3F","()",""],["on_xmldecl_encoding","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_xmldecl_encoding","(str)",""],["on_xmldecl_end","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_xmldecl_end","()",""],["on_xmldecl_standalone","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_xmldecl_standalone","(str)",""],["on_xmldecl_version","RSS::XMLScanListener","RSS/XMLScanListener.html#method-i-on_xmldecl_version","(str)",""],["once_writer","Racc::Sym","Racc/Sym.html#method-c-once_writer","(nm)",""],["one?","Array","Array.html#method-i-one-3F","(*args)","<p>See also Enumerable#one?\n"],["one?","Enumerable","Enumerable.html#method-i-one-3F","(*args)","<p>Passes each element of the collection to the given block. The method returns <code>true</code> if the block returns …\n"],["one?","OpenSSL::BN","OpenSSL/BN.html#method-i-one-3F","()",""],["ongoing_visibility=","RDoc::Context","RDoc/Context.html#method-i-ongoing_visibility-3D","(visibility)","<p>Changes the visibility for new methods to <code>visibility</code>\n"],["opaque=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-opaque-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["opaque=","URI::Generic","URI/Generic.html#method-i-opaque-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["open","Bundler::CLI","Bundler/CLI.html#method-i-open","(name)",""],["open","CSV","CSV.html#method-c-open","(filename, mode=\"r\", **options)","<p>This method opens an IO object, and wraps that with CSV. This is intended as the primary interface for …\n"],["open","DBM","DBM.html#method-c-open","(*args)","<p>Open a dbm database and yields it if a block is given. See also <code>DBM.new</code>.\n"],["open","DRb::DRbProtocol","DRb/DRbProtocol.html#method-i-open","(uri, config, first=true)","<p>Open a client connection to <code>uri</code> with the configuration <code>config</code>.\n<p>The DRbProtocol module asks each registered …\n"],["open","DRb::DRbProtocol","DRb/DRbProtocol.html#method-c-open","(uri, config, first=true)","<p>Open a client connection to <code>uri</code> with the configuration <code>config</code>.\n<p>The DRbProtocol module asks each registered …\n"],["open","DRb::DRbSSLSocket","DRb/DRbSSLSocket.html#method-c-open","(uri, config)","<p>Return an DRb::DRbSSLSocket instance as a client-side connection, with the SSL connected.  This is called …\n"],["open","Dir","Dir.html#method-c-open","(*args)","<p>The optional <em>encoding</em> keyword argument specifies the encoding of the directory. If not specified, the …\n"],["open","File","File.html#method-c-open","(*args)","<p>With no associated block, File.open is a synonym for File.new. If the optional code block is given, it …\n"],["open","GDBM","GDBM.html#method-c-open","(*args)","<p>If called without a block, this is synonymous to GDBM::new. If a block is given, the new GDBM instance …\n"],["open","IO","IO.html#method-c-open","(*args)","<p>With no associated block, IO.open is a synonym for IO.new.  If the optional code block is given, it will …\n"],["open","Kernel","Kernel.html#method-c-open","(*args)","<p>Creates an IO object connected to the given stream, file, or subprocess.\n<p>If <code>path</code> does not start with a …\n"],["open","Kernel","Kernel.html#method-i-open","(*args)","<p>Creates an IO object connected to the given stream, file, or subprocess.\n<p>If <code>path</code> does not start with a …\n"],["open","Net::FTP","Net/FTP.html#method-c-open","(host, *args)","<p>A synonym for <code>FTP.new</code>, but with a mandatory host parameter.\n<p>If a block is given, it is passed the <code>FTP</code> …\n"],["open","OpenURI::OpenRead","OpenURI/OpenRead.html#method-i-open","(*rest, &block)","<p>OpenURI::OpenRead#open provides `open&#39; for URI::HTTP and URI::FTP.\n<p>OpenURI::OpenRead#open takes optional …\n"],["open","PTY","PTY.html#method-c-open","()","<p>Allocates a pty (pseudo-terminal).\n<p>In the block form, yields two arguments <code>master_io, slave_file</code> and the …\n"],["open","Pathname","Pathname.html#method-i-open","(p1 = v1, p2 = v2, p3 = v3)","<p>Opens the file for reading or writing.\n<p>See File.open.\n"],["open","Resolv::DNS","Resolv/DNS.html#method-c-open","(*args)","<p>Creates a new DNS resolver.  See Resolv::DNS.new for argument details.\n<p>Yields the created DNS resolver …\n"],["open","SDBM","SDBM.html#method-c-open","(*args)","<p>If called without a block, this is the same as SDBM.new.\n<p>If a block is given, the new database will be …\n"],["open","StringIO","StringIO.html#method-c-open","(*args)","<p>Equivalent to StringIO.new except that when it is called with a block, it yields with the new instance …\n"],["open","Syslog","Syslog.html#method-c-open","(p1 = v1, p2 = v2, p3 = v3)","<p>Open the syslog facility. Raises a runtime exception if it is already open.\n<p>Can be called with or without …\n"],["open","Tempfile","Tempfile.html#method-i-open","()","<p>Opens or reopens the file with mode “r+”.\n"],["open","Tempfile","Tempfile.html#method-c-open","(*args, **kw)","<p>Creates a new Tempfile.\n<p>If no block is given, this is a synonym for Tempfile.new.\n<p>If a block is given, …\n"],["open","URI","URI.html#method-c-open","(name, *rest, &block)","<p>Allows the opening of various resources including URIs.\n<p>If the first argument responds to the &#39;open&#39; …\n"],["open","Zlib::GzipReader","Zlib/GzipReader.html#method-c-open","(*args)","<p>Opens a file specified by <code>filename</code> as a gzipped file, and returns a GzipReader object associated with …\n"],["open","Zlib::GzipWriter","Zlib/GzipWriter.html#method-c-open","(*args)","<p>Opens a file specified by <code>filename</code> for writing gzip compressed data, and returns a GzipWriter object …\n"],["open!","Syslog","Syslog.html#method-c-open-21","(*args)","<p>Closes and then reopens the syslog.\n<p>Arguments are the same as for open().\n"],["open_and_lock_file","PStore","PStore.html#method-i-open_and_lock_file","(filename, read_only)","<p>Open the specified filename (either in read-only mode or in read-write mode) and lock it for reading …\n"],["open_editor","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-open_editor","(editor, file)",""],["open_editor","Gem::Commands::OpenCommand","Gem/Commands/OpenCommand.html#method-i-open_editor","(path)",""],["open_gem","Gem::Commands::OpenCommand","Gem/Commands/OpenCommand.html#method-i-open_gem","(name)",""],["open_message_stream","Net::SMTP","Net/SMTP.html#method-i-open_message_stream","(from_addr, *to_addrs)","<p>Opens a message writer stream and gives it to the block. The stream is valid only in the block, and has …\n"],["open_server","DRb::DRbProtocol","DRb/DRbProtocol.html#method-c-open_server","(uri, config, first=true)","<p>Open a server listening for connections at <code>uri</code> with configuration <code>config</code>.\n<p>The DRbProtocol module asks …\n"],["open_server","DRb::DRbProtocol","DRb/DRbProtocol.html#method-i-open_server","(uri, config, first=true)","<p>Open a server listening for connections at <code>uri</code> with configuration <code>config</code>.\n<p>The DRbProtocol module asks …\n"],["open_server","DRb::DRbSSLSocket","DRb/DRbSSLSocket.html#method-c-open_server","(uri, config)","<p>Returns a DRb::DRbSSLSocket instance as a server-side connection, with the SSL connected.  This is called …\n"],["open_uri_or_path","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-open_uri_or_path","(path)","<p>Thanks, FakeWeb!\n"],["open_uri_original_open","Kernel","Kernel.html#method-i-open_uri_original_open","(*args)",""],["open_uri_original_open","Kernel","Kernel.html#method-c-open_uri_original_open","(*args)",""],["opendir","Pathname","Pathname.html#method-i-opendir","()","<p>Opens the referenced directory.\n<p>See Dir.open.\n"],["opened?","Syslog","Syslog.html#method-c-opened-3F","()","<p>Returns true if the syslog is open.\n"],["operating_system_defaults","Gem","Gem.html#method-c-operating_system_defaults","()","<p>Default options for gem commands for Ruby packagers.\n<p>The options here should be structured as an array …\n"],["option","Bundler::Thor","Bundler/Thor.html#method-c-option","(name, options = {})",""],["option","Net::FTP","Net/FTP.html#method-i-option","(name, params = nil)","<p>Issues an OPTS command\n<p>name Should be the name of the option to set\n<p>params is any optional parameters to …\n"],["option","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-option","(sym, default = nil, &block)",""],["option_is_deprecated?","Gem::Command","Gem/Command.html#method-i-option_is_deprecated-3F","(option)",""],["option_list","RDoc::Task","RDoc/Task.html#method-i-option_list","()","<p>List of options that will be supplied to RDoc\n"],["option_list","RDoc::Task","RDoc/Task.html#method-i-option_list","()","<p>List of options that will be supplied to RDoc\n"],["optional?","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-optional-3F","()","<p>Returns true if argument is optional.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbook&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["options","Bundler::FileUtils","Bundler/FileUtils.html#method-c-options","()","<p>Returns an Array of option names.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">options</span>  <span class=\"ruby-comment\">#=&gt; [&quot;noop&quot;, &quot;force&quot;, &quot;verbose&quot;, &quot;preserve&quot;, ...</span>\n</pre>\n"],["options","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-options","()",""],["options","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-options","()",""],["options","Bundler::Thor","Bundler/Thor.html#method-c-options","(options = nil)",""],["options","FileUtils","FileUtils.html#method-c-options","()","<p>Returns an Array of option names.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">options</span>  <span class=\"ruby-comment\">#=&gt; [&quot;noop&quot;, &quot;force&quot;, &quot;verbose&quot;, &quot;preserve&quot;, &quot;mode&quot;]</span>\n</pre>\n"],["options","Net::HTTP","Net/HTTP.html#method-i-options","(path, initheader = nil)","<p>Sends a OPTIONS request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["options","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-options","()","<p>Gets various OpenSSL options.\n"],["options","OptionParser::Arguable","OptionParser/Arguable.html#method-i-options","()","<p>Actual OptionParser object, automatically created if nonexistent.\n<p>If called with a block, yields the  …\n"],["options","RDoc::CodeObject","RDoc/CodeObject.html#method-i-options","()","<p>The options instance from the store this CodeObject is attached to, or a default options instance if …\n"],["options","Regexp","Regexp.html#method-i-options","()","<p>Returns the set of bits corresponding to the options used when creating this Regexp (see Regexp::new …\n"],["options","Syslog","Syslog.html#method-c-options","()","<p>Returns the options bitmask used in the last call to open()\n"],["options=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-options-3D","(p1)","<p>Sets various OpenSSL options.\n"],["options=","OptionParser::Arguable","OptionParser/Arguable.html#method-i-options-3D","(opt)","<p>Sets OptionParser object, when <code>opt</code> is <code>false</code> or <code>nil</code>, methods OptionParser::Arguable#options and OptionParser::Arguable#options= …\n"],["options_of","Bundler::FileUtils","Bundler/FileUtils.html#method-c-options_of","(mid)","<p>Returns an Array of option names of the method <code>mid</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">options_of</span>(<span class=\"ruby-value\">:rm</span>)  <span class=\"ruby-comment\">#=&gt; [&quot;noop&quot;, ...</span>\n</pre>\n"],["options_of","FileUtils","FileUtils.html#method-c-options_of","(mid)","<p>Returns an Array of option names of the method <code>mid</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">options_of</span>(<span class=\"ruby-value\">:rm</span>)  <span class=\"ruby-comment\">#=&gt; [&quot;noop&quot;, &quot;verbose&quot;, ...</span>\n</pre>\n"],["options_to_lock","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-options_to_lock","()","<p>Options to be saved in the lockfile so that the source plugin is able to check out same version of gem …\n"],["optname","Socket::Option","Socket/Option.html#method-i-optname","()","<p>returns the socket option name as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:RECVPKTINFO</span>, [<span class=\"ruby-value\">1</span>].<span class=\"ruby-identifier\">pack</span>(<span class=\"ruby-string\">&quot;i!&quot;</span>)).<span class=\"ruby-identifier\">optname</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["ord","Integer","Integer.html#method-i-ord","()","<p>Returns the <code>int</code> itself.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">97</span>.<span class=\"ruby-identifier\">ord</span>   <span class=\"ruby-comment\">#=&gt; 97</span>\n</pre>\n<p>This method is intended for compatibility to character literals …\n"],["ord","String","String.html#method-i-ord","()","<p>Returns the Integer ordinal of a one-character string.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;a&quot;</span>.<span class=\"ruby-identifier\">ord</span>         <span class=\"ruby-comment\">#=&gt; 97</span>\n</pre>\n"],["order","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-order","()","<p>Returns the order of the group.\n<p>See the OpenSSL documentation for EC_GROUP_get_order()\n"],["order","OptionParser","OptionParser.html#method-i-order","(*argv, into: nil, &nonopt)","<p>Parses command line arguments <code>argv</code> in order. When a block is given, each non-option argument is yielded. …\n"],["order!","OptionParser","OptionParser.html#method-i-order-21","(argv = default_argv, into: nil, &nonopt)","<p>Same as #order, but removes switches destructively. Non-option arguments remain in <code>argv</code>.\n"],["order!","OptionParser::Arguable","OptionParser/Arguable.html#method-i-order-21","(&blk)","<p>Parses <code>self</code> destructively in order and returns <code>self</code> containing the rest arguments left unparsed.\n"],["ordering=","GetoptLong","GetoptLong.html#method-i-ordering-3D","(ordering)","<p>Set the handling of the ordering of options and arguments. A RuntimeError is raised if option processing …\n"],["ordinal","Date","Date.html#method-c-ordinal","(p1 = v1, p2 = v2, p3 = v3)","<p>Creates a date object denoting the given ordinal date.\n<p>The day of year should be a negative or a positive …\n"],["ordinal","DateTime","DateTime.html#method-c-ordinal","(p1 = v1, p2 = v2, p3 = v3, p4 = v4, p5 = v5, p6 = v6, p7 = v7)","<p>Creates a DateTime object denoting the given ordinal date.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">ordinal</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">34</span>) <span class=\"ruby-comment\">#=&gt; #&lt;DateTime: 2001-02-03T00:00:00+00:00 ...</span>\n</pre>\n"],["orig_initialize","RDoc::Markdown","RDoc/Markdown.html#method-i-orig_initialize","(extensions = DEFAULT_EXTENSIONS, debug = false)","<p>TODO remove when kpeg 0.10 is released\n"],["orig_name","Zlib::GzipFile","Zlib/GzipFile.html#method-i-orig_name","()","<p>Returns original filename recorded in the gzip file header, or <code>nil</code> if original filename is not present. …\n"],["orig_name=","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-orig_name-3D","(p1)","<p>Specify the original name (<code>str</code>) in the gzip header.\n"],["original_env","Bundler","Bundler.html#method-c-original_env","()","<p>@return [Hash] Environment present before Bundler was activated\n"],["original_exec","Bundler","Bundler.html#method-c-original_exec","(*args)","<p>Run a `Kernel.exec` to a subcommand with the environment present before Bundler was activated\n"],["original_name","Method","Method.html#method-i-original_name","()","<p>Returns the original name of the method.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">class</span> <span class=\"ruby-constant\">C</span>\n  <span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">foo</span>; <span class=\"ruby-keyword\">end</span>\n  <span class=\"ruby-keyword\">alias</span> <span class=\"ruby-identifier\">bar</span> <span class=\"ruby-identifier\">foo</span>\n<span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-constant\">C</span>.<span class=\"ruby-identifier\">instance_method</span>(<span class=\"ruby-value\">:bar</span>).<span class=\"ruby-identifier\">original_name</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["original_name","UnboundMethod","UnboundMethod.html#method-i-original_name","()","<p>Returns the original name of the method.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">class</span> <span class=\"ruby-constant\">C</span>\n  <span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">foo</span>; <span class=\"ruby-keyword\">end</span>\n  <span class=\"ruby-keyword\">alias</span> <span class=\"ruby-identifier\">bar</span> <span class=\"ruby-identifier\">foo</span>\n<span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-constant\">C</span>.<span class=\"ruby-identifier\">instance_method</span>(<span class=\"ruby-value\">:bar</span>).<span class=\"ruby-identifier\">original_name</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["original_system","Bundler","Bundler.html#method-c-original_system","(*args)","<p>Run subcommand with the environment present before Bundler was activated\n"],["orthogonal?","Matrix","Matrix.html#method-i-orthogonal-3F","()","<p>Returns <code>true</code> if this is an orthogonal matrix Raises an error if matrix is not square.\n"],["os_code","Zlib::GzipFile","Zlib/GzipFile.html#method-i-os_code","()","<p>Returns OS code number recorded in the gzip file header.\n"],["os_match","Bundler::GemHelpers::PlatformMatch","Bundler/GemHelpers/PlatformMatch.html#method-c-os_match","(spec_platform, user_platform)",""],["other_elements","RSS::Maker::Base","RSS/Maker/Base.html#method-c-other_elements","()",""],["otool_available?","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-otool_available-3F","()",""],["out","CGI","CGI.html#method-i-out","(options = \"text/html\")","<p>Print an HTTP header and body to $DEFAULT_OUTPUT ($&gt;)\n<p><code>content_type_string</code> &mdash; If a string is passed, it …\n"],["out_of_line?","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-out_of_line-3F","()","<p>Returns true if the element contains linked content.\n"],["out_of_line?","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-out_of_line-3F","()",""],["out_of_space_message","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-out_of_space_message","()",""],["outact","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-outact","(f, t, act)",""],["outdated","Bundler::CLI","Bundler/CLI.html#method-i-outdated","(*gems)",""],["outdated","Gem::Specification","Gem/Specification.html#method-c-outdated","()","<p>Return a list of all outdated local gem names.  This method is HEAVY as it must go fetch specifications …\n"],["outdated?","Bundler::CLI::Show","Bundler/CLI/Show.html#method-i-outdated-3F","(current, latest)",""],["outdated_and_latest_version","Gem::Specification","Gem/Specification.html#method-c-outdated_and_latest_version","()","<p>Enumerates the outdated local gems yielding the local specification and the latest remote version.\n<p>This …\n"],["output","Bundler::Molinillo::UI","Bundler/Molinillo/UI.html#method-i-output","()","<p>The {IO} object that should be used to print output. `STDOUT`, by default.\n<p>@return [IO]\n"],["output","Gem::MockGemUi","Gem/MockGemUi.html#method-i-output","()",""],["output","Gem::Resolver","Gem/Resolver.html#method-i-output","()",""],["output","Gem::Resolver::Molinillo::UI","Gem/Resolver/Molinillo/UI.html#method-i-output","()","<p>The {IO} object that should be used to print output. `STDOUT`, by default.\n<p>@return [IO]\n"],["output","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-output","(out)",""],["output=","Readline","Readline.html#method-c-output-3D","(p1)","<p>Specifies a File object <code>output</code> that is output stream for Readline.readline method.\n"],["output=","Reline::Core","Reline/Core.html#method-i-output-3D","(val)",""],["output?","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-output-3F","()","<p>Returns true if argument is output.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Internet Controls&#39;</span>, <span class=\"ruby-string\">&#39;DWebBrowserEvents&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["output_conflict","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-output_conflict","(out)","<p>Warnings\n"],["output_encoding=","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-output_encoding-3D","(enc)",""],["output_flag_file","RDoc::RDoc","RDoc/RDoc.html#method-i-output_flag_file","(op_dir)","<p>Return the path name of the flag file in an output directory.\n"],["output_modifier_proc=","Reline::Core","Reline/Core.html#method-i-output_modifier_proc-3D","(p)",""],["output_name","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-output_name","(context)","<p>Name for output to HTML.  For class methods the full name with a “.” is used like <code>SomeClass.method_name</code> …\n"],["output_post_install_messages","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-output_post_install_messages","(messages)",""],["output_query_results","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-output_query_results","(spec_tuples)",""],["output_rule","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-output_rule","(out)","<p>Rules\n"],["output_state","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-output_state","(out)","<p>States\n"],["output_token","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-output_token","(out)","<p>Tokens\n"],["output_useless","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-output_useless","(out)",""],["output_versions","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-output_versions","(output, versions)",""],["output_without_groups_message","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-output_without_groups_message","(command)",""],["outrrconf","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-outrrconf","(f, confs)",""],["outsrconf","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-outsrconf","(f, confs)",""],["override_for","Bundler::Source::Git","Bundler/Source/Git.html#method-i-override_for","(path)",""],["owned?","File","File.html#method-c-owned-3F","(p1)","<p>Returns <code>true</code> if the named file exists and the effective used id of the calling process is the owner of …\n"],["owned?","File::Stat","File/Stat.html#method-i-owned-3F","()","<p>Returns <code>true</code> if the effective user id of the process is the same as the owner of <em>stat</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">owned?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["owned?","FileTest","FileTest.html#method-i-owned-3F","(p1)","<p>Returns <code>true</code> if the named file exists and the effective used id of the calling process is the owner of …\n"],["owned?","Mutex","Mutex.html#method-i-owned-3F","()","<p>Returns <code>true</code> if this lock is currently held by current thread.\n"],["owned?","Pathname","Pathname.html#method-i-owned-3F","()","<p>See FileTest.owned?.\n"],["owner","Method","Method.html#method-i-owner","()","<p>Returns the class or module that defines the method. See also Method#receiver.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:map</span>).<span class=\"ruby-identifier\">owner</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["owner","UnboundMethod","UnboundMethod.html#method-i-owner","()","<p>Returns the class or module that defines the method. See also Method#receiver.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:map</span>).<span class=\"ruby-identifier\">owner</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["p","Kernel","Kernel.html#method-i-p","(*args)","<p>For each object, directly writes <em>obj</em>.<code>inspect</code> followed by a newline to the program&#39;s standard output. …\n"],["p","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-p","()","<p>Returns the permutation matrix <code>P</code>\n"],["pack","Array","Array.html#method-i-pack","(fmt, buffer: nil)","<p>Packs the contents of <em>arr</em> into a binary sequence according to the directives in <em>aTemplateString</em> (see …\n"],["pack","Racc::States","Racc/States.html#method-i-pack","(state)",""],["pack_sockaddr_in","Socket","Socket.html#method-c-pack_sockaddr_in","(p1, p2)","<p>Packs <em>port</em> and <em>host</em> as an AF_INET/AF_INET6 sockaddr string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">sockaddr_in</span>(<span class=\"ruby-value\">80</span>, <span class=\"ruby-string\">&quot;127.0.0.1&quot;</span>)\n<span class=\"ruby-comment\">#=&gt; &quot;\\x02\\x00\\x00P\\x7F\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00&quot; ...</span>\n</pre>\n"],["pack_sockaddr_un","Socket","Socket.html#method-c-pack_sockaddr_un","(p1)","<p>Packs <em>path</em> as an AF_UNIX sockaddr string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">sockaddr_un</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>) <span class=\"ruby-comment\">#=&gt; &quot;\\x01\\x00/tmp/sock\\x00\\x00...&quot;</span>\n</pre>\n"],["package_name","Bundler::Thor","Bundler/Thor.html#method-c-package_name","(name, _ = {})","<p>Allows for custom “Command” package naming.\n<p>Parameters\n<p>name&lt;String&gt; options&lt;Hash&gt; …\n"],["padding=","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-padding-3D","(value)","<p>Sets the output padding, not allowing less than zero values.\n"],["padding=","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-padding-3D","(p1)","<p>Enables or disables padding. By default encryption operations are padded using standard block padding …\n"],["page","RDoc::Store","RDoc/Store.html#method-i-page","(name)","<p>Returns the RDoc::TopLevel that is a text file and has the given <code>name</code>\n"],["page_file","RDoc::Store","RDoc/Store.html#method-i-page_file","(page_name)","<p>Path to the ri data for <code>page_name</code>\n"],["page_name","RDoc::TopLevel","RDoc/TopLevel.html#method-i-page_name","()","<p>Base name of this file without the extension\n"],["pair","Socket","Socket.html#method-c-pair","(p1, p2, p3 = v3)","<p>Creates a pair of sockets connected each other.\n<p><em>domain</em> should be a communications domain such as: :INET, …\n"],["pair","UNIXSocket","UNIXSocket.html#method-c-pair","(p1 = v1, p2 = v2)","<p>Creates a pair of sockets connected to each other.\n<p><em>socktype</em> should be a socket type such as: :STREAM, …\n"],["paragraph","RDoc::Markdown","RDoc/Markdown.html#method-i-paragraph","(parts)","<p>Creates an RDoc::Markup::Paragraph from <code>parts</code> and including\nextension-specific behavior\n"],["parallel_compact_index_client","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-parallel_compact_index_client","()",""],["param_list","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-param_list","()","<p>A list of this method&#39;s method and yield parameters.  <code>call-seq</code> params are preferred over parsed method …\n"],["param_seq","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-param_seq","()","<p>Pretty parameter list for this method.  If the method&#39;s parameters were given by <code>call-seq</code> it is preferred …\n"],["parameters","Method","Method.html#method-i-parameters","()","<p>Returns the parameter information of this method.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">foo</span>(<span class=\"ruby-identifier\">bar</span>); <span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:foo</span>).<span class=\"ruby-identifier\">parameters</span> <span class=\"ruby-comment\">#=&gt; [[:req, ...</span>\n</pre>\n"],["parameters","Proc","Proc.html#method-i-parameters","()","<p>Returns the parameter information of this proc.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">prc</span> = <span class=\"ruby-identifier\">lambda</span>{<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">x</span>, <span class=\"ruby-identifier\">y</span>=<span class=\"ruby-value\">42</span>, <span class=\"ruby-operator\">*</span><span class=\"ruby-identifier\">other</span><span class=\"ruby-operator\">|</span>}\n<span class=\"ruby-identifier\">prc</span>.<span class=\"ruby-identifier\">parameters</span>  <span class=\"ruby-comment\">#=&gt; [[:req, ...</span>\n</pre>\n"],["parameters","TracePoint","TracePoint.html#method-i-parameters","()","<p>Return the parameters definition of the method or block that the current hook belongs to. Format is the …\n"],["parameters","UnboundMethod","UnboundMethod.html#method-i-parameters","()","<p>Returns the parameter information of this method.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">def</span> <span class=\"ruby-identifier ruby-title\">foo</span>(<span class=\"ruby-identifier\">bar</span>); <span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:foo</span>).<span class=\"ruby-identifier\">parameters</span> <span class=\"ruby-comment\">#=&gt; [[:req, ...</span>\n</pre>\n"],["params","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-params","()","<p>Stores all parameters of key to the hash INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don&#39;t use …\n"],["params","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-params","()","<p>Stores all parameters of key to the hash INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don&#39;t use …\n"],["params","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-params","()","<p>THIS METHOD IS INSECURE, PRIVATE INFORMATION CAN LEAK OUT!!!\n<p>Stores all parameters of key to the hash. …\n"],["params","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-params","()","<p>returns array of WIN32OLE_PARAM object corresponding with method parameters.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["params","Zlib::Deflate","Zlib/Deflate.html#method-i-params","(p1, p2)","<p>Changes the parameters of the deflate stream to allow changes between different types of data that require …\n"],["params=","CGI::QueryExtension","CGI/QueryExtension.html#method-i-params-3D","(hash)","<p>Set all the parameters.\n"],["params_ok?","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-params_ok-3F","()","<p>Validates the Diffie-Hellman parameters associated with this instance. It checks whether a safe prime …\n"],["paranoid","Gem::Indexer","Gem/Indexer.html#method-i-paranoid","(path, extension)","<p>Ensure <code>path</code> and path with <code>extension</code> are identical.\n"],["parent","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-parent","()","<p>Return the ActivationRequest that contained the dependency that we were activated for.\n"],["parent","Pathname","Pathname.html#method-i-parent","()","<p>Returns the parent directory.\n<p>This is same as <code>self + &#39;..&#39;</code>.\n"],["parent","RDoc::CodeObject","RDoc/CodeObject.html#method-i-parent","()","<p>Our parent CodeObject.  The parent may be missing for classes loaded from legacy RI data stores.\n"],["parent","REXML::Light::Node","REXML/Light/Node.html#method-i-parent","()",""],["parent=","REXML::Child","REXML/Child.html#method-i-parent-3D","( other )","<p>Sets the parent of this child to the supplied argument.\n<p>other &mdash; Must be a Parent object.  If this object …\n"],["parent=","REXML::Light::Node","REXML/Light/Node.html#method-i-parent-3D","( node )",""],["parent=","REXML::Text","REXML/Text.html#method-i-parent-3D","(parent)",""],["parent?","REXML::Node","REXML/Node.html#method-i-parent-3F","()",""],["parent?","REXML::Parent","REXML/Parent.html#method-i-parent-3F","()",""],["parent_file_name","RDoc::CodeObject","RDoc/CodeObject.html#method-i-parent_file_name","()","<p>File name of our parent\n"],["parent_name","RDoc::CodeObject","RDoc/CodeObject.html#method-i-parent_name","()","<p>Name of our parent\n"],["parent_name","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-parent_name","()","<p>Name of our parent with special handling for un-marshaled methods\n"],["parent_of","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-parent_of","(requirement)","<p>@return [Object] the requirement that led to `requirement` being added\n\n<pre>to the list of requirements.</pre>\n"],["parent_of","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-parent_of","(requirement)","<p>@return [Object] the requirement that led to `requirement` being added\n\n<pre>to the list of requirements.</pre>\n"],["parent_setting_for","Bundler::Settings","Bundler/Settings.html#method-i-parent_setting_for","(name)",""],["parse","Bundler::Settings::Mirrors","Bundler/Settings/Mirrors.html#method-i-parse","(key, value)",""],["parse","Bundler::URI","Bundler/URI.html#method-c-parse","(uri)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-identifier\">uri_str</span>)\n</pre>\n<p>Args\n"],["parse","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-parse","(uri)","<p>Args\n<p><code>uri</code> &mdash; String\n\n<p>Description\n"],["parse","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-parse","(uri)","<p>Args\n<p><code>uri</code> &mdash; String\n\n<p>Description\n"],["parse","CGI","CGI.html#method-c-parse","(query)","<p>Parse an HTTP query string into a hash of key=&gt;value pairs.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">params</span> = <span class=\"ruby-constant\">CGI</span>.<span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-string\">&quot;query_string&quot;</span>)\n  <span class=\"ruby-comment\"># ...</span>\n</pre>\n"],["parse","CGI::Cookie","CGI/Cookie.html#method-c-parse","(raw_cookie)","<p>Parse a raw cookie string into a hash of cookie-name=&gt;Cookie pairs.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">cookies</span> = <span class=\"ruby-constant\">CGI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Cookie</span>.<span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-string\">&quot;raw_cookie_string&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["parse","CSV","CSV.html#method-c-parse","(str, **options, &block)","<p>This method can be used to easily parse CSV out of a String. You may either provide a <code>block</code> which will …\n"],["parse","CSV::Parser","CSV/Parser.html#method-i-parse","(&block)",""],["parse","Date","Date.html#method-c-parse","(p1 = v1, p2 = v2, p3 = v3, p4 = {})","<p>Parses the given representation of date and time, and creates a date object.  This method does not function …\n"],["parse","DateTime","DateTime.html#method-c-parse","(p1 = v1, p2 = v2, p3 = v3, p4 = {})","<p>Parses the given representation of date and time, and creates a DateTime object.  This method does not …\n"],["parse","Gem::RequestSet::Lockfile::Parser","Gem/RequestSet/Lockfile/Parser.html#method-i-parse","()",""],["parse","Gem::Requirement","Gem/Requirement.html#method-c-parse","(obj)","<p>Parse <code>obj</code>, returning an <code>[op, version]</code> pair. <code>obj</code> can be a String or a Gem::Version.\n<p>If <code>obj</code> is a String …\n"],["parse","Gem::UriParser","Gem/UriParser.html#method-i-parse","(uri)","<p>Parses the #uri, returning the original uri if it&#39;s invalid\n"],["parse","JSON","JSON.html#method-i-parse","(source, opts = {})","<p>Parse the JSON document <em>source</em> into a Ruby data structure and return it.\n<p><em>opts</em> can have the following keys: …\n"],["parse","JSON::Ext::Parser","JSON/Ext/Parser.html#method-i-parse","()","<p>Parses the current JSON text <em>source</em> and returns the complete data structure as a result.\n"],["parse","Net::SMTP::Response","Net/SMTP/Response.html#method-c-parse","(str)","<p>Parses the received response and separates the reply code and the human readable reply text\n"],["parse","OpenSSL::Config","OpenSSL/Config.html#method-c-parse","(string)","<p>Parses a given <em>string</em> as a blob that contains configuration for OpenSSL.\n<p>If the source of the IO is a …\n"],["parse","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-c-parse","(str, template=OBJECT_TYPE_TEMPLATE)",""],["parse","OptionParser","OptionParser.html#method-i-parse","(*argv, into: nil)","<p>Parses command line arguments <code>argv</code> in order when environment variable POSIXLY_CORRECT is set, and in …\n"],["parse","OptionParser::Switch::NoArgument","OptionParser/Switch/NoArgument.html#method-i-parse","(arg, argv)","<p>Raises an exception if any arguments given.\n"],["parse","OptionParser::Switch::OptionalArgument","OptionParser/Switch/OptionalArgument.html#method-i-parse","(arg, argv, &error)","<p>Parses argument if given, or uses default value.\n"],["parse","OptionParser::Switch::PlacedArgument","OptionParser/Switch/PlacedArgument.html#method-i-parse","(arg, argv, &error)","<p>Returns nil if argument is not present or begins with &#39;-&#39;.\n"],["parse","OptionParser::Switch::RequiredArgument","OptionParser/Switch/RequiredArgument.html#method-i-parse","(arg, argv)","<p>Raises an exception if argument is not present.\n"],["parse","Psych","Psych.html#method-c-parse","(yaml, legacy_filename = NOT_GIVEN, filename: nil, fallback: NOT_GIVEN)","<p>Parse a YAML string in <code>yaml</code>.  Returns the Psych::Nodes::Document. <code>filename</code> is used in the exception message …\n"],["parse","Psych::Parser","Psych/Parser.html#method-i-parse","(p1, p2 = v2)","<p>Parse the YAML document contained in <code>yaml</code>.  Events will be called on the handler set on the parser instance. …\n"],["parse","RDoc::ClassModule","RDoc/ClassModule.html#method-i-parse","(comment_location)","<p>Parses <code>comment_location</code> into an RDoc::Markup::Document composed of multiple RDoc::Markup::Documents with …\n"],["parse","RDoc::Comment","RDoc/Comment.html#method-i-parse","()","<p>Parses the comment into an RDoc::Markup::Document.  The parsed document is cached until the text is changed. …\n"],["parse","RDoc::Markdown","RDoc/Markdown.html#method-c-parse","(markdown)","<p>Parses the <code>markdown</code> document into an RDoc::Document using the default\nextensions.\n"],["parse","RDoc::Markdown","RDoc/Markdown.html#method-i-parse","(markdown)","<p>Parses <code>markdown</code> into an RDoc::Document\n"],["parse","RDoc::Markup","RDoc/Markup.html#method-c-parse","(str)","<p>Parses <code>str</code> into an RDoc::Markup::Document.\n"],["parse","RDoc::Options","RDoc/Options.html#method-i-parse","(argv)","<p>Parses command line options.\n"],["parse","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-c-parse","(code)",""],["parse","RDoc::RD","RDoc/RD.html#method-c-parse","(rd)","<p>Parses <code>rd</code> source and returns an RDoc::Markup::Document.  If the <code>=begin</code> or <code>=end</code> lines are missing they …\n"],["parse","RDoc::Text","RDoc/Text.html#method-i-parse","(text, format = 'rdoc')","<p>Normalizes <code>text</code> then builds a RDoc::Markup::Document from it\n"],["parse","RDoc::TomDoc","RDoc/TomDoc.html#method-c-parse","(text)","<p>Parses TomDoc from text\n<p>text &mdash; A String containing TomDoc-format text.\n\n<p>Examples\n"],["parse","REXML::DTD::Parser","REXML/DTD/Parser.html#method-c-parse","( input )",""],["parse","REXML::Parsers::LightParser","REXML/Parsers/LightParser.html#method-i-parse","()",""],["parse","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-parse","()",""],["parse","REXML::Parsers::StreamParser","REXML/Parsers/StreamParser.html#method-i-parse","()",""],["parse","REXML::Parsers::TreeParser","REXML/Parsers/TreeParser.html#method-i-parse","()",""],["parse","REXML::Parsers::UltraLightParser","REXML/Parsers/UltraLightParser.html#method-i-parse","()",""],["parse","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-parse","(path)",""],["parse","REXML::XPathParser","REXML/XPathParser.html#method-i-parse","(path, nodeset)",""],["parse","RSS::BaseParser","RSS/BaseParser.html#method-i-parse","()",""],["parse","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-c-parse","(duration, do_validate=true)",""],["parse","RSS::Parser","RSS/Parser.html#method-c-parse","(rss, *args)",""],["parse","RSS::Utils::CSV","RSS/Utils/CSV.html#method-i-parse","(value, &block)",""],["parse","RSS::Utils::ExplicitCleanOther","RSS/Utils/ExplicitCleanOther.html#method-i-parse","(value)",""],["parse","RSS::Utils::YesOther","RSS/Utils/YesOther.html#method-i-parse","(value)",""],["parse","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-c-parse","(src, filename = '-', lineno = 1)",""],["parse","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-parse","(src, filename = '-', lineno = 1)",""],["parse","Ripper","Ripper.html#method-c-parse","(src, filename = '(ripper)', lineno = 1)","<p>Parses the given Ruby program read from <code>src</code>. <code>src</code> must be a String or an IO or a object with a #gets method. …\n"],["parse","Ripper","Ripper.html#method-i-parse","()","<p>Start parsing and returns the value of the root action.\n"],["parse","Ripper::Filter","Ripper/Filter.html#method-i-parse","(init = nil)","<p>Starts the parser. <code>init</code> is a data accumulator and is passed to the next event handler (as of Enumerable#inject …\n"],["parse","RubyVM::AbstractSyntaxTree","RubyVM/AbstractSyntaxTree.html#method-c-parse","(string)","<p>Parses the given <em>string</em> into an abstract syntax tree, returning the root node of that tree.\n<p>SyntaxError …\n"],["parse","Time","Time.html#method-c-parse","(date, now=self.now)","<p>Takes a string representation of a Time and attempts to parse it using a heuristic.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;time&#39;</span>\n\n<span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-string\">&quot;2010-10-31&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["parse","URI","URI.html#method-c-parse","(uri)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-identifier\">uri_str</span>)\n</pre>\n<p>Args\n"],["parse","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-parse","(uri)","<p>Args\n<p><code>uri</code> &mdash; String\n\n<p>Description\n"],["parse","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-parse","(uri)","<p>Args\n<p><code>uri</code> &mdash; String\n\n<p>Description\n"],["parse","WEBrick::Cookie","WEBrick/Cookie.html#method-c-parse","(str)","<p>Parses a Cookie field sent from the user-agent.  Returns an array of cookies.\n"],["parse","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-parse","(socket=nil)","<p>Parses a request from <code>socket</code>.  This is called internally by WEBrick::HTTPServer.\n"],["parse!","Gem::UriParser","Gem/UriParser.html#method-i-parse-21","(uri)","<p>Parses the #uri, raising if it&#39;s invalid\n"],["parse!","JSON","JSON.html#method-i-parse-21","(source, opts = {})","<p>Parse the JSON document <em>source</em> into a Ruby data structure and return it. The bang version of the parse …\n"],["parse!","OptionParser","OptionParser.html#method-i-parse-21","(argv = default_argv, into: nil)","<p>Same as #parse, but removes switches destructively. Non-option arguments remain in <code>argv</code>.\n"],["parse!","OptionParser::Arguable","OptionParser/Arguable.html#method-i-parse-21","()","<p>Parses <code>self</code> destructively and returns <code>self</code> containing the rest arguments left unparsed.\n"],["parse_alias","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_alias","(context, single, tk, comment)","<p>Parses an <code>alias</code> in <code>context</code> with <code>comment</code>\n"],["parse_arg","OptionParser::Switch","OptionParser/Switch.html#method-i-parse_arg","(arg)","<p>Parses <code>arg</code> and returns rest of <code>arg</code> and matched portion to the argument pattern. Yields when the pattern …\n"],["parse_args","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-parse_args","( string )",""],["parse_args","REXML::QuickPath","REXML/QuickPath.html#method-c-parse_args","( element, string )",""],["parse_attr","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_attr","(context, single, tk, comment)","<p>Creates an RDoc::Attr for the name following <code>tk</code>, setting the comment to <code>comment</code>.\n"],["parse_attr_accessor","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_attr_accessor","(context, single, tk, comment)","<p>Creates an RDoc::Attr for each attribute listed after <code>tk</code>, setting the comment for each to <code>comment</code>.\n"],["parse_attributes","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-parse_attributes","(prefixes, curr_ns)",""],["parse_bind_options","Fiddle::Importer","Fiddle/Importer.html#method-i-parse_bind_options","(opts)",""],["parse_bundled_with","Bundler::LockfileParser","Bundler/LockfileParser.html#method-i-parse_bundled_with","(line)",""],["parse_call_parameters","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_call_parameters","(tk)","<p>Extracts call parameters from the token stream.\n"],["parse_class","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_class","(container, single, tk, comment)","<p>Parses a class in <code>context</code> with <code>comment</code>\n"],["parse_column_end","CSV::Parser","CSV/Parser.html#method-i-parse_column_end","()",""],["parse_column_value","CSV::Parser","CSV/Parser.html#method-i-parse_column_value","()",""],["parse_comment","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_comment","(container, tk, comment)","<p>Generates an RDoc::Method or RDoc::Attr from <code>comment</code> by looking for :method: or :attr: directives in …\n"],["parse_comment_tomdoc","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_comment_tomdoc","(container, tk, comment)","<p>Creates an RDoc::Method on <code>container</code> from <code>comment</code> if there is a Signature section in the comment\n"],["parse_config","OpenSSL::Config","OpenSSL/Config.html#method-c-parse_config","(io)","<p>Parses the configuration data read from <em>io</em>, see also #parse.\n<p>Raises a ConfigError on invalid configuration …\n"],["parse_config_lines","OpenSSL::Config","OpenSSL/Config.html#method-c-parse_config_lines","(io)",""],["parse_constant","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_constant","(container, tk, comment, ignore_constants = false)","<p>Parses a constant in <code>context</code> with <code>comment</code>.  If <code>ignore_constants</code> is true, no found constants will be added …\n"],["parse_constant_visibility","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_constant_visibility","(container, single, tk)","<p>Parses a Module#private_constant or Module#public_constant call from <code>tk</code>.\n"],["parse_ctype","Fiddle::CParser","Fiddle/CParser.html#method-i-parse_ctype","(ty, tymap=nil)","<p>Given a String of C type <code>ty</code>, returns the corresponding Fiddle constant.\n<p><code>ty</code> can also accept an Array of …\n"],["parse_dependency","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-parse_dependency","(string)",""],["parse_dependency","Bundler::LockfileParser","Bundler/LockfileParser.html#method-i-parse_dependency","(line)",""],["parse_dn","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-parse_dn","()","<p>Private method to cleanup <code>dn</code> from using the <code>path</code> component attribute.\n"],["parse_dn","URI::LDAP","URI/LDAP.html#method-i-parse_dn","()","<p>Private method to cleanup <code>dn</code> from using the <code>path</code> component attribute.\n"],["parse_dot_doc_file","RDoc::RDoc","RDoc/RDoc.html#method-i-parse_dot_doc_file","(in_dir, filename)","<p>The .document file contains a list of file and directory name patterns, representing candidates for documentation. …\n"],["parse_entries","RDoc::Parser::ChangeLog","RDoc/Parser/ChangeLog.html#method-i-parse_entries","()","<p>Parses the entries in the ChangeLog.\n<p>Returns an Array of each ChangeLog entry in order of parsing.\n<p>A ChangeLog …\n"],["parse_file","Psych","Psych.html#method-c-parse_file","(filename, fallback: false)","<p>Parse a file at <code>filename</code>. Returns the Psych::Nodes::Document.\n<p>Raises a Psych::SyntaxError when a YAML …\n"],["parse_file","RDoc::RDoc","RDoc/RDoc.html#method-i-parse_file","(filename)","<p>Parses <code>filename</code> and returns an RDoc::TopLevel\n"],["parse_file","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-c-parse_file","(filename)",""],["parse_file","RubyVM::AbstractSyntaxTree","RubyVM/AbstractSyntaxTree.html#method-c-parse_file","(pathname)","<p>Reads the file from <em>pathname</em>, then parses it like ::parse, returning the root node of the abstract syntax …\n"],["parse_files","RDoc::RDoc","RDoc/RDoc.html#method-i-parse_files","(files)","<p>Parse each file on the command line, recursively entering directories.\n"],["parse_files_matching","RDoc::Parser","RDoc/Parser.html#method-c-parse_files_matching","(regexp)","<p>Record which file types this parser can understand.\n<p>It is ok to call this multiple times.\n"],["parse_form_data","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-parse_form_data","(io, boundary)","<p>Parses form data in <code>io</code> with the given <code>boundary</code>\n"],["parse_form_data","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-parse_form_data","(io, boundary)","<p>Parses form data in <code>io</code> with the given <code>boundary</code>\n"],["parse_gem","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-parse_gem","(string)",""],["parse_header","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-parse_header","(raw)","<p>Parses an HTTP header <code>raw</code> into a hash of header fields with an Array of values.\n"],["parse_header","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-parse_header","(raw)","<p>Parses an HTTP header <code>raw</code> into a hash of header fields with an Array of values.\n"],["parse_headers","CSV::Parser","CSV/Parser.html#method-i-parse_headers","(row)",""],["parse_helper","REXML::DTD::Parser","REXML/DTD/Parser.html#method-c-parse_helper","( input )","<p>Takes a String and parses it out\n"],["parse_id","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-parse_id","(base_error_message, accept_external_id:, accept_public_id:)",""],["parse_id_invalid_details","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-parse_id_invalid_details","(accept_external_id:, accept_public_id:)",""],["parse_int","Psych::ScalarScanner","Psych/ScalarScanner.html#method-i-parse_int","(string)","<p>Parse and return an int from <code>string</code>\n"],["parse_line","CSV","CSV.html#method-c-parse_line","(line, **options)","<p>This method is a shortcut for converting a single line of a CSV String into an Array. Note that if <code>line</code> …\n"],["parse_line_number_from_description","Bundler::Dsl::DSLError","Bundler/Dsl/DSLError.html#method-i-parse_line_number_from_description","()",""],["parse_make_command_line","Gem::TestCase","Gem/TestCase.html#method-i-parse_make_command_line","(line)",""],["parse_meta_attr","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_meta_attr","(context, single, tk, comment)","<p>Parses a meta-programmed attribute and creates an RDoc::Attr.\n<p>To create foo and bar attributes on class …\n"],["parse_meta_method","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_meta_method","(container, single, tk, comment)","<p>Parses a meta-programmed method\n"],["parse_metadata","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-parse_metadata","(data)",""],["parse_method","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_method","(container, single, tk, comment)","<p>Parses a normal method defined by <code>def</code>\n"],["parse_method_dummy","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_method_dummy","(container)","<p>Parses a method that needs to be ignored.\n"],["parse_method_or_yield_parameters","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_method_or_yield_parameters","(method = nil, modifiers = RDoc::METHOD_MODIFIERS)","<p>Extracts <code>yield</code> parameters from <code>method</code>\n"],["parse_method_parameters","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_method_parameters","(method)","<p>Capture the method&#39;s parameters. Along the way, look for a comment containing:\n\n<pre class=\"ruby\"><span class=\"ruby-comment\"># yields: ....</span>\n</pre>\n<p>and add …\n"],["parse_method_params_and_body","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_method_params_and_body","(container, single, meth, added_container)","<p>Parses the parameters and body of <code>meth</code>\n"],["parse_mlsx_entry","Net::FTP","Net/FTP.html#method-i-parse_mlsx_entry","(entry)",""],["parse_module","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_module","(container, single, tk, comment)","<p>Parses an RDoc::NormalModule in <code>container</code> with <code>comment</code>\n"],["parse_name","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-parse_name","(base_error_message)",""],["parse_no_quote","CSV::Parser","CSV/Parser.html#method-i-parse_no_quote","(&block)",""],["parse_openssl","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-c-parse_openssl","(str, template=OBJECT_TYPE_TEMPLATE)",""],["parse_option_string","Racc::DebugFlags","Racc/DebugFlags.html#method-c-parse_option_string","(s)",""],["parse_pasv_ipv4_host","Net::FTP","Net/FTP.html#method-i-parse_pasv_ipv4_host","(s)",""],["parse_pasv_ipv6_host","Net::FTP","Net/FTP.html#method-i-parse_pasv_ipv6_host","(s)",""],["parse_pasv_port","Net::FTP","Net/FTP.html#method-i-parse_pasv_port","(s)",""],["parse_pi_content","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-parse_pi_content","(content)","<p>Extract the first name=“value” pair from content. Works with single quotes according to the …\n"],["parse_platform","Bundler::LockfileParser","Bundler/LockfileParser.html#method-i-parse_platform","(line)",""],["parse_printf_format","IRB::OutputMethod","IRB/OutputMethod.html#method-i-parse_printf_format","(format, opts)","<p>Returns an array of the given <code>format</code> and <code>opts</code> to be used by Kernel#sprintf, if there was a successful …\n"],["parse_query","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-parse_query","()","<p>Private method to cleanup <code>attributes</code>, <code>scope</code>, <code>filter</code>, and <code>extensions</code> from using the <code>query</code> component attribute. …\n"],["parse_query","URI::LDAP","URI/LDAP.html#method-i-parse_query","()","<p>Private method to cleanup <code>attributes</code>, <code>scope</code>, <code>filter</code>, and <code>extensions</code> from using the <code>query</code> component attribute. …\n"],["parse_query","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-parse_query","(str)","<p>Parses the query component of a URI in <code>str</code>\n"],["parse_query","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-parse_query","(str)","<p>Parses the query component of a URI in <code>str</code>\n"],["parse_quotable_loose","CSV::Parser","CSV/Parser.html#method-i-parse_quotable_loose","(&block)",""],["parse_quotable_robust","CSV::Parser","CSV/Parser.html#method-i-parse_quotable_robust","(&block)",""],["parse_quoted_column_value","CSV::Parser","CSV/Parser.html#method-i-parse_quoted_column_value","()",""],["parse_qvalues","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-parse_qvalues","(value)","<p>Parses q values in <code>value</code> as used in Accept headers.\n"],["parse_qvalues","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-parse_qvalues","(value)","<p>Parses q values in <code>value</code> as used in Accept headers.\n"],["parse_range_header","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-parse_range_header","(ranges_specifier)","<p>Parses a Range header value <code>ranges_specifier</code>\n"],["parse_range_header","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-parse_range_header","(ranges_specifier)","<p>Parses a Range header value <code>ranges_specifier</code>\n"],["parse_require","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_require","(context, comment)","<p>Parses an RDoc::Require in <code>context</code> containing <code>comment</code>\n"],["parse_rescue","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_rescue","()","<p>Parses a rescue\n"],["parse_rfc2253","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-c-parse_rfc2253","(str, template=OBJECT_TYPE_TEMPLATE)",""],["parse_row_end","CSV::Parser","CSV/Parser.html#method-i-parse_row_end","()",""],["parse_ruby","Bundler::LockfileParser","Bundler/LockfileParser.html#method-i-parse_ruby","(line)",""],["parse_set_cookie","WEBrick::Cookie","WEBrick/Cookie.html#method-c-parse_set_cookie","(str)","<p>Parses the cookie in <code>str</code>\n"],["parse_set_cookies","WEBrick::Cookie","WEBrick/Cookie.html#method-c-parse_set_cookies","(str)","<p>Parses the cookies in <code>str</code>\n"],["parse_signature","Fiddle::CParser","Fiddle/CParser.html#method-i-parse_signature","(signature, tymap=nil)","<p>Parses a C prototype signature\n<p>If Hash <code>tymap</code> is provided, the return value and the arguments from the …\n"],["parse_source","Bundler::LockfileParser","Bundler/LockfileParser.html#method-i-parse_source","(line)",""],["parse_source","REXML::DTD::EntityDecl","REXML/DTD/EntityDecl.html#method-c-parse_source","(source, listener)",""],["parse_source","REXML::DTD::NotationDecl","REXML/DTD/NotationDecl.html#method-c-parse_source","(source, listener)",""],["parse_spec","Bundler::LockfileParser","Bundler/LockfileParser.html#method-i-parse_spec","(line)",""],["parse_statements","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_statements","(container, single = NORMAL, current_method = nil, comment = new_comment(''))","<p>The core of the Ruby parser.\n"],["parse_stream","Psych","Psych.html#method-c-parse_stream","(yaml, legacy_filename = NOT_GIVEN, filename: nil, &block)","<p>Parse a YAML string in <code>yaml</code>.  Returns the Psych::Nodes::Stream. This method can handle multiple YAML …\n"],["parse_stream","REXML::Document","REXML/Document.html#method-c-parse_stream","( source, listener )",""],["parse_struct_signature","Fiddle::CParser","Fiddle/CParser.html#method-i-parse_struct_signature","(signature, tymap=nil)","<p>Parses a C struct&#39;s members\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;fiddle/import&#39;</span>\n\n<span class=\"ruby-identifier\">include</span> <span class=\"ruby-constant\">Fiddle</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">CParser</span>\n  <span class=\"ruby-comment\">#=&gt; Object ...</span>\n</pre>\n"],["parse_symbol_arg","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_symbol_arg","(no = nil)","<p>Parse up to <code>no</code> symbol arguments\n"],["parse_symbol_in_arg","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_symbol_in_arg","()","<p>Returns symbol text from the next token\n"],["parse_time","Psych::ScalarScanner","Psych/ScalarScanner.html#method-i-parse_time","(string)","<p>Parse and return a Time from <code>string</code>\n"],["parse_top_level_statements","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_top_level_statements","(container)","<p>Parses statements in the top-level <code>container</code>\n"],["parse_unquoted_column_value","CSV::Parser","CSV/Parser.html#method-i-parse_unquoted_column_value","()",""],["parse_uri","Gem::UriParsing","Gem/UriParsing.html#method-i-parse_uri","(source_uri)",""],["parse_user_code","Racc::GrammarFileParser","Racc/GrammarFileParser.html#method-i-parse_user_code","()","<p>User Code Block\n"],["parse_visibility","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_visibility","(container, single, tk)","<p>Determines the visibility in <code>container</code> from <code>tk</code>\n"],["parse_yield","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-parse_yield","(context, single, tk, method)","<p>Determines the block parameter for <code>context</code>\n"],["parser","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-parser","()","<p>Returns the parser to be used.\n<p>Unless a Bundler::URI::Parser is defined, DEFAULT_PARSER is used.\n"],["parser","CSV","CSV.html#method-i-parser","()",""],["parser","Gem::Command","Gem/Command.html#method-i-parser","()","<p>Create on demand parser.\n"],["parser","Psych","Psych.html#method-c-parser","()","<p>Returns a default parser\n"],["parser","URI::Generic","URI/Generic.html#method-i-parser","()","<p>Returns the parser to be used.\n<p>Unless a URI::Parser is defined, DEFAULT_PARSER is used.\n"],["parser=","RDoc::TopLevel","RDoc/TopLevel.html#method-i-parser-3D","(val)",""],["parser_class","Racc::Grammar","Racc/Grammar.html#method-i-parser_class","()",""],["parser_class","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-parser_class","(classname, superclass)",""],["parser_class","Racc::StateTransitionTable","Racc/StateTransitionTable.html#method-i-parser_class","()",""],["parser_enumerator","CSV","CSV.html#method-i-parser_enumerator","()",""],["parser_fields_converter","CSV","CSV.html#method-i-parser_fields_converter","()",""],["parser_file","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-parser_file","()",""],["parser_options","CSV","CSV.html#method-i-parser_options","()",""],["partition","Enumerable","Enumerable.html#method-i-partition","()","<p>Returns two arrays, the first containing the elements of <em>enum</em> for which the block evaluates to true, …\n"],["partition","String","String.html#method-i-partition","(p1)","<p>Searches <em>sep</em> or pattern (<em>regexp</em>) in the string and returns the part before it, the match, and the part …\n"],["pass","Thread","Thread.html#method-c-pass","()","<p>Give the thread scheduler a hint to pass execution to another thread. A running thread may or may not …\n"],["passwd","Etc","Etc.html#method-c-passwd","()","<p>Provides a convenient Ruby iterator which executes a block for each entry in the /etc/passwd file.\n<p>The …\n"],["password","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-password","()","<p>Returns the password component.\n"],["password","URI::Generic","URI/Generic.html#method-i-password","()","<p>Returns the password component.\n"],["password=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-password-3D","(password)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["password=","URI::Generic","URI/Generic.html#method-i-password-3D","(password)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["password_field","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-password_field","(name = \"\", value = nil, size = 40, maxlength = nil)","<p>Generate a Password Input element as a string.\n<p><code>name</code> is the name of the input field.  <code>value</code> is its default …\n"],["patch","Net::HTTP","Net/HTTP.html#method-i-patch","(path, data, initheader = nil, dest = nil)","<p>Sends a PATCH request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["patch_level_options","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-patch_level_options","(options)",""],["path","ARGF","ARGF.html#method-i-path","()","<p>Returns the current filename. “-” is returned when the current file is STDIN.\n<p>For example:\n\n<pre>$ ...</pre>\n"],["path","Bundler::Dsl","Bundler/Dsl.html#method-i-path","(path, options = {}, &blk)",""],["path","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-path","(obj)",""],["path","Bundler::Settings","Bundler/Settings.html#method-i-path","()","<p>for legacy reasons, in Bundler 2, we do not respect :disable_shared_gems\n"],["path","Bundler::Source::Git","Bundler/Source/Git.html#method-i-path","()",""],["path","Bundler::URI::FTP","Bundler/URI/FTP.html#method-i-path","()","<p>Returns the path from an FTP Bundler::URI.\n<p>RFC 1738 specifically states that the path for an FTP Bundler::URI …\n"],["path","CSV","CSV.html#method-i-path","()",""],["path","Dir","Dir.html#method-i-path","()","<p>Returns the path parameter passed to <em>dir</em>&#39;s constructor.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;..&quot;</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">path</span>   <span class=\"ruby-comment\">#=&gt; &quot;..&quot;</span>\n</pre>\n"],["path","File","File.html#method-c-path","(p1)","<p>Returns the string representation of the path\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">path</span>(<span class=\"ruby-string\">&quot;/dev/null&quot;</span>)          <span class=\"ruby-comment\">#=&gt; &quot;/dev/null&quot;</span>\n<span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">path</span>(<span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/tmp&quot;</span>)) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["path","File","File.html#method-i-path","()","<p>Returns the pathname used to create <em>file</em> as a string. Does not normalize the name.\n<p>The pathname may not …\n"],["path","Gem","Gem.html#method-c-path","()",""],["path","PStore","PStore.html#method-i-path","()","<p>Returns the path to the data store file.\n"],["path","RDoc::ClassModule","RDoc/ClassModule.html#method-i-path","()","<p>Path to this class or module for use with HTML generator output.\n"],["path","RDoc::Constant","RDoc/Constant.html#method-i-path","()","<p>Path to this constant for use with HTML generator output.\n"],["path","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-path","()","<p>Path to this method for use with HTML generator output.\n"],["path","RDoc::TopLevel","RDoc/TopLevel.html#method-i-path","()","<p>Path to this file for use with HTML generator output.\n"],["path","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-path","()","<p>Returns the path of this instruction sequence.\n<p><code>&lt;compiled&gt;</code> if the iseq was evaluated from a string. …\n"],["path","Tempfile","Tempfile.html#method-i-path","()","<p>Returns the full path name of the temporary file. This will be nil if #unlink has been called.\n"],["path","Thread::Backtrace::Location","Thread/Backtrace/Location.html#method-i-path","()","<p>Returns the file name of this frame.\n<p>For example, using <code>caller_locations.rb</code> from Thread::Backtrace::Location …\n"],["path","TracePoint","TracePoint.html#method-i-path","()","<p>Path of the file being run\n"],["path","UNIXSocket","UNIXSocket.html#method-i-path","()","<p>Returns the path of the local address of unixsocket.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">UNIXServer</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>)\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-identifier\">s</span>.<span class=\"ruby-identifier\">path</span> <span class=\"ruby-comment\">#=&gt; &quot;/tmp/sock&quot;</span>\n</pre>\n"],["path","URI::FTP","URI/FTP.html#method-i-path","()","<p>Returns the path from an FTP URI.\n<p>RFC 1738 specifically states that the path for an FTP URI does not include …\n"],["path","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-path","()","<p>Returns the type library file path.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlib</span> = <span class=\"ruby-constant\">WIN32OLE_TYPELIB</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["path2class","Psych::ClassLoader","Psych/ClassLoader.html#method-i-path2class","(p1)","<p>Convert <code>path</code> string to a class\n"],["path=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-path-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["path=","CGI::Cookie","CGI/Cookie.html#method-i-path-3D","(str)","<p>Set path for which this cookie applies\n"],["path=","URI::Generic","URI/Generic.html#method-i-path-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["path?","Bundler::Source","Bundler/Source.html#method-i-path-3F","()",""],["path_ok?","Gem::Uninstaller","Gem/Uninstaller.html#method-i-path_ok-3F","(gem_dir, spec)","<p>Is <code>spec</code> in <code>gem_dir</code>?\n"],["path_separator","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-path_separator","()",""],["path_separator","Gem","Gem.html#method-c-path_separator","()","<p>How String Gem paths should be split.  Overridable for esoteric platforms.\n"],["path_to?","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-path_to-3F","(other)","<p>Is there a path from `self` to `other` following edges in the dependency graph? @return true iff there …\n"],["path_to?","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-path_to-3F","(other)","<p>Is there a path from `self` to `other` following edges in the dependency graph? @return true iff there …\n"],["pathconf","IO","IO.html#method-i-pathconf","(p1)","<p>Returns pathname configuration variable using fpathconf().\n<p><em>name</em> should be a constant under <code>Etc</code> which begins …\n"],["paths","Bundler::Standalone","Bundler/Standalone.html#method-i-paths","()",""],["paths","Gem","Gem.html#method-c-paths","()","<p>Retrieve the PathSupport object that RubyGems uses to lookup files.\n"],["paths=","Gem","Gem.html#method-c-paths-3D","(env)","<p>Initialize the filesystem paths to use from <code>env</code>. <code>env</code> is a hash-like object (typically ENV) that is queried …\n"],["pattern","OptionParser::Switch","OptionParser/Switch.html#method-c-pattern","()",""],["pattern","OptionParser::Switch::NoArgument","OptionParser/Switch/NoArgument.html#method-c-pattern","()",""],["pause","RubyVM::MJIT","RubyVM/MJIT.html#method-c-pause","(p1 = {})",""],["pbkdf2_hmac","OpenSSL::KDF","OpenSSL/KDF.html#method-c-pbkdf2_hmac","(p1, p2 = {})","<p>PKCS #5 PBKDF2 (Password-Based Key Derivation Function 2) in combination with HMAC. Takes <em>pass</em>, <em>salt</em> …\n"],["pbkdf2_hmac","OpenSSL::PKCS5","OpenSSL/PKCS5.html#method-i-pbkdf2_hmac","(pass, salt, iter, keylen, digest)","<p>OpenSSL::PKCS5.pbkdf2_hmac has been renamed to OpenSSL::KDF.pbkdf2_hmac. This method is provided for …\n"],["pbkdf2_hmac_sha1","OpenSSL::PKCS5","OpenSSL/PKCS5.html#method-i-pbkdf2_hmac_sha1","(pass, salt, iter, keylen)",""],["peek","Enumerator","Enumerator.html#method-i-peek","()","<p>Returns the next object in the enumerator, but doesn&#39;t move the internal position forward.  If the …\n"],["peek","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-peek","()",""],["peek","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-peek","(depth=0)","<p>Peek at the <code>depth</code> event in the stack.  The first element on the stack is at depth 0.  If <code>depth</code> is -1, …\n"],["peek","REXML::Parsers::PullParser","REXML/Parsers/PullParser.html#method-i-peek","(depth=0)",""],["peek","StringScanner","StringScanner.html#method-i-peek","(p1)","<p>Extracts a string corresponding to <code>string[pos,len]</code>, without advancing the scan pointer.\n\n<pre>s = StringScanner.new(&#39;test ...</pre>\n"],["peek_read","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-peek_read","()","<p>Peek equivalent for get_tkread\n"],["peek_result","Coverage","Coverage.html#method-c-peek_result","()","<p>Returns a hash that contains filename as key and coverage array as value. This is the same as `Coverage.result(stop: …\n"],["peek_tk","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-peek_tk","()","<p>Peek at the next token, but don&#39;t remove it from the stream\n"],["peek_values","Enumerator","Enumerator.html#method-i-peek_values","()","<p>Returns the next object as an array, similar to Enumerator#next_values, but doesn&#39;t move the internal …\n"],["peep","StringScanner","StringScanner.html#method-i-peep","(p1)","<p>Equivalent to #peek. This method is obsolete; use #peek instead.\n"],["peer_cert","Net::HTTP","Net/HTTP.html#method-i-peer_cert","()","<p>Returns the X.509 certificates the server presented.\n"],["peer_cert","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-peer_cert","()","<p>The X509 certificate for this socket&#39;s peer.\n"],["peer_cert_chain","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-peer_cert_chain","()","<p>The X509 certificate chain for this socket&#39;s peer.\n"],["peeraddr","IPSocket","IPSocket.html#method-i-peeraddr","(*args)","<p>Returns the remote address as an array which contains address_family, port, hostname and numeric_address. …\n"],["peeraddr","OpenSSL::SSL::SocketForwarder","OpenSSL/SSL/SocketForwarder.html#method-i-peeraddr","()",""],["peeraddr","UNIXSocket","UNIXSocket.html#method-i-peeraddr","()","<p>Returns the remote address as an array which contains address_family and unix_path.\n<p>Example\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">serv</span> = <span class=\"ruby-constant\">UNIXServer</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["peg_parse","RDoc::Markdown","RDoc/Markdown.html#method-i-peg_parse","(markdown)","<p>The internal kpeg parse method\n"],["pem_files_in","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-pem_files_in","(dir)",""],["pending","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-pending","()","<p>The number of bytes that are immediately available for reading.\n"],["pending_interrupt?","Thread","Thread.html#method-c-pending_interrupt-3F","(*args)","<p>Returns whether or not the asynchronous queue is empty.\n<p>Since Thread::handle_interrupt can be used to …\n"],["pending_interrupt?","Thread","Thread.html#method-i-pending_interrupt-3F","(*args)","<p>Returns whether or not the asynchronous queue is empty for the target thread.\n<p>If <code>error</code> is given, then …\n"],["percent_doc","RDoc::Stats","RDoc/Stats.html#method-i-percent_doc","()","<p>Calculates the percentage of items documented.\n"],["perform_bundle_install","Bundler::CLI::Add","Bundler/CLI/Add.html#method-i-perform_bundle_install","()",""],["perform_git_push","Bundler::GemHelper","Bundler/GemHelper.html#method-i-perform_git_push","(options = \"\")",""],["permanent_link=","RSS::Maker::ItemsBase::ItemBase::GuidBase","RSS/Maker/ItemsBase/ItemBase/GuidBase.html#method-i-permanent_link-3D","(bool)",""],["permanent_link?","RSS::Maker::ItemsBase::ItemBase::GuidBase","RSS/Maker/ItemsBase/ItemBase/GuidBase.html#method-i-permanent_link-3F","()",""],["permutation","Array","Array.html#method-i-permutation","(*args)","<p>When invoked with a block, yield all permutations of length <code>n</code> of the elements of the array, then return …\n"],["permutation?","Matrix","Matrix.html#method-i-permutation-3F","()","<p>Returns <code>true</code> if this is a permutation matrix Raises an error if matrix is not square.\n"],["permute","OptionParser","OptionParser.html#method-i-permute","(*argv, into: nil)","<p>Parses command line arguments <code>argv</code> in permutation mode and returns list of non-option arguments. When …\n"],["permute!","OptionParser","OptionParser.html#method-i-permute-21","(argv = default_argv, into: nil)","<p>Same as #permute, but removes switches destructively. Non-option arguments remain in <code>argv</code>.\n"],["permute!","OptionParser::Arguable","OptionParser/Arguable.html#method-i-permute-21","()","<p>Parses <code>self</code> destructively in permutation mode and returns <code>self</code> containing the rest arguments left unparsed. …\n"],["pfamily","Addrinfo","Addrinfo.html#method-i-pfamily","()","<p>returns the protocol family as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">pfamily</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">PF_INET</span> <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["phase","Complex","Complex.html#method-i-phase","()","<p>Returns the angle part of its polar form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>.<span class=\"ruby-identifier\">polar</span>(<span class=\"ruby-value\">3</span>, <span class=\"ruby-constant\">Math</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">PI</span><span class=\"ruby-operator\">/</span><span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">arg</span>  <span class=\"ruby-comment\">#=&gt; 1.5707963267948966</span>\n</pre>\n"],["phase","Float","Float.html#method-i-phase","()","<p>Returns 0 if the value is positive, pi otherwise.\n"],["phase","Numeric","Numeric.html#method-i-phase","()","<p>Returns 0 if the value is positive, pi otherwise.\n"],["pick_best!","Gem::AvailableSet","Gem/AvailableSet.html#method-i-pick_best-21","()",""],["pid","IO","IO.html#method-i-pid","()","<p>Returns the process ID of a child process associated with <em>ios</em>. This will be set by IO.popen.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">pipe</span> = <span class=\"ruby-constant\">IO</span>.<span class=\"ruby-identifier\">popen</span>(<span class=\"ruby-string\">&quot;-&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["pid","Process","Process.html#method-c-pid","()","<p>Returns the process id of this process. Not available on all platforms.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">pid</span>   <span class=\"ruby-comment\">#=&gt; 27415</span>\n</pre>\n"],["pid","Process::Status","Process/Status.html#method-i-pid","()","<p>Returns the process ID that this status object represents.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">fork</span> { <span class=\"ruby-identifier\">exit</span> }   <span class=\"ruby-comment\">#=&gt; 26569</span>\n<span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">wait</span>    <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["pid","StringIO","StringIO.html#method-i-pid","()","<p>Returns <code>nil</code>.  Just for compatibility to IO.\n"],["pin_gem_source","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-pin_gem_source","(name, type = :default, source = nil)","<p>Pins the gem <code>name</code> to the given <code>source</code>.  Adding a gem with the same name from a different <code>source</code> will …\n"],["pinned_spec_names","Bundler::Definition","Bundler/Definition.html#method-i-pinned_spec_names","(skip = nil)",""],["pipe","IO","IO.html#method-c-pipe","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a pair of pipe endpoints (connected to each other) and returns them as a two-element array of …\n"],["pipe?","File","File.html#method-c-pipe-3F","(p1)","<p>Returns <code>true</code> if the named file is a pipe.\n<p><em>file_name</em> can be an IO object.\n"],["pipe?","File::Stat","File/Stat.html#method-i-pipe-3F","()","<p>Returns <code>true</code> if the operating system supports pipes and <em>stat</em> is a pipe; <code>false</code> otherwise.\n"],["pipe?","FileTest","FileTest.html#method-i-pipe-3F","(p1)","<p>Returns <code>true</code> if the named file is a pipe.\n<p><em>file_name</em> can be an IO object.\n"],["pipe?","Pathname","Pathname.html#method-i-pipe-3F","()","<p>See FileTest.pipe?.\n"],["pipeline","Open3","Open3.html#method-c-pipeline","(*cmds)","<p>Open3.pipeline starts a list of commands as a pipeline. It waits for the completion of the commands. …\n"],["pipeline","Open3","Open3.html#method-i-pipeline","(*cmds)","<p>Open3.pipeline starts a list of commands as a pipeline. It waits for the completion of the commands. …\n"],["pipeline_r","Open3","Open3.html#method-c-pipeline_r","(*cmds, &block)","<p>Open3.pipeline_r starts a list of commands as a pipeline with a pipe which connects to stdout of the …\n"],["pipeline_r","Open3","Open3.html#method-i-pipeline_r","(*cmds, &block)","<p>Open3.pipeline_r starts a list of commands as a pipeline with a pipe which connects to stdout of the …\n"],["pipeline_rw","Open3","Open3.html#method-i-pipeline_rw","(*cmds, &block)","<p>Open3.pipeline_rw starts a list of commands as a pipeline with pipes which connect to stdin of the first …\n"],["pipeline_rw","Open3","Open3.html#method-c-pipeline_rw","(*cmds, &block)","<p>Open3.pipeline_rw starts a list of commands as a pipeline with pipes which connect to stdin of the first …\n"],["pipeline_start","Open3","Open3.html#method-i-pipeline_start","(*cmds, &block)","<p>Open3.pipeline_start starts a list of commands as a pipeline. No pipes are created for stdin of the first …\n"],["pipeline_start","Open3","Open3.html#method-c-pipeline_start","(*cmds, &block)","<p>Open3.pipeline_start starts a list of commands as a pipeline. No pipes are created for stdin of the first …\n"],["pipeline_w","Open3","Open3.html#method-i-pipeline_w","(*cmds, &block)","<p>Open3.pipeline_w starts a list of commands as a pipeline with a pipe which connects to stdin of the first …\n"],["pipeline_w","Open3","Open3.html#method-c-pipeline_w","(*cmds, &block)","<p>Open3.pipeline_w starts a list of commands as a pipeline with a pipe which connects to stdin of the first …\n"],["pkcs5_keyivgen","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-pkcs5_keyivgen","(p1, p2 = v2, p3 = v3, p4 = v4)","<p>Generates and sets the key/IV based on a password.\n<p><strong>WARNING</strong>: This method is only PKCS5 v1.5 compliant when …\n"],["pkg_config","MakeMakefile","MakeMakefile.html#method-i-pkg_config","(pkg, option=nil)","<p>Returns compile/link information about an installed library in a tuple of <code>[cflags, ldflags, libs]</code>, by …\n"],["plain_specs","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-plain_specs","()",""],["plain_specs=","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-plain_specs-3D","(specs)",""],["platform","Bundler::CLI","Bundler/CLI.html#method-i-platform","()",""],["platform","Bundler::Dsl","Bundler/Dsl.html#method-i-platform","(*platforms)",""],["platform","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-platform","()","<p>Platform of the gem\n"],["platform","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-platform","(*platforms)","<p>Block form for restricting gems to a set of platforms.\n<p>The gem dependencies platform is different from …\n"],["platform","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-platform","()","<p>The platform of this activation request&#39;s specification\n"],["platform","Gem::Resolver::SpecSpecification","Gem/Resolver/SpecSpecification.html#method-i-platform","()","<p>The platform this gem works on.\n"],["platform","Gem::Specification","Gem/Specification.html#method-i-platform","()","<p>The platform this gem runs on.  See Gem::Platform for details.\n"],["platform=","Gem::Specification","Gem/Specification.html#method-i-platform-3D","(platform)","<p>The platform this gem runs on.\n<p>This is usually Gem::Platform::RUBY or Gem::Platform::CURRENT.\n<p>Most gems …\n"],["platform_defaults","Gem","Gem.html#method-c-platform_defaults","()","<p>Default options for gem commands for Ruby implementers.\n<p>The options here should be structured as an array …\n"],["platform_sort_key","Bundler::Resolver","Bundler/Resolver.html#method-c-platform_sort_key","(platform)",""],["platform_specificity_match","Bundler::GemHelpers","Bundler/GemHelpers.html#method-i-platform_specificity_match","(spec_platform, user_platform)",""],["platform_specificity_match","Bundler::GemHelpers","Bundler/GemHelpers.html#method-c-platform_specificity_match","(spec_platform, user_platform)",""],["platform_string","Bundler::LazySpecification::Identifier","Bundler/LazySpecification/Identifier.html#method-i-platform_string","()",""],["platform_version_match","Bundler::GemHelpers::PlatformMatch","Bundler/GemHelpers/PlatformMatch.html#method-c-platform_version_match","(spec_platform, user_platform)",""],["platforms","Bundler::Dsl","Bundler/Dsl.html#method-i-platforms","(*platforms)",""],["platforms","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-platforms","()",""],["platforms","Gem","Gem.html#method-c-platforms","()","<p>Array of platforms this RubyGems supports.\n"],["platforms","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-platforms","(*platforms)","<p>Block form for restricting gems to a particular set of platforms.  See #platform.\n"],["platforms=","Gem","Gem.html#method-c-platforms-3D","(platforms)","<p>Set array of platforms this RubyGems supports (primarily for testing).\n"],["platforms_match?","Bundler::MatchPlatform","Bundler/MatchPlatform.html#method-c-platforms_match-3F","(gemspec_platform, local_platform)",""],["plugin","Bundler::Dsl","Bundler/Dsl.html#method-i-plugin","(*args)",""],["plugin","Bundler::Plugin::DSL","Bundler/Plugin/DSL.html#method-i-plugin","(name, *args)",""],["plugin_commands","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-plugin_commands","(plugin)",""],["plugin_path","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-plugin_path","(name)",""],["plural_forms","RSS::Element","RSS/Element.html#method-c-plural_forms","()",""],["point","Readline","Readline.html#method-c-point","()","<p>Returns the index of the current cursor position in <code>Readline.line_buffer</code>.\n<p>The index in <code>Readline.line_buffer</code> …\n"],["point=","Readline","Readline.html#method-c-point-3D","(p1)","<p>Set the index of the current cursor position in <code>Readline.line_buffer</code>.\n<p>Raises NotImplementedError if the …\n"],["point_conversion_form","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-point_conversion_form","()","<p>Returns the form how EC::Point data is encoded as ASN.1.\n<p>See also #point_conversion_form=.\n"],["point_conversion_form=","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-point_conversion_form-3D","(p1)","<p>Sets the form how EC::Point data is encoded as ASN.1 as defined in X9.62.\n<p><em>format</em> can be one of these: …\n"],["pointer","StringScanner","StringScanner.html#method-i-pointer","()","<p>Returns the byte position of the scan pointer.  In the &#39;reset&#39; position, this value is zero. …\n"],["pointer=","StringScanner","StringScanner.html#method-i-pointer-3D","(p1)","<p>Sets the byte position of the scan pointer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">StringScanner</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;test string&#39;</span>)\n<span class=\"ruby-identifier\">s</span>.<span class=\"ruby-identifier\">pos</span> = <span class=\"ruby-value\">7</span>            <span class=\"ruby-operator\">...</span>\n</pre>\n"],["pointer_out","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-pointer_out","(out, ptr)",""],["polar","Complex","Complex.html#method-c-polar","(p1, p2 = v2)","<p>Returns a complex object which denotes the given polar form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>.<span class=\"ruby-identifier\">polar</span>(<span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">0</span>)            <span class=\"ruby-comment\">#=&gt; (3.0+0.0i) ...</span>\n</pre>\n"],["polar","Complex","Complex.html#method-i-polar","()","<p>Returns an array; [cmp.abs, cmp.arg].\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">polar</span>  <span class=\"ruby-comment\">#=&gt; [2.23606797749979, 1.1071487177940904]</span>\n</pre>\n"],["polar","Numeric","Numeric.html#method-i-polar","()","<p>Returns an array; [num.abs, num.arg].\n"],["pool_available","Bundler::ConnectionPool::Wrapper","Bundler/ConnectionPool/Wrapper.html#method-i-pool_available","()",""],["pool_shutdown","Bundler::ConnectionPool::Wrapper","Bundler/ConnectionPool/Wrapper.html#method-i-pool_shutdown","(&block)",""],["pool_size","Bundler::ConnectionPool::Wrapper","Bundler/ConnectionPool/Wrapper.html#method-i-pool_size","()",""],["pools_for","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-pools_for","(proxy)",""],["pop","Array","Array.html#method-i-pop","(*args)","<p>Removes the last element from <code>self</code> and returns it, or <code>nil</code> if the array is empty.\n<p>If a number <code>n</code> is given, …\n"],["pop","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-pop","(timeout = 0.5, options = {})","<p>Retrieves a connection from the stack.  If a connection is available it is immediately returned.  If …\n"],["pop","Bundler::Thor::NestedContext","Bundler/Thor/NestedContext.html#method-i-pop","()",""],["pop","Net::POPMail","Net/POPMail.html#method-i-pop","( dest = +'' )","<p>This method fetches the message.  If called with a block, the message is yielded to the block one chunk …\n"],["pop","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-pop","()",""],["pop","Queue","Queue.html#method-i-pop","(*args)","<p>Retrieves data from the queue.\n<p>If the queue is empty, the calling thread is suspended until data is pushed …\n"],["pop","Rinda::NotifyTemplateEntry","Rinda/NotifyTemplateEntry.html#method-i-pop","()","<p>Retrieves a notification.  Raises RequestExpiredError when this NotifyTemplateEntry expires.\n"],["pop","SizedQueue","SizedQueue.html#method-i-pop","(*args)","<p>Retrieves data from the queue.\n<p>If the queue is empty, the calling thread is suspended until data is pushed …\n"],["pop!","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-pop-21","(graph)","<p>Pops the most recent action from the log and undoes the action @param [DependencyGraph] graph @return …\n"],["pop!","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-pop-21","(graph)","<p>Pops the most recent action from the log and undoes the action @param [DependencyGraph] graph @return …\n"],["pop_inspect_key","PP::PPMethods","PP/PPMethods.html#method-i-pop_inspect_key","(id)","<p>Removes an object from the set of objects being pretty printed.\n"],["pop_possibility_state","Bundler::Molinillo::DependencyState","Bundler/Molinillo/DependencyState.html#method-i-pop_possibility_state","()","<p>Removes a possibility from `self` @return [PossibilityState] a state with a single possibility,\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">the</span> <span class=\"ruby-identifier\">possibility</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["pop_possibility_state","Gem::Resolver::Molinillo::DependencyState","Gem/Resolver/Molinillo/DependencyState.html#method-i-pop_possibility_state","()","<p>Removes a possibility from `self` @return [PossibilityState] a state with a single possibility,\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">the</span> <span class=\"ruby-identifier\">possibility</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["pop_token","RDoc::TokenStream","RDoc/TokenStream.html#method-i-pop_token","()","<p>Remove the last token from the collected tokens\n"],["pop_workspace","IRB::Context","IRB/Context.html#method-i-pop_workspace","()","<p>Removes the last element from the current #workspaces stack and returns it, or <code>nil</code> if the current workspace …\n"],["popen","Gem::Util","Gem/Util.html#method-c-popen","(*command)","<p>This calls IO.popen and reads the result\n"],["popen","IO","IO.html#method-c-popen","(*args)","<p>Runs the specified command as a subprocess; the subprocess&#39;s standard input and output will be connected …\n"],["popen2","Open3","Open3.html#method-i-popen2","(*cmd, &block)","<p>Open3.popen2 is similar to Open3.popen3 except that it doesn&#39;t create a pipe for the standard error …\n"],["popen2","Open3","Open3.html#method-c-popen2","(*cmd, &block)","<p>Open3.popen2 is similar to Open3.popen3 except that it doesn&#39;t create a pipe for the standard error …\n"],["popen2e","Open3","Open3.html#method-i-popen2e","(*cmd, &block)","<p>Open3.popen2e is similar to Open3.popen3 except that it merges the standard output stream and the standard …\n"],["popen2e","Open3","Open3.html#method-c-popen2e","(*cmd, &block)","<p>Open3.popen2e is similar to Open3.popen3 except that it merges the standard output stream and the standard …\n"],["popen3","Open3","Open3.html#method-c-popen3","(*cmd, &block)","<p>Open stdin, stdout, and stderr streams and start external executable. In addition, a thread to wait for …\n"],["popen3","Open3","Open3.html#method-i-popen3","(*cmd, &block)","<p>Open stdin, stdout, and stderr streams and start external executable. In addition, a thread to wait for …\n"],["popup_menu","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-popup_menu","(name = \"\", *values)","<p>Generate a Select element as a string.\n<p><code>name</code> is the name of the element.  The <code>values</code> are the options that …\n"],["port","Net::POP3","Net/POP3.html#method-i-port","()","<p>The port number to connect to.\n"],["port","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-port","()","<p>The port this request is for\n"],["port=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-port-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["port=","URI::Generic","URI/Generic.html#method-i-port-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["pos","ARGF","ARGF.html#method-i-pos","()","<p>Returns the current offset (in bytes) of the current file in <code>ARGF</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ARGF</span>.<span class=\"ruby-identifier\">pos</span>    <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-constant\">ARGF</span>.<span class=\"ruby-identifier\">gets</span>   <span class=\"ruby-comment\">#=&gt; &quot;This ...</span>\n</pre>\n"],["pos","Dir","Dir.html#method-i-pos","()","<p>Returns the current position in <em>dir</em>. See also Dir#seek.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testdir&quot;</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">tell</span>   <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">read</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["pos","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-pos","()","<p>The position in the tar entry\n"],["pos","IO","IO.html#method-i-pos","()","<p>Returns the current offset (in bytes) of <em>ios</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>)\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">pos</span>    <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">gets</span>   <span class=\"ruby-comment\">#=&gt; &quot;This ...</span>\n</pre>\n"],["pos","StringIO","StringIO.html#method-i-pos","()","<p>Returns the current offset (in bytes).\n"],["pos","StringScanner","StringScanner.html#method-i-pos","()","<p>Returns the byte position of the scan pointer.  In the &#39;reset&#39; position, this value is zero. …\n"],["pos","Zlib::GzipReader","Zlib/GzipReader.html#method-i-pos","()","<p>Total number of output bytes output so far.\n"],["pos","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-pos","()","<p>Total number of input bytes read so far.\n"],["pos=","ARGF","ARGF.html#method-i-pos-3D","(p1)","<p>Seeks to the position given by <em>position</em> (in bytes) in <code>ARGF</code>.\n<p>For example:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ARGF</span>.<span class=\"ruby-identifier\">pos</span> = <span class=\"ruby-value\">17</span>\n<span class=\"ruby-constant\">ARGF</span>.<span class=\"ruby-identifier\">gets</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["pos=","Dir","Dir.html#method-i-pos-3D","(p1)","<p>Synonym for Dir#seek, but returns the position parameter.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testdir&quot;</span>)   <span class=\"ruby-comment\">#=&gt; #&lt;Dir:0x401b3c40&gt; ...</span>\n</pre>\n"],["pos=","IO","IO.html#method-i-pos-3D","(p1)","<p>Seeks to the given position (in bytes) in <em>ios</em>. It is not guaranteed that seeking to the right position …\n"],["pos=","StringIO","StringIO.html#method-i-pos-3D","(p1)","<p>Seeks to the given position (in bytes).\n"],["pos=","StringScanner","StringScanner.html#method-i-pos-3D","(p1)","<p>Sets the byte position of the scan pointer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-constant\">StringScanner</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;test string&#39;</span>)\n<span class=\"ruby-identifier\">s</span>.<span class=\"ruby-identifier\">pos</span> = <span class=\"ruby-value\">7</span>            <span class=\"ruby-operator\">...</span>\n</pre>\n"],["position","REXML::Functions","REXML/Functions.html#method-c-position","( )",""],["position","REXML::IOSource","REXML/IOSource.html#method-i-position","()",""],["position","REXML::ParseException","REXML/ParseException.html#method-i-position","()",""],["position","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-position","()",""],["position","REXML::Source","REXML/Source.html#method-i-position","()",""],["position","REXML::XPathNode","REXML/XPathNode.html#method-i-position","()",""],["positive?","Float","Float.html#method-i-positive-3F","()","<p>Returns <code>true</code> if <code>float</code> is greater than 0.\n"],["positive?","Numeric","Numeric.html#method-i-positive-3F","()","<p>Returns <code>true</code> if <code>num</code> is greater than 0.\n"],["positive?","Rational","Rational.html#method-i-positive-3F","()","<p>Returns <code>true</code> if <code>rat</code> is greater than 0.\n"],["positive_integer_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-positive_integer_writer","(name, disp_name=name)",""],["possibilities","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-possibilities","()","<p>(see Bundler::Molinillo::ResolutionState#possibilities)\n"],["possibilities","Gem::Resolver::Molinillo::Delegates::ResolutionState","Gem/Resolver/Molinillo/Delegates/ResolutionState.html#method-i-possibilities","()","<p>(see Gem::Resolver::Molinillo::ResolutionState#possibilities)\n"],["possibilities_for_requirement","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-possibilities_for_requirement","(requirement, activated = self.activated)","<p>Checks a proposed requirement with any existing locked requirement before generating an array of possibilities …\n"],["possibility","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-possibility","()","<p>@return [Object] the current possibility that the resolution is trying\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">to</span> <span class=\"ruby-identifier\">activate</span>\n</pre>\n"],["possibility","Bundler::Molinillo::Resolver::Resolution::Conflict","Bundler/Molinillo/Resolver/Resolution/Conflict.html#method-i-possibility","()","<p>@return [Object] a spec that was unable to be activated due to a conflict\n"],["possibility","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-possibility","()","<p>@return [Object] the current possibility that the resolution is trying\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">to</span> <span class=\"ruby-identifier\">activate</span>\n</pre>\n"],["possibility_satisfies_requirements?","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-possibility_satisfies_requirements-3F","(possibility, requirements)","<p>@param [Object] possibility a single possibility @param [Array] requirements an array of requirements …\n"],["post","Net::HTTP","Net/HTTP.html#method-c-post","(url, data, header = nil)","<p>Posts data to the specified URI object.\n<p>Example:\n\n<pre>require &#39;net/http&#39;\nrequire &#39;uri&#39;\n\nNet::HTTP.post URI(&#39;http://www.example.com/api/search&#39;), ...</pre>\n"],["post","Net::HTTP","Net/HTTP.html#method-i-post","(path, data, initheader = nil, dest = nil)","<p>Posts <code>data</code> (must be a String) to <code>path</code>. <code>header</code> must be a Hash like { &#39;Accept&#39; =&gt; &#39;<strong>/</strong>&#39;, …\n"],["post2","Net::HTTP","Net/HTTP.html#method-i-post2","(path, data, initheader = nil)",""],["post_build","Gem","Gem.html#method-c-post_build","(&hook)","<p>Adds a post-build hook that will be passed an Gem::Installer instance when Gem::Installer#install is …\n"],["post_connection_check","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-post_connection_check","(hostname)","<p>Perform hostname verification following RFC 6125.\n<p>This method MUST be called after calling #connect to …\n"],["post_form","Net::HTTP","Net/HTTP.html#method-c-post_form","(url, params)","<p>Posts HTML form data to the specified URI object. The form data must be provided as a Hash mapping from …\n"],["post_install","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-post_install","(spec, disable_exts = false)","<p>It builds extensions, generates bins and installs them for the spec provided.\n<p>It depends on `spec.loaded_from` …\n"],["post_install","Bundler::Source::Path::Installer","Bundler/Source/Path/Installer.html#method-i-post_install","()",""],["post_install","Gem","Gem.html#method-c-post_install","(&hook)","<p>Adds a post-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is …\n"],["post_install_message","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-post_install_message","()","<p>needed for post_install_messages during install\n"],["post_match","MatchData","MatchData.html#method-i-post_match","()","<p>Returns the portion of the original string after the current match. Equivalent to the special variable …\n"],["post_match","StringScanner","StringScanner.html#method-i-post_match","()","<p>Returns the <strong><em>post</strong>-match</em> (in the regular expression sense) of the last scan.\n\n<pre>s = StringScanner.new(&#39;test ...</pre>\n"],["post_reset","Gem","Gem.html#method-c-post_reset","(&hook)","<p>Adds a hook that will get run after Gem::Specification.reset is run.\n"],["post_reset_hooks","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-post_reset_hooks","()",""],["post_sort","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-post_sort","(result)","<p>Specific version moves can&#39;t always reliably be done during sorting as not all elements are compared …\n"],["post_uninstall","Gem","Gem.html#method-c-post_uninstall","(&hook)","<p>Adds a post-uninstall hook that will be passed a Gem::Uninstaller instance and the spec that was uninstalled …\n"],["pow","Integer","Integer.html#method-i-pow","(*args)","<p>Returns (modular) exponentiation as:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">pow</span>(<span class=\"ruby-identifier\">b</span>)     <span class=\"ruby-comment\">#=&gt; same as a**b</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">pow</span>(<span class=\"ruby-identifier\">b</span>, <span class=\"ruby-identifier\">m</span>)  <span class=\"ruby-comment\">#=&gt; same as (a**b) % m, ...</span>\n</pre>\n"],["power","BigDecimal","BigDecimal.html#method-i-power","(p1, p2 = v2)","<p>Returns the value raised to the power of n.\n<p>Note that n must be an Integer.\n<p>Also available as the operator …\n"],["pp","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-pp","(*objs)","<p>Same as #ppx, except it uses the #prefix given during object initialization. See OutputMethod#ppx for …\n"],["pp","IRB::OutputMethod","IRB/OutputMethod.html#method-i-pp","(*objs)","<p>Prints the given <code>objs</code> calling Object#inspect on each.\n<p>See #puts for more detail.\n"],["pp","Kernel","Kernel.html#method-i-pp","(*objs)","<p>prints arguments in pretty form.\n<p>pp returns argument(s).\n"],["pp","Kernel","Kernel.html#method-c-pp","(*objs)","<p>prints arguments in pretty form.\n<p>pp returns argument(s).\n"],["pp","PP","PP.html#method-c-pp","(obj, out=$>, width=79)","<p>Outputs <code>obj</code> to <code>out</code> in pretty printed format of <code>width</code> columns in width.\n<p>If <code>out</code> is omitted, <code>$&gt;</code> is assumed. …\n"],["pp","PP::PPMethods","PP/PPMethods.html#method-i-pp","(obj)","<p>Adds <code>obj</code> to the pretty printing buffer using Object#pretty_print or Object#pretty_print_cycle.\n<p>Object#pretty_print_cycle …\n"],["pp_hash","PP::PPMethods","PP/PPMethods.html#method-i-pp_hash","(obj)","<p>A pretty print for a Hash\n"],["pp_object","PP::PPMethods","PP/PPMethods.html#method-i-pp_object","(obj)","<p>A present standard failsafe for pretty printing any given Object\n"],["ppid","Process","Process.html#method-c-ppid","()","<p>Returns the process id of the parent of this process. Returns untrustworthy value on Win32/64. Not available …\n"],["ppx","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-ppx","(prefix, *objs)","<p>Same as #pp, except it concatenates the given <code>prefix</code> with the #prefix given during object initialization. …\n"],["ppx","IRB::OutputMethod","IRB/OutputMethod.html#method-i-ppx","(prefix, *objs)","<p>Prints the given <code>objs</code> calling Object#inspect on each and appending the given <code>prefix</code>.\n<p>See #puts for more …\n"],["pre_input_hook","Readline","Readline.html#method-c-pre_input_hook","()","<p>Returns a Proc object <code>proc</code> to call after the first prompt has been printed and just before readline starts …\n"],["pre_input_hook=","Readline","Readline.html#method-c-pre_input_hook-3D","(p1)","<p>Specifies a Proc object <code>proc</code> to call after the first prompt has been printed and just before readline …\n"],["pre_input_hook=","Reline::Core","Reline/Core.html#method-i-pre_input_hook-3D","(p)",""],["pre_install","Gem","Gem.html#method-c-pre_install","(&hook)","<p>Adds a pre-install hook that will be passed an Gem::Installer instance when Gem::Installer#install is …\n"],["pre_install_checks","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-i-pre_install_checks","()",""],["pre_install_checks","Gem::Installer","Gem/Installer.html#method-i-pre_install_checks","()","<p>Performs various checks before installing the gem such as the install repository is writable and its …\n"],["pre_match","MatchData","MatchData.html#method-i-pre_match","()","<p>Returns the portion of the original string before the current match. Equivalent to the special variable …\n"],["pre_match","StringScanner","StringScanner.html#method-i-pre_match","()","<p>Returns the <strong><em>pre</strong>-match</em> (in the regular expression sense) of the last scan.\n\n<pre>s = StringScanner.new(&#39;test ...</pre>\n"],["pre_reset","Gem","Gem.html#method-c-pre_reset","(&hook)","<p>Adds a hook that will get run before Gem::Specification.reset is run.\n"],["pre_uninstall","Gem","Gem.html#method-c-pre_uninstall","(&hook)","<p>Adds a pre-uninstall hook that will be passed an Gem::Uninstaller instance and the spec that will be …\n"],["pread","IO","IO.html#method-i-pread","(p1, p2, p3 = v3)","<p>Reads <em>maxlen</em> bytes from <em>ios</em> using the pread system call and returns them as a string without modifying …\n"],["prec","Racc::Rule","Racc/Rule.html#method-i-prec","(sym, &block)",""],["precedence","Racc::Rule","Racc/Rule.html#method-i-precedence","()",""],["precedence=","Racc::Rule","Racc/Rule.html#method-i-precedence-3D","(sym)",""],["precedence_table","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-precedence_table","(&block)",""],["preceding","REXML::XPathParser","REXML/XPathParser.html#method-i-preceding","(node)","<p>Builds a nodeset of all of the preceding nodes of the supplied node, in reverse document order\n<p>preceding … &mdash; "],["preceding_node_of","REXML::XPathParser","REXML/XPathParser.html#method-i-preceding_node_of","( node )",""],["precs","BigDecimal","BigDecimal.html#method-i-precs","()","<p>Returns an Array of two Integer values.\n<p>The first value is the current number of significant digits in …\n"],["pred","Integer","Integer.html#method-i-pred","()","<p>Returns the predecessor of <code>int</code>, i.e. the Integer equal to <code>int-1</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">pred</span>      <span class=\"ruby-comment\">#=&gt; 0</span>\n(<span class=\"ruby-value\">-1</span>).<span class=\"ruby-identifier\">pred</span>   <span class=\"ruby-comment\">#=&gt; -2</span>\n</pre>\n"],["predecessors","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-predecessors","()","<p>@return [Array&lt;Vertex&gt;] the vertices of {#graph} that have an edge with\n\n<pre>`self` as their {Edge#destination}</pre>\n"],["predecessors","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-predecessors","()","<p>@return [Array&lt;Vertex&gt;] the vertices of {#graph} that have an edge with\n\n<pre>`self` as their {Edge#destination}</pre>\n"],["predicate","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-predicate","(path)",""],["predicate","REXML::QuickPath","REXML/QuickPath.html#method-c-predicate","( elements, path )","<p>A predicate filters a node-set with respect to an axis to produce a new node-set. For each node in the …\n"],["predicate","REXML::XPathParser","REXML/XPathParser.html#method-i-predicate","(path, nodeset)",""],["predicate_to_string","REXML::Parsers::XPathParser","REXML/Parsers/XPathParser.html#method-i-predicate_to_string","( path, &block )",""],["prefetch","Gem::AvailableSet","Gem/AvailableSet.html#method-i-prefetch","(reqs)",""],["prefetch","Gem::Resolver::APISet","Gem/Resolver/APISet.html#method-i-prefetch","(reqs)","<p>A hint run by the resolver to allow the Set to fetch data for DependencyRequests <code>reqs</code>.\n"],["prefetch","Gem::Resolver::ComposedSet","Gem/Resolver/ComposedSet.html#method-i-prefetch","(reqs)","<p>Prefetches <code>reqs</code> in all sets.\n"],["prefetch","Gem::Resolver::GitSet","Gem/Resolver/GitSet.html#method-i-prefetch","(reqs)","<p>Prefetches specifications from the git repositories in this set.\n"],["prefetch","Gem::Resolver::InstallerSet","Gem/Resolver/InstallerSet.html#method-i-prefetch","(reqs)",""],["prefetch","Gem::Resolver::Set","Gem/Resolver/Set.html#method-i-prefetch","(reqs)","<p>The #prefetch method may be overridden, but this is not necessary.  This default implementation does …\n"],["prefix","Gem","Gem.html#method-c-prefix","()","<p>The directory prefix this RubyGems was installed at. If your prefix is in a standard location (ie, rubygems …\n"],["prefix","IPAddr","IPAddr.html#method-i-prefix","()","<p>Returns the prefix length in bits for the ipaddr.\n"],["prefix","REXML::Attribute","REXML/Attribute.html#method-i-prefix","()","<p>Returns the namespace of the attribute.\n\n<pre>e = Element.new( &quot;elns:myelement&quot; )\ne.add_attribute( &quot;nsa:a&quot;, ...</pre>\n"],["prefix","REXML::Light::Node","REXML/Light/Node.html#method-i-prefix","( namespace=nil )",""],["prefix=","IPAddr","IPAddr.html#method-i-prefix-3D","(prefix)","<p>Sets the prefix length in bits\n"],["prefix_of","REXML::Light::Node","REXML/Light/Node.html#method-i-prefix_of","( node, namespace=nil )",""],["prefixes","REXML::Attributes","REXML/Attributes.html#method-i-prefixes","()","<p>Returns an array of Strings containing all of the prefixes declared by this set of # attributes.  The …\n"],["prefixes","REXML::Element","REXML/Element.html#method-i-prefixes","()","<p>Evaluates to an <code>Array</code> containing the prefixes (names) of all defined namespaces at this context node. …\n"],["prepare","CSV::Parser","CSV/Parser.html#method-i-prepare","()","<p>A set of tasks to prepare the file in order to parse it\n"],["prepare","CSV::Writer","CSV/Writer.html#method-i-prepare","()",""],["prepare_backslash","CSV::Parser","CSV/Parser.html#method-i-prepare_backslash","()",""],["prepare_format","CSV::Writer","CSV/Writer.html#method-i-prepare_format","()",""],["prepare_header","CSV::Parser","CSV/Parser.html#method-i-prepare_header","()",""],["prepare_header","CSV::Writer","CSV/Writer.html#method-i-prepare_header","()",""],["prepare_line","CSV::Parser","CSV/Parser.html#method-i-prepare_line","()",""],["prepare_message","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-prepare_message","(message, *color)",""],["prepare_output","CSV::Writer","CSV/Writer.html#method-i-prepare_output","()",""],["prepare_parser","CSV::Parser","CSV/Parser.html#method-i-prepare_parser","()",""],["prepare_quote_character","CSV::Parser","CSV/Parser.html#method-i-prepare_quote_character","()",""],["prepare_quoted","CSV::Parser","CSV/Parser.html#method-i-prepare_quoted","()",""],["prepare_separators","CSV::Parser","CSV/Parser.html#method-i-prepare_separators","()",""],["prepare_skip_lines","CSV::Parser","CSV/Parser.html#method-i-prepare_skip_lines","()",""],["prepare_strip","CSV::Parser","CSV/Parser.html#method-i-prepare_strip","()",""],["prepare_unquoted","CSV::Parser","CSV/Parser.html#method-i-prepare_unquoted","()",""],["prepare_variable","CSV::Parser","CSV/Parser.html#method-i-prepare_variable","()",""],["prepend","Array","Array.html#method-i-prepend","(*args)",""],["prepend","Gem::List","Gem/List.html#method-i-prepend","(value)",""],["prepend","Gem::List","Gem/List.html#method-c-prepend","(list, value)",""],["prepend","Module","Module.html#method-i-prepend","(*args)","<p>Invokes Module.prepend_features on each parameter in reverse order.\n"],["prepend","OptionParser::List","OptionParser/List.html#method-i-prepend","(*args)","<p>Inserts <code>switch</code> at the head of the list, and associates short, long and negated long options. Arguments …\n"],["prepend","String","String.html#method-i-prepend","(*args)","<p>Prepend—Prepend the given strings to <em>str</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-string\">&quot;!&quot;</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">prepend</span>(<span class=\"ruby-string\">&quot;hello &quot;</span>, <span class=\"ruby-string\">&quot;world&quot;</span>) <span class=\"ruby-comment\">#=&gt; &quot;hello world!&quot;</span>\n<span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["prepend_features","Module","Module.html#method-i-prepend_features","(p1)","<p>When this module is prepended in another, Ruby calls #prepend_features in this module, passing it the …\n"],["prepend_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-prepend_file","(path, *args, &block)",""],["prepend_to_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-prepend_to_file","(path, *args, &block)","<p>Prepend text to a file. Since it depends on insert_into_file, it&#39;s reversible.\n<p>Parameters\n<p>path&lt;String&gt; … &mdash; "],["prepended","Module","Module.html#method-i-prepended","(p1)","<p>The equivalent of <code>included</code>, but for prepended modules.\n\n<pre>module A\n  def self.prepended(mod)\n    puts &quot;#{self} ...</pre>\n"],["prerelease","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-prerelease","()",""],["prerelease=","Gem::Resolver::ComposedSet","Gem/Resolver/ComposedSet.html#method-i-prerelease-3D","(allow_prerelease)","<p>When <code>allow_prerelease</code> is set to <code>true</code> prereleases gems are allowed to match dependencies.\n"],["prerelease=","Gem::Resolver::InstallerSet","Gem/Resolver/InstallerSet.html#method-i-prerelease-3D","(allow_prerelease)",""],["prerelease?","Gem::Dependency","Gem/Dependency.html#method-i-prerelease-3F","()","<p>Does this dependency require a prerelease?\n"],["prerelease?","Gem::NameTuple","Gem/NameTuple.html#method-i-prerelease-3F","()","<p>Indicate if this NameTuple is for a prerelease version.\n"],["prerelease?","Gem::Requirement","Gem/Requirement.html#method-i-prerelease-3F","()","<p>A requirement is a prerelease if any of the versions inside of it are prereleases\n"],["prerelease?","Gem::Version","Gem/Version.html#method-i-prerelease-3F","()","<p>A version is considered a prerelease if it contains a letter.\n"],["prerelease_specs","Gem::Server","Gem/Server.html#method-i-prerelease_specs","(req, res)",""],["preserve_paths","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-preserve_paths","()",""],["pressed?","IO","IO.html#method-i-pressed-3F","(p1)",""],["pretty","CGI::Util","CGI/Util.html#method-i-pretty","(string, shift = \" \")","<p>Prettify (indent) an HTML string.\n<p><code>string</code> is the HTML string to indent.  <code>shift</code> is the indentation unit …\n"],["pretty_dep","Bundler::Definition","Bundler/Definition.html#method-i-pretty_dep","(dep, source = false)",""],["pretty_dependency","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-pretty_dependency","(dep, print_source = false)",""],["pretty_generate","JSON","JSON.html#method-i-pretty_generate","(obj, opts = nil)","<p>Generate a JSON document from the Ruby data structure <em>obj</em> and return it. The returned document is a prettier …\n"],["pretty_inspect","Kernel","Kernel.html#method-i-pretty_inspect","()","<p>Returns a pretty printed object as a string.\n<p>In order to use this method you must first require the PP …\n"],["pretty_name","RDoc::Alias","RDoc/Alias.html#method-i-pretty_name","()",""],["pretty_name","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-pretty_name","()","<p>Method/attribute name with class/instance indicator\n"],["pretty_new_name","RDoc::Alias","RDoc/Alias.html#method-i-pretty_new_name","()","<p>New name with prefix &#39;::&#39; or &#39;#&#39;.\n"],["pretty_old_name","RDoc::Alias","RDoc/Alias.html#method-i-pretty_old_name","()","<p>Old name with prefix &#39;::&#39; or &#39;#&#39;.\n"],["pretty_print","OpenSSL::BN","OpenSSL/BN.html#method-i-pretty_print","(q)",""],["pretty_print","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-pretty_print","(q)",""],["pretty_print","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-pretty_print","(q)",""],["pretty_print","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-pretty_print","(q)",""],["pretty_print_children","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-pretty_print_children","(q, names = [])",""],["pretty_values_for","Bundler::Settings","Bundler/Settings.html#method-i-pretty_values_for","(exposed_key)",""],["prev_day","Date","Date.html#method-i-prev_day","(p1 = v1)","<p>This method is equivalent to d - n.\n"],["prev_float","Float","Float.html#method-i-prev_float","()","<p>Returns the previous representable floating point number.\n<p>(-Float::MAX).prev_float and (-Float::INFINITY).prev_float …\n"],["prev_month","Date","Date.html#method-i-prev_month","(p1 = v1)","<p>This method is equivalent to d &lt;&lt; n.\n<p>See Date#<< for examples.\n"],["prev_year","Date","Date.html#method-i-prev_year","(p1 = v1)","<p>This method is equivalent to d &lt;&lt; (n * 12).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">prev_year</span>      <span class=\"ruby-comment\">#=&gt; #&lt;Date: 2000-02-03 ...</span>\n</pre>\n"],["previous=","REXML::Validation::State","REXML/Validation/State.html#method-i-previous-3D","( previous )",""],["previous_element","REXML::Element","REXML/Element.html#method-i-previous_element","()","<p>Returns the previous sibling that is an element, or nil if there is no Element sibling prior to this …\n"],["previous_sibling=","REXML::Child","REXML/Child.html#method-i-previous_sibling-3D","(other)","<p>Sets the previous sibling of this child.  This can be used to insert a child before some other child. …\n"],["previous_sibling_node","REXML::Node","REXML/Node.html#method-i-previous_sibling_node","()","<p>@return the previous sibling (nil if unset)\n"],["primary","Rinda::RingFinger","Rinda/RingFinger.html#method-c-primary","()","<p>Returns the first advertised TupleSpace.\n"],["prime?","Integer","Integer.html#method-i-prime-3F","()","<p>Returns true if <code>self</code> is a prime number, else returns false.\n"],["prime?","OpenSSL::BN","OpenSSL/BN.html#method-i-prime-3F","(p1 = v1)","<p>Performs a Miller-Rabin probabilistic primality test with <em>checks</em> iterations. If <em>checks</em> is not specified, …\n"],["prime?","Prime","Prime.html#method-i-prime-3F","(value, generator = Prime::Generator23.new)","<p>Returns true if <code>value</code> is a prime number, else returns false.\n<p>Parameters\n<p><code>value</code> &mdash; an arbitrary integer to be …\n"],["prime_division","Integer","Integer.html#method-i-prime_division","(generator = Prime::Generator23.new)","<p>Returns the factorization of <code>self</code>.\n<p>See Prime#prime_division for more details.\n"],["prime_division","Prime","Prime.html#method-i-prime_division","(value, generator = Prime::Generator23.new)","<p>Returns the factorization of <code>value</code>.\n<p>Parameters\n<p><code>value</code> &mdash; An arbitrary integer.\n"],["prime_fasttest?","OpenSSL::BN","OpenSSL/BN.html#method-i-prime_fasttest-3F","(p1 = v1, p2 = v2)","<p>Performs a Miller-Rabin primality test. This is same as #prime? except this first attempts trial divisions …\n"],["primitive_convert","Encoding::Converter","Encoding/Converter.html#method-i-primitive_convert","(p1, p2, p3 = v3, p4 = v4, p5 = v5, p6 = {})","<p>possible opt elements:\n\n<pre>hash form:\n  :partial_input =&gt; true           # source buffer may be part of larger ...</pre>\n"],["primitive_errinfo","Encoding::Converter","Encoding/Converter.html#method-i-primitive_errinfo","()","<p>primitive_errinfo returns important information regarding the last error as a 5-element array:\n\n<pre>[result, ...</pre>\n"],["print","ARGF","ARGF.html#method-i-print","(*args)","<p>Writes the given object(s) to <em>ios</em>. Returns <code>nil</code>.\n<p>The stream must be opened for writing. Each given object …\n"],["print","CGI","CGI.html#method-i-print","(*options)","<p>Print an argument or list of arguments to the default output stream\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">cgi</span> = <span class=\"ruby-constant\">CGI</span>.<span class=\"ruby-identifier\">new</span>\n<span class=\"ruby-identifier\">cgi</span>.<span class=\"ruby-identifier\">print</span>    <span class=\"ruby-comment\"># default: ...</span>\n</pre>\n"],["print","IO","IO.html#method-i-print","(*args)","<p>Writes the given object(s) to <em>ios</em>. Returns <code>nil</code>.\n<p>The stream must be opened for writing. Each given object …\n"],["print","IO::generic_writable","IO/generic_writable.html#method-i-print","(*args)","<p>See IO#print.\n"],["print","IRB::Locale","IRB/Locale.html#method-i-print","(*opts)",""],["print","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-print","(*opts)","<p>See OutputMethod#print for more detail.\n"],["print","IRB::OutputMethod","IRB/OutputMethod.html#method-i-print","(*opts)","<p>Open this method to implement your own output method, raises a NotImplementedError if you don&#39;t define …\n"],["print","IRB::StdioOutputMethod","IRB/StdioOutputMethod.html#method-i-print","(*opts)","<p>Prints the given <code>opts</code> to standard output, see IO#print for more information.\n"],["print","Kernel","Kernel.html#method-i-print","(*args)","<p>Prints each object in turn to <code>$stdout</code>. If the output field separator (<code>$,</code>) is not <code>nil</code>, its contents will …\n"],["print","Net::WriteAdapter","Net/WriteAdapter.html#method-i-print","(str)",""],["print","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-print","(*args)","<p>Writes <em>args</em> to the stream.\n<p>See IO#print for full details.\n"],["print","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-print","(*args)","<p>Same as IO.\n"],["print_atab","Racc::States","Racc/States.html#method-i-print_atab","(idx, tab)","<p>for debug\n"],["print_command","Bundler::CLI","Bundler/CLI.html#method-i-print_command","()",""],["print_gem","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-print_gem","(current_spec, active_spec, dependency, groups)",""],["print_gem_info","Bundler::CLI::Info","Bundler/CLI/Info.html#method-i-print_gem_info","(spec)",""],["print_gem_path","Bundler::CLI::Info","Bundler/CLI/Info.html#method-i-print_gem_path","(spec)",""],["print_gems","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-print_gems","(gems_list)",""],["print_in_columns","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-print_in_columns","(array)","<p>Prints values in columns\n<p>Parameters\n<p>Array[String, String, …]\n"],["print_major_deprecations!","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-print_major_deprecations-21","()",""],["print_mem_leaks","OpenSSL","OpenSSL.html#method-c-print_mem_leaks","()","<p>For debugging the Ruby/OpenSSL library. Calls CRYPTO_mem_leaks_fp(stderr). Prints detected memory leaks …\n"],["print_options","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-print_options","(shell, options, group_name = nil)","<p>Receives a set of options and print them.\n"],["print_post_install_message","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-print_post_install_message","(name, msg)",""],["print_tab","Racc::States","Racc/States.html#method-i-print_tab","(idx, rel, tab)",""],["print_tab_i","Racc::States","Racc/States.html#method-i-print_tab_i","(idx, rel, tab, i)","<p>for debug\n"],["print_table","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-print_table","(array, options = {})","<p>Prints a table.\n<p>Parameters\n<p>Array[Array[String, String, …]]\n"],["print_usage","IRB","IRB.html#method-c-print_usage","()","<p>Outputs the irb help message, see IRB@Command+line+options.\n"],["print_using_message","Bundler::Source","Bundler/Source.html#method-i-print_using_message","(message)",""],["print_wrapped","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-print_wrapped","(message, options = {})","<p>Prints a long string, word-wrapping the text to the current width of the terminal display. Ideal for …\n"],["printable_commands","Bundler::Thor","Bundler/Thor.html#method-c-printable_commands","(all = true, subcommand = false)","<p>Returns commands ready to be printed.\n"],["printable_commands","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-printable_commands","(*)","<p>Returns commands ready to be printed.\n"],["printable_tasks","Bundler::Thor","Bundler/Thor.html#method-c-printable_tasks","(all = true, subcommand = false)",""],["printable_tasks","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-printable_tasks","(*)",""],["printb","Racc::States","Racc/States.html#method-i-printb","(i)","<p>for debug\n"],["printf","ARGF","ARGF.html#method-i-printf","(*args)","<p>Formats and writes to <em>ios</em>, converting parameters under control of the format string. See Kernel#sprintf …\n"],["printf","IO","IO.html#method-i-printf","(*args)","<p>Formats and writes to <em>ios</em>, converting parameters under control of the format string. See Kernel#sprintf …\n"],["printf","IO::generic_writable","IO/generic_writable.html#method-i-printf","(*args)","<p>See IO#printf.\n"],["printf","IRB::Locale","IRB/Locale.html#method-i-printf","(*opts)",""],["printf","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-printf","(format, *opts)","<p>See OutputMethod#printf for more detail.\n"],["printf","IRB::OutputMethod","IRB/OutputMethod.html#method-i-printf","(format, *opts)","<p>Extends IO#printf to format the given <code>opts</code> for Kernel#sprintf using #parse_printf_format\n"],["printf","Kernel","Kernel.html#method-i-printf","(*args)","<p>Equivalent to:\n\n<pre>io.write(sprintf(string, obj, ...))</pre>\n<p>or\n"],["printf","Net::WriteAdapter","Net/WriteAdapter.html#method-i-printf","(*args)",""],["printf","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-printf","(s, *args)","<p>Formats and writes to the stream converting parameters under control of the format string.\n<p>See Kernel#sprintf …\n"],["printf","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-printf","(*args)","<p>Same as IO.\n"],["printn","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-printn","(*opts)","<p>See OutputMethod#printn for more detail.\n"],["printn","IRB::OutputMethod","IRB/OutputMethod.html#method-i-printn","(*opts)","<p>Prints the given <code>opts</code>, with a newline delimiter.\n"],["prints_major_deprecations?","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-prints_major_deprecations-3F","()",""],["priority","Thread","Thread.html#method-i-priority","()","<p>Returns the priority of <em>thr</em>. Default is inherited from the current thread which creating the new thread, …\n"],["priority=","Thread","Thread.html#method-i-priority-3D","(p1)","<p>Sets the priority of <em>thr</em> to <em>integer</em>. Higher-priority threads will run more frequently than lower-priority …\n"],["pristine","Bundler::CLI","Bundler/CLI.html#method-i-pristine","(*gems)",""],["private","Module","Module.html#method-i-private","(*args)","<p>With no arguments, sets the default visibility for subsequently defined methods to private. With arguments, …\n"],["private?","IPAddr","IPAddr.html#method-i-private-3F","()","<p>Returns true if the ipaddr is a private address.  IPv4 addresses in 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16 …\n"],["private?","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-private-3F","()","<p>Indicates whether this DH instance has a private key associated with it or not. The private key may be …\n"],["private?","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-private-3F","()","<p>Indicates whether this DSA instance has a private key associated with it or not. The private key may …\n"],["private?","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-private-3F","()","<p>Returns whether this EC instance has a private key. The private key (BN) can be retrieved with EC#private_key …\n"],["private?","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-private-3F","()","<p>Does this keypair contain a private key?\n"],["private_call?","NoMethodError","NoMethodError.html#method-i-private_call-3F","()","<p>Return true if the caused method was called as private.\n"],["private_class_method","Module","Module.html#method-i-private_class_method","(*args)","<p>Makes existing class methods private. Often used to hide the default constructor <code>new</code>.\n<p>String arguments …\n"],["private_constant","Module","Module.html#method-i-private_constant","(*args)","<p>Makes a list of existing constants private.\n"],["private_decrypt","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-private_decrypt","(p1, p2 = v2)","<p>Decrypt <em>string</em>, which has been encrypted with the public key, with the private key.  <em>padding</em> defaults …\n"],["private_encrypt","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-private_encrypt","(p1, p2 = v2)","<p>Encrypt <em>string</em> with the private key.  <em>padding</em> defaults to PKCS1_PADDING. The encrypted string output …\n"],["private_instance_methods","Module","Module.html#method-i-private_instance_methods","(*args)","<p>Returns a list of the private instance methods defined in <em>mod</em>. If the optional parameter is <code>false</code>, the …\n"],["private_iv_get","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-private_iv_get","(p1, p2)","<p>Get the private instance variable <code>prop</code> from <code>target</code>\n"],["private_key","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-private_key","()","<p>See the OpenSSL documentation for EC_KEY_get0_private_key()\n"],["private_key=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-private_key-3D","(key)","<p>Sets this client&#39;s SSL private key\n"],["private_key=","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-private_key-3D","(p1)","<p>See the OpenSSL documentation for EC_KEY_set_private_key()\n"],["private_key?","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-private_key-3F","()",""],["private_method?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-private_method-3F","(instance)",""],["private_method?","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-private_method-3F","(instance)",""],["private_method_defined?","Module","Module.html#method-i-private_method_defined-3F","(*args)","<p>Returns <code>true</code> if the named private method is defined by <em>mod</em>.  If <em>inherit</em> is set, the lookup will also …\n"],["private_methods","Object","Object.html#method-i-private_methods","(*args)","<p>Returns the list of private methods accessible to <em>obj</em>. If the <em>all</em> parameter is set to <code>false</code>, only those …\n"],["probe_writtable_socket","Bundler::Settings::TCPSocketProbe","Bundler/Settings/TCPSocketProbe.html#method-i-probe_writtable_socket","(socket, address)",""],["proc","Kernel","Kernel.html#method-i-proc","()","<p>Equivalent to Proc.new.\n"],["proc","Racc::UserAction","Racc/UserAction.html#method-c-proc","(pr = nil, &block)",""],["proc?","Racc::UserAction","Racc/UserAction.html#method-i-proc-3F","()",""],["procdest","Net::HTTPResponse","Net/HTTPResponse.html#method-i-procdest","(dest, block)",""],["process","Net::IMAP::CramMD5Authenticator","Net/IMAP/CramMD5Authenticator.html#method-i-process","(challenge)",""],["process","Net::IMAP::DigestMD5Authenticator","Net/IMAP/DigestMD5Authenticator.html#method-i-process","(challenge)",""],["process","Net::IMAP::LoginAuthenticator","Net/IMAP/LoginAuthenticator.html#method-i-process","(data)",""],["process","Net::IMAP::PlainAuthenticator","Net/IMAP/PlainAuthenticator.html#method-i-process","(data)",""],["process_args","Gem::CommandManager","Gem/CommandManager.html#method-i-process_args","(args, build_args=nil)",""],["process_based_port","Gem::TestCase","Gem/TestCase.html#method-c-process_based_port","()","<p>Allows tests to use a random (but controlled) port number instead of a hardcoded one. This helps CI tools …\n"],["process_based_port","Gem::TestCase","Gem/TestCase.html#method-i-process_based_port","()","<p>See ::process_based_port\n"],["process_instruction","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-process_instruction","()",""],["process_queue","Bundler::Worker","Bundler/Worker.html#method-i-process_queue","(i)",""],["process_specs","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-process_specs","()","<p>Dequeue a spec and save its post-install message and then enqueue the remaining specs. Some specs might&#39;ve …\n"],["process_title","Bundler::CLI::Exec","Bundler/CLI/Exec.html#method-i-process_title","(file, args)",""],["process_topmost_state","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-process_topmost_state","()","<p>Processes the topmost available {RequirementState} on the stack @return [void]\n"],["process_topmost_state","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-process_topmost_state","()","<p>Processes the topmost available {RequirementState} on the stack @return [void]\n"],["processingInstruction","RSS::REXMLLikeXMLParser","RSS/REXMLLikeXMLParser.html#method-i-processingInstruction","(target, content)",""],["processing_instruction","REXML::Functions","REXML/Functions.html#method-c-processing_instruction","( node )",""],["processing_instruction","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-processing_instruction","(target, data)",""],["processor_count","Bundler::Installer","Bundler/Installer.html#method-i-processor_count","()",""],["produce","Enumerator","Enumerator.html#method-c-produce","(p1 = v1)","<p>Creates an infinite enumerator from any block, just called over and over.  The result of the previous …\n"],["product","Array","Array.html#method-i-product","(*args)","<p>Returns an array of all combinations of elements from all arrays.\n<p>The length of the returned array is …\n"],["progid","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-progid","()","<p>Returns ProgID if it exists. If not found, then returns nil.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel ...</pre>\n"],["progids","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-c-progids","()","<p>Returns array of ProgID.\n"],["program_name","OptionParser","OptionParser.html#method-i-program_name","()","<p>Program name to be emitted in error message and default banner, defaults to $0.\n"],["progress","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-progress","(position)",""],["progress_rate","Bundler::Molinillo::UI","Bundler/Molinillo/UI.html#method-i-progress_rate","()","<p>How often progress should be conveyed to the user via {#indicate_progress}, in seconds. A third of a …\n"],["progress_rate","Gem::Resolver::Molinillo::UI","Gem/Resolver/Molinillo/UI.html#method-i-progress_rate","()","<p>How often progress should be conveyed to the user via {#indicate_progress}, in seconds. A third of a …\n"],["progress_reporter","Gem::StreamUI","Gem/StreamUI.html#method-i-progress_reporter","(*args)","<p>Return a progress reporter object chosen from the current verbosity.\n"],["prompt_mode=","IRB::Context","IRB/Context.html#method-i-prompt_mode-3D","(mode)","<p>Sets the <code>mode</code> of the prompt in this context.\n<p>See IRB@Customizing+the+IRB+Prompt for more information. …\n"],["prompt_proc=","Reline::Core","Reline/Core.html#method-i-prompt_proc-3D","(p)",""],["prompting?","IRB::Context","IRB/Context.html#method-i-prompting-3F","()","<p>Whether #verbose? is <code>true</code>, and <code>input_method</code> is either StdioInputMethod or ReidlineInputMethod or ReadlineInputMethod …\n"],["proper_subset?","Set","Set.html#method-i-proper_subset-3F","(set)","<p>Returns true if the set is a proper subset of the given set.\n"],["proper_superset?","Set","Set.html#method-i-proper_superset-3F","(set)","<p>Returns true if the set is a proper superset of the given set.\n"],["propfind","Net::HTTP","Net/HTTP.html#method-i-propfind","(path, body = nil, initheader = {'Depth' => '0'})","<p>Sends a PROPFIND request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["proppatch","Net::HTTP","Net/HTTP.html#method-i-proppatch","(path, body, initheader = nil)","<p>Sends a PROPPATCH request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["protected","Module","Module.html#method-i-protected","(*args)","<p>With no arguments, sets the default visibility for subsequently defined methods to protected. With arguments, …\n"],["protected_instance_methods","Module","Module.html#method-i-protected_instance_methods","(*args)","<p>Returns a list of the protected instance methods defined in <em>mod</em>. If the optional parameter is <code>false</code>, …\n"],["protected_method_defined?","Module","Module.html#method-i-protected_method_defined-3F","(*args)","<p>Returns <code>true</code> if the named protected method is defined <em>mod</em>.  If <em>inherit</em> is set, the lookup will also search …\n"],["protected_methods","Delegator","Delegator.html#method-i-protected_methods","(all=true)","<p>Returns the methods available to this delegate object as the union of this object&#39;s and _<em>getobj</em> …\n"],["protected_methods","Object","Object.html#method-i-protected_methods","(*args)","<p>Returns the list of protected methods accessible to <em>obj</em>. If the <em>all</em> parameter is set to <code>false</code>, only those …\n"],["protocol","Addrinfo","Addrinfo.html#method-i-protocol","()","<p>returns the socket type as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">protocol</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">IPPROTO_TCP</span> <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["provide","Rinda::RingProvider","Rinda/RingProvider.html#method-i-provide","()","<p>Advertises this service on the primary remote TupleSpace.\n"],["provides?","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-provides-3F","(req_str)",""],["provides?","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-c-provides-3F","(req_str)",""],["proxy=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-proxy-3D","(proxy)","<p>Sets the proxy server.  The <code>proxy</code> may be the Bundler::URI of the proxy server, the symbol <code>:ENV</code> which …\n"],["proxy?","Net::HTTP","Net/HTTP.html#method-i-proxy-3F","()","<p>True if requests for this connection will be proxied\n"],["proxy_address","Net::HTTP","Net/HTTP.html#method-i-proxy_address","()","<p>The address of the proxy server, if one is configured.\n"],["proxy_basic_auth","Net::HTTPHeader","Net/HTTPHeader.html#method-i-proxy_basic_auth","(account, password)","<p>Set Proxy-Authorization: header for “Basic” authorization.\n"],["proxy_basic_auth","WEBrick::HTTPAuth","WEBrick/HTTPAuth.html#method-i-proxy_basic_auth","(req, res, realm)","<p>Simple wrapper for providing basic authentication for a proxied request. When called with a request  …\n"],["proxy_bypass?","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-proxy_bypass-3F","(host, port)","<p>Returns true when proxy should by bypassed for host.\n"],["proxy_class?","Net::HTTP","Net/HTTP.html#method-c-proxy_class-3F","()","<p>returns true if self is a class which was created by HTTP::Proxy.\n"],["proxy_for","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-proxy_for","(proxy, uri)",""],["proxy_from_env","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-proxy_from_env","()","<p>Creates a Bundler::URI for an HTTP proxy server from ENV variables.\n<p>If <code>HTTP_PROXY</code> is set a proxy will …\n"],["proxy_from_env?","Net::HTTP","Net/HTTP.html#method-i-proxy_from_env-3F","()","<p>True if the proxy for this connection is determined from the environment\n"],["proxy_pass","Net::HTTP","Net/HTTP.html#method-i-proxy_pass","()","<p>The password of the proxy server, if one is configured.\n"],["proxy_port","Net::HTTP","Net/HTTP.html#method-i-proxy_port","()","<p>The port of the proxy server, if one is configured.\n"],["proxy_uri","Gem::Request","Gem/Request.html#method-i-proxy_uri","()",""],["proxy_user","Net::HTTP","Net/HTTP.html#method-i-proxy_user","()","<p>The username of the proxy server, if one is configured.\n"],["proxyaddr","Net::HTTP","Net/HTTP.html#method-i-proxyaddr","()",""],["proxyport","Net::HTTP","Net/HTTP.html#method-i-proxyport","()",""],["prune","Find","Find.html#method-c-prune","()","<p>Skips the current file or directory, restarting the loop with the next entry. If the current file is …\n"],["prune","Find","Find.html#method-i-prune","()","<p>Skips the current file or directory, restarting the loop with the next entry. If the current file is …\n"],["prune_cache","Bundler::Runtime","Bundler/Runtime.html#method-i-prune_cache","(cache_path)",""],["prune_gem_cache","Bundler::Runtime","Bundler/Runtime.html#method-i-prune_gem_cache","(resolve, cache_path)",""],["prune_git_and_path_cache","Bundler::Runtime","Bundler/Runtime.html#method-i-prune_git_and_path_cache","(resolve, cache_path)",""],["pseudo_bytes","OpenSSL::Random","OpenSSL/Random.html#method-c-pseudo_bytes","(p1)","<p>Generates a String with <em>length</em> number of pseudo-random bytes.\n<p>Pseudo-random byte sequences generated by …\n"],["ptr","Fiddle::Pointer","Fiddle/Pointer.html#method-i-ptr","()","<p>Returns a new Fiddle::Pointer instance that is a dereferenced pointer for this pointer.\n<p>Analogous to the …\n"],["ptr_bug!","Racc::LocationPointer","Racc/LocationPointer.html#method-i-ptr_bug-21","()",""],["pubDate","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-pubDate","()",""],["pubDate","RSS::Maker::ItemsBase::ItemBase","RSS/Maker/ItemsBase/ItemBase.html#method-i-pubDate","()",""],["pubDate=","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-pubDate-3D","(date)",""],["pubDate=","RSS::Maker::ItemsBase::ItemBase","RSS/Maker/ItemsBase/ItemBase.html#method-i-pubDate-3D","(date)",""],["public","Module","Module.html#method-i-public","(*args)","<p>With no arguments, sets the default visibility for subsequently defined methods to public. With arguments, …\n"],["public","REXML::DocType","REXML/DocType.html#method-i-public","()","<p>This method retrieves the public identifier identifying the document&#39;s DTD.\n<p>Method contributed by …\n"],["public?","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-public-3F","()","<p>Indicates whether this DH instance has a public key associated with it or not. The public key may be …\n"],["public?","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-public-3F","()","<p>Indicates whether this DSA instance has a public key associated with it or not. The public key may be …\n"],["public?","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-public-3F","()","<p>Returns whether this EC instance has a public key. The public key (EC::Point) can be retrieved with  …\n"],["public?","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-public-3F","()","<p>The return value is always <code>true</code> since every private key is also a public key.\n"],["public_class_method","Module","Module.html#method-i-public_class_method","(*args)","<p>Makes a list of existing class methods public.\n<p>String arguments are converted to symbols.\n"],["public_command","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-public_command","(*names)","<p>Allows to use private methods from parent in child classes as commands.\n<p>Parameters\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">names</span><span class=\"ruby-operator\">&lt;</span><span class=\"ruby-constant\">Array</span><span class=\"ruby-operator\">&gt;</span><span class=\"ruby-operator\">::</span> <span class=\"ruby-constant\">Method</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["public_constant","Module","Module.html#method-i-public_constant","(*args)","<p>Makes a list of existing constants public.\n"],["public_decrypt","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-public_decrypt","(p1, p2 = v2)","<p>Decrypt <em>string</em>, which has been encrypted with the private key, with the public key.  <em>padding</em> defaults …\n"],["public_encrypt","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-public_encrypt","(p1, p2 = v2)","<p>Encrypt <em>string</em> with the public key.  <em>padding</em> defaults to PKCS1_PADDING. The encrypted string output can …\n"],["public_instance_method","Module","Module.html#method-i-public_instance_method","(p1)","<p>Similar to <em>instance_method</em>, searches public method only.\n"],["public_instance_methods","Module","Module.html#method-i-public_instance_methods","(*args)","<p>Returns a list of the public instance methods defined in <em>mod</em>. If the optional parameter is <code>false</code>, the …\n"],["public_key","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-public_key","()","<p>Returns the public key associated with the SPKI, an instance of OpenSSL::PKey.\n"],["public_key","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-public_key","()","<p>Returns a new DH instance that carries just the public information, i.e. the prime <em>p</em> and the generator …\n"],["public_key","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-public_key","()","<p>Returns a new DSA instance that carries just the public key information. If the current instance has …\n"],["public_key","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-public_key","()","<p>See the OpenSSL documentation for EC_KEY_get0_public_key()\n"],["public_key","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-public_key","()","<p>Makes new RSA instance containing the public key from the private key.\n"],["public_key","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-public_key","()",""],["public_key","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-public_key","()",""],["public_key=","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-public_key-3D","(p1)","<p>Parameters\n<p><em>pub</em> - the public key to be set for this instance\n\n<p>Sets the public key to be associated with the …\n"],["public_key=","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-public_key-3D","(p1)","<p>See the OpenSSL documentation for EC_KEY_set_public_key()\n"],["public_key=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-public_key-3D","(p1)",""],["public_key=","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-public_key-3D","(p1)",""],["public_key?","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-public_key-3F","()",""],["public_method","Object","Object.html#method-i-public_method","(p1)","<p>Similar to <em>method</em>, searches public method only.\n"],["public_method_defined?","Module","Module.html#method-i-public_method_defined-3F","(*args)","<p>Returns <code>true</code> if the named public method is defined by <em>mod</em>.  If <em>inherit</em> is set, the lookup will also search …\n"],["public_methods","Delegator","Delegator.html#method-i-public_methods","(all=true)","<p>Returns the methods available to this delegate object as the union of this object&#39;s and _<em>getobj</em> …\n"],["public_methods","Object","Object.html#method-i-public_methods","(*args)","<p>Returns the list of public methods accessible to <em>obj</em>. If the <em>all</em> parameter is set to <code>false</code>, only those …\n"],["public_send","Object","Object.html#method-i-public_send","(*args)","<p>Invokes the method identified by <em>symbol</em>, passing it any arguments specified. Unlike send, public_send …\n"],["public_task","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-public_task","(*names)",""],["pull","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-pull","()","<p>Returns the next event.  This is a <code>PullEvent</code> object.\n"],["pull","REXML::Parsers::PullParser","REXML/Parsers/PullParser.html#method-i-pull","()",""],["pull_event","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-pull_event","()",""],["purgeable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-purgeable-3F","()","<p>Returns <code>true</code> if the objects in the directory may be deleted, or the directory may be purged.\n"],["purpose=","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-purpose-3D","(p1)","<p>Sets the store&#39;s purpose to <em>purpose</em>. If specified, the verifications on the store will check every …\n"],["purpose=","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-purpose-3D","(p1)","<p>Sets the purpose of the context. See Store#purpose=.\n"],["push","Array","Array.html#method-i-push","(*args)","<p>Append — Pushes the given object(s) on to the end of this array. This expression returns the array …\n"],["push","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-push","(obj, options = {})","<p>Returns <code>obj</code> to the stack.  <code>options</code> is ignored in TimedStack but may be used by subclasses that extend …\n"],["push","Bundler::Thor::NestedContext","Bundler/Thor/NestedContext.html#method-i-push","()",""],["push","CSV::Row","CSV/Row.html#method-i-push","(*args)","<p>A shortcut for appending multiple fields. Equivalent to:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">args</span>.<span class=\"ruby-identifier\">each</span> { <span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">arg</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">csv_row</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-identifier\">arg</span> }\n</pre>\n<p>This method …\n"],["push","CSV::Table","CSV/Table.html#method-i-push","(*rows)","<p>A shortcut for appending multiple rows. Equivalent to:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">rows</span>.<span class=\"ruby-identifier\">each</span> { <span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">row</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-keyword\">self</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-identifier\">row</span> }\n</pre>\n<p>This method returns …\n"],["push","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-push","(value)",""],["push","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-push","(object)",""],["push","Queue","Queue.html#method-i-push","(p1)","<p>Pushes the given <code>object</code> to the queue.\n"],["push","REXML::Parent","REXML/Parent.html#method-i-push","( object )",""],["push","Rinda::TupleBag","Rinda/TupleBag.html#method-i-push","(tuple)","<p>Add <code>tuple</code> to the TupleBag.\n"],["push","SizedQueue","SizedQueue.html#method-i-push","(*args)","<p>Pushes <code>object</code> to the queue.\n<p>If there is no space left in the queue, waits until space becomes available, …\n"],["push_action","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-push_action","(graph, action)","<p>Adds the given action to the log, running the action @param [DependencyGraph] graph @param [Action] action …\n"],["push_action","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-push_action","(graph, action)","<p>Adds the given action to the log, running the action @param [DependencyGraph] graph @param [Action] action …\n"],["push_inspect_key","PP::PPMethods","PP/PPMethods.html#method-i-push_inspect_key","(id)","<p>Adds the object_id <code>id</code> to the set of objects being pretty printed, so as to not repeat objects.\n"],["push_state_for_requirements","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-push_state_for_requirements","(new_requirements, requires_sort = true, new_activated = activated)","<p>Pushes a new {DependencyState} that encapsulates both existing and new requirements @param [Array] new_requirements …\n"],["push_state_for_requirements","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-push_state_for_requirements","(new_requirements, requires_sort = true, new_activated = activated)","<p>Pushes a new {DependencyState} that encapsulates both existing and new requirements @param [Array] new_requirements …\n"],["push_workspace","IRB::Context","IRB/Context.html#method-i-push_workspace","(*_main)","<p>Creates a new workspace with the given object or binding, and appends it onto the current #workspaces …\n"],["put","Net::FTP","Net/FTP.html#method-i-put","(localfile, remotefile = File.basename(localfile), blocksize = DEFAULT_BLOCKSIZE, &block)","<p>Transfers <code>localfile</code> to the server in whatever mode the session is set (text or binary).  See #puttextfile …\n"],["put","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-put","(src, convert_line = false)","<p>Low Level Routines\n"],["put_state_transition_table","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-put_state_transition_table","(f)","<p>State Transition Table Serialization\n"],["put_string","Net::IMAP","Net/IMAP.html#method-i-put_string","(str)",""],["putback","Encoding::Converter","Encoding/Converter.html#method-i-putback","(*args)","<p>Put back the bytes which will be converted.\n<p>The bytes are caused by invalid_byte_sequence error. When …\n"],["putbinaryfile","Net::FTP","Net/FTP.html#method-i-putbinaryfile","(localfile, remotefile = File.basename(localfile), blocksize = DEFAULT_BLOCKSIZE)","<p>Transfers <code>localfile</code> to the server in binary mode, storing the result in <code>remotefile</code>. If a block is supplied, …\n"],["putc","ARGF","ARGF.html#method-i-putc","(p1)","<p>If <em>obj</em> is Numeric, write the character whose code is the least-significant byte of <em>obj</em>.  If <em>obj</em> is String …\n"],["putc","IO","IO.html#method-i-putc","(p1)","<p>If <em>obj</em> is Numeric, write the character whose code is the least-significant byte of <em>obj</em>.  If <em>obj</em> is String …\n"],["putc","Kernel","Kernel.html#method-i-putc","(p1)","<p>Equivalent to:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">$stdout</span>.<span class=\"ruby-identifier\">putc</span>(<span class=\"ruby-identifier\">int</span>)\n</pre>\n<p>Refer to the documentation for IO#putc for important information regarding …\n"],["putc","StringIO","StringIO.html#method-i-putc","(p1)","<p>See IO#putc.\n"],["putc","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-putc","(p1)","<p>Same as IO.\n"],["puts","ARGF","ARGF.html#method-i-puts","(*args)","<p>Writes the given object(s) to <em>ios</em>. Writes a newline after any that do not already end with a newline …\n"],["puts","CSV","CSV.html#method-i-puts","(row)",""],["puts","IO","IO.html#method-i-puts","(*args)","<p>Writes the given object(s) to <em>ios</em>. Writes a newline after any that do not already end with a newline …\n"],["puts","IO::generic_writable","IO/generic_writable.html#method-i-puts","(*args)","<p>See IO#puts.\n"],["puts","IRB::Locale","IRB/Locale.html#method-i-puts","(*opts)",""],["puts","IRB::Notifier::AbstractNotifier","IRB/Notifier/AbstractNotifier.html#method-i-puts","(*objs)","<p>See OutputMethod#puts for more detail.\n"],["puts","IRB::OutputMethod","IRB/OutputMethod.html#method-i-puts","(*objs)","<p>Calls #print on each element in the given <code>objs</code>, followed by a newline character.\n"],["puts","Kernel","Kernel.html#method-i-puts","(*args)","<p>Equivalent to\n\n<pre>$stdout.puts(obj, ...)</pre>\n"],["puts","Net::WriteAdapter","Net/WriteAdapter.html#method-i-puts","(str = '')",""],["puts","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-puts","(*args)","<p>Writes <em>args</em> to the stream along with a record separator.\n<p>See IO#puts for full details.\n"],["puts","XMP","XMP.html#method-i-puts","(exps)","<p>Evaluates the given <code>exps</code>, for example:\n\n<pre>require &#39;irb/xmp&#39;\nx = XMP.new\n\nx.puts &#39;{:a =&gt; 1, :b =&gt; 2, :c =&gt; ...</pre>\n"],["puts","XMP::StringInputMethod","XMP/StringInputMethod.html#method-i-puts","(exps)","<p>Concatenates all expressions in this printer, separated by newlines.\n<p>An Encoding::CompatibilityError is …\n"],["puts","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-puts","(*args)","<p>Same as IO.\n"],["puttextfile","Net::FTP","Net/FTP.html#method-i-puttextfile","(localfile, remotefile = File.basename(localfile))","<p>Transfers <code>localfile</code> to the server in ASCII (text) mode, storing the result in <code>remotefile</code>. If callback …\n"],["pwd","Bundler::FileUtils","Bundler/FileUtils.html#method-i-pwd","()","<p>Returns the name of the current directory.\n"],["pwd","Bundler::FileUtils","Bundler/FileUtils.html#method-c-pwd","()","<p>Returns the name of the current directory.\n"],["pwd","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-pwd","()",""],["pwd","Dir","Dir.html#method-c-pwd","()","<p>Returns the path to the current working directory of this process as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">chdir</span>(<span class=\"ruby-string\">&quot;/tmp&quot;</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["pwd","FileUtils","FileUtils.html#method-c-pwd","()","<p>Returns the name of the current directory.\n"],["pwd","FileUtils","FileUtils.html#method-i-pwd","()","<p>Returns the name of the current directory.\n"],["pwd","Net::FTP","Net/FTP.html#method-i-pwd","()","<p>Returns the current remote directory.\n"],["pwd","Pathname","Pathname.html#method-c-pwd","()","<p>Returns the current working directory as a Pathname.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">getwd</span>\n    <span class=\"ruby-comment\">#=&gt; #&lt;Pathname:/home/zzak/projects/ruby&gt;</span>\n</pre>\n"],["pwrite","IO","IO.html#method-i-pwrite","(p1, p2)","<p>Writes the given string to <em>ios</em> at <em>offset</em> using pwrite() system call.  This is advantageous to combining …\n"],["qdval","Net::IMAP::DigestMD5Authenticator","Net/IMAP/DigestMD5Authenticator.html#method-i-qdval","(k, v)","<p>some responses need quoting\n"],["query","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-query","()","<p>Request query as a Hash\n"],["query=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-query-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["query=","URI::Generic","URI/Generic.html#method-i-query-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["quick","Gem::Server","Gem/Server.html#method-i-quick","(req, res)",""],["quick_gem","Gem::TestCase","Gem/TestCase.html#method-i-quick_gem","(name, version='2')","<p>Creates a Gem::Specification with a minimum of extra work.  <code>name</code> and <code>version</code> are the gem&#39;s name and …\n"],["quiet","RDoc::Options","RDoc/Options.html#method-i-quiet","()","<p>Don&#39;t display progress as we process the files\n"],["quiet=","RDoc::Options","RDoc/Options.html#method-i-quiet-3D","(bool)","<p>Set quietness to <code>bool</code>\n"],["quiet?","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-quiet-3F","()",""],["quiet?","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-quiet-3F","()",""],["quit","Net::FTP","Net/FTP.html#method-i-quit","()","<p>Exits the FTP session.\n"],["quit","Net::SMTP","Net/SMTP.html#method-i-quit","()",""],["quo","BigDecimal","BigDecimal.html#method-i-quo","(p1)","<p>Divide by the specified value.\n<p>See BigDecimal#div.\n"],["quo","Complex","Complex.html#method-i-quo","(p1)","<p>Performs division.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; ((1/1)+(0/1)*i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>)   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["quo","Float","Float.html#method-i-quo","(p1)","<p>Returns <code>float / numeric</code>, same as Float#/.\n"],["quo","Numeric","Numeric.html#method-i-quo","(p1)","<p>Returns the most exact division (rational for integers, float for floats).\n"],["quo","Rational","Rational.html#method-i-quo","(p1)","<p>Performs division.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)  <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>)   <span class=\"ruby-comment\">#=&gt; (1/1)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">900</span>)   <span class=\"ruby-operator\">/</span> <span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">1</span>)      <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["quote","CSV::Writer","CSV/Writer.html#method-i-quote","(field)",""],["quote","Regexp","Regexp.html#method-c-quote","(p1)","<p>Escapes any characters that would have special meaning in a regular expression. Returns a new escaped …\n"],["quote","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-quote","(str)","<p>Quotes and escapes quotes in <code>str</code>\n"],["quote","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-quote","(str)","<p>Quotes and escapes quotes in <code>str</code>\n"],["quote_char","CSV","CSV.html#method-i-quote_char","()","<p>The encoded <code>:quote_char</code> used in parsing and writing. See CSV::new for details.\n"],["quote_character","CSV::Parser","CSV/Parser.html#method-i-quote_character","()",""],["quote_field","CSV::Writer","CSV/Writer.html#method-i-quote_field","(field)",""],["quote_string","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-quote_string","(str, charset)",""],["quoting_detection_proc","Readline","Readline.html#method-c-quoting_detection_proc","()","<p>Returns the quoting detection Proc object.\n"],["quoting_detection_proc=","Readline","Readline.html#method-c-quoting_detection_proc-3D","(p1)","<p>Specifies a Proc object <code>proc</code> to determine if a character in the user&#39;s input is escaped. It should …\n"],["r","Vector","Vector.html#method-i-r","()",""],["racc_accept","Racc::Parser","Racc/Parser.html#method-i-racc_accept","()",""],["racc_e_pop","Racc::Parser","Racc/Parser.html#method-i-racc_e_pop","(state, tstack, vstack)",""],["racc_next_state","Racc::Parser","Racc/Parser.html#method-i-racc_next_state","(curstate, state)",""],["racc_print_stacks","Racc::Parser","Racc/Parser.html#method-i-racc_print_stacks","(t, v)",""],["racc_print_states","Racc::Parser","Racc/Parser.html#method-i-racc_print_states","(s)",""],["racc_read_token","Racc::Parser","Racc/Parser.html#method-i-racc_read_token","(t, tok, val)","<p>For debugging output\n"],["racc_reduce","Racc::Parser","Racc/Parser.html#method-i-racc_reduce","(toks, sim, tstack, vstack)",""],["racc_shift","Racc::Parser","Racc/Parser.html#method-i-racc_shift","(tok, tstack, vstack)",""],["racc_token2str","Racc::Parser","Racc/Parser.html#method-i-racc_token2str","(tok)",""],["radio_button","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-radio_button","(name = \"\", value = nil, checked = nil)","<p>Generates a radio-button Input element.\n<p><code>name</code> is the name of the input field.  <code>value</code> is the value of the …\n"],["radio_group","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-radio_group","(name = \"\", *values)","<p>Generate a sequence of radio button Input elements, as a String.\n<p>This works the same as #checkbox_group() …\n"],["raise","Delegator","Delegator.html#method-i-raise","","<p>Use #__raise__ if your Delegator does not have a object to delegate the #raise method call.\n"],["raise","Fiber","Fiber.html#method-i-raise","(*args)","<p>Raises an exception in the fiber at the point at which the last Fiber.yield was called, or at the start …\n"],["raise","Kernel","Kernel.html#method-i-raise","(*args)","<p>With no arguments, raises the exception in <code>$!</code> or raises a RuntimeError if <code>$!</code> is <code>nil</code>.  With a single  …\n"],["raise","Thread","Thread.html#method-i-raise","(*args)","<p>Raises an exception from the given thread. The caller does not have to be <code>thr</code>. See Kernel#raise for more …\n"],["raise_error_unless_state","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-raise_error_unless_state","(conflicts)","<p>Raises a VersionConflict error, or any underlying error, if there is no current state @return [void] …\n"],["raise_for_undefined_entity?","RSS::BaseListener","RSS/BaseListener.html#method-c-raise_for_undefined_entity-3F","()",""],["raise_for_undefined_entity?","RSS::BaseParser","RSS/BaseParser.html#method-c-raise_for_undefined_entity-3F","()",""],["raise_for_undefined_entity?","RSS::REXMLListener","RSS/REXMLListener.html#method-c-raise_for_undefined_entity-3F","()",""],["raised_exception","TracePoint","TracePoint.html#method-i-raised_exception","()","<p>Value from exception raised on the <code>:raise</code> event\n"],["rake_classes","Bundler::Thor::RakeCompat","Bundler/Thor/RakeCompat.html#method-c-rake_classes","()",""],["rake_namespace","Object","Object.html#method-i-rake_namespace","(name)",""],["rand","Kernel","Kernel.html#method-i-rand","(*args)","<p>If called without an argument, or if <code>max.to_i.abs == 0</code>, rand returns a pseudo-random floating point number …\n"],["rand","Random","Random.html#method-c-rand","(*args)","<p>Alias of Random::DEFAULT.rand.\n"],["rand","Random","Random.html#method-i-rand","(*args)","<p>When <code>max</code> is an Integer, <code>rand</code> returns a random integer greater than or equal to zero and less than <code>max</code> …\n"],["rand","Random::Formatter","Random/Formatter.html#method-i-rand","(*args)","<p>Generates formatted random number from raw random bytes. See Random#rand.\n"],["random_add","OpenSSL::Random","OpenSSL/Random.html#method-c-random_add","(p1, p2)","<p>Mixes the bytes from <em>str</em> into the Pseudo Random Number Generator(PRNG) state.\n<p>Thus, if the data from  …\n"],["random_bytes","OpenSSL::Random","OpenSSL/Random.html#method-c-random_bytes","(p1)","<p>Generates a String with <em>length</em> number of cryptographically strong pseudo-random bytes.\n<p>Example\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">OpenSSL</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Random</span>.<span class=\"ruby-identifier\">random_bytes</span>(<span class=\"ruby-value\">12</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["random_bytes","Random::Formatter","Random/Formatter.html#method-i-random_bytes","(n=nil)","<p>SecureRandom.random_bytes generates a random binary string.\n<p>The argument <em>n</em> specifies the length of the …\n"],["random_iv","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-random_iv","()","<p>Generate a random IV with OpenSSL::Random.random_bytes and sets it to the cipher, and returns it.\n<p>You …\n"],["random_key","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-random_key","()","<p>Generate a random key with OpenSSL::Random.random_bytes and sets it to the cipher, and returns it.\n<p>You …\n"],["random_number","Random::Formatter","Random/Formatter.html#method-i-random_number","(*args)","<p>Generates formatted random number from raw random bytes. See Random#rand.\n"],["random_string","WEBrick::Utils","WEBrick/Utils.html#method-c-random_string","(len)","<p>Generates a random string of length <code>len</code>\n"],["random_string","WEBrick::Utils","WEBrick/Utils.html#method-i-random_string","(len)","<p>Generates a random string of length <code>len</code>\n"],["range","Net::HTTPHeader","Net/HTTPHeader.html#method-i-range","()","<p>Returns an Array of Range objects which represent the Range: HTTP header field, or <code>nil</code> if there is no …\n"],["range=","Net::HTTPHeader","Net/HTTPHeader.html#method-i-range-3D","(r, e = nil)",""],["range_length","Net::HTTPHeader","Net/HTTPHeader.html#method-i-range_length","()","<p>The length of the range represented in Content-Range: header.\n"],["rank","Matrix","Matrix.html#method-i-rank","()","<p>Returns the rank of the matrix. Beware that using Float values can yield erroneous results because of …\n"],["rank_e","Matrix","Matrix.html#method-i-rank_e","()","<p>deprecated; use Matrix#rank\n"],["rassoc","Array","Array.html#method-i-rassoc","(p1)","<p>Searches through the array whose elements are also arrays.\n<p>Compares <code>obj</code> with the second element of each …\n"],["rassoc","ENV","ENV.html#method-c-rassoc","(p1)","<p>Returns an Array of the name and value of the environment variable with <code>value</code> or <code>nil</code> if the value cannot …\n"],["rassoc","Hash","Hash.html#method-i-rassoc","(p1)","<p>Searches through the hash comparing <em>obj</em> with the value using <code>==</code>. Returns the first key-value pair (two-element …\n"],["rationalize","Complex","Complex.html#method-i-rationalize","(*args)","<p>Returns the value as a rational if possible (the imaginary part should be exactly zero).\n\n<pre>Complex(1.0/3, ...</pre>\n"],["rationalize","Float","Float.html#method-i-rationalize","(*args)","<p>Returns a simpler approximation of the value (flt-|eps| &lt;= result &lt;= flt+|eps|).  If the optional …\n"],["rationalize","Integer","Integer.html#method-i-rationalize","(*args)","<p>Returns the value as a rational.  The optional argument <code>eps</code> is always ignored.\n"],["rationalize","NilClass","NilClass.html#method-i-rationalize","(*args)","<p>Returns zero as a rational.  The optional argument <code>eps</code> is always ignored.\n"],["rationalize","Rational","Rational.html#method-i-rationalize","(*args)","<p>Returns a simpler approximation of the value if the optional argument <code>eps</code> is given (rat-|eps| &lt;= result …\n"],["raw","IO","IO.html#method-i-raw","(*args)","<p>Yields <code>self</code> within raw mode, and returns the result of the block.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">STDIN</span>.<span class=\"ruby-identifier\">raw</span>(<span class=\"ruby-operator\">&amp;</span><span class=\"ruby-value\">:gets</span>)\n</pre>\n<p>will read and return …\n"],["raw","REXML::Element","REXML/Element.html#method-i-raw","()","<p>Evaluates to <code>true</code> if raw mode is set for this element.  This is the case if the context has :<code>raw</code> set …\n"],["raw!","IO","IO.html#method-i-raw-21","(*args)","<p>Enables raw mode, and returns <code>io</code>.\n<p>If the terminal mode needs to be back, use <code>io.raw { ... }</code>.\n<p>See IO#raw …\n"],["raw_cookie","CGI::QueryExtension","CGI/QueryExtension.html#method-i-raw_cookie","()","<p>Get the raw cookies as a string.\n"],["raw_cookie2","CGI::QueryExtension","CGI/QueryExtension.html#method-i-raw_cookie2","()","<p>Get the raw RFC2965 cookies as a string.\n"],["raw_data","GC::Profiler","GC/Profiler.html#method-c-raw_data","()","<p>Returns an Array of individual raw profile data Hashes ordered from earliest to latest by <code>:GC_INVOKE_TIME</code> …\n"],["raw_encoding","CSV","CSV.html#method-i-raw_encoding","()","<p>Returns the encoding of the internal IO object.\n"],["raw_require_paths","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-raw_require_paths","()",""],["raw_spec","Gem::Package","Gem/Package.html#method-c-raw_spec","(path, security_policy = nil)","<p>Extracts the Gem::Specification and raw metadata from the .gem file at <code>path</code>.\n"],["rb_files_in","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-rb_files_in","(dir)",""],["rb_scan_args","RDoc::Parser::C","RDoc/Parser/C.html#method-i-rb_scan_args","(method_body)","<p>Extracts parameters from the <code>method_body</code> and returns a method parameter string.  Follows 1.9.3dev&#39;s …\n"],["rbx?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-rbx-3F","()",""],["rcptto","Net::SMTP","Net/SMTP.html#method-i-rcptto","(to_addr)",""],["rcptto_list","Net::SMTP","Net/SMTP.html#method-i-rcptto_list","(to_addrs)",""],["rdev","File::Stat","File/Stat.html#method-i-rdev","()","<p>Returns an integer representing the device type on which <em>stat</em> resides. Returns <code>nil</code> if the operating system …\n"],["rdev_major","File::Stat","File/Stat.html#method-i-rdev_major","()","<p>Returns the major part of <code>File_Stat#rdev</code> or <code>nil</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/fd1&quot;</span>).<span class=\"ruby-identifier\">rdev_major</span>   <span class=\"ruby-comment\">#=&gt; 2</span>\n<span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/tty&quot;</span>).<span class=\"ruby-identifier\">rdev_major</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rdev_minor","File::Stat","File/Stat.html#method-i-rdev_minor","()","<p>Returns the minor part of <code>File_Stat#rdev</code> or <code>nil</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/fd1&quot;</span>).<span class=\"ruby-identifier\">rdev_minor</span>   <span class=\"ruby-comment\">#=&gt; 1</span>\n<span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;/dev/tty&quot;</span>).<span class=\"ruby-identifier\">rdev_minor</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rdoc","Gem::Server","Gem/Server.html#method-i-rdoc","(req, res)","<p>Can be used for quick navigation to the rdoc documentation.  You can then define a search shortcut for …\n"],["rdoc_installed?","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-rdoc_installed-3F","()","<p>Is rdoc documentation installed?\n"],["rdoc_installed?","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-rdoc_installed-3F","()","<p>Is rdoc documentation installed?\n"],["rdoc_options","Gem::Specification","Gem/Specification.html#method-i-rdoc_options","()","<p>Specifies the rdoc options to be used when generating API documentation.\n<p>Usage:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">spec</span>.<span class=\"ruby-identifier\">rdoc_options</span> <span class=\"ruby-operator\">&lt;&lt;</span> <span class=\"ruby-string\">&#39;--title&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rdoc_options=","Gem::Specification","Gem/Specification.html#method-i-rdoc_options-3D","(options)","<p>Sets rdoc_options to <code>value</code>, ensuring it is an array. Don&#39;t use this, push onto the array instead. …\n"],["rdoc_target","RDoc::Task","RDoc/Task.html#method-i-rdoc_target","()",""],["rdoc_target","RDoc::Task","RDoc/Task.html#method-i-rdoc_target","()",""],["rdoc_task_description","RDoc::Task","RDoc/Task.html#method-i-rdoc_task_description","()","<p>Task description for the rdoc task or its renamed equivalent\n"],["rdoc_task_description","RDoc::Task","RDoc/Task.html#method-i-rdoc_task_description","()","<p>Task description for the rdoc task or its renamed equivalent\n"],["rdoc_task_name","RDoc::Task","RDoc/Task.html#method-i-rdoc_task_name","()",""],["rdoc_task_name","RDoc::Task","RDoc/Task.html#method-i-rdoc_task_name","()",""],["re_exchange","Process::GID","Process/GID.html#method-c-re_exchange","()","<p>Exchange real and effective group IDs and return the new effective group ID. Not available on all platforms. …\n"],["re_exchange","Process::UID","Process/UID.html#method-c-re_exchange","()","<p>Exchange real and effective user IDs and return the new effective user ID. Not available on all platforms. …\n"],["re_exchangeable?","Process::GID","Process/GID.html#method-c-re_exchangeable-3F","()","<p>Returns <code>true</code> if the real and effective group IDs of a process may be exchanged on the current platform. …\n"],["re_exchangeable?","Process::UID","Process/UID.html#method-c-re_exchangeable-3F","()","<p>Returns <code>true</code> if the real and effective user IDs of a process may be exchanged on the current platform. …\n"],["re_sign","Gem::Security","Gem/Security.html#method-c-re_sign","(expired_certificate, private_key, age = ONE_YEAR, extensions = EXTENSIONS)","<p>Signs <code>expired_certificate</code> with <code>private_key</code> if the keys match and the expired certificate was self-signed. …\n"],["re_sign_cert","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-re_sign_cert","(cert, cert_path, private_key)",""],["re_sign_cert","Gem::Security::Signer","Gem/Security/Signer.html#method-c-re_sign_cert","(expired_cert, expired_cert_path, private_key)","<p>Attemps to re-sign an expired cert with a given private key\n"],["reachable_objects_from","ObjectSpace","ObjectSpace.html#method-c-reachable_objects_from","(p1)","<p>MRI specific feature &mdash; Return all reachable objects from `obj&#39;.\n\n<p>This method returns all reachable objects …\n"],["reachable_objects_from_root","ObjectSpace","ObjectSpace.html#method-c-reachable_objects_from_root","()","<p>MRI specific feature &mdash; Return all reachable objects from root.\n\n"],["read","ARGF","ARGF.html#method-i-read","(p1 = v1, p2 = v2)","<p>Reads <em>length</em> bytes from ARGF. The files named on the command line are concatenated and treated as a single …\n"],["read","CSV","CSV.html#method-i-read","()","<p>Slurps the remaining rows and returns an Array of Arrays.\n<p>The data source must be open for reading.\n"],["read","CSV","CSV.html#method-c-read","(path, **options)","<p>Use to slurp a CSV file into an Array of Arrays. Pass the <code>path</code> to the file and any <code>options</code> CSV::new() …\n"],["read","Dir","Dir.html#method-i-read","()","<p>Reads the next entry from <em>dir</em> and returns it as a string. Returns <code>nil</code> at the end of the stream.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testdir&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["read","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-read","(len = nil)","<p>Reads <code>len</code> bytes from the tar file entry, or the rest of the entry if nil\n"],["read","IO","IO.html#method-c-read","(p1, p2 = v2, p3 = v3, p4 = v4, p5 = {})","<p>Opens the file, optionally seeks to the given <code>offset</code>, then returns <code>length</code> bytes (defaulting to the rest …\n"],["read","IO","IO.html#method-i-read","(p1 = v1, p2 = v2)","<p>Reads <em>length</em> bytes from the I/O stream.\n<p><em>length</em> must be a non-negative integer or <code>nil</code>.\n<p>If <em>length</em> is a positive …\n"],["read","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-read","(size=nil, buf=nil)","<p>Reads <em>size</em> bytes from the stream.  If <em>buf</em> is provided it must reference a string which will receive the …\n"],["read","OpenSSL::PKey","OpenSSL/PKey.html#method-c-read","(p1, p2 = v2)","<p>Reads a DER or PEM encoded string from <em>string</em> or <em>io</em> and returns an instance of the appropriate PKey class. …\n"],["read","OpenURI::OpenRead","OpenURI/OpenRead.html#method-i-read","(options={})","<p>OpenURI::OpenRead#read() reads a content referenced by self and returns the content as string. The string …\n"],["read","Pathname","Pathname.html#method-i-read","(p1 = v1, p2 = v2, p3 = v3)","<p>Returns all data from the file, or the first <code>N</code> bytes if specified.\n<p>See File.read.\n"],["read","REXML::IOSource","REXML/IOSource.html#method-i-read","()",""],["read","REXML::Source","REXML/Source.html#method-i-read","()",""],["read","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-read","(len)",""],["read","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-read","(tuple, sec=nil)","<p>Reads <code>tuple</code>, but does not remove it.\n"],["read","Rinda::TupleSpaceProxy","Rinda/TupleSpaceProxy.html#method-i-read","(tuple, sec=nil, &block)","<p>Reads <code>tuple</code> from the proxied TupleSpace.  See TupleSpace#read.\n"],["read","Rinda::WaitTemplateEntry","Rinda/WaitTemplateEntry.html#method-i-read","(tuple)",""],["read","StringIO","StringIO.html#method-i-read","(*args)","<p>See IO#read.\n"],["read","Zlib::GzipReader","Zlib/GzipReader.html#method-i-read","(p1 = v1)","<p>See Zlib::GzipReader documentation for a description.\n"],["read_all","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-read_all","(tuple)","<p>Returns all tuples matching <code>tuple</code>.  Does not remove the found tuples.\n"],["read_all","Rinda::TupleSpaceProxy","Rinda/TupleSpaceProxy.html#method-i-read_all","(tuple)","<p>Reads all tuples matching <code>tuple</code> from the proxied TupleSpace.  See TupleSpace#read_all.\n"],["read_binary","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-read_binary","(path)",""],["read_binary","Gem","Gem.html#method-c-read_binary","(path)","<p>Safely read a file in binary mode on all platforms.\n"],["read_binary","Gem::TestCase","Gem/TestCase.html#method-i-read_binary","(path)","<p>Reads a binary file at <code>path</code>\n"],["read_body","Net::HTTPResponse","Net/HTTPResponse.html#method-i-read_body","(dest = nil, &block)","<p>Gets the entity body returned by the remote HTTP server.\n<p>If a block is given, the body is passed to the …\n"],["read_body_0","Net::HTTPResponse","Net/HTTPResponse.html#method-i-read_body_0","(dest)",""],["read_cache","Gem::TestCase","Gem/TestCase.html#method-i-read_cache","(path)","<p>Reads a Marshal file at <code>path</code>\n"],["read_checksums","Gem::Package","Gem/Package.html#method-i-read_checksums","(gem)","<p>Reads and loads checksums.yaml.gz from the tar file <code>gem</code>\n"],["read_chunk","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-read_chunk","()",""],["read_directive","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-read_directive","(allowed)","<p>Directives are modifier comments that can appear after class, module, or method names. For example:\n\n<pre>def ...</pre>\n"],["read_documentation_modifiers","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-read_documentation_modifiers","(context, allowed)","<p>Handles directives following the definition for <code>context</code> (any RDoc::CodeObject) if the directives are …\n"],["read_escaped_key","Reline::Core","Reline/Core.html#method-i-read_escaped_key","(keyseq_timeout, c, block)",""],["read_file","Bundler","Bundler.html#method-c-read_file","(file)",""],["read_file","Bundler::Env","Bundler/Env.html#method-c-read_file","(filename)",""],["read_file","RDoc::Encoding","RDoc/Encoding.html#method-c-read_file","(filename, encoding, force_transcode = false)","<p>Reads the contents of <code>filename</code> and handles any encoding directives in the file.\n<p>The content will be converted …\n"],["read_from_cmdline","CGI::QueryExtension","CGI/QueryExtension.html#method-i-read_from_cmdline","()","<p>offline mode. read name=value pairs on standard input.\n"],["read_io","Reline::Core","Reline/Core.html#method-i-read_io","(keyseq_timeout, &block)","<p>Keystrokes of GNU Readline will timeout it with the specification of “keyseq-timeout” when …\n"],["read_multipart","CGI::QueryExtension","CGI/QueryExtension.html#method-i-read_multipart","(boundary, content_length)","<p>Parses multipart form elements according to\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">http</span><span class=\"ruby-value\">:/</span><span class=\"ruby-operator\">/</span><span class=\"ruby-identifier\">www</span>.<span class=\"ruby-identifier\">w3</span>.<span class=\"ruby-identifier\">org</span><span class=\"ruby-operator\">/</span><span class=\"ruby-constant\">TR</span><span class=\"ruby-operator\">/</span><span class=\"ruby-identifier\">html401</span><span class=\"ruby-operator\">/</span><span class=\"ruby-identifier\">interact</span><span class=\"ruby-operator\">/</span><span class=\"ruby-identifier\">forms</span>.<span class=\"ruby-identifier\">html</span><span class=\"ruby-comment\">#h-17.13.4.2</span>\n</pre>\n"],["read_nonblock","ARGF","ARGF.html#method-i-read_nonblock","(p1, p2 = v2, p3 = {})","<p>Reads at most <em>maxlen</em> bytes from the ARGF stream in non-blocking mode.\n"],["read_nonblock","IO","IO.html#method-i-read_nonblock","(len, buf = nil, exception: true)","<p>Reads at most <em>maxlen</em> bytes from <em>ios</em> using the read(2) system call after O_NONBLOCK is set for the underlying …\n"],["read_nonblock","IO::generic_readable","IO/generic_readable.html#method-i-read_nonblock","(p1, p2 = v2, p3 = {})","<p>Similar to #read, but raises <code>EOFError</code> at end of string unless the +exception: false+ option is passed …\n"],["read_nonblock","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-read_nonblock","(maxlen, buf=nil, exception: true)","<p>Reads at most <em>maxlen</em> bytes in the non-blocking manner.\n<p>When no data can be read without blocking it raises …\n"],["read_smime","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-c-read_smime","(p1)",""],["read_status_line","Net::HTTPResponse","Net/HTTPResponse.html#method-c-read_status_line","(sock)",""],["read_timeout=","Net::FTP","Net/FTP.html#method-i-read_timeout-3D","(sec)","<p>Setter for the read_timeout attribute.\n"],["read_timeout=","Net::HTTP","Net/HTTP.html#method-i-read_timeout-3D","(sec)","<p>Setter for the read_timeout attribute.\n"],["read_timeout=","Net::POP3","Net/POP3.html#method-i-read_timeout-3D","(sec)","<p>Set the read timeout.\n"],["read_timeout=","Net::SMTP","Net/SMTP.html#method-i-read_timeout-3D","(sec)","<p>Set the number of seconds to wait until timing-out a read(2) call.\n"],["read_with_substitution","REXML::Text","REXML/Text.html#method-c-read_with_substitution","( input, illegal=nil )","<p>Reads text, substituting entities\n"],["readable?","File","File.html#method-c-readable-3F","(p1)","<p>Returns <code>true</code> if the named file is readable by the effective user and group id of this process. See eaccess(3). …\n"],["readable?","File::Stat","File/Stat.html#method-i-readable-3F","()","<p>Returns <code>true</code> if <em>stat</em> is readable by the effective user id of this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">readable?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["readable?","FileTest","FileTest.html#method-i-readable-3F","(p1)","<p>Returns <code>true</code> if the named file is readable by the effective user and group id of this process. See eaccess(3). …\n"],["readable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-readable-3F","()","<p>Returns <code>true</code> if the RETR command may be applied to the file.\n"],["readable?","Pathname","Pathname.html#method-i-readable-3F","()","<p>See FileTest.readable?.\n"],["readable_after_eof?","IRB::InputMethod","IRB/InputMethod.html#method-i-readable_after_eof-3F","()","<p>Whether this input method is still readable when there is no more data to read.\n<p>See IO#eof for more information. …\n"],["readable_after_eof?","IRB::ReadlineInputMethod","IRB/ReadlineInputMethod.html#method-i-readable_after_eof-3F","()","<p>Whether this input method is still readable when there is no more data to read.\n<p>See IO#eof for more information. …\n"],["readable_after_eof?","IRB::ReidlineInputMethod","IRB/ReidlineInputMethod.html#method-i-readable_after_eof-3F","()","<p>Whether this input method is still readable when there is no more data to read.\n<p>See IO#eof for more information. …\n"],["readable_after_eof?","IRB::StdioInputMethod","IRB/StdioInputMethod.html#method-i-readable_after_eof-3F","()","<p>Whether this input method is still readable when there is no more data to read.\n<p>See IO#eof for more information. …\n"],["readable_real?","File","File.html#method-c-readable_real-3F","(p1)","<p>Returns <code>true</code> if the named file is readable by the real user and group id of this process. See access(3). …\n"],["readable_real?","File::Stat","File/Stat.html#method-i-readable_real-3F","()","<p>Returns <code>true</code> if <em>stat</em> is readable by the real user id of this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">readable_real?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["readable_real?","FileTest","FileTest.html#method-i-readable_real-3F","(p1)","<p>Returns <code>true</code> if the named file is readable by the real user and group id of this process. See access(3). …\n"],["readable_real?","Pathname","Pathname.html#method-i-readable_real-3F","()","<p>See FileTest.readable_real?.\n"],["readagain_bytes","Encoding::InvalidByteSequenceError","Encoding/InvalidByteSequenceError.html#method-i-readagain_bytes","()","<p>Returns the bytes to be read again when Encoding::InvalidByteSequenceError occurs.\n"],["readbyte","ARGF","ARGF.html#method-i-readbyte","()","<p>Reads the next 8-bit byte from ARGF and returns it as an <code>Integer</code>. Raises an <code>EOFError</code> after the last byte …\n"],["readbyte","IO","IO.html#method-i-readbyte","()","<p>Reads a byte as with IO#getbyte, but raises an EOFError on end of file.\n"],["readbyte","IO::generic_readable","IO/generic_readable.html#method-i-readbyte","()","<p>See IO#readbyte.\n"],["readbyte","Zlib::GzipReader","Zlib/GzipReader.html#method-i-readbyte","()","<p>See Zlib::GzipReader documentation for a description.\n"],["readchar","ARGF","ARGF.html#method-i-readchar","()","<p>Reads the next character from <code>ARGF</code> and returns it as a <code>String</code>. Raises an <code>EOFError</code> after the last character …\n"],["readchar","IO","IO.html#method-i-readchar","()","<p>Reads a one-character string from <em>ios</em>. Raises an EOFError on end of file.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>)\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">readchar</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["readchar","IO::generic_readable","IO/generic_readable.html#method-i-readchar","()","<p>See IO#readchar.\n"],["readchar","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-readchar","()","<p>Reads a one-character string from the stream.  Raises an EOFError at end of file.\n"],["readchar","Zlib::GzipReader","Zlib/GzipReader.html#method-i-readchar","()","<p>See Zlib::GzipReader documentation for a description.\n"],["readline","ARGF","ARGF.html#method-i-readline","(*args)","<p>Returns the next line from the current file in <code>ARGF</code>.\n<p>By default lines are assumed to be separated by  …\n"],["readline","Bundler::Thor::LineEditor","Bundler/Thor/LineEditor.html#method-c-readline","(prompt, options = {})",""],["readline","Bundler::Thor::LineEditor::Basic","Bundler/Thor/LineEditor/Basic.html#method-i-readline","()",""],["readline","Bundler::Thor::LineEditor::Readline","Bundler/Thor/LineEditor/Readline.html#method-i-readline","()",""],["readline","CSV","CSV.html#method-i-readline","()",""],["readline","IO","IO.html#method-i-readline","(*args)","<p>Reads a line as with IO#gets, but raises an EOFError on end of file.\n"],["readline","IO::generic_readable","IO/generic_readable.html#method-i-readline","(*args)","<p>See IO#readline.\n"],["readline","IRB::Locale","IRB/Locale.html#method-i-readline","(*rs)",""],["readline","Kernel","Kernel.html#method-i-readline","(*args)","<p>Equivalent to Kernel::gets, except <code>readline</code> raises <code>EOFError</code> at end of file.\n"],["readline","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-readline","(eol=$/)","<p>Reads a line from the stream which is separated by <em>eol</em>.\n<p>Raises EOFError if at end of file.\n"],["readline","REXML::IOSource","REXML/IOSource.html#method-i-readline","()",""],["readline","Readline","Readline.html#method-c-readline","(p1 = v1, p2 = v2)","<p>Shows the <code>prompt</code> and reads the inputted line with line editing. The inputted line is added to the history …\n"],["readline","Reline::Core","Reline/Core.html#method-i-readline","(prompt = '', add_hist = false)",""],["readline","Zlib::GzipReader","Zlib/GzipReader.html#method-i-readline","(*args)","<p>See Zlib::GzipReader documentation for a description.\n"],["readlines","ARGF","ARGF.html#method-i-readlines","(*args)","<p>Reads <code>ARGF</code>&#39;s current file in its entirety, returning an <code>Array</code> of its lines, one line per element. …\n"],["readlines","CSV","CSV.html#method-i-readlines","()",""],["readlines","CSV","CSV.html#method-c-readlines","(path, **options)","<p>Alias for CSV::read().\n"],["readlines","IO","IO.html#method-c-readlines","(p1, p2 = v2, p3 = v3, p4 = v4, p5 = {})","<p>Reads the entire file specified by <em>name</em> as individual lines, and returns those lines in an array. Lines …\n"],["readlines","IO","IO.html#method-i-readlines","(*args)","<p>Reads all of the lines in <em>ios</em>, and returns them in an array. Lines are separated by the optional <em>sep</em> …\n"],["readlines","Kernel","Kernel.html#method-i-readlines","(*args)","<p>Returns an array containing the lines returned by calling <code>Kernel.gets(<em>sep</em>)</code> until the end of file.\n"],["readlines","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-readlines","(eol=$/)","<p>Reads lines from the stream which are separated by <em>eol</em>.\n<p>See also #gets\n"],["readlines","Pathname","Pathname.html#method-i-readlines","(p1 = v1, p2 = v2, p3 = v3)","<p>Returns all the lines from the file.\n<p>See File.readlines.\n"],["readlines","StringIO","StringIO.html#method-i-readlines","(*args)","<p>See IO#readlines.\n"],["readlines","Zlib::GzipReader","Zlib/GzipReader.html#method-i-readlines","(*args)","<p>See Zlib::GzipReader documentation for a description.\n"],["readlink","File","File.html#method-c-readlink","(p1)","<p>Returns the name of the file referenced by the given link. Not available on all platforms.\n\n<pre>File.symlink(&quot;testfile&quot;, ...</pre>\n"],["readlink","Pathname","Pathname.html#method-i-readlink","()","<p>Read symbolic link.\n<p>See File.readlink.\n"],["readmultiline","Reline::Core","Reline/Core.html#method-i-readmultiline","(prompt = '', add_hist = false, &confirm_multiline_termination)",""],["readpartial","ARGF","ARGF.html#method-i-readpartial","(*args)","<p>Reads at most <em>maxlen</em> bytes from the ARGF stream.\n<p>If the optional <em>outbuf</em> argument is present, it must reference …\n"],["readpartial","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-readpartial","(maxlen = nil, outbuf = \"\".b)",""],["readpartial","IO","IO.html#method-i-readpartial","(*args)","<p>Reads at most <em>maxlen</em> bytes from the I/O stream. It blocks only if <em>ios</em> has no data immediately available. …\n"],["readpartial","IO::generic_readable","IO/generic_readable.html#method-i-readpartial","(*args)","<p>Similar to #read, but raises <code>EOFError</code> at end of string instead of returning <code>nil</code>, as well as IO#sysread …\n"],["readpartial","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-readpartial","(maxlen, buf=nil)","<p>Reads at most <em>maxlen</em> bytes from the stream.  If <em>buf</em> is provided it must reference a string which will …\n"],["readpartial","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-readpartial","(size, buf = ''.b)","<p>for IO.copy_stream.  Note: we may return a larger string than <code>size</code> here; but IO.copy_stream does not …\n"],["readpartial","Zlib::GzipReader","Zlib/GzipReader.html#method-i-readpartial","(p1, p2 = v2)","<p>Reads at most <em>maxlen</em> bytes from the gziped stream but it blocks only if <em>gzipreader</em> has no data immediately …\n"],["reads","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-reads","(re)",""],["ready","Net::SMTP","Net/SMTP.html#method-i-ready","(from_addr, *to_addrs)",""],["ready?","IO","IO.html#method-i-ready-3F","()","<p>Returns true if input available without blocking, or false.\n"],["ready_to_enqueue?","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-ready_to_enqueue-3F","()","<p>Only true when spec in neither installed nor already enqueued\n"],["real","Complex","Complex.html#method-i-real","()","<p>Returns the real part.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">real</span>      <span class=\"ruby-comment\">#=&gt; 7</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">9</span>, <span class=\"ruby-value\">-4</span>).<span class=\"ruby-identifier\">real</span>  <span class=\"ruby-comment\">#=&gt; 9</span>\n</pre>\n"],["real","Matrix","Matrix.html#method-i-real","()","<p>Returns the real part of the matrix.\n\n<pre>Matrix[[Complex(1,2), Complex(0,1), 0], [1, 2, 3]]\n  =&gt; 1+2i  i  ...</pre>\n"],["real","Numeric","Numeric.html#method-i-real","()","<p>Returns self.\n"],["real?","Complex","Complex.html#method-i-real-3F","()","<p>Returns false, even if the complex number has no imaginary part.\n"],["real?","Matrix","Matrix.html#method-i-real-3F","()","<p>Returns <code>true</code> if all entries of the matrix are real.\n"],["real?","Numeric","Numeric.html#method-i-real-3F","()","<p>Returns <code>true</code> if <code>num</code> is a real number (i.e. not Complex).\n"],["real_load","IRB::Locale","IRB/Locale.html#method-i-real_load","(path, priv)",""],["realdirpath","File","File.html#method-c-realdirpath","(*args)","<p>Returns the real (absolute) pathname of <em>pathname</em> in the actual filesystem. The real pathname doesn&#39;t …\n"],["realdirpath","Pathname","Pathname.html#method-i-realdirpath","(p1 = v1)","<p>Returns the real (absolute) pathname of <code>self</code> in the actual filesystem.\n<p>Does not contain symlinks or useless …\n"],["realloc","Fiddle","Fiddle.html#method-c-realloc","(p1, p2)","<p>Change the size of the memory allocated at the memory location <code>addr</code> to <code>size</code> bytes.  Returns the memory …\n"],["really_verbose","Gem::ConfigFile","Gem/ConfigFile.html#method-i-really_verbose","()","<p>Really verbose mode gives you extra output.\n"],["realpath","File","File.html#method-c-realpath","(*args)","<p>Returns the real (absolute) pathname of <em>pathname</em> in the actual filesystem not containing symlinks or …\n"],["realpath","Pathname","Pathname.html#method-i-realpath","(p1 = v1)","<p>Returns the real (absolute) pathname for <code>self</code> in the actual filesystem.\n<p>Does not contain symlinks or useless …\n"],["realtime","Benchmark","Benchmark.html#method-c-realtime","()","<p>Returns the elapsed real time used to execute the given block.\n"],["realtime","Benchmark","Benchmark.html#method-i-realtime","()","<p>Returns the elapsed real time used to execute the given block.\n"],["reason","LocalJumpError","LocalJumpError.html#method-i-reason","()","<p>The reason this block was terminated: :break, :redo, :retry, :next, :return, or :noreason.\n"],["reason","OptionParser::ParseError","OptionParser/ParseError.html#method-i-reason","()","<p>Returns error reason. Override this for I18N.\n"],["reason_phrase","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-i-reason_phrase","(code)","<p>Returns the description corresponding to the HTTP status <code>code</code>\n\n<pre>WEBrick::HTTPStatus.reason_phrase 404\n=&gt; ...</pre>\n"],["reason_phrase","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-reason_phrase","(code)","<p>Returns the description corresponding to the HTTP status <code>code</code>\n\n<pre>WEBrick::HTTPStatus.reason_phrase 404\n=&gt; ...</pre>\n"],["reason_phrase","WEBrick::HTTPStatus::Status","WEBrick/HTTPStatus/Status.html#method-i-reason_phrase","()","<p>Returns the HTTP status description\n"],["receive","REXML::Validation::RelaxNG","REXML/Validation/RelaxNG.html#method-i-receive","(event)",""],["receive_responses","Net::IMAP","Net/IMAP.html#method-i-receive_responses","()",""],["receiver","Binding","Binding.html#method-i-receiver","()","<p>Returns the bound receiver of the binding object.\n"],["receiver","FrozenError","FrozenError.html#method-i-receiver","()","<p>Return the receiver associated with this FrozenError exception.\n"],["receiver","KeyError","KeyError.html#method-i-receiver","()","<p>Return the receiver associated with this KeyError exception.\n"],["receiver","Method","Method.html#method-i-receiver","()","<p>Returns the bound receiver of the method object.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:map</span>).<span class=\"ruby-identifier\">receiver</span> <span class=\"ruby-comment\"># =&gt; 1..3</span>\n</pre>\n"],["receiver","NameError","NameError.html#method-i-receiver","()","<p>Return the receiver associated with this NameError exception.\n"],["recipients","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-recipients","()",""],["reconnect","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-reconnect","()","<p>Forces reconnection of HTTP connections.\n"],["reconnect_ssl","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-reconnect_ssl","()","<p>Forces reconnection of SSL connections.\n"],["record_depth","Gem::Resolver::Stats","Gem/Resolver/Stats.html#method-i-record_depth","(stack)",""],["record_entity_expansion","REXML::Document","REXML/Document.html#method-i-record_entity_expansion","()",""],["record_location","RDoc::CodeObject","RDoc/CodeObject.html#method-i-record_location","(top_level)","<p>Records the RDoc::TopLevel (file) where this code object was defined\n"],["record_location","RDoc::Context","RDoc/Context.html#method-i-record_location","(top_level)","<p>Record <code>top_level</code> as a file <code>self</code> is in.\n"],["record_path","Racc::States","Racc/States.html#method-i-record_path","(begst, rule)",""],["record_requirements","Gem::Resolver::Stats","Gem/Resolver/Stats.html#method-i-record_requirements","(reqs)",""],["record_response","Net::IMAP","Net/IMAP.html#method-i-record_response","(name, data)",""],["recover","OptionParser::ParseError","OptionParser/ParseError.html#method-i-recover","(argv)","<p>Pushes back erred argument(s) to <code>argv</code>.\n"],["rect","Complex","Complex.html#method-i-rect","()","<p>Returns an array; [cmp.real, cmp.imag].\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">rectangular</span>  <span class=\"ruby-comment\">#=&gt; [1, 2]</span>\n</pre>\n"],["rect","Complex","Complex.html#method-c-rect","(p1, p2 = v2)","<p>Returns a complex object which denotes the given rectangular form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>.<span class=\"ruby-identifier\">rectangular</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>)  <span class=\"ruby-comment\">#=&gt; (1+2i)</span>\n</pre>\n"],["rect","Matrix","Matrix.html#method-i-rect","()","<p>Returns an array containing matrices corresponding to the real and imaginary parts of the matrix\n<p>m.rect …\n"],["rect","Numeric","Numeric.html#method-i-rect","()","<p>Returns an array; [num, 0].\n"],["rectangular","Complex","Complex.html#method-i-rectangular","()","<p>Returns an array; [cmp.real, cmp.imag].\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">rectangular</span>  <span class=\"ruby-comment\">#=&gt; [1, 2]</span>\n</pre>\n"],["rectangular","Complex","Complex.html#method-c-rectangular","(p1, p2 = v2)","<p>Returns a complex object which denotes the given rectangular form.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>.<span class=\"ruby-identifier\">rectangular</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>)  <span class=\"ruby-comment\">#=&gt; (1+2i)</span>\n</pre>\n"],["rectangular","Matrix","Matrix.html#method-i-rectangular","()",""],["rectangular","Numeric","Numeric.html#method-i-rectangular","()","<p>Returns an array; [num, 0].\n"],["recurse_proc","JSON","JSON.html#method-i-recurse_proc","(result, &proc)","<p>Recursively calls passed <em>Proc</em> if the parsed data structure is an <em>Array</em> or <em>Hash</em>\n"],["recursive_predecessors","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-recursive_predecessors","()","<p>@return [Set&lt;Vertex&gt;] the vertices of {#graph} where `self` is a\n\n<pre>{#descendent?}</pre>\n"],["recursive_predecessors","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-recursive_predecessors","()","<p>@return [Array&lt;Vertex&gt;] the vertices of {#graph} where `self` is a\n\n<pre>{#descendent?}</pre>\n"],["recursive_successors","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-recursive_successors","()","<p>@return [Set&lt;Vertex&gt;] the vertices of {#graph} where `self` is an\n\n<pre>{#ancestor?}</pre>\n"],["recursive_successors","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-recursive_successors","()","<p>@return [Array&lt;Vertex&gt;] the vertices of {#graph} where `self` is an\n\n<pre>{#ancestor?}</pre>\n"],["recv","BasicSocket","BasicSocket.html#method-i-recv","(*args)","<p>Receives a message.\n<p><em>maxlen</em> is the maximum number of bytes to receive.\n<p><em>flags</em> should be a bitwise OR of Socket::MSG_* …\n"],["recv_io","UNIXSocket","UNIXSocket.html#method-i-recv_io","(p1 = v1, p2 = v2)","<p>Example\n\n<pre>UNIXServer.open(&quot;/tmp/sock&quot;) {|serv|\n  UNIXSocket.open(&quot;/tmp/sock&quot;) {|c|\n    s = serv.accept\n ...</pre>\n"],["recv_nonblock","BasicSocket","BasicSocket.html#method-i-recv_nonblock","(len, flag = 0, str = nil, exception: true)","<p>Receives up to <em>maxlen</em> bytes from <code>socket</code> using recvfrom(2) after O_NONBLOCK is set for the underlying …\n"],["recv_response","Net::SMTP","Net/SMTP.html#method-i-recv_response","()",""],["recvfrom","IPSocket","IPSocket.html#method-i-recvfrom","(*args)","<p>Receives a message and return the message as a string and an address which the message come from.\n<p><em>maxlen</em> …\n"],["recvfrom","Socket","Socket.html#method-i-recvfrom","(*args)","<p>Receives up to <em>maxlen</em> bytes from <code>socket</code>. <em>flags</em> is zero or more of the <code>MSG_</code> options. The first element …\n"],["recvfrom","UNIXSocket","UNIXSocket.html#method-i-recvfrom","(*args)","<p>Receives a message via <em>unixsocket</em>.\n<p><em>maxlen</em> is the maximum number of bytes to receive.\n<p><em>flags</em> should be a …\n"],["recvfrom_nonblock","Socket","Socket.html#method-i-recvfrom_nonblock","(len, flag = 0, str = nil, exception: true)","<p>Receives up to <em>maxlen</em> bytes from <code>socket</code> using recvfrom(2) after O_NONBLOCK is set for the underlying …\n"],["recvfrom_nonblock","UDPSocket","UDPSocket.html#method-i-recvfrom_nonblock","(len, flag = 0, outbuf = nil, exception: true)","<p>Receives up to <em>maxlen</em> bytes from <code>udpsocket</code> using recvfrom(2) after O_NONBLOCK is set for the underlying …\n"],["recvmsg","BasicSocket","BasicSocket.html#method-i-recvmsg","(dlen = nil, flags = 0, clen = nil, scm_rights: false)","<p>recvmsg receives a message using recvmsg(2) system call in blocking manner.\n<p><em>maxmesglen</em> is the maximum …\n"],["recvmsg_nonblock","BasicSocket","BasicSocket.html#method-i-recvmsg_nonblock","(dlen = nil, flags = 0, clen = nil, scm_rights: false, exception: true)","<p>recvmsg receives a message using recvmsg(2) system call in non-blocking manner.\n<p>It is similar to BasicSocket#recvmsg …\n"],["redefine_method","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-redefine_method","(klass, method, unbound_method = nil, &block)",""],["redirect?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-i-redirect-3F","(code)","<p>Is <code>code</code> a redirection status?\n"],["redirect?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-redirect-3F","(code)","<p>Is <code>code</code> a redirection status?\n"],["redirect_to_directory_uri","WEBrick::HTTPServlet::AbstractServlet","WEBrick/HTTPServlet/AbstractServlet.html#method-i-redirect_to_directory_uri","(req, res)","<p>Redirects to a path ending in /\n"],["redisplay","Readline","Readline.html#method-c-redisplay","()","<p>Change what&#39;s displayed on the screen to reflect the current contents.\n<p>See GNU Readline&#39;s rl_redisplay …\n"],["reduce","Enumerable","Enumerable.html#method-i-reduce","(p1 = v1, p2 = v2)","<p>Combines all elements of <em>enum</em> by applying a binary operation, specified by a block or a symbol that names …\n"],["reduce","Racc::ActionTable","Racc/ActionTable.html#method-i-reduce","(i)",""],["reduce_n","Racc::ActionTable","Racc/ActionTable.html#method-i-reduce_n","()",""],["reduce_table","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-reduce_table","(grammar)",""],["reduce_to_hessenberg","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-reduce_to_hessenberg","()","<p>Nonsymmetric reduction to Hessenberg form.\n"],["ref","Fiddle::Pointer","Fiddle/Pointer.html#method-i-ref","()","<p>Returns a new Fiddle::Pointer instance that is a reference pointer for this pointer.\n<p>Analogous to the …\n"],["reference","RDoc::Markdown","RDoc/Markdown.html#method-i-reference","(label, link)","<p>Stores <code>label</code> as a reference to <code>link</code> and fills in previously unknown\nlink references.\n"],["refine","Module","Module.html#method-i-refine","(p1)","<p>Refine <em>mod</em> in the receiver.\n<p>Returns a module, where refined methods are defined.\n"],["reformatted_help_args","Bundler::CLI","Bundler/CLI.html#method-c-reformatted_help_args","(args)","<p>Reformat the arguments passed to bundle that include a –help flag into the corresponding `bundle help …\n"],["refresh","Gem","Gem.html#method-c-refresh","()","<p>Refresh available gems from disk.\n"],["refresh_line","Readline","Readline.html#method-c-refresh_line","()","<p>Clear the current input line.\n"],["refute_path_exists","Gem::TestCase","Gem/TestCase.html#method-i-refute_path_exists","(path, msg = nil)","<p>TODO: move to minitest\n"],["regenerate_binstubs","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-regenerate_binstubs","()",""],["regexp","Bundler::URI","Bundler/URI.html#method-c-regexp","(schemes = nil)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">regexp</span>([<span class=\"ruby-identifier\">match_schemes</span>])\n</pre>\n<p>Args\n"],["regexp","MatchData","MatchData.html#method-i-regexp","()","<p>Returns the regexp.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> = <span class=\"ruby-regexp\">/a.*b/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;abc&quot;</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">regexp</span> <span class=\"ruby-comment\">#=&gt; /a.*b/</span>\n</pre>\n"],["regexp","OptionParser::Completion","OptionParser/Completion.html#method-c-regexp","(key, icase)",""],["regexp","URI","URI.html#method-c-regexp","(schemes = nil)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">regexp</span>([<span class=\"ruby-identifier\">match_schemes</span>])\n</pre>\n<p>Args\n"],["regist","DRb::ExtServManager","DRb/ExtServManager.html#method-i-regist","(name, ro)",""],["regist_server","DRb","DRb.html#method-c-regist_server","(server)","<p>Registers <code>server</code> with DRb.\n<p>This is called when a new DRb::DRbServer is created.\n<p>If there is no primary …\n"],["regist_server","DRb","DRb.html#method-i-regist_server","(server)","<p>Registers <code>server</code> with DRb.\n<p>This is called when a new DRb::DRbServer is created.\n<p>If there is no primary …\n"],["register","Bundler::Thor","Bundler/Thor.html#method-c-register","(klass, subcommand_name, usage, description, options = {})","<p>Registers another Bundler::Thor subclass as a command.\n<p>Parameters\n<p>klass&lt;Class&gt; &mdash; Bundler::Thor subclass …\n"],["register","Gem::NoAliasYAMLTree","Gem/NoAliasYAMLTree.html#method-i-register","(target, obj)","<p>Noop this out so there are no anchors\n"],["register","OpenSSL::ASN1::ObjectId","OpenSSL/ASN1/ObjectId.html#method-c-register","(p1, p2, p3)","<p>This adds a new ObjectId to the internal tables. Where <em>object_id</em> is the numerical form, <em>short_name</em> is …\n"],["register","Psych::Streaming","Psych/Streaming.html#method-i-register","(target, obj)",""],["register","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-register","(node, object)",""],["register","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-register","(target, yaml_obj)",""],["register","WEBrick::Utils::TimeoutHandler","WEBrick/Utils/TimeoutHandler.html#method-c-register","(seconds, exception)","<p>Registers a new timeout handler\n<p><code>time</code> &mdash; Timeout in seconds\n<p><code>exception</code> &mdash; Exception to raise when timeout elapsed …\n"],["register_command","Gem::CommandManager","Gem/CommandManager.html#method-i-register_command","(command, obj=false)","<p>Register the Symbol <code>command</code> as a gem command.\n"],["register_default_spec","Gem","Gem.html#method-c-register_default_spec","(spec)","<p>Register a Gem::Specification for default gem.\n<p>Two formats for the specification are supported:\n<p>MRI 2.0 …\n"],["register_empty","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-register_empty","(object)",""],["register_plugin","Bundler::Plugin","Bundler/Plugin.html#method-i-register_plugin","(name, spec, optional_plugin = false)","<p>Runs the plugins.rb file in an isolated namespace, records the plugin actions it registers for and then …\n"],["register_plugin","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-register_plugin","(name, path, load_paths, commands, sources, hooks)","<p>This function is to be called when a new plugin is installed. This function shall add the functions of …\n"],["register_uri","RSS::BaseListener","RSS/BaseListener.html#method-c-register_uri","(uri, name)","<p>register uri against this name.\n"],["registry=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-registry-3D","(v)",""],["registry=","URI::Generic","URI/Generic.html#method-i-registry-3D","(v)",""],["regular?","Matrix","Matrix.html#method-i-regular-3F","()","<p>Returns <code>true</code> if this is a regular (i.e. non-singular) matrix.\n"],["rehash","ENV","ENV.html#method-c-rehash","()","<p>Re-hashing the environment variables does nothing.  It is provided for compatibility with Hash.\n"],["rehash","Hash","Hash.html#method-i-rehash","()","<p>Rebuilds the hash based on the current hash values for each key. If values of key objects have changed …\n"],["reject","Array","Array.html#method-i-reject","()","<p>Returns a new array containing the items in <code>self</code> for which the given block is not <code>true</code>. The ordering …\n"],["reject","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-reject","(&block)",""],["reject","DBM","DBM.html#method-i-reject","()","<p>Converts the contents of the database to an in-memory Hash, then calls Hash#reject with the specified …\n"],["reject","ENV","ENV.html#method-c-reject","()","<p>Same as ENV.delete_if, but works on (and returns) a copy of the environment.\n"],["reject","Enumerable","Enumerable.html#method-i-reject","()","<p>Returns an array for all elements of <code>enum</code> for which the given <code>block</code> returns <code>false</code>.\n<p>If no block is given, …\n"],["reject","Enumerator::Lazy","Enumerator/Lazy.html#method-i-reject","()","<p>Like Enumerable#reject, but chains operation to be lazy-evaluated.\n"],["reject","GDBM","GDBM.html#method-i-reject","()","<p>Returns a hash copy of <em>gdbm</em> where all key-value pairs from <em>gdbm</em> for which <em>block</em> evaluates to true are …\n"],["reject","Hash","Hash.html#method-i-reject","()","<p>Returns a new hash consisting of entries for which the block returns false.\n<p>If no block is given, an enumerator …\n"],["reject","OptionParser","OptionParser.html#method-i-reject","(*args, &blk)","<p>Directs to reject specified class argument.\n<p><code>t</code> &mdash; Argument class specifier, any object including Class.\n\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">reject</span>(<span class=\"ruby-identifier\">t</span>)\n</pre>\n"],["reject","OptionParser","OptionParser.html#method-c-reject","(*args, &blk)","<p>See #reject.\n"],["reject","OptionParser::List","OptionParser/List.html#method-i-reject","(t)","<p>See OptionParser.reject.\n"],["reject","SDBM","SDBM.html#method-i-reject","()","<p>Creates a new Hash using the key-value pairs from the database, then calls Hash#reject with the given …\n"],["reject","YAML::DBM","YAML/DBM.html#method-i-reject","()","<p>Converts the contents of the database to an in-memory Hash, then calls Hash#reject with the specified …\n"],["reject!","Array","Array.html#method-i-reject-21","()","<p>Deletes every element of <code>self</code> for which the block evaluates to <code>true</code>, if no changes were made returns …\n"],["reject!","DBM","DBM.html#method-i-reject-21","()","<p>Deletes all entries for which the code block returns true. Returns self.\n"],["reject!","ENV","ENV.html#method-c-reject-21","()","<p>Similar to ENV.delete_if, but returns <code>nil</code> if no changes were made.\n<p>Deletes each environment variable for …\n"],["reject!","GDBM","GDBM.html#method-i-reject-21","()","<p>Deletes every key-value pair from <em>gdbm</em> for which <em>block</em> evaluates to true.\n"],["reject!","Hash","Hash.html#method-i-reject-21","()","<p>Equivalent to Hash#delete_if, but returns <code>nil</code> if no changes were made.\n"],["reject!","SDBM","SDBM.html#method-i-reject-21","()","<p>Iterates over the key-value pairs in the database, deleting those for which the block returns <code>true</code>.\n"],["reject!","Set","Set.html#method-i-reject-21","(&block)","<p>Equivalent to Set#delete_if, but returns nil if no changes were made. Returns an enumerator if no block …\n"],["relative?","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-relative-3F","()","<p>Returns true if Bundler::URI does not have a scheme (e.g. http:// or https://) specified.\n"],["relative?","Pathname","Pathname.html#method-i-relative-3F","()","<p>The opposite of Pathname#absolute?\n<p>It returns <code>false</code> if the pathname begins with a slash.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> = <span class=\"ruby-constant\">Pathname</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;/im/sure&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["relative?","URI::Generic","URI/Generic.html#method-i-relative-3F","()","<p>Returns true if URI does not have a scheme (e.g. http:// or https://) specified.\n"],["relative_matches","Bundler::Thor::LineEditor::Readline::PathCompletion","Bundler/Thor/LineEditor/Readline/PathCompletion.html#method-i-relative_matches","()",""],["relative_path","Bundler::Source::Path","Bundler/Source/Path.html#method-i-relative_path","(path = self.path)",""],["relative_path_from","Pathname","Pathname.html#method-i-relative_path_from","(base_directory)","<p>Returns a relative path from the given <code>base_directory</code> to the receiver.\n<p>If <code>self</code> is absolute, then <code>base_directory</code> …\n"],["relative_to_original_destination_root","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-relative_to_original_destination_root","(path, remove_dot = true)","<p>Returns the given path relative to the absolute root (ie, root where the script started).\n"],["release","Gem::Version","Gem/Version.html#method-i-release","()","<p>The release for this version (e.g. 1.2.0.a -&gt; 1.2.0). Non-prerelease versions return themselves.\n"],["release","OptionParser","OptionParser.html#method-i-release","()","<p>Release code\n"],["release?","Bundler::BuildMetadata","Bundler/BuildMetadata.html#method-c-release-3F","()","<p>Whether this is an official release build of Bundler.\n"],["relevant_sources_for_vertex","Bundler::Resolver","Bundler/Resolver.html#method-i-relevant_sources_for_vertex","(vertex)",""],["reload","DRb::DRbUnknown","DRb/DRbUnknown.html#method-i-reload","()","<p>Attempt to load the wrapped marshalled object again.\n<p>If the class of the object is now known locally, …\n"],["reload","WEBrick::HTTPAuth::Htdigest","WEBrick/HTTPAuth/Htdigest.html#method-i-reload","()","<p>Reloads passwords from the database\n"],["reload","WEBrick::HTTPAuth::Htgroup","WEBrick/HTTPAuth/Htgroup.html#method-i-reload","()","<p>Reload groups from the database\n"],["reload","WEBrick::HTTPAuth::Htpasswd","WEBrick/HTTPAuth/Htpasswd.html#method-i-reload","()","<p>Reload passwords from the database\n"],["remainder","BigDecimal","BigDecimal.html#method-i-remainder","(p1)","<p>Returns the remainder from dividing by the value.\n<p>x.remainder(y) means x-y*(x/y).truncate\n"],["remainder","Integer","Integer.html#method-i-remainder","(p1)","<p>Returns the remainder after dividing <code>int</code> by <code>numeric</code>.\n<p><code>x.remainder(y)</code> means <code>x-y*(x/y).truncate</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">5</span>.<span class=\"ruby-identifier\">remainder</span>(<span class=\"ruby-value\">3</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["remainder","Numeric","Numeric.html#method-i-remainder","(p1)","<p><code>x.remainder(y)</code> means <code>x-y*(x/y).truncate</code>.\n<p>See Numeric#divmod.\n"],["remembered_flag_deprecation","Bundler::CLI","Bundler/CLI.html#method-i-remembered_flag_deprecation","(name)",""],["remote!","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-remote-21","()","<p>Set internal representation to fetch the gems/specs from remote.\n<p>When this is called, the source should …\n"],["remote!","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-remote-21","()",""],["remote!","Bundler::Source::Path","Bundler/Source/Path.html#method-i-remote-21","()",""],["remote!","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-remote-21","()",""],["remote!","Bundler::SourceList","Bundler/SourceList.html#method-i-remote-21","()",""],["remote=","Gem::Resolver::ComposedSet","Gem/Resolver/ComposedSet.html#method-i-remote-3D","(remote)","<p>Sets the remote network access for all composed sets.\n"],["remote?","Gem::LocalRemoteOptions","Gem/LocalRemoteOptions.html#method-i-remote-3F","()","<p>Is remote fetching enabled?\n"],["remote_address","BasicSocket","BasicSocket.html#method-i-remote_address","()","<p>Returns an Addrinfo object for remote address obtained by getpeername.\n<p>Note that addrinfo.protocol is …\n"],["remote_ip","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-remote_ip","()","<p>The client&#39;s IP address\n"],["remote_specs","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-remote_specs","()",""],["remote_uri","Bundler::Fetcher","Bundler/Fetcher.html#method-i-remote_uri","()",""],["remote_uri","Bundler::Fetcher::Base","Bundler/Fetcher/Base.html#method-i-remote_uri","()",""],["remotes_for_spec","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-remotes_for_spec","(spec)",""],["remove","Bundler::CLI","Bundler/CLI.html#method-i-remove","(*gems)",""],["remove","Bundler::FileUtils","Bundler/FileUtils.html#method-c-remove","(list, force: nil, noop: nil, verbose: nil)",""],["remove","Bundler::FileUtils","Bundler/FileUtils.html#method-i-remove","(list, force: nil, noop: nil, verbose: nil)",""],["remove","Bundler::Injector","Bundler/Injector.html#method-c-remove","(gems, options = {})",""],["remove","Bundler::Injector","Bundler/Injector.html#method-i-remove","(gemfile_path, lockfile_path)","<p>@param [Pathname] gemfile_path The Gemfile from which to remove dependencies. @param [Pathname] lockfile_path …\n"],["remove","FileUtils","FileUtils.html#method-c-remove","(list, force: nil, noop: nil, verbose: nil)",""],["remove","FileUtils","FileUtils.html#method-i-remove","(list, force: nil, noop: nil, verbose: nil)",""],["remove","Gem::Resolver::RequirementList","Gem/Resolver/RequirementList.html#method-i-remove","()","<p>Remove the oldest DependencyRequest from the list.\n"],["remove","Gem::Uninstaller","Gem/Uninstaller.html#method-i-remove","(spec)","<p>spec &mdash; the spec of the gem to be uninstalled\n<p>list &mdash; the list of all such gems\n\n<p>Warning: this method modifies …\n"],["remove","OptionParser","OptionParser.html#method-i-remove","()","<p>Removes the last List.\n"],["remove","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-remove","()","<p>Removes generated RDoc and ri data\n"],["remove","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-remove","()","<p>Removes generated RDoc and ri data\n"],["remove","REXML::Attribute","REXML/Attribute.html#method-i-remove","()","<p>Removes this Attribute from the tree, and returns true if successful\n<p>This method is usually not called …\n"],["remove","REXML::Child","REXML/Child.html#method-i-remove","()","<p>Removes this child from the parent.\n<p>Returns &mdash; self\n\n"],["remove_all","Gem::Uninstaller","Gem/Uninstaller.html#method-i-remove_all","(list)","<p>Removes all gems in <code>list</code>.\n<p>NOTE: removes uninstalled gems from <code>list</code>.\n"],["remove_argument","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-remove_argument","(*names)","<p>Removes a previous defined argument. If :undefine is given, undefine accessors as well.\n<p>Parameters\n<p>names&lt;Array&gt; … &mdash; "],["remove_auth","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-remove_auth","(remote)",""],["remove_auth","Bundler::Source::Rubygems::Remote","Bundler/Source/Rubygems/Remote.html#method-i-remove_auth","(uri)",""],["remove_blank_lines","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-remove_blank_lines","(src)",""],["remove_by_name","Gem::DependencyList","Gem/DependencyList.html#method-i-remove_by_name","(full_name)","<p>Removes the gemspec matching <code>full_name</code> from the dependency list\n"],["remove_cache","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-remove_cache","()",""],["remove_class_option","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-remove_class_option","(*names)","<p>Removes a previous defined class option.\n<p>Parameters\n<p>names&lt;Array&gt; &mdash; Class options to be removed\n"],["remove_class_variable","Module","Module.html#method-i-remove_class_variable","(p1)","<p>Removes the definition of the <em>sym</em>, returning that constant&#39;s value.\n\n<pre>class Dummy\n  @@var = 99\n  puts ...</pre>\n"],["remove_coding_comment","RDoc::Parser::Simple","RDoc/Parser/Simple.html#method-i-remove_coding_comment","(text)","<p>Removes the encoding magic comment from <code>text</code>\n"],["remove_command","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-remove_command","(*names)","<p>Removes a given command from this Bundler::Thor class. This is usually done if you are inheriting from …\n"],["remove_commented_out_lines","RDoc::Parser::C","RDoc/Parser/C.html#method-i-remove_commented_out_lines","()","<p>Removes lines that are commented out that might otherwise get picked up when scanning for classes and …\n"],["remove_const","Module","Module.html#method-i-remove_const","(p1)","<p>Removes the definition of the given constant, returning that constant&#39;s previous value.  If that …\n"],["remove_deps","Bundler::Injector","Bundler/Injector.html#method-i-remove_deps","(gemfile_path)","<p>evaluates a gemfile to remove the specified gem from it.\n"],["remove_dir","Bundler::FileUtils","Bundler/FileUtils.html#method-c-remove_dir","(path, force = false)","<p>Removes a directory <code>dir</code> and its contents recursively. This method ignores StandardError if <code>force</code> is true. …\n"],["remove_dir","Bundler::FileUtils","Bundler/FileUtils.html#method-i-remove_dir","(path, force = false)","<p>Removes a directory <code>dir</code> and its contents recursively. This method ignores StandardError if <code>force</code> is true. …\n"],["remove_dir","Bundler::Runtime","Bundler/Runtime.html#method-i-remove_dir","(dir, dry_run)",""],["remove_dir","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-remove_dir","(path, config = {})",""],["remove_dir","FileUtils","FileUtils.html#method-c-remove_dir","(path, force = false)","<p>Removes a directory <code>dir</code> and its contents recursively. This method ignores StandardError if <code>force</code> is true. …\n"],["remove_dir","FileUtils","FileUtils.html#method-i-remove_dir","(path, force = false)","<p>Removes a directory <code>dir</code> and its contents recursively. This method ignores StandardError if <code>force</code> is true. …\n"],["remove_entry","Bundler::FileUtils","Bundler/FileUtils.html#method-i-remove_entry","(path, force = false)","<p>This method removes a file system entry <code>path</code>. <code>path</code> might be a regular file, a directory, or something. …\n"],["remove_entry","Bundler::FileUtils","Bundler/FileUtils.html#method-c-remove_entry","(path, force = false)","<p>This method removes a file system entry <code>path</code>. <code>path</code> might be a regular file, a directory, or something. …\n"],["remove_entry","FileUtils","FileUtils.html#method-c-remove_entry","(path, force = false)","<p>This method removes a file system entry <code>path</code>. <code>path</code> might be a regular file, a directory, or something. …\n"],["remove_entry","FileUtils","FileUtils.html#method-i-remove_entry","(path, force = false)","<p>This method removes a file system entry <code>path</code>. <code>path</code> might be a regular file, a directory, or something. …\n"],["remove_entry_secure","Bundler::FileUtils","Bundler/FileUtils.html#method-i-remove_entry_secure","(path, force = false)","<p>This method removes a file system entry <code>path</code>.  <code>path</code> shall be a regular file, a directory, or something. …\n"],["remove_entry_secure","Bundler::FileUtils","Bundler/FileUtils.html#method-c-remove_entry_secure","(path, force = false)","<p>This method removes a file system entry <code>path</code>.  <code>path</code> shall be a regular file, a directory, or something. …\n"],["remove_entry_secure","FileUtils","FileUtils.html#method-c-remove_entry_secure","(path, force = false)","<p>This method removes a file system entry <code>path</code>.  <code>path</code> shall be a regular file, a directory, or something. …\n"],["remove_entry_secure","FileUtils","FileUtils.html#method-i-remove_entry_secure","(path, force = false)","<p>This method removes a file system entry <code>path</code>.  <code>path</code> shall be a regular file, a directory, or something. …\n"],["remove_executables","Gem::Uninstaller","Gem/Uninstaller.html#method-i-remove_executables","(spec)","<p>Removes installed executables and batch files (windows only) for <code>gemspec</code>.\n"],["remove_file","Bundler::FileUtils","Bundler/FileUtils.html#method-c-remove_file","(path, force = false)","<p>Removes a file <code>path</code>. This method ignores StandardError if <code>force</code> is true.\n"],["remove_file","Bundler::FileUtils","Bundler/FileUtils.html#method-i-remove_file","(path, force = false)","<p>Removes a file <code>path</code>. This method ignores StandardError if <code>force</code> is true.\n"],["remove_file","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-remove_file","(path, config = {})","<p>Removes a file at the given location.\n<p>Parameters\n<p>path&lt;String&gt; &mdash; path of the file to be changed\n"],["remove_file","FileUtils","FileUtils.html#method-i-remove_file","(path, force = false)","<p>Removes a file <code>path</code>. This method ignores StandardError if <code>force</code> is true.\n"],["remove_file","FileUtils","FileUtils.html#method-c-remove_file","(path, force = false)","<p>Removes a file <code>path</code>. This method ignores StandardError if <code>force</code> is true.\n"],["remove_from_documentation?","RDoc::Context","RDoc/Context.html#method-i-remove_from_documentation-3F","()","<p>Should we remove this context from the documentation?\n<p>The answer is yes if:\n<p>#received_nodoc is <code>true</code>\n"],["remove_frozen_string_literal","RDoc::Encoding","RDoc/Encoding.html#method-c-remove_frozen_string_literal","(string)",""],["remove_gems_from_dependencies","Bundler::Injector","Bundler/Injector.html#method-i-remove_gems_from_dependencies","(builder, gems, gemfile_path)","<p>@param [Dsl]      builder Dsl object of current Gemfile. @param [Array]    gems Array of names of gems …\n"],["remove_gems_from_gemfile","Bundler::Injector","Bundler/Injector.html#method-i-remove_gems_from_gemfile","(gems, gemfile_path)","<p>@param [Array] gems            Array of names of gems to be removed. @param [Pathname] gemfile_path  …\n"],["remove_handler","WEBrick::HTTPServlet::FileHandler","WEBrick/HTTPServlet/FileHandler.html#method-c-remove_handler","(suffix)","<p>Remove custom handling of requests for files with <code>suffix</code>\n"],["remove_installed!","Gem::AvailableSet","Gem/AvailableSet.html#method-i-remove_installed-21","(dep)",""],["remove_instance_variable","Object","Object.html#method-i-remove_instance_variable","(p1)","<p>Removes the named instance variable from <em>obj</em>, returning that variable&#39;s value. String arguments are …\n"],["remove_invisible","RDoc::Context","RDoc/Context.html#method-i-remove_invisible","(min_visibility)","<p>Removes methods and attributes with a visibility less than <code>min_visibility</code>.\n"],["remove_invocation","Bundler::Thor::Group","Bundler/Thor/Group.html#method-c-remove_invocation","(*names)","<p>Remove a previously added invocation.\n<p>Examples\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">remove_invocation</span> <span class=\"ruby-value\">:test_framework</span>\n</pre>\n"],["remove_magic_comment","RDoc::Encoding","RDoc/Encoding.html#method-c-remove_magic_comment","(string)","<p>Removes magic comments and shebang\n"],["remove_method","Module","Module.html#method-i-remove_method","(*args)","<p>Removes the method identified by <em>symbol</em> from the current class. For an example, see Module#undef_method …\n"],["remove_modeline","RDoc::Parser","RDoc/Parser.html#method-c-remove_modeline","(content)","<p>Removes an emacs-style modeline from the first line of the document\n"],["remove_nested_blocks","Bundler::Injector","Bundler/Injector.html#method-i-remove_nested_blocks","(gemfile, block_name)","<p>@param [Array] gemfile       Array of gemfile contents. @param [String] block_name   Name of block name …\n"],["remove_nodoc","RDoc::Store","RDoc/Store.html#method-i-remove_nodoc","(all_hash)","<p>Removes from <code>all_hash</code> the contexts that are nodoc or have no content.\n<p>See RDoc::Context#remove_from_documentation? …\n"],["remove_nodoc_children","RDoc::ClassModule","RDoc/ClassModule.html#method-i-remove_nodoc_children","()","<p>Updates the child modules or classes of class/module <code>parent</code> by deleting the ones that have been removed …\n"],["remove_old_bin_files","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-remove_old_bin_files","(bin_dir)",""],["remove_old_lib_files","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-remove_old_lib_files","(lib_dir)",""],["remove_option","Gem::Command","Gem/Command.html#method-i-remove_option","(name)","<p>Remove previously defined command-line argument <code>name</code>.\n"],["remove_owners","Gem::Commands::OwnerCommand","Gem/Commands/OwnerCommand.html#method-i-remove_owners","(name, owners)",""],["remove_platform","Bundler::Definition","Bundler/Definition.html#method-i-remove_platform","(platform)",""],["remove_private","RDoc::Comment","RDoc/Comment.html#method-i-remove_private","()","<p>Removes private sections from this comment.  Private sections are flush to the comment marker and start …\n"],["remove_private_comment","RDoc::Parser::Simple","RDoc/Parser/Simple.html#method-i-remove_private_comment","(comment)","<p>Removes private comments.\n<p>Unlike RDoc::Comment#remove_private this implementation only looks for two dashes …\n"],["remove_response_handler","Net::IMAP","Net/IMAP.html#method-i-remove_response_handler","(handler)","<p>Removes the response handler.\n"],["remove_server","DRb","DRb.html#method-i-remove_server","(server)","<p>Removes <code>server</code> from the list of registered servers.\n"],["remove_server","DRb","DRb.html#method-c-remove_server","(server)","<p>Removes <code>server</code> from the list of registered servers.\n"],["remove_siginfo_handler","RDoc::RDoc","RDoc/RDoc.html#method-i-remove_siginfo_handler","()","<p>Removes a siginfo handler and replaces the previous\n"],["remove_specs_unsatisfied_by","Gem::DependencyList","Gem/DependencyList.html#method-i-remove_specs_unsatisfied_by","(dependencies)","<p>Remove everything in the DependencyList that matches but doesn&#39;t satisfy items in <code>dependencies</code> (a …\n"],["remove_stress_to_class","GC","GC.html#method-c-remove_stress_to_class","(*args)","<p>No longer raises NoMemoryError when allocating an instance of the given classes.\n"],["remove_task","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-remove_task","(*names)",""],["remove_token_listener","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-remove_token_listener","(obj)","<p>Removes the token listener <code>obj</code>\n"],["remove_unparseable","RDoc::RDoc","RDoc/RDoc.html#method-i-remove_unparseable","(files)","<p>Removes file extensions known to be unparseable from <code>files</code> and TAGS files for emacs and vim.\n"],["removed_method_calls","Gem::Specification","Gem/Specification.html#method-i-removed_method_calls","()",""],["removed_specs","Bundler::Definition","Bundler/Definition.html#method-i-removed_specs","()",""],["renamable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-renamable-3F","()","<p>Returns <code>true</code> if the file or directory may be renamed by RNFR.\n"],["rename","File","File.html#method-c-rename","(p1, p2)","<p>Renames the given file to the new name. Raises a SystemCallError if the file cannot be renamed.\n\n<pre>File.rename(&quot;afile&quot;, ...</pre>\n"],["rename","Net::FTP","Net/FTP.html#method-i-rename","(fromname, toname)","<p>Renames a file on the server.\n"],["rename","Net::IMAP","Net/IMAP.html#method-i-rename","(mailbox, newname)","<p>Sends a RENAME command to change the name of the <code>mailbox</code> to <code>newname</code>.\n<p>A Net::IMAP::NoResponseError is raised …\n"],["rename","Pathname","Pathname.html#method-i-rename","(p1)","<p>Rename the file.\n<p>See File.rename.\n"],["render_frame","IRB::RubyModel","IRB/RubyModel.html#method-i-render_frame","(i)",""],["renew","Rinda::SimpleRenewer","Rinda/SimpleRenewer.html#method-i-renew","()","<p>Called by the TupleSpace to check if the object is still alive.\n"],["renew","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-renew","(sec_or_renewer)","<p>Reset the expiry time according to <code>sec_or_renewer</code>.\n<p><code>nil</code> &mdash; it is set to expire in the far future.\n<p><code>true</code> &mdash; it has …\n"],["reopen","IO","IO.html#method-i-reopen","(p1, p2 = v2, p3 = {})","<p>Reassociates <em>ios</em> with the I/O stream given in <em>other_IO</em> or to a new stream opened on <em>path</em>. This may dynamically …\n"],["reopen","Logger","Logger.html#method-i-reopen","(logdev = nil)","<p>Args\n<p><code>logdev</code> &mdash; The log device.  This is a filename (String) or IO object (typically <code>STDOUT</code>, <code>STDERR</code>, or an …\n\n"],["reopen","StringIO","StringIO.html#method-i-reopen","(*args)","<p>Reinitializes the stream with the given <em>other_StrIO</em> or <em>string</em> and <em>mode</em> (see StringIO#new).\n"],["reopen","Syslog","Syslog.html#method-c-reopen","(*args)","<p>Closes and then reopens the syslog.\n<p>Arguments are the same as for open().\n"],["reorganize","GDBM","GDBM.html#method-i-reorganize","()","<p>Reorganizes the database file. This operation removes reserved space of elements that have already been …\n"],["repeated_combination","Array","Array.html#method-i-repeated_combination","(p1)","<p>When invoked with a block, yields all repeated combinations of length <code>n</code> of elements from the array and …\n"],["repeated_permutation","Array","Array.html#method-i-repeated_permutation","(p1)","<p>When invoked with a block, yield all repeated permutations of length <code>n</code> of the elements of the array, …\n"],["replace","Array","Array.html#method-i-replace","(p1)","<p>Replaces the contents of <code>self</code> with the contents of <code>other_ary</code>, truncating or expanding if necessary.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["replace","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-replace","(other)","<p>When replacing with another hash, the initial order of our keys must come from the other hash -ordered …\n"],["replace","DBM","DBM.html#method-i-replace","(p1)","<p>Replaces the contents of the database with the contents of the specified object. Takes any object which …\n"],["replace","ENV","ENV.html#method-c-replace","(p1)","<p>Replaces the entire content of the environment variables with the name/value pairs in the given <code>hash</code> …\n"],["replace","GDBM","GDBM.html#method-i-replace","(p1)","<p>Replaces the content of <em>gdbm</em> with the key-value pairs of <em>other</em>. <em>other</em> must have an each_pair method. …\n"],["replace","Gem::SourceList","Gem/SourceList.html#method-i-replace","(other)","<p>Replaces this SourceList with the sources in <code>other</code>  See #<< for acceptable items in <code>other</code>.\n"],["replace","Hash","Hash.html#method-i-replace","(p1)","<p>Replaces the contents of <em>hsh</em> with the contents of <em>other_hash</em>.\n\n<pre>h = { &quot;a&quot; =&gt; 100, &quot;b&quot; =&gt; 200 }\nh.replace({ ...</pre>\n"],["replace","Racc::Rule","Racc/Rule.html#method-i-replace","(src, dest)",""],["replace","SDBM","SDBM.html#method-i-replace","(p1)","<p>Empties the database, then inserts the given key-value pairs.\n<p>This method will work with any object which …\n"],["replace","Set","Set.html#method-i-replace","(enum)","<p>Replaces the contents of the set with the contents of the given enumerable object and returns self.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">set</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["replace","String","String.html#method-i-replace","(p1)","<p>Replaces the contents of <em>str</em> with the corresponding values in <em>other_str</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">s</span> = <span class=\"ruby-string\">&quot;hello&quot;</span>         <span class=\"ruby-comment\">#=&gt; &quot;hello&quot; ...</span>\n</pre>\n"],["replace","YAML::DBM","YAML/DBM.html#method-i-replace","( hsh )","<p>Replaces the contents of the database with the contents of the specified object. Takes any object which …\n"],["replace!","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-replace-21","(oth)","<p>Replaces self by other Bundler::URI object.\n"],["replace!","URI::Generic","URI/Generic.html#method-i-replace-21","(oth)","<p>Replaces self by other URI object.\n"],["replace_bin_path","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-replace_bin_path","(specs_by_name)","<p>Used to make bin stubs that are not created by bundler work under bundler. The new Gem.bin_path only …\n"],["replace_child","REXML::Parent","REXML/Parent.html#method-i-replace_child","( to_replace, replacement )","<p>Replaces one child with another, making sure the nodelist is correct @param to_replace the child to replace …\n"],["replace_entrypoints","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-replace_entrypoints","(specs)","<p>Replace or hook into RubyGems to provide a bundlerized view of the world.\n"],["replace_gem","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-replace_gem","(specs, specs_by_name)",""],["replace_location","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-replace_location","(src)",""],["replace_remotes","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-replace_remotes","(other_remotes, allow_equivalent = false)",""],["replace_sources!","Bundler::SourceList","Bundler/SourceList.html#method-i-replace_sources-21","(replacement_sources)","<p>Returns true if there are changes\n"],["replace_with","REXML::Child","REXML/Child.html#method-i-replace_with","( child )","<p>Replaces this object with another object.  Basically, calls Parent.replace_child\n<p>Returns &mdash; self\n\n"],["replacement","Encoding::Converter","Encoding/Converter.html#method-i-replacement","()","<p>Returns the replacement string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ec</span> = <span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Converter</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;euc-jp&quot;</span>, <span class=\"ruby-string\">&quot;us-ascii&quot;</span>)\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-identifier\">ec</span>.<span class=\"ruby-identifier\">replacement</span>   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["replacement=","Encoding::Converter","Encoding/Converter.html#method-i-replacement-3D","(p1)","<p>Sets the replacement string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">ec</span> = <span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Converter</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;utf-8&quot;</span>, <span class=\"ruby-string\">&quot;us-ascii&quot;</span>, <span class=\"ruby-value\">:undef</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">:replace</span>)\n<span class=\"ruby-identifier\">ec</span>.<span class=\"ruby-identifier\">replacement</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["replicate","Encoding","Encoding.html#method-i-replicate","(p1)","<p>Returns a replicated encoding of <em>enc</em> whose name is <em>name</em>. The new encoding should have the same byte structure …\n"],["replies?","Bundler::Settings::TCPSocketProbe","Bundler/Settings/TCPSocketProbe.html#method-i-replies-3F","(mirror)",""],["reply","Socket::UDPSource","Socket/UDPSource.html#method-i-reply","(msg)","<p>Sends the String <code>msg</code> to the source\n"],["reply_service","Rinda::RingServer","Rinda/RingServer.html#method-i-reply_service","()","<p>Creates a thread that notifies waiting clients from the TupleSpace.\n"],["report","Bundler::Env","Bundler/Env.html#method-c-report","(options = {})",""],["report","GC::Profiler","GC/Profiler.html#method-c-report","(*args)","<p>Writes the GC::Profiler.result to <code>$stdout</code> or the given IO object.\n"],["report","RDoc::Stats","RDoc/Stats.html#method-i-report","()","<p>Returns a report on which items are not documented\n"],["report_attributes","RDoc::Stats","RDoc/Stats.html#method-i-report_attributes","(cm)","<p>Returns a report on undocumented attributes in ClassModule <code>cm</code>\n"],["report_class_module","RDoc::Stats","RDoc/Stats.html#method-i-report_class_module","(cm)","<p>Returns a report on undocumented items in ClassModule <code>cm</code>\n"],["report_constants","RDoc::Stats","RDoc/Stats.html#method-i-report_constants","(cm)","<p>Returns a report on undocumented constants in ClassModule <code>cm</code>\n"],["report_methods","RDoc::Stats","RDoc/Stats.html#method-i-report_methods","(cm)","<p>Returns a report on undocumented methods in ClassModule <code>cm</code>\n"],["report_on_exception","Thread","Thread.html#method-i-report_on_exception","()","<p>Returns the status of the thread-local “report on exception&#39;&#39; condition for this <code>thr</code>.\n<p>The default …\n"],["report_on_exception","Thread","Thread.html#method-c-report_on_exception","()","<p>Returns the status of the global “report on exception&#39;&#39; condition.\n<p>The default is <code>true</code> since …\n"],["report_on_exception=","Thread","Thread.html#method-i-report_on_exception-3D","(p1)","<p>When set to <code>true</code>, a message is printed on $stderr if an exception kills this <code>thr</code>.  See ::report_on_exception …\n"],["report_on_exception=","Thread","Thread.html#method-c-report_on_exception-3D","(p1)","<p>Returns the new state. When set to <code>true</code>, all threads created afterwards will inherit the condition and …\n"],["repository_subdirectories","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-repository_subdirectories","()",""],["represent_map","Psych::Coder","Psych/Coder.html#method-i-represent_map","(tag, map)","<p>Emit a sequence with <code>map</code> and <code>tag</code>\n"],["represent_object","Psych::Coder","Psych/Coder.html#method-i-represent_object","(tag, obj)","<p>Emit an arbitrary object <code>obj</code> and <code>tag</code>\n"],["represent_scalar","Psych::Coder","Psych/Coder.html#method-i-represent_scalar","(tag, value)","<p>Emit a scalar with <code>value</code> and <code>tag</code>\n"],["represent_seq","Psych::Coder","Psych/Coder.html#method-i-represent_seq","(tag, list)","<p>Emit a sequence with <code>list</code> and <code>tag</code>\n"],["request","Bundler::Fetcher::Downloader","Bundler/Fetcher/Downloader.html#method-i-request","(uri, headers)",""],["request","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-request","(uri, req = nil, &block)","<p>Makes a request on <code>uri</code>.  If <code>req</code> is nil a Net::HTTP::Get is performed against <code>uri</code>.\n<p>If a block is passed …\n"],["request","Gem::FakeFetcher","Gem/FakeFetcher.html#method-i-request","(uri, request_class, last_modified = nil)",""],["request","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-request","(uri, request_class, last_modified = nil)","<p>Performs a Net::HTTP request of type <code>request_class</code> on <code>uri</code> returning a Net::HTTP response object.  request …\n"],["request","Net::HTTP","Net/HTTP.html#method-i-request","(req, body = nil)","<p>Sends an HTTPRequest object <code>req</code> to the HTTP server.\n<p>If <code>req</code> is a Net::HTTP::Post or Net::HTTP::Put request …\n"],["request_body_permitted?","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-request_body_permitted-3F","()",""],["request_context","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-request_context","()","<p>Return a String indicating who caused this request to be added (only valid for implicit requests)\n"],["request_get","Net::HTTP","Net/HTTP.html#method-i-request_get","(path, initheader = nil)","<p>Sends a GET request to the <code>path</code>. Returns the response as a Net::HTTPResponse object.\n<p>When called with …\n"],["request_head","Net::HTTP","Net/HTTP.html#method-i-request_head","(path, initheader = nil, &block)","<p>Sends a HEAD request to the <code>path</code> and returns the response as a Net::HTTPResponse object.\n<p>Returns the response. …\n"],["request_issue_report_for","Bundler::FriendlyErrors","Bundler/FriendlyErrors.html#method-i-request_issue_report_for","(e)",""],["request_path","Gem::Resolver::Conflict","Gem/Resolver/Conflict.html#method-i-request_path","(current)","<p>Path of activations from the <code>current</code> list.\n"],["request_post","Net::HTTP","Net/HTTP.html#method-i-request_post","(path, data, initheader = nil)","<p>Sends a POST request to the <code>path</code>.\n<p>Returns the response as a Net::HTTPResponse object.\n<p>When called with …\n"],["request_uri","Bundler::URI::HTTP","Bundler/URI/HTTP.html#method-i-request_uri","()","<p>Description\n<p>Returns the full path for an HTTP request, as required by Net::HTTP::Get.\n<p>If the Bundler::URI …\n"],["request_uri","URI::HTTP","URI/HTTP.html#method-i-request_uri","()","<p>Description\n<p>Returns the full path for an HTTP request, as required by Net::HTTP::Get.\n<p>If the URI contains …\n"],["requested_dependencies","Bundler::Definition","Bundler/Definition.html#method-i-requested_dependencies","()",""],["requested_groups","Bundler::Definition","Bundler/Definition.html#method-i-requested_groups","()",""],["requested_specs","Bundler::Definition","Bundler/Definition.html#method-i-requested_specs","()",""],["requested_specs","Bundler::Gemdeps","Bundler/Gemdeps.html#method-i-requested_specs","()",""],["requester","Gem::Resolver::Conflict","Gem/Resolver/Conflict.html#method-i-requester","()","<p>Return the Specification that listed the dependency\n"],["requests","Gem::RequestSet::Lockfile","Gem/RequestSet/Lockfile.html#method-i-requests","()",""],["require","Bundler","Bundler.html#method-c-require","(*groups)","<p>Setups Bundler environment (see Bundler.setup) if it is not already set, and loads all gems from groups …\n"],["require","Bundler::Runtime","Bundler/Runtime.html#method-i-require","(*groups)",""],["require","IRB::Locale","IRB/Locale.html#method-i-require","(file, priv = nil)",""],["require","Kernel","Kernel.html#method-i-require","(path)","<p>When RubyGems is required, Kernel#require is replaced with our own which is capable of loading gems on …\n"],["require","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-require","(feature)",""],["require_io_console","Gem::StreamUI","Gem/StreamUI.html#method-i-require_io_console","()",""],["require_nested_dependencies_for","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-require_nested_dependencies_for","(possibility_set)","<p>Requires the dependencies that the recently activated spec has @param [Object] activated_possibility …\n"],["require_nested_dependencies_for","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-require_nested_dependencies_for","(activated_spec)","<p>Requires the dependencies that the recently activated spec has @param [Object] activated_spec the specification …\n"],["require_path","Gem::Specification","Gem/Specification.html#method-i-require_path","()","<p>Singular accessor for #require_paths\n"],["require_path=","Gem::Specification","Gem/Specification.html#method-i-require_path-3D","(path)","<p>Singular accessor for #require_paths\n"],["require_path_or_force","Bundler::CLI::Clean","Bundler/CLI/Clean.html#method-i-require_path_or_force","()",""],["require_paths","Bundler::EndpointSpecification","Bundler/EndpointSpecification.html#method-i-require_paths","()","<p>needed for standalone, load required_paths from local gemspec after the gem is installed\n"],["require_paths","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-require_paths","()","<p>Paths in the gem to add to <code>$LOAD_PATH</code> when this gem is activated.\n<p>See also #require_paths=\n<p>If you have …\n"],["require_paths=","Gem::Specification","Gem/Specification.html#method-i-require_paths-3D","(val)","<p>Paths in the gem to add to <code>$LOAD_PATH</code> when this gem is activated. If you have an extension you do not …\n"],["require_relative","Kernel","Kernel.html#method-i-require_relative","(p1)","<p>Ruby tries to load the library named <em>string</em> relative to the requiring file&#39;s path.  If the file&#39;s …\n"],["require_thor_actions","Bundler","Bundler.html#method-c-require_thor_actions","()",""],["require_tree_for_spec","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-require_tree_for_spec","(spec)",""],["required_arguments_for","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-required_arguments_for","(klass, usage)","<p>Add usage with required arguments\n"],["required_arguments_for","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-required_arguments_for","(klass, usage)","<p>Add usage with required arguments\n"],["required_attribute?","Gem::Specification","Gem/Specification.html#method-c-required_attribute-3F","(name)","<p>Is <code>name</code> a required attribute?\n"],["required_attributes","Gem::Specification","Gem/Specification.html#method-c-required_attributes","()","<p>Required specification attributes\n"],["required_element?","RSS::Maker::RSS09::Image","RSS/Maker/RSS09/Image.html#method-i-required_element-3F","()",""],["required_element?","RSS::Maker::RSS20::Image","RSS/Maker/RSS20/Image.html#method-i-required_element-3F","()",""],["required_options","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-required_options","()",""],["required_options","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-required_options","()",""],["required_prefix","RSS::Element","RSS/Element.html#method-c-required_prefix","()",""],["required_prefix","RSS::ITunesChannelModel::ITunesCategory","RSS/ITunesChannelModel/ITunesCategory.html#method-c-required_prefix","()",""],["required_prefix","RSS::ITunesChannelModel::ITunesImage","RSS/ITunesChannelModel/ITunesImage.html#method-c-required_prefix","()",""],["required_prefix","RSS::ITunesChannelModel::ITunesOwner","RSS/ITunesChannelModel/ITunesOwner.html#method-c-required_prefix","()",""],["required_prefix","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-c-required_prefix","()",""],["required_prefix","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-c-required_prefix","()",""],["required_prefix","RSS::ImageItemModel::ImageItem","RSS/ImageItemModel/ImageItem.html#method-c-required_prefix","()",""],["required_prefix","RSS::TaxonomyTopicModel::TaxonomyTopic","RSS/TaxonomyTopicModel/TaxonomyTopic.html#method-c-required_prefix","()",""],["required_prefix","RSS::TaxonomyTopicsModel::TaxonomyTopics","RSS/TaxonomyTopicsModel/TaxonomyTopics.html#method-c-required_prefix","()",""],["required_ruby_version=","Gem::Specification","Gem/Specification.html#method-i-required_ruby_version-3D","(req)","<p>The version of Ruby required by this gem.  The ruby version can be specified to the patch-level:\n\n<pre>$ ruby ...</pre>\n"],["required_rubygems_version=","Gem::Specification","Gem/Specification.html#method-i-required_rubygems_version-3D","(req)","<p>The RubyGems version required by this gem\n"],["required_uri","RSS::Atom::CommonModel","RSS/Atom/CommonModel.html#method-c-required_uri","()","<p>Returns the Atom URI W3C Namespace\n"],["required_uri","RSS::Element","RSS/Element.html#method-c-required_uri","()",""],["required_uri","RSS::ITunesChannelModel::ITunesCategory","RSS/ITunesChannelModel/ITunesCategory.html#method-c-required_uri","()",""],["required_uri","RSS::ITunesChannelModel::ITunesImage","RSS/ITunesChannelModel/ITunesImage.html#method-c-required_uri","()",""],["required_uri","RSS::ITunesChannelModel::ITunesOwner","RSS/ITunesChannelModel/ITunesOwner.html#method-c-required_uri","()",""],["required_uri","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-c-required_uri","()",""],["required_uri","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-c-required_uri","()",""],["required_uri","RSS::ImageItemModel::ImageItem","RSS/ImageItemModel/ImageItem.html#method-c-required_uri","()",""],["required_uri","RSS::RDF","RSS/RDF.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Bag","RSS/RDF/Bag.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Bag","RSS/RDF/Bag.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Channel","RSS/RDF/Channel.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Channel::Image","RSS/RDF/Channel/Image.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Channel::Items","RSS/RDF/Channel/Items.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Channel::Textinput","RSS/RDF/Channel/Textinput.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Image","RSS/RDF/Image.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Item","RSS/RDF/Item.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Li","RSS/RDF/Li.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Li","RSS/RDF/Li.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Li","RSS/RDF/Li.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Seq","RSS/RDF/Seq.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Seq","RSS/RDF/Seq.html#method-c-required_uri","()",""],["required_uri","RSS::RDF::Textinput","RSS/RDF/Textinput.html#method-c-required_uri","()",""],["required_uri","RSS::TaxonomyTopicModel::TaxonomyTopic","RSS/TaxonomyTopicModel/TaxonomyTopic.html#method-c-required_uri","()",""],["required_uri","RSS::TaxonomyTopicsModel::TaxonomyTopics","RSS/TaxonomyTopicsModel/TaxonomyTopics.html#method-c-required_uri","()",""],["required_variable_names","RSS::Maker::Atom::Entry::Items::Item","RSS/Maker/Atom/Entry/Items/Item.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::Atom::Feed::Channel","RSS/Maker/Atom/Feed/Channel.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::Atom::Feed::Image","RSS/Maker/Atom/Feed/Image.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::Atom::Feed::Items::Item","RSS/Maker/Atom/Feed/Items/Item.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::Atom::Feed::Items::Item::Content","RSS/Maker/Atom/Feed/Items/Item/Content.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::Atom::Feed::Items::Item::Source","RSS/Maker/Atom/Feed/Items/Item/Source.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::Atom::Feed::Items::Item::Source::Icon","RSS/Maker/Atom/Feed/Items/Item/Source/Icon.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::AtomCategory","RSS/Maker/AtomCategory.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::AtomGenerator","RSS/Maker/AtomGenerator.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::AtomLink","RSS/Maker/AtomLink.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::AtomLogo","RSS/Maker/AtomLogo.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::AtomTextConstruct","RSS/Maker/AtomTextConstruct.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::ITunesChannelModel::ITunesOwnerBase","RSS/Maker/ITunesChannelModel/ITunesOwnerBase.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Channel","RSS/Maker/RSS09/Channel.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Channel::Copyright","RSS/Maker/RSS09/Channel/Copyright.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Channel::Description","RSS/Maker/RSS09/Channel/Description.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Channel::Links::Link","RSS/Maker/RSS09/Channel/Links/Link.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Channel::SkipDays::Day","RSS/Maker/RSS09/Channel/SkipDays/Day.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Channel::SkipHours::Hour","RSS/Maker/RSS09/Channel/SkipHours/Hour.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Channel::Title","RSS/Maker/RSS09/Channel/Title.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Image","RSS/Maker/RSS09/Image.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Items::Item","RSS/Maker/RSS09/Items/Item.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Items::Item::Description","RSS/Maker/RSS09/Items/Item/Description.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Items::Item::Links::Link","RSS/Maker/RSS09/Items/Item/Links/Link.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Items::Item::Title","RSS/Maker/RSS09/Items/Item/Title.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS09::Textinput","RSS/Maker/RSS09/Textinput.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Channel","RSS/Maker/RSS10/Channel.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Channel::Description","RSS/Maker/RSS10/Channel/Description.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Channel::Links::Link","RSS/Maker/RSS10/Channel/Links/Link.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Channel::Title","RSS/Maker/RSS10/Channel/Title.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Image","RSS/Maker/RSS10/Image.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Items::Item","RSS/Maker/RSS10/Items/Item.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Items::Item::Description","RSS/Maker/RSS10/Items/Item/Description.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Items::Item::Title","RSS/Maker/RSS10/Items/Item/Title.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS10::Textinput","RSS/Maker/RSS10/Textinput.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Channel","RSS/Maker/RSS20/Channel.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Channel::Categories::Category","RSS/Maker/RSS20/Channel/Categories/Category.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Channel::Cloud","RSS/Maker/RSS20/Channel/Cloud.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Channel::Generator","RSS/Maker/RSS20/Channel/Generator.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Items::Item","RSS/Maker/RSS20/Items/Item.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Items::Item::Categories::Category","RSS/Maker/RSS20/Items/Item/Categories/Category.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Items::Item::Enclosure","RSS/Maker/RSS20/Items/Item/Enclosure.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Items::Item::Guid","RSS/Maker/RSS20/Items/Item/Guid.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::RSS20::Items::Item::Source","RSS/Maker/RSS20/Items/Item/Source.html#method-i-required_variable_names","()",""],["required_variable_names","RSS::Maker::XMLStyleSheets::XMLStyleSheet","RSS/Maker/XMLStyleSheets/XMLStyleSheet.html#method-i-required_variable_names","()",""],["required_variables_are_set?","RSS::Maker::Base","RSS/Maker/Base.html#method-i-required_variables_are_set-3F","()",""],["requirement","Bundler::DepProxy","Bundler/DepProxy.html#method-i-requirement","()",""],["requirement","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-requirement","()","<p>(see Bundler::Molinillo::ResolutionState#requirement)\n"],["requirement","Gem::Dependency","Gem/Dependency.html#method-i-requirement","()","<p>What does this dependency require?\n"],["requirement","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-requirement","()","<p>The version requirement for this dependency request\n"],["requirement","Gem::Resolver::Molinillo::Delegates::ResolutionState","Gem/Resolver/Molinillo/Delegates/ResolutionState.html#method-i-requirement","()","<p>(see Gem::Resolver::Molinillo::ResolutionState#requirement)\n"],["requirement!","Gem::Resolver::Stats","Gem/Resolver/Stats.html#method-i-requirement-21","()",""],["requirement_for_existing_name","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-requirement_for_existing_name","(name)","<p>@return [Object] the requirement that led to a version of a possibility\n\n<pre>with the given name being activated.</pre>\n"],["requirement_for_existing_name","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-requirement_for_existing_name","(name)","<p>@return [Object] the requirement that led to a version of a possibility\n\n<pre>with the given name being activated.</pre>\n"],["requirement_satisfied_by?","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-requirement_satisfied_by-3F","(requirement, activated, spec)","<p>(see Bundler::Molinillo::SpecificationProvider#requirement_satisfied_by?)\n"],["requirement_satisfied_by?","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-requirement_satisfied_by-3F","(requirement, activated, spec)","<p>Determines whether the given `requirement` is satisfied by the given `spec`, in the context of the current …\n"],["requirement_satisfied_by?","Bundler::Resolver","Bundler/Resolver.html#method-i-requirement_satisfied_by-3F","(requirement, activated, spec)",""],["requirement_satisfied_by?","Gem::Resolver","Gem/Resolver.html#method-i-requirement_satisfied_by-3F","(requirement, activated, spec)",""],["requirement_satisfied_by?","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-requirement_satisfied_by-3F","(requirement, activated, spec)","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#requirement_satisfied_by?)\n"],["requirement_satisfied_by?","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-requirement_satisfied_by-3F","(requirement, activated, spec)","<p>Determines whether the given `requirement` is satisfied by the given `spec`, in the context of the current …\n"],["requirement_tree_for","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-requirement_tree_for","(requirement)","<p>@return [Array&lt;Object&gt;] the list of requirements that led to\n\n<pre>`requirement` being required.</pre>\n"],["requirement_tree_for","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-requirement_tree_for","(requirement)","<p>@return [Array&lt;Object&gt;] the list of requirements that led to\n\n<pre>`requirement` being required.</pre>\n"],["requirement_trees","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-requirement_trees","()","<p>@return [Array&lt;Array&lt;Object&gt;&gt;] The different requirement\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">trees</span> <span class=\"ruby-identifier\">that</span> <span class=\"ruby-identifier\">led</span> <span class=\"ruby-identifier\">to</span> <span class=\"ruby-identifier\">every</span> <span class=\"ruby-identifier\">requirement</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["requirement_trees","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-requirement_trees","()","<p>@return [Array&lt;Array&lt;Object&gt;&gt;] The different requirement\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">trees</span> <span class=\"ruby-identifier\">that</span> <span class=\"ruby-identifier\">led</span> <span class=\"ruby-identifier\">to</span> <span class=\"ruby-identifier\">every</span> <span class=\"ruby-identifier\">requirement</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["requirements","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-requirements","()","<p>(see Bundler::Molinillo::ResolutionState#requirements)\n"],["requirements","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-requirements","()","<p>@return [Array&lt;Object&gt;] all of the requirements that required\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">this</span> <span class=\"ruby-identifier\">vertex</span>\n</pre>\n"],["requirements","Gem::Resolver::Molinillo::Delegates::ResolutionState","Gem/Resolver/Molinillo/Delegates/ResolutionState.html#method-i-requirements","()","<p>(see Gem::Resolver::Molinillo::ResolutionState#requirements)\n"],["requirements","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-requirements","()","<p>@return [Array&lt;Object&gt;] all of the requirements that required\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">this</span> <span class=\"ruby-identifier\">vertex</span>\n</pre>\n"],["requirements","Gem::Specification","Gem/Specification.html#method-i-requirements","()","<p>Lists the external (to RubyGems) requirements that must be met for this gem to work.  It&#39;s simply …\n"],["requirements=","Gem::Specification","Gem/Specification.html#method-i-requirements-3D","(req)","<p>Set requirements to <code>req</code>, ensuring it is an array. Don&#39;t use this, push onto the array instead.\n"],["requirements_list","Gem::Dependency","Gem/Dependency.html#method-i-requirements_list","()",""],["requires","Bundler::Gemdeps","Bundler/Gemdeps.html#method-i-requires","()",""],["requires_checkout?","Bundler::Source::Git","Bundler/Source/Git.html#method-i-requires_checkout-3F","()",""],["requires_sudo?","Bundler","Bundler.html#method-c-requires_sudo-3F","()",""],["requires_sudo?","Bundler::Plugin::Installer::Rubygems","Bundler/Plugin/Installer/Rubygems.html#method-i-requires_sudo-3F","()",""],["requires_sudo?","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-requires_sudo-3F","()",""],["rerdoc_task_description","RDoc::Task","RDoc/Task.html#method-i-rerdoc_task_description","()","<p>Task description for the rerdoc task or its renamed description\n"],["rerdoc_task_description","RDoc::Task","RDoc/Task.html#method-i-rerdoc_task_description","()","<p>Task description for the rerdoc task or its renamed description\n"],["rerdoc_task_name","RDoc::Task","RDoc/Task.html#method-i-rerdoc_task_name","()",""],["rerdoc_task_name","RDoc::Task","RDoc/Task.html#method-i-rerdoc_task_name","()",""],["reset","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-reset","(connection)","<p>Finishes then restarts the Net::HTTP <code>connection</code>\n"],["reset","Bundler::Plugin::Events","Bundler/Plugin/Events.html#method-c-reset","()",""],["reset","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-reset","()",""],["reset","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-reset","(value = nil, name = nil)","<p>Generate a reset button Input element, as a String.\n<p>This resets the values on a form to their initial …\n"],["reset","Digest::Base","Digest/Base.html#method-i-reset","()","<p>Reset the digest to its initial state and return <code>self</code>.\n"],["reset","Digest::Instance","Digest/Instance.html#method-i-reset","()","<p>Resets the digest to the initial state and returns self.\n<p>This method is overridden by each implementation …\n"],["reset","Gem::CommandManager","Gem/CommandManager.html#method-c-reset","()","<p>Reset the authoritative instance of the command manager.\n"],["reset","Gem::Request","Gem/Request.html#method-i-reset","(connection)","<p>Resets HTTP connection <code>connection</code>.\n"],["reset","Gem::Security","Gem/Security.html#method-c-reset","()","<p>Resets the trust directory for verifying gems.\n"],["reset","Gem::Specification","Gem/Specification.html#method-c-reset","()","<p>Reset the list of known specs, running pre and post reset hooks registered in Gem.\n"],["reset","Net::POP3","Net/POP3.html#method-i-reset","()","<p>Resets the session.  This clears all “deleted” marks from messages.\n<p>This method raises a POPError …\n"],["reset","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-reset","()","<p>Fully resets the internal state of the Cipher. By using this, the same Cipher instance may be used several …\n"],["reset","OpenSSL::Digest","OpenSSL/Digest.html#method-i-reset","()","<p>Resets the Digest in the sense that any Digest#update that has been performed is abandoned and the Digest …\n"],["reset","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-reset","()","<p>Returns <em>hmac</em> as it was when it was first initialized, with all processed data cleared from it.\n<p>Example …\n"],["reset","RDoc::Parser::RipperStateLex::InnerStateLex","RDoc/Parser/RipperStateLex/InnerStateLex.html#method-i-reset","()",""],["reset","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-reset","()","<p>Resets the tools\n"],["reset","REXML::Validation::Choice","REXML/Validation/Choice.html#method-i-reset","()",""],["reset","REXML::Validation::Interleave","REXML/Validation/Interleave.html#method-i-reset","()",""],["reset","REXML::Validation::OneOrMore","REXML/Validation/OneOrMore.html#method-i-reset","()",""],["reset","REXML::Validation::State","REXML/Validation/State.html#method-i-reset","()",""],["reset","REXML::Validation::Validator","REXML/Validation/Validator.html#method-i-reset","()",""],["reset","Set","Set.html#method-i-reset","()","<p>Resets the internal state after modification to existing elements and returns self.\n<p>Elements will be reindexed …\n"],["reset","StringScanner","StringScanner.html#method-i-reset","()","<p>Reset the scan pointer (index 0) and clear matching data.\n"],["reset","Zlib::ZStream","Zlib/ZStream.html#method-i-reset","()","<p>Resets and initializes the stream. All data in both input and output buffer are discarded.\n"],["reset!","Bundler","Bundler.html#method-c-reset-21","()",""],["reset!","Bundler::Plugin","Bundler/Plugin.html#method-i-reset-21","()",""],["reset_nil_attributes_to_default","Gem::Specification","Gem/Specification.html#method-i-reset_nil_attributes_to_default","()","<p>Reset nil attributes to their default values to make the spec valid\n"],["reset_paths!","Bundler","Bundler.html#method-c-reset_paths-21","()",""],["reset_rubygems!","Bundler","Bundler.html#method-c-reset_rubygems-21","()",""],["resolve","Bundler::Definition","Bundler/Definition.html#method-i-resolve","()","<p>Resolve all the dependencies specified in Gemfile. It ensures that dependencies that have been already …\n"],["resolve","Bundler::Molinillo::Resolver","Bundler/Molinillo/Resolver.html#method-i-resolve","(requested, base = DependencyGraph.new)","<p>Resolves the requested dependencies into a {DependencyGraph}, locking to the base dependency graph (if …\n"],["resolve","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-resolve","()","<p>Resolves the {#original_requested} dependencies into a full dependency\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">graph</span>\n</pre>\n<p>@raise [ResolverError] if …\n"],["resolve","Bundler::Resolver","Bundler/Resolver.html#method-c-resolve","(requirements, index, source_requirements = {}, base = [], gem_version_promoter = GemVersionPromoter.new, additional_base_requirements = [], platforms = nil)","<p>Figures out the best possible configuration of gems that satisfies the list of passed dependencies and …\n"],["resolve","Gem::RequestSet","Gem/RequestSet.html#method-i-resolve","(set = Gem::Resolver::BestSet.new)","<p>Resolve the requested dependencies and return an Array of Specification objects to be activated.\n"],["resolve","Gem::Resolver","Gem/Resolver.html#method-i-resolve","()","<p>Proceed with resolution! Returns an array of ActivationRequest objects.\n"],["resolve","Gem::Resolver::Molinillo::Resolver","Gem/Resolver/Molinillo/Resolver.html#method-i-resolve","(requested, base = DependencyGraph.new)","<p>Resolves the requested dependencies into a {DependencyGraph}, locking to the base dependency graph (if …\n"],["resolve","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-resolve","()","<p>Resolves the {#original_requested} dependencies into a full dependency\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">graph</span>\n</pre>\n<p>@raise [ResolverError] if …\n"],["resolve","RDoc::CrossReference","RDoc/CrossReference.html#method-i-resolve","(name, text)","<p>Returns a reference to <code>name</code>.\n<p>If the reference is found and <code>name</code> is not documented <code>text</code> will be returned. …\n"],["resolve","Racc::States","Racc/States.html#method-i-resolve","(state)","<p>resolve\n"],["resolve_activated_specs","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-resolve_activated_specs","()",""],["resolve_aliases","RDoc::Context","RDoc/Context.html#method-i-resolve_aliases","(added)","<p>Tries to resolve unmatched aliases when a method or attribute has just been added.\n"],["resolve_class","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-resolve_class","(klassname)","<p>Convert <code>klassname</code> to a Class\n"],["resolve_current","Gem::RequestSet","Gem/RequestSet.html#method-i-resolve_current","()","<p>Resolve the requested dependencies against the gems available via Gem.path and return an Array of Specification …\n"],["resolve_if_needed","Bundler::Installer","Bundler/Installer.html#method-i-resolve_if_needed","(options)","<p>returns whether or not a re-resolve was needed\n"],["resolve_name","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-resolve_name","(name)",""],["resolve_path","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-resolve_path","(path)",""],["resolve_remotely!","Bundler::Definition","Bundler/Definition.html#method-i-resolve_remotely-21","()",""],["resolve_row_separator","CSV::Parser","CSV/Parser.html#method-i-resolve_row_separator","(separator)",""],["resolve_rr","Racc::States","Racc/States.html#method-i-resolve_rr","(state, r)",""],["resolve_sr","Racc::States","Racc/States.html#method-i-resolve_sr","(state, s)",""],["resolve_with_cache!","Bundler::Definition","Bundler/Definition.html#method-i-resolve_with_cache-21","()",""],["resources","RSS::RDF::Channel::Items","RSS/RDF/Channel/Items.html#method-i-resources","()",""],["resources","RSS::TaxonomyTopicsModel::TaxonomyTopics","RSS/TaxonomyTopicsModel/TaxonomyTopics.html#method-i-resources","()",""],["respond_to?","Bundler::ConnectionPool::Wrapper","Bundler/ConnectionPool/Wrapper.html#method-i-respond_to-3F","(id, *args)",""],["respond_to?","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-respond_to-3F","(*args)",""],["respond_to?","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-respond_to-3F","(method, include_all = false)",""],["respond_to?","DRb::DRbObject","DRb/DRbObject.html#method-i-respond_to-3F","(msg_id, priv=false)","<p>Routes respond_to? to the referenced remote object.\n"],["respond_to?","DRb::DRbObject","DRb/DRbObject.html#method-i-respond_to-3F","(msg_id, priv=false)","<p>Routes respond_to? to the referenced remote object.\n"],["respond_to?","Object","Object.html#method-i-respond_to-3F","(p1, p2 = v2)","<p>Returns <code>true</code> if <em>obj</em> responds to the given method.  Private and protected methods are included in the …\n"],["respond_to_missing?","Bundler::Plugin::API","Bundler/Plugin/API.html#method-i-respond_to_missing-3F","(name, include_private = false)",""],["respond_to_missing?","Delegator","Delegator.html#method-i-respond_to_missing-3F","(m, include_private)","<p>Checks for a method provided by this the delegate object by forwarding the call through _<em>getobj</em>_.\n"],["respond_to_missing?","Object","Object.html#method-i-respond_to_missing-3F","(p1, p2)","<p>DO NOT USE THIS DIRECTLY.\n<p>Hook method to return whether the <em>obj</em> can respond to <em>id</em> method or not.\n<p>When the …\n"],["response_body_permitted?","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-response_body_permitted-3F","()",""],["response_class","Net::HTTPResponse","Net/HTTPResponse.html#method-c-response_class","(code)",""],["responses","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-responses","()","<p>Returns an Array of SingleResponse for this BasicResponse.\n"],["rest","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-rest","()",""],["rest","StringScanner","StringScanner.html#method-i-rest","()","<p>Returns the “rest” of the string (i.e. everything after the scan pointer). If there is no more …\n"],["rest?","StringScanner","StringScanner.html#method-i-rest-3F","()","<p>Returns true iff there is more data in the string.  See #eos?. This method is obsolete; use #eos? instead. …\n"],["rest_size","StringScanner","StringScanner.html#method-i-rest_size","()","<p><code>s.rest_size</code> is equivalent to <code>s.rest.size</code>.\n"],["restore","Bundler::EnvironmentPreserver","Bundler/EnvironmentPreserver.html#method-i-restore","()","<p>@return [Hash]\n"],["restore","CGI::Session::FileStore","CGI/Session/FileStore.html#method-i-restore","()","<p>Restore session state from the session&#39;s FileStore file.\n<p>Returns the session state as a hash.\n"],["restore","CGI::Session::MemoryStore","CGI/Session/MemoryStore.html#method-i-restore","()","<p>Restore session state.\n<p>Returns session data as a hash.\n"],["restore","CGI::Session::NullStore","CGI/Session/NullStore.html#method-i-restore","()","<p>Restore (empty) session state.\n"],["restore","CGI::Session::PStore","CGI/Session/PStore.html#method-i-restore","()","<p>Restore session state from the session&#39;s PStore file.\n<p>Returns the session state as a hash.\n"],["restore","JSON","JSON.html#method-c-restore","(source, proc = nil, options = {})",""],["restore","JSON","JSON.html#method-i-restore","(source, proc = nil, options = {})",""],["restore","Marshal","Marshal.html#method-c-restore","(*args)","<p>Returns the result of converting the serialized data in source into a Ruby object (possibly with associated …\n"],["restsize","StringScanner","StringScanner.html#method-i-restsize","()","<p><code>s.restsize</code> is equivalent to <code>s.rest_size</code>. This method is obsolete; use #rest_size instead.\n"],["result","Coverage","Coverage.html#method-c-result","(p1 = v1)","<p>Returns a hash that contains filename as key and coverage array as value. If <code>clear</code> is true, it clears …\n"],["result","ERB","ERB.html#method-i-result","(b=new_toplevel)","<p>Executes the generated ERB code to produce a completed template, returning the results of that code. …\n"],["result","GC::Profiler","GC/Profiler.html#method-c-result","()","<p>Returns a profile data report such as:\n\n<pre>GC 1 invokes.\nIndex    Invoke Time(sec)       Use Size(byte)   ...</pre>\n"],["result","StopIteration","StopIteration.html#method-i-result","()","<p>Returns the return value of the iterator.\n\n<pre>o = Object.new\ndef o.each\n  yield 1\n  yield 2\n  yield 3\n  100 ...</pre>\n"],["result_with_hash","ERB","ERB.html#method-i-result_with_hash","(hash)","<p>Render a template on a new toplevel binding with local variables specified by a Hash object.\n"],["resume","DEBUGGER__","DEBUGGER__.html#method-c-resume","()",""],["resume","Fiber","Fiber.html#method-i-resume","(*args)","<p>Resumes the fiber from the point at which the last Fiber.yield was called, or starts running it if it …\n"],["resume","RubyVM::MJIT","RubyVM/MJIT.html#method-c-resume","()",""],["retrbinary","Net::FTP","Net/FTP.html#method-i-retrbinary","(cmd, blocksize, rest_offset = nil)","<p>Puts the connection into binary (image) mode, issues the given command, and fetches the data returned, …\n"],["retrieve_active_spec","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-retrieve_active_spec","(definition, current_spec)",""],["retrieve_comment_body","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-retrieve_comment_body","(tk)","<p>Retrieve comment body without =begin/=end\n"],["retrieve_heredoc_info","RDoc::Parser::RipperStateLex","RDoc/Parser/RipperStateLex.html#method-i-retrieve_heredoc_info","(tk)",""],["retrlines","Net::FTP","Net/FTP.html#method-i-retrlines","(cmd)","<p>Puts the connection into ASCII (text) mode, issues the given command, and passes the resulting data, …\n"],["return_headers?","CSV","CSV.html#method-i-return_headers-3F","()","<p>Returns <code>true</code> if headers will be returned as a row of results. See CSV::new for details.\n"],["return_headers?","CSV::Parser","CSV/Parser.html#method-i-return_headers-3F","()",""],["return_type","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-return_type","()","<p>Returns string of return value type of method.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["return_type_detail","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-return_type_detail","()","<p>Returns detail information of return value type of method. The information is array.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["return_value","TracePoint","TracePoint.html#method-i-return_value","()","<p>Return value from <code>:return</code>, <code>c_return</code>, and <code>b_return</code> event\n"],["return_vtype","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-return_vtype","()","<p>Returns number of return value type of method.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["retval?","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-retval-3F","()","<p>Returns true if argument is return value.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;DirectX 7 for Visual Basic Type Library&#39;, ...</pre>\n"],["reverse","Array","Array.html#method-i-reverse","()","<p>Returns a new array containing <code>self</code>&#39;s elements in reverse order.\n\n<pre class=\"ruby\">[ <span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;b&quot;</span>, <span class=\"ruby-string\">&quot;c&quot;</span> ].<span class=\"ruby-identifier\">reverse</span>   <span class=\"ruby-comment\">#=&gt; [&quot;c&quot;, ...</span>\n</pre>\n"],["reverse","IPAddr","IPAddr.html#method-i-reverse","()","<p>Returns a string for DNS reverse lookup.  It returns a string in RFC3172 form for an IPv6 address.\n"],["reverse","String","String.html#method-i-reverse","()","<p>Returns a new string with the characters from <em>str</em> in reverse order.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;stressed&quot;</span>.<span class=\"ruby-identifier\">reverse</span>   <span class=\"ruby-comment\">#=&gt; &quot;desserts&quot;</span>\n</pre>\n"],["reverse!","Array","Array.html#method-i-reverse-21","()","<p>Reverses <code>self</code> in place.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [ <span class=\"ruby-string\">&quot;a&quot;</span>, <span class=\"ruby-string\">&quot;b&quot;</span>, <span class=\"ruby-string\">&quot;c&quot;</span> ]\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">reverse!</span>       <span class=\"ruby-comment\">#=&gt; [&quot;c&quot;, &quot;b&quot;, &quot;a&quot;]</span>\n<span class=\"ruby-identifier\">a</span>                <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["reverse!","String","String.html#method-i-reverse-21","()","<p>Reverses <em>str</em> in place.\n"],["reverse_each","Array","Array.html#method-i-reverse_each","()","<p>Same as Array#each, but traverses <code>self</code> in reverse order.\n\n<pre>a = [ &quot;a&quot;, &quot;b&quot;, &quot;c&quot; ]\na.reverse_each {|x| print ...</pre>\n"],["reverse_each","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-reverse_each","()","<p>@!visibility private Enumerates each action in the log in reverse order @yield [Action]\n"],["reverse_each","Enumerable","Enumerable.html#method-i-reverse_each","(*args)","<p>Builds a temporary array and traverses that array in reverse order.\n<p>If no block is given, an enumerator …\n"],["reverse_each","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-reverse_each","()","<p>@!visibility private Enumerates each action in the log in reverse order @yield [Action]\n"],["reverse_rubygems_kernel_mixin","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-reverse_rubygems_kernel_mixin","()",""],["reversed_requirement_tree_index","Bundler::Molinillo::Resolver::Resolution::UnwindDetails","Bundler/Molinillo/Resolver/Resolution/UnwindDetails.html#method-i-reversed_requirement_tree_index","()","<p>@return [Integer] index of state requirement in reversed requirement tree\n\n<pre>(the conflicting requirement ...</pre>\n"],["revision","Bundler::Source::Git","Bundler/Source/Git.html#method-i-revision","()",""],["revision","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-revision","()",""],["revive","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-revive","(klass, node)",""],["revive_hash","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-revive_hash","(hash, o)",""],["revocation_reason","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-revocation_reason","()",""],["revocation_time","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-revocation_time","()",""],["revoked","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-revoked","()",""],["revoked=","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-revoked-3D","(p1)",""],["rewind","ARGF","ARGF.html#method-i-rewind","()","<p>Positions the current file to the beginning of input, resetting <code>ARGF.lineno</code> to zero.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ARGF</span>.<span class=\"ruby-identifier\">readline</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["rewind","CSV","CSV.html#method-i-rewind","()","<p>Rewinds the underlying IO object and resets CSV&#39;s lineno() counter.\n"],["rewind","CSV::Writer","CSV/Writer.html#method-i-rewind","()","<p>Winds back to the beginning\n"],["rewind","Dir","Dir.html#method-i-rewind","()","<p>Repositions <em>dir</em> to the first entry.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testdir&quot;</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">read</span>     <span class=\"ruby-comment\">#=&gt; &quot;.&quot;</span>\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">rewind</span>   <span class=\"ruby-comment\">#=&gt; #&lt;Dir:0x401b3fb0&gt; ...</span>\n</pre>\n"],["rewind","Enumerator","Enumerator.html#method-i-rewind","()","<p>Rewinds the enumeration sequence to the beginning.\n<p>If the enclosed object responds to a “rewind” …\n"],["rewind","Enumerator::Chain","Enumerator/Chain.html#method-i-rewind","()","<p>Rewinds the enumerator chain by calling the “rewind” method on each enumerable in reverse order. …\n"],["rewind","Gem::Package::TarReader","Gem/Package/TarReader.html#method-i-rewind","()","<p>NOTE: Do not call #rewind during #each\n"],["rewind","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-rewind","()","<p>Rewinds to the beginning of the tar file entry\n"],["rewind","IO","IO.html#method-i-rewind","()","<p>Positions <em>ios</em> to the beginning of input, resetting #lineno to zero.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>)\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">readline</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rewind","Prime::EratosthenesGenerator","Prime/EratosthenesGenerator.html#method-i-rewind","()",""],["rewind","Prime::Generator23","Prime/Generator23.html#method-i-rewind","()",""],["rewind","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-rewind","()","<p>Rewinds the internal position for enumeration.\n<p>See <code>Enumerator</code>#rewind.\n"],["rewind","Prime::TrialDivisionGenerator","Prime/TrialDivisionGenerator.html#method-i-rewind","()",""],["rewind","REXML::Parsers::LightParser","REXML/Parsers/LightParser.html#method-i-rewind","()",""],["rewind","REXML::Parsers::UltraLightParser","REXML/Parsers/UltraLightParser.html#method-i-rewind","()",""],["rewind","StringIO","StringIO.html#method-i-rewind","()","<p>Positions the stream to the beginning of input, resetting <code>lineno</code> to zero.\n"],["rewind","Zlib::GzipReader","Zlib/GzipReader.html#method-i-rewind","()","<p>Resets the position of the file pointer to the point created the GzipReader object.  The associated  …\n"],["rewind_to","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-rewind_to","(tag)","<p>Rewinds the graph to the state tagged as `tag` @param  [Object] tag the tag to rewind to @return [Void] …\n"],["rewind_to","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-rewind_to","(graph, tag)","<p>@macro action\n"],["rewind_to","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-rewind_to","(tag)","<p>Rewinds the graph to the state tagged as `tag` @param  [Object] tag the tag to rewind to @return [Void] …\n"],["rewind_to","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-rewind_to","(graph, tag)","<p>@macro action\n"],["rfc1123_date","CGI::Util","CGI/Util.html#method-i-rfc1123_date","(time)","<p>Format a <code>Time</code> object as a String using the format specified by RFC 1123.\n\n<pre>CGI.rfc1123_date(Time.now)\n  ...</pre>\n"],["rfc2822","Date","Date.html#method-c-rfc2822","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.\n\n<pre>Date.rfc2822(&#39;Sat, ...</pre>\n"],["rfc2822","Date","Date.html#method-i-rfc2822","()","<p>This method is equivalent to strftime(&#39;%a, %-d %b %Y %T %z&#39;).\n"],["rfc2822","DateTime","DateTime.html#method-c-rfc2822","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new DateTime object by parsing from a string according to some typical RFC 2822 formats.\n\n<pre>DateTime.rfc2822(&#39;Sat, ...</pre>\n"],["rfc2822","Time","Time.html#method-c-rfc2822","(date)","<p>Parses <code>date</code> as date-time defined by RFC 2822 and converts it to a Time object.  The format is identical …\n"],["rfc2822","Time","Time.html#method-i-rfc2822","()","<p>Returns a string which represents the time as date-time defined by RFC 2822:\n\n<pre>day-of-week, DD month-name ...</pre>\n"],["rfc3339","Date","Date.html#method-c-rfc3339","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new Date object by parsing from a string according to some typical RFC 3339 formats.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">rfc3339</span>(<span class=\"ruby-string\">&#39;2001-02-03T04:05:06+07:00&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rfc3339","Date","Date.html#method-i-rfc3339","()","<p>This method is equivalent to strftime(&#39;%FT%T%:z&#39;).\n"],["rfc3339","DateTime","DateTime.html#method-i-rfc3339","(*args)","<p>This method is equivalent to strftime(&#39;%FT%T%:z&#39;). The optional argument <code>n</code> is the number of digits …\n"],["rfc3339","DateTime","DateTime.html#method-c-rfc3339","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new DateTime object by parsing from a string according to some typical RFC 3339 formats.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">rfc3339</span>(<span class=\"ruby-string\">&#39;2001-02-03T04:05:06+07:00&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rfc822","Date","Date.html#method-i-rfc822","()","<p>This method is equivalent to strftime(&#39;%a, %-d %b %Y %T %z&#39;).\n"],["rfc822","Date","Date.html#method-c-rfc822","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.\n\n<pre>Date.rfc2822(&#39;Sat, ...</pre>\n"],["rfc822","DateTime","DateTime.html#method-c-rfc822","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new DateTime object by parsing from a string according to some typical RFC 2822 formats.\n\n<pre>DateTime.rfc2822(&#39;Sat, ...</pre>\n"],["rfc822","Time","Time.html#method-c-rfc822","(date)",""],["rfc822","Time","Time.html#method-i-rfc822","()",""],["rg_full_gem_path","Gem::Specification","Gem/Specification.html#method-i-rg_full_gem_path","()",""],["rg_loaded_from","Gem::Specification","Gem/Specification.html#method-i-rg_loaded_from","()",""],["ri_dir","Gem::Specification","Gem/Specification.html#method-i-ri_dir","()","<p>Returns the full path to this spec&#39;s ri directory.\n"],["ri_installed?","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-ri_installed-3F","()","<p>Is ri data installed?\n"],["ri_installed?","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-ri_installed-3F","()","<p>Is ri data installed?\n"],["ri_paths","RDoc::Servlet","RDoc/Servlet.html#method-i-ri_paths","(&block)","<p>Enumerates the ri paths.  See RDoc::RI::Paths#each\n"],["rid","Process::GID","Process/GID.html#method-c-rid","()","<p>Returns the (real) group ID for this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">gid</span>   <span class=\"ruby-comment\">#=&gt; 500</span>\n</pre>\n"],["rid","Process::UID","Process/UID.html#method-c-rid","()","<p>Returns the (real) user ID of this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">uid</span>   <span class=\"ruby-comment\">#=&gt; 501</span>\n</pre>\n"],["right","Racc::Grammar::PrecedenceDefinitionEnv","Racc/Grammar/PrecedenceDefinitionEnv.html#method-i-right","(*syms)",""],["rindex","Array","Array.html#method-i-rindex","(*args)","<p>Returns the <em>index</em> of the last object in <code>self</code> <code>==</code> to <code>obj</code>.\n<p>If a block is given instead of an argument, returns …\n"],["rindex","String","String.html#method-i-rindex","(p1, p2 = v2)","<p>Returns the index of the last occurrence of the given <em>substring</em> or pattern (<em>regexp</em>) in <em>str</em>. Returns  …\n"],["rjust","String","String.html#method-i-rjust","(*args)","<p>If <em>integer</em> is greater than the length of <em>str</em>, returns a new String of length <em>integer</em> with <em>str</em> right justified …\n"],["rm","Bundler::FileUtils","Bundler/FileUtils.html#method-i-rm","(list, force: nil, noop: nil, verbose: nil)","<p>Remove file(s) specified in <code>list</code>.  This method cannot remove directories. All StandardErrors are ignored …\n"],["rm","Bundler::FileUtils","Bundler/FileUtils.html#method-c-rm","(list, force: nil, noop: nil, verbose: nil)","<p>Remove file(s) specified in <code>list</code>.  This method cannot remove directories. All StandardErrors are ignored …\n"],["rm","FileUtils","FileUtils.html#method-c-rm","(list, force: nil, noop: nil, verbose: nil)","<p>Remove file(s) specified in <code>list</code>.  This method cannot remove directories. All StandardErrors are ignored …\n"],["rm","FileUtils","FileUtils.html#method-i-rm","(list, force: nil, noop: nil, verbose: nil)","<p>Remove file(s) specified in <code>list</code>.  This method cannot remove directories. All StandardErrors are ignored …\n"],["rm_f","Bundler::FileUtils","Bundler/FileUtils.html#method-c-rm_f","(list, noop: nil, verbose: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["rm_f","Bundler::FileUtils","Bundler/FileUtils.html#method-i-rm_f","(list, noop: nil, verbose: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["rm_f","FileUtils","FileUtils.html#method-i-rm_f","(list, noop: nil, verbose: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["rm_f","FileUtils","FileUtils.html#method-c-rm_f","(list, noop: nil, verbose: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n"],["rm_r","Bundler::FileUtils","Bundler/FileUtils.html#method-i-rm_r","(list, force: nil, noop: nil, verbose: nil, secure: nil)","<p>remove files <code>list[0]</code> <code>list[1]</code>… If <code>list[n]</code> is a directory, removes its all contents recursively. This …\n"],["rm_r","Bundler::FileUtils","Bundler/FileUtils.html#method-c-rm_r","(list, force: nil, noop: nil, verbose: nil, secure: nil)","<p>remove files <code>list[0]</code> <code>list[1]</code>… If <code>list[n]</code> is a directory, removes its all contents recursively. This …\n"],["rm_r","FileUtils","FileUtils.html#method-i-rm_r","(list, force: nil, noop: nil, verbose: nil, secure: nil)","<p>remove files <code>list[0]</code> <code>list[1]</code>… If <code>list[n]</code> is a directory, removes its all contents recursively. This …\n"],["rm_r","FileUtils","FileUtils.html#method-c-rm_r","(list, force: nil, noop: nil, verbose: nil, secure: nil)","<p>remove files <code>list[0]</code> <code>list[1]</code>… If <code>list[n]</code> is a directory, removes its all contents recursively. This …\n"],["rm_rf","Bundler","Bundler.html#method-c-rm_rf","(path)",""],["rm_rf","Bundler::FileUtils","Bundler/FileUtils.html#method-c-rm_rf","(list, noop: nil, verbose: nil, secure: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm_r</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n<p>WARNING: This method causes local vulnerability. …\n"],["rm_rf","Bundler::FileUtils","Bundler/FileUtils.html#method-i-rm_rf","(list, noop: nil, verbose: nil, secure: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm_r</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n<p>WARNING: This method causes local vulnerability. …\n"],["rm_rf","FileUtils","FileUtils.html#method-c-rm_rf","(list, noop: nil, verbose: nil, secure: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm_r</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n<p>WARNING: This method causes local vulnerability. Read the …\n"],["rm_rf","FileUtils","FileUtils.html#method-i-rm_rf","(list, noop: nil, verbose: nil, secure: nil)","<p>Equivalent to\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rm_r</span>(<span class=\"ruby-identifier\">list</span>, <span class=\"ruby-value\">force:</span> <span class=\"ruby-keyword\">true</span>)\n</pre>\n<p>WARNING: This method causes local vulnerability. Read the …\n"],["rmdir","Bundler::FileUtils","Bundler/FileUtils.html#method-c-rmdir","(list, parents: nil, noop: nil, verbose: nil)","<p>Removes one or more directories.\n\n<pre>Bundler::FileUtils.rmdir &#39;somedir&#39;\nBundler::FileUtils.rmdir %w(somedir ...</pre>\n"],["rmdir","Bundler::FileUtils","Bundler/FileUtils.html#method-i-rmdir","(list, parents: nil, noop: nil, verbose: nil)","<p>Removes one or more directories.\n\n<pre>Bundler::FileUtils.rmdir &#39;somedir&#39;\nBundler::FileUtils.rmdir %w(somedir ...</pre>\n"],["rmdir","Dir","Dir.html#method-c-rmdir","(p1)","<p>Deletes the named directory. Raises a subclass of SystemCallError if the directory isn&#39;t empty.\n"],["rmdir","FileUtils","FileUtils.html#method-c-rmdir","(list, parents: nil, noop: nil, verbose: nil)","<p>Removes one or more directories.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rmdir</span> <span class=\"ruby-string\">&#39;somedir&#39;</span>\n<span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rmdir</span> <span class=\"ruby-node\">%w(somedir anydir otherdir)</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rmdir","FileUtils","FileUtils.html#method-i-rmdir","(list, parents: nil, noop: nil, verbose: nil)","<p>Removes one or more directories.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rmdir</span> <span class=\"ruby-string\">&#39;somedir&#39;</span>\n<span class=\"ruby-constant\">FileUtils</span>.<span class=\"ruby-identifier\">rmdir</span> <span class=\"ruby-node\">%w(somedir anydir otherdir)</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["rmdir","Net::FTP","Net/FTP.html#method-i-rmdir","(dirname)","<p>Removes a remote directory.\n"],["rmdir","Pathname","Pathname.html#method-i-rmdir","()","<p>Remove the referenced directory.\n<p>See Dir.rmdir.\n"],["rmtree","Bundler::FileUtils","Bundler/FileUtils.html#method-i-rmtree","(list, noop: nil, verbose: nil, secure: nil)",""],["rmtree","Bundler::FileUtils","Bundler/FileUtils.html#method-c-rmtree","(list, noop: nil, verbose: nil, secure: nil)",""],["rmtree","FileUtils","FileUtils.html#method-i-rmtree","(list, noop: nil, verbose: nil, secure: nil)",""],["rmtree","FileUtils","FileUtils.html#method-c-rmtree","(list, noop: nil, verbose: nil, secure: nil)",""],["rmtree","Pathname","Pathname.html#method-i-rmtree","()","<p>Recursively deletes a directory, including all directories beneath it.\n<p>See FileUtils.rm_r\n"],["root","Bundler","Bundler.html#method-c-root","()",""],["root","Bundler::Plugin","Bundler/Plugin.html#method-i-root","()","<p>The directory root for all plugin related data\n<p>If run in an app, points to local root, in app_config_path …\n"],["root","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-root","()","<p>It is used to obtain the full_gem_path.\n<p>spec&#39;s loaded_from path is expanded against this to get full_gem_path …\n"],["root","Bundler::Plugin::Installer::Git","Bundler/Plugin/Installer/Git.html#method-i-root","()",""],["root","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-root","()",""],["root","Bundler::Source::Path","Bundler/Source/Path.html#method-i-root","()",""],["root","Gem::Server","Gem/Server.html#method-i-root","(req, res)",""],["root","Psych::Nodes::Document","Psych/Nodes/Document.html#method-i-root","()","<p>Returns the root node.  A Document may only have one root node: yaml.org/spec/1.1/#id898031\n"],["root","RDoc::Servlet","RDoc/Servlet.html#method-i-root","(req, res)","<p>Generates the root page on <code>res</code>.  <code>req</code> is ignored.\n"],["root","REXML::Document","REXML/Document.html#method-i-root","()","<p>@return the root Element of the document, or nil if this document has no children.\n"],["root","REXML::Element","REXML/Element.html#method-i-root","()",""],["root","REXML::Light::Node","REXML/Light/Node.html#method-i-root","()",""],["root?","PStore","PStore.html#method-i-root-3F","(name)","<p>Returns true if the supplied <em>name</em> is currently in the data store.\n<p><strong>WARNING</strong>:  This method is only valid …\n"],["root?","Pathname","Pathname.html#method-i-root-3F","()","<p>Predicate method for root directories.  Returns <code>true</code> if the pathname consists of consecutive slashes. …\n"],["root_node","REXML::Element","REXML/Element.html#method-i-root_node","()","<p>Evaluates to the root node of the document that this element belongs to. If this element doesn&#39;t …\n"],["root_search","RDoc::Servlet","RDoc/Servlet.html#method-i-root_search","(req, res)","<p>Generates a search index for the root page on <code>res</code>.  <code>req</code> is ignored.\n"],["root_vertex_named","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-root_vertex_named","(name)","<p>@param [String] name @return [Vertex,nil] the root vertex with the given name\n"],["root_vertex_named","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-root_vertex_named","(name)","<p>@param [String] name @return [Vertex,nil] the root vertex with the given name\n"],["roots","PStore","PStore.html#method-i-roots","()","<p>Returns the names of all object hierarchies currently in the store.\n<p><strong>WARNING</strong>:  This method is only valid …\n"],["rotate","Array","Array.html#method-i-rotate","(*args)","<p>Returns a new array by rotating <code>self</code> so that the element at <code>count</code> is the first element of the new array. …\n"],["rotate!","Array","Array.html#method-i-rotate-21","(*args)","<p>Rotates <code>self</code> in place so that the element at <code>count</code> comes first, and returns <code>self</code>.\n<p>If <code>count</code> is negative …\n"],["round","BigDecimal","BigDecimal.html#method-i-round","(p1 = v1, p2 = v2)","<p>Round to the nearest integer (by default), returning the result as a BigDecimal if n is specified, or …\n"],["round","Float","Float.html#method-i-round","(p1 = v1, p2 = {})","<p>Returns <code>float</code> rounded to the nearest value with a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>When …\n"],["round","Integer","Integer.html#method-i-round","(p1 = v1, p2 = {})","<p>Returns <code>int</code> rounded to the nearest value with a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>When …\n"],["round","Matrix","Matrix.html#method-i-round","(ndigits=0)","<p>Returns a matrix with entries rounded to the given precision (see Float#round)\n"],["round","Numeric","Numeric.html#method-i-round","(*args)","<p>Returns <code>num</code> rounded to the nearest value with a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>Numeric …\n"],["round","REXML::Functions","REXML/Functions.html#method-c-round","( number )",""],["round","Rational","Rational.html#method-i-round","(*args, p2 = {})","<p>Returns <code>rat</code> rounded to the nearest value with a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>When …\n"],["round","Time","Time.html#method-i-round","(*args)","<p>Rounds sub seconds to a given precision in decimal digits (0 digits by default). It returns a new Time …\n"],["round","Vector","Vector.html#method-i-round","(ndigits=0)","<p>Returns a vector with entries rounded to the given precision (see Float#round)\n"],["route_from","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-route_from","(oth)","<p>Args\n<p><code>oth</code> &mdash; Bundler::URI or String\n\n<p>Description\n"],["route_from","URI::Generic","URI/Generic.html#method-i-route_from","(oth)","<p>Args\n<p><code>oth</code> &mdash; URI or String\n\n<p>Description\n"],["route_to","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-route_to","(oth)","<p>Args\n<p><code>oth</code> &mdash; Bundler::URI or String\n\n<p>Description\n"],["route_to","URI::Generic","URI/Generic.html#method-i-route_to","(oth)","<p>Args\n<p><code>oth</code> &mdash; URI or String\n\n<p>Description\n"],["row","Matrix","Matrix.html#method-i-row","(i)","<p>Returns row vector number <code>i</code> of the matrix as a Vector (starting at 0 like an array).  When a block is …\n"],["row_count","Matrix","Matrix.html#method-i-row_count","()","<p>Returns the number of rows.\n"],["row_sep","CSV","CSV.html#method-i-row_sep","()","<p>The encoded <code>:row_sep</code> used in parsing and writing. See CSV::new for details.\n"],["row_separator","CSV::Parser","CSV/Parser.html#method-i-row_separator","()",""],["row_size","Matrix","Matrix.html#method-i-row_size","()",""],["row_vector","Matrix","Matrix.html#method-c-row_vector","(row)","<p>Creates a single-row matrix where the values of that row are as given in <code>row</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Matrix</span>.<span class=\"ruby-identifier\">row_vector</span>([<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>]) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["row_vectors","Matrix","Matrix.html#method-i-row_vectors","()","<p>Returns an array of the row vectors of the matrix.  See Vector.\n"],["rows","Matrix","Matrix.html#method-c-rows","(rows, copy = true)","<p>Creates a matrix where <code>rows</code> is an array of arrays, each of which is a row of the matrix.  If the optional …\n"],["rpartition","String","String.html#method-i-rpartition","(p1)","<p>Searches <em>sep</em> or pattern (<em>regexp</em>) in the string from the end of the string, and returns the part before …\n"],["rr_conflict","Racc::State","Racc/State.html#method-i-rr_conflict","(high, low, ctok)",""],["rrconflict_exist?","Racc::States","Racc/States.html#method-i-rrconflict_exist-3F","()",""],["rruleid","Racc::State","Racc/State.html#method-i-rruleid","(rule)",""],["rset","Net::SMTP","Net/SMTP.html#method-i-rset","()","<p>Aborts the current mail transaction\n"],["rshift!","OpenSSL::BN","OpenSSL/BN.html#method-i-rshift-21","(p1)",""],["rss","RSS::BaseParser","RSS/BaseParser.html#method-i-rss","()",""],["rstrip","String","String.html#method-i-rstrip","()","<p>Returns a copy of the receiver with trailing whitespace removed. See also String#lstrip and String#strip …\n"],["rstrip!","String","String.html#method-i-rstrip-21","()","<p>Removes trailing whitespace from the receiver. Returns the altered receiver, or <code>nil</code> if no change was …\n"],["ruby","Bundler::RubyDsl","Bundler/RubyDsl.html#method-i-ruby","(*ruby_version)",""],["ruby","Gem","Gem.html#method-c-ruby","()","<p>The path to the running Ruby interpreter.\n"],["ruby","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-ruby","(version, options = {})","<p>Restricts this gem dependencies file to the given ruby <code>version</code>.\n<p>You may also provide <code>engine:</code> and <code>engine_version:</code> …\n"],["ruby2_keywords","Module","Module.html#method-i-ruby2_keywords","(*args)","<p>For the given method names, marks the method as passing keywords through a normal argument splat.  This …\n"],["ruby2_keywords","Proc","Proc.html#method-i-ruby2_keywords","()","<p>Marks the proc as passing keywords through a normal argument splat. This should only be called on procs …\n"],["ruby2_keywords_hash","Hash","Hash.html#method-c-ruby2_keywords_hash","(p1)","<p>Duplicates a given hash and adds a ruby2_keywords flag. This method is not for casual use; debugging, …\n"],["ruby2_keywords_hash?","Hash","Hash.html#method-c-ruby2_keywords_hash-3F","(p1)","<p>Checks if a given hash is flagged by Module#ruby2_keywords (or Proc#ruby2_keywords). This method is not …\n"],["ruby=","Gem","Gem.html#method-c-ruby-3D","(ruby)","<p>Allows setting path to Ruby.  This method is available when requiring &#39;rubygems/test_case&#39;\n"],["ruby?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-ruby-3F","()",""],["ruby_api_version","Gem","Gem.html#method-c-ruby_api_version","()","<p>Returns a String containing the API compatibility version of Ruby\n"],["ruby_code","Gem::Specification","Gem/Specification.html#method-i-ruby_code","(obj)","<p>Return a string containing a Ruby code representation of the given object.\n"],["ruby_command","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-ruby_command","()","<p>Return the path to the ruby interpreter taking into account multiple installations and windows extensions. …\n"],["ruby_engine","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-ruby_engine","()",""],["ruby_engine","Gem","Gem.html#method-c-ruby_engine","()",""],["ruby_scope","Bundler","Bundler.html#method-c-ruby_scope","()",""],["ruby_shebang?","Bundler::CLI::Exec","Bundler/CLI/Exec.html#method-i-ruby_shebang-3F","(file)",""],["ruby_version","Bundler::Env","Bundler/Env.html#method-c-ruby_version","()",""],["ruby_version","Gem","Gem.html#method-c-ruby_version","()","<p>A Gem::Version for the currently running Ruby.\n"],["rubybin","Gem::TestCase","Gem/TestCase.html#method-c-rubybin","()","<p>Finds the path to the Ruby executable\n"],["rubygem_push","Bundler::GemHelper","Bundler/GemHelper.html#method-i-rubygem_push","(path)",""],["rubygems","Bundler","Bundler.html#method-c-rubygems","()",""],["rubygems_aggregate_class","Bundler::Plugin::SourceList","Bundler/Plugin/SourceList.html#method-i-rubygems_aggregate_class","()",""],["rubygems_aggregate_class","Bundler::SourceList","Bundler/SourceList.html#method-i-rubygems_aggregate_class","()",""],["rubygems_api_key","Gem::ConfigFile","Gem/ConfigFile.html#method-i-rubygems_api_key","()","<p>Returns the RubyGems.org API key\n"],["rubygems_api_key=","Gem::ConfigFile","Gem/ConfigFile.html#method-i-rubygems_api_key-3D","(api_key)","<p>Sets the RubyGems.org API key to <code>api_key</code>\n"],["rubygems_api_request","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-rubygems_api_request","(method, path, host = nil, allowed_push_host = nil, &block)","<p>Creates an RubyGems API to <code>host</code> and <code>path</code> with the given HTTP <code>method</code>.\n<p>If <code>allowed_push_host</code> metadata is …\n"],["rubygems_dir","Bundler::Plugin::Installer::Rubygems","Bundler/Plugin/Installer/Rubygems.html#method-i-rubygems_dir","()",""],["rubygems_dir","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-rubygems_dir","()",""],["rubygems_primary_remotes","Bundler::SourceList","Bundler/SourceList.html#method-i-rubygems_primary_remotes","()",""],["rubygems_remotes","Bundler::SourceList","Bundler/SourceList.html#method-i-rubygems_remotes","()",""],["rubygems_sources","Bundler::SourceList","Bundler/SourceList.html#method-i-rubygems_sources","()",""],["rubygems_target_version","Gem::Commands::UpdateCommand","Gem/Commands/UpdateCommand.html#method-i-rubygems_target_version","()",""],["rubygems_version","Gem","Gem.html#method-c-rubygems_version","()","<p>A Gem::Version for the currently running RubyGems\n"],["rule","Bundler::Settings::Validator","Bundler/Settings/Validator.html#method-c-rule","(keys, description, &blk)",""],["rule","Racc::Rule","Racc/Rule.html#method-i-rule","()",""],["rule","Racc::Sym","Racc/Sym.html#method-i-rule","()",""],["ruleid","Racc::Reduce","Racc/Reduce.html#method-i-ruleid","()",""],["rules","Bundler::Settings::Validator","Bundler/Settings/Validator.html#method-c-rules","()",""],["run","Bundler::CLI::Add","Bundler/CLI/Add.html#method-i-run","()",""],["run","Bundler::CLI::Binstubs","Bundler/CLI/Binstubs.html#method-i-run","()",""],["run","Bundler::CLI::Cache","Bundler/CLI/Cache.html#method-i-run","()",""],["run","Bundler::CLI::Check","Bundler/CLI/Check.html#method-i-run","()",""],["run","Bundler::CLI::Clean","Bundler/CLI/Clean.html#method-i-run","()",""],["run","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-run","()",""],["run","Bundler::CLI::Console","Bundler/CLI/Console.html#method-i-run","()",""],["run","Bundler::CLI::Doctor","Bundler/CLI/Doctor.html#method-i-run","()",""],["run","Bundler::CLI::Exec","Bundler/CLI/Exec.html#method-i-run","()",""],["run","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-run","()",""],["run","Bundler::CLI::Info","Bundler/CLI/Info.html#method-i-run","()",""],["run","Bundler::CLI::Init","Bundler/CLI/Init.html#method-i-run","()",""],["run","Bundler::CLI::Inject","Bundler/CLI/Inject.html#method-i-run","()",""],["run","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-run","()",""],["run","Bundler::CLI::Issue","Bundler/CLI/Issue.html#method-i-run","()",""],["run","Bundler::CLI::List","Bundler/CLI/List.html#method-i-run","()",""],["run","Bundler::CLI::Lock","Bundler/CLI/Lock.html#method-i-run","()",""],["run","Bundler::CLI::Open","Bundler/CLI/Open.html#method-i-run","()",""],["run","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-run","()",""],["run","Bundler::CLI::Package","Bundler/CLI/Package.html#method-i-run","()",""],["run","Bundler::CLI::Platform","Bundler/CLI/Platform.html#method-i-run","()",""],["run","Bundler::CLI::Pristine","Bundler/CLI/Pristine.html#method-i-run","()",""],["run","Bundler::CLI::Remove","Bundler/CLI/Remove.html#method-i-run","()",""],["run","Bundler::CLI::Show","Bundler/CLI/Show.html#method-i-run","()",""],["run","Bundler::CLI::Update","Bundler/CLI/Update.html#method-i-run","()",""],["run","Bundler::CLI::Viz","Bundler/CLI/Viz.html#method-i-run","()",""],["run","Bundler::Graph::GraphVizClient","Bundler/Graph/GraphVizClient.html#method-i-run","()",""],["run","Bundler::Installer","Bundler/Installer.html#method-i-run","(options)","<p>Runs the install procedures for a specific Gemfile.\n<p>Firstly, this method will check to see if `Bundler.bundle_path` …\n"],["run","Bundler::Retry","Bundler/Retry.html#method-i-run","(&block)",""],["run","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-run","(command, config = {})","<p>Executes a command returning the contents of the command.\n<p>Parameters\n<p>command&lt;String&gt; &mdash; the command …\n"],["run","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-run","(instance, args = [])","<p>By default, a command invokes a method in the thor class. You can change this implementation to create …\n"],["run","Bundler::Thor::Command","Bundler/Thor/Command.html#method-i-run","(instance, args = [])","<p>By default, a command invokes a method in the thor class. You can change this implementation to create …\n"],["run","Bundler::Thor::DynamicCommand","Bundler/Thor/DynamicCommand.html#method-i-run","(instance, args = [])",""],["run","Bundler::Thor::DynamicCommand","Bundler/Thor/DynamicCommand.html#method-i-run","(instance, args = [])",""],["run","DRb::DRbServer","DRb/DRbServer.html#method-i-run","()","<p>Starts the DRb main loop in a new thread.\n"],["run","ERB","ERB.html#method-i-run","(b=new_toplevel)","<p>Generate results and print them. (see ERB#result)\n"],["run","Gem::CommandManager","Gem/CommandManager.html#method-i-run","(args, build_args=nil)","<p>Run the command specified by <code>args</code>.\n"],["run","Gem::Ext::Builder","Gem/Ext/Builder.html#method-c-run","(command, results, command_name = nil)",""],["run","Gem::GemRunner","Gem/GemRunner.html#method-i-run","(args)","<p>Run the gem command with the following arguments.\n"],["run","Gem::Server","Gem/Server.html#method-c-run","(options)",""],["run","Gem::Server","Gem/Server.html#method-i-run","()",""],["run","IRB::Irb","IRB/Irb.html#method-i-run","(conf = IRB.conf)",""],["run","Thread","Thread.html#method-i-run","()","<p>Wakes up <code>thr</code>, making it eligible for scheduling.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">new</span> { <span class=\"ruby-identifier\">puts</span> <span class=\"ruby-string\">&quot;a&quot;</span>; <span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">stop</span>; <span class=\"ruby-identifier\">puts</span> <span class=\"ruby-string\">&quot;c&quot;</span> }\n<span class=\"ruby-identifier\">sleep</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["run","WEBrick::GenericServer","WEBrick/GenericServer.html#method-i-run","(sock)","<p>You must subclass GenericServer and implement #run which accepts a TCP client socket\n"],["run","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-run","(sock)","<p>Processes requests on <code>sock</code>\n"],["run_hooks","Bundler::Source::Path::Installer","Bundler/Source/Path/Installer.html#method-i-run_hooks","(type)",""],["run_ruby_script","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-run_ruby_script","(command, config = {})","<p>Executes a ruby script (taking into account WIN32 platform quirks).\n<p>Parameters\n<p>command&lt;String&gt; &mdash; the …\n"],["running?","Coverage","Coverage.html#method-c-running-3F","()","<p>Returns true if coverage stats are currently being collected (after Coverage.start call, but before  …\n"],["runtime?","Gem::Dependency","Gem/Dependency.html#method-i-runtime-3F","()",""],["runtime_dependencies","Gem::Specification","Gem/Specification.html#method-i-runtime_dependencies","()","<p>List of dependencies that will automatically be activated at runtime.\n"],["runtime_source","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-runtime_source","()",""],["s3_uri_signer","Gem::RemoteFetcher","Gem/RemoteFetcher.html#method-i-s3_uri_signer","(uri)","<p>we have our own signing code here to avoid a dependency on the aws-sdk gem\n"],["safe_delete","Gem::Uninstaller","Gem/Uninstaller.html#method-i-safe_delete","(&block)",""],["safe_level","Thread","Thread.html#method-i-safe_level","()","<p>Returns the safe level.\n<p>This method is obsolete because $SAFE is a process global state. Simply check …\n"],["safe_load","Gem::SafeYAML","Gem/SafeYAML.html#method-c-safe_load","(input)",""],["safe_load","Psych","Psych.html#method-c-safe_load","(yaml, legacy_permitted_classes = NOT_GIVEN, legacy_permitted_symbols = NOT_GIVEN, legacy_aliases = NOT_GIVEN, legacy_filename = NOT_GIVEN, permitted_classes: [], permitted_symbols: [], aliases: false, filename: nil, fallback: nil, symbolize_names: false)","<p>Safely load the yaml string in <code>yaml</code>.  By default, only the following classes are allowed to be deserialized: …\n"],["safe_unlink","Bundler::FileUtils","Bundler/FileUtils.html#method-c-safe_unlink","(list, noop: nil, verbose: nil)",""],["safe_unlink","Bundler::FileUtils","Bundler/FileUtils.html#method-i-safe_unlink","(list, noop: nil, verbose: nil)",""],["safe_unlink","FileUtils","FileUtils.html#method-c-safe_unlink","(list, noop: nil, verbose: nil)",""],["safe_unlink","FileUtils","FileUtils.html#method-i-safe_unlink","(list, noop: nil, verbose: nil)",""],["same_attributes?","Gem::Specification","Gem/Specification.html#method-i-same_attributes-3F","(spec)","<p>True if this gem has the same attributes as <code>other</code>.\n"],["same_feed_type?","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-same_feed_type-3F","(type)",""],["sample","Array","Array.html#method-i-sample","(*args)","<p>Choose a random element or <code>n</code> random elements from the array.\n<p>The elements are chosen by using random and …\n"],["sanitize","Gem::Specification","Gem/Specification.html#method-i-sanitize","()","<p>Sanitize the descriptive fields in the spec.  Sometimes non-ASCII characters will garble the site index. …\n"],["sanitize_path","RDoc::Options","RDoc/Options.html#method-i-sanitize_path","(path)","<p>Removes directories from <code>path</code> that are outside the current directory\n"],["sanitize_string","Gem::Specification","Gem/Specification.html#method-i-sanitize_string","(string)","<p>Sanitize a single string.\n"],["satisfied_by?","Gem::Requirement","Gem/Requirement.html#method-i-satisfied_by-3F","(version)","<p>True if <code>version</code> satisfies this Requirement.\n"],["satisfies?","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-satisfies-3F","(dependency)",""],["satisfies_locked_spec?","Bundler::Definition","Bundler/Definition.html#method-i-satisfies_locked_spec-3F","(dep)",""],["satisfies_requirement?","Gem::Specification","Gem/Specification.html#method-i-satisfies_requirement-3F","(dependency)","<p>Checks if this specification meets the requirement of <code>dependency</code>.\n"],["saturday?","Date","Date.html#method-i-saturday-3F","()","<p>Returns true if the date is Saturday.\n"],["saturday?","Time","Time.html#method-i-saturday-3F","()","<p>Returns <code>true</code> if <em>time</em> represents Saturday.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">2006</span>, <span class=\"ruby-value\">6</span>, <span class=\"ruby-value\">10</span>)      <span class=\"ruby-comment\">#=&gt; 2006-06-10 00:00:00 -0500 ...</span>\n</pre>\n"],["save","RDoc::Store","RDoc/Store.html#method-i-save","()","<p>Saves all entries in the store\n"],["save_cache","RDoc::Store","RDoc/Store.html#method-i-save_cache","()","<p>Writes the cache file for this store\n"],["save_class","RDoc::Store","RDoc/Store.html#method-i-save_class","(klass)","<p>Writes the ri data for <code>klass</code> (or module)\n"],["save_data","PStore","PStore.html#method-i-save_data","(original_checksum, original_file_size, file)",""],["save_data_with_atomic_file_rename_strategy","PStore","PStore.html#method-i-save_data_with_atomic_file_rename_strategy","(data, file)",""],["save_data_with_fast_strategy","PStore","PStore.html#method-i-save_data_with_fast_strategy","(data, file)",""],["save_exception_mode","BigDecimal","BigDecimal.html#method-c-save_exception_mode","()","<p>Execute the provided block, but preserve the exception mode\n\n<pre>BigDecimal.save_exception_mode do\n  BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, ...</pre>\n"],["save_history","IRB::Context","IRB/Context.html#method-i-save_history","()","<p>A copy of the default <code>IRB.conf[:SAVE_HISTORY]</code>\n"],["save_history=","IRB::Context","IRB/Context.html#method-i-save_history-3D","(val)","<p>Sets <code>IRB.conf[:SAVE_HISTORY]</code> to the given <code>val</code> and calls #init_save_history with this context.\n<p>Will store …\n"],["save_index","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-save_index","()","<p>Should be called when any of the instance variables change. Stores the instance variables in YAML format. …\n"],["save_limit","BigDecimal","BigDecimal.html#method-c-save_limit","()","<p>Execute the provided block, but preserve the precision limit\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BigDecimal</span>.<span class=\"ruby-identifier\">limit</span>(<span class=\"ruby-value\">100</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-constant\">BigDecimal</span>.<span class=\"ruby-identifier\">limit</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["save_loaded_features","Gem::TestCase","Gem/TestCase.html#method-i-save_loaded_features","()",""],["save_method","RDoc::Store","RDoc/Store.html#method-i-save_method","(klass, method)","<p>Writes the ri data for <code>method</code> on <code>klass</code>\n"],["save_page","RDoc::Store","RDoc/Store.html#method-i-save_page","(page)","<p>Writes the ri data for <code>page</code>\n"],["save_plugins","Bundler::Plugin","Bundler/Plugin.html#method-i-save_plugins","(plugins, specs, optional_plugins = [])","<p>Post installation processing and registering with index\n<p>@param [Array&lt;String&gt;] plugins list to be …\n"],["save_rounding_mode","BigDecimal","BigDecimal.html#method-c-save_rounding_mode","()","<p>Execute the provided block, but preserve the rounding mode\n\n<pre>BigDecimal.save_rounding_mode do\n  BigDecimal.mode(BigDecimal::ROUND_MODE, ...</pre>\n"],["say","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-say","(message = \"\", color = nil, force_new_line = (message.to_s !~ /( |\\t)\\Z/))","<p>Say (print) something to the user. If the sentence ends with a whitespace or tab character, a new line …\n"],["say","Bundler::UI::RGProxy","Bundler/UI/RGProxy.html#method-i-say","(message)",""],["say","Gem::StreamUI","Gem/StreamUI.html#method-i-say","(statement=\"\")","<p>Display a statement.\n"],["say","Gem::UserInteraction","Gem/UserInteraction.html#method-i-say","(statement = '')","<p>Displays the given <code>statement</code> on the standard output (or equivalent).\n"],["say_status","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-say_status","(status, message, log_status = true)","<p>Say a status with the given color and appends the message. Since this method is used frequently by actions, …\n"],["scalar","Matrix","Matrix.html#method-c-scalar","(n, value)","<p>Creates an <code>n</code> by <code>n</code> diagonal matrix where each diagonal element is <code>value</code>.\n\n<pre>Matrix.scalar(2, 5)\n  =&gt; 5 0\n ...</pre>\n"],["scalar","Psych::Coder","Psych/Coder.html#method-i-scalar","(*args)",""],["scalar","Psych::Emitter","Psych/Emitter.html#method-i-scalar","(p1, p2, p3, p4, p5, p6)","<p>Emit a scalar with <code>value</code>, <code>anchor</code>, <code>tag</code>, and a <code>plain</code> or <code>quoted</code> string type with <code>style</code>.\n<p>See Psych::Handler#scalar …\n"],["scalar","Psych::Handler","Psych/Handler.html#method-i-scalar","(value, anchor, tag, plain, quoted, style)","<p>Called when a scalar <code>value</code> is found.  The scalar may have an <code>anchor</code>, a <code>tag</code>, be implicitly <code>plain</code> or implicitly …\n"],["scalar","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-scalar","(value, anchor, tag, plain, quoted, style)",""],["scalar=","Psych::Coder","Psych/Coder.html#method-i-scalar-3D","(value)","<p>Emit a scalar with <code>value</code>\n"],["scalar?","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-scalar-3F","()",""],["scalar?","Psych::Nodes::Scalar","Psych/Nodes/Scalar.html#method-i-scalar-3F","()",""],["scan","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-scan","(pattern)",""],["scan","IRB::Color","IRB/Color.html#method-c-scan","(code, allow_last_error:)",""],["scan","OpenSSL::X509::Name::RFC2253DN","OpenSSL/X509/Name/RFC2253DN.html#method-i-scan","(dn)",""],["scan","RDoc::Parser::C","RDoc/Parser/C.html#method-i-scan","()","<p>Extracts the classes, modules, methods, attributes, constants and aliases from a C file and returns an …\n"],["scan","RDoc::Parser::ChangeLog","RDoc/Parser/ChangeLog.html#method-i-scan","()","<p>Converts the ChangeLog into an RDoc::Markup::Document\n"],["scan","RDoc::Parser::Markdown","RDoc/Parser/Markdown.html#method-i-scan","()","<p>Creates an Markdown-format TopLevel for the given file.\n"],["scan","RDoc::Parser::RD","RDoc/Parser/RD.html#method-i-scan","()","<p>Creates an rd-format TopLevel for the given file.\n"],["scan","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-scan","()","<p>Scans this Ruby file for Ruby constructs\n"],["scan","RDoc::Parser::Simple","RDoc/Parser/Simple.html#method-i-scan","()","<p>Extract the file contents and attach them to the TopLevel as a comment\n"],["scan","REXML::IOSource","REXML/IOSource.html#method-i-scan","(pattern, cons=false)",""],["scan","REXML::Source","REXML/Source.html#method-i-scan","(pattern, cons=false)","<p>Scans the source for a given pattern.  Note, that this is not your usual scan() method.  For one thing, …\n"],["scan","String","String.html#method-i-scan","(p1)","<p>Both forms iterate through <em>str</em>, matching the pattern (which may be a Regexp or a String). For each match, …\n"],["scan","StringScanner","StringScanner.html#method-i-scan","(p1)","<p>Tries to match with <code>pattern</code> at the current position. If there&#39;s a match, the scanner advances the …\n"],["scan_action","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-scan_action","()",""],["scan_all","CSV::Parser::InputsScanner","CSV/Parser/InputsScanner.html#method-i-scan_all","(pattern)",""],["scan_error!","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-scan_error-21","(msg)",""],["scan_full","StringScanner","StringScanner.html#method-i-scan_full","(p1, p2, p3)","<p>Tests whether the given <code>pattern</code> is matched from the current scan pointer. Advances the scan pointer if …\n"],["scan_make_command_lines","Gem::TestCase","Gem/TestCase.html#method-i-scan_make_command_lines","(output)",""],["scan_quoted","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-scan_quoted","(left, tag = 'string')",""],["scan_token","IRB::Color::SymbolState","IRB/Color/SymbolState.html#method-i-scan_token","(token)","<p>Return true if the token is a part of Symbol.\n"],["scan_until","StringScanner","StringScanner.html#method-i-scan_until","(p1)","<p>Scans the string <em>until</em> the <code>pattern</code> is matched.  Returns the substring up to and including the end of …\n"],["scheme=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-scheme-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["scheme=","URI::Generic","URI/Generic.html#method-i-scheme-3D","(v)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["scheme_list","Bundler::URI","Bundler/URI.html#method-c-scheme_list","()","<p>Returns a Hash of the defined schemes.\n"],["scheme_list","URI","URI.html#method-c-scheme_list","()","<p>Returns a Hash of the defined schemes.\n"],["scope","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-scope","()","<p>Returns scope.\n"],["scope","URI::LDAP","URI/LDAP.html#method-i-scope","()","<p>Returns scope.\n"],["scope=","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-scope-3D","(val)","<p>Setter for scope <code>val</code>.\n"],["scope=","URI::LDAP","URI/LDAP.html#method-i-scope-3D","(val)","<p>Setter for scope <code>val</code>.\n"],["scope_options","Bundler::CLI::Config","Bundler/CLI/Config.html#method-c-scope_options","()",""],["scroll_backward","IO","IO.html#method-i-scroll_backward","(p1)",""],["scroll_forward","IO","IO.html#method-i-scroll_forward","(p1)",""],["scrolling_list","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-scrolling_list","(name = \"\", *values)",""],["scrub","String","String.html#method-i-scrub","(*args)","<p>If the string is invalid byte sequence then replace invalid bytes with given replacement character, else …\n"],["scrub!","String","String.html#method-i-scrub-21","(*args)","<p>If the string is invalid byte sequence then replace invalid bytes with given replacement character, else …\n"],["scrypt","OpenSSL::KDF","OpenSSL/KDF.html#method-c-scrypt","(p1, p2 = {})","<p>Derives a key from <em>pass</em> using given parameters with the scrypt password-based key derivation function. …\n"],["search","Bundler::Index","Bundler/Index.html#method-i-search","(query, base = nil)","<p>Search this index&#39;s specs, and any source indexes that this index knows about, returning all of the …\n"],["search","IRB::JobManager","IRB/JobManager.html#method-i-search","(key)","<p>Returns the associated job for the given <code>key</code>.\n<p>If given an Integer, it will return the <code>key</code> index for the …\n"],["search","Net::IMAP","Net/IMAP.html#method-i-search","(keys, charset = nil)","<p>Sends a SEARCH command to search the mailbox for messages that match the given searching criteria, and …\n"],["search","OptionParser","OptionParser.html#method-i-search","(id, key)","<p>Searches <code>key</code> in @stack for <code>id</code> hash and returns or yields the result.\n"],["search","OptionParser::List","OptionParser/List.html#method-i-search","(id, key)","<p>Searches <code>key</code> in <code>id</code> list. The result is returned or yielded if a block is given. If it isn&#39;t found, …\n"],["search_all","Bundler::Index","Bundler/Index.html#method-i-search_all","(name)",""],["search_by_dependency","Bundler::Index","Bundler/Index.html#method-i-search_by_dependency","(dependency, base = nil)",""],["search_by_spec","Bundler::Index","Bundler/Index.html#method-i-search_by_spec","(spec)",""],["search_const","OptionParser","OptionParser.html#method-c-search_const","(klass, name)",""],["search_convpath","Encoding::Converter","Encoding/Converter.html#method-c-search_convpath","(*args)","<p>Returns a conversion path.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Converter</span>.<span class=\"ruby-identifier\">search_convpath</span>(<span class=\"ruby-string\">&quot;ISO-8859-1&quot;</span>, <span class=\"ruby-string\">&quot;EUC-JP&quot;</span>)\n<span class=\"ruby-comment\">#=&gt; [[#&lt;Encoding:ISO-8859-1&gt;, ...</span>\n</pre>\n"],["search_file","IRB::Locale","IRB/Locale.html#method-i-search_file","(lib_paths, dir, file)","<p>@param paths load paths in which IRB find a localized file. @param dir directory @param file basename …\n"],["search_for","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-search_for","(dependency)","<p>(see Bundler::Molinillo::SpecificationProvider#search_for)\n"],["search_for","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-search_for","(dependency)","<p>Search for the specifications that match the given dependency. The specifications in the returned array …\n"],["search_for","Bundler::Resolver","Bundler/Resolver.html#method-i-search_for","(dependency)",""],["search_for","Gem::Resolver","Gem/Resolver.html#method-i-search_for","(dependency)",""],["search_for","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-search_for","(dependency)","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#search_for)\n"],["search_for","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-search_for","(dependency)","<p>Search for the specifications that match the given dependency. The specifications in the returned array …\n"],["search_for_dependency","Gem::SpecFetcher","Gem/SpecFetcher.html#method-i-search_for_dependency","(dependency, matching_platform=true)","<p>Find and fetch gem name tuples that match <code>dependency</code>.\n<p>If <code>matching_platform</code> is false, gems for all platforms …\n"],["search_full","StringScanner","StringScanner.html#method-i-search_full","(p1, p2, p3)","<p>Scans the string <em>until</em> the <code>pattern</code> is matched. Advances the scan pointer if <code>advance_pointer_p</code>, otherwise …\n"],["search_internal","Net::IMAP","Net/IMAP.html#method-i-search_internal","(cmd, keys, charset)",""],["search_record","RDoc::ClassModule","RDoc/ClassModule.html#method-i-search_record","()","<p>Search record used by RDoc::Generator::JsonIndex\n"],["search_record","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-search_record","()","<p>Used by RDoc::Generator::JsonIndex to create a record for the search engine.\n"],["search_record","RDoc::TopLevel","RDoc/TopLevel.html#method-i-search_record","()","<p>Search record used by RDoc::Generator::JsonIndex\n"],["search_servlet","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-search_servlet","(path)","<p>Finds a servlet for <code>path</code>\n"],["search_up","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-search_up","(*names)",""],["searcher=","Gem","Gem.html#method-c-searcher-3D","(searcher)","<p>Allows setting the gem path searcher.  This method is available when requiring &#39;rubygems/test_case&#39; …\n"],["sec","Date","Date.html#method-i-sec","()",""],["sec","DateTime","DateTime.html#method-i-sec","()","<p>Returns the second (0-59).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">sec</span>          <span class=\"ruby-comment\">#=&gt; 6</span>\n</pre>\n"],["sec","Time","Time.html#method-i-sec","()","<p>Returns the second of the minute (0..60) for <em>time</em>.\n<p><strong>Note:</strong> Seconds range from zero to 60 to allow the system …\n"],["sec_fraction","DateTime","DateTime.html#method-i-sec_fraction","()","<p>Returns the fractional part of the second.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6.5</span>).<span class=\"ruby-identifier\">sec_fraction</span>       <span class=\"ruby-comment\">#=&gt; (1/2)</span>\n</pre>\n"],["second","Date","Date.html#method-i-second","()",""],["second","DateTime","DateTime.html#method-i-second","()","<p>Returns the second (0-59).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">sec</span>          <span class=\"ruby-comment\">#=&gt; 6</span>\n</pre>\n"],["second=","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-second-3D","(second)",""],["second=","RSS::Maker::ITunesItemModel::ITunesDurationBase","RSS/Maker/ITunesItemModel/ITunesDurationBase.html#method-i-second-3D","(second)",""],["second_fraction","DateTime","DateTime.html#method-i-second_fraction","()","<p>Returns the fractional part of the second.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6.5</span>).<span class=\"ruby-identifier\">sec_fraction</span>       <span class=\"ruby-comment\">#=&gt; (1/2)</span>\n</pre>\n"],["seconds_to_components","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-c-seconds_to_components","(total_seconds)",""],["section","RDoc::CodeObject","RDoc/CodeObject.html#method-i-section","()","<p>The section this CodeObject is in.  Sections allow grouping of constants, attributes and methods inside …\n"],["section_contents","RDoc::Context","RDoc/Context.html#method-i-section_contents","()","<p>Returns RDoc::Context::Section objects referenced in this context for use in a table of contents.\n"],["sections","OpenSSL::Config","OpenSSL/Config.html#method-i-sections","()","<p>Get the names of all sections in the current configuration\n"],["sections","RDoc::Context","RDoc/Context.html#method-i-sections","()","<p>Sections in this context\n"],["sections_in_lockfile","Bundler::LockfileParser","Bundler/LockfileParser.html#method-c-sections_in_lockfile","(lockfile_contents)",""],["sections_to_ignore","Bundler::LockfileParser","Bundler/LockfileParser.html#method-c-sections_to_ignore","(base_version = nil)",""],["secure=","CGI::Cookie","CGI/Cookie.html#method-i-secure-3D","(val)","<p>Set whether the Cookie is a secure cookie or not.\n<p><code>val</code> must be a boolean.\n"],["security_level","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-security_level","()","<p>Returns the security level for the context.\n<p>See also OpenSSL::SSL::SSLContext#security_level=.\n"],["security_level=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-security_level-3D","(p1)","<p>Sets the security level for the context. OpenSSL limits parameters according to the level. The “parameters” …\n"],["security_policies","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-security_policies","()",""],["security_policy_keys","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-security_policy_keys","()",""],["see","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-see","()","<p>A method/attribute to look at, in particular if this method/attribute has no documentation.\n<p>It can be …\n"],["seed","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-seed","()","<p>See the OpenSSL documentation for EC_GROUP_get0_seed()\n"],["seed","OpenSSL::Random","OpenSSL/Random.html#method-c-seed","(p1)","<p>::seed is equivalent to ::add where <em>entropy</em> is length of <em>str</em>.\n"],["seed","Random","Random.html#method-i-seed","()","<p>Returns the seed value used to initialize the generator. This may be used to initialize another generator …\n"],["seed=","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-seed-3D","(p1)","<p>See the OpenSSL documentation for EC_GROUP_set_seed()\n"],["seek","ARGF","ARGF.html#method-i-seek","(*args)","<p>Seeks to offset <em>amount</em> (an <code>Integer</code>) in the <code>ARGF</code> stream according to the value of <em>whence</em>. See IO#seek …\n"],["seek","Dir","Dir.html#method-i-seek","(p1)","<p>Seeks to a particular location in <em>dir</em>. <em>integer</em> must be a value returned by Dir#tell.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testdir&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["seek","Gem::Package::TarReader","Gem/Package/TarReader.html#method-i-seek","(name)","<p>Seeks through the tar file until it finds the <code>entry</code> with <code>name</code> and yields it.  Rewinds the tar file to …\n"],["seek","IO","IO.html#method-i-seek","(p1, p2 = v2)","<p>Seeks to a given offset <em>anInteger</em> in the stream according to the value of <em>whence</em>:\n\n<pre class=\"ruby\"><span class=\"ruby-value\">:CUR</span> <span class=\"ruby-keyword\">or</span> <span class=\"ruby-constant\">IO</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">SEEK_CUR</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["seek","StringIO","StringIO.html#method-i-seek","(p1, p2 = v2)","<p>Seeks to a given offset <em>amount</em> in the stream according to the value of <em>whence</em> (see IO#seek).\n"],["segments_do_not_match","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-segments_do_not_match","(level)",""],["select","Array","Array.html#method-i-select","()","<p>Returns a new array containing all elements of <code>ary</code> for which the given <code>block</code> returns a true value.\n<p>If …\n"],["select","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-select","(*components)","<p>Args\n<p><code>components</code> &mdash; Multiple Symbol arguments defined in Bundler::URI::HTTP.\n\n<p>Description\n"],["select","DBM","DBM.html#method-i-select","()","<p>Returns a new array consisting of the [key, value] pairs for which the code block returns true.\n"],["select","ENV","ENV.html#method-c-select","()","<p>Returns a copy of the environment for entries where the block returns true.\n<p>Returns an Enumerator if no …\n"],["select","Enumerable","Enumerable.html#method-i-select","()","<p>Returns an array containing all elements of <code>enum</code> for which the given <code>block</code> returns a true value.\n<p>The  …\n"],["select","Enumerator::Lazy","Enumerator/Lazy.html#method-i-select","()","<p>Like Enumerable#select, but chains operation to be lazy-evaluated.\n"],["select","GDBM","GDBM.html#method-i-select","()","<p>Returns a new array of all key-value pairs of the database for which <em>block</em> evaluates to true.\n"],["select","Hash","Hash.html#method-i-select","()","<p>Returns a new hash consisting of entries for which the block returns true.\n<p>If no block is given, an enumerator …\n"],["select","IO","IO.html#method-c-select","(p1, p2 = v2, p3 = v3, p4 = v4)","<p>Calls select(2) system call. It monitors given arrays of IO objects, waits until one or more of IO objects …\n"],["select","Kernel","Kernel.html#method-i-select","(p1, p2 = v2, p3 = v3, p4 = v4)","<p>Calls select(2) system call. It monitors given arrays of IO objects, waits until one or more of IO objects …\n"],["select","Net::IMAP","Net/IMAP.html#method-i-select","(mailbox)","<p>Sends a SELECT command to select a <code>mailbox</code> so that messages in the <code>mailbox</code> can be accessed.\n<p>After you …\n"],["select","SDBM","SDBM.html#method-i-select","()","<p>Returns a new Array of key-value pairs for which the block returns <code>true</code>.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;sdbm&#39;</span>\n\n<span class=\"ruby-constant\">SDBM</span>.<span class=\"ruby-identifier\">open</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["select","Struct","Struct.html#method-i-select","(*args)","<p>Yields each member value from the struct to the block and returns an Array containing the member values …\n"],["select","URI::Generic","URI/Generic.html#method-i-select","(*components)","<p>Args\n<p><code>components</code> &mdash; Multiple Symbol arguments defined in URI::HTTP.\n\n<p>Description\n"],["select","YAML::DBM","YAML/DBM.html#method-i-select","( *keys )","<p>If a block is provided, returns a new array containing [key, value] pairs for which the block returns …\n"],["select!","Array","Array.html#method-i-select-21","()","<p>Invokes the given block passing in successive elements from <code>self</code>, deleting elements for which the block …\n"],["select!","ENV","ENV.html#method-c-select-21","()","<p>Equivalent to ENV.keep_if but returns <code>nil</code> if no changes were made.\n<p>ENV.filter! is an alias for ENV.select! …\n"],["select!","Hash","Hash.html#method-i-select-21","()","<p>Equivalent to Hash#keep_if, but returns <code>nil</code> if no changes were made.\n<p>Hash#filter! is an alias for Hash#select! …\n"],["select!","Set","Set.html#method-i-select-21","(&block)","<p>Equivalent to Set#keep_if, but returns nil if no changes were made. Returns an enumerator if no block …\n"],["select_best_platform_match","Bundler::GemHelpers","Bundler/GemHelpers.html#method-i-select_best_platform_match","(specs, platform)",""],["select_best_platform_match","Bundler::GemHelpers","Bundler/GemHelpers.html#method-c-select_best_platform_match","(specs, platform)",""],["select_spec","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-select_spec","(name, regex_match = nil)",""],["self","TracePoint","TracePoint.html#method-i-self","()","<p>Return the trace object during event\n<p>Same as TracePoint#binding:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">trace</span>.<span class=\"ruby-identifier\">binding</span>.<span class=\"ruby-identifier\">eval</span>(<span class=\"ruby-string\">&#39;self&#39;</span>)\n</pre>\n"],["self_null?","Racc::Sym","Racc/Sym.html#method-i-self_null-3F","()",""],["send","BasicSocket","BasicSocket.html#method-i-send","(p1, p2, p3 = v3)","<p>send <em>mesg</em> via <em>basicsocket</em>.\n<p><em>mesg</em> should be a string.\n<p><em>flags</em> should be a bitwise OR of Socket::MSG_* constants. …\n"],["send","Object","Object.html#method-i-send","(*args)","<p>Invokes the method identified by <em>symbol</em>, passing it any arguments specified. You can use <code>__send__</code> if …\n"],["send","REXML::Functions","REXML/Functions.html#method-c-send","(name, *args)",""],["send","UDPSocket","UDPSocket.html#method-i-send","(p1, p2, p3, p4)","<p>Sends <em>mesg</em> via <em>udpsocket</em>.\n<p><em>flags</em> should be a bitwise OR of Socket::MSG_* constants.\n\n<pre>u1 = UDPSocket.new\nu1.bind(&quot;127.0.0.1&quot;, ...</pre>\n"],["send_command","Net::IMAP","Net/IMAP.html#method-i-send_command","(cmd, *args, &block)",""],["send_data","Net::IMAP","Net/IMAP.html#method-i-send_data","(data, tag = nil)",""],["send_entity","Net::HTTP","Net/HTTP.html#method-i-send_entity","(path, data, initheader, dest, type, &block)","<p>Executes a request which uses a representation and returns its body.\n"],["send_gem","Gem::Commands::PushCommand","Gem/Commands/PushCommand.html#method-i-send_gem","(name)",""],["send_io","UNIXSocket","UNIXSocket.html#method-i-send_io","(p1)","<p>Sends <em>io</em> as file descriptor passing.\n\n<pre>s1, s2 = UNIXSocket.pair\n\ns1.send_io STDOUT\nstdout = s2.recv_io\n ...</pre>\n"],["send_list_data","Net::IMAP","Net/IMAP.html#method-i-send_list_data","(list, tag = nil)",""],["send_literal","Net::IMAP","Net/IMAP.html#method-i-send_literal","(str, tag = nil)",""],["send_mail","Net::SMTP","Net/SMTP.html#method-i-send_mail","(msgstr, from_addr, *to_addrs)",""],["send_message","Net::SMTP","Net/SMTP.html#method-i-send_message","(msgstr, from_addr, *to_addrs)","<p>Sends <code>msgstr</code> as a message.  Single CR (“r”) and LF (“n”) found in the <code>msgstr</code>, are …\n"],["send_number_data","Net::IMAP","Net/IMAP.html#method-i-send_number_data","(num)",""],["send_owner_request","Gem::Commands::OwnerCommand","Gem/Commands/OwnerCommand.html#method-i-send_owner_request","(method, name, owner)",""],["send_push_request","Gem::Commands::PushCommand","Gem/Commands/PushCommand.html#method-i-send_push_request","(name, args)",""],["send_quoted_string","Net::IMAP","Net/IMAP.html#method-i-send_quoted_string","(str)",""],["send_request","Net::HTTP","Net/HTTP.html#method-i-send_request","(name, path, data = nil, header = nil)","<p>Sends an HTTP request to the HTTP server. Also sends a DATA string if <code>data</code> is given.\n<p>Returns a Net::HTTPResponse …\n"],["send_request_with_body","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-send_request_with_body","(sock, ver, path, body)",""],["send_request_with_body_data","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-send_request_with_body_data","(sock, ver, path, params)",""],["send_request_with_body_stream","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-send_request_with_body_stream","(sock, ver, path, f)",""],["send_string_data","Net::IMAP","Net/IMAP.html#method-i-send_string_data","(str, tag = nil)",""],["send_symbol_data","Net::IMAP","Net/IMAP.html#method-i-send_symbol_data","(symbol)",""],["send_time_data","Net::IMAP","Net/IMAP.html#method-i-send_time_data","(time)",""],["sendcmd","Net::FTP","Net/FTP.html#method-i-sendcmd","(cmd)","<p>Sends a command and returns the response.\n"],["sender","IRB::Frame","IRB/Frame.html#method-c-sender","()","<p>Returns the binding context of the caller from the last frame initialized\n"],["sendmail","Net::SMTP","Net/SMTP.html#method-i-sendmail","(msgstr, from_addr, *to_addrs)",""],["sendmsg","BasicSocket","BasicSocket.html#method-i-sendmsg","(mesg, flags = 0, dest_sockaddr = nil, *controls)","<p>sendmsg sends a message using sendmsg(2) system call in blocking manner.\n<p><em>mesg</em> is a string to send.\n<p><em>flags</em> …\n"],["sendmsg_nonblock","BasicSocket","BasicSocket.html#method-i-sendmsg_nonblock","(mesg, flags = 0, dest_sockaddr = nil, *controls, exception: true)","<p>sendmsg_nonblock sends a message using sendmsg(2) system call in non-blocking manner.\n<p>It is similar to …\n"],["separated_by","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-separated_by","(sep, sym, &block)",""],["separated_by1","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-separated_by1","(sep, sym, &block)",""],["separator","OptionParser","OptionParser.html#method-i-separator","(string)","<p>Add separator in summary.\n"],["seplist","PP::PPMethods","PP/PPMethods.html#method-i-seplist","(list, sep=nil, iter_method=:each)","<p>Adds a separated list. The list is separated by comma with breakable space, by default.\n<p>#seplist iterates …\n"],["seq","Racc::Grammar::DefinitionEnv","Racc/Grammar/DefinitionEnv.html#method-i-seq","(*list, &block)",""],["seq=","Psych::Coder","Psych/Coder.html#method-i-seq-3D","(list)","<p>Emit a sequence of <code>list</code>\n"],["sequence?","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-sequence-3F","()",""],["sequence?","Psych::Nodes::Sequence","Psych/Nodes/Sequence.html#method-i-sequence-3F","()",""],["sequential_execution_mode!","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-sequential_execution_mode-21","()",""],["sequentially","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-sequentially","()",""],["serial","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-serial","()","<p>Returns the serial number of the certificate for which status is being requested.\n"],["serial","OpenSSL::PKCS7::RecipientInfo","OpenSSL/PKCS7/RecipientInfo.html#method-i-serial","()",""],["serial","OpenSSL::PKCS7::SignerInfo","OpenSSL/PKCS7/SignerInfo.html#method-i-serial","()",""],["serial","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-serial","()",""],["serial","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-serial","()",""],["serial=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-serial-3D","(p1)",""],["serial=","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-serial-3D","(p1)",""],["serial_compact_index_client","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-serial_compact_index_client","()",""],["serialize","Racc::Sym","Racc/Sym.html#method-i-serialize","()",""],["serialize_gemspecs_in","Bundler::Source::Git","Bundler/Source/Git.html#method-i-serialize_gemspecs_in","(destination)",""],["serialize_integer_list_compressed","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-serialize_integer_list_compressed","(name, table)",""],["serialize_integer_list_std","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-serialize_integer_list_std","(name, table)",""],["server_error?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-i-server_error-3F","(code)","<p>Is <code>code</code> a server error status?\n"],["server_error?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-server_error-3F","(code)","<p>Is <code>code</code> a server error status?\n"],["server_name","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-server_name","()","<p>The server name this request is for\n"],["service","DRb::ExtServManager","DRb/ExtServManager.html#method-i-service","(name)",""],["service","WEBrick::CGI","WEBrick/CGI.html#method-i-service","(req, res)","<p>Services the request <code>req</code> which will fill in the response <code>res</code>.  See WEBrick::HTTPServlet::AbstractServlet#service …\n"],["service","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-service","(req, res)","<p>Services <code>req</code> and fills in <code>res</code>\n"],["service","WEBrick::HTTPServlet::AbstractServlet","WEBrick/HTTPServlet/AbstractServlet.html#method-i-service","(req, res)","<p>Dispatches to a <code>do_</code> method based on <code>req</code> if such a method is available.  (<code>do_GET</code> for a GET request).  …\n"],["session","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-session","()","<p>Returns the SSLSession object currently used, or nil if the session is not established.\n"],["session=","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-session-3D","(p1)","<p>Sets the Session to be used when the connection is established.\n"],["session_add","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-session_add","(p1)","<p>Adds <em>session</em> to the session cache.\n"],["session_cache_mode","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-session_cache_mode","()","<p>The current session cache mode.\n"],["session_cache_mode=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-session_cache_mode-3D","(p1)","<p>Sets the SSL session cache mode.  Bitwise-or together the desired SESSION_CACHE_* constants to set.  …\n"],["session_cache_size","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-session_cache_size","()","<p>Returns the current session cache size.  Zero is used to represent an unlimited cache size.\n"],["session_cache_size=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-session_cache_size-3D","(p1)","<p>Sets the session cache size.  Returns the previously valid session cache size.  Zero is used to represent …\n"],["session_cache_stats","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-session_cache_stats","()","<p>Returns a Hash containing the following keys:\n<p>:accept &mdash; Number of started SSL/TLS handshakes in server mode …\n"],["session_get_cb","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-session_get_cb","()",""],["session_new_cb","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-session_new_cb","()",""],["session_remove","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-session_remove","(p1)","<p>Removes <em>session</em> from the session cache.\n"],["session_reused?","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-session_reused-3F","()","<p>Returns <code>true</code> if a reused session was negotiated during the handshake.\n"],["set","Bundler::CLI::Config","Bundler/CLI/Config.html#method-i-set","(name, value, *value_)",""],["set","Bundler::Settings::Validator::Rule","Bundler/Settings/Validator/Rule.html#method-i-set","(settings, key, value, *reasons)",""],["set","IPAddr","IPAddr.html#method-i-set","(addr, *family)","<p>Set +@addr+, the internal stored ip address, to given <code>addr</code>. The parameter <code>addr</code> is validated using the …\n"],["set_accept","Racc::States","Racc/States.html#method-i-set_accept","()","<p>complete\n"],["set_api_key","Gem::ConfigFile","Gem/ConfigFile.html#method-i-set_api_key","(host, api_key)","<p>Set a specific host&#39;s API key to <code>api_key</code>\n"],["set_api_key","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-set_api_key","(host, key)","<p>Returns true when the user has enabled multifactor authentication from <code>response</code> text and no otp provided …\n"],["set_attributes","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-set_attributes","(val)","<p>Private setter for attributes <code>val</code>.\n"],["set_attributes","URI::LDAP","URI/LDAP.html#method-i-set_attributes","(val)","<p>Private setter for attributes <code>val</code>.\n"],["set_backtrace","Exception","Exception.html#method-i-set_backtrace","(p1)","<p>Sets the backtrace information associated with <code>exc</code>. The <code>backtrace</code> must be an array of String objects …\n"],["set_backtrace","OptionParser::ParseError","OptionParser/ParseError.html#method-i-set_backtrace","(array)",""],["set_bit!","OpenSSL::BN","OpenSSL/BN.html#method-i-set_bit-21","(p1)",""],["set_bundle_environment","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-set_bundle_environment","()",""],["set_bundle_variables","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-set_bundle_variables","()",""],["set_close_on_exec","WEBrick::Utils","WEBrick/Utils.html#method-c-set_close_on_exec","(io)","<p>Sets the close on exec flag for <code>io</code>\n"],["set_close_on_exec","WEBrick::Utils","WEBrick/Utils.html#method-i-set_close_on_exec","(io)","<p>Sets the close on exec flag for <code>io</code>\n"],["set_col_range","Matrix","Matrix.html#method-i-set_col_range","(row, col_range, value)",""],["set_color","Bundler::Thor::Shell::Color","Bundler/Thor/Shell/Color.html#method-i-set_color","(string, *colors)","<p>Set color by using a string or one of the defined constants. If a third option is set to true, it also …\n"],["set_color","Bundler::Thor::Shell::HTML","Bundler/Thor/Shell/HTML.html#method-i-set_color","(string, *colors)","<p>Set color by using a string or one of the defined constants. If a third option is set to true, it also …\n"],["set_column_vector","Matrix","Matrix.html#method-i-set_column_vector","(row_range, col, value)",""],["set_command_option","Bundler::Settings","Bundler/Settings.html#method-i-set_command_option","(key, value)",""],["set_command_option_if_given","Bundler::Settings","Bundler/Settings.html#method-i-set_command_option_if_given","(key, value)",""],["set_component","Matrix","Matrix.html#method-i-set_component","(i, j, v)",""],["set_component","Vector","Vector.html#method-i-set_component","(i, v)",""],["set_config_file_name","Gem::ConfigFile","Gem/ConfigFile.html#method-i-set_config_file_name","(args)",""],["set_constant_visibility_for","RDoc::Context","RDoc/Context.html#method-i-set_constant_visibility_for","(names, visibility)","<p>Given an array <code>names</code> of constants, set the visibility of each constant to <code>visibility</code>\n"],["set_content_type","Net::HTTPHeader","Net/HTTPHeader.html#method-i-set_content_type","(type, params = {})","<p>Sets the content type in an HTTP header. The <code>type</code> should be a full HTTP content type, e.g. “text/html”. …\n"],["set_crt_params","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-set_crt_params","(p1, p2, p3)","<p>Sets <em>dmp1</em>, <em>dmq1</em>, <em>iqmp</em> for the RSA instance. They are calculated by <code>d mod (p - 1)</code>, <code>d mod (q - 1)</code> and  …\n"],["set_ctypes","Fiddle::CStructEntity","Fiddle/CStructEntity.html#method-i-set_ctypes","(types)","<p>Calculates the offsets and sizes for the given <code>types</code> in the struct.\n"],["set_ctypes","Fiddle::CUnionEntity","Fiddle/CUnionEntity.html#method-i-set_ctypes","(types)","<p>Calculate the necessary offset and for each union member with the given <code>types</code>\n"],["set_current_section","RDoc::Context","RDoc/Context.html#method-i-set_current_section","(title, comment)","<p>Sets the current section to a section with <code>title</code>.  See also #add_section\n"],["set_debug_output","Net::HTTP","Net/HTTP.html#method-i-set_debug_output","(output)","<p><strong>WARNING</strong> This method opens a serious security hole. Never use this method in production code.\n<p>Sets an output …\n"],["set_debug_output","Net::POP3","Net/POP3.html#method-i-set_debug_output","(arg)","<p><strong>WARNING</strong>: This method causes a serious security hole. Use this method only for debugging.\n<p>Set an output …\n"],["set_debug_output","Net::SMTP","Net/SMTP.html#method-i-set_debug_output","(arg)",""],["set_default","OpenSSL::Engine","OpenSSL/Engine.html#method-i-set_default","(p1)","<p>Set the defaults for this engine with the given <em>flag</em>.\n<p>These flags are used to control combinations of …\n"],["set_default_paths","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-set_default_paths","()","<p>Configures <em>store</em> to look up CA certificates from the system default certificate store as needed basis. …\n"],["set_default_values","RSS::Maker::Base","RSS/Maker/Base.html#method-i-set_default_values","(&block)",""],["set_dictionary","Zlib::Deflate","Zlib/Deflate.html#method-i-set_dictionary","(p1)","<p>Sets the preset dictionary and returns <code>string</code>. This method is available just only after Zlib::Deflate.new …\n"],["set_dictionary","Zlib::Inflate","Zlib/Inflate.html#method-i-set_dictionary","(p1)","<p>Sets the preset dictionary and returns <code>string</code>.  This method is available just only after a Zlib::NeedDict …\n"],["set_dn","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-set_dn","(val)","<p>Private setter for dn <code>val</code>.\n"],["set_dn","URI::LDAP","URI/LDAP.html#method-i-set_dn","(val)","<p>Private setter for dn <code>val</code>.\n"],["set_element","Matrix","Matrix.html#method-i-set_element","(i, j, v)",""],["set_element","Vector","Vector.html#method-i-set_element","(i, v)",""],["set_encoding","ARGF","ARGF.html#method-i-set_encoding","(*args)","<p>If single argument is specified, strings read from ARGF are tagged with the encoding specified.\n<p>If two …\n"],["set_encoding","IO","IO.html#method-i-set_encoding","(p1, p2 = v2, p3 = {})","<p>If single argument is specified, read string from io is tagged with the encoding specified.  If encoding …\n"],["set_encoding","StringIO","StringIO.html#method-i-set_encoding","(p1, p2 = v2, p3 = {})","<p>Specify the encoding of the StringIO as <em>ext_enc</em>. Use the default external encoding if <em>ext_enc</em> is nil. …\n"],["set_encoding_by_bom","IO","IO.html#method-i-set_encoding_by_bom","()","<p>Checks if <code>ios</code> starts with a BOM, and then consumes it and sets the external encoding.  Returns the result …\n"],["set_encoding_by_bom","StringIO","StringIO.html#method-i-set_encoding_by_bom","()",""],["set_end_location","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-set_end_location","(node)",""],["set_env","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-set_env","(key, value)",""],["set_eoutvar","Bundler::Thor::Actions::CapturableERB","Bundler/Thor/Actions/CapturableERB.html#method-i-set_eoutvar","(compiler, eoutvar = \"_erbout\")",""],["set_eoutvar","ERB","ERB.html#method-i-set_eoutvar","(compiler, eoutvar = '_erbout')","<p>Can be used to set <em>eoutvar</em> as described in ERB::new.  It&#39;s probably easier to just use the constructor …\n"],["set_eoutvar","RDoc::ERBIO","RDoc/ERBIO.html#method-i-set_eoutvar","(compiler, io_variable)","<p>Instructs <code>compiler</code> how to write to <code>io_variable</code>\n"],["set_eoutvar","RDoc::ERBPartial","RDoc/ERBPartial.html#method-i-set_eoutvar","(compiler, eoutvar = '_erbout')","<p>Overrides <code>compiler</code> startup to set the <code>eoutvar</code> to an empty string only if it isn&#39;t already set.\n"],["set_error","GetoptLong","GetoptLong.html#method-i-set_error","(type, message)","<p>Set an error (a protected method).\n"],["set_error","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-set_error","(ex, backtrace=false)","<p>Creates an error page for exception <code>ex</code> with an optional <code>backtrace</code>\n"],["set_extensions","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-set_extensions","(val)","<p>Private setter for extensions <code>val</code>.\n"],["set_extensions","URI::LDAP","URI/LDAP.html#method-i-set_extensions","(val)","<p>Private setter for extensions <code>val</code>.\n"],["set_factors","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-set_factors","(p1, p2)","<p>Sets <em>p</em>, <em>q</em> for the RSA instance.\n"],["set_field","Net::HTTPHeader","Net/HTTPHeader.html#method-i-set_field","(key, val)",""],["set_filter","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-set_filter","(val)","<p>Private setter for filter <code>val</code>.\n"],["set_filter","URI::LDAP","URI/LDAP.html#method-i-set_filter","(val)","<p>Private setter for filter <code>val</code>.\n"],["set_form","Net::HTTPHeader","Net/HTTPHeader.html#method-i-set_form","(params, enctype='application/x-www-form-urlencoded', formopt={})","<p>Set an HTML form data set. <code>params</code> is the form data set; it is an Array of Arrays or a Hash +enctype is …\n"],["set_form_data","Net::HTTPHeader","Net/HTTPHeader.html#method-i-set_form_data","(params, sep = '&')","<p>Set header fields and a body from HTML form data. <code>params</code> should be an Array of Arrays or a Hash containing …\n"],["set_generator","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-set_generator","(p1, p2, p3)","<p>Sets the curve parameters. <em>generator</em> must be an instance of EC::Point that is on the curve. <em>order</em> and …\n"],["set_get_line_procs","Tracer","Tracer.html#method-c-set_get_line_procs","(file_name, p = nil, &b)","<p>Register an event handler <code>p</code> which is called every time a line in <code>file_name</code> is executed.\n<p>Example:\n\n<pre>Tracer.set_get_line_procs(&quot;example.rb&quot;, ...</pre>\n"],["set_global","Bundler::Settings","Bundler/Settings.html#method-i-set_global","(key, value)",""],["set_headers","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-set_headers","(v)","<p>Private setter for headers <code>v</code>.\n"],["set_headers","URI::MailTo","URI/MailTo.html#method-i-set_headers","(v)","<p>Private setter for headers <code>v</code>.\n"],["set_host","Bundler::URI::File","Bundler/URI/File.html#method-i-set_host","(v)","<p>Protected setter for the host component <code>v</code>.\n<p>See also Bundler::URI::Generic.host=.\n"],["set_host","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_host","(v)","<p>Protected setter for the host component <code>v</code>.\n<p>See also Bundler::URI::Generic.host=.\n"],["set_host","URI::File","URI/File.html#method-i-set_host","(v)","<p>Protected setter for the host component <code>v</code>.\n<p>See also URI::Generic.host=.\n"],["set_host","URI::Generic","URI/Generic.html#method-i-set_host","(v)","<p>Protected setter for the host component <code>v</code>.\n<p>See also URI::Generic.host=.\n"],["set_installed_by_version","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-set_installed_by_version","(spec, installed_by_version = Gem::VERSION)",""],["set_key","Bundler::Settings","Bundler/Settings.html#method-i-set_key","(raw_key, value, hash, file)",""],["set_key","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-set_key","(p1, p2)","<p>Sets <em>pub_key</em> and <em>priv_key</em> for the DH instance. <em>priv_key</em> may be <code>nil</code>.\n"],["set_key","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-set_key","(p1, p2)","<p>Sets <em>pub_key</em> and <em>priv_key</em> for the DSA instance. <em>priv_key</em> may be <code>nil</code>.\n"],["set_key","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-set_key","(p1, p2, p3)","<p>Sets <em>n</em>, <em>e</em>, <em>d</em> for the RSA instance.\n"],["set_last_thread","DEBUGGER__","DEBUGGER__.html#method-c-set_last_thread","(th)",""],["set_last_value","IRB::Context","IRB/Context.html#method-i-set_last_value","(value)","<p>Sets the return value from the last statement evaluated in this context to #last_value.\n"],["set_local","Bundler::Settings","Bundler/Settings.html#method-i-set_local","(key, value)",""],["set_local!","Bundler::Source::Git","Bundler/Source/Git.html#method-i-set_local-21","(path)",""],["set_location","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-set_location","(node)",""],["set_minmax_proto_version","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-set_minmax_proto_version","(p1, p2)","<p>Sets the minimum and maximum supported protocol versions. See #min_version= and #max_version=.\n"],["set_next_element","RSS::Element","RSS/Element.html#method-i-set_next_element","(tag_name, next_element)",""],["set_non_blocking","WEBrick::Utils","WEBrick/Utils.html#method-c-set_non_blocking","(io)","<p>Sets IO operations on <code>io</code> to be non-blocking\n"],["set_non_blocking","WEBrick::Utils","WEBrick/Utils.html#method-i-set_non_blocking","(io)","<p>Sets IO operations on <code>io</code> to be non-blocking\n"],["set_opaque","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_opaque","(v)","<p>Protected setter for the opaque component <code>v</code>.\n<p>See also Bundler::URI::Generic.opaque=.\n"],["set_opaque","URI::Generic","URI/Generic.html#method-i-set_opaque","(v)","<p>Protected setter for the opaque component <code>v</code>.\n<p>See also URI::Generic.opaque=.\n"],["set_option","OptionParser::ParseError","OptionParser/ParseError.html#method-i-set_option","(opt, eq)",""],["set_options","GetoptLong","GetoptLong.html#method-i-set_options","(*arguments)","<p>Set options. Takes the same argument as GetoptLong.new.\n<p>Raises a RuntimeError if option processing has …\n"],["set_params","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-set_params","(params={})","<p>Sets saner defaults optimized for the use with HTTP-like protocols.\n<p>If a Hash <em>params</em> is given, the parameters …\n"],["set_parent","RSS::Maker::Base","RSS/Maker/Base.html#method-i-set_parent","(target, parent)",""],["set_passwd","WEBrick::HTTPAuth::Htdigest","WEBrick/HTTPAuth/Htdigest.html#method-i-set_passwd","(realm, user, pass)","<p>Sets a password in the database for <code>user</code> in <code>realm</code> to <code>pass</code>.\n"],["set_passwd","WEBrick::HTTPAuth::Htpasswd","WEBrick/HTTPAuth/Htpasswd.html#method-i-set_passwd","(realm, user, pass)","<p>Sets a password in the database for <code>user</code> in <code>realm</code> to <code>pass</code>.\n"],["set_passwd","WEBrick::HTTPAuth::UserDB","WEBrick/HTTPAuth/UserDB.html#method-i-set_passwd","(realm, user, pass)","<p>Sets a password in <code>realm</code> with <code>user</code> and <code>password</code> for the auth_type of this database.\n"],["set_password","Bundler::URI::File","Bundler/URI/File.html#method-i-set_password","(v)","<p>do nothing\n"],["set_password","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_password","(v)","<p>Protected setter for the password component <code>v</code>.\n<p>See also Bundler::URI::Generic.password=.\n"],["set_password","URI::File","URI/File.html#method-i-set_password","(v)","<p>do nothing\n"],["set_password","URI::Generic","URI/Generic.html#method-i-set_password","(v)","<p>Protected setter for the password component <code>v</code>.\n<p>See also URI::Generic.password=.\n"],["set_path","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-set_path","()",""],["set_path","Bundler::URI::FTP","Bundler/URI/FTP.html#method-i-set_path","(v)","<p>Private setter for the path of the Bundler::URI::FTP.\n"],["set_path","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_path","(v)","<p>Protected setter for the path component <code>v</code>.\n<p>See also Bundler::URI::Generic.path=.\n"],["set_path","URI::FTP","URI/FTP.html#method-i-set_path","(v)","<p>Private setter for the path of the URI::FTP.\n"],["set_path","URI::Generic","URI/Generic.html#method-i-set_path","(v)","<p>Protected setter for the path component <code>v</code>.\n<p>See also URI::Generic.path=.\n"],["set_payload","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-set_payload","(name, payload)","<p>Sets the payload of the vertex with the given name @param [String] name the name of the vertex @param …\n"],["set_payload","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-set_payload","(graph, name, payload)","<p>@macro action\n"],["set_payload","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-set_payload","(name, payload)","<p>Sets the payload of the vertex with the given name @param [String] name the name of the vertex @param …\n"],["set_payload","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-set_payload","(graph, name, payload)","<p>@macro action\n"],["set_port","Bundler::URI::File","Bundler/URI/File.html#method-i-set_port","(v)","<p>do nothing\n"],["set_port","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_port","(v)","<p>Protected setter for the port component <code>v</code>.\n<p>See also Bundler::URI::Generic.port=.\n"],["set_port","URI::File","URI/File.html#method-i-set_port","(v)","<p>do nothing\n"],["set_port","URI::Generic","URI/Generic.html#method-i-set_port","(v)","<p>Protected setter for the port component <code>v</code>.\n<p>See also URI::Generic.port=.\n"],["set_pqg","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-set_pqg","(p1, p2, p3)","<p>Sets <em>p</em>, <em>q</em>, <em>g</em> to the DH instance.\n"],["set_pqg","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-set_pqg","(p1, p2, p3)","<p>Sets <em>p</em>, <em>q</em>, <em>g</em> to the DSA instance.\n"],["set_range","Net::HTTPHeader","Net/HTTPHeader.html#method-i-set_range","(r, e = nil)","<p>Sets the HTTP Range: header. Accepts either a Range object as a single argument, or a beginning index …\n"],["set_range","Vector","Vector.html#method-i-set_range","(range, value)",""],["set_redirect","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-set_redirect","(status, url)","<p>Redirects to <code>url</code> with a WEBrick::HTTPStatus::Redirect <code>status</code>.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">res</span>.<span class=\"ruby-identifier\">set_redirect</span> <span class=\"ruby-constant\">WEBrick</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">HTTPStatus</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">TemporaryRedirect</span>\n</pre>\n"],["set_row_and_col_range","Matrix","Matrix.html#method-i-set_row_and_col_range","(row_range, col_range, value)",""],["set_row_range","Matrix","Matrix.html#method-i-set_row_range","(row_range, col, value)",""],["set_rubylib","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-set_rubylib","()",""],["set_rubyopt","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-set_rubyopt","()",""],["set_scheme","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_scheme","(v)","<p>Protected setter for the scheme component <code>v</code>.\n<p>See also Bundler::URI::Generic.scheme=.\n"],["set_scheme","URI::Generic","URI/Generic.html#method-i-set_scheme","(v)","<p>Protected setter for the scheme component <code>v</code>.\n<p>See also URI::Generic.scheme=.\n"],["set_scope","Bundler::URI::LDAP","Bundler/URI/LDAP.html#method-i-set_scope","(val)","<p>Private setter for scope <code>val</code>.\n"],["set_scope","URI::LDAP","URI/LDAP.html#method-i-set_scope","(val)","<p>Private setter for scope <code>val</code>.\n"],["set_screen_size","Readline","Readline.html#method-c-set_screen_size","(p1, p2)","<p>Set terminal size to <code>rows</code> and <code>columns</code>.\n<p>See GNU Readline&#39;s rl_set_screen_size function.\n<p>Raises NotImplementedError …\n"],["set_size","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-i-set_size","(new_value)",""],["set_socket","Net::FTP","Net/FTP.html#method-i-set_socket","(sock, get_greeting = true)","<p>Set the socket used to connect to the FTP server.\n<p>May raise FTPReplyError if <code>get_greeting</code> is false.\n"],["set_start_location","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-set_start_location","(node)",""],["set_table","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-set_table","(entries, dummy, tbl, chk, ptr)",""],["set_to","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-set_to","(v)","<p>Private setter for to <code>v</code>.\n"],["set_to","URI::MailTo","URI/MailTo.html#method-i-set_to","(v)","<p>Private setter for to <code>v</code>.\n"],["set_to_infinity!","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-set_to_infinity-21","()",""],["set_trace","DEBUGGER__","DEBUGGER__.html#method-c-set_trace","( arg )",""],["set_trace_func","Kernel","Kernel.html#method-i-set_trace_func","(p1)","<p>Establishes <em>proc</em> as the handler for tracing, or disables tracing if the parameter is <code>nil</code>.\n<p><strong>Note:</strong> this method …\n"],["set_trace_func","Thread","Thread.html#method-i-set_trace_func","(p1)","<p>Establishes <em>proc</em> on <em>thr</em> as the handler for tracing, or disables tracing if the parameter is <code>nil</code>.\n<p>See  …\n"],["set_typecode","Bundler::URI::FTP","Bundler/URI/FTP.html#method-i-set_typecode","(v)","<p>Private setter for the typecode <code>v</code>.\n<p>See also Bundler::URI::FTP.typecode=.\n"],["set_typecode","URI::FTP","URI/FTP.html#method-i-set_typecode","(v)","<p>Private setter for the typecode <code>v</code>.\n<p>See also URI::FTP.typecode=.\n"],["set_user","Bundler::URI::File","Bundler/URI/File.html#method-i-set_user","(v)","<p>do nothing\n"],["set_user","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_user","(v)","<p>Protected setter for the user component <code>v</code>.\n<p>See also Bundler::URI::Generic.user=.\n"],["set_user","URI::File","URI/File.html#method-i-set_user","(v)","<p>do nothing\n"],["set_user","URI::Generic","URI/Generic.html#method-i-set_user","(v)","<p>Protected setter for the user component <code>v</code>.\n<p>See also URI::Generic.user=.\n"],["set_userinfo","Bundler::URI::File","Bundler/URI/File.html#method-i-set_userinfo","(v)","<p>do nothing\n"],["set_userinfo","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-set_userinfo","(user, password = nil)","<p>Protected setter for the <code>user</code> component, and <code>password</code> if available (with validation).\n<p>See also Bundler::URI::Generic.userinfo= …\n"],["set_userinfo","URI::File","URI/File.html#method-i-set_userinfo","(v)","<p>do nothing\n"],["set_userinfo","URI::Generic","URI/Generic.html#method-i-set_userinfo","(user, password = nil)","<p>Protected setter for the <code>user</code> component, and <code>password</code> if available (with validation).\n<p>See also URI::Generic.userinfo= …\n"],["set_value","Matrix","Matrix.html#method-i-set_value","(row, col, value)",""],["set_value","Vector","Vector.html#method-i-set_value","(index, value)",""],["set_visibility_for","RDoc::Context","RDoc/Context.html#method-i-set_visibility_for","(methods, visibility, singleton = false)","<p>Given an array <code>methods</code> of method names, set the visibility of each to <code>visibility</code>\n"],["set_xhtml_uri_as_default_uri","RSS::Maker::AtomTextConstructBase::EnsureXMLContent","RSS/Maker/AtomTextConstructBase/EnsureXMLContent.html#method-i-set_xhtml_uri_as_default_uri","(children)",""],["setacl","Net::IMAP","Net/IMAP.html#method-i-setacl","(mailbox, user, rights)","<p>Sends the SETACL command along with <code>mailbox</code>, <code>user</code> and the <code>rights</code> that user is to have on that mailbox. …\n"],["setbyte","String","String.html#method-i-setbyte","(p1, p2)","<p>modifies the <em>index</em>th byte as <em>integer</em>.\n"],["setegid","Process::Sys","Process/Sys.html#method-c-setegid","(p1)","<p>Set the effective group ID of the calling process to <em>group</em>.  Not available on all platforms.\n"],["seteuid","Process::Sys","Process/Sys.html#method-c-seteuid","(p1)","<p>Set the effective user ID of the calling process to <em>user</em>.  Not available on all platforms.\n"],["setgid","Process::Sys","Process/Sys.html#method-c-setgid","(p1)","<p>Set the group ID of the current process to <em>group</em>. Not available on all platforms.\n"],["setgid?","File","File.html#method-c-setgid-3F","(p1)","<p>Returns <code>true</code> if the named file has the setgid bit set.\n<p><em>file_name</em> can be an IO object.\n"],["setgid?","File::Stat","File/Stat.html#method-i-setgid-3F","()","<p>Returns <code>true</code> if <em>stat</em> has the set-group-id permission bit set, <code>false</code> if it doesn&#39;t or if the operating …\n"],["setgid?","FileTest","FileTest.html#method-i-setgid-3F","(p1)","<p>Returns <code>true</code> if the named file has the setgid bit set.\n<p><em>file_name</em> can be an IO object.\n"],["setgid?","Pathname","Pathname.html#method-i-setgid-3F","()","<p>See FileTest.setgid?.\n"],["setgrent","Etc","Etc.html#method-c-setgrent","()","<p>Resets the process of reading the /etc/group file, so that the next call to ::getgrent will return the …\n"],["setpgid","Process","Process.html#method-c-setpgid","(p1, p2)","<p>Sets the process group ID of <em>pid</em> (0 indicates this process) to <em>integer</em>. Not available on all platforms. …\n"],["setpgrp","Process","Process.html#method-c-setpgrp","()","<p>Equivalent to <code>setpgid(0,0)</code>. Not available on all platforms.\n"],["setpriority","Process","Process.html#method-c-setpriority","(p1, p2, p3)","<p>See Process.getpriority.\n\n<pre>Process.setpriority(Process::PRIO_USER, 0, 19)      #=&gt; 0\nProcess.setpriority(Process::PRIO_PROCESS, ...</pre>\n"],["setproctitle","Process","Process.html#method-c-setproctitle","(p1)","<p>Sets the process title that appears on the ps(1) command.  Not necessarily effective on all platforms. …\n"],["setproperty","WIN32OLE","WIN32OLE.html#method-i-setproperty","(*args)","<p>Sets property of OLE object. When you want to set property with argument, you can use this method.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">excel</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["setpwent","Etc","Etc.html#method-c-setpwent","()","<p>Resets the process of reading the /etc/passwd file, so that the next call to ::getpwent will return the …\n"],["setquota","Net::IMAP","Net/IMAP.html#method-i-setquota","(mailbox, quota)","<p>Sends a SETQUOTA command along with the specified <code>mailbox</code> and <code>quota</code>.  If <code>quota</code> is nil, then <code>quota</code> will …\n"],["setregid","Process::Sys","Process/Sys.html#method-c-setregid","(p1, p2)","<p>Sets the (group) real and/or effective group IDs of the current process to <em>rid</em> and <em>eid</em>, respectively. …\n"],["setresgid","Process::Sys","Process/Sys.html#method-c-setresgid","(p1, p2, p3)","<p>Sets the (group) real, effective, and saved user IDs of the current process to <em>rid</em>, <em>eid</em>, and <em>sid</em> respectively. …\n"],["setresuid","Process::Sys","Process/Sys.html#method-c-setresuid","(p1, p2, p3)","<p>Sets the (user) real, effective, and saved user IDs of the current process to <em>rid</em>, <em>eid</em>, and <em>sid</em> respectively. …\n"],["setreuid","Process::Sys","Process/Sys.html#method-c-setreuid","(p1, p2)","<p>Sets the (user) real and/or effective user IDs of the current process to <em>rid</em> and <em>eid</em>, respectively.  …\n"],["setrgid","Process::Sys","Process/Sys.html#method-c-setrgid","(p1)","<p>Set the real group ID of the calling process to <em>group</em>. Not available on all platforms.\n"],["setrlimit","Process","Process.html#method-c-setrlimit","(*args)","<p>Sets the resource limit of the process. <em>cur_limit</em> means current (soft) limit and <em>max_limit</em> means maximum …\n"],["setruid","Process::Sys","Process/Sys.html#method-c-setruid","(p1)","<p>Set the real user ID of the calling process to <em>user</em>. Not available on all platforms.\n"],["setsid","Process","Process.html#method-c-setsid","()","<p>Establishes this process as a new session and process group leader, with no controlling tty. Returns …\n"],["setsockopt","BasicSocket","BasicSocket.html#method-i-setsockopt","(p1, p2, p3)","<p>Sets a socket option. These are protocol and system specific, see your local system documentation for …\n"],["setsockopt","OpenSSL::SSL::SocketForwarder","OpenSSL/SSL/SocketForwarder.html#method-i-setsockopt","(level, optname, optval)",""],["setter","RSS::BaseListener","RSS/BaseListener.html#method-c-setter","(uri, tag_name)","<p>return the setter for the uri, tag_name pair, or nil.\n"],["settings","Bundler","Bundler.html#method-c-settings","()",""],["settings_flag","Bundler::FeatureFlag","Bundler/FeatureFlag.html#method-c-settings_flag","(flag, &default)",""],["settings_method","Bundler::FeatureFlag","Bundler/FeatureFlag.html#method-c-settings_method","(name, key, &default)",""],["settings_option","Bundler::FeatureFlag","Bundler/FeatureFlag.html#method-c-settings_option","(key, &default)",""],["setuid","Process::Sys","Process/Sys.html#method-c-setuid","(p1)","<p>Set the user ID of the current process to <em>user</em>. Not available on all platforms.\n"],["setuid?","File","File.html#method-c-setuid-3F","(p1)","<p>Returns <code>true</code> if the named file has the setuid bit set.\n<p><em>file_name</em> can be an IO object.\n"],["setuid?","File::Stat","File/Stat.html#method-i-setuid-3F","()","<p>Returns <code>true</code> if <em>stat</em> has the set-user-id permission bit set, <code>false</code> if it doesn&#39;t or if the operating …\n"],["setuid?","FileTest","FileTest.html#method-i-setuid-3F","(p1)","<p>Returns <code>true</code> if the named file has the setuid bit set.\n<p><em>file_name</em> can be an IO object.\n"],["setuid?","Pathname","Pathname.html#method-i-setuid-3F","()","<p>See FileTest.setuid?.\n"],["setup","Bundler","Bundler.html#method-c-setup","(*groups)","<p>Turns on the Bundler runtime. After <code>Bundler.setup</code> call, all <code>load</code> or <code>require</code> of the gems would be allowed …\n"],["setup","Bundler::Runtime","Bundler/Runtime.html#method-i-setup","(*groups)",""],["setup","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-setup","()",""],["setup","Gem::TestCase","Gem/TestCase.html#method-i-setup","()","<p>#setup prepares a sandboxed location to install gems.  All installs are directed to a temporary directory. …\n"],["setup","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-setup","()","<p>This method is called automatically when a new SSLSocket is created. However, it is not thread-safe and …\n"],["setup","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-setup","()","<p>Prepares the spec for documentation generation\n"],["setup","RDoc::RubygemsHook","RDoc/RubygemsHook.html#method-i-setup","()","<p>Prepares the spec for documentation generation\n"],["setup_base_gem","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-setup_base_gem","()","<p>Creates the following instance variables:\n<p>@spec &mdash; a spec named &#39;a&#39;, intended for regular installs …\n\n"],["setup_base_installer","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-setup_base_installer","()","<p>Creates the following instance variables:\n<p>@spec &mdash; a spec named &#39;a&#39;, intended for regular installs …\n"],["setup_base_spec","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-setup_base_spec","()","<p>Sets up a generic specification for testing the rubygems installer\n<p>And returns it\n"],["setup_base_user_installer","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-setup_base_user_installer","()","<p>Creates the following instance variables:\n<p>@spec &mdash; a spec named &#39;a&#39;, intended for regular installs …\n"],["setup_cache_all","Bundler::CLI::Cache","Bundler/CLI/Cache.html#method-i-setup_cache_all","()",""],["setup_cache_all","Bundler::CLI::Package","Bundler/CLI/Package.html#method-i-setup_cache_all","()",""],["setup_certificate","DRb::DRbSSLSocket::SSLConfig","DRb/DRbSSLSocket/SSLConfig.html#method-i-setup_certificate","()","<p>Ensures that :SSLCertificate and :SSLPrivateKey have been provided or that a new certificate is generated …\n"],["setup_elements","RSS::Maker::Atom::Entry","RSS/Maker/Atom/Entry.html#method-i-setup_elements","(entry)",""],["setup_elements","RSS::Maker::Atom::Feed","RSS/Maker/Atom/Feed.html#method-i-setup_elements","(feed)",""],["setup_elements","RSS::Maker::RSS09","RSS/Maker/RSS09.html#method-i-setup_elements","(rss)",""],["setup_elements","RSS::Maker::RSS10","RSS/Maker/RSS10.html#method-i-setup_elements","(rss)",""],["setup_generator","RDoc::Options","RDoc/Options.html#method-i-setup_generator","(generator_name = @generator_name)","<p>Set up an output generator for the named <code>generator_name</code>.\n<p>If the found generator responds to :setup_options …\n"],["setup_image","RSS::Maker::RSS09::Channel","RSS/Maker/RSS09/Channel.html#method-i-setup_image","(rss)",""],["setup_image","RSS::Maker::RSS10::Channel","RSS/Maker/RSS10/Channel.html#method-i-setup_image","(rss)",""],["setup_items","RSS::Maker::RSS09::Channel","RSS/Maker/RSS09/Channel.html#method-i-setup_items","(rss)",""],["setup_items","RSS::Maker::RSS10::Channel","RSS/Maker/RSS10/Channel.html#method-i-setup_items","(rss)",""],["setup_maker","RSS::Atom::Entry","RSS/Atom/Entry.html#method-i-setup_maker","(maker)","<p>Sets up the <code>maker</code> for constructing Entry elements.\n"],["setup_maker","RSS::RDF::Bag","RSS/RDF/Bag.html#method-i-setup_maker","(target)",""],["setup_maker","RSS::RDF::Bag","RSS/RDF/Bag.html#method-i-setup_maker","(target)",""],["setup_maker","RSS::RDF::Seq","RSS/RDF/Seq.html#method-i-setup_maker","(target)",""],["setup_maker","RSS::RDF::Seq","RSS/RDF/Seq.html#method-i-setup_maker","(target)",""],["setup_maker","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-setup_maker","(maker)",""],["setup_maker","RSS::SetupMaker","RSS/SetupMaker.html#method-i-setup_maker","(maker)",""],["setup_maker","RSS::XMLStyleSheet","RSS/XMLStyleSheet.html#method-i-setup_maker","(maker)",""],["setup_maker_attributes","RSS::Atom::Feed::Generator","RSS/Atom/Feed/Generator.html#method-i-setup_maker_attributes","(target)",""],["setup_maker_attributes","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-i-setup_maker_attributes","(target)",""],["setup_maker_attributes","RSS::ITunesChannelModel::ITunesCategory","RSS/ITunesChannelModel/ITunesCategory.html#method-i-setup_maker_attributes","(category)",""],["setup_maker_attributes","RSS::ITunesChannelModel::ITunesImage","RSS/ITunesChannelModel/ITunesImage.html#method-i-setup_maker_attributes","(image)",""],["setup_maker_attributes","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-i-setup_maker_attributes","(favicon)",""],["setup_maker_attributes","RSS::ImageItemModel::ImageItem","RSS/ImageItemModel/ImageItem.html#method-i-setup_maker_attributes","(item)",""],["setup_maker_attributes","RSS::RDF::Channel","RSS/RDF/Channel.html#method-i-setup_maker_attributes","(channel)",""],["setup_maker_attributes","RSS::Rss::Channel::Item::Category","RSS/Rss/Channel/Item/Category.html#method-i-setup_maker_attributes","(category)",""],["setup_maker_attributes","RSS::Rss::Channel::Item::Enclosure","RSS/Rss/Channel/Item/Enclosure.html#method-i-setup_maker_attributes","(enclosure)",""],["setup_maker_attributes","RSS::Rss::Channel::Item::Guid","RSS/Rss/Channel/Item/Guid.html#method-i-setup_maker_attributes","(guid)",""],["setup_maker_attributes","RSS::Rss::Channel::Item::Source","RSS/Rss/Channel/Item/Source.html#method-i-setup_maker_attributes","(source)",""],["setup_maker_attributes","RSS::SetupMaker","RSS/SetupMaker.html#method-i-setup_maker_attributes","(target)",""],["setup_maker_element","RSS::Atom::ContentModel","RSS/Atom/ContentModel.html#method-i-setup_maker_element","(target)",""],["setup_maker_element","RSS::Atom::Feed","RSS/Atom/Feed.html#method-i-setup_maker_element","(channel)",""],["setup_maker_element","RSS::ITunesChannelModel::ITunesOwner","RSS/ITunesChannelModel/ITunesOwner.html#method-i-setup_maker_element","(owner)",""],["setup_maker_element","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-setup_maker_element","(duration)",""],["setup_maker_element","RSS::Rss::Channel::Item","RSS/Rss/Channel/Item.html#method-i-setup_maker_element","(item)",""],["setup_maker_element","RSS::SetupMaker","RSS/SetupMaker.html#method-i-setup_maker_element","(target)",""],["setup_maker_element_writer","RSS::Atom::ContentModel","RSS/Atom/ContentModel.html#method-i-setup_maker_element_writer","()",""],["setup_maker_element_writer","RSS::Atom::Feed::Logo","RSS/Atom/Feed/Logo.html#method-i-setup_maker_element_writer","()",""],["setup_maker_elements","RSS::Atom::Feed","RSS/Atom/Feed.html#method-i-setup_maker_elements","(channel)",""],["setup_maker_elements","RSS::ITunesChannelModel::ITunesCategory","RSS/ITunesChannelModel/ITunesCategory.html#method-i-setup_maker_elements","(category)",""],["setup_maker_elements","RSS::Rss","RSS/Rss.html#method-i-setup_maker_elements","(maker)",""],["setup_maker_elements","RSS::Rss::Channel","RSS/Rss/Channel.html#method-i-setup_maker_elements","(channel)",""],["setup_maker_elements","RSS::SetupMaker","RSS/SetupMaker.html#method-i-setup_maker_elements","(parent)",""],["setup_manpath","Bundler::Runtime","Bundler/Runtime.html#method-i-setup_manpath","()",""],["setup_next_element","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-setup_next_element","(tag_name, klass, attributes)",""],["setup_next_element_in_unknown_element","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-setup_next_element_in_unknown_element","()",""],["setup_other_elements","RSS::Maker::Base","RSS/Maker/Base.html#method-i-setup_other_elements","(feed, current=nil)",""],["setup_output_dir","RDoc::RDoc","RDoc/RDoc.html#method-i-setup_output_dir","(dir, force)","<p>Create an output dir if it doesn&#39;t exist. If it does exist, but doesn&#39;t contain the flag file …\n"],["setup_params","WEBrick::AccessLog","WEBrick/AccessLog.html#method-i-setup_params","(config, req, res)","<p>This format specification is a subset of mod_log_config of Apache:\n<p>%a &mdash; Remote IP address\n<p>%b &mdash; Total response …\n"],["setup_signer","Gem::Package","Gem/Package.html#method-i-setup_signer","(signer_options: {})","<p>Prepares the gem for signing and checksum generation.  If a signing certificate and key are not present …\n"],["setup_ssl_context","DRb::DRbSSLSocket::SSLConfig","DRb/DRbSSLSocket/SSLConfig.html#method-i-setup_ssl_context","()","<p>Establish the OpenSSL::SSL::SSLContext with the configuration parameters provided.\n"],["setup_textinput","RSS::Maker::RSS09::Channel","RSS/Maker/RSS09/Channel.html#method-i-setup_textinput","(rss)",""],["setup_textinput","RSS::Maker::RSS10::Channel","RSS/Maker/RSS10/Channel.html#method-i-setup_textinput","(rss)",""],["setup_values","RSS::Maker::Base","RSS/Maker/Base.html#method-i-setup_values","(target)",""],["sev_threshold=","Logger","Logger.html#method-i-sev_threshold-3D","(severity)",""],["sexp","Ripper","Ripper.html#method-c-sexp","(src, filename = '-', lineno = 1)","<p>EXPERIMENTAL &mdash; Parses <code>src</code> and create S-exp tree. Returns more readable tree rather than Ripper.sexp_raw …\n"],["sexp_raw","Ripper","Ripper.html#method-c-sexp_raw","(src, filename = '-', lineno = 1)","<p>EXPERIMENTAL &mdash; Parses <code>src</code> and create S-exp tree. This method is mainly for developer use.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;ripper&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n\n"],["sh","Bundler::GemHelper","Bundler/GemHelper.html#method-i-sh","(cmd, &block)",""],["sh_with_input","Bundler::GemHelper","Bundler/GemHelper.html#method-i-sh_with_input","(cmd)",""],["sh_with_status","Bundler::GemHelper","Bundler/GemHelper.html#method-i-sh_with_status","(cmd, &block)",""],["shallow_eql?","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-shallow_eql-3F","(other)","<p>@param  [Vertex] other the other vertex to compare to @return [Boolean] whether the two vertices are …\n"],["shallow_eql?","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-shallow_eql-3F","(other)","<p>@param  [Vertex] other the other vertex to compare to @return [Boolean] whether the two vertices are …\n"],["shebang","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-shebang","()",""],["shebang","Gem::Installer","Gem/Installer.html#method-i-shebang","(bin_file_name)","<p>Generates a #! line for <code>bin_file_name</code>&#39;s wrapper copying arguments if necessary.\n<p>If the :custom_shebang …\n"],["shebang","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-shebang","(path)",""],["shell","Bundler::Thor::Base","Bundler/Thor/Base.html#method-c-shell","()","<p>Returns the shell used in all Bundler::Thor classes. If you are in a Unix platform it will use a colored …\n"],["shell","Bundler::Thor::Shell","Bundler/Thor/Shell.html#method-i-shell","()","<p>Holds the shell for the given Bundler::Thor instance. If no shell is given, it gets a default shell from …\n"],["shellescape","Shellwords","Shellwords.html#method-c-shellescape","(str)","<p>Escapes a string so that it can be safely used in a Bourne shell command line.  <code>str</code> can be a non-string …\n"],["shellescape","Shellwords","Shellwords.html#method-i-shellescape","(str)","<p>Escapes a string so that it can be safely used in a Bourne shell command line.  <code>str</code> can be a non-string …\n"],["shellescape","String","String.html#method-i-shellescape","()","<p>Escapes <code>str</code> so that it can be safely used in a Bourne shell command line.\n<p>See Shellwords.shellescape for …\n"],["shelljoin","Array","Array.html#method-i-shelljoin","()","<p>Builds a command line string from an argument list <code>array</code> joining all elements escaped for the Bourne …\n"],["shelljoin","Shellwords","Shellwords.html#method-c-shelljoin","(array)","<p>Builds a command line string from an argument list, <code>array</code>.\n<p>All elements are joined into a single string …\n"],["shelljoin","Shellwords","Shellwords.html#method-i-shelljoin","(array)","<p>Builds a command line string from an argument list, <code>array</code>.\n<p>All elements are joined into a single string …\n"],["shellsplit","Shellwords","Shellwords.html#method-i-shellsplit","(line)","<p>Splits a string into an array of tokens in the same way the UNIX Bourne shell does.\n\n<pre>argv = Shellwords.split(&#39;here ...</pre>\n"],["shellsplit","Shellwords","Shellwords.html#method-c-shellsplit","(line)","<p>Splits a string into an array of tokens in the same way the UNIX Bourne shell does.\n\n<pre>argv = Shellwords.split(&#39;here ...</pre>\n"],["shellsplit","String","String.html#method-i-shellsplit","()","<p>Splits <code>str</code> into an array of tokens in the same way the UNIX Bourne shell does.\n<p>See Shellwords.shellsplit …\n"],["shellwords","Shellwords","Shellwords.html#method-i-shellwords","(line)",""],["shellwords","Shellwords","Shellwords.html#method-c-shellwords","(line)",""],["shift","Array","Array.html#method-i-shift","(*args)","<p>Removes the first element of <code>self</code> and returns it (shifting all other elements down by one). Returns  …\n"],["shift","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-shift","()",""],["shift","CSV","CSV.html#method-i-shift","()","<p>The primary read method for wrapped Strings and IOs, a single row is pulled from the data source, parsed …\n"],["shift","DBM","DBM.html#method-i-shift","()","<p>Removes a [key, value] pair from the database, and returns it. If the database is empty, returns nil. …\n"],["shift","ENV","ENV.html#method-c-shift","()","<p>Removes the first environment variable from ENV and returns a 2-element Array containing its name and …\n"],["shift","GDBM","GDBM.html#method-i-shift","()","<p>Removes a key-value-pair from this database and returns it as a two-item array [ <em>key</em>, <em>value</em> ]. Returns …\n"],["shift","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-shift","()",""],["shift","Hash","Hash.html#method-i-shift","()","<p>Removes a key-value pair from <em>hsh</em> and returns it as the two-item array <code>[</code> <em>key, value</em> <code>]</code>, or the hash&#39;s …\n"],["shift","Queue","Queue.html#method-i-shift","(*args)",""],["shift","Racc::ActionTable","Racc/ActionTable.html#method-i-shift","(i)",""],["shift","SDBM","SDBM.html#method-i-shift","()","<p>Removes a key-value pair from the database and returns them as an Array. If the database is empty, returns …\n"],["shift","SizedQueue","SizedQueue.html#method-i-shift","(*args)",""],["shift","YAML::DBM","YAML/DBM.html#method-i-shift","()","<p>Removes a [key, value] pair from the database, and returns it. If the database is empty, returns <code>nil</code> …\n"],["shift_n","Racc::ActionTable","Racc/ActionTable.html#method-i-shift_n","()",""],["short_name","OpenSSL::ASN1::ObjectId","OpenSSL/ASN1/ObjectId.html#method-i-short_name","()",""],["shortref_for_display","Bundler::Source::Git","Bundler/Source/Git.html#method-i-shortref_for_display","(ref)",""],["shortref_for_path","Bundler::Source::Git","Bundler/Source/Git.html#method-i-shortref_for_path","(ref)",""],["should_include?","Bundler::Dependency","Bundler/Dependency.html#method-i-should_include-3F","()",""],["should_report_srconflict?","Racc::States","Racc/States.html#method-i-should_report_srconflict-3F","()",""],["should_terminal","Racc::Sym","Racc/Sym.html#method-i-should_terminal","()",""],["should_terminal?","Racc::Sym","Racc/Sym.html#method-i-should_terminal-3F","()",""],["show","Bundler::CLI","Bundler/CLI.html#method-i-show","(gem_name = nil)",""],["show_documentation","RDoc::Servlet","RDoc/Servlet.html#method-i-show_documentation","(req, res)","<p>Displays documentation for <code>req</code> on <code>res</code>, whether that be HTML or some asset.\n"],["show_files","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-show_files","(files)",""],["show_gems","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-show_gems","(name)","<p>Guts of original execute\n"],["show_help","Gem::Command","Gem/Command.html#method-i-show_help","()","<p>Display the help message for the command.\n"],["show_local_gems","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-show_local_gems","(name, req = Gem::Requirement.default)",""],["show_lookup_failure","Gem::Command","Gem/Command.html#method-i-show_lookup_failure","(gem_name, version, errors, suppress_suggestions = false, required_by = nil)","<p>Display to the user that a gem couldn&#39;t be found and reasons why\n"],["show_owners","Gem::Commands::OwnerCommand","Gem/Commands/OwnerCommand.html#method-i-show_owners","(name)",""],["show_prereleases?","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-show_prereleases-3F","()",""],["show_pretty_values_for","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-show_pretty_values_for","(setting)",""],["show_rdoc_for_pattern","Gem::Server","Gem/Server.html#method-i-show_rdoc_for_pattern","(pattern, res)","<p>Returns true and prepares http response, if rdoc for the requested gem name pattern was found.\n<p>The search …\n"],["show_release_notes","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-show_release_notes","()",""],["show_remote_gems","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-show_remote_gems","(name)",""],["show_version","OptionParser","OptionParser.html#method-c-show_version","(*pkgs)",""],["show_warning","Bundler::Injector","Bundler/Injector.html#method-i-show_warning","(message)",""],["shuffle","Array","Array.html#method-i-shuffle","(*args)","<p>Returns a new array with elements of <code>self</code> shuffled.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [ <span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span> ]           <span class=\"ruby-comment\">#=&gt; [1, 2, 3]</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">shuffle</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["shuffle!","Array","Array.html#method-i-shuffle-21","(*args)","<p>Shuffles elements in <code>self</code> in place.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [ <span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span> ]           <span class=\"ruby-comment\">#=&gt; [1, 2, 3]</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">shuffle!</span>                <span class=\"ruby-operator\">...</span>\n</pre>\n"],["shutdown","BasicSocket","BasicSocket.html#method-i-shutdown","(p1 = v1)","<p>Calls shutdown(2) system call.\n<p>s.shutdown(Socket::SHUT_RD) disallows further read.\n<p>s.shutdown(Socket::SHUT_WR …\n"],["shutdown","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-i-shutdown","(&block)",""],["shutdown","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-shutdown","(&block)","<p>Shuts down the TimedStack which prevents connections from being checked out.  The <code>block</code> is called once …\n"],["shutdown","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-shutdown","()","<p>Shuts down all connections\n<p><strong>NOTE</strong>: Calling shutdown for can be dangerous!\n<p>If any thread is still using a …\n"],["shutdown","DRb::DRbServer","DRb/DRbServer.html#method-i-shutdown","()",""],["shutdown","OpenSSL::SSL::SSLServer","OpenSSL/SSL/SSLServer.html#method-i-shutdown","(how=Socket::SHUT_RDWR)","<p>See BasicSocket#shutdown for details.\n"],["shutdown","Rinda::RingServer","Rinda/RingServer.html#method-i-shutdown","()","<p>Shuts down the RingServer\n"],["shutdown","WEBrick::GenericServer","WEBrick/GenericServer.html#method-i-shutdown","()","<p>Shuts down the server and all listening sockets.  New listeners must be provided to restart the server. …\n"],["shutdown_connections","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-shutdown_connections","(options = nil)","<p>This is an extension point for TimedStack and is called with a mutex.\n<p>This method must shut down all connections …\n"],["sid_available?","Process::GID","Process/GID.html#method-c-sid_available-3F","()","<p>Returns <code>true</code> if the current platform has saved group ID functionality.\n"],["sid_available?","Process::UID","Process/UID.html#method-c-sid_available-3F","()","<p>Returns <code>true</code> if the current platform has saved user ID functionality.\n"],["sign","BigDecimal","BigDecimal.html#method-i-sign","()","<p>Returns the sign of the value.\n<p>Returns a positive value if &gt; 0, a negative value if &lt; 0, and a zero …\n"],["sign","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-sign","(cert_file)",""],["sign","Gem::S3URISigner","Gem/S3URISigner.html#method-i-sign","(expiration = 86400)","<p>Signs S3 URI using query-params according to the reference: docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html …\n"],["sign","Gem::Security","Gem/Security.html#method-c-sign","(certificate, signing_key, signing_cert, age = ONE_YEAR, extensions = EXTENSIONS, serial = 1)","<p>Sign the public key from <code>certificate</code> with the <code>signing_key</code> and <code>signing_cert</code>, using the Gem::Security::DIGEST_ALGORITHM …\n"],["sign","Gem::Security::Signer","Gem/Security/Signer.html#method-i-sign","(data)","<p>Sign data with given digest algorithm\n"],["sign","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-sign","(p1, p2)","<p>Parameters\n<p><em>key</em> - the private key to be used for signing this instance\n<p><em>digest</em> - the digest to be used for …\n"],["sign","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-sign","(p1, p2, p3 = v3, p4 = v4, p5 = v5)","<p>Signs this OCSP response using the <em>cert</em>, <em>key</em> and optional <em>digest</em>. This behaves in the similar way as …\n"],["sign","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-sign","(p1, p2, p3 = v3, p4 = v4, p5 = v5)","<p>Signs this OCSP request using <em>cert</em>, <em>key</em> and optional <em>digest</em>. If <em>digest</em> is not specified, SHA-1 is used. …\n"],["sign","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-c-sign","(p1, p2, p3, p4 = v4, p5 = v5)",""],["sign","OpenSSL::PKey::PKey","OpenSSL/PKey/PKey.html#method-i-sign","(p1, p2)","<p>To sign the String <em>data</em>, <em>digest</em>, an instance of OpenSSL::Digest, must be provided. The return value is …\n"],["sign","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-sign","(p1, p2)",""],["sign","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-sign","(p1, p2)",""],["sign","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-sign","(p1, p2)",""],["sign_in","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-sign_in","(sign_in_host = nil)","<p>Signs in with the RubyGems API at <code>sign_in_host</code> and sets the rubygems API key.\n"],["sign_pss","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-sign_pss","(p1, p2, p3 = {})","<p>Signs <em>data</em> using the Probabilistic Signature Scheme (RSA-PSS) and returns the calculated signature.\n<p>RSAError …\n"],["signal","ConditionVariable","ConditionVariable.html#method-i-signal","()","<p>Wakes up the first thread in line waiting for this lock.\n"],["signal","MonitorMixin::ConditionVariable","MonitorMixin/ConditionVariable.html#method-i-signal","()","<p>Wakes up the first thread in line waiting for this lock.\n"],["signal","Rinda::WaitTemplateEntry","Rinda/WaitTemplateEntry.html#method-i-signal","()",""],["signal_handle","IRB::Irb","IRB/Irb.html#method-i-signal_handle","()","<p>Handler for the signal SIGINT, see Kernel#trap for more information.\n"],["signal_status","IRB::Irb","IRB/Irb.html#method-i-signal_status","(status)","<p>Evaluates the given block using the given <code>status</code>.\n"],["signaled?","Process::Status","Process/Status.html#method-i-signaled-3F","()","<p>Returns <code>true</code> if <em>stat</em> terminated because of an uncaught signal.\n"],["signame","Signal","Signal.html#method-c-signame","(p1)","<p>Convert signal number to signal name. Returns <code>nil</code> if the signo is an invalid signal number.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Signal</span>.<span class=\"ruby-identifier\">trap</span>(<span class=\"ruby-string\">&quot;INT&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["signature","RDoc::TomDoc","RDoc/TomDoc.html#method-c-signature","(comment)","<p>Extracts the Signature section&#39;s method signature\n<p>comment &mdash; An RDoc::Comment that will be parsed and …\n\n"],["signature_algorithm","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-signature_algorithm","()",""],["signature_algorithm","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-signature_algorithm","()",""],["signature_algorithm","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-signature_algorithm","()",""],["signed?","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-signed-3F","()","<p>Returns <code>true</code> if the request is signed, <code>false</code> otherwise. Note that the validity of the signature is <strong>not</strong> …\n"],["signed_time","OpenSSL::PKCS7::SignerInfo","OpenSSL/PKCS7/SignerInfo.html#method-i-signed_time","()",""],["signers","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-signers","()",""],["signo","SignalException","SignalException.html#method-i-signo","()","<p>Returns a signal number.\n"],["silence","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-silence","(&blk)",""],["silence","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-silence","()",""],["silent_system","Gem::Util","Gem/Util.html#method-c-silent_system","(*command)","<p>Invokes system, but silences all output.\n"],["similar_word_list","Bundler::SimilarityDetector","Bundler/SimilarityDetector.html#method-i-similar_word_list","(word, limit = 3)","<p>return the result of &#39;similar_words&#39;, concatenated into a list (eg “a, b, or c”)\n"],["similar_words","Bundler::SimilarityDetector","Bundler/SimilarityDetector.html#method-i-similar_words","(word, limit = 3)","<p>return an array of words similar to &#39;word&#39; from the corpus\n"],["sin","BigMath","BigMath.html#method-i-sin","(x, prec)","<p>Computes the sine of <code>decimal</code> to the specified number of digits of precision, <code>numeric</code>.\n<p>If <code>decimal</code> is Infinity …\n"],["sin","Math","Math.html#method-c-sin","(p1)","<p>Computes the sine of <code>x</code> (expressed in radians). Returns a Float in the range -1.0..1.0.\n<p>Domain: (-INFINITY, …\n"],["single?","Bundler::VersionRanges::ReqR","Bundler/VersionRanges/ReqR.html#method-i-single-3F","()",""],["single?","REXML::Validation::Event","REXML/Validation/Event.html#method-i-single-3F","()",""],["single_delegate","SingleForwardable","SingleForwardable.html#method-i-single_delegate","(hash)","<p>Takes a hash as its argument.  The key is a symbol or an array of symbols.  These symbols correspond …\n"],["single_version_string","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-single_version_string","()",""],["singleline_format","PrettyPrint","PrettyPrint.html#method-c-singleline_format","(output=''.dup, maxwidth=nil, newline=nil, genspace=nil)","<p>This is similar to PrettyPrint::format but the result has no breaks.\n<p><code>maxwidth</code>, <code>newline</code> and <code>genspace</code> are …\n"],["singleline_pp","PP","PP.html#method-c-singleline_pp","(obj, out=$>)","<p>Outputs <code>obj</code> to <code>out</code> like PP.pp but with no indent and newline.\n<p>PP.singleline_pp returns <code>out</code>.\n"],["singleton_class","Object","Object.html#method-i-singleton_class","()","<p>Returns the singleton class of <em>obj</em>.  This method creates a new singleton class if <em>obj</em> does not have one. …\n"],["singleton_class?","Module","Module.html#method-i-singleton_class-3F","()","<p>Returns <code>true</code> if <em>mod</em> is a singleton class or <code>false</code> if it is an ordinary class or module.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">class</span> <span class=\"ruby-constant\">C</span>\n<span class=\"ruby-keyword\">end</span>\n<span class=\"ruby-constant\">C</span>.<span class=\"ruby-identifier\">singleton_class?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["singleton_method","Object","Object.html#method-i-singleton_method","(p1)","<p>Similar to <em>method</em>, searches singleton method only.\n\n<pre>class Demo\n  def initialize(n)\n    @iv = n\n  end\n  ...</pre>\n"],["singleton_method_added","BasicObject","BasicObject.html#method-i-singleton_method_added","(p1)","<p>Invoked as a callback whenever a singleton method is added to the receiver.\n\n<pre>module Chatty\n  def Chatty.singleton_method_added(id) ...</pre>\n"],["singleton_method_added","REXML::Functions","REXML/Functions.html#method-c-singleton_method_added","(name)",""],["singleton_method_removed","BasicObject","BasicObject.html#method-i-singleton_method_removed","(p1)","<p>Invoked as a callback whenever a singleton method is removed from the receiver.\n\n<pre>module Chatty\n  def Chatty.singleton_method_removed(id) ...</pre>\n"],["singleton_method_undefined","BasicObject","BasicObject.html#method-i-singleton_method_undefined","(p1)","<p>Invoked as a callback whenever a singleton method is undefined in the receiver.\n\n<pre>module Chatty\n  def Chatty.singleton_method_undefined(id) ...</pre>\n"],["singleton_methods","Object","Object.html#method-i-singleton_methods","(*args)","<p>Returns an array of the names of singleton methods for <em>obj</em>. If the optional <em>all</em> parameter is true, the …\n"],["singular?","Matrix","Matrix.html#method-i-singular-3F","()","<p>Returns <code>true</code> if this is a singular matrix.\n"],["singular?","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-singular-3F","()","<p>Returns <code>true</code> if <code>U</code>, and hence <code>A</code>, is singular.\n"],["sinh","Math","Math.html#method-c-sinh","(p1)","<p>Computes the hyperbolic sine of <code>x</code> (expressed in radians).\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (-INFINITY, …\n"],["site","Net::FTP","Net/FTP.html#method-i-site","(arg)","<p>Issues a SITE command.\n"],["size","Array","Array.html#method-i-size","()",""],["size","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-i-size","()","<p>Size of this connection pool\n"],["size","Bundler::Index","Bundler/Index.html#method-i-size","()",""],["size","Bundler::SpecSet","Bundler/SpecSet.html#method-i-size","()",""],["size","DBM","DBM.html#method-i-size","()","<p>Returns the number of entries in the database.\n"],["size","Digest::Instance","Digest/Instance.html#method-i-size","()","<p>Returns digest_obj.digest_length().\n"],["size","ENV","ENV.html#method-c-size","()","<p>Returns the number of environment variables.\n"],["size","Enumerator","Enumerator.html#method-i-size","()","<p>Returns the size of the enumerator, or <code>nil</code> if it can&#39;t be calculated lazily.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">100</span>).<span class=\"ruby-identifier\">to_a</span>.<span class=\"ruby-identifier\">permutation</span>(<span class=\"ruby-value\">4</span>).<span class=\"ruby-identifier\">size</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["size","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-size","()","<p>Returns the number of elements in this arithmetic sequence if it is a finite sequence.  Otherwise, returns …\n"],["size","Enumerator::Chain","Enumerator/Chain.html#method-i-size","()","<p>Returns the total size of the enumerator chain calculated by summing up the size of each enumerable in …\n"],["size","Fiddle::CStructEntity","Fiddle/CStructEntity.html#method-c-size","(types)","<p>Returns the offset for the packed sizes for the given <code>types</code>.\n\n<pre>Fiddle::CStructEntity.size(\n  [ Fiddle::TYPE_DOUBLE, ...</pre>\n"],["size","Fiddle::CUnionEntity","Fiddle/CUnionEntity.html#method-c-size","(types)","<p>Returns the size needed for the union with the given <code>types</code>.\n\n<pre>Fiddle::CUnionEntity.size(\n  [ Fiddle::TYPE_DOUBLE, ...</pre>\n"],["size","Fiddle::Pointer","Fiddle/Pointer.html#method-i-size","()","<p>Get the size of this pointer.\n"],["size","File","File.html#method-i-size","()","<p>Returns the size of <em>file</em> in bytes.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">size</span>   <span class=\"ruby-comment\">#=&gt; 66</span>\n</pre>\n"],["size","File","File.html#method-c-size","(p1)","<p>Returns the size of <code>file_name</code>.\n<p><em>file_name</em> can be an IO object.\n"],["size","File::Stat","File/Stat.html#method-i-size","()","<p>Returns the size of <em>stat</em> in bytes.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">size</span>   <span class=\"ruby-comment\">#=&gt; 66</span>\n</pre>\n"],["size","FileTest","FileTest.html#method-i-size","(p1)","<p>Returns the size of <code>file_name</code>.\n<p><em>file_name</em> can be an IO object.\n"],["size","GDBM","GDBM.html#method-i-size","()","<p>Returns the number of key-value pairs in this database.\n"],["size","Gem::AvailableSet","Gem/AvailableSet.html#method-i-size","()",""],["size","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-size","()",""],["size","Gem::Resolver::RequirementList","Gem/Resolver/RequirementList.html#method-i-size","()","<p>How many elements are in the list\n"],["size","Hash","Hash.html#method-i-size","()","<p>Returns the number of key-value pairs in the hash.\n\n<pre>h = { &quot;d&quot; =&gt; 100, &quot;a&quot; =&gt; 200, &quot;v&quot; =&gt; 300, &quot;e&quot; =&gt; 400 ...</pre>\n"],["size","Integer","Integer.html#method-i-size","()","<p>Returns the number of bytes in the machine representation of <code>int</code> (machine dependent).\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">size</span>          <span class=\"ruby-operator\">...</span>\n</pre>\n"],["size","MatchData","MatchData.html#method-i-size","()","<p>Returns the number of elements in the match array.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> = <span class=\"ruby-regexp\">/(.)(.)(\\d+)(\\d)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;THX1138.&quot;</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">length</span>   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["size","Net::FTP","Net/FTP.html#method-i-size","(filename)","<p>Returns the size of the given (remote) filename.\n"],["size","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-size","()","<p>Returns the number of referenced objects\n"],["size","Pathname","Pathname.html#method-i-size","()","<p>See FileTest.size.\n"],["size","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-size","()",""],["size","Queue","Queue.html#method-i-size","()",""],["size","REXML::Attributes","REXML/Attributes.html#method-i-size","()",""],["size","REXML::Elements","REXML/Elements.html#method-i-size","()","<p>Returns the number of <code>Element</code> children of the parent object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">doc</span> = <span class=\"ruby-constant\">Document</span>.<span class=\"ruby-identifier\">new</span> <span class=\"ruby-string\">&#39;&lt;a&gt;sean&lt;b/&gt;elliott&lt;b/&gt;russell&lt;b/&gt;&lt;/a&gt;&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["size","REXML::Light::Node","REXML/Light/Node.html#method-i-size","()",""],["size","REXML::Parent","REXML/Parent.html#method-i-size","()","<p>@return the number of children of this parent\n"],["size","Racc::Grammar","Racc/Grammar.html#method-i-size","()",""],["size","Racc::ISet","Racc/ISet.html#method-i-size","()",""],["size","Racc::Rule","Racc/Rule.html#method-i-size","()",""],["size","Racc::States","Racc/States.html#method-i-size","()",""],["size","Range","Range.html#method-i-size","()","<p>Returns the number of elements in the range. Both the begin and the end of the Range must be Numeric …\n"],["size","Rinda::Tuple","Rinda/Tuple.html#method-i-size","()","<p>The number of elements in the tuple.\n"],["size","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-size","()","<p>The size of the tuple.\n"],["size","SDBM","SDBM.html#method-i-size","()","<p>Returns the number of keys in the database.\n"],["size","Set","Set.html#method-i-size","()","<p>Returns the number of elements.\n"],["size","SizedQueue","SizedQueue.html#method-i-size","()",""],["size","String","String.html#method-i-size","()","<p>Returns the character length of <em>str</em>.\n"],["size","StringIO","StringIO.html#method-i-size","()","<p>Returns the size of the buffer string.\n"],["size","StringScanner","StringScanner.html#method-i-size","()","<p>Returns the amount of subgroups in the most recent match. The full match counts as a subgroup.\n\n<pre>s = StringScanner.new(&quot;Fri ...</pre>\n"],["size","Struct","Struct.html#method-i-size","()","<p>Returns the number of struct members.\n\n<pre>Customer = Struct.new(:name, :address, :zip)\njoe = Customer.new(&quot;Joe ...</pre>\n"],["size","Symbol","Symbol.html#method-i-size","()","<p>Same as <code>sym.to_s.length</code>.\n"],["size","Tempfile","Tempfile.html#method-i-size","()","<p>Returns the size of the temporary file.  As a side effect, the IO buffer is flushed before determining …\n"],["size","Vector","Vector.html#method-i-size","()","<p>Returns the number of elements in the vector.\n"],["size=","Fiddle::Pointer","Fiddle/Pointer.html#method-i-size-3D","(p1)","<p>Set the size of this pointer to <code>size</code>\n"],["size=","RSS::ImageFaviconModel::ImageFavicon","RSS/ImageFaviconModel/ImageFavicon.html#method-i-size-3D","(new_value)",""],["size?","File","File.html#method-c-size-3F","(p1)","<p>Returns <code>nil</code> if <code>file_name</code> doesn&#39;t exist or has zero size, the size of the file otherwise.\n<p><em>file_name</em> …\n"],["size?","File::Stat","File/Stat.html#method-i-size-3F","()","<p>Returns the size of <em>stat</em> in bytes.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">size</span>   <span class=\"ruby-comment\">#=&gt; 66</span>\n</pre>\n"],["size?","FileTest","FileTest.html#method-i-size-3F","(p1)","<p>Returns <code>nil</code> if <code>file_name</code> doesn&#39;t exist or has zero size, the size of the file otherwise.\n<p><em>file_name</em> …\n"],["size?","Pathname","Pathname.html#method-i-size-3F","()","<p>See FileTest.size?.\n"],["size_opt_params","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-size_opt_params","()","<p>Returns the size of optional parameters.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["size_params","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-size_params","()","<p>Returns the size of arguments of the method.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["sizeof","Fiddle::Importer","Fiddle/Importer.html#method-i-sizeof","(ty)","<p>Returns the sizeof <code>ty</code>, using Fiddle::Importer.parse_ctype to determine the C type and the appropriate …\n"],["skew_symmetric?","Matrix","Matrix.html#method-i-skew_symmetric-3F","()",""],["skip","ARGF","ARGF.html#method-i-skip","()","<p>Sets the current file to the next file in ARGV. If there aren&#39;t any more files it has no effect. …\n"],["skip","Bundler::Deprecate","Bundler/Deprecate.html#method-c-skip","()",""],["skip","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-skip","(type)",""],["skip","StringScanner","StringScanner.html#method-i-skip","(p1)","<p>Attempts to skip over the given <code>pattern</code> beginning with the scan pointer. If it matches, the scan pointer …\n"],["skip=","Bundler::Deprecate","Bundler/Deprecate.html#method-c-skip-3D","(skip)",""],["skip_blanks?","CSV","CSV.html#method-i-skip_blanks-3F","()","<p>Returns <code>true</code> blank lines are skipped by the parser. See CSV::new for details.\n"],["skip_blanks?","CSV::Parser","CSV/Parser.html#method-i-skip_blanks-3F","()",""],["skip_comment","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-skip_comment","()",""],["skip_during","Bundler::Deprecate","Bundler/Deprecate.html#method-c-skip_during","()",""],["skip_during","Gem::Deprecate","Gem/Deprecate.html#method-c-skip_during","()","<p>Temporarily turn off warnings. Intended for tests only.\n"],["skip_during","Gem::Deprecate","Gem/Deprecate.html#method-i-skip_during","()","<p>Temporarily turn off warnings. Intended for tests only.\n"],["skip_for_variable","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-skip_for_variable","()","<p>skip the var [in] part of a &#39;for&#39; statement\n"],["skip_line?","CSV::Parser","CSV/Parser.html#method-i-skip_line-3F","(line)",""],["skip_lines","CSV","CSV.html#method-i-skip_lines","()","<p>The regex marking a line as a comment. See CSV::new for details.\n"],["skip_lines","CSV::Parser","CSV/Parser.html#method-i-skip_lines","()",""],["skip_method","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-skip_method","(container)","<p>Skips the next method in <code>container</code>\n"],["skip_needless_lines","CSV::Parser","CSV/Parser.html#method-i-skip_needless_lines","()",""],["skip_optional_do_after_expression","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-skip_optional_do_after_expression","()","<p>while, until, and for have an optional do\n"],["skip_tkspace","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-skip_tkspace","()","<p>Skips whitespace tokens including newlines\n"],["skip_tkspace_comment","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-skip_tkspace_comment","(skip_nl = true)","<p>Skip spaces until a comment is found\n"],["skip_tkspace_without_nl","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-skip_tkspace_without_nl","()","<p>Skips whitespace tokens excluding newlines\n"],["skip_until","StringScanner","StringScanner.html#method-i-skip_until","(p1)","<p>Advances the scan pointer until <code>pattern</code> is matched and consumed.  Returns the number of bytes advanced, …\n"],["sleep","Kernel","Kernel.html#method-i-sleep","(*args)","<p>Suspends the current thread for <em>duration</em> seconds (which may be any number, including a <code>Float</code> with fractional …\n"],["sleep","Mutex","Mutex.html#method-i-sleep","(*args)","<p>Releases the lock and sleeps <code>timeout</code> seconds if it is given and non-nil or forever.  Raises <code>ThreadError</code> …\n"],["sleep","Mutex_m","Mutex_m.html#method-i-sleep","(timeout = nil)","<p>See Mutex#sleep\n"],["slice","Array","Array.html#method-i-slice","(*args)","<p>Element Reference — Returns the element at <code>index</code>, or returns a subarray starting at the <code>start</code> index …\n"],["slice","ENV","ENV.html#method-c-slice","(*args)","<p>Returns a hash containing only the given keys from ENV and their values.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">slice</span>(<span class=\"ruby-string\">&quot;TERM&quot;</span>,<span class=\"ruby-string\">&quot;HOME&quot;</span>)  <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["slice","Hash","Hash.html#method-i-slice","(*args)","<p>Returns a hash containing only the given keys and their values.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-value\">a:</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-value\">b:</span> <span class=\"ruby-value\">200</span>, <span class=\"ruby-value\">c:</span> <span class=\"ruby-value\">300</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">slice</span>(<span class=\"ruby-value\">:a</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["slice","Ripper","Ripper.html#method-c-slice","(src, pattern, n = 0)","<p>EXPERIMENTAL &mdash; Parses <code>src</code> and return a string which was matched to <code>pattern</code>. <code>pattern</code> should be described …\n"],["slice","String","String.html#method-i-slice","(*args)","<p>Element Reference — If passed a single <code>index</code>, returns a substring of one character at that index.  …\n"],["slice","Symbol","Symbol.html#method-i-slice","(*args)","<p>Returns <code>sym.to_s[]</code>.\n"],["slice!","Array","Array.html#method-i-slice-21","(*args)","<p>Deletes the element(s) given by an <code>index</code> (optionally up to <code>length</code> elements) or by a <code>range</code>.\n<p>Returns the …\n"],["slice!","String","String.html#method-i-slice-21","(*args)","<p>Deletes the specified portion from <em>str</em>, and returns the portion deleted.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">string</span> = <span class=\"ruby-string\">&quot;this is a string&quot;</span>\n<span class=\"ruby-identifier\">string</span>.<span class=\"ruby-identifier\">slice!</span>(<span class=\"ruby-value\">2</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["slice_after","Enumerable","Enumerable.html#method-i-slice_after","(p1)","<p>Creates an enumerator for each chunked elements. The ends of chunks are defined by <em>pattern</em> and the block. …\n"],["slice_after","Enumerator::Lazy","Enumerator/Lazy.html#method-i-slice_after","(*args)","<p>Like Enumerable#slice_after, but chains operation to be lazy-evaluated.\n"],["slice_before","Enumerable","Enumerable.html#method-i-slice_before","(p1)","<p>Creates an enumerator for each chunked elements. The beginnings of chunks are defined by <em>pattern</em> and …\n"],["slice_before","Enumerator::Lazy","Enumerator/Lazy.html#method-i-slice_before","(*args)","<p>Like Enumerable#slice_before, but chains operation to be lazy-evaluated.\n"],["slice_body","Bundler::CompactIndexClient::Updater","Bundler/CompactIndexClient/Updater.html#method-i-slice_body","(body, range)",""],["slice_when","Enumerable","Enumerable.html#method-i-slice_when","()","<p>Creates an enumerator for each chunked elements. The beginnings of chunks are defined by the block.\n<p>This …\n"],["slice_when","Enumerator::Lazy","Enumerator/Lazy.html#method-i-slice_when","(*args)","<p>Like Enumerable#slice_when, but chains operation to be lazy-evaluated.\n"],["sn","OpenSSL::ASN1::ObjectId","OpenSSL/ASN1/ObjectId.html#method-i-sn","()","<p>The short name of the ObjectId, as defined in &lt;openssl/objects.h&gt;.\n"],["snake_case","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-snake_case","(str)","<p>Receives a string and convert it to snake case. SnakeCase returns snake_case.\n<p>Parameters\n<p>String\n"],["snippet","RDoc::Text","RDoc/Text.html#method-i-snippet","(text, limit = 100)","<p>The first <code>limit</code> characters of <code>text</code> as HTML\n"],["sockaddr_in","Socket","Socket.html#method-c-sockaddr_in","(p1, p2)","<p>Packs <em>port</em> and <em>host</em> as an AF_INET/AF_INET6 sockaddr string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">sockaddr_in</span>(<span class=\"ruby-value\">80</span>, <span class=\"ruby-string\">&quot;127.0.0.1&quot;</span>)\n<span class=\"ruby-comment\">#=&gt; &quot;\\x02\\x00\\x00P\\x7F\\x00\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00&quot; ...</span>\n</pre>\n"],["sockaddr_un","Socket","Socket.html#method-c-sockaddr_un","(p1)","<p>Packs <em>path</em> as an AF_UNIX sockaddr string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">sockaddr_un</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>) <span class=\"ruby-comment\">#=&gt; &quot;\\x01\\x00/tmp/sock\\x00\\x00...&quot;</span>\n</pre>\n"],["socket?","File","File.html#method-c-socket-3F","(p1)","<p>Returns <code>true</code> if the named file is a socket.\n<p><em>file_name</em> can be an IO object.\n"],["socket?","File::Stat","File/Stat.html#method-i-socket-3F","()","<p>Returns <code>true</code> if <em>stat</em> is a socket, <code>false</code> if it isn&#39;t or if the operating system doesn&#39;t support …\n"],["socket?","FileTest","FileTest.html#method-i-socket-3F","(p1)","<p>Returns <code>true</code> if the named file is a socket.\n<p><em>file_name</em> can be an IO object.\n"],["socket?","Pathname","Pathname.html#method-i-socket-3F","()","<p>See FileTest.socket?.\n"],["socketpair","Socket","Socket.html#method-c-socketpair","(p1, p2, p3 = v3)","<p>Creates a pair of sockets connected each other.\n<p><em>domain</em> should be a communications domain such as: :INET, …\n"],["socketpair","UNIXSocket","UNIXSocket.html#method-c-socketpair","(p1 = v1, p2 = v2)","<p>Creates a pair of sockets connected to each other.\n<p><em>socktype</em> should be a socket type such as: :STREAM, …\n"],["socktype","Addrinfo","Addrinfo.html#method-i-socktype","()","<p>returns the socket type as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">socktype</span> <span class=\"ruby-operator\">==</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">SOCK_STREAM</span> <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["solve","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-solve","(b)","<p>Returns <code>m</code> so that <code>A*m = b</code>, or equivalently so that <code>L*U*m = P*b</code> <code>b</code> can be a Matrix or a Vector\n"],["sort","Array","Array.html#method-i-sort","()","<p>Returns a new array created by sorting <code>self</code>.\n<p>Comparisons for the sort will be done using the <code>&lt;=&gt;</code> …\n"],["sort","Enumerable","Enumerable.html#method-i-sort","()","<p>Returns an array containing the items in <em>enum</em> sorted.\n<p>Comparisons for the sort will be done using the …\n"],["sort","Net::IMAP","Net/IMAP.html#method-i-sort","(sort_keys, search_keys, charset)","<p>Sends a SORT command to sort messages in the mailbox. Returns an array of message sequence numbers.  …\n"],["sort","REXML::XPathParser","REXML/XPathParser.html#method-i-sort","(array_of_nodes, order)","<p>Reorders an array of nodes so that they are in document order It tries to do this efficiently.\n<p>FIXME: …\n"],["sort!","Array","Array.html#method-i-sort-21","()","<p>Sorts <code>self</code> in place.\n<p>Comparisons for the sort will be done using the <code>&lt;=&gt;</code> operator or using an optional …\n"],["sort!","Bundler::SpecSet","Bundler/SpecSet.html#method-i-sort-21","()",""],["sort_by","Enumerable","Enumerable.html#method-i-sort_by","()","<p>Sorts <em>enum</em> using a set of keys generated by mapping the values in <em>enum</em> through the given block.\n<p>The result …\n"],["sort_by!","Array","Array.html#method-i-sort_by-21","()","<p>Sorts <code>self</code> in place using a set of keys generated by mapping the values in <code>self</code> through the given block. …\n"],["sort_by!","Gem::Specification","Gem/Specification.html#method-c-sort_by-21","(list, &block)",""],["sort_dep_specs","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-sort_dep_specs","(spec_groups, locked_spec)",""],["sort_dependencies","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-sort_dependencies","(dependencies, activated, conflicts)","<p>(see Bundler::Molinillo::SpecificationProvider#sort_dependencies)\n"],["sort_dependencies","Bundler::Molinillo::SpecificationProvider","Bundler/Molinillo/SpecificationProvider.html#method-i-sort_dependencies","(dependencies, activated, conflicts)","<p>Sort dependencies so that the ones that are easiest to resolve are first. Easiest to resolve is (usually) …\n"],["sort_dependencies","Bundler::Resolver","Bundler/Resolver.html#method-i-sort_dependencies","(dependencies, activated, conflicts)",""],["sort_dependencies","Gem::Resolver","Gem/Resolver.html#method-i-sort_dependencies","(dependencies, activated, conflicts)",""],["sort_dependencies","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-sort_dependencies","(dependencies, activated, conflicts)","<p>(see Gem::Resolver::Molinillo::SpecificationProvider#sort_dependencies)\n"],["sort_dependencies","Gem::Resolver::Molinillo::SpecificationProvider","Gem/Resolver/Molinillo/SpecificationProvider.html#method-i-sort_dependencies","(dependencies, activated, conflicts)","<p>Sort dependencies so that the ones that are easiest to resolve are first. Easiest to resolve is (usually) …\n"],["sort_if_need","RSS::Maker::ItemsBase","RSS/Maker/ItemsBase.html#method-i-sort_if_need","()",""],["sort_internal","Net::IMAP","Net/IMAP.html#method-i-sort_internal","(cmd, sort_keys, search_keys, charset)",""],["sort_obj","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-sort_obj","()","<p>Create a delegate used for sorting. This strategy is copied from RubyGems 2.23 and ensures that Bundler&#39;s …\n"],["sort_obj","Gem::Specification","Gem/Specification.html#method-i-sort_obj","()","<p>Returns an object you can use to sort specifications in #sort_by.\n"],["sort_platforms","Bundler::Resolver","Bundler/Resolver.html#method-c-sort_platforms","(platforms)","<p>Sort platforms from most general to most specific\n"],["sort_sections","RDoc::Context","RDoc/Context.html#method-i-sort_sections","()","<p>Sorts sections alphabetically (default) or in TomDoc fashion (none, Public, Internal, Deprecated)\n"],["sort_specs","Bundler::Index","Bundler/Index.html#method-i-sort_specs","(specs)",""],["sort_specs","Bundler::Index","Bundler/Index.html#method-c-sort_specs","(specs)",""],["sort_versions","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-sort_versions","(dep, spec_groups)","<p>Given a Dependency and an Array of SpecGroups of available versions for a gem, this method will return …\n"],["sorted","Bundler::SpecSet","Bundler/SpecSet.html#method-i-sorted","()",""],["sorted","Gem::AvailableSet","Gem/AvailableSet.html#method-i-sorted","()",""],["sorted_requests","Gem::RequestSet","Gem/RequestSet.html#method-i-sorted_requests","()",""],["source","Bundler::Dsl","Bundler/Dsl.html#method-i-source","(source, *args, &blk)",""],["source","Bundler::Plugin","Bundler/Plugin.html#method-i-source","(name)","<p>@return [Class] that handles the source. The calss includes API::Source\n"],["source","Bundler::Plugin::API","Bundler/Plugin/API.html#method-c-source","(source, cls = self)","<p>The plugins should declare that they provide a installation source through this helper.\n<p>@param [String] …\n"],["source","Bundler::Plugin::DSL","Bundler/Plugin/DSL.html#method-i-source","(source, *args, &blk)",""],["source","Gem::RequestSet::GemDependencyAPI","Gem/RequestSet/GemDependencyAPI.html#method-i-source","(url)","<p>Sets <code>url</code> as a source for gems for this dependency API.  RubyGems uses the default configured sources …\n"],["source","Gem::Resolver::InstalledSpecification","Gem/Resolver/InstalledSpecification.html#method-i-source","()","<p>The source for this specification\n"],["source","Gem::Specification","Gem/Specification.html#method-i-source","()",""],["source","JSON::Ext::Parser","JSON/Ext/Parser.html#method-i-source","()","<p>Returns a copy of the current <em>source</em> string, that was used to construct this Parser.\n"],["source","RDoc::Store","RDoc/Store.html#method-i-source","()","<p>Source of the contents of this store.\n<p>For a store from a gem the source is the gem name.  For a store …\n"],["source","REXML::Parsers::SAX2Parser","REXML/Parsers/SAX2Parser.html#method-i-source","()",""],["source","Regexp","Regexp.html#method-i-source","()","<p>Returns the original string of the pattern.\n\n<pre class=\"ruby\"><span class=\"ruby-regexp\">/ab+c/ix</span>.<span class=\"ruby-identifier\">source</span> <span class=\"ruby-comment\">#=&gt; &quot;ab+c&quot;</span>\n</pre>\n<p>Note that escape sequences are retained …\n"],["source=","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-source-3D","(source)",""],["source?","Bundler::Plugin","Bundler/Plugin.html#method-i-source-3F","(name)","<p>Checks if any plugin declares the source\n"],["source?","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-source-3F","(source)",""],["source?","Racc::UserAction","Racc/UserAction.html#method-i-source-3F","()",""],["source_date_epoch","Gem","Gem.html#method-c-source_date_epoch","()","<p>Returns the value of Gem.source_date_epoch_string, as a Time object.\n<p>This is used throughout RubyGems …\n"],["source_date_epoch_string","Gem","Gem.html#method-c-source_date_epoch_string","()","<p>If the SOURCE_DATE_EPOCH environment variable is set, returns it&#39;s value. Otherwise, returns the …\n"],["source_encoding","Encoding::Converter","Encoding/Converter.html#method-i-source_encoding","()","<p>Returns the source encoding as an Encoding object.\n"],["source_encoding","Encoding::InvalidByteSequenceError","Encoding/InvalidByteSequenceError.html#method-i-source_encoding","()","<p>Returns the source encoding as an encoding object.\n<p>Note that the result may not be equal to the source …\n"],["source_encoding","Encoding::UndefinedConversionError","Encoding/UndefinedConversionError.html#method-i-source_encoding","()","<p>Returns the source encoding as an encoding object.\n<p>Note that the result may not be equal to the source …\n"],["source_encoding_name","Encoding::InvalidByteSequenceError","Encoding/InvalidByteSequenceError.html#method-i-source_encoding_name","()","<p>Returns the source encoding name as a string.\n"],["source_encoding_name","Encoding::UndefinedConversionError","Encoding/UndefinedConversionError.html#method-i-source_encoding_name","()","<p>Returns the source encoding name as a string.\n"],["source_file","IRB::IrbLoader","IRB/IrbLoader.html#method-i-source_file","(path)","<p>Loads a given file in the current session and displays the source lines\n<p>See Irb#suspend_input_method for …\n"],["source_for","Gem::AvailableSet","Gem/AvailableSet.html#method-i-source_for","(spec)",""],["source_from_lock","Bundler::Plugin","Bundler/Plugin.html#method-i-source_from_lock","(locked_opts)","<p>@param [Hash] The options that are present in the lock file @return [API::Source] the instance of the …\n"],["source_list_for","Bundler::SourceList","Bundler/SourceList.html#method-i-source_list_for","(source)",""],["source_location","Binding","Binding.html#method-i-source_location","()","<p>Returns the Ruby source filename and line number of the binding object.\n"],["source_location","Method","Method.html#method-i-source_location","()","<p>Returns the Ruby source filename and line number containing this method or nil if this method was not …\n"],["source_location","Proc","Proc.html#method-i-source_location","()","<p>Returns the Ruby source filename and line number containing this proc or <code>nil</code> if this proc was not defined …\n"],["source_location","UnboundMethod","UnboundMethod.html#method-i-source_location","()","<p>Returns the Ruby source filename and line number containing this method or nil if this method was not …\n"],["source_ole_types","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-source_ole_types","()","<p>Returns the array of WIN32OLE_TYPE object which is implemented by the WIN32OLE_TYPE object and having …\n"],["source_paths","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-source_paths","()","<p>Holds source paths in instance so they can be manipulated.\n"],["source_paths","Bundler::Thor::Actions::ClassMethods","Bundler/Thor/Actions/ClassMethods.html#method-i-source_paths","()","<p>Hold source paths for one Bundler::Thor instance. source_paths_for_search is the method responsible to …\n"],["source_paths","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-source_paths","()","<p>Returns the paths to the source files for use with analysis and documentation tools.  These paths are …\n"],["source_paths_for_search","Bundler::Thor::Actions::ClassMethods","Bundler/Thor/Actions/ClassMethods.html#method-i-source_paths_for_search","()","<p>Returns the source paths in the following order:\n\n<pre>1) This class source paths\n2) Source root\n3) Parents ...</pre>\n"],["source_plugin","Bundler::Plugin::Index","Bundler/Plugin/Index.html#method-i-source_plugin","(name)",""],["source_requirements","Bundler::Definition","Bundler/Definition.html#method-i-source_requirements","()",""],["source_root","Bundler::CLI","Bundler/CLI.html#method-c-source_root","()",""],["source_root","Bundler::Thor::Actions::ClassMethods","Bundler/Thor/Actions/ClassMethods.html#method-i-source_root","(path = nil)","<p>Stores and return the source root for this class\n"],["source_text","Racc::UserAction","Racc/UserAction.html#method-c-source_text","(src)",""],["sources","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-sources","()",""],["sources","Gem","Gem.html#method-c-sources","()","<p>Returns an Array of sources to fetch remote gems from. Uses default_sources if the sources list is empty. …\n"],["sources=","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-sources-3D","(val)",""],["sources=","Gem","Gem.html#method-c-sources-3D","(new_sources)","<p>Need to be able to set the sources without calling Gem.sources.replace since that would cause an infinite …\n"],["space","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-space","()","<p>Returns the string that is used to insert a space between the tokens in a JSON string.\n"],["space=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-space-3D","(p1)","<p>Sets <em>space</em> to the string that is used to insert a space between the tokens in a JSON string.\n"],["space_before","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-space_before","()","<p>Returns the string that is used to insert a space before the &#39;:&#39; in JSON objects.\n"],["space_before=","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-space_before-3D","(p1)","<p>Sets the string that is used to insert a space before the &#39;:&#39; in JSON objects.\n"],["spawn","Kernel","Kernel.html#method-i-spawn","(*args)","<p>spawn executes specified command and return its pid.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">pid</span> = <span class=\"ruby-identifier\">spawn</span>(<span class=\"ruby-string\">&quot;tar xf ruby-2.0.0-p195.tar.bz2&quot;</span>)\n<span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">wait</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["spawn","PTY","PTY.html#method-c-spawn","(*args)","<p>Spawns the specified command on a newly allocated pty. You can also use the alias ::getpty.\n<p>The command&#39;s …\n"],["spawn","Process","Process.html#method-c-spawn","(*args)","<p>spawn executes specified command and return its pid.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">pid</span> = <span class=\"ruby-identifier\">spawn</span>(<span class=\"ruby-string\">&quot;tar xf ruby-2.0.0-p195.tar.bz2&quot;</span>)\n<span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">wait</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["spec","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-spec","(name, version, platform = nil)",""],["spec","Gem::Installer","Gem/Installer.html#method-i-spec","()","<p>Lazy accessor for the installer&#39;s spec.\n"],["spec","Gem::Package","Gem/Package.html#method-i-spec","()","<p>The spec for this gem.\n<p>If this is a package for a built gem the spec is loaded from the gem and returned. …\n"],["spec","Gem::Package::Old","Gem/Package/Old.html#method-i-spec","()","<p>The specification for this gem\n"],["spec","Gem::Resolver::LockSpecification","Gem/Resolver/LockSpecification.html#method-i-spec","()","<p>A specification constructed from the lockfile is returned\n"],["spec","Gem::TestCase::SpecFetcherSetup","Gem/TestCase/SpecFetcherSetup.html#method-i-spec","(name, version, dependencies = nil, &block)","<p>Creates a spec with <code>name</code>, <code>version</code> and <code>deps</code>.  The created gem can be downloaded and installed.\n<p>The specification …\n"],["spec_authors","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-spec_authors","(entry, spec)",""],["spec_cache_dir","Gem","Gem.html#method-c-spec_cache_dir","()",""],["spec_cache_dirs","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-spec_cache_dirs","()",""],["spec_default_gem?","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-spec_default_gem-3F","(spec)",""],["spec_dir","Gem::Specification","Gem/Specification.html#method-i-spec_dir","()","<p>Returns the full path to the directory containing this spec&#39;s gemspec file. eg: /usr/local/lib/ruby/gems/1.8/specifications …\n"],["spec_extension_dir","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-spec_extension_dir","(spec)",""],["spec_file","Gem::Installer","Gem/Installer.html#method-i-spec_file","()","<p>The location of the spec file that is installed.\n"],["spec_file","Gem::Specification","Gem/Specification.html#method-i-spec_file","()","<p>Returns the full path to this spec&#39;s gemspec file. eg: /usr/local/lib/ruby/gems/1.8/specifications/mygem-1.0.gemspec …\n"],["spec_for","Gem::Commands::ContentsCommand","Gem/Commands/ContentsCommand.html#method-i-spec_for","(name)",""],["spec_for","Gem::Commands::OpenCommand","Gem/Commands/OpenCommand.html#method-i-spec_for","(name)",""],["spec_for_dependency","Bundler::Graph","Bundler/Graph.html#method-i-spec_for_dependency","(dependency)",""],["spec_for_dependency","Bundler::SpecSet","Bundler/SpecSet.html#method-i-spec_for_dependency","(dep, match_current_platform)",""],["spec_for_dependency","Gem::SpecFetcher","Gem/SpecFetcher.html#method-i-spec_for_dependency","(dependency, matching_platform=true)","<p>Find and fetch specs that match <code>dependency</code>.\n<p>If <code>matching_platform</code> is false, gems for all platforms are …\n"],["spec_for_gem","Bundler::CLI::Info","Bundler/CLI/Info.html#method-i-spec_for_gem","(gem_name)",""],["spec_from_gem","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-spec_from_gem","(path, policy = nil)",""],["spec_git_paths","Bundler::Definition","Bundler/Definition.html#method-i-spec_git_paths","()",""],["spec_groups","Gem::RequestSet::Lockfile","Gem/RequestSet/Lockfile.html#method-i-spec_groups","()",""],["spec_homepage","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-spec_homepage","(entry, spec)",""],["spec_license","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-spec_license","(entry, spec)",""],["spec_loaded_from","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-spec_loaded_from","(entry, spec, specs)",""],["spec_matches_for_glob","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-spec_matches_for_glob","(spec, glob)",""],["spec_missing_extensions?","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-spec_missing_extensions-3F","(spec, default = true)",""],["spec_name","Gem::NameTuple","Gem/NameTuple.html#method-i-spec_name","()","<p>Return the name that the gemspec file would be\n"],["spec_name","Gem::Specification","Gem/Specification.html#method-i-spec_name","()","<p>The default name of the gemspec.  See also #file_name\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">spec</span>.<span class=\"ruby-identifier\">spec_name</span> <span class=\"ruby-comment\"># =&gt; &quot;example-1.0.gemspec&quot;</span>\n</pre>\n"],["spec_names","Bundler::Index","Bundler/Index.html#method-i-spec_names","()",""],["spec_not_found","Bundler::CLI::Info","Bundler/CLI/Info.html#method-i-spec_not_found","(gem_name)",""],["spec_path","Gem::Commands::LockCommand","Gem/Commands/LockCommand.html#method-i-spec_path","(gem_full_name)",""],["spec_platforms","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-spec_platforms","(entry, platforms)",""],["spec_predecessors","Gem::DependencyList","Gem/DependencyList.html#method-i-spec_predecessors","()","<p>Return a hash of predecessors.  <code>result[spec]</code> is an Array of gemspecs that have a dependency satisfied …\n"],["spec_settings","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-spec_settings","()",""],["spec_summary","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-spec_summary","(entry, spec)",""],["special_prefixes","Readline","Readline.html#method-c-special_prefixes","()","<p>Gets the list of characters that are word break characters, but should be left in text when it is passed …\n"],["special_prefixes=","Readline","Readline.html#method-c-special_prefixes-3D","(p1)","<p>Sets the list of characters that are word break characters, but should be left in text when it is passed …\n"],["special_prefixes=","Reline::Core","Reline/Core.html#method-i-special_prefixes-3D","(v)",""],["specific?","Bundler::Dependency","Bundler/Dependency.html#method-i-specific-3F","()",""],["specific?","Gem::Dependency","Gem/Dependency.html#method-i-specific-3F","()","<p>True if the dependency will not always match the latest version.\n"],["specific?","Gem::Requirement","Gem/Requirement.html#method-i-specific-3F","()","<p>True if the requirement will not always match the latest version.\n"],["specific_dependency","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-specific_dependency","(name, version, platform)",""],["specific_extra_args","Gem::Command","Gem/Command.html#method-c-specific_extra_args","(cmd)","<p>Return an array of extra arguments for the command.  The extra arguments come from the gem configuration …\n"],["specific_extra_args_hash","Gem::Command","Gem/Command.html#method-c-specific_extra_args_hash","()","<p>Accessor for the specific extra args hash (self initializing).\n"],["specific_failure_message","Bundler::GemInstaller","Bundler/GemInstaller.html#method-i-specific_failure_message","(e)",""],["specific_gem_for","Bundler::Settings","Bundler/Settings.html#method-i-specific_gem_for","(name)",""],["specs","Bundler::Definition","Bundler/Definition.html#method-i-specs","()","<p>For given dependency list returns a SpecSet with Gemspec of all the required dependencies.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1</span>. <span class=\"ruby-constant\">The</span> <span class=\"ruby-identifier\">method</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["specs","Bundler::Fetcher","Bundler/Fetcher.html#method-i-specs","(gem_names, source)","<p>return the specs in the bundler format as an index\n"],["specs","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-specs","(gem_names)",""],["specs","Bundler::Fetcher::Dependency","Bundler/Fetcher/Dependency.html#method-i-specs","(gem_names, full_dependency_list = [], last_spec_list = [])",""],["specs","Bundler::Fetcher::Index","Bundler/Fetcher/Index.html#method-i-specs","(_gem_names)",""],["specs","Bundler::Gemdeps","Bundler/Gemdeps.html#method-i-specs","()",""],["specs","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-specs","()","<p>Parses the gemspec files to find the specs for the gems that can be satisfied by the source.\n<p>Few important …\n"],["specs","Bundler::Source::Git","Bundler/Source/Git.html#method-i-specs","(*)",""],["specs","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-specs","()",""],["specs","Bundler::Source::Path","Bundler/Source/Path.html#method-i-specs","()",""],["specs","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-specs","()",""],["specs","Gem::RequestSet","Gem/RequestSet.html#method-i-specs","()",""],["specs","Gem::Server","Gem/Server.html#method-i-specs","(req, res)",""],["specs","Gem::Source::Git","Gem/Source/Git.html#method-i-specs","()","<p>Loads all gemspecs in the repository\n"],["specs_by_name","Bundler::Index","Bundler/Index.html#method-i-specs_by_name","(name)",""],["specs_changed?","Bundler::Definition","Bundler/Definition.html#method-i-specs_changed-3F","(source)","<p>Check if the specs of the given source changed according to the locked source.\n"],["specs_for","Bundler::Definition","Bundler/Definition.html#method-i-specs_for","(groups)",""],["specs_for_names","Bundler::Fetcher::CompactIndex","Bundler/Fetcher/CompactIndex.html#method-i-specs_for_names","(gem_names)",""],["specs_for_source_changed?","Bundler::Definition","Bundler/Definition.html#method-i-specs_for_source_changed-3F","(source)",""],["specs_in","Gem::RequestSet","Gem/RequestSet.html#method-i-specs_in","(dir)",""],["specs_path","Bundler","Bundler.html#method-c-specs_path","()",""],["specs_type","Gem::Commands::QueryCommand","Gem/Commands/QueryCommand.html#method-i-specs_type","()",""],["specs_with_retry","Bundler::Fetcher","Bundler/Fetcher.html#method-i-specs_with_retry","(gem_names, source)","<p>return the specs in the bundler format as an index with retries\n"],["spell_checker","UndefinedCommandError::SpellChecker","UndefinedCommandError/SpellChecker.html#method-i-spell_checker","()",""],["spell_checker","UnknownArgumentError::SpellChecker","UnknownArgumentError/SpellChecker.html#method-i-spell_checker","()",""],["split","BigDecimal","BigDecimal.html#method-i-split","()","<p>Splits a BigDecimal number into four parts, returned as an array of values.\n<p>The first value represents …\n"],["split","Bundler::URI","Bundler/URI.html#method-c-split","(uri)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">split</span>(<span class=\"ruby-identifier\">uri</span>)\n</pre>\n<p>Args\n"],["split","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-split","(uri)","<p>Returns a split Bundler::URI against regexp.\n"],["split","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-split","(uri)","<p>Returns a split Bundler::URI against regexp.\n"],["split","File","File.html#method-c-split","(p1)","<p>Splits the given string into a directory and a file component and returns them in a two-element array. …\n"],["split","Pathname","Pathname.html#method-i-split","()","<p>Returns the #dirname and the #basename in an Array.\n<p>See File.split.\n"],["split","Shellwords","Shellwords.html#method-c-split","(line)",""],["split","String","String.html#method-i-split","(p1 = v1, p2 = v2)","<p>Divides <em>str</em> into substrings based on a delimiter, returning an array of these substrings.\n<p>If <em>pattern</em> is …\n"],["split","URI","URI.html#method-c-split","(uri)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">URI</span><span class=\"ruby-operator\">::</span><span class=\"ruby-identifier\">split</span>(<span class=\"ruby-identifier\">uri</span>)\n</pre>\n<p>Args\n"],["split","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-split","(uri)","<p>Returns a split URI against regexp.\n"],["split","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-split","(uri)","<p>Returns a split URI against regexp.\n"],["split_arguments","Fiddle::CParser","Fiddle/CParser.html#method-i-split_arguments","(arguments, sep=',')",""],["split_gem_path","Gem::PathSupport","Gem/PathSupport.html#method-i-split_gem_path","(gpaths, home)","<p>Split the Gem search path (as reported by Gem.path).\n"],["split_header_value","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-split_header_value","(str)","<p>Splits a header value <code>str</code> according to HTTP specification.\n"],["split_header_value","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-c-split_header_value","(str)","<p>Splits a header value <code>str</code> according to HTTP specification.\n"],["split_name","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-split_name","(name)",""],["split_path","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-split_path","(path)","<p>Returns an Array of the path split on &#39;/&#39;.\n"],["split_path","URI::Generic","URI/Generic.html#method-i-split_path","(path)","<p>Returns an Array of the path split on &#39;/&#39;.\n"],["split_specific_setting_for","Bundler::Settings","Bundler/Settings.html#method-i-split_specific_setting_for","(name)",""],["split_userinfo","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-split_userinfo","(ui)","<p>Returns the userinfo <code>ui</code> as <code>[user, password]</code> if properly formatted as &#39;user:password&#39;.\n"],["split_userinfo","URI::Generic","URI/Generic.html#method-i-split_userinfo","(ui)","<p>Returns the userinfo <code>ui</code> as <code>[user, password]</code> if properly formatted as &#39;user:password&#39;.\n"],["sprintf","Kernel","Kernel.html#method-i-sprintf","(*args)","<p>Returns the string resulting from applying <em>format_string</em> to any additional arguments.  Within the format …\n"],["sqr","OpenSSL::BN","OpenSSL/BN.html#method-i-sqr","()",""],["sqrt","BigDecimal","BigDecimal.html#method-i-sqrt","(p1)","<p>Returns the square root of the value.\n<p>Result has at least n significant digits.\n"],["sqrt","BigMath","BigMath.html#method-i-sqrt","(x, prec)","<p>Computes the square root of <code>decimal</code> to the specified number of digits of precision, <code>numeric</code>.\n\n<pre>BigMath.sqrt(BigDecimal(&#39;2&#39;), ...</pre>\n"],["sqrt","Integer","Integer.html#method-c-sqrt","(p1)","<p>Returns the integer square root of the non-negative integer <code>n</code>, i.e. the largest non-negative integer …\n"],["sqrt","Math","Math.html#method-c-sqrt","(p1)","<p>Returns the non-negative square root of <code>x</code>.\n<p>Domain: [0, INFINITY)\n<p>Codomain:[0, INFINITY)\n"],["square?","Matrix","Matrix.html#method-i-square-3F","()","<p>Returns <code>true</code> if this is a square matrix.\n"],["squeeze","String","String.html#method-i-squeeze","(*args)","<p>Builds a set of characters from the <em>other_str</em> parameter(s) using the procedure described for String#count …\n"],["squeeze!","String","String.html#method-i-squeeze-21","(*args)","<p>Squeezes <em>str</em> in place, returning either <em>str</em>, or <code>nil</code> if no changes were made.\n"],["sr_conflict","Racc::State","Racc/State.html#method-i-sr_conflict","(shift, reduce)",""],["srand","Kernel","Kernel.html#method-i-srand","(*args)","<p>Seeds the system pseudo-random number generator, Random::DEFAULT, with <code>number</code>.  The previous seed value …\n"],["srand","Random","Random.html#method-c-srand","(*args)","<p>Seeds the system pseudo-random number generator, Random::DEFAULT, with <code>number</code>.  The previous seed value …\n"],["src_type","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-src_type","()","<p>Returns source class when the OLE class is &#39;Alias&#39;.\n\n<pre>tobj =  WIN32OLE_TYPE.new(&#39;Microsoft Office ...</pre>\n"],["srconflict_exist?","Racc::States","Racc/States.html#method-i-srconflict_exist-3F","()",""],["ssl","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-ssl","(connection)","<p>Enables SSL on <code>connection</code>\n"],["ssl?","Net::SMTP","Net/SMTP.html#method-i-ssl-3F","()",""],["ssl?","WEBrick::HTTPRequest","WEBrick/HTTPRequest.html#method-i-ssl-3F","()","<p>Is this an SSL request?\n"],["ssl_params","Net::POP3","Net/POP3.html#method-c-ssl_params","()","<p>returns the SSL Parameters\n<p>see also POP3.enable_ssl\n"],["ssl_servername_callback","WEBrick::GenericServer","WEBrick/GenericServer.html#method-i-ssl_servername_callback","(sslsocket, hostname = nil)","<p>ServerNameIndication callback\n"],["ssl_servername_callback","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-ssl_servername_callback","(sslsocket, hostname = nil)","<p>ServerNameIndication callback\n"],["ssl_socket","Net::SMTP","Net/SMTP.html#method-i-ssl_socket","(socket, context)",""],["ssl_timeout=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-ssl_timeout-3D","(ssl_timeout)","<p>SSL session lifetime\n"],["ssl_version","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-ssl_version","()","<p>Returns a String representing the SSL/TLS version that was negotiated for the connection, for example …\n"],["ssl_version=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-ssl_version-3D","(ssl_version)","<p>SSL version to use\n"],["ssl_version=","OpenSSL::SSL::SSLContext","OpenSSL/SSL/SSLContext.html#method-i-ssl_version-3D","(meth)","<p>Sets the SSL/TLS protocol version for the context. This forces connections to use only the specified …\n"],["sspi_auth","Net::HTTP","Net/HTTP.html#method-i-sspi_auth","(req)",""],["sspi_auth?","Net::HTTP","Net/HTTP.html#method-i-sspi_auth-3F","(res)",""],["stand_alone?","REXML::Document","REXML/Document.html#method-i-stand_alone-3F","()","<p>@return the XMLDecl standalone value of this document as a String. If no XMLDecl has been set, returns …\n"],["start","Bundler::CLI","Bundler/CLI.html#method-c-start","(*)",""],["start","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-start","(http)","<p>Starts the Net::HTTP <code>connection</code>\n"],["start","Bundler::Resolver","Bundler/Resolver.html#method-i-start","(requirements)",""],["start","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-start","(given_args = ARGV, config = {})","<p>Parses the command and options from the given args, instantiate the class and invoke the command. This …\n"],["start","Coverage","Coverage.html#method-c-start","(p1 = v1)","<p>Enables coverage measurement.\n"],["start","Date","Date.html#method-i-start","()","<p>Returns the Julian day number denoting the day of calendar reform.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">start</span>           <span class=\"ruby-operator\">...</span>\n</pre>\n"],["start","GC","GC.html#method-c-start","(full_mark: true, immediate_mark: true, immediate_sweep: true)","<p>Initiates garbage collection, even if manually disabled.\n<p>This method is defined with keyword arguments …\n"],["start","IRB","IRB.html#method-c-start","(ap_path = nil)","<p>Initializes IRB and creates a new Irb.irb object at the <code>TOPLEVEL_BINDING</code>\n"],["start","Net::HTTP","Net/HTTP.html#method-c-start","(address, *arg)","<p>Creates a new Net::HTTP object, then additionally opens the TCP connection and HTTP session.\n<p>Arguments …\n"],["start","Net::HTTP","Net/HTTP.html#method-i-start","()","<p>Opens a TCP connection and HTTP session.\n<p>When this method is called with a block, it passes the Net::HTTP …\n"],["start","Net::POP3","Net/POP3.html#method-c-start","(address, port = nil, account = nil, password = nil, isapop = false)","<p>Creates a new POP3 object and open the connection.  Equivalent to\n\n<pre>Net::POP3.new(address, port, isapop).start(account, ...</pre>\n"],["start","Net::POP3","Net/POP3.html#method-i-start","(account, password)","<p>Starts a POP3 session.\n<p>When called with block, gives a POP3 object to the block and closes the session …\n"],["start","Net::SMTP","Net/SMTP.html#method-c-start","(address, port = nil, helo = 'localhost', user = nil, secret = nil, authtype = nil)","<p>Creates a new Net::SMTP object and connects to the server.\n<p>This method is equivalent to:\n\n<pre>Net::SMTP.new(address, ...</pre>\n"],["start","Net::SMTP","Net/SMTP.html#method-i-start","(helo = 'localhost', user = nil, secret = nil, authtype = nil)","<p>Opens a TCP connection and starts the SMTP session.\n<p>Parameters\n<p><code>helo</code> is the <em>HELO</em> <em>domain</em> that you&#39;ll …\n"],["start","Psych::Streaming","Psych/Streaming.html#method-i-start","(encoding = Nodes::Stream::UTF8)","<p>Start streaming using <code>encoding</code>\n"],["start","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-start","(encoding = Nodes::Stream::UTF8)",""],["start","Thread","Thread.html#method-c-start","(*args)","<p>Basically the same as ::new. However, if class Thread is subclassed, then calling <code>start</code> in that subclass …\n"],["start","WEBrick::CGI","WEBrick/CGI.html#method-i-start","(env=ENV, stdin=$stdin, stdout=$stdout)","<p>Starts the CGI process with the given environment <code>env</code> and standard input and output <code>stdin</code> and <code>stdout</code> …\n"],["start","WEBrick::Daemon","WEBrick/Daemon.html#method-c-start","()","<p>Performs the standard operations for daemonizing a process.  Runs a block, if given.\n"],["start","WEBrick::GenericServer","WEBrick/GenericServer.html#method-i-start","(&block)","<p>Starts the server and runs the <code>block</code> for each connection.  This method does not return until the server …\n"],["start","WEBrick::SimpleServer","WEBrick/SimpleServer.html#method-c-start","()","<p>A SimpleServer only yields when you start it\n"],["startElement","RSS::REXMLLikeXMLParser","RSS/REXMLLikeXMLParser.html#method-i-startElement","(name, attrs)",""],["start_collecting_tokens","RDoc::TokenStream","RDoc/TokenStream.html#method-i-start_collecting_tokens","()",""],["start_doc","RDoc::CodeObject","RDoc/CodeObject.html#method-i-start_doc","()","<p>Enable capture of documentation unless documentation has been turned off by :enddoc:\n"],["start_document","Psych::Emitter","Psych/Emitter.html#method-i-start_document","(p1, p2, p3)","<p>Start a document emission with YAML <code>version</code>, <code>tags</code>, and an <code>implicit</code> start.\n<p>See Psych::Handler#start_document …\n"],["start_document","Psych::Handler","Psych/Handler.html#method-i-start_document","(version, tag_directives, implicit)","<p>Called when the document starts with the declared <code>version</code>, <code>tag_directives</code>, if the document is <code>implicit</code> …\n"],["start_document","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-start_document","(version, tag_directives, implicit)","<p>Handles start_document events with <code>version</code>, <code>tag_directives</code>, and <code>implicit</code> styling.\n<p>See Psych::Handler#start_document …\n"],["start_document","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-start_document","()",""],["start_element","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-start_element","(uri, localname, qname, attributes)",""],["start_element?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-start_element-3F","()","<p>Content: [ String tag_name, Hash attributes ]\n"],["start_else_element","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-start_else_element","(local, prefix, attrs, ns)",""],["start_get_text_element","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-start_get_text_element","(tag_name, prefix, ns, required_uri)",""],["start_have_something_element","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-start_have_something_element","(tag_name, prefix, attrs, ns, klass)",""],["start_keeper","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-start_keeper","()","<p>Creates a thread that scans the tuplespace for expired tuples.\n"],["start_mapping","Psych::Emitter","Psych/Emitter.html#method-i-start_mapping","(p1, p2, p3, p4)","<p>Start emitting a YAML map with <code>anchor</code>, <code>tag</code>, an <code>implicit</code> start and end, and <code>style</code>.\n<p>See Psych::Handler#start_mapping …\n"],["start_mapping","Psych::Handler","Psych/Handler.html#method-i-start_mapping","(anchor, tag, implicit, style)","<p>Called when a map starts.\n<p><code>anchor</code> is the anchor associated with the map or <code>nil</code>. <code>tag</code> is the tag associated …\n"],["start_prefix_mapping","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-start_prefix_mapping","(prefix, uri)",""],["start_resolution","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-start_resolution","()","<p>Sets up the resolution process @return [void]\n"],["start_resolution","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-start_resolution","()","<p>Sets up the resolution process @return [void]\n"],["start_row","CSV::Parser","CSV/Parser.html#method-i-start_row","()",""],["start_sequence","Psych::Emitter","Psych/Emitter.html#method-i-start_sequence","(p1, p2, p3, p4)","<p>Start emitting a sequence with <code>anchor</code>, a <code>tag</code>, <code>implicit</code> sequence start and end, along with <code>style</code>.\n<p>See  …\n"],["start_sequence","Psych::Handler","Psych/Handler.html#method-i-start_sequence","(anchor, tag, implicit, style)","<p>Called when a sequence is started.\n<p><code>anchor</code> is the anchor associated with the sequence or nil. <code>tag</code> is the …\n"],["start_service","DRb","DRb.html#method-i-start_service","(uri=nil, front=nil, config=nil)","<p>Start a dRuby server locally.\n<p>The new dRuby server will become the primary server, even if another server …\n"],["start_service","DRb","DRb.html#method-c-start_service","(uri=nil, front=nil, config=nil)","<p>Start a dRuby server locally.\n<p>The new dRuby server will become the primary server, even if another server …\n"],["start_stream","Psych::Emitter","Psych/Emitter.html#method-i-start_stream","(p1)","<p>Start a stream emission with <code>encoding</code>\n<p>See Psych::Handler#start_stream\n"],["start_stream","Psych::Handler","Psych/Handler.html#method-i-start_stream","(encoding)","<p>Called with <code>encoding</code> when the YAML stream starts.  This method is called once per stream.  A stream may …\n"],["start_stream","Psych::TreeBuilder","Psych/TreeBuilder.html#method-i-start_stream","(encoding)",""],["start_symbol=","Racc::Grammar","Racc/Grammar.html#method-i-start_symbol-3D","(s)",""],["start_tls_session","Net::FTP","Net/FTP.html#method-i-start_tls_session","(sock)",""],["start_tls_session","Net::IMAP","Net/IMAP.html#method-i-start_tls_session","(params = {})",""],["start_with?","String","String.html#method-i-start_with-3F","(*args)","<p>Returns true if <code>str</code> starts with one of the <code>prefixes</code> given. Each of the <code>prefixes</code> should be a String or …\n"],["start_with?","Symbol","Symbol.html#method-i-start_with-3F","(*args)","<p>Returns true if <code>sym</code> starts with one of the <code>prefixes</code> given. Each of the <code>prefixes</code> should be a String or …\n"],["started?","Net::HTTP","Net/HTTP.html#method-i-started-3F","()","<p>Returns true if the HTTP session has been started.\n"],["started?","Net::POP3","Net/POP3.html#method-i-started-3F","()","<p><code>true</code> if the POP3 session has started.\n"],["started?","Net::SMTP","Net/SMTP.html#method-i-started-3F","()","<p><code>true</code> if the SMTP session has been started.\n"],["starts_with","REXML::Functions","REXML/Functions.html#method-c-starts_with","( string, test )","<p>Fixed by Mike Stok\n"],["starttls","Net::IMAP","Net/IMAP.html#method-i-starttls","(options = {}, verify = true)","<p>Sends a STARTTLS command to start TLS session.\n"],["starttls","Net::SMTP","Net/SMTP.html#method-i-starttls","()",""],["starttls?","Net::SMTP","Net/SMTP.html#method-i-starttls-3F","()","<p>Returns truth value if this object uses STARTTLS. If this object always uses STARTTLS, returns :always. …\n"],["starttls_always?","Net::SMTP","Net/SMTP.html#method-i-starttls_always-3F","()","<p>true if this object uses STARTTLS.\n"],["starttls_auto?","Net::SMTP","Net/SMTP.html#method-i-starttls_auto-3F","()","<p>true if this object uses STARTTLS when server advertises STARTTLS.\n"],["stat","CSV","CSV.html#method-i-stat","(*args)",""],["stat","File","File.html#method-c-stat","(p1)","<p>Returns a File::Stat object for the named file (see File::Stat).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">mtime</span>   <span class=\"ruby-comment\">#=&gt; Tue ...</span>\n</pre>\n"],["stat","GC","GC.html#method-c-stat","(hash_or_key = nil)","<p>Returns a Hash containing information about the GC.\n<p>The hash includes information about internal statistics …\n"],["stat","IO","IO.html#method-i-stat","()","<p>Returns status information for <em>ios</em> as an object of type File::Stat.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>)\n<span class=\"ruby-identifier\">s</span> = <span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">stat</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["stat","Pathname","Pathname.html#method-i-stat","()","<p>Returns a File::Stat object.\n<p>See File.stat.\n"],["stat","RubyVM","RubyVM.html#method-c-stat","(*args)","<p>Returns a Hash containing implementation-dependent counters inside the VM.\n<p>This hash includes information …\n"],["stat","TracePoint","TracePoint.html#method-c-stat","()","<p>Returns internal information of TracePoint.\n<p>The contents of the returned value are implementation specific. …\n"],["state","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-state","()","<p>@return [RequirementState] the current state the resolution is\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">operating</span> <span class=\"ruby-identifier\">upon</span>\n</pre>\n"],["state","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-state","()","<p>@return [RequirementState] the current state the resolution is\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">operating</span> <span class=\"ruby-identifier\">upon</span>\n</pre>\n"],["state","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-state","()","<p>A description of the current connection state. This is for diagnostic purposes only.\n"],["state","Ripper","Ripper.html#method-i-state","()","<p>Return scanner state of current token.\n"],["state","Ripper::Filter","Ripper/Filter.html#method-i-state","()","<p>The scanner&#39;s state of the current token. This value is the bitwise OR of zero or more of the <code>Ripper::EXPR_*</code> …\n"],["state_any?","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-state_any-3F","(state)","<p>@return [Boolean] whether or not the given state has any possibilities\n\n<pre>left.</pre>\n"],["state_index_for_unwind","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-state_index_for_unwind","()","<p>@return [Integer] The index to which the resolution should unwind in the\n\n<pre>case of conflict.</pre>\n"],["state_transition_table","Racc::Grammar","Racc/Grammar.html#method-i-state_transition_table","()",""],["state_transition_table","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-state_transition_table","()",""],["state_transition_table","Racc::States","Racc/States.html#method-i-state_transition_table","()",""],["states","Racc::Grammar","Racc/Grammar.html#method-i-states","()",""],["status","Net::FTP","Net/FTP.html#method-i-status","(pathname = nil)","<p>Returns the status (STAT command).\n<p>pathname &mdash; when stat is invoked with pathname as a parameter it acts …\n\n"],["status","Net::IMAP","Net/IMAP.html#method-i-status","(mailbox, attr)","<p>Sends a STATUS command, and returns the status of the indicated <code>mailbox</code>. <code>attr</code> is a list of one or more …\n"],["status","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-status","()","<p>Returns an Array of statuses for this response.  Each status contains a CertificateId, the status (0 …\n"],["status","OpenSSL::OCSP::Response","OpenSSL/OCSP/Response.html#method-i-status","()","<p>Returns the status of the response.\n"],["status","PTY::ChildExited","PTY/ChildExited.html#method-i-status","()","<p>Returns the exit status of the child for which PTY#check raised this exception\n"],["status","SystemExit","SystemExit.html#method-i-status","()","<p>Return the status value associated with this system exit.\n"],["status","Thread","Thread.html#method-i-status","()","<p>Returns the status of <code>thr</code>.\n<p><code>&quot;sleep&quot;</code> &mdash; Returned if this thread is sleeping or waiting on I/O\n<p><code>&quot;run&quot;</code> … &mdash; "],["status=","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-status-3D","(status)","<p>Sets the response&#39;s status to the <code>status</code> code\n"],["status?","OpenSSL::Random","OpenSSL/Random.html#method-c-status-3F","()","<p>Return <code>true</code> if the PRNG has been seeded with enough data, <code>false</code> otherwise.\n"],["status_code","Bundler::BundlerError","Bundler/BundlerError.html#method-c-status_code","(code)",""],["status_code","Bundler::Dsl::DSLError","Bundler/Dsl/DSLError.html#method-i-status_code","()",""],["status_line","WEBrick::HTTPResponse","WEBrick/HTTPResponse.html#method-i-status_line","()","<p>The response&#39;s HTTP status line\n"],["status_string","OpenSSL::OCSP::Response","OpenSSL/OCSP/Response.html#method-i-status_string","()","<p>Returns a status string for the response.\n"],["status_type_char","Net::SMTP::Response","Net/SMTP/Response.html#method-i-status_type_char","()","<p>Takes the first digit of the reply code to determine the status type\n"],["stderr","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-stderr","()",""],["stdinput","CGI","CGI.html#method-i-stdinput","()","<p>Synonym for $stdin.\n"],["stdout","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-stdout","()",""],["stdout","DEBUGGER__","DEBUGGER__.html#method-c-stdout","()","<p>Returns the IO used as stdout. Defaults to STDOUT\n"],["stdout=","DEBUGGER__","DEBUGGER__.html#method-c-stdout-3D","(s)","<p>Sets the IO used as stdout. Defaults to STDOUT\n"],["stdoutput","CGI","CGI.html#method-i-stdoutput","()","<p>Synonym for $stdout.\n"],["step","Date","Date.html#method-i-step","(p1, p2 = v2)","<p>Iterates evaluation of the given block, which takes a date object. The limit should be a date object. …\n"],["step","Enumerator::ArithmeticSequence","Enumerator/ArithmeticSequence.html#method-i-step","()",""],["step","Numeric","Numeric.html#method-i-step","(*args)","<p>Invokes the given block with the sequence of numbers starting at <code>num</code>, incremented by <code>step</code> (defaulted …\n"],["step","REXML::XPathParser","REXML/XPathParser.html#method-i-step","(path_stack, any_type: :element, order: :forward)",""],["step","Range","Range.html#method-i-step","(*args)","<p>Iterates over the range, passing each <code>n</code>th element to the block. If begin and end are numeric, <code>n</code> is added …\n"],["sticky?","File","File.html#method-c-sticky-3F","(p1)","<p>Returns <code>true</code> if the named file has the sticky bit set.\n<p><em>file_name</em> can be an IO object.\n"],["sticky?","File::Stat","File/Stat.html#method-i-sticky-3F","()","<p>Returns <code>true</code> if <em>stat</em> has its sticky bit set, <code>false</code> if it doesn&#39;t or if the operating system doesn&#39;t …\n"],["sticky?","FileTest","FileTest.html#method-i-sticky-3F","(p1)","<p>Returns <code>true</code> if the named file has the sticky bit set.\n<p><em>file_name</em> can be an IO object.\n"],["sticky?","Pathname","Pathname.html#method-i-sticky-3F","()","<p>See FileTest.sticky?.\n"],["stop","Bundler::Worker","Bundler/Worker.html#method-i-stop","()",""],["stop","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-stop","()","<p>Sends “close notify” to the peer and tries to shut down the SSL connection gracefully.\n"],["stop","Thread","Thread.html#method-c-stop","()","<p>Stops execution of the current thread, putting it into a “sleep&#39;&#39; state, and schedules execution …\n"],["stop","WEBrick::GenericServer","WEBrick/GenericServer.html#method-i-stop","()","<p>Stops the server from accepting new connections.\n"],["stop?","Thread","Thread.html#method-i-stop-3F","()","<p>Returns <code>true</code> if <code>thr</code> is dead or sleeping.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">new</span> { <span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">stop</span> }\n<span class=\"ruby-identifier\">b</span> = <span class=\"ruby-constant\">Thread</span>.<span class=\"ruby-identifier\">current</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">stop?</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["stop_doc","RDoc::CodeObject","RDoc/CodeObject.html#method-i-stop_doc","()","<p>Disable capture of documentation\n"],["stop_on_unknown_option!","Bundler::Thor","Bundler/Thor.html#method-c-stop_on_unknown_option-21","(*command_names)","<p>Stop parsing of options as soon as an unknown option or a regular argument is encountered.  All remaining …\n"],["stop_pool","DRb::DRbConn","DRb/DRbConn.html#method-c-stop_pool","()",""],["stop_service","DRb","DRb.html#method-i-stop_service","()","<p>Stop the local dRuby server.\n<p>This operates on the primary server.  If there is no primary server currently …\n"],["stop_service","DRb","DRb.html#method-c-stop_service","()","<p>Stop the local dRuby server.\n<p>This operates on the primary server.  If there is no primary server currently …\n"],["stop_service","DRb::DRbServer","DRb/DRbServer.html#method-i-stop_service","()","<p>Stop this server.\n"],["stop_service","DRb::ExtServ","DRb/ExtServ.html#method-i-stop_service","()",""],["stop_threads","Bundler::Worker","Bundler/Worker.html#method-i-stop_threads","()","<p>Stop the worker threads by sending a poison object down the request queue so as worker threads after …\n"],["stopped?","Process::Status","Process/Status.html#method-i-stopped-3F","()","<p>Returns <code>true</code> if this process is stopped. This is only returned if the corresponding #wait call had the …\n"],["stopsig","Process::Status","Process/Status.html#method-i-stopsig","()","<p>Returns the number of the signal that caused <em>stat</em> to stop (or <code>nil</code> if self is not stopped).\n"],["storbinary","Net::FTP","Net/FTP.html#method-i-storbinary","(cmd, file, blocksize, rest_offset = nil)","<p>Puts the connection into binary (image) mode, issues the given server-side command (such as “STOR …\n"],["store","DBM","DBM.html#method-i-store","(p1, p2)","<p>Stores the specified string value in the database, indexed via the string key provided.\n"],["store","ENV","ENV.html#method-c-store","(p1, p2)","<p>ENV.store is an alias for ENV.[]=.\n<p>Creates, updates, or deletes the named environment variable, returning …\n"],["store","GDBM","GDBM.html#method-i-store","(p1, p2)","<p>Associates the value <em>value</em> with the specified <em>key</em>.\n"],["store","Hash","Hash.html#method-i-store","(p1, p2)","<p>Element Assignment\n<p>Associates the value given by <code>value</code> with the key given by <code>key</code>.\n\n<pre>h = { &quot;a&quot; =&gt; 100, &quot;b&quot; ...</pre>\n"],["store","Net::IMAP","Net/IMAP.html#method-i-store","(set, attr, flags)","<p>Sends a STORE command to alter data associated with messages in the mailbox, in particular their flags. …\n"],["store","SDBM","SDBM.html#method-i-store","(p1, p2)","<p>Stores a new <code>value</code> in the database with the given <code>key</code> as an index.\n<p>If the <code>key</code> already exists, this will …\n"],["store","YAML::DBM","YAML/DBM.html#method-i-store","( key, val )","<p>Stores <code>value</code> in database with <code>key</code> as the index. <code>value</code> is converted to YAML before being stored.\n<p>Returns …\n"],["store=","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-store-3D","(store)","<p>Sets the store for this method and its referenced code objects.\n"],["store=","RDoc::ClassModule","RDoc/ClassModule.html#method-i-store-3D","(store)","<p>Sets the store for this class or module and its contained code objects.\n"],["store=","RDoc::CodeObject","RDoc/CodeObject.html#method-i-store-3D","(store)","<p>Sets the <code>store</code> that contains this CodeObject\n"],["store=","RDoc::Constant","RDoc/Constant.html#method-i-store-3D","(store)","<p>Sets the store for this class or module and its contained code objects.\n"],["store=","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-store-3D","(store)","<p>Sets the store for this class or module and its contained code objects.\n"],["store=","RDoc::Mixin","RDoc/Mixin.html#method-i-store-3D","(store)","<p>Sets the store for this class or module and its contained code objects.\n"],["store=","RDoc::RDoc","RDoc/RDoc.html#method-i-store-3D","(store)","<p>Sets the current documentation tree to <code>store</code> and sets the store&#39;s rdoc driver to this instance.\n"],["store_connection","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-store_connection","(obj, options = nil)","<p>This is an extension point for TimedStack and is called with a mutex.\n<p>This method must return <code>obj</code> to the …\n"],["store_for","RDoc::Servlet","RDoc/Servlet.html#method-i-store_for","(source_name)","<p>Returns an RDoc::Store for the given <code>source_name</code> (&#39;ruby&#39; or a gem name).\n"],["store_internal","Net::IMAP","Net/IMAP.html#method-i-store_internal","(cmd, set, attr, flags)",""],["storlines","Net::FTP","Net/FTP.html#method-i-storlines","(cmd, file)","<p>Puts the connection into ASCII (text) mode, issues the given server-side command (such as “STOR …\n"],["stream=","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-stream-3D","( source )",""],["stream?","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-stream-3F","()",""],["stream?","Psych::Nodes::Stream","Psych/Nodes/Stream.html#method-i-stream-3F","()",""],["stream_check","Net::HTTPResponse","Net/HTTPResponse.html#method-i-stream_check","()",""],["stream_end?","Zlib::ZStream","Zlib/ZStream.html#method-i-stream_end-3F","()","<p>Returns true if the stream is finished.\n"],["streaming?","Psych::Handler","Psych/Handler.html#method-i-streaming-3F","()","<p>Is this handler a streaming handler?\n"],["stress","GC","GC.html#method-c-stress","()","<p>Returns current status of GC stress mode.\n"],["stress=","GC","GC.html#method-c-stress-3D","(flag)","<p>Updates the GC stress mode.\n<p>When stress mode is enabled, the GC is invoked at every GC opportunity: all …\n"],["strftime","Date","Date.html#method-i-strftime","(*args)","<p>Formats date according to the directives in the given format string. The directives begin with a percent …\n"],["strftime","DateTime","DateTime.html#method-i-strftime","(*args)","<p>Formats date according to the directives in the given format string. The directives begin with a percent …\n"],["strftime","Time","Time.html#method-i-strftime","(p1)","<p>Formats <em>time</em> according to the directives in the given format string.\n<p>The directives begin with a percent …\n"],["strict?","REXML::XPathParser","REXML/XPathParser.html#method-i-strict-3F","()",""],["strict_args_position!","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-strict_args_position-21","()","<p>If you want only strict string args (useful when cascading thor classes), call strict_args_position! …\n"],["strict_decode64","Base64","Base64.html#method-i-strict_decode64","(str)","<p>Returns the Base64-decoded version of <code>str</code>. This method complies with RFC 4648. ArgumentError is raised …\n"],["strict_encode64","Base64","Base64.html#method-i-strict_encode64","(bin)","<p>Returns the Base64-encoded version of <code>bin</code>. This method complies with RFC 4648. No line feeds are added. …\n"],["strict_oct","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-c-strict_oct","(str)",""],["strike","RDoc::Markdown","RDoc/Markdown.html#method-i-strike","","<p>Enables the strike extension\n"],["string","MatchData","MatchData.html#method-i-string","()","<p>Returns a frozen copy of the string passed in to <code>match</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> = <span class=\"ruby-regexp\">/(.)(.)(\\d+)(\\d)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;THX1138.&quot;</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">string</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["string","REXML::Functions","REXML/Functions.html#method-c-string","( object=@@context[:node] )","<p>A node-set is converted to a string by returning the string-value of the node in the node-set that is …\n"],["string","StringIO","StringIO.html#method-i-string","()","<p>Returns underlying String object, the subject of IO.\n"],["string","StringScanner","StringScanner.html#method-i-string","()","<p>Returns the string being scanned.\n"],["string","TempIO","TempIO.html#method-i-string","()","<p>The content of the TempIO as a String.\n"],["string=","StringIO","StringIO.html#method-i-string-3D","(p1)","<p>Changes underlying String object, the subject of IO.\n"],["string=","StringScanner","StringScanner.html#method-i-string-3D","(p1)","<p>Changes the string being scanned to <code>str</code> and resets the scanner. Returns <code>str</code>.\n"],["string_length","REXML::Functions","REXML/Functions.html#method-c-string_length","( string )","<p>UNTESTED\n"],["string_list","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-string_list","(name, list)",""],["string_symbol?","Racc::Sym","Racc/Sym.html#method-i-string_symbol-3F","()",""],["string_value","REXML::Functions","REXML/Functions.html#method-c-string_value","( o )","<p>A node-set is converted to a string by returning the concatenation of the string-value of each of the …\n"],["strip","String","String.html#method-i-strip","()","<p>Returns a copy of the receiver with leading and trailing whitespace removed.\n<p>Whitespace is defined as …\n"],["strip!","String","String.html#method-i-strip-21","()","<p>Removes leading and trailing whitespace from the receiver. Returns the altered receiver, or <code>nil</code> if there …\n"],["strip_hashes","RDoc::Text","RDoc/Text.html#method-i-strip_hashes","(text)","<p>Strips leading # characters from <code>text</code>\n"],["strip_leading_spaces","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-strip_leading_spaces","(text)",""],["strip_newlines","RDoc::Text","RDoc/Text.html#method-i-strip_newlines","(text)","<p>Strips leading and trailing n characters from <code>text</code>\n"],["strip_quotes","REXML::DocType","REXML/DocType.html#method-i-strip_quotes","(quoted_string)","<p>Method contributed by Henrik Martensson\n"],["strip_stars","RDoc::Text","RDoc/Text.html#method-i-strip_stars","(text)","<p>Strips /* */ style comments\n"],["strip_value","CSV::Parser","CSV/Parser.html#method-i-strip_value","(value)",""],["strong","RDoc::Markdown","RDoc/Markdown.html#method-i-strong","(text)","<p>Wraps <code>text</code> in strong markup for rdoc inline formatting\n"],["strongly_connected_components","TSort","TSort.html#method-c-strongly_connected_components","(each_node, each_child)","<p>Returns strongly connected components as an array of arrays of nodes. The array is sorted from children …\n"],["strongly_connected_components","TSort","TSort.html#method-i-strongly_connected_components","()","<p>Returns strongly connected components as an array of arrays of nodes. The array is sorted from children …\n"],["strptime","Date","Date.html#method-c-strptime","(p1 = v1, p2 = v2, p3 = v3)","<p>Parses the given representation of date and time with the given template, and creates a date object. …\n"],["strptime","DateTime","DateTime.html#method-c-strptime","(p1 = v1, p2 = v2, p3 = v3)","<p>Parses the given representation of date and time with the given template, and creates a DateTime object. …\n"],["strptime","Time","Time.html#method-c-strptime","(date, format, now=self.now)","<p>Works similar to <code>parse</code> except that instead of using a heuristic to detect the format of the input string, …\n"],["struct","Fiddle::Importer","Fiddle/Importer.html#method-i-struct","(signature)","<p>Creates a class to wrap the C struct described by <code>signature</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">MyStruct</span> = <span class=\"ruby-identifier\">struct</span> [<span class=\"ruby-string\">&#39;int i&#39;</span>, <span class=\"ruby-string\">&#39;char c&#39;</span>]\n</pre>\n"],["stub_rubygems","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-stub_rubygems","(specs)",""],["stub_set_spec","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-stub_set_spec","(stub, spec)",""],["stubbed?","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-stubbed-3F","()","<p>Whether this specification is stubbed - i.e. we have information about the gem from a stub line, without …\n"],["stubbed?","Gem::Specification","Gem/Specification.html#method-i-stubbed-3F","()",""],["stubs","Gem::Specification","Gem/Specification.html#method-c-stubs","()","<p>Returns a Gem::StubSpecification for every installed gem\n"],["stubs_for","Gem::Specification","Gem/Specification.html#method-c-stubs_for","(name)","<p>Returns a Gem::StubSpecification for installed gem named <code>name</code> only returns stubs that match Gem.platforms …\n"],["su","WEBrick::Utils","WEBrick/Utils.html#method-c-su","(user)","<p>Changes the process&#39;s uid and gid to the ones of <code>user</code>\n"],["su","WEBrick::Utils","WEBrick/Utils.html#method-i-su","(user)","<p>Changes the process&#39;s uid and gid to the ones of <code>user</code>\n"],["sub","BigDecimal","BigDecimal.html#method-i-sub","(p1, p2)","<p>Subtract the specified value.\n<p>e.g.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">sub</span>(<span class=\"ruby-identifier\">b</span>,<span class=\"ruby-identifier\">n</span>)\n</pre>\n"],["sub","IRB::Vec","IRB/Vec.html#method-i-sub","(other)",""],["sub","Kernel","Kernel.html#method-i-sub","(*args)","<p>Equivalent to <code>$_.sub(<em>args</em>)</code>, except that <code>$_</code> will be updated if substitution occurs. Available only when …\n"],["sub","Pathname","Pathname.html#method-i-sub","(*args)","<p>Return a pathname which is substituted by String#sub.\n\n<pre>path1 = Pathname.new(&#39;/usr/bin/perl&#39;)\npath1.sub(&#39;perl&#39;, ...</pre>\n"],["sub","String","String.html#method-i-sub","(*args)","<p>Returns a copy of <code>str</code> with the <em>first</em> occurrence of <code>pattern</code> replaced by the second argument. The <code>pattern</code> …\n"],["sub!","String","String.html#method-i-sub-21","(*args)","<p>Performs the same substitution as String#sub in-place.\n<p>Returns <code>str</code> if a substitution was performed or …\n"],["sub_dependencies_to_avoid","Bundler::Molinillo::Resolver::Resolution::UnwindDetails","Bundler/Molinillo/Resolver/Resolution/UnwindDetails.html#method-i-sub_dependencies_to_avoid","()","<p>@return [Array] array of sub-dependencies to avoid when choosing a\n\n<pre>new possibility for the state we&#39;ve ...</pre>\n"],["sub_ext","Pathname","Pathname.html#method-i-sub_ext","(p1)","<p>Return a pathname with <code>repl</code> added as a suffix to the basename.\n<p>If self has no extension part, <code>repl</code> is …\n"],["sub_type","Net::HTTPHeader","Net/HTTPHeader.html#method-i-sub_type","()","<p>Returns a content type string such as “html”. This method returns nil if Content-Type: header …\n"],["subclass_files","Bundler::Thor::Base","Bundler/Thor/Base.html#method-c-subclass_files","()","<p>Returns the files where the subclasses are kept.\n<p>Returns\n<p>Hash[path&lt;String&gt; =&gt; Class]\n"],["subclasses","Bundler::Thor::Base","Bundler/Thor/Base.html#method-c-subclasses","()","<p>Returns the classes that inherits from Bundler::Thor or Bundler::Thor::Group.\n<p>Returns\n<p>Array\n"],["subcommand","Bundler::Thor","Bundler/Thor.html#method-c-subcommand","(subcommand, subcommand_class)",""],["subcommand_classes","Bundler::Thor","Bundler/Thor.html#method-c-subcommand_classes","()",""],["subcommand_help","Bundler::Thor","Bundler/Thor.html#method-c-subcommand_help","(cmd)",""],["subcommands","Bundler::Thor","Bundler/Thor.html#method-c-subcommands","()",""],["subdomain_of?","Resolv::DNS::Name","Resolv/DNS/Name.html#method-i-subdomain_of-3F","(other)","<p>Returns true if <code>other</code> is a subdomain.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">domain</span> = <span class=\"ruby-constant\">Resolv</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">DNS</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Name</span>.<span class=\"ruby-identifier\">create</span>(<span class=\"ruby-string\">&quot;y.z&quot;</span>)\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Resolv</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">DNS</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Name</span>.<span class=\"ruby-identifier\">create</span>(<span class=\"ruby-string\">&quot;w.x.y.z&quot;</span>).<span class=\"ruby-identifier\">subdomain_of?</span>(<span class=\"ruby-identifier\">domain</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["subject","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-subject","()",""],["subject","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-subject","()",""],["subject=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-subject-3D","(p1)",""],["subject=","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-subject-3D","(p1)",""],["subject_certificate=","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-subject_certificate-3D","(p1)",""],["subject_request=","OpenSSL::X509::ExtensionFactory","OpenSSL/X509/ExtensionFactory.html#method-i-subject_request-3D","(p1)",""],["submit","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-submit","(value = nil, name = nil)","<p>Generate a submit button Input element, as a String.\n<p><code>value</code> is the text to display on the button.  <code>name</code> …\n"],["subscribe","Net::IMAP","Net/IMAP.html#method-i-subscribe","(mailbox)","<p>Sends a SUBSCRIBE command to add the specified <code>mailbox</code> name to the server&#39;s set of “active” …\n"],["subsec","Time","Time.html#method-i-subsec","()","<p>Returns the fraction for <em>time</em>.\n<p>The return value can be a rational number.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>        <span class=\"ruby-comment\">#=&gt; 2009-03-26 ...</span>\n</pre>\n"],["subset?","Set","Set.html#method-i-subset-3F","(set)","<p>Returns true if the set is a subset of the given set.\n"],["substring","REXML::Functions","REXML/Functions.html#method-c-substring","( string, start, length=nil )","<p>Take equal portions of Mike Stok and Sean Russell; mix vigorously, and pour into a tall, chilled glass. …\n"],["substring_after","REXML::Functions","REXML/Functions.html#method-c-substring_after","( string, test )","<p>Kouhei fixed this too\n"],["substring_before","REXML::Functions","REXML/Functions.html#method-c-substring_before","( string, test )","<p>Kouhei fixed this\n"],["subtask","Bundler::Thor","Bundler/Thor.html#method-c-subtask","(subcommand, subcommand_class)",""],["subtask_help","Bundler::Thor","Bundler/Thor.html#method-c-subtask_help","(cmd)",""],["subtasks","Bundler::Thor","Bundler/Thor.html#method-c-subtasks","()",""],["subtract","Set","Set.html#method-i-subtract","(enum)","<p>Deletes every element that appears in the given enumerable object and returns self.\n"],["succ","Date","Date.html#method-i-succ","()","<p>Returns a date object denoting the following day.\n"],["succ","IPAddr","IPAddr.html#method-i-succ","()","<p>Returns the successor to the ipaddr.\n"],["succ","Integer","Integer.html#method-i-succ","()","<p>Returns the successor of <code>int</code>, i.e. the Integer equal to <code>int+1</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">next</span>      <span class=\"ruby-comment\">#=&gt; 2</span>\n(<span class=\"ruby-value\">-1</span>).<span class=\"ruby-identifier\">next</span>   <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">succ</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["succ","Prime::EratosthenesGenerator","Prime/EratosthenesGenerator.html#method-i-succ","()",""],["succ","Prime::Generator23","Prime/Generator23.html#method-i-succ","()",""],["succ","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-succ","()","<p>returns the next pseudo-prime number, and move the internal position forward.\n<p><code>PseudoPrimeGenerator</code>#succ …\n"],["succ","Prime::TrialDivisionGenerator","Prime/TrialDivisionGenerator.html#method-i-succ","()",""],["succ","String","String.html#method-i-succ","()","<p>Returns the successor to <em>str</em>. The successor is calculated by incrementing characters starting from the …\n"],["succ","Symbol","Symbol.html#method-i-succ","()","<p>Same as <code>sym.to_s.succ.intern</code>.\n"],["succ","Time","Time.html#method-i-succ","()","<p>Returns a new Time object, one second later than <em>time</em>. Time#succ is obsolete since 1.9.2 for time is …\n"],["succ!","String","String.html#method-i-succ-21","()","<p>Equivalent to String#succ, but modifies the receiver in place.\n"],["success?","Net::SMTP::Response","Net/SMTP/Response.html#method-i-success-3F","()","<p>Determines whether the response received was a Positive Completion reply (2xx reply code)\n"],["success?","Process::Status","Process/Status.html#method-i-success-3F","()","<p>Returns <code>true</code> if <em>stat</em> is successful, <code>false</code> if not. Returns <code>nil</code> if #exited? is not <code>true</code>.\n"],["success?","SystemExit","SystemExit.html#method-i-success-3F","()","<p>Returns <code>true</code> if exiting successful, <code>false</code> if not.\n"],["success?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-c-success-3F","(code)","<p>Is <code>code</code> a successful status?\n"],["success?","WEBrick::HTTPStatus","WEBrick/HTTPStatus.html#method-i-success-3F","(code)","<p>Is <code>code</code> a successful status?\n"],["successors","Bundler::Molinillo::DependencyGraph::Vertex","Bundler/Molinillo/DependencyGraph/Vertex.html#method-i-successors","()","<p>@return [Array&lt;Vertex&gt;] the vertices of {#graph} that have an edge with\n\n<pre>`self` as their {Edge#origin}</pre>\n"],["successors","Gem::Resolver::Molinillo::DependencyGraph::Vertex","Gem/Resolver/Molinillo/DependencyGraph/Vertex.html#method-i-successors","()","<p>@return [Array&lt;Vertex&gt;] the vertices of {#graph} that have an edge with\n\n<pre>`self` as their {Edge#origin}</pre>\n"],["sudo","Bundler","Bundler.html#method-c-sudo","(str)",""],["suffix_pattern","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-suffix_pattern","()",""],["suffix_pattern","Gem","Gem.html#method-c-suffix_pattern","()","<p>Glob pattern for require-able path suffixes.\n"],["suffix_regexp","Gem","Gem.html#method-c-suffix_regexp","()",""],["suffixes","Gem","Gem.html#method-c-suffixes","()","<p>Suffixes for require-able paths.\n"],["suggest_gems_from_name","Gem::SpecFetcher","Gem/SpecFetcher.html#method-i-suggest_gems_from_name","(gem_name, type = :latest)","<p>Suggests gems based on the supplied <code>gem_name</code>. Returns an array of alternative gem names.\n"],["suggestions","Gem::Licenses","Gem/Licenses.html#method-c-suggestions","(license)",""],["sum","Array","Array.html#method-i-sum","(*args)","<p>Returns the sum of elements. For example, [e1, e2, e3].sum returns init + e1 + e2 + e3.\n<p>If a block is …\n"],["sum","Enumerable","Enumerable.html#method-i-sum","(*args)","<p>Returns the sum of elements in an Enumerable.\n<p>If a block is given, the block is applied to each element …\n"],["sum","REXML::Functions","REXML/Functions.html#method-c-sum","( nodes )",""],["sum","String","String.html#method-i-sum","(*args)","<p>Returns a basic <em>n</em>-bit checksum of the characters in <em>str</em>, where <em>n</em> is the optional Integer parameter, defaulting …\n"],["summarize","OptionParser","OptionParser.html#method-i-summarize","(to = [], width = @summary_width, max = width - 1, indent = @summary_indent, &blk)","<p>Puts option summary into <code>to</code> and returns <code>to</code>. Yields each line if a block is given.\n<p><code>to</code> &mdash; Output destination, …\n"],["summarize","OptionParser::List","OptionParser/List.html#method-i-summarize","(*args, &block)","<p>Creates the summary table, passing each line to the <code>block</code> (without newline). The arguments <code>args</code> are passed …\n"],["summarize","OptionParser::Switch","OptionParser/Switch.html#method-i-summarize","(sdone = {}, ldone = {}, width = 1, max = width - 1, indent = \"\")","<p>Produces the summary text. Each line of the summary is yielded to the block (without newline).\n<p><code>sdone</code> &mdash; "],["summary","RDoc::Stats","RDoc/Stats.html#method-i-summary","()","<p>Returns a summary of the collected statistics.\n"],["summary=","Gem::Specification","Gem/Specification.html#method-i-summary-3D","(str)","<p>A short summary of this gem&#39;s description.\n"],["sunday?","Date","Date.html#method-i-sunday-3F","()","<p>Returns true if the date is Sunday.\n"],["sunday?","Time","Time.html#method-i-sunday-3F","()","<p>Returns <code>true</code> if <em>time</em> represents Sunday.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">1990</span>, <span class=\"ruby-value\">4</span>, <span class=\"ruby-value\">1</span>)       <span class=\"ruby-comment\">#=&gt; 1990-04-01 00:00:00 -0600 ...</span>\n</pre>\n"],["super_method","Method","Method.html#method-i-super_method","()","<p>Returns a Method of superclass which would be called when super is used or nil if there is no method …\n"],["super_method","UnboundMethod","UnboundMethod.html#method-i-super_method","()","<p>Returns a Method of superclass which would be called when super is used or nil if there is no method …\n"],["superclass","Class","Class.html#method-i-superclass","()","<p>Returns the superclass of <em>class</em>, or <code>nil</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">superclass</span>          <span class=\"ruby-comment\">#=&gt; IO</span>\n<span class=\"ruby-constant\">IO</span>.<span class=\"ruby-identifier\">superclass</span>            <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["superclass","RDoc::ClassModule","RDoc/ClassModule.html#method-i-superclass","()","<p>Get the superclass of this class.  Attempts to retrieve the superclass object, returns the name if it …\n"],["superclass","RDoc::NormalModule","RDoc/NormalModule.html#method-i-superclass","()","<p>Modules don&#39;t have one, raises NoMethodError\n"],["superclass=","RDoc::ClassModule","RDoc/ClassModule.html#method-i-superclass-3D","(superclass)","<p>Set the superclass of this class to <code>superclass</code>\n"],["superclass_method","RDoc::AnyMethod","RDoc/AnyMethod.html#method-i-superclass_method","()","<p>For methods that <code>super</code>, find the superclass method that would be called.\n"],["superset?","Set","Set.html#method-i-superset-3F","(set)","<p>Returns true if the set is a superset of the given set.\n"],["supply_default_content_type","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-supply_default_content_type","()",""],["supported?","IRB::Color","IRB/Color.html#method-c-supported-3F","()",""],["supported?","RSS::Maker","RSS/Maker.html#method-c-supported-3F","(version)","<p>Returns true if the version is supported\n"],["suppress","RDoc::CodeObject","RDoc/CodeObject.html#method-i-suppress","()","<p>Use this to suppress a CodeObject and all its children until the next file it is seen in or documentation …\n"],["suppress_configured_credentials","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-suppress_configured_credentials","(remote)",""],["suppressed?","RDoc::CodeObject","RDoc/CodeObject.html#method-i-suppressed-3F","()","<p>Has this class been suppressed?\n<p>See also #suppress\n"],["suspend","DEBUGGER__","DEBUGGER__.html#method-c-suspend","()",""],["suspend_context","IRB::Irb","IRB/Irb.html#method-i-suspend_context","(context)","<p>Evaluates the given block using the given <code>context</code> as the Context.\n"],["suspend_input_method","IRB::Irb","IRB/Irb.html#method-i-suspend_input_method","(input_method)","<p>Evaluates the given block using the given <code>input_method</code> as the Context#io.\n<p>Used by the irb commands <code>source</code> …\n"],["suspend_name","IRB::Irb","IRB/Irb.html#method-i-suspend_name","(path = nil, name = nil)","<p>Evaluates the given block using the given <code>path</code> as the Context#irb_path and <code>name</code> as the Context#irb_name …\n"],["suspend_workspace","IRB::Irb","IRB/Irb.html#method-i-suspend_workspace","(workspace)","<p>Evaluates the given block using the given <code>workspace</code> as the Context#workspace.\n<p>Used by the irb command …\n"],["swapcase","String","String.html#method-i-swapcase","(*args)","<p>Returns a copy of <em>str</em> with uppercase alphabetic characters converted to lowercase and lowercase characters …\n"],["swapcase","Symbol","Symbol.html#method-i-swapcase","(*args)","<p>Same as <code>sym.to_s.swapcase.intern</code>.\n"],["swapcase!","String","String.html#method-i-swapcase-21","(*args)","<p>Equivalent to String#swapcase, but modifies the receiver in place, returning <em>str</em>, or <code>nil</code> if no changes …\n"],["switch","IRB::JobManager","IRB/JobManager.html#method-i-switch","(key)","<p>Changes the current active irb session to the given <code>key</code> in the jobs Array.\n<p>Raises an IrbAlreadyDead exception …\n"],["switch","Process::GID","Process/GID.html#method-c-switch","()","<p>Switch the effective and real group IDs of the current process. If a <em>block</em> is given, the group IDs will …\n"],["switch","Process::UID","Process/UID.html#method-c-switch","()","<p>Switch the effective and real user IDs of the current process. If a <em>block</em> is given, the user IDs will …\n"],["switch_name","OptionParser::Switch","OptionParser/Switch.html#method-i-switch_name","()","<p>Main name of the switch.\n"],["sym","Fiddle::CompositeHandler","Fiddle/CompositeHandler.html#method-i-sym","(symbol)","<p>Returns the address as an Integer from any handlers with the function named <code>symbol</code>.\n<p>Raises a DLError if …\n"],["sym","Fiddle::Handle","Fiddle/Handle.html#method-c-sym","(p1)","<p>Get the address as an Integer for the function named <code>name</code>.\n"],["sym","Fiddle::Handle","Fiddle/Handle.html#method-i-sym","(p1)","<p>Get the address as an Integer for the function named <code>name</code>.\n"],["sym_int_hash","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-sym_int_hash","(name, h)",""],["symbol_locations","Racc::LogFileGenerator","Racc/LogFileGenerator.html#method-i-symbol_locations","(locs)",""],["symbolize","Psych::ClassLoader::Restricted","Psych/ClassLoader/Restricted.html#method-i-symbolize","(sym)",""],["symbols","Racc::Grammar","Racc/Grammar.html#method-i-symbols","()",""],["symlink","Bundler::FileUtils","Bundler/FileUtils.html#method-c-symlink","(src, dest, force: nil, noop: nil, verbose: nil)",""],["symlink","Bundler::FileUtils","Bundler/FileUtils.html#method-i-symlink","(src, dest, force: nil, noop: nil, verbose: nil)",""],["symlink","File","File.html#method-c-symlink","(p1, p2)","<p>Creates a symbolic link called <em>new_name</em> for the existing file <em>old_name</em>. Raises a NotImplemented exception …\n"],["symlink","FileUtils","FileUtils.html#method-c-symlink","(src, dest, force: nil, noop: nil, verbose: nil)",""],["symlink","FileUtils","FileUtils.html#method-i-symlink","(src, dest, force: nil, noop: nil, verbose: nil)",""],["symlink?","File","File.html#method-c-symlink-3F","(p1)","<p>Returns <code>true</code> if the named file is a symbolic link.\n"],["symlink?","File::Stat","File/Stat.html#method-i-symlink-3F","()","<p>Returns <code>true</code> if <em>stat</em> is a symbolic link, <code>false</code> if it isn&#39;t or if the operating system doesn&#39;t …\n"],["symlink?","FileTest","FileTest.html#method-i-symlink-3F","(p1)","<p>Returns <code>true</code> if the named file is a symbolic link.\n"],["symlink?","Gem::Package::TarReader::Entry","Gem/Package/TarReader/Entry.html#method-i-symlink-3F","()","<p>Is this tar entry a symlink?\n"],["symlink?","Pathname","Pathname.html#method-i-symlink-3F","()","<p>See FileTest.symlink?.\n"],["symmetric?","Matrix","Matrix.html#method-i-symmetric-3F","()","<p>Returns <code>true</code> if this is a symmetric matrix. Raises an error if matrix is not square.\n"],["sync","GDBM","GDBM.html#method-i-sync","()","<p>Unless the <em>gdbm</em> object has been opened with the <strong>SYNC</strong> flag, it is not guaranteed that database modification …\n"],["sync","IO","IO.html#method-i-sync","()","<p>Returns the current “sync mode&#39;&#39; of <em>ios</em>. When sync mode is true, all output is immediately flushed …\n"],["sync","StringIO","StringIO.html#method-i-sync","()","<p>Returns <code>true</code> always.\n"],["sync","Zlib::GzipFile","Zlib/GzipFile.html#method-i-sync","()","<p>Same as IO#sync\n"],["sync","Zlib::Inflate","Zlib/Inflate.html#method-i-sync","(p1)","<p>Inputs <code>string</code> into the end of input buffer and skips data until a full flush point can be found.  If …\n"],["sync=","IO","IO.html#method-i-sync-3D","(p1)","<p>Sets the “sync mode&#39;&#39; to <code>true</code> or <code>false</code>. When sync mode is true, all output is immediately flushed …\n"],["sync=","StringIO","StringIO.html#method-i-sync-3D","(p1)","<p>Returns the argument unchanged.  Just for compatibility to IO.\n"],["sync=","Zlib::GzipFile","Zlib/GzipFile.html#method-i-sync-3D","(p1)","<p>Same as IO.  If flag is <code>true</code>, the associated IO object must respond to the <code>flush</code> method.  While <code>sync</code> …\n"],["sync_keys!","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-sync_keys-21","()",""],["sync_point?","Zlib::Inflate","Zlib/Inflate.html#method-i-sync_point-3F","()","<p>Quoted verbatim from original documentation:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">What</span> <span class=\"ruby-identifier\">is</span> <span class=\"ruby-identifier\">this?</span>\n</pre>\n<p><code>:)</code>\n"],["synchronize","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-synchronize","()",""],["synchronize","Monitor","Monitor.html#method-i-synchronize","()",""],["synchronize","MonitorMixin","MonitorMixin.html#method-i-synchronize","(&b)",""],["synchronize","Mutex","Mutex.html#method-i-synchronize","()","<p>Obtains a lock, runs the block, and releases the lock when the block completes.  See the example under …\n"],["syncmode=","GDBM","GDBM.html#method-i-syncmode-3D","(p1)","<p>Turns the database&#39;s synchronization mode on or off. If the synchronization mode is turned on, the …\n"],["sysaccept","Socket","Socket.html#method-i-sysaccept","()","<p>Accepts an incoming connection returning an array containing the (integer) file descriptor for the incoming …\n"],["sysaccept","TCPServer","TCPServer.html#method-i-sysaccept","()","<p>Returns a file descriptor of a accepted connection.\n\n<pre>TCPServer.open(&quot;127.0.0.1&quot;, 28561) {|serv|\n  fd = ...</pre>\n"],["sysaccept","UNIXServer","UNIXServer.html#method-i-sysaccept","()","<p>Accepts a new connection. It returns the new file descriptor which is an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">UNIXServer</span>.<span class=\"ruby-identifier\">open</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["syscall","Kernel","Kernel.html#method-i-syscall","(*args)","<p>Calls the operating system function identified by <em>num</em> and returns the result of the function or raises …\n"],["sysclose","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-sysclose","()","<p>Sends “close notify” to the peer and tries to shut down the SSL connection gracefully.\n<p>If sync_close …\n"],["sysconf","Etc","Etc.html#method-c-sysconf","(p1)","<p>Returns system configuration variable using sysconf().\n<p><em>name</em> should be a constant under <code>Etc</code> which begins …\n"],["sysconfdir","Etc","Etc.html#method-c-sysconfdir","()","<p>Returns system configuration directory.\n<p>This is typically “/etc”, but is modified by the prefix …\n"],["syslog","Syslog::Logger","Syslog/Logger.html#method-c-syslog","()","<p>Returns the internal Syslog object that is initialized when the first instance is created.\n"],["syslog=","Syslog::Logger","Syslog/Logger.html#method-c-syslog-3D","(syslog)","<p>Specifies the internal Syslog object to be used.\n"],["sysopen","IO","IO.html#method-c-sysopen","(p1, p2 = v2, p3 = v3)","<p>Opens the given path, returning the underlying file descriptor as a Integer.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">IO</span>.<span class=\"ruby-identifier\">sysopen</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>)   <span class=\"ruby-operator\">...</span>\n</pre>\n"],["sysopen","Pathname","Pathname.html#method-i-sysopen","(p1 = v1, p2 = v2)","<p>See IO.sysopen.\n"],["sysread","IO","IO.html#method-i-sysread","(p1, p2 = v2)","<p>Reads <em>maxlen</em> bytes from <em>ios</em> using a low-level read and returns them as a string.  Do not mix with other …\n"],["sysread","IO::generic_readable","IO/generic_readable.html#method-i-sysread","(*args)","<p>Similar to #read, but raises <code>EOFError</code> at end of string instead of returning <code>nil</code>, as well as IO#sysread …\n"],["sysread","Object","Object.html#method-i-sysread","(io, size)","<p>cgi_runner.rb – CGI launcher.\n<p>Author: IPR – Internet Programming with Ruby – writers Copyright © …\n"],["sysread","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-sysread","(*args)","<p>Reads <em>length</em> bytes from the SSL connection.  If a pre-allocated <em>buffer</em> is provided the data will be written …\n"],["sysread_nonblock","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-sysread_nonblock","(*args)","<p>A non-blocking version of #sysread.  Raises an SSLError if reading would block.  If “exception: …\n"],["sysseek","IO","IO.html#method-i-sysseek","(p1, p2 = v2)","<p>Seeks to a given <em>offset</em> in the stream according to the value of <em>whence</em> (see IO#seek for values of <em>whence</em> …\n"],["syssign","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-syssign","(p1)","<p>Computes and returns the DSA signature of <em>string</em>, where <em>string</em> is expected to be an already-computed …\n"],["system","Bundler::RubyVersion","Bundler/RubyVersion.html#method-c-system","()",""],["system","Kernel","Kernel.html#method-i-system","(*args)","<p>Executes <em>command…</em> in a subshell. <em>command…</em> is one of following forms.\n<p><code>commandline</code> &mdash; command line string …\n"],["system","Net::FTP","Net/FTP.html#method-i-system","()","<p>Returns system information.\n"],["system","REXML::DocType","REXML/DocType.html#method-i-system","()","<p>This method retrieves the system identifier identifying the document&#39;s DTD\n<p>Method contributed by  …\n"],["system_bindir","Bundler","Bundler.html#method-c-system_bindir","()",""],["systmpdir","Etc","Etc.html#method-c-systmpdir","()","<p>Returns system temporary directory; typically “/tmp”.\n"],["sysverify","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-sysverify","(p1, p2)","<p>Verifies whether the signature is valid given the message digest input. It does so by validating <em>sig</em> …\n"],["syswrite","IO","IO.html#method-i-syswrite","(p1)","<p>Writes the given string to <em>ios</em> using a low-level write. Returns the number of bytes written. Do not mix …\n"],["syswrite","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-syswrite","(p1)","<p>Writes <em>string</em> to the SSL connection.\n"],["syswrite_nonblock","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-syswrite_nonblock","(p1, p2 = {})","<p>Writes <em>string</em> to the SSL connection in a non-blocking manner.  Raises an SSLError if writing would block. …\n"],["t","Matrix","Matrix.html#method-i-t","()",""],["table","CSV","CSV.html#method-c-table","(path, **options)","<p>A shortcut for:\n\n<pre>CSV.read( path, { headers:           true,\n                  converters:        :numeric, ...</pre>\n"],["tag","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-tag","(tag)","<p>Tags the current state of the dependency as the given tag @param  [Object] tag an opaque tag for the …\n"],["tag","Bundler::Molinillo::DependencyGraph::Log","Bundler/Molinillo/DependencyGraph/Log.html#method-i-tag","(graph, tag)","<p>@macro action\n"],["tag","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-tag","(tag)","<p>Tags the current state of the dependency as the given tag @param  [Object] tag an opaque tag for the …\n"],["tag","Gem::Resolver::Molinillo::DependencyGraph::Log","Gem/Resolver/Molinillo/DependencyGraph/Log.html#method-i-tag","(graph, tag)","<p>@macro action\n"],["tag","RSS::Element","RSS/Element.html#method-i-tag","(indent, additional_attrs={}, &block)",""],["tag","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-tag","(indent, attrs={}, &block)",""],["tag","UncaughtThrowError","UncaughtThrowError.html#method-i-tag","()","<p>Return the tag object which was called for.\n"],["tag_end","REXML::StreamListener","REXML/StreamListener.html#method-i-tag_end","(name)","<p>Called when the end tag is reached.  In the case of &lt;tag/&gt;, tag_end will be called immediately …\n"],["tag_end","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-tag_end","(name)",""],["tag_filter","RSS::Element","RSS/Element.html#method-i-tag_filter","(tags)",""],["tag_name","RSS::Element","RSS/Element.html#method-i-tag_name","()",""],["tag_name","RSS::Element","RSS/Element.html#method-c-tag_name","()",""],["tag_name_with_prefix","RSS::Element","RSS/Element.html#method-i-tag_name_with_prefix","(prefix)",""],["tag_start","REXML::StreamListener","REXML/StreamListener.html#method-i-tag_start","(name, attrs)","<p>Called when a tag is encountered. @p name the tag name @p attrs an array of arrays of attribute/value …\n"],["tag_start","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-tag_start","(name, attributes)",""],["tag_version","Bundler::GemHelper","Bundler/GemHelper.html#method-i-tag_version","()",""],["taint","Object","Object.html#method-i-taint","()","<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.\n"],["taint","Pathname","Pathname.html#method-i-taint","()","<p>Returns pathname.  This method is deprecated and will be removed in Ruby 3.2.\n"],["tainted?","Object","Object.html#method-i-tainted-3F","()","<p>Returns false.  This method is deprecated and will be removed in Ruby 3.2.\n"],["take","Array","Array.html#method-i-take","(p1)","<p>Returns first <code>n</code> elements from the array.\n<p>If a negative number is given, raises an ArgumentError.\n<p>See also …\n"],["take","Enumerable","Enumerable.html#method-i-take","(p1)","<p>Returns first n elements from <em>enum</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">4</span>, <span class=\"ruby-value\">5</span>, <span class=\"ruby-value\">0</span>]\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">take</span>(<span class=\"ruby-value\">3</span>)             <span class=\"ruby-comment\">#=&gt; [1, 2, 3]</span>\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">take</span>(<span class=\"ruby-value\">30</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["take","Enumerator::Lazy","Enumerator/Lazy.html#method-i-take","(p1)","<p>Like Enumerable#take, but chains operation to be lazy-evaluated.\n"],["take","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-take","(tuple, sec=nil, &block)","<p>Removes <code>tuple</code>\n"],["take","Rinda::TupleSpaceProxy","Rinda/TupleSpaceProxy.html#method-i-take","(tuple, sec=nil, &block)","<p>Takes <code>tuple</code> from the proxied TupleSpace.  See TupleSpace#take.\n"],["take_while","Array","Array.html#method-i-take_while","()","<p>Passes elements to the block until the block returns <code>nil</code> or <code>false</code>, then stops iterating and returns an …\n"],["take_while","Enumerable","Enumerable.html#method-i-take_while","()","<p>Passes elements to the block until the block returns <code>nil</code> or <code>false</code>, then stops iterating and returns an …\n"],["take_while","Enumerator::Lazy","Enumerator/Lazy.html#method-i-take_while","()","<p>Like Enumerable#take_while, but chains operation to be lazy-evaluated.\n"],["tally","Enumerable","Enumerable.html#method-i-tally","()","<p>Tallies the collection, i.e., counts the occurrences of each element. Returns a hash with the elements …\n"],["tan","Math","Math.html#method-c-tan","(p1)","<p>Computes the tangent of <code>x</code> (expressed in radians).\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (-INFINITY,  …\n"],["tanh","Math","Math.html#method-c-tanh","(p1)","<p>Computes the hyperbolic tangent of <code>x</code> (expressed in radians).\n<p>Domain: (-INFINITY, INFINITY)\n<p>Codomain: (-1, …\n"],["tap","Object","Object.html#method-i-tap","()","<p>Yields self to the block, and then returns self. The primary purpose of this method is to “tap into” …\n"],["tar_dir_header","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-tar_dir_header","(name, prefix, mode, mtime)",""],["tar_file_header","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-tar_file_header","(fname, dname, mode, length, mtime)",""],["tar_symlink_header","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-tar_symlink_header","(fname, prefix, mode, mtime, linkname)",""],["target_bin_path","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-target_bin_path","(bin_dir, bin_file)",""],["target_respond_to?","Delegator","Delegator.html#method-i-target_respond_to-3F","(target, m, include_private)","<p>Handle BasicObject instances\n"],["task","Object","Object.html#method-i-task","(*)",""],["task_help","Bundler::Thor","Bundler/Thor.html#method-c-task_help","(shell, command_name)",""],["tasks","Bundler::Thor::Base::ClassMethods","Bundler/Thor/Base/ClassMethods.html#method-i-tasks","()",""],["tcp","Addrinfo","Addrinfo.html#method-c-tcp","(p1, p2)","<p>returns an addrinfo object for TCP address.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-string\">&quot;smtp&quot;</span>) <span class=\"ruby-comment\">#=&gt; #&lt;Addrinfo: 127.0.0.1:25 ...</span>\n</pre>\n"],["tcp","Socket","Socket.html#method-c-tcp","(host, port, local_host = nil, local_port = nil, connect_timeout: nil, resolv_timeout: nil)","<p>creates a new socket object connected to host:port using TCP/IP.\n<p>If local_host:local_port is given, the …\n"],["tcp_server_loop","Socket","Socket.html#method-c-tcp_server_loop","(host=nil, port)","<p>creates a TCP/IP server on <em>port</em> and calls the block for each connection accepted. The block is called …\n"],["tcp_server_sockets","Socket","Socket.html#method-c-tcp_server_sockets","(host=nil, port)","<p>creates TCP/IP server sockets for <em>host</em> and <em>port</em>. <em>host</em> is optional.\n<p>If no block given, it returns an array …\n"],["tcp_socket","Net::IMAP","Net/IMAP.html#method-i-tcp_socket","(host, port)",""],["tcp_socket","Net::SMTP","Net/SMTP.html#method-i-tcp_socket","(address, port)",""],["teardown","Gem::TestCase","Gem/TestCase.html#method-i-teardown","()","<p>#teardown restores the process to its original state and removes the tempdir\n"],["tell","ARGF","ARGF.html#method-i-tell","()","<p>Returns the current offset (in bytes) of the current file in <code>ARGF</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ARGF</span>.<span class=\"ruby-identifier\">pos</span>    <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-constant\">ARGF</span>.<span class=\"ruby-identifier\">gets</span>   <span class=\"ruby-comment\">#=&gt; &quot;This ...</span>\n</pre>\n"],["tell","Dir","Dir.html#method-i-tell","()","<p>Returns the current position in <em>dir</em>. See also Dir#seek.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testdir&quot;</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">tell</span>   <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">read</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["tell","IO","IO.html#method-i-tell","()","<p>Returns the current offset (in bytes) of <em>ios</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">f</span> = <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>)\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">pos</span>    <span class=\"ruby-comment\">#=&gt; 0</span>\n<span class=\"ruby-identifier\">f</span>.<span class=\"ruby-identifier\">gets</span>   <span class=\"ruby-comment\">#=&gt; &quot;This ...</span>\n</pre>\n"],["tell","StringIO","StringIO.html#method-i-tell","()","<p>Returns the current offset (in bytes).\n"],["tell","Zlib::GzipReader","Zlib/GzipReader.html#method-i-tell","()","<p>Total number of output bytes output so far.\n"],["tell","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-tell","()","<p>Total number of input bytes read so far.\n"],["tell_err","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-tell_err","(message, color = nil, newline = nil)",""],["tell_me","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-tell_me","(msg, color = nil, newline = nil)","<p>valimism\n"],["template","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-template","(source, *args, &block)","<p>Gets an ERB template at the relative source, executes it and makes a copy at the relative destination. …\n"],["template_dir_for","RDoc::Options","RDoc/Options.html#method-i-template_dir_for","(template)","<p>Finds the template dir for <code>template</code>\n"],["template_files","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-template_files","()","<p>for installation of bundler as default gems\n"],["template_files_in","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-template_files_in","(dir)","<p>for cleanup old bundler files\n"],["temporary","Bundler::Settings","Bundler/Settings.html#method-i-temporary","(update)",""],["term=","Racc::Sym","Racc/Sym.html#method-i-term-3D","(t)",""],["terminal","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-terminal","(o)",""],["terminal?","Racc::Sym","Racc/Sym.html#method-i-terminal-3F","()",""],["terminal_width","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-terminal_width","()","<p>This code was copied from Rake, available under MIT-LICENSE Copyright © 2003, 2004 Jim Weirich\n"],["terminals","Racc::SymbolTable","Racc/SymbolTable.html#method-i-terminals","(&block)",""],["terminate","GetoptLong","GetoptLong.html#method-i-terminate","()","<p>Explicitly terminate option processing.\n"],["terminate","OptionParser","OptionParser.html#method-i-terminate","(arg = nil)","<p>Terminates option parsing. Optional parameter <code>arg</code> is a string pushed back to be the first non-option …\n"],["terminate","OptionParser","OptionParser.html#method-c-terminate","(arg = nil)",""],["terminate","StringScanner","StringScanner.html#method-i-terminate","()","<p>Sets the scan pointer to the end of the string and clear matching data.\n"],["terminate","Thread","Thread.html#method-i-terminate","()","<p>Terminates <code>thr</code> and schedules another thread to be run, returning the terminated Thread.  If this is the …\n"],["terminate","WEBrick::Utils::TimeoutHandler","WEBrick/Utils/TimeoutHandler.html#method-c-terminate","()",""],["terminate_interaction","Gem::MockGemUi","Gem/MockGemUi.html#method-i-terminate_interaction","(status=0)",""],["terminate_interaction","Gem::StreamUI","Gem/StreamUI.html#method-i-terminate_interaction","(status = 0)","<p>Terminate the application with exit code <code>status</code>, running any exit handlers that might have been defined. …\n"],["terminate_interaction","Gem::UserInteraction","Gem/UserInteraction.html#method-i-terminate_interaction","(exit_code = 0)","<p>Terminates the RubyGems process with the given <code>exit_code</code>\n"],["terminated?","Gem::MockGemUi","Gem/MockGemUi.html#method-i-terminated-3F","()",""],["terminated?","GetoptLong","GetoptLong.html#method-i-terminated-3F","()","<p>Returns true if option processing has terminated, false otherwise.\n"],["termsig","Process::Status","Process/Status.html#method-i-termsig","()","<p>Returns the number of the signal that caused <em>stat</em> to terminate (or <code>nil</code> if self was not terminated by …\n"],["test","Kernel","Kernel.html#method-i-test","(*args)","<p>Uses the character <code>cmd</code> to perform various tests on <code>file1</code> (first table below) or on <code>file1</code> and <code>file2</code> (second …\n"],["test_all","Date","Date.html#method-c-test_all","()",""],["test_civil","Date","Date.html#method-c-test_civil","()",""],["test_commercial","Date","Date.html#method-c-test_commercial","()",""],["test_nth_kday","Date","Date.html#method-c-test_nth_kday","()",""],["test_ordinal","Date","Date.html#method-c-test_ordinal","()",""],["test_unit_conv","Date","Date.html#method-c-test_unit_conv","()",""],["test_weeknum","Date","Date.html#method-c-test_weeknum","()",""],["text","PrettyPrint","PrettyPrint.html#method-i-text","(obj, width=obj.length)","<p>This adds <code>obj</code> as a text of <code>width</code> columns in width.\n<p>If <code>width</code> is not specified, obj.length is used.\n"],["text","PrettyPrint::SingleLine","PrettyPrint/SingleLine.html#method-i-text","(obj, width=nil)","<p>Add <code>obj</code> to the text to be output.\n<p><code>width</code> argument is here for compatibility. It is a noop argument.\n"],["text","REXML::Element","REXML/Element.html#method-i-text","( path = nil )","<p>A convenience method which returns the String value of the <em>first</em> child text element, if one exists, and …\n"],["text","REXML::Functions","REXML/Functions.html#method-c-text","( )",""],["text","REXML::StreamListener","REXML/StreamListener.html#method-i-text","(text)","<p>Called when text is encountered in the document @p text the text content.\n"],["text","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-text","(data)",""],["text=","RDoc::Comment","RDoc/Comment.html#method-i-text-3D","(text)","<p>Replaces this comment&#39;s text with <code>text</code> and resets the parsed document.\n<p>An error is raised if the comment …\n"],["text=","REXML::Element","REXML/Element.html#method-i-text-3D","( text )","<p>Sets the first Text child of this object.  See text() for a discussion about Text children.\n<p>If a Text …\n"],["text=","REXML::Light::Node","REXML/Light/Node.html#method-i-text-3D","( foo )",""],["text?","RDoc::TopLevel","RDoc/TopLevel.html#method-i-text-3F","()","<p>Is this TopLevel from a text file instead of a source code file?\n"],["text?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-text-3F","()","<p>Content: [ String raw_text, String unnormalized_text ]\n"],["text_field","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-text_field","(name = \"\", value = nil, size = 40, maxlength = nil)","<p>Generate a text field Input element, as a String.\n<p><code>name</code> is the name of the input field.  <code>value</code> is its initial …\n"],["text_type_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-text_type_writer","(name, disp_name=name)",""],["textarea","CGI::HtmlExtension","CGI/HtmlExtension.html#method-i-textarea","(name = \"\", cols = 70, rows = 10)","<p>Generate a TextArea element, as a String.\n<p><code>name</code> is the name of the textarea.  <code>cols</code> is the number of columns …\n"],["textinput","RSS::Rss","RSS/Rss.html#method-i-textinput","()",""],["texts","REXML::Element","REXML/Element.html#method-i-texts","()","<p>Get an array of all Text children. IMMUTABLE\n"],["then","Object","Object.html#method-i-then","()","<p>Yields self to the block and returns the result of the block.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">3</span>.<span class=\"ruby-identifier\">next</span>.<span class=\"ruby-identifier\">then</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">x</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">x</span><span class=\"ruby-operator\">**</span><span class=\"ruby-identifier\">x</span> }.<span class=\"ruby-identifier\">to_s</span>            <span class=\"ruby-operator\">...</span>\n</pre>\n"],["this","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-this","()",""],["this_update","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-this_update","()",""],["thor","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-thor","(command, *args)","<p>Run a thor command. A hash of options can be given and it&#39;s converted to switches.\n<p>Parameters\n<p>command&lt;String&gt; … &mdash; "],["thor_classes_in","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-thor_classes_in","(klass)","<p>Returns the thor classes declared inside the given class.\n"],["thor_root","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-thor_root","()","<p>Returns the root where thor files are located, depending on the OS.\n"],["thor_root_glob","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-thor_root_glob","()","<p>Returns the files in the thor root. On Windows thor_root will be something like this:\n\n<pre>C:\\Documents and ...</pre>\n"],["thread","DRb","DRb.html#method-c-thread","()","<p>Get the thread of the primary server.\n<p>This returns nil if there is no primary server.  See #primary_server …\n"],["thread","DRb","DRb.html#method-i-thread","()","<p>Get the thread of the primary server.\n<p>This returns nil if there is no primary server.  See #primary_server …\n"],["thread","IRB::JobManager","IRB/JobManager.html#method-i-thread","(key)","<p>Returns the thread for the given <code>key</code> object, see #search for more information.\n"],["thread","Net::IMAP","Net/IMAP.html#method-i-thread","(algorithm, search_keys, charset)","<p>Similar to #search(), but returns message sequence numbers in threaded format, as a Net::IMAP::ThreadMember …\n"],["thread_internal","Net::IMAP","Net/IMAP.html#method-i-thread_internal","(cmd, algorithm, search_keys, charset)",""],["thread_list","DEBUGGER__","DEBUGGER__.html#method-c-thread_list","(num)",""],["thread_list_all","DEBUGGER__","DEBUGGER__.html#method-c-thread_list_all","()","<p>Prints all threads in @thread_list to @stdout. Returns a sorted array of values from the @thread_list …\n"],["thread_variable?","Thread","Thread.html#method-i-thread_variable-3F","(p1)","<p>Returns <code>true</code> if the given string (or symbol) exists as a thread-local variable.\n\n<pre>me = Thread.current\nme.thread_variable_set(:oliver, ...</pre>\n"],["thread_variable_get","Thread","Thread.html#method-i-thread_variable_get","(p1)","<p>Returns the value of a thread local variable that has been set.  Note that these are different than fiber …\n"],["thread_variable_set","Thread","Thread.html#method-i-thread_variable_set","(p1, p2)","<p>Sets a thread local with <code>key</code> to <code>value</code>.  Note that these are local to threads, and not to fibers.  Please …\n"],["thread_variables","Thread","Thread.html#method-i-thread_variables","()","<p>Returns an array of the names of the thread-local variables (as Symbols).\n\n<pre>thr = Thread.new do\n  Thread.current.thread_variable_set(:cat, ...</pre>\n"],["throw","Kernel","Kernel.html#method-i-throw","(p1, p2 = v2)","<p>Transfers control to the end of the active <code>catch</code> block waiting for <em>tag</em>. Raises <code>UncaughtThrowError</code> if …\n"],["thursday?","Date","Date.html#method-i-thursday-3F","()","<p>Returns true if the date is Thursday.\n"],["thursday?","Time","Time.html#method-i-thursday-3F","()","<p>Returns <code>true</code> if <em>time</em> represents Thursday.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">1995</span>, <span class=\"ruby-value\">12</span>, <span class=\"ruby-value\">21</span>)     <span class=\"ruby-comment\">#=&gt; 1995-12-21 00:00:00 -0600 ...</span>\n</pre>\n"],["time","Gem","Gem.html#method-c-time","(msg, width = 0, display = Gem.configuration.verbose)","<p>Prints the amount of time the supplied block takes to run using the debug UI output.\n"],["time","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-time","()","<p>Returns the time at which the session was established.\n"],["time","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-time","()",""],["time=","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-time-3D","(p1)","<p>Sets start time of the session. Time resolution is in seconds.\n"],["time=","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-time-3D","(p1)",""],["time=","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-time-3D","(p1)","<p>Sets the time to be used in verifications.\n"],["time=","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-time-3D","(p1)","<p>Sets the time used in the verification. If not set, the current time is used.\n"],["timeout","Object","Object.html#method-i-timeout","(*args, &block)",""],["timeout","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-timeout","()","<p>Returns the timeout value set for the session, in seconds from the established time.\n"],["timeout","Timeout","Timeout.html#method-i-timeout","(sec, klass = nil, message = nil)","<p>Perform an operation in a block, raising an error if it takes longer than <code>sec</code> seconds to complete.\n<p><code>sec</code> … &mdash; "],["timeout","Timeout","Timeout.html#method-c-timeout","(sec, klass = nil, message = nil)","<p>Perform an operation in a block, raising an error if it takes longer than <code>sec</code> seconds to complete.\n<p><code>sec</code> … &mdash; "],["timeout","WEBrick::Utils","WEBrick/Utils.html#method-c-timeout","(seconds, exception=Timeout::Error)","<p>Executes the passed block and raises <code>exception</code> if execution takes more than <code>seconds</code>.\n<p>If <code>seconds</code> is zero …\n"],["timeout","WEBrick::Utils","WEBrick/Utils.html#method-i-timeout","(seconds, exception=Timeout::Error)","<p>Executes the passed block and raises <code>exception</code> if execution takes more than <code>seconds</code>.\n<p>If <code>seconds</code> is zero …\n"],["timeout=","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-timeout-3D","(p1)","<p>Sets how long until the session expires in seconds.\n"],["timeouts=","Resolv::DNS","Resolv/DNS.html#method-i-timeouts-3D","(values)","<p>Sets the resolver timeouts.  This may be a single positive number or an array of positive numbers representing …\n"],["times","Integer","Integer.html#method-i-times","()","<p>Iterates the given block <code>int</code> times, passing in values from zero to <code>int - 1</code>.\n<p>If no block is given, an  …\n"],["times","Process","Process.html#method-c-times","()","<p>Returns a <code>Tms</code> structure (see Process::Tms) that contains user and system CPU times for this process, …\n"],["timestamp","Socket::AncillaryData","Socket/AncillaryData.html#method-i-timestamp","()","<p>returns the timestamp as a time object.\n<p><em>ancillarydata</em> should be one of following type:\n<p>SOL_SOCKET/SCM_TIMESTAMP …\n"],["title","RDoc::Store","RDoc/Store.html#method-i-title","()","<p>Gets the title for this RDoc store.  This is used as the title in each page on the RDoc server\n"],["title=","RDoc::Store","RDoc/Store.html#method-i-title-3D","(title)","<p>Sets the title page for this RDoc store.\n"],["tk_nl?","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-tk_nl-3F","(tk)",""],["tls?","Net::SMTP","Net/SMTP.html#method-i-tls-3F","()","<p>true if this object uses SMTP/TLS (SMTPS).\n"],["tlsconnect","Net::SMTP","Net/SMTP.html#method-i-tlsconnect","(s)",""],["tmp","Bundler","Bundler.html#method-c-tmp","(name = Process.pid.to_s)",""],["tmp","Bundler::Plugin::API","Bundler/Plugin/API.html#method-i-tmp","(*names)","<p>A tmp dir to be used by plugins Accepts names that get concatenated as suffix\n<p>@return [Pathname] object …\n"],["tmp_dh_callback","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-tmp_dh_callback","()",""],["tmp_ecdh_callback","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-tmp_ecdh_callback","()",""],["tmp_home_path","Bundler","Bundler.html#method-c-tmp_home_path","(warning)",""],["tmp_key","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-tmp_key","()","<p>Returns the ephemeral key used in case of forward secrecy cipher.\n"],["tmpdir","Dir","Dir.html#method-c-tmpdir","()","<p>Returns the operating system&#39;s temporary file path.\n"],["to=","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-to-3D","(v)","<p>Setter for to <code>v</code>.\n"],["to=","URI::MailTo","URI/MailTo.html#method-i-to-3D","(v)","<p>Setter for to <code>v</code>.\n"],["to_a","ARGF","ARGF.html#method-i-to_a","(*args)","<p>Reads <code>ARGF</code>&#39;s current file in its entirety, returning an <code>Array</code> of its lines, one line per element. …\n"],["to_a","Array","Array.html#method-i-to_a","()","<p>Returns <code>self</code>.\n<p>If called on a subclass of Array, converts the receiver to an Array object.\n"],["to_a","Benchmark::Tms","Benchmark/Tms.html#method-i-to_a","()","<p>Returns a new 6-element array, consisting of the label, user CPU time, system CPU time, children&#39;s …\n"],["to_a","Bundler::SpecSet","Bundler/SpecSet.html#method-i-to_a","()",""],["to_a","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-to_a","()",""],["to_a","CSV::Table","CSV/Table.html#method-i-to_a","()","<p>Returns the table as an Array of Arrays. Headers will be the first row, then all of the field rows will …\n"],["to_a","DBM","DBM.html#method-i-to_a","()","<p>Converts the contents of the database to an array of [key, value] arrays, and returns it.\n"],["to_a","ENV","ENV.html#method-c-to_a","()","<p>Converts the environment variables into an array of names and value arrays.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">to_a</span> <span class=\"ruby-comment\"># =&gt; [[&quot;TERM&quot;, &quot;xterm-color&quot;], ...</span>\n</pre>\n"],["to_a","Enumerable","Enumerable.html#method-i-to_a","(*args)","<p>Returns an array containing the items in <em>enum</em>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">to_a</span>                       <span class=\"ruby-comment\">#=&gt; [1, 2, 3, 4, 5, 6, ...</span>\n</pre>\n"],["to_a","Enumerator::Lazy","Enumerator/Lazy.html#method-i-to_a","()","<p>Expands <code>lazy</code> enumerator to an array. See Enumerable#to_a.\n"],["to_a","GDBM","GDBM.html#method-i-to_a","()","<p>Returns an array of all key-value pairs contained in the database.\n"],["to_a","Gem::List","Gem/List.html#method-i-to_a","()",""],["to_a","Gem::NameTuple","Gem/NameTuple.html#method-i-to_a","()","<p>Convert back to the [name, version, platform] tuple\n"],["to_a","Gem::Platform","Gem/Platform.html#method-i-to_a","()",""],["to_a","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-to_a","()",""],["to_a","Gem::SourceList","Gem/SourceList.html#method-i-to_a","()","<p>Returns an Array of source URI Strings.\n"],["to_a","Hash","Hash.html#method-i-to_a","()","<p>Converts <em>hsh</em> to a nested array of <code>[</code> <em>key, value</em> <code>]</code> arrays.\n\n<pre>h = { &quot;c&quot; =&gt; 300, &quot;a&quot; =&gt; 100, &quot;d&quot; =&gt; 400, &quot;c&quot; ...</pre>\n"],["to_a","MatchData","MatchData.html#method-i-to_a","()","<p>Returns the array of matches.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> = <span class=\"ruby-regexp\">/(.)(.)(\\d+)(\\d)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;THX1138.&quot;</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">to_a</span>   <span class=\"ruby-comment\">#=&gt; [&quot;HX1138&quot;, &quot;H&quot;, &quot;X&quot;, ...</span>\n</pre>\n"],["to_a","Matrix","Matrix.html#method-i-to_a","()","<p>Returns an array of arrays that describe the rows of the matrix.\n"],["to_a","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-to_a","()",""],["to_a","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-to_a","()",""],["to_a","NilClass","NilClass.html#method-i-to_a","()","<p>Always returns an empty array.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">nil</span>.<span class=\"ruby-identifier\">to_a</span>   <span class=\"ruby-comment\">#=&gt; []</span>\n</pre>\n"],["to_a","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-to_a","()",""],["to_a","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-to_a","()","<p>Returns an Array representation of the distinguished name suitable for passing to ::new\n"],["to_a","OptionParser","OptionParser.html#method-i-to_a","()","<p>Returns option summary list.\n"],["to_a","REXML::Attributes","REXML/Attributes.html#method-i-to_a","()",""],["to_a","REXML::Elements","REXML/Elements.html#method-i-to_a","( xpath=nil )","<p>Returns an Array of Element children.  An XPath may be supplied to filter the children.  Only Element …\n"],["to_a","REXML::Parent","REXML/Parent.html#method-i-to_a","()",""],["to_a","Racc::ISet","Racc/ISet.html#method-i-to_a","()",""],["to_a","Range","Range.html#method-i-to_a","()","<p>Returns an array containing the items in the range.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">7</span>).<span class=\"ruby-identifier\">to_a</span>  <span class=\"ruby-comment\">#=&gt; [1, 2, 3, 4, 5, 6, 7]</span>\n(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span>).<span class=\"ruby-identifier\">to_a</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_a","Rinda::RingFinger","Rinda/RingFinger.html#method-i-to_a","()","<p>Contains all discovered TupleSpaces except for the primary.\n"],["to_a","Rinda::RingFinger","Rinda/RingFinger.html#method-c-to_a","()","<p>Contains all discovered TupleSpaces except for the primary.\n"],["to_a","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-to_a","()","<p>Returns an Array with 14 elements representing the instruction sequence with the following data:\n<p>magic … &mdash; "],["to_a","SDBM","SDBM.html#method-i-to_a","()","<p>Returns a new Array containing each key-value pair in the database.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;sdbm&#39;</span>\n\n<span class=\"ruby-constant\">SDBM</span>.<span class=\"ruby-identifier\">open</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_a","Set","Set.html#method-i-to_a","()","<p>Converts the set to an array.  The order of elements is uncertain.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Set</span>[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>].<span class=\"ruby-identifier\">to_a</span>                    <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["to_a","Struct","Struct.html#method-i-to_a","()","<p>Returns the values for this struct as an Array.\n\n<pre>Customer = Struct.new(:name, :address, :zip)\njoe = Customer.new(&quot;Joe ...</pre>\n"],["to_a","Time","Time.html#method-i-to_a","()","<p>Returns a ten-element <em>array</em> of values for <em>time</em>:\n\n<pre>[sec, min, hour, day, month, year, wday, yday, isdst, ...</pre>\n"],["to_a","Vector","Vector.html#method-i-to_a","()","<p>Returns the elements of the vector in an array.\n"],["to_a","YAML::DBM","YAML/DBM.html#method-i-to_a","()","<p>Converts the contents of the database to an array of [key, value] arrays, and returns it.\n"],["to_array","Bundler::Settings","Bundler/Settings.html#method-i-to_array","(value)",""],["to_ary","Array","Array.html#method-i-to_ary","()","<p>Returns <code>self</code>.\n"],["to_ary","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-to_ary","()",""],["to_ary","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-to_ary","()",""],["to_ary","Gem::SourceList","Gem/SourceList.html#method-i-to_ary","()",""],["to_ary","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-to_ary","()","<p>Returns [eigenvector_matrix, eigenvalue_matrix, eigenvector_matrix_inv]\n"],["to_ary","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-to_ary","()","<p>Returns <code>L</code>, <code>U</code>, <code>P</code> in an array\n"],["to_ary","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-i-to_ary","()","<p>A FormData will behave like an Array\n"],["to_atom","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-to_atom","(type, &block)",""],["to_basic","Gem::NameTuple","Gem/NameTuple.html#method-c-to_basic","(list)","<p>Turn an array of NameTuple objects back into an array of\n<p>name, version, platform &mdash; tuples.\n\n"],["to_binary","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-to_binary","(*args)","<p>Returns serialized iseq binary format data as a String object. A corresponding iseq object is created …\n"],["to_bn","Integer","Integer.html#method-i-to_bn","()","<p>Casts an Integer as an OpenSSL::BN\n<p>See `man bn` for more info.\n"],["to_bn","OpenSSL::BN","OpenSSL/BN.html#method-i-to_bn","()",""],["to_bn","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-to_bn","(conversion_form = group.point_conversion_form)","<p>Returns the octet string representation of the EC point as an instance of OpenSSL::BN.\n<p>If <em>conversion_form</em> …\n"],["to_bool","Bundler::Settings","Bundler/Settings.html#method-i-to_bool","(value)",""],["to_c","Complex","Complex.html#method-i-to_c","()","<p>Returns self.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">to_c</span>      <span class=\"ruby-comment\">#=&gt; (2+0i)</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">-8</span>, <span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">to_c</span>  <span class=\"ruby-comment\">#=&gt; (-8+6i)</span>\n</pre>\n"],["to_c","NilClass","NilClass.html#method-i-to_c","()","<p>Returns zero as a complex.\n"],["to_c","Numeric","Numeric.html#method-i-to_c","()","<p>Returns the value as a complex.\n"],["to_c","String","String.html#method-i-to_c","()","<p>Returns a complex which denotes the string form.  The parser ignores leading whitespaces and trailing …\n"],["to_class_name","RSS::Utils","RSS/Utils.html#method-i-to_class_name","(name)","<p>Given a <code>name</code> in a name_with_underscores or a name-with-dashes format, returns the CamelCase version of …\n"],["to_csv","CSV::Row","CSV/Row.html#method-i-to_csv","(**options)","<p>Returns the row as a CSV String. Headers are not used. Equivalent to:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">csv_row</span>.<span class=\"ruby-identifier\">fields</span>.<span class=\"ruby-identifier\">to_csv</span>( <span class=\"ruby-identifier\">options</span> )\n</pre>\n"],["to_csv","CSV::Table","CSV/Table.html#method-i-to_csv","(write_headers: true, **options)","<p>Returns the table as a complete CSV String. Headers will be listed first, then all of the field rows. …\n"],["to_d","BigDecimal","BigDecimal.html#method-i-to_d","()","<p>Returns self.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bigdecimal/util&#39;</span>\n\n<span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&quot;3.14&quot;</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">to_d</span>                       <span class=\"ruby-comment\"># =&gt; 0.314e1</span>\n</pre>\n"],["to_d","Float","Float.html#method-i-to_d","(precision=Float::DIG)","<p>Returns the value of <code>float</code> as a BigDecimal. The <code>precision</code> parameter is used to determine the number of …\n"],["to_d","Integer","Integer.html#method-i-to_d","()","<p>Returns the value of <code>int</code> as a BigDecimal.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bigdecimal&#39;</span>\n<span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bigdecimal/util&#39;</span>\n\n<span class=\"ruby-value\">42</span>.<span class=\"ruby-identifier\">to_d</span>   <span class=\"ruby-comment\"># ...</span>\n</pre>\n"],["to_d","NilClass","NilClass.html#method-i-to_d","()","<p>Returns nil represented as a BigDecimal.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bigdecimal&#39;</span>\n<span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bigdecimal/util&#39;</span>\n\n<span class=\"ruby-keyword\">nil</span>.<span class=\"ruby-identifier\">to_d</span>   <span class=\"ruby-comment\"># ...</span>\n</pre>\n"],["to_d","Rational","Rational.html#method-i-to_d","(precision)","<p>Returns the value as a BigDecimal.\n<p>The required <code>precision</code> parameter is used to determine the number of …\n"],["to_d","String","String.html#method-i-to_d","()","<p>Returns the result of interpreting leading characters in <code>str</code> as a BigDecimal.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bigdecimal&#39;</span>\n<span class=\"ruby-identifier\">require</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_date","Date","Date.html#method-i-to_date","()","<p>Returns self.\n"],["to_date","DateTime","DateTime.html#method-i-to_date","()","<p>Returns a Date object which denotes self.\n"],["to_date","Time","Time.html#method-i-to_date","()","<p>Returns a Date object which denotes self.\n"],["to_datetime","Date","Date.html#method-i-to_datetime","()","<p>Returns a DateTime object which denotes self.\n"],["to_datetime","DateTime","DateTime.html#method-i-to_datetime","()","<p>Returns self.\n"],["to_datetime","Time","Time.html#method-i-to_datetime","()","<p>Returns a DateTime object which denotes self.\n"],["to_definition","Bundler::Dsl","Bundler/Dsl.html#method-i-to_definition","(lockfile, unlock)",""],["to_der","OpenSSL::ASN1::ASN1Data","OpenSSL/ASN1/ASN1Data.html#method-i-to_der","()","<p>Encodes this ASN1Data into a DER-encoded String value. The result is DER-encoded except for the possibility …\n"],["to_der","OpenSSL::ASN1::Constructive","OpenSSL/ASN1/Constructive.html#method-i-to_der","()","<p>See ASN1Data#to_der for details.\n"],["to_der","OpenSSL::ASN1::Primitive","OpenSSL/ASN1/Primitive.html#method-i-to_der","()","<p>See ASN1Data#to_der for details.\n"],["to_der","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-to_der","()","<p>Returns the DER encoding of this SPKI.\n"],["to_der","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-to_der","()","<p>Encodes this basic response into a DER-encoded string.\n"],["to_der","OpenSSL::OCSP::CertificateId","OpenSSL/OCSP/CertificateId.html#method-i-to_der","()","<p>Encodes this certificate identifier into a DER-encoded string.\n"],["to_der","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-to_der","()","<p>Returns this request as a DER-encoded string\n"],["to_der","OpenSSL::OCSP::Response","OpenSSL/OCSP/Response.html#method-i-to_der","()","<p>Returns this response as a DER-encoded string.\n"],["to_der","OpenSSL::OCSP::SingleResponse","OpenSSL/OCSP/SingleResponse.html#method-i-to_der","()","<p>Encodes this SingleResponse into a DER-encoded string.\n"],["to_der","OpenSSL::PKCS12","OpenSSL/PKCS12.html#method-i-to_der","()",""],["to_der","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-to_der","()",""],["to_der","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-to_der","()","<p>Encodes this DH to its DER encoding. Note that any existing per-session public/private keys will <strong>not</strong> …\n"],["to_der","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-to_der","()","<p>Encodes this DSA to its DER encoding.\n"],["to_der","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-to_der","()","<p>See the OpenSSL documentation for i2d_ECPrivateKey_bio()\n"],["to_der","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-to_der","()","<p>See the OpenSSL documentation for i2d_ECPKParameters_bio()\n"],["to_der","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-to_der","()","<p>Outputs this keypair in DER encoding.\n"],["to_der","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-to_der","()","<p>Returns an ASN1 encoded String that contains the Session object.\n"],["to_der","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-i-to_der","()",""],["to_der","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-to_der","()",""],["to_der","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-to_der","()",""],["to_der","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-to_der","()",""],["to_der","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-to_der","()","<p>Converts the name to DER encoding\n"],["to_der","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-to_der","()",""],["to_der","OpenSSL::X509::Revoked","OpenSSL/X509/Revoked.html#method-i-to_der","()",""],["to_digits","BigDecimal","BigDecimal.html#method-i-to_digits","()","<p>Converts a BigDecimal to a String of the form “nnnnnn.mmm”. This method is deprecated; use …\n"],["to_dot","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-to_dot","(options = {})","<p>@param [Hash] options options for dot output. @return [String] Returns a dot format representation of …\n"],["to_dot","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-to_dot","(options = {})","<p>@param [Hash] options options for dot output. @return [String] Returns a dot format representation of …\n"],["to_element_methods","RSS::Element","RSS/Element.html#method-c-to_element_methods","()",""],["to_enum","Enumerator::Lazy","Enumerator/Lazy.html#method-i-to_enum","(*args)","<p>Similar to Object#to_enum, except it returns a lazy enumerator. This makes it easy to define Enumerable …\n"],["to_enum","Object","Object.html#method-i-to_enum","(*args)","<p>Creates a new Enumerator which will enumerate by calling <code>method</code> on <code>obj</code>, passing <code>args</code> if any. What was …\n"],["to_f","BigDecimal","BigDecimal.html#method-i-to_f","()","<p>Returns a new Float object having approximately the same value as the BigDecimal number. Normal accuracy …\n"],["to_f","Complex","Complex.html#method-i-to_f","()","<p>Returns the value as a float if possible (the imaginary part should be exactly zero).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">0</span>).<span class=\"ruby-identifier\">to_f</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_f","Float","Float.html#method-i-to_f","()","<p>Since <code>float</code> is already a Float, returns <code>self</code>.\n"],["to_f","Integer","Integer.html#method-i-to_f","()","<p>Converts <code>int</code> to a Float.  If <code>int</code> doesn&#39;t fit in a Float, the result is infinity.\n"],["to_f","NilClass","NilClass.html#method-i-to_f","()","<p>Always returns zero.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">nil</span>.<span class=\"ruby-identifier\">to_f</span>   <span class=\"ruby-comment\">#=&gt; 0.0</span>\n</pre>\n"],["to_f","Rational","Rational.html#method-i-to_f","()","<p>Returns the value as a Float.\n\n<pre>Rational(2).to_f      #=&gt; 2.0\nRational(9, 4).to_f   #=&gt; 2.25\nRational(-3, ...</pre>\n"],["to_f","String","String.html#method-i-to_f","()","<p>Returns the result of interpreting leading characters in <em>str</em> as a floating point number. Extraneous characters …\n"],["to_f","Time","Time.html#method-i-to_f","()","<p>Returns the value of <em>time</em> as a floating point number of seconds since the Epoch.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>\n<span class=\"ruby-string\">&quot;%10.5f&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_feed","RSS::Maker::Atom::Entry::Items","RSS/Maker/Atom/Entry/Items.html#method-i-to_feed","(entry)",""],["to_feed","RSS::Maker::Atom::Entry::Items::Item","RSS/Maker/Atom/Entry/Items/Item.html#method-i-to_feed","(entry)",""],["to_feed","RSS::Maker::Atom::Feed::Channel","RSS/Maker/Atom/Feed/Channel.html#method-i-to_feed","(feed)",""],["to_feed","RSS::Maker::Atom::Feed::Channel::Cloud","RSS/Maker/Atom/Feed/Channel/Cloud.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::Atom::Feed::Channel::SkipDays","RSS/Maker/Atom/Feed/Channel/SkipDays.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::Atom::Feed::Channel::SkipHours","RSS/Maker/Atom/Feed/Channel/SkipHours.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::Atom::Feed::Image","RSS/Maker/Atom/Feed/Image.html#method-i-to_feed","(feed)",""],["to_feed","RSS::Maker::Atom::Feed::Items","RSS/Maker/Atom/Feed/Items.html#method-i-to_feed","(feed)",""],["to_feed","RSS::Maker::Atom::Feed::Items::Item","RSS/Maker/Atom/Feed/Items/Item.html#method-i-to_feed","(feed)",""],["to_feed","RSS::Maker::Atom::Feed::Items::Item::Content","RSS/Maker/Atom/Feed/Items/Item/Content.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::Atom::Feed::Items::Item::Enclosure","RSS/Maker/Atom/Feed/Items/Item/Enclosure.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::Atom::Feed::Items::Item::Guid","RSS/Maker/Atom/Feed/Items/Item/Guid.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::Atom::Feed::Items::Item::Source","RSS/Maker/Atom/Feed/Items/Item/Source.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::Atom::Feed::Items::Item::Source::Icon","RSS/Maker/Atom/Feed/Items/Item/Source/Icon.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::AtomCategory","RSS/Maker/AtomCategory.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::AtomGenerator","RSS/Maker/AtomGenerator.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::AtomLink","RSS/Maker/AtomLink.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::AtomLogo","RSS/Maker/AtomLogo.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::ITunesChannelModel::ITunesCategoriesBase::ITunesCategoryBase","RSS/Maker/ITunesChannelModel/ITunesCategoriesBase/ITunesCategoryBase.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::ITunesChannelModel::ITunesImageBase","RSS/Maker/ITunesChannelModel/ITunesImageBase.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::ITunesChannelModel::ITunesOwnerBase","RSS/Maker/ITunesChannelModel/ITunesOwnerBase.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::ITunesItemModel::ITunesDurationBase","RSS/Maker/ITunesItemModel/ITunesDurationBase.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::ImageFaviconModel::ImageFaviconBase","RSS/Maker/ImageFaviconModel/ImageFaviconBase.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::ImageItemModel::ImageItemBase","RSS/Maker/ImageItemModel/ImageItemBase.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::RSS09::Channel","RSS/Maker/RSS09/Channel.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS09::Channel::Authors","RSS/Maker/RSS09/Channel/Authors.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::Authors::Author","RSS/Maker/RSS09/Channel/Authors/Author.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::Categories","RSS/Maker/RSS09/Channel/Categories.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Channel::Cloud","RSS/Maker/RSS09/Channel/Cloud.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Channel::Contributors","RSS/Maker/RSS09/Channel/Contributors.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::Copyright","RSS/Maker/RSS09/Channel/Copyright.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::Description","RSS/Maker/RSS09/Channel/Description.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::Generator","RSS/Maker/RSS09/Channel/Generator.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::Links","RSS/Maker/RSS09/Channel/Links.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::Links::Link","RSS/Maker/RSS09/Channel/Links/Link.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::SkipDays","RSS/Maker/RSS09/Channel/SkipDays.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::SkipDays::Day","RSS/Maker/RSS09/Channel/SkipDays/Day.html#method-i-to_feed","(rss, days)",""],["to_feed","RSS::Maker::RSS09::Channel::SkipHours","RSS/Maker/RSS09/Channel/SkipHours.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Channel::SkipHours::Hour","RSS/Maker/RSS09/Channel/SkipHours/Hour.html#method-i-to_feed","(rss, hours)",""],["to_feed","RSS::Maker::RSS09::Channel::Title","RSS/Maker/RSS09/Channel/Title.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS09::Image","RSS/Maker/RSS09/Image.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS09::Items","RSS/Maker/RSS09/Items.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS09::Items::Item","RSS/Maker/RSS09/Items/Item.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Authors","RSS/Maker/RSS09/Items/Item/Authors.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Categories","RSS/Maker/RSS09/Items/Item/Categories.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Content","RSS/Maker/RSS09/Items/Item/Content.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Contributors","RSS/Maker/RSS09/Items/Item/Contributors.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Description","RSS/Maker/RSS09/Items/Item/Description.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Enclosure","RSS/Maker/RSS09/Items/Item/Enclosure.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Guid","RSS/Maker/RSS09/Items/Item/Guid.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Links","RSS/Maker/RSS09/Items/Item/Links.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Links::Link","RSS/Maker/RSS09/Items/Item/Links/Link.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Rights","RSS/Maker/RSS09/Items/Item/Rights.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source","RSS/Maker/RSS09/Items/Item/Source.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Authors","RSS/Maker/RSS09/Items/Item/Source/Authors.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Categories","RSS/Maker/RSS09/Items/Item/Source/Categories.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Contributors","RSS/Maker/RSS09/Items/Item/Source/Contributors.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Generator","RSS/Maker/RSS09/Items/Item/Source/Generator.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Icon","RSS/Maker/RSS09/Items/Item/Source/Icon.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Links","RSS/Maker/RSS09/Items/Item/Source/Links.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Logo","RSS/Maker/RSS09/Items/Item/Source/Logo.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Rights","RSS/Maker/RSS09/Items/Item/Source/Rights.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Subtitle","RSS/Maker/RSS09/Items/Item/Source/Subtitle.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Source::Title","RSS/Maker/RSS09/Items/Item/Source/Title.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS09::Items::Item::Title","RSS/Maker/RSS09/Items/Item/Title.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS09::Textinput","RSS/Maker/RSS09/Textinput.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS10::Channel","RSS/Maker/RSS10/Channel.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS10::Channel::Authors","RSS/Maker/RSS10/Channel/Authors.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::Authors::Author","RSS/Maker/RSS10/Channel/Authors/Author.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::Categories","RSS/Maker/RSS10/Channel/Categories.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Channel::Cloud","RSS/Maker/RSS10/Channel/Cloud.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Channel::Contributors","RSS/Maker/RSS10/Channel/Contributors.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::Copyright","RSS/Maker/RSS10/Channel/Copyright.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::Description","RSS/Maker/RSS10/Channel/Description.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::Generator","RSS/Maker/RSS10/Channel/Generator.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::Links","RSS/Maker/RSS10/Channel/Links.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::Links::Link","RSS/Maker/RSS10/Channel/Links/Link.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Channel::SkipDays","RSS/Maker/RSS10/Channel/SkipDays.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Channel::SkipHours","RSS/Maker/RSS10/Channel/SkipHours.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Channel::Title","RSS/Maker/RSS10/Channel/Title.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS10::Image","RSS/Maker/RSS10/Image.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS10::Items","RSS/Maker/RSS10/Items.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS10::Items::Item","RSS/Maker/RSS10/Items/Item.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Authors","RSS/Maker/RSS10/Items/Item/Authors.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Categories","RSS/Maker/RSS10/Items/Item/Categories.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Content","RSS/Maker/RSS10/Items/Item/Content.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Contributors","RSS/Maker/RSS10/Items/Item/Contributors.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Description","RSS/Maker/RSS10/Items/Item/Description.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Enclosure","RSS/Maker/RSS10/Items/Item/Enclosure.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Guid","RSS/Maker/RSS10/Items/Item/Guid.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Links","RSS/Maker/RSS10/Items/Item/Links.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Rights","RSS/Maker/RSS10/Items/Item/Rights.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source","RSS/Maker/RSS10/Items/Item/Source.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Authors","RSS/Maker/RSS10/Items/Item/Source/Authors.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Categories","RSS/Maker/RSS10/Items/Item/Source/Categories.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Contributors","RSS/Maker/RSS10/Items/Item/Source/Contributors.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Generator","RSS/Maker/RSS10/Items/Item/Source/Generator.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Icon","RSS/Maker/RSS10/Items/Item/Source/Icon.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Links","RSS/Maker/RSS10/Items/Item/Source/Links.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Logo","RSS/Maker/RSS10/Items/Item/Source/Logo.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Rights","RSS/Maker/RSS10/Items/Item/Source/Rights.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Subtitle","RSS/Maker/RSS10/Items/Item/Source/Subtitle.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Source::Title","RSS/Maker/RSS10/Items/Item/Source/Title.html#method-i-to_feed","(*args)",""],["to_feed","RSS::Maker::RSS10::Items::Item::Title","RSS/Maker/RSS10/Items/Item/Title.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS10::Textinput","RSS/Maker/RSS10/Textinput.html#method-i-to_feed","(rss)",""],["to_feed","RSS::Maker::RSS20::Channel::Categories","RSS/Maker/RSS20/Channel/Categories.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS20::Channel::Categories::Category","RSS/Maker/RSS20/Channel/Categories/Category.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS20::Channel::Cloud","RSS/Maker/RSS20/Channel/Cloud.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS20::Channel::Generator","RSS/Maker/RSS20/Channel/Generator.html#method-i-to_feed","(rss, channel)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Authors","RSS/Maker/RSS20/Items/Item/Authors.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Authors::Author","RSS/Maker/RSS20/Items/Item/Authors/Author.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Categories","RSS/Maker/RSS20/Items/Item/Categories.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Categories::Category","RSS/Maker/RSS20/Items/Item/Categories/Category.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Enclosure","RSS/Maker/RSS20/Items/Item/Enclosure.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Guid","RSS/Maker/RSS20/Items/Item/Guid.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Source","RSS/Maker/RSS20/Items/Item/Source.html#method-i-to_feed","(rss, item)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Source::Links","RSS/Maker/RSS20/Items/Item/Source/Links.html#method-i-to_feed","(rss, source)",""],["to_feed","RSS::Maker::RSS20::Items::Item::Source::Links::Link","RSS/Maker/RSS20/Items/Item/Source/Links/Link.html#method-i-to_feed","(rss, source)",""],["to_feed","RSS::Maker::RSSBase","RSS/Maker/RSSBase.html#method-i-to_feed","()",""],["to_feed","RSS::Maker::TrackBackModel::TrackBackAboutsBase::TrackBackAboutBase","RSS/Maker/TrackBackModel/TrackBackAboutsBase/TrackBackAboutBase.html#method-i-to_feed","(feed, current)",""],["to_feed","RSS::Maker::XMLStyleSheets::XMLStyleSheet","RSS/Maker/XMLStyleSheets/XMLStyleSheet.html#method-i-to_feed","(feed)",""],["to_feed","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-to_feed","(type, &block)",""],["to_feed_for_categories","RSS::Maker::ITunesChannelModel::ITunesCategoriesBase::ITunesCategoryBase","RSS/Maker/ITunesChannelModel/ITunesCategoriesBase/ITunesCategoryBase.html#method-i-to_feed_for_categories","(feed, current)",""],["to_fullpath","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-to_fullpath","(path)","<p>Full path of the target library file. If the file is not in this gem, return nil.\n"],["to_gem_version_with_patchlevel","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-to_gem_version_with_patchlevel","()",""],["to_gemfile","Gem::Specification","Gem/Specification.html#method-i-to_gemfile","(path = nil)",""],["to_h","Array","Array.html#method-i-to_h","()","<p>Returns the result of interpreting <em>ary</em> as an array of <code>[key, value]</code> pairs.\n\n<pre class=\"ruby\">[[<span class=\"ruby-value\">:foo</span>, <span class=\"ruby-value\">:bar</span>], [<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>]].<span class=\"ruby-identifier\">to_h</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_h","Bundler::BuildMetadata","Bundler/BuildMetadata.html#method-c-to_h","()","<p>A hash representation of the build metadata.\n"],["to_h","CSV::Row","CSV/Row.html#method-i-to_h","()","<p>Collapses the row into a simple Hash. Be warned that this discards field order and clobbers duplicate …\n"],["to_h","ENV","ENV.html#method-c-to_h","()","<p>Creates a hash with a copy of the environment variables.\n"],["to_h","Enumerable","Enumerable.html#method-i-to_h","(*args)","<p>Returns the result of interpreting <em>enum</em> as a list of <code>[key, value]</code> pairs.\n\n<pre class=\"ruby\"><span class=\"ruby-node\">%i[hello world]</span>.<span class=\"ruby-identifier\">each_with_index</span>.<span class=\"ruby-identifier\">to_h</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_h","Hash","Hash.html#method-i-to_h","()","<p>Returns <code>self</code>. If called on a subclass of Hash, converts the receiver to a Hash object.\n<p>If a block is given, …\n"],["to_h","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-to_h","()","<p>Returns the configuration instance variables as a hash, that can be passed to the configure method.\n"],["to_h","NilClass","NilClass.html#method-i-to_h","()","<p>Always returns an empty hash.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">nil</span>.<span class=\"ruby-identifier\">to_h</span>   <span class=\"ruby-comment\">#=&gt; {}</span>\n</pre>\n"],["to_h","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-to_h","()",""],["to_h","OpenStruct","OpenStruct.html#method-i-to_h","(&block)","<p>Converts the OpenStruct to a hash with keys representing each attribute (as symbols) and their corresponding …\n"],["to_h","Struct","Struct.html#method-i-to_h","()","<p>Returns a Hash containing the names and values for the struct&#39;s members.\n<p>If a block is given, the …\n"],["to_h","WIN32OLE_RECORD","WIN32OLE_RECORD.html#method-i-to_h","()","<p>Returns Ruby Hash object which represents VT_RECORD variable. The keys of Hash object are member names …\n"],["to_hash","Bundler::SpecSet","Bundler/SpecSet.html#method-i-to_hash","()",""],["to_hash","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-to_hash","()",""],["to_hash","CSV::Row","CSV/Row.html#method-i-to_hash","()",""],["to_hash","DBM","DBM.html#method-i-to_hash","()","<p>Converts the contents of the database to an in-memory Hash object, and returns it.\n"],["to_hash","ENV","ENV.html#method-c-to_hash","()","<p>Creates a hash with a copy of the environment variables.\n"],["to_hash","GDBM","GDBM.html#method-i-to_hash","()","<p>Returns a hash of all key-value pairs contained in the database.\n"],["to_hash","Hash","Hash.html#method-i-to_hash","()","<p>Returns <code>self</code>.\n"],["to_hash","JSON::Ext::Generator::State","JSON/Ext/Generator/State.html#method-i-to_hash","()",""],["to_hash","JSON::GenericObject","JSON/GenericObject.html#method-i-to_hash","()",""],["to_hash","Net::HTTPHeader","Net/HTTPHeader.html#method-i-to_hash","()","<p>Returns a Hash consisting of header names and array of values. e.g. {“cache-control” =&gt; …\n"],["to_hash","SDBM","SDBM.html#method-i-to_hash","()","<p>Returns a new Hash containing each key-value pair in the database.\n"],["to_hash","YAML::DBM","YAML/DBM.html#method-i-to_hash","()","<p>Converts the contents of the database to an in-memory Hash object, and returns it.\n"],["to_html","RDoc::Text","RDoc/Text.html#method-i-to_html","(text)","<p>Converts ampersand, dashes, ellipsis, quotes, copyright and registered trademark symbols in <code>text</code> to properly …\n"],["to_html","RDoc::TokenStream","RDoc/TokenStream.html#method-c-to_html","(token_stream)","<p>Converts <code>token_stream</code> to HTML wrapping various tokens with <code>&lt;span&gt;</code> elements. Some tokens types are …\n"],["to_i","ARGF","ARGF.html#method-i-to_i","()","<p>Returns an integer representing the numeric file descriptor for the current file. Raises an <code>ArgumentError</code> …\n"],["to_i","BigDecimal","BigDecimal.html#method-i-to_i","()","<p>Returns the value as an Integer.\n<p>If the BigDecimal is infinity or NaN, raises FloatDomainError.\n"],["to_i","CSV","CSV.html#method-i-to_i","()",""],["to_i","Complex","Complex.html#method-i-to_i","()","<p>Returns the value as an integer if possible (the imaginary part should be exactly zero).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">0</span>).<span class=\"ruby-identifier\">to_i</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_i","Fiddle::Closure","Fiddle/Closure.html#method-i-to_i","()","<p>Returns the memory address for this closure\n"],["to_i","Fiddle::Function","Fiddle/Function.html#method-i-to_i","()","<p>The integer memory location of this function\n"],["to_i","Fiddle::Handle","Fiddle/Handle.html#method-i-to_i","()","<p>Returns the memory address for this handle.\n"],["to_i","Fiddle::Pointer","Fiddle/Pointer.html#method-i-to_i","()","<p>Returns the integer memory location of this pointer.\n"],["to_i","Float","Float.html#method-i-to_i","()","<p>Returns the <code>float</code> truncated to an Integer.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1.2</span>.<span class=\"ruby-identifier\">to_i</span>      <span class=\"ruby-comment\">#=&gt; 1</span>\n(<span class=\"ruby-value\">-1.2</span>).<span class=\"ruby-identifier\">to_i</span>   <span class=\"ruby-comment\">#=&gt; -1</span>\n</pre>\n<p>Note that the limited …\n"],["to_i","IO","IO.html#method-i-to_i","()",""],["to_i","IPAddr","IPAddr.html#method-i-to_i","()","<p>Returns the integer representation of the ipaddr.\n"],["to_i","Integer","Integer.html#method-i-to_i","()","<p>Since <code>int</code> is already an Integer, returns <code>self</code>.\n<p>#to_int is an alias for #to_i.\n"],["to_i","NilClass","NilClass.html#method-i-to_i","()","<p>Always returns zero.\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">nil</span>.<span class=\"ruby-identifier\">to_i</span>   <span class=\"ruby-comment\">#=&gt; 0</span>\n</pre>\n"],["to_i","OpenSSL::BN","OpenSSL/BN.html#method-i-to_i","()",""],["to_i","Process::Status","Process/Status.html#method-i-to_i","()","<p>Returns the bits in <em>stat</em> as a Integer. Poking around in these bits is platform dependent.\n\n<pre>fork { exit ...</pre>\n"],["to_i","Rational","Rational.html#method-i-to_i","()","<p>Returns the truncated value as an integer.\n<p>Equivalent to Rational#truncate.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">to_i</span>    <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["to_i","String","String.html#method-i-to_i","(*args)","<p>Returns the result of interpreting leading characters in <em>str</em> as an integer base <em>base</em> (between 2 and 36). …\n"],["to_i","Time","Time.html#method-i-to_i","()","<p>Returns the value of <em>time</em> as an integer number of seconds since the Epoch.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>\n<span class=\"ruby-string\">&quot;%10.5f&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">to_f</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_i","WEBrick::HTTPStatus::Status","WEBrick/HTTPStatus/Status.html#method-i-to_i","()",""],["to_id","DRb","DRb.html#method-c-to_id","(obj)","<p>Get a reference id for an object using the current server.\n<p>This raises a DRbServerNotFound error if there …\n"],["to_id","DRb","DRb.html#method-i-to_id","(obj)","<p>Get a reference id for an object using the current server.\n<p>This raises a DRbServerNotFound error if there …\n"],["to_id","DRb::DRbIdConv","DRb/DRbIdConv.html#method-i-to_id","(obj)","<p>Convert an object into a reference id.\n<p>This implementation returns the object&#39;s __id__ in the local …\n"],["to_id","DRb::DRbIdConv","DRb/DRbIdConv.html#method-i-to_id","(obj)","<p>Convert an object into a reference id.\n<p>This implementation returns the object&#39;s __id__ in the local …\n"],["to_id","DRb::DRbServer","DRb/DRbServer.html#method-i-to_id","(obj)","<p>Convert a local object to a dRuby reference.\n"],["to_int","BigDecimal","BigDecimal.html#method-i-to_int","()","<p>Returns the value as an Integer.\n<p>If the BigDecimal is infinity or NaN, raises FloatDomainError.\n"],["to_int","Fiddle::Pointer","Fiddle/Pointer.html#method-i-to_int","()","<p>Returns the integer memory location of this pointer.\n"],["to_int","Float","Float.html#method-i-to_int","()","<p>Returns the <code>float</code> truncated to an Integer.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1.2</span>.<span class=\"ruby-identifier\">to_i</span>      <span class=\"ruby-comment\">#=&gt; 1</span>\n(<span class=\"ruby-value\">-1.2</span>).<span class=\"ruby-identifier\">to_i</span>   <span class=\"ruby-comment\">#=&gt; -1</span>\n</pre>\n<p>Note that the limited …\n"],["to_int","Integer","Integer.html#method-i-to_int","()","<p>Since <code>int</code> is already an Integer, returns <code>self</code>.\n<p>#to_int is an alias for #to_i.\n"],["to_int","Numeric","Numeric.html#method-i-to_int","()","<p>Invokes the child class&#39;s <code>to_i</code> method to convert <code>num</code> to an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1.0</span>.<span class=\"ruby-identifier\">class</span>          <span class=\"ruby-comment\">#=&gt; Float</span>\n<span class=\"ruby-value\">1.0</span>.<span class=\"ruby-identifier\">to_int</span>.<span class=\"ruby-identifier\">class</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_int","OpenSSL::BN","OpenSSL/BN.html#method-i-to_int","()",""],["to_io","ARGF","ARGF.html#method-i-to_io","()","<p>Returns an <code>IO</code> object representing the current file. This will be a <code>File</code> object unless the current file …\n"],["to_io","CSV","CSV.html#method-i-to_io","()",""],["to_io","IO","IO.html#method-i-to_io","()","<p>Returns <em>ios</em>.\n"],["to_io","OpenSSL::SSL::SSLServer","OpenSSL/SSL/SSLServer.html#method-i-to_io","()","<p>Returns the TCPServer passed to the SSLServer when initialized.\n"],["to_io","Zlib::GzipFile","Zlib/GzipFile.html#method-i-to_io","()","<p>Same as IO.\n"],["to_json","BigDecimal","BigDecimal.html#method-i-to_json","(*args)","<p>return the JSON value\n"],["to_json","Complex","Complex.html#method-i-to_json","(*args)","<p>Stores class name (Complex) along with real value <code>r</code> and imaginary value <code>i</code> as JSON string\n"],["to_json","Date","Date.html#method-i-to_json","(*args)","<p>Stores class name (Date) with Julian year <code>y</code>, month <code>m</code>, day <code>d</code> and Day of Calendar Reform <code>sg</code> as JSON string …\n"],["to_json","DateTime","DateTime.html#method-i-to_json","(*args)","<p>Stores class name (DateTime) with Julian year <code>y</code>, month <code>m</code>, day <code>d</code>, hour <code>H</code>, minute <code>M</code>, second <code>S</code>, offset  …\n"],["to_json","Exception","Exception.html#method-i-to_json","(*args)","<p>Stores class name (Exception) with message <code>m</code> and backtrace array <code>b</code> as JSON string\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::Array","JSON/Ext/Generator/GeneratorMethods/Array.html#method-i-to_json","(*args)","<p>Returns a JSON string containing a JSON array, that is generated from this Array instance. <em>state</em> is a …\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::Bignum","JSON/Ext/Generator/GeneratorMethods/Bignum.html#method-i-to_json","(*args)","<p>Returns a JSON string representation for this Integer number.\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::FalseClass","JSON/Ext/Generator/GeneratorMethods/FalseClass.html#method-i-to_json","(*args)","<p>Returns a JSON string for false: &#39;false&#39;.\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::Fixnum","JSON/Ext/Generator/GeneratorMethods/Fixnum.html#method-i-to_json","(*args)","<p>Returns a JSON string representation for this Integer number.\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::Float","JSON/Ext/Generator/GeneratorMethods/Float.html#method-i-to_json","(*args)","<p>Returns a JSON string representation for this Float number.\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::Hash","JSON/Ext/Generator/GeneratorMethods/Hash.html#method-i-to_json","(*args)","<p>Returns a JSON string containing a JSON object, that is generated from this Hash instance. <em>state</em> is a …\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::Integer","JSON/Ext/Generator/GeneratorMethods/Integer.html#method-i-to_json","(*args)","<p>Returns a JSON string representation for this Integer number.\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::NilClass","JSON/Ext/Generator/GeneratorMethods/NilClass.html#method-i-to_json","(*args)","<p>Returns a JSON string for nil: &#39;null&#39;.\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::Object","JSON/Ext/Generator/GeneratorMethods/Object.html#method-i-to_json","(p1 = v1)","<p>Converts this object to a string (calling #to_s), converts it to a JSON string, and returns the result. …\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::String","JSON/Ext/Generator/GeneratorMethods/String.html#method-i-to_json","(*args)","<p>This string should be encoded with UTF-8 A call to this method returns a JSON string encoded with UTF16 …\n"],["to_json","JSON::Ext::Generator::GeneratorMethods::TrueClass","JSON/Ext/Generator/GeneratorMethods/TrueClass.html#method-i-to_json","(*args)","<p>Returns a JSON string for true: &#39;true&#39;.\n"],["to_json","JSON::GenericObject","JSON/GenericObject.html#method-i-to_json","(*a)",""],["to_json","OpenStruct","OpenStruct.html#method-i-to_json","(*args)","<p>Stores class name (OpenStruct) with this struct&#39;s values <code>t</code> as a JSON string.\n"],["to_json","Psych","Psych.html#method-c-to_json","(object)","<p>Dump Ruby <code>object</code> to a JSON string.\n"],["to_json","Range","Range.html#method-i-to_json","(*args)","<p>Stores class name (Range) with JSON array of arguments <code>a</code> which include <code>first</code> (integer), <code>last</code> (integer), …\n"],["to_json","Rational","Rational.html#method-i-to_json","(*args)","<p>Stores class name (Rational) along with numerator value <code>n</code> and denominator value <code>d</code> as JSON string\n"],["to_json","Regexp","Regexp.html#method-i-to_json","(*args)","<p>Stores class name (Regexp) with options <code>o</code> and source <code>s</code> (Regexp or String) as JSON string\n"],["to_json","Set","Set.html#method-i-to_json","(*args)","<p>return the JSON value\n"],["to_json","Struct","Struct.html#method-i-to_json","(*args)","<p>Stores class name (Struct) with Struct values <code>v</code> as a JSON string. Only named structs are supported.\n"],["to_json","Symbol","Symbol.html#method-i-to_json","(*a)","<p>Stores class name (Symbol) with String representation of Symbol as a JSON string.\n"],["to_json","Time","Time.html#method-i-to_json","(*args)","<p>Stores class name (Time) with number of seconds since epoch and number of microseconds for Time as JSON …\n"],["to_json_raw","JSON::Ext::Generator::GeneratorMethods::String","JSON/Ext/Generator/GeneratorMethods/String.html#method-i-to_json_raw","(*args)","<p>This method creates a JSON text from the result of a call to to_json_raw_object of this String.\n"],["to_json_raw_object","JSON::Ext::Generator::GeneratorMethods::String","JSON/Ext/Generator/GeneratorMethods/String.html#method-i-to_json_raw_object","()","<p>This method creates a raw object hash, that can be nested into other data structures and will be generated …\n"],["to_lock","Bundler::Definition","Bundler/Definition.html#method-i-to_lock","()",""],["to_lock","Bundler::Dependency","Bundler/Dependency.html#method-i-to_lock","()",""],["to_lock","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-to_lock","()",""],["to_lock","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-to_lock","()","<p>Generates the content to be entered into the lockfile. Saves type and remote and also calls to `options_to_lock`. …\n"],["to_lock","Bundler::Source::Git","Bundler/Source/Git.html#method-i-to_lock","()",""],["to_lock","Bundler::Source::Path","Bundler/Source/Path.html#method-i-to_lock","()",""],["to_lock","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-to_lock","()",""],["to_lock","Gem::Dependency","Gem/Dependency.html#method-i-to_lock","()",""],["to_mailtext","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-to_mailtext","()","<p>Returns the RFC822 e-mail text equivalent of the URL, as a String.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;bundler/vendor/uri/lib/uri&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_mailtext","URI::MailTo","URI/MailTo.html#method-i-to_mailtext","()","<p>Returns the RFC822 e-mail text equivalent of the URL, as a String.\n<p>Example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;uri&#39;</span>\n\n<span class=\"ruby-identifier\">uri</span> = <span class=\"ruby-constant\">URI</span>.<span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-string\">&quot;mailto:ruby-list@ruby-lang.org?Subject=subscribe&amp;cc=myaddr&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_matrix","Matrix","Matrix.html#method-i-to_matrix","()","<p>Explicit conversion to a Matrix. Returns self\n"],["to_matrix","Vector","Vector.html#method-i-to_matrix","()","<p>Return a single-column matrix from this vector\n"],["to_name","Resolv::IPv4","Resolv/IPv4.html#method-i-to_name","()","<p>Turns this IPv4 address into a Resolv::DNS::Name.\n"],["to_name","Resolv::IPv6","Resolv/IPv6.html#method-i-to_name","()","<p>Turns this IPv6 address into a Resolv::DNS::Name.\n"],["to_obj","DRb","DRb.html#method-c-to_obj","(ref)","<p>Convert a reference into an object using the current server.\n<p>This raises a DRbServerNotFound error if …\n"],["to_obj","DRb","DRb.html#method-i-to_obj","(ref)","<p>Convert a reference into an object using the current server.\n<p>This raises a DRbServerNotFound error if …\n"],["to_obj","DRb::DRbIdConv","DRb/DRbIdConv.html#method-i-to_obj","(ref)","<p>Convert an object reference id to an object.\n<p>This implementation looks up the reference id in the local …\n"],["to_obj","DRb::DRbIdConv","DRb/DRbIdConv.html#method-i-to_obj","(ref)","<p>Convert an object reference id to an object.\n<p>This implementation looks up the reference id in the local …\n"],["to_obj","DRb::DRbServer","DRb/DRbServer.html#method-i-to_obj","(ref)","<p>Convert a dRuby reference to the local object it refers to.\n"],["to_oct","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-to_oct","(n, pad_size)",""],["to_octet_string","OpenSSL::PKey::EC::Point","OpenSSL/PKey/EC/Point.html#method-i-to_octet_string","(p1)","<p>Returns the octet string representation of the elliptic curve point.\n<p><em>conversion_form</em> specifies how the …\n"],["to_path","Dir","Dir.html#method-i-to_path","()","<p>Returns the path parameter passed to <em>dir</em>&#39;s constructor.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">d</span> = <span class=\"ruby-constant\">Dir</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;..&quot;</span>)\n<span class=\"ruby-identifier\">d</span>.<span class=\"ruby-identifier\">path</span>   <span class=\"ruby-comment\">#=&gt; &quot;..&quot;</span>\n</pre>\n"],["to_path","File","File.html#method-i-to_path","()","<p>Returns the pathname used to create <em>file</em> as a string. Does not normalize the name.\n<p>The pathname may not …\n"],["to_path","Pathname","Pathname.html#method-i-to_path","()","<p>Return the path as a String.\n<p>to_path is implemented so Pathname objects are usable with File.open, etc. …\n"],["to_pem","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-to_pem","()","<p>Returns the PEM encoding of this SPKI.\n"],["to_pem","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-to_pem","()",""],["to_pem","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-to_pem","()",""],["to_pem","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-to_pem","(p1 = v1, p2 = v2)",""],["to_pem","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-to_pem","(p1 = v1, p2 = v2)",""],["to_pem","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-to_pem","()","<p>See the OpenSSL documentation for PEM_write_bio_ECPKParameters()\n"],["to_pem","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-to_pem","(p1 = v1, p2 = v2)",""],["to_pem","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-to_pem","()","<p>Returns a PEM encoded String that contains the Session object.\n"],["to_pem","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-to_pem","()",""],["to_pem","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-to_pem","()",""],["to_pem","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-to_pem","()",""],["to_proc","Enumerator::Yielder","Enumerator/Yielder.html#method-i-to_proc","()","<p>Returns a Proc object that takes an argument and yields it.\n<p>This method is implemented so that a Yielder …\n"],["to_proc","Hash","Hash.html#method-i-to_proc","()","<p>Returns a Proc which maps keys to values.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = {<span class=\"ruby-value\">a:</span><span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">b:</span><span class=\"ruby-value\">2</span>}\n<span class=\"ruby-identifier\">hp</span> = <span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">to_proc</span>\n<span class=\"ruby-identifier\">hp</span>.<span class=\"ruby-identifier\">call</span>(<span class=\"ruby-value\">:a</span>)          <span class=\"ruby-comment\">#=&gt; 1</span>\n<span class=\"ruby-identifier\">hp</span>.<span class=\"ruby-identifier\">call</span>(<span class=\"ruby-value\">:b</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_proc","Method","Method.html#method-i-to_proc","()","<p>Returns a Proc object corresponding to this method.\n"],["to_proc","Proc","Proc.html#method-i-to_proc","()","<p>Part of the protocol for converting objects to Proc objects. Instances of class Proc simply return themselves. …\n"],["to_proc","Symbol","Symbol.html#method-i-to_proc","()","<p>Returns a <em>Proc</em> object which responds to the given method by <em>sym</em>.\n\n<pre class=\"ruby\">(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">..</span><span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">collect</span>(<span class=\"ruby-operator\">&amp;</span><span class=\"ruby-value\">:to_s</span>)  <span class=\"ruby-comment\">#=&gt; [&quot;1&quot;, &quot;2&quot;, ...</span>\n</pre>\n"],["to_ptr","Fiddle::Pointer","Fiddle/Pointer.html#method-c-to_ptr","(p1)","<p>Get the underlying pointer for ruby object <code>val</code> and return it as a Fiddle::Pointer object.\n"],["to_r","BigDecimal","BigDecimal.html#method-i-to_r","()","<p>Converts a BigDecimal to a Rational.\n"],["to_r","Complex","Complex.html#method-i-to_r","()","<p>Returns the value as a rational if possible (the imaginary part should be exactly zero).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">0</span>).<span class=\"ruby-identifier\">to_r</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_r","Float","Float.html#method-i-to_r","()","<p>Returns the value as a rational.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">2.0</span>.<span class=\"ruby-identifier\">to_r</span>    <span class=\"ruby-comment\">#=&gt; (2/1)</span>\n<span class=\"ruby-value\">2.5</span>.<span class=\"ruby-identifier\">to_r</span>    <span class=\"ruby-comment\">#=&gt; (5/2)</span>\n<span class=\"ruby-value\">-0.75</span>.<span class=\"ruby-identifier\">to_r</span>  <span class=\"ruby-comment\">#=&gt; (-3/4)</span>\n<span class=\"ruby-value\">0.0</span>.<span class=\"ruby-identifier\">to_r</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_r","Integer","Integer.html#method-i-to_r","()","<p>Returns the value as a rational.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">1</span>.<span class=\"ruby-identifier\">to_r</span>        <span class=\"ruby-comment\">#=&gt; (1/1)</span>\n(<span class=\"ruby-value\">1</span><span class=\"ruby-operator\">&lt;&lt;</span><span class=\"ruby-value\">64</span>).<span class=\"ruby-identifier\">to_r</span>  <span class=\"ruby-comment\">#=&gt; (18446744073709551616/1)</span>\n</pre>\n"],["to_r","NilClass","NilClass.html#method-i-to_r","()","<p>Returns zero as a rational.\n"],["to_r","Rational","Rational.html#method-i-to_r","()","<p>Returns self.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">to_r</span>      <span class=\"ruby-comment\">#=&gt; (2/1)</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">-8</span>, <span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">to_r</span>  <span class=\"ruby-comment\">#=&gt; (-4/3)</span>\n</pre>\n"],["to_r","String","String.html#method-i-to_r","()","<p>Returns the result of interpreting leading characters in <code>str</code> as a rational.  Leading whitespace and extraneous …\n"],["to_r","Time","Time.html#method-i-to_r","()","<p>Returns the value of <em>time</em> as a rational number of seconds since the Epoch.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">to_r</span>        <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_range","IPAddr","IPAddr.html#method-i-to_range","()","<p>Creates a Range object for the network address.\n"],["to_request_set","Gem::AvailableSet","Gem/AvailableSet.html#method-i-to_request_set","(development = :none)","<p>Converts this AvailableSet into a RequestSet that can be used to install gems.\n<p>If <code>development</code> is :none …\n"],["to_rfc822text","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-to_rfc822text","()",""],["to_rfc822text","URI::MailTo","URI/MailTo.html#method-i-to_rfc822text","()",""],["to_rss","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-to_rss","(type, &block)",""],["to_ruby","Gem::Specification","Gem/Specification.html#method-i-to_ruby","()","<p>Returns a Ruby code representation of this specification, such that it can be eval&#39;ed and reconstruct …\n"],["to_ruby","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-to_ruby","()","<p>Convert this node to Ruby.\n<p>See also Psych::Visitors::ToRuby\n"],["to_ruby_for_cache","Gem::Specification","Gem/Specification.html#method-i-to_ruby_for_cache","()","<p>Returns a Ruby lighter-weight code representation of this specification, used for indexing only.\n<p>See  …\n"],["to_s","ARGF","ARGF.html#method-i-to_s","()","<p>Returns “ARGF”.\n"],["to_s","Addrinfo","Addrinfo.html#method-i-to_s","()","<p>returns the socket address as packed struct sockaddr string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">to_sockaddr</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_s","Array","Array.html#method-i-to_s","()",""],["to_s","Benchmark::Tms","Benchmark/Tms.html#method-i-to_s","()","<p>Same as #format.\n"],["to_s","BigDecimal","BigDecimal.html#method-i-to_s","(p1 = v1)","<p>Converts the value to a string.\n<p>The default format looks like  0.xxxxEnn.\n<p>The optional parameter s consists …\n"],["to_s","Bundler::DepProxy","Bundler/DepProxy.html#method-i-to_s","()",""],["to_s","Bundler::Dsl::DSLError","Bundler/Dsl/DSLError.html#method-i-to_s","()","<p>The message of the exception reports the content of podspec for the line that generated the original …\n"],["to_s","Bundler::LazySpecification","Bundler/LazySpecification.html#method-i-to_s","()",""],["to_s","Bundler::Molinillo::Resolver::Resolution::PossibilitySet","Bundler/Molinillo/Resolver/Resolution/PossibilitySet.html#method-i-to_s","()","<p>String representation of the possibility set, for debugging\n"],["to_s","Bundler::ParallelInstaller::SpecInstallation","Bundler/ParallelInstaller/SpecInstallation.html#method-i-to_s","()",""],["to_s","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-to_s","()",""],["to_s","Bundler::RemoteSpecification","Bundler/RemoteSpecification.html#method-i-to_s","()",""],["to_s","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-to_s","()",""],["to_s","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-to_s","(versions = self.versions)",""],["to_s","Bundler::Source::Git","Bundler/Source/Git.html#method-i-to_s","()",""],["to_s","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-to_s","()",""],["to_s","Bundler::Source::Path","Bundler/Source/Path.html#method-i-to_s","()",""],["to_s","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-to_s","()",""],["to_s","Bundler::Source::Rubygems::Remote","Bundler/Source/Rubygems/Remote.html#method-i-to_s","()",""],["to_s","Bundler::URI::FTP","Bundler/URI/FTP.html#method-i-to_s","()","<p>Returns a String representation of the Bundler::URI::FTP.\n"],["to_s","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-to_s","()","<p>Constructs String from Bundler::URI.\n"],["to_s","Bundler::URI::MailTo","Bundler/URI/MailTo.html#method-i-to_s","()","<p>Constructs String from Bundler::URI.\n"],["to_s","Bundler::VersionRanges::ReqR","Bundler/VersionRanges/ReqR.html#method-i-to_s","()",""],["to_s","CGI::Cookie","CGI/Cookie.html#method-i-to_s","()","<p>Convert the Cookie to its string representation.\n"],["to_s","CSV::Row","CSV/Row.html#method-i-to_s","(**options)",""],["to_s","CSV::Table","CSV/Table.html#method-i-to_s","(write_headers: true, **options)",""],["to_s","Complex","Complex.html#method-i-to_s","()","<p>Returns the value as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">to_s</span>                       <span class=\"ruby-comment\">#=&gt; &quot;2+0i&quot;</span>\n<span class=\"ruby-constant\">Complex</span>(<span class=\"ruby-string\">&#39;-8/6&#39;</span>).<span class=\"ruby-identifier\">to_s</span>  <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_s","Date","Date.html#method-i-to_s","()","<p>Returns a string in an ISO 8601 format. (This method doesn&#39;t use the expanded representations.)\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">to_s</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_s","DateTime","DateTime.html#method-i-to_s","()","<p>Returns a string in an ISO 8601 format. (This method doesn&#39;t use the expanded representations.)\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>,<span class=\"ruby-string\">&#39;-7&#39;</span>).<span class=\"ruby-identifier\">to_s</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_s","Digest::Instance","Digest/Instance.html#method-i-to_s","()","<p>Returns digest_obj.hexdigest().\n"],["to_s","ENV","ENV.html#method-c-to_s","()","<p>Returns “ENV”\n"],["to_s","Encoding","Encoding.html#method-i-to_s","()","<p>Returns the name of the encoding.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Encoding</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">UTF_8</span>.<span class=\"ruby-identifier\">name</span>      <span class=\"ruby-comment\">#=&gt; &quot;UTF-8&quot;</span>\n</pre>\n"],["to_s","Exception","Exception.html#method-i-to_s","()","<p>Returns exception&#39;s message (or the name of the exception if no message is set).\n"],["to_s","FalseClass","FalseClass.html#method-i-to_s","()","<p>The string representation of <code>false</code> is “false”.\n"],["to_s","Fiber","Fiber.html#method-i-to_s","()","<p>Returns fiber information string.\n"],["to_s","Fiddle::Pointer","Fiddle/Pointer.html#method-i-to_s","(p1 = v1)","<p>Returns the pointer contents as a string.\n<p>When called with no arguments, this method will return the contents …\n"],["to_s","Float","Float.html#method-i-to_s","()","<p>Returns a string containing a representation of <code>self</code>. As well as a fixed or exponential form of the  …\n"],["to_s","Gem::Platform","Gem/Platform.html#method-i-to_s","()",""],["to_s","Gem::RequestSet::Lockfile","Gem/RequestSet/Lockfile.html#method-i-to_s","()","<p>The contents of the lock file.\n"],["to_s","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-to_s","()",""],["to_s","Gem::Version","Gem/Version.html#method-i-to_s","()",""],["to_s","Hash","Hash.html#method-i-to_s","()",""],["to_s","IPAddr","IPAddr.html#method-i-to_s","()","<p>Returns a string containing the IP address representation.\n"],["to_s","Integer","Integer.html#method-i-to_s","(*args)","<p>Returns a string containing the place-value representation of <code>int</code> with radix <code>base</code> (between 2 and 36). …\n"],["to_s","MatchData","MatchData.html#method-i-to_s","()","<p>Returns the entire matched string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">m</span> = <span class=\"ruby-regexp\">/(.)(.)(\\d+)(\\d)/</span>.<span class=\"ruby-identifier\">match</span>(<span class=\"ruby-string\">&quot;THX1138.&quot;</span>)\n<span class=\"ruby-identifier\">m</span>.<span class=\"ruby-identifier\">to_s</span>   <span class=\"ruby-comment\">#=&gt; &quot;HX1138&quot;</span>\n</pre>\n"],["to_s","Matrix","Matrix.html#method-i-to_s","()","<p>Overrides Object#to_s\n"],["to_s","Method","Method.html#method-i-to_s","()","<p>Returns a human-readable description of the underlying method.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;cat&quot;</span>.<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:count</span>).<span class=\"ruby-identifier\">inspect</span>   <span class=\"ruby-comment\">#=&gt; &quot;#&lt;Method: ...</span>\n</pre>\n"],["to_s","Module","Module.html#method-i-to_s","()","<p>Returns a string representing this module or class. For basic classes and modules, this is the name. …\n"],["to_s","NilClass","NilClass.html#method-i-to_s","()","<p>Always returns the empty string.\n"],["to_s","Object","Object.html#method-i-to_s","()","<p>Returns a string representing <em>obj</em>. The default #to_s prints the object&#39;s class and an encoding of …\n"],["to_s","OpenSSL::BN","OpenSSL/BN.html#method-i-to_s","(p1 = v1)","<p>Parameters\n<p><em>base</em> - Integer Valid values:\n<p>0 - MPI\n"],["to_s","OpenSSL::Config","OpenSSL/Config.html#method-i-to_s","()","<p>Get the parsable form of the current configuration\n<p>Given the following configuration being created:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">config</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_s","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-to_s","()",""],["to_s","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-to_s","()",""],["to_s","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-to_s","()",""],["to_s","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-to_s","()",""],["to_s","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-to_s","(p1 = v1, p2 = v2)",""],["to_s","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-to_s","(p1 = v1, p2 = v2)",""],["to_s","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-to_s","()",""],["to_s","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-to_s","()",""],["to_s","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-to_s","()",""],["to_s","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-to_s","(*args)","<p>Returns a String representation of the Distinguished Name. <em>format</em> is one of:\n<p>OpenSSL::X509::Name::COMPAT …\n"],["to_s","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-to_s","()",""],["to_s","OpenStruct","OpenStruct.html#method-i-to_s","()",""],["to_s","OptionParser","OptionParser.html#method-i-to_s","()",""],["to_s","OptionParser::ParseError","OptionParser/ParseError.html#method-i-to_s","()",""],["to_s","Pathname","Pathname.html#method-i-to_s","()","<p>Return the path as a String.\n<p>to_path is implemented so Pathname objects are usable with File.open, etc. …\n"],["to_s","Proc","Proc.html#method-i-to_s","()","<p>Returns the unique identifier for this proc, along with an indication of where the proc was defined. …\n"],["to_s","Process::Status","Process/Status.html#method-i-to_s","()","<p>Show pid and exit status as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">system</span>(<span class=\"ruby-string\">&quot;false&quot;</span>)\n<span class=\"ruby-identifier\">p</span> <span class=\"ruby-identifier\">$?</span>.<span class=\"ruby-identifier\">to_s</span>         <span class=\"ruby-comment\">#=&gt; &quot;pid 12766 exit 1&quot;</span>\n</pre>\n"],["to_s","REXML::Attribute","REXML/Attribute.html#method-i-to_s","()","<p>Returns the attribute value, with entities replaced\n"],["to_s","REXML::CData","REXML/CData.html#method-i-to_s","()","<p>Returns the content of this CData object\n<p><em>Examples</em>\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">c</span> = <span class=\"ruby-constant\">CData</span>.<span class=\"ruby-identifier\">new</span>( <span class=\"ruby-string\">&quot;Some text&quot;</span> )\n<span class=\"ruby-identifier\">c</span>.<span class=\"ruby-identifier\">to_s</span>        <span class=\"ruby-comment\"># -&gt; &quot;Some ...</span>\n</pre>\n"],["to_s","REXML::DTD::EntityDecl","REXML/DTD/EntityDecl.html#method-i-to_s","()",""],["to_s","REXML::DTD::NotationDecl","REXML/DTD/NotationDecl.html#method-i-to_s","()",""],["to_s","REXML::Declaration","REXML/Declaration.html#method-i-to_s","()",""],["to_s","REXML::Entity","REXML/Entity.html#method-i-to_s","()","<p>Returns this entity as a string.  See write().\n"],["to_s","REXML::ExternalEntity","REXML/ExternalEntity.html#method-i-to_s","()",""],["to_s","REXML::Light::Node","REXML/Light/Node.html#method-i-to_s","()",""],["to_s","REXML::Node","REXML/Node.html#method-i-to_s","(indent=nil)","<p>indent &mdash; <strong>DEPRECATED</strong> This parameter is now ignored.  See the formatters in the REXML::Formatters package …\n\n"],["to_s","REXML::NotationDecl","REXML/NotationDecl.html#method-i-to_s","()",""],["to_s","REXML::Output","REXML/Output.html#method-i-to_s","()",""],["to_s","REXML::ParseException","REXML/ParseException.html#method-i-to_s","()",""],["to_s","REXML::Text","REXML/Text.html#method-i-to_s","()","<p>Returns the string value of this text node.  This string is always escaped, meaning that it is a valid …\n"],["to_s","REXML::Validation::Event","REXML/Validation/Event.html#method-i-to_s","()",""],["to_s","REXML::Validation::Ref","REXML/Validation/Ref.html#method-i-to_s","()",""],["to_s","REXML::Validation::State","REXML/Validation/State.html#method-i-to_s","()",""],["to_s","RSS::Element","RSS/Element.html#method-i-to_s","(need_convert=true, indent='')",""],["to_s","RSS::XML::Element","RSS/XML/Element.html#method-i-to_s","()",""],["to_s","RSS::XMLStyleSheet","RSS/XMLStyleSheet.html#method-i-to_s","()",""],["to_s","Racc::Grammar","Racc/Grammar.html#method-i-to_s","()",""],["to_s","Racc::ISet","Racc/ISet.html#method-i-to_s","()",""],["to_s","Racc::LocationPointer","Racc/LocationPointer.html#method-i-to_s","()",""],["to_s","Racc::RRconflict","Racc/RRconflict.html#method-i-to_s","()",""],["to_s","Racc::Rule","Racc/Rule.html#method-i-to_s","()",""],["to_s","Racc::SRconflict","Racc/SRconflict.html#method-i-to_s","()",""],["to_s","Racc::SourceText","Racc/SourceText.html#method-i-to_s","()",""],["to_s","Racc::State","Racc/State.html#method-i-to_s","()",""],["to_s","Racc::States","Racc/States.html#method-i-to_s","()",""],["to_s","Racc::Sym","Racc/Sym.html#method-i-to_s","()",""],["to_s","Range","Range.html#method-i-to_s","()","<p>Convert this range object to a printable form (using #to_s to convert the begin and end objects).\n"],["to_s","Rational","Rational.html#method-i-to_s","()","<p>Returns the value as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">2</span>).<span class=\"ruby-identifier\">to_s</span>      <span class=\"ruby-comment\">#=&gt; &quot;2/1&quot;</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-value\">-8</span>, <span class=\"ruby-value\">6</span>).<span class=\"ruby-identifier\">to_s</span>  <span class=\"ruby-comment\">#=&gt; &quot;-4/3&quot;</span>\n<span class=\"ruby-constant\">Rational</span>(<span class=\"ruby-string\">&#39;1/2&#39;</span>).<span class=\"ruby-identifier\">to_s</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_s","Regexp","Regexp.html#method-i-to_s","()","<p>Returns a string containing the regular expression and its options (using the <code>(?opts:source)</code> notation. …\n"],["to_s","Resolv::DNS::Name","Resolv/DNS/Name.html#method-i-to_s","()","<p>returns the domain name as a string.\n<p>The domain name doesn&#39;t have a trailing dot even if the name …\n"],["to_s","Set","Set.html#method-i-to_s","()",""],["to_s","Socket::Option","Socket/Option.html#method-i-to_s","()","<p>returns the socket option data as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:RECVPKTINFO</span>, [<span class=\"ruby-value\">1</span>].<span class=\"ruby-identifier\">pack</span>(<span class=\"ruby-string\">&quot;i!&quot;</span>)).<span class=\"ruby-identifier\">data</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_s","String","String.html#method-i-to_s","()","<p>Returns <code>self</code>.\n<p>If called on a subclass of String, converts the receiver to a String object.\n"],["to_s","Struct","Struct.html#method-i-to_s","()",""],["to_s","Symbol","Symbol.html#method-i-to_s","()","<p>Returns the name or string corresponding to <em>sym</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">:fred</span>.<span class=\"ruby-identifier\">id2name</span>   <span class=\"ruby-comment\">#=&gt; &quot;fred&quot;</span>\n<span class=\"ruby-value\">:ginger</span>.<span class=\"ruby-identifier\">to_s</span>    <span class=\"ruby-comment\">#=&gt; &quot;ginger&quot;</span>\n</pre>\n"],["to_s","Thread","Thread.html#method-i-to_s","()","<p>Dump the name, id, and status of <em>thr</em> to a string.\n"],["to_s","Thread::Backtrace::Location","Thread/Backtrace/Location.html#method-i-to_s","()","<p>Returns a Kernel#caller style string representing this frame.\n"],["to_s","Time","Time.html#method-i-to_s","()","<p>Returns a string representing <em>time</em>. Equivalent to calling #strftime with the appropriate format string. …\n"],["to_s","TrueClass","TrueClass.html#method-i-to_s","()","<p>The string representation of <code>true</code> is “true”.\n"],["to_s","URI::FTP","URI/FTP.html#method-i-to_s","()","<p>Returns a String representation of the URI::FTP.\n"],["to_s","URI::Generic","URI/Generic.html#method-i-to_s","()","<p>Constructs String from URI.\n"],["to_s","URI::MailTo","URI/MailTo.html#method-i-to_s","()","<p>Constructs String from URI.\n"],["to_s","UnboundMethod","UnboundMethod.html#method-i-to_s","()","<p>Returns a human-readable description of the underlying method.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;cat&quot;</span>.<span class=\"ruby-identifier\">method</span>(<span class=\"ruby-value\">:count</span>).<span class=\"ruby-identifier\">inspect</span>   <span class=\"ruby-comment\">#=&gt; &quot;#&lt;Method: ...</span>\n</pre>\n"],["to_s","UncaughtThrowError","UncaughtThrowError.html#method-i-to_s","()","<p>Returns formatted message with the inspected tag.\n"],["to_s","Vector","Vector.html#method-i-to_s","()","<p>Overrides Object#to_s\n"],["to_s","WEBrick::Cookie","WEBrick/Cookie.html#method-i-to_s","()","<p>The cookie string suitable for use in an HTTP header\n"],["to_s","WEBrick::HTTPUtils::FormData","WEBrick/HTTPUtils/FormData.html#method-i-to_s","()","<p>This FormData&#39;s body\n"],["to_s","WEBrick::HTTPVersion","WEBrick/HTTPVersion.html#method-i-to_s","()","<p>The HTTP version as show in the HTTP request and response.  For example, “1.1”\n"],["to_s","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-to_s","()",""],["to_s","WIN32OLE_PARAM","WIN32OLE_PARAM.html#method-i-to_s","()",""],["to_s","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-to_s","()",""],["to_s","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-to_s","()",""],["to_s","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-to_s","()",""],["to_set","Enumerable","Enumerable.html#method-i-to_set","(klass = Set, *args, &block)","<p>Makes a set from the enumerable object with given arguments. Needs to +require “set”+ to use …\n"],["to_set","Set","Set.html#method-i-to_set","(klass = Set, *args, &block)","<p>Returns self if no arguments are given.  Otherwise, converts the set to another with klass.new(self, …\n"],["to_sockaddr","Addrinfo","Addrinfo.html#method-i-to_sockaddr","()","<p>returns the socket address as packed struct sockaddr string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">to_sockaddr</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_socket_address","Bundler::SocketAddress","Bundler/SocketAddress.html#method-i-to_socket_address","()",""],["to_spec","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-to_spec","()","<p>Return a Gem::Specification from this gem\n"],["to_spec","Gem::Dependency","Gem/Dependency.html#method-i-to_spec","()",""],["to_spec","Gem::Specification","Gem/Specification.html#method-i-to_spec","()","<p>Returns self\n"],["to_specs","Bundler::Resolver::SpecGroup","Bundler/Resolver/SpecGroup.html#method-i-to_specs","()",""],["to_specs","Gem::Dependency","Gem/Dependency.html#method-i-to_specs","()",""],["to_str","Fiddle::Pointer","Fiddle/Pointer.html#method-i-to_str","(p1 = v1)","<p>Returns the pointer contents as a string.\n<p>When called with no arguments, this method will return the contents …\n"],["to_str","String","String.html#method-i-to_str","()","<p>Returns <code>self</code>.\n<p>If called on a subclass of String, converts the receiver to a String object.\n"],["to_string","IPAddr","IPAddr.html#method-i-to_string","()","<p>Returns a string containing the IP address representation in canonical form.\n"],["to_string","REXML::Attribute","REXML/Attribute.html#method-i-to_string","()","<p>Returns this attribute out as XML source, expanding the name\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = <span class=\"ruby-constant\">Attribute</span>.<span class=\"ruby-identifier\">new</span>( <span class=\"ruby-string\">&quot;x&quot;</span>, <span class=\"ruby-string\">&quot;y&quot;</span> )\n<span class=\"ruby-identifier\">a</span>.<span class=\"ruby-identifier\">to_string</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["to_sym","String","String.html#method-i-to_sym","()","<p>Returns the Symbol corresponding to <em>str</em>, creating the symbol if it did not previously exist. See Symbol#id2name …\n"],["to_sym","Symbol","Symbol.html#method-i-to_sym","()","<p>In general, <code>to_sym</code> returns the Symbol corresponding to an object. As <em>sym</em> is already a symbol, <code>self</code> is …\n"],["to_text","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-to_text","()","<p>Returns a textual representation of this SPKI, useful for debugging purposes.\n"],["to_text","OpenSSL::PKey::DH","OpenSSL/PKey/DH.html#method-i-to_text","()","<p>Prints all parameters of key to buffer INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don&#39;t use :-)) …\n"],["to_text","OpenSSL::PKey::DSA","OpenSSL/PKey/DSA.html#method-i-to_text","()","<p>Prints all parameters of key to buffer INSECURE: PRIVATE INFORMATIONS CAN LEAK OUT!!! Don&#39;t use :-)) …\n"],["to_text","OpenSSL::PKey::EC","OpenSSL/PKey/EC.html#method-i-to_text","()","<p>See the OpenSSL documentation for EC_KEY_print()\n"],["to_text","OpenSSL::PKey::EC::Group","OpenSSL/PKey/EC/Group.html#method-i-to_text","()","<p>See the OpenSSL documentation for ECPKParameters_print()\n"],["to_text","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-to_text","()","<p>THIS METHOD IS INSECURE, PRIVATE INFORMATION CAN LEAK OUT!!!\n<p>Dumps all parameters of a keypair to a String …\n"],["to_text","OpenSSL::SSL::Session","OpenSSL/SSL/Session.html#method-i-to_text","()","<p>Shows everything in the Session object. This is for diagnostic purposes.\n"],["to_text","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-to_text","()",""],["to_text","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-to_text","()",""],["to_text","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-to_text","()",""],["to_time","Date","Date.html#method-i-to_time","()","<p>Returns a Time object which denotes self. If self is a julian date, convert it to a gregorian date before …\n"],["to_time","DateTime","DateTime.html#method-i-to_time","()","<p>Returns a Time object which denotes self.\n"],["to_time","Time","Time.html#method-i-to_time","()","<p>Returns self.\n"],["to_tty?","Exception","Exception.html#method-c-to_tty-3F","()","<p>Returns <code>true</code> if exception messages will be sent to a tty.\n"],["to_uri","RSS::Parser","RSS/Parser.html#method-i-to_uri","(rss)","<p>Attempt to convert rss to a URI, but just return it if there&#39;s a ::URI::Error\n"],["to_utf8","OpenSSL::X509::Name","OpenSSL/X509/Name.html#method-i-to_utf8","()","<p>Returns an UTF-8 representation of the distinguished name, as specified in RFC 2253.\n"],["to_value","Fiddle::Pointer","Fiddle/Pointer.html#method-i-to_value","()","<p>Cast this pointer to a ruby object.\n"],["to_write_io","ARGF","ARGF.html#method-i-to_write_io","()","<p>Returns IO instance tied to <em>ARGF</em> for writing if inplace mode is enabled.\n"],["to_xml","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-to_xml","(type=nil, &block)",""],["to_yaml","Bundler::StubSpecification","Bundler/StubSpecification.html#method-i-to_yaml","()",""],["to_yaml","Object","Object.html#method-i-to_yaml","(options = {})","<p>Convert an object to YAML.  See Psych.dump for more information on the available <code>options</code>.\n"],["to_yaml","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-to_yaml","(io = nil, options = {})",""],["to_yaml_properties","Gem::Dependency","Gem/Dependency.html#method-i-to_yaml_properties","()",""],["today","Date","Date.html#method-c-today","(p1 = v1)","<p>Creates a date object denoting the present day.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">today</span>   <span class=\"ruby-comment\">#=&gt; #&lt;Date: 2011-06-11 ...&gt;</span>\n</pre>\n"],["toeuc","Kconv","Kconv.html#method-i-toeuc","(str)","<p>Convert <code>str</code> to EUC-JP\n"],["toeuc","Kconv","Kconv.html#method-c-toeuc","(str)","<p>Convert <code>str</code> to EUC-JP\n"],["toeuc","String","String.html#method-i-toeuc","()","<p>Convert <code>self</code> to EUC-JP\n"],["tojis","Kconv","Kconv.html#method-c-tojis","(str)","<p>Convert <code>str</code> to ISO-2022-JP\n"],["tojis","Kconv","Kconv.html#method-i-tojis","(str)","<p>Convert <code>str</code> to ISO-2022-JP\n"],["tojis","String","String.html#method-i-tojis","()","<p>Convert <code>self</code> to ISO-2022-JP\n"],["token","Ripper","Ripper.html#method-i-token","()","<p>Return the current token string.\n"],["token_listener","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-token_listener","(obj)","<p>Has <code>obj</code> listen to tokens\n"],["token_stream","RDoc::TokenStream","RDoc/TokenStream.html#method-i-token_stream","()","<p>Current token stream\n"],["token_table","Racc::StateTransitionTableGenerator","Racc/StateTransitionTableGenerator.html#method-i-token_table","(grammar)",""],["token_to_str","Racc::Parser","Racc/Parser.html#method-i-token_to_str","(t)","<p>Convert internal ID of token symbol to the string.\n"],["token_value_table","Racc::StateTransitionTable","Racc/StateTransitionTable.html#method-i-token_value_table","()",""],["tokenize","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-tokenize","(input)",""],["tokenize","Psych::ScalarScanner","Psych/ScalarScanner.html#method-i-tokenize","(string)","<p>Tokenize <code>string</code> returning the Ruby object\n"],["tokenize","RDoc::TomDoc","RDoc/TomDoc.html#method-i-tokenize","(text)","<p>Turns text into an Array of tokens\n<p>text &mdash; A String containing TomDoc-format text.\n\n<p>Returns\n"],["tokenize","Ripper","Ripper.html#method-c-tokenize","(src, filename = '-', lineno = 1)","<p>Tokenizes the Ruby program and returns an array of strings.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Ripper</span>.<span class=\"ruby-identifier\">tokenize</span>(<span class=\"ruby-string\">&quot;def m(a) nil end&quot;</span>)\n   <span class=\"ruby-comment\"># ...</span>\n</pre>\n"],["tokens_to_s","RDoc::TokenStream","RDoc/TokenStream.html#method-i-tokens_to_s","()","<p>Returns a string representation of the token stream\n"],["tolocale","Kconv","Kconv.html#method-i-tolocale","(str)","<p>Convert <code>self</code> to locale encoding\n"],["tolocale","Kconv","Kconv.html#method-c-tolocale","(str)","<p>Convert <code>self</code> to locale encoding\n"],["tolocale","String","String.html#method-i-tolocale","()","<p>Convert <code>self</code> to locale encoding\n"],["tomdoc?","RDoc::Comment","RDoc/Comment.html#method-i-tomdoc-3F","()","<p>Returns true if this comment is in TomDoc format.\n"],["top","IRB::Frame","IRB/Frame.html#method-i-top","(n = 0)","<p>Returns the <code>n</code> number of frames on the call stack from the last frame initialized.\n<p>Raises FrameUnderflow …\n"],["top","IRB::Frame","IRB/Frame.html#method-c-top","(n = 0)","<p>Convenience method for Frame#top\n"],["top","Net::POPMail","Net/POPMail.html#method-i-top","(lines, dest = +'')","<p>Fetches the message header and <code>lines</code> lines of body.\n<p>The optional <code>dest</code> argument is obsolete.\n<p>This method …\n"],["top","OptionParser","OptionParser.html#method-i-top","()","<p>Subject of #on / #on_head, #accept / #reject\n"],["top","OptionParser","OptionParser.html#method-c-top","()",""],["top_level","RDoc::Context","RDoc/Context.html#method-i-top_level","()","<p>Return the TopLevel that owns us\n"],["top_level","RDoc::Require","RDoc/Require.html#method-i-top_level","()","<p>The RDoc::TopLevel corresponding to this require, or <code>nil</code> if not found.\n"],["toplevel?","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-toplevel-3F","()",""],["toplevel_load","IRB::Locale","IRB/Locale.html#method-i-toplevel_load","(file, priv=nil)",""],["tosjis","Kconv","Kconv.html#method-c-tosjis","(str)","<p>Convert <code>str</code> to Shift_JIS\n"],["tosjis","Kconv","Kconv.html#method-i-tosjis","(str)","<p>Convert <code>str</code> to Shift_JIS\n"],["tosjis","String","String.html#method-i-tosjis","()","<p>Convert <code>self</code> to Shift_JIS\n"],["total_in","Zlib::ZStream","Zlib/ZStream.html#method-i-total_in","()","<p>Returns the total bytes of the input data to the stream.  FIXME\n"],["total_out","Zlib::ZStream","Zlib/ZStream.html#method-i-total_out","()","<p>Returns the total bytes of the output data from the stream.  FIXME\n"],["total_time","GC::Profiler","GC/Profiler.html#method-c-total_time","()","<p>The total time used for garbage collection in seconds\n"],["touch","Bundler::FileUtils","Bundler/FileUtils.html#method-c-touch","(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)","<p>Updates modification time (mtime) and access time (atime) of file(s) in <code>list</code>.  Files are created if they …\n"],["touch","Bundler::FileUtils","Bundler/FileUtils.html#method-i-touch","(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)","<p>Updates modification time (mtime) and access time (atime) of file(s) in <code>list</code>.  Files are created if they …\n"],["touch","FileUtils","FileUtils.html#method-c-touch","(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)","<p>Updates modification time (mtime) and access time (atime) of file(s) in <code>list</code>.  Files are created if they …\n"],["touch","FileUtils","FileUtils.html#method-i-touch","(list, noop: nil, verbose: nil, mtime: nil, nocreate: nil)","<p>Updates modification time (mtime) and access time (atime) of file(s) in <code>list</code>.  Files are created if they …\n"],["toutf16","Kconv","Kconv.html#method-i-toutf16","(str)","<p>Convert <code>str</code> to UTF-16\n"],["toutf16","Kconv","Kconv.html#method-c-toutf16","(str)","<p>Convert <code>str</code> to UTF-16\n"],["toutf16","String","String.html#method-i-toutf16","()","<p>Convert <code>self</code> to UTF-16\n"],["toutf32","Kconv","Kconv.html#method-i-toutf32","(str)","<p>Convert <code>str</code> to UTF-32\n"],["toutf32","Kconv","Kconv.html#method-c-toutf32","(str)","<p>Convert <code>str</code> to UTF-32\n"],["toutf32","String","String.html#method-i-toutf32","()","<p>Convert <code>self</code> to UTF-32\n"],["toutf8","Kconv","Kconv.html#method-i-toutf8","(str)","<p>Convert <code>str</code> to UTF-8\n"],["toutf8","Kconv","Kconv.html#method-c-toutf8","(str)","<p>Convert <code>str</code> to UTF-8\n"],["toutf8","String","String.html#method-i-toutf8","()","<p>Convert <code>self</code> to UTF-8\n"],["tr","Matrix","Matrix.html#method-i-tr","()",""],["tr","String","String.html#method-i-tr","(p1, p2)","<p>Returns a copy of <code>str</code> with the characters in <code>from_str</code> replaced by the corresponding characters in <code>to_str</code> …\n"],["tr!","String","String.html#method-i-tr-21","(p1, p2)","<p>Translates <em>str</em> in place, using the same rules as String#tr. Returns <em>str</em>, or <code>nil</code> if no changes were made. …\n"],["tr_s","String","String.html#method-i-tr_s","(p1, p2)","<p>Processes a copy of <em>str</em> as described under String#tr, then removes duplicate characters in regions that …\n"],["tr_s!","String","String.html#method-i-tr_s-21","(p1, p2)","<p>Performs String#tr_s processing on <em>str</em> in place, returning <em>str</em>, or <code>nil</code> if no changes were made.\n"],["trace","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-trace","(e, newline = nil, force = false)",""],["trace","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-trace","(message, newline = nil, force = false)",""],["trace","Matrix","Matrix.html#method-i-trace","()","<p>Returns the trace (sum of diagonal elements) of the matrix.\n\n<pre>Matrix[[7,6], [3,9]].trace\n  =&gt; 16</pre>\n"],["trace","Net::HTTP","Net/HTTP.html#method-i-trace","(path, initheader = nil)","<p>Sends a TRACE request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["trace","REXML::XPathParser","REXML/XPathParser.html#method-i-trace","(*args)",""],["trace","TracePoint","TracePoint.html#method-c-trace","(*events)","<p>Document-method: trace\n\n<pre>A convenience method for TracePoint.new, that activates the trace\nautomatically. ...</pre>\n"],["trace_func","IRB::Frame","IRB/Frame.html#method-i-trace_func","(event, file, line, id, binding)","<p>Used by Kernel#set_trace_func to register each event in the call stack\n"],["trace_object_allocations","ObjectSpace","ObjectSpace.html#method-c-trace_object_allocations","()","<p>Starts tracing object allocations from the ObjectSpace extension module.\n<p>For example:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">require</span> <span class=\"ruby-string\">&#39;objspace&#39;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["trace_object_allocations_clear","ObjectSpace","ObjectSpace.html#method-c-trace_object_allocations_clear","()","<p>Clear recorded tracing information.\n"],["trace_object_allocations_debug_start","ObjectSpace","ObjectSpace.html#method-c-trace_object_allocations_debug_start","()",""],["trace_object_allocations_start","ObjectSpace","ObjectSpace.html#method-c-trace_object_allocations_start","()","<p>Starts tracing object allocations.\n"],["trace_object_allocations_stop","ObjectSpace","ObjectSpace.html#method-c-trace_object_allocations_stop","()","<p>Stop tracing object allocations.\n<p>Note that if ::trace_object_allocations_start is called n-times, then …\n"],["trace_points","RubyVM::InstructionSequence","RubyVM/InstructionSequence.html#method-i-trace_points","()","<p>Return trace points in the instruction sequence. Return an array of [line, event_symbol] pair.\n"],["trace_var","Kernel","Kernel.html#method-i-trace_var","(*args)","<p>Controls tracing of assignments to global variables. The parameter <code>symbol</code> identifies the variable (as …\n"],["transaction","PStore","PStore.html#method-i-transaction","(read_only = false)","<p>Opens a new transaction for the data store.  Code executed inside a block passed to this method may read …\n"],["transfer","Fiber","Fiber.html#method-i-transfer","(*args)","<p>Transfer control to another fiber, resuming it from where it last stopped or starting it if it was not …\n"],["transform","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-transform","()",""],["transform_keys","Hash","Hash.html#method-i-transform_keys","()","<p>Returns a new hash with the results of running the block once for every key. This method does not change …\n"],["transform_keys!","Hash","Hash.html#method-i-transform_keys-21","()","<p>Invokes the given block once for each key in <em>hsh</em>, replacing it with the new key returned by the block, …\n"],["transform_values","Hash","Hash.html#method-i-transform_values","()","<p>Returns a new hash with the results of running the block once for every value. This method does not change …\n"],["transform_values!","Hash","Hash.html#method-i-transform_values-21","()","<p>Invokes the given block once for each value in <em>hsh</em>, replacing it with the new value returned by the block, …\n"],["translate","REXML::Functions","REXML/Functions.html#method-c-translate","( string, tr1, tr2 )","<p>This is entirely Mike Stok&#39;s beast\n"],["transport_request","Net::HTTP","Net/HTTP.html#method-i-transport_request","(req)",""],["transpose","Array","Array.html#method-i-transpose","()","<p>Assumes that <code>self</code> is an array of arrays and transposes the rows and columns.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">a</span> = [[<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">2</span>], [<span class=\"ruby-value\">3</span>,<span class=\"ruby-value\">4</span>], [<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>]] <span class=\"ruby-operator\">...</span>\n</pre>\n"],["transpose","Matrix","Matrix.html#method-i-transpose","()","<p>Returns the transpose of the matrix.\n\n<pre>Matrix[[1,2], [3,4], [5,6]]\n  =&gt; 1 2\n     3 4\n     5 6\nMatrix[[1,2], ...</pre>\n"],["transpose","Racc::States","Racc/States.html#method-i-transpose","(rel)",""],["trap","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-trap","(signal, override = false, &block)",""],["trap","Kernel","Kernel.html#method-i-trap","(*args)","<p>Specifies the handling of signals. The first parameter is a signal name (a string such as “SIGALRM&#39;&#39;, …\n"],["trap","Signal","Signal.html#method-c-trap","(*args)","<p>Specifies the handling of signals. The first parameter is a signal name (a string such as “SIGALRM&#39;&#39;, …\n"],["traverse","Gem::Specification","Gem/Specification.html#method-i-traverse","(trail = [], visited = {}, &block)","<p>Recursively walk dependencies of this spec, executing the <code>block</code> for each hop.\n"],["traverse","OpenSSL::ASN1","OpenSSL/ASN1.html#method-c-traverse","(p1)","<p>If a block is given, it prints out each of the elements encountered. Block parameters are (in that order): …\n"],["traverse","Racc::States","Racc/States.html#method-i-traverse","(i, index, vertices, map, relation)",""],["traverse_parents","Gem::Util","Gem/Util.html#method-c-traverse_parents","(directory, &block)","<p>Enumerates the parents of <code>directory</code>.\n"],["tree","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-tree","()",""],["tridiagonalize","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-tridiagonalize","()","<p>Symmetric Householder reduction to tridiagonal form.\n"],["true","REXML::Functions","REXML/Functions.html#method-c-true","( )","<p>UNTESTED\n"],["truffleruby?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-truffleruby-3F","()",""],["truncate","BigDecimal","BigDecimal.html#method-i-truncate","(p1 = v1)","<p>Truncate to the nearest integer (by default), returning the result as a BigDecimal.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">BigDecimal</span>(<span class=\"ruby-string\">&#39;3.14159&#39;</span>).<span class=\"ruby-identifier\">truncate</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["truncate","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-truncate","(string, width)",""],["truncate","File","File.html#method-i-truncate","(p1)","<p>Truncates <em>file</em> to at most <em>integer</em> bytes. The file must be opened for writing. Not available on all platforms. …\n"],["truncate","File","File.html#method-c-truncate","(p1, p2)","<p>Truncates the file <em>file_name</em> to be at most <em>integer</em> bytes long. Not available on all platforms.\n\n<pre>f = File.new(&quot;out&quot;, ...</pre>\n"],["truncate","Float","Float.html#method-i-truncate","(*args)","<p>Returns <code>float</code> truncated (toward zero) to a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>When the …\n"],["truncate","Integer","Integer.html#method-i-truncate","(*args)","<p>Returns <code>int</code> truncated (toward zero) to a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>When the precision …\n"],["truncate","Numeric","Numeric.html#method-i-truncate","(*args)","<p>Returns <code>num</code> truncated (toward zero) to a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>Numeric implements …\n"],["truncate","Pathname","Pathname.html#method-i-truncate","(p1)","<p>Truncates the file to <code>length</code> bytes.\n<p>See File.truncate.\n"],["truncate","Rational","Rational.html#method-i-truncate","(*args)","<p>Returns <code>rat</code> truncated (toward zero) to a precision of <code>ndigits</code> decimal digits (default: 0).\n<p>When the precision …\n"],["truncate","StringIO","StringIO.html#method-i-truncate","(p1)","<p>Truncates the buffer string to at most <em>integer</em> bytes. The stream must be opened for writing.\n"],["truncate_text","Gem::Text","Gem/Text.html#method-i-truncate_text","(text, description, max_length = 100_000)",""],["trust","Object","Object.html#method-i-trust","()","<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.\n"],["trust=","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-trust-3D","(p1)",""],["trust=","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-trust-3D","(p1)",""],["trust_cert","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-i-trust_cert","(certificate)","<p>Add a certificate to trusted certificate list.\n"],["trust_dir","Gem::Security","Gem/Security.html#method-c-trust_dir","()","<p>Returns a Gem::Security::TrustDir which wraps the directory where trusted certificates live.\n"],["trusted_certificates","Gem::Security","Gem/Security.html#method-c-trusted_certificates","(&block)","<p>Enumerates the trusted certificates via Gem::Security::TrustDir.\n"],["try_activate","Gem","Gem.html#method-c-try_activate","(path)","<p>Try to activate a gem containing <code>path</code>. Returns true if activation succeeded or wasn&#39;t needed because …\n"],["try_const","MakeMakefile","MakeMakefile.html#method-i-try_const","(const, headers = nil, opt = \"\", &b)","<p>Returns whether or not the constant <code>const</code> is defined.\n<p>See also <code>have_const</code>\n"],["try_convert","Array","Array.html#method-c-try_convert","(p1)","<p>Tries to convert <code>obj</code> into an array, using the <code>to_ary</code> method.  Returns the converted array or <code>nil</code> if  …\n"],["try_convert","Hash","Hash.html#method-c-try_convert","(p1)","<p>Try to convert <em>obj</em> into a hash, using to_hash method. Returns converted hash or nil if <em>obj</em> cannot be …\n"],["try_convert","IO","IO.html#method-c-try_convert","(p1)","<p>Try to convert <em>obj</em> into an IO, using to_io method. Returns converted IO or <code>nil</code> if <em>obj</em> cannot be converted …\n"],["try_convert","Regexp","Regexp.html#method-c-try_convert","(p1)","<p>Try to convert <em>obj</em> into a Regexp, using to_regexp method. Returns converted regexp or nil if <em>obj</em> cannot …\n"],["try_convert","String","String.html#method-c-try_convert","(p1)","<p>Try to convert <em>obj</em> into a String, using to_str method. Returns converted string or nil if <em>obj</em> cannot …\n"],["try_create","Bundler::ConnectionPool::TimedStack","Bundler/ConnectionPool/TimedStack.html#method-i-try_create","(options = nil)","<p>This is an extension point for TimedStack and is called with a mutex.\n<p>This method must create a connection …\n"],["try_enter","Monitor","Monitor.html#method-i-try_enter","()",""],["try_lock","Mutex","Mutex.html#method-i-try_lock","()","<p>Attempts to obtain the lock and returns immediately. Returns <code>true</code> if the lock was granted.\n"],["try_mon_enter","Monitor","Monitor.html#method-i-try_mon_enter","()","<p>for compatibility\n"],["try_mon_enter","MonitorMixin","MonitorMixin.html#method-i-try_mon_enter","()","<p>For backward compatibility\n"],["try_type","MakeMakefile","MakeMakefile.html#method-i-try_type","(type, headers = nil, opt = \"\", &b)","<p>Returns whether or not the static type <code>type</code> is defined.\n<p>See also <code>have_type</code>\n"],["tsort","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-c-tsort","(vertices)","<p>Topologically sorts the given vertices. @param [Enumerable&lt;Vertex&gt;] vertices the vertices to be …\n"],["tsort","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-c-tsort","(vertices)","<p>Topologically sorts the given vertices. @param [Enumerable&lt;Vertex&gt;] vertices the vertices to be …\n"],["tsort","TSort","TSort.html#method-i-tsort","()","<p>Returns a topologically sorted array of nodes. The array is sorted from children to parents, i.e. the …\n"],["tsort","TSort","TSort.html#method-c-tsort","(each_node, each_child)","<p>Returns a topologically sorted array of nodes. The array is sorted from children to parents, i.e. the …\n"],["tsort_each","TSort","TSort.html#method-i-tsort_each","()","<p>The iterator version of the #tsort method. <code><em>obj</em>.tsort_each</code> is similar to <code><em>obj</em>.tsort.each</code>, but modification …\n"],["tsort_each","TSort","TSort.html#method-c-tsort_each","(each_node, each_child)","<p>The iterator version of the TSort.tsort method.\n<p>The graph is represented by <em>each_node</em> and <em>each_child</em>. …\n"],["tsort_each_child","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-tsort_each_child","(vertex, &block)","<p>@!visibility private\n"],["tsort_each_child","Bundler::SpecSet","Bundler/SpecSet.html#method-i-tsort_each_child","(s)",""],["tsort_each_child","Gem::DependencyList","Gem/DependencyList.html#method-i-tsort_each_child","(node)",""],["tsort_each_child","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-tsort_each_child","(vertex, &block)","<p>@!visibility private\n"],["tsort_each_child","TSort","TSort.html#method-i-tsort_each_child","(node)","<p>Should be implemented by a extended class.\n<p>#tsort_each_child is used to iterate for child nodes of <em>node</em> …\n"],["tsort_each_node","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-tsort_each_node","()","<p>@!visibility private\n"],["tsort_each_node","Bundler::SpecSet","Bundler/SpecSet.html#method-i-tsort_each_node","()",""],["tsort_each_node","Gem::DependencyList","Gem/DependencyList.html#method-i-tsort_each_node","(&block)",""],["tsort_each_node","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-tsort_each_node","()","<p>@!visibility private\n"],["tsort_each_node","TSort","TSort.html#method-i-tsort_each_node","()","<p>Should be implemented by a extended class.\n<p>#tsort_each_node is used to iterate for all nodes over a graph. …\n"],["tty?","Gem::MockGemUi::TTY","Gem/MockGemUi/TTY.html#method-i-tty-3F","()",""],["tty?","Gem::StreamUI","Gem/StreamUI.html#method-i-tty-3F","()","<p>Returns true if TTY methods should be used on this StreamUI.\n"],["tty?","IO","IO.html#method-i-tty-3F","()","<p>Returns <code>true</code> if <em>ios</em> is associated with a terminal device (tty), <code>false</code> otherwise.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">isatty</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["tty?","StringIO","StringIO.html#method-i-tty-3F","()","<p>Returns <code>false</code>.  Just for compatibility to IO.\n"],["tuesday?","Date","Date.html#method-i-tuesday-3F","()","<p>Returns true if the date is Tuesday.\n"],["tuesday?","Time","Time.html#method-i-tuesday-3F","()","<p>Returns <code>true</code> if <em>time</em> represents Tuesday.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">1991</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">19</span>)      <span class=\"ruby-comment\">#=&gt; 1991-02-19 00:00:00 -0600 ...</span>\n</pre>\n"],["tv_nsec","Time","Time.html#method-i-tv_nsec","()","<p>Returns the number of nanoseconds for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>        <span class=\"ruby-comment\">#=&gt; 2007-11-17 15:18:03 +0900</span>\n<span class=\"ruby-string\">&quot;%10.9f&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["tv_sec","Time","Time.html#method-i-tv_sec","()","<p>Returns the value of <em>time</em> as an integer number of seconds since the Epoch.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>\n<span class=\"ruby-string\">&quot;%10.5f&quot;</span> <span class=\"ruby-operator\">%</span> <span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">to_f</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["tv_usec","Time","Time.html#method-i-tv_usec","()","<p>Returns the number of microseconds for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>        <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:03:26 -0600</span>\n<span class=\"ruby-string\">&quot;%10.6f&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["type","Bundler::DepProxy","Bundler/DepProxy.html#method-i-type","()",""],["type","Gem::Dependency","Gem/Dependency.html#method-i-type","()","<p>Dependency type.\n"],["type","Gem::Resolver::DependencyRequest","Gem/Resolver/DependencyRequest.html#method-i-type","()",""],["type","ObjectSpace::InternalObjectWrapper","ObjectSpace/InternalObjectWrapper.html#method-i-type","()","<p>Returns the type of the internal object.\n"],["type","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-type","()",""],["type","RDoc::ClassModule","RDoc/ClassModule.html#method-i-type","()","<p>&#39;module&#39; or &#39;class&#39;\n"],["type","RDoc::MethodAttr","RDoc/MethodAttr.html#method-i-type","()","<p>Type of method/attribute (class or instance)\n"],["type","RubyVM::AbstractSyntaxTree::Node","RubyVM/AbstractSyntaxTree/Node.html#method-i-type","()","<p>Returns the type of this node as a symbol.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">root</span> = <span class=\"ruby-constant\">RubyVM</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AbstractSyntaxTree</span>.<span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-string\">&quot;x = 1 + 2&quot;</span>)\n<span class=\"ruby-identifier\">root</span>.<span class=\"ruby-identifier\">type</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["type","Socket::AncillaryData","Socket/AncillaryData.html#method-i-type","()","<p>returns the cmsg type as an integer.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AncillaryData</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET6</span>, <span class=\"ruby-value\">:IPV6</span>, <span class=\"ruby-value\">:PKTINFO</span>, <span class=\"ruby-string\">&quot;&quot;</span>).<span class=\"ruby-identifier\">type</span>\n<span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["type=","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-type-3D","(p1)",""],["type_params","Net::HTTPHeader","Net/HTTPHeader.html#method-i-type_params","()","<p>Any parameters specified for the content type, returned as a Hash. For example, a header of Content-Type: …\n"],["typealias","Fiddle::Importer","Fiddle/Importer.html#method-i-typealias","(alias_type, orig_type)","<p>Sets the type alias for <code>alias_type</code> as <code>orig_type</code>\n"],["typecode=","Bundler::URI::FTP","Bundler/URI/FTP.html#method-i-typecode-3D","(typecode)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["typecode=","URI::FTP","URI/FTP.html#method-i-typecode-3D","(typecode)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["typekind","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-typekind","()","<p>Returns number which represents type.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Word 10.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Documents&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["typelibs","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-c-typelibs","()","<p>Returns array of type libraries. This method will be OBSOLETE. Use WIN32OLE_TYPELIB.typelibs.collect{|t| …\n"],["typelibs","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-c-typelibs","()","<p>Returns the array of WIN32OLE_TYPELIB object.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlibs</span> = <span class=\"ruby-constant\">WIN32OLE_TYPELIB</span>.<span class=\"ruby-identifier\">typelibs</span>\n</pre>\n"],["typename","WIN32OLE_RECORD","WIN32OLE_RECORD.html#method-i-typename","()","<p>Returns the type name of VT_RECORD OLE variable.\n<p>If COM server in VB.NET ComServer project is the following: …\n"],["typo_squatting?","Gem::Source","Gem/Source.html#method-i-typo_squatting-3F","(host, distance_threshold=4)",""],["u","ERB::Util","ERB/Util.html#method-i-u","(s)",""],["u","ERB::Util","ERB/Util.html#method-c-u","(s)",""],["u","Matrix::LUPDecomposition","Matrix/LUPDecomposition.html#method-i-u","()","<p>Returns the upper triangular factor <code>U</code>\n"],["ucmp","OpenSSL::BN","OpenSSL/BN.html#method-i-ucmp","(p1)",""],["udp","Addrinfo","Addrinfo.html#method-c-udp","(p1, p2)","<p>returns an addrinfo object for UDP address.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">udp</span>(<span class=\"ruby-string\">&quot;localhost&quot;</span>, <span class=\"ruby-string\">&quot;daytime&quot;</span>) <span class=\"ruby-comment\">#=&gt; #&lt;Addrinfo: 127.0.0.1:13 ...</span>\n</pre>\n"],["udp_server_loop","Socket","Socket.html#method-c-udp_server_loop","(host=nil, port)","<p>creates a UDP/IP server on <em>port</em> and calls the block for each message arrived. The block is called with …\n"],["udp_server_loop_on","Socket","Socket.html#method-c-udp_server_loop_on","(sockets)","<p>Run UDP/IP server loop on the given sockets.\n<p>The return value of Socket.udp_server_sockets is appropriate …\n"],["udp_server_recv","Socket","Socket.html#method-c-udp_server_recv","(sockets)","<p>Receive UDP/IP packets from the given <em>sockets</em>. For each packet received, the block is called.\n<p>The block …\n"],["udp_server_sockets","Socket","Socket.html#method-c-udp_server_sockets","(host=nil, port)","<p>Creates UDP/IP sockets for a UDP server.\n<p>If no block given, it returns an array of sockets.\n<p>If a block …\n"],["ui","Bundler","Bundler.html#method-c-ui","()",""],["ui","Gem","Gem.html#method-c-ui","()","<p>Lazily loads DefaultUserInteraction and returns the default UI.\n"],["ui","Gem::DefaultUserInteraction","Gem/DefaultUserInteraction.html#method-c-ui","()","<p>Return the default UI.\n"],["ui","Gem::DefaultUserInteraction","Gem/DefaultUserInteraction.html#method-i-ui","()","<p>See DefaultUserInteraction::ui\n"],["ui=","Bundler","Bundler.html#method-c-ui-3D","(ui)",""],["ui=","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-ui-3D","(obj)",""],["ui=","Gem::DefaultUserInteraction","Gem/DefaultUserInteraction.html#method-i-ui-3D","(new_ui)","<p>See DefaultUserInteraction::ui=\n"],["ui=","Gem::DefaultUserInteraction","Gem/DefaultUserInteraction.html#method-c-ui-3D","(new_ui)","<p>Set the default UI.  If the default UI is never explicitly set, a simple console based UserInteraction …\n"],["uid","File::Stat","File/Stat.html#method-i-uid","()","<p>Returns the numeric user id of the owner of <em>stat</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">uid</span>   <span class=\"ruby-comment\">#=&gt; 501</span>\n</pre>\n"],["uid","Process","Process.html#method-c-uid","()","<p>Returns the (real) user ID of this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Process</span>.<span class=\"ruby-identifier\">uid</span>   <span class=\"ruby-comment\">#=&gt; 501</span>\n</pre>\n"],["uid=","Process","Process.html#method-c-uid-3D","(p1)","<p>Sets the (user) user ID for this process. Not available on all platforms.\n"],["uid_copy","Net::IMAP","Net/IMAP.html#method-i-uid_copy","(set, mailbox)","<p>Similar to #copy(), but <code>set</code> contains unique identifiers.\n"],["uid_fetch","Net::IMAP","Net/IMAP.html#method-i-uid_fetch","(set, attr, mod = nil)","<p>Similar to #fetch(), but <code>set</code> contains unique identifiers.\n"],["uid_move","Net::IMAP","Net/IMAP.html#method-i-uid_move","(set, mailbox)","<p>Similar to #move(), but <code>set</code> contains unique identifiers.\n"],["uid_search","Net::IMAP","Net/IMAP.html#method-i-uid_search","(keys, charset = nil)","<p>Similar to #search(), but returns unique identifiers.\n"],["uid_sort","Net::IMAP","Net/IMAP.html#method-i-uid_sort","(sort_keys, search_keys, charset)","<p>Similar to #sort(), but returns an array of unique identifiers.\n"],["uid_store","Net::IMAP","Net/IMAP.html#method-i-uid_store","(set, attr, flags)","<p>Similar to #store(), but <code>set</code> contains unique identifiers.\n"],["uid_thread","Net::IMAP","Net/IMAP.html#method-i-uid_thread","(algorithm, search_keys, charset)","<p>Similar to #thread(), but returns unique identifiers instead of message sequence numbers.\n"],["uidl","Net::POPMail","Net/POPMail.html#method-i-uidl","()",""],["umask","File","File.html#method-c-umask","(*args)","<p>Returns the current umask value for this process. If the optional argument is given, set the umask to …\n"],["umount","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-umount","(dir)",""],["unadvise","WIN32OLE_EVENT","WIN32OLE_EVENT.html#method-i-unadvise","()","<p>disconnects OLE server. If this method called, then the WIN32OLE_EVENT object does not receive the OLE …\n"],["uname","Etc","Etc.html#method-c-uname","()","<p>Returns the system information obtained by uname system call.\n<p>The return value is a hash which has 5 keys …\n"],["unbind","Method","Method.html#method-i-unbind","()","<p>Dissociates <em>meth</em> from its current receiver. The resulting UnboundMethod can subsequently be bound to …\n"],["unbundled_env","Bundler","Bundler.html#method-c-unbundled_env","()","<p>@return [Hash] Environment with all bundler-related variables removed\n"],["unbundled_exec","Bundler","Bundler.html#method-c-unbundled_exec","(*args)","<p>Run a `Kernel.exec` to a subcommand in an environment with all bundler related variables removed\n"],["unbundled_system","Bundler","Bundler.html#method-c-unbundled_system","(*args)","<p>Run subcommand in an environment with all bundler related variables removed\n"],["uncomment_lines","Bundler::Thor::Actions","Bundler/Thor/Actions.html#method-i-uncomment_lines","(path, flag, *args)","<p>Uncomment all lines matching a given regex.  It will leave the space which existed before the comment …\n"],["unconverted_fields?","CSV","CSV.html#method-i-unconverted_fields-3F","()","<p>Returns <code>true</code> if unconverted_fields() to parsed results. See CSV::new for details.\n"],["unconverted_fields?","CSV::Parser","CSV/Parser.html#method-i-unconverted_fields-3F","()",""],["undef_method","Module","Module.html#method-i-undef_method","(*args)","<p>Prevents the current class from responding to calls to the named method. Contrast this with <code>remove_method</code> …\n"],["undefine_finalizer","ObjectSpace","ObjectSpace.html#method-c-undefine_finalizer","(p1)","<p>Removes all finalizers for <em>obj</em>.\n"],["undo_replacements","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-undo_replacements","()",""],["undoc_params","RDoc::Stats","RDoc/Stats.html#method-i-undoc_params","(method)","<p>Determines which parameters in <code>method</code> were not documented.  Returns a total parameter count and an Array …\n"],["undump","String","String.html#method-i-undump","()","<p>Returns an unescaped version of the string. This does the inverse of String#dump.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;\\&quot;hello \\\\n &#39;&#39;\\&quot;&quot;</span>.<span class=\"ruby-identifier\">undump</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["unescape","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-unescape","(str)","<p>Bundler::URI::unescape wrapper\n"],["unescape","Bundler::URI::Escape","Bundler/URI/Escape.html#method-i-unescape","(*arg)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Bundler</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">URI</span>.<span class=\"ruby-identifier\">unescape</span>(<span class=\"ruby-identifier\">str</span>)\n</pre>\n<p>Args\n"],["unescape","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-unescape","(str, escaped = @regexp[:ESCAPED])","<p>Args\n<p><code>str</code> &mdash; String to remove escapes from\n<p><code>escaped</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["unescape","Bundler::URI::RFC2396_Parser","Bundler/URI/RFC2396_Parser.html#method-i-unescape","(str, escaped = @regexp[:ESCAPED])","<p>Args\n<p><code>str</code> &mdash; String to remove escapes from\n<p><code>escaped</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["unescape","CGI::Util","CGI/Util.html#method-i-unescape","(string,encoding=@@accept_charset)","<p>URL-decode a string with encoding(optional).\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">string</span> = <span class=\"ruby-constant\">CGI</span>.<span class=\"ruby-identifier\">unescape</span>(<span class=\"ruby-string\">&quot;%27Stop%21%27+said+Fred&quot;</span>)\n   <span class=\"ruby-comment\"># =&gt; ...</span>\n</pre>\n"],["unescape","Gem::UriFormatter","Gem/UriFormatter.html#method-i-unescape","()","<p>Unescapes the #uri which came from a CGI parameter\n"],["unescape","URI::Escape","URI/Escape.html#method-i-unescape","(*arg)","<p>Synopsis\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">URI</span>.<span class=\"ruby-identifier\">unescape</span>(<span class=\"ruby-identifier\">str</span>)\n</pre>\n<p>Args\n"],["unescape","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-unescape","(str, escaped = @regexp[:ESCAPED])","<p>Args\n<p><code>str</code> &mdash; String to remove escapes from\n<p><code>escaped</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["unescape","URI::RFC2396_Parser","URI/RFC2396_Parser.html#method-i-unescape","(str, escaped = @regexp[:ESCAPED])","<p>Args\n<p><code>str</code> &mdash; String to remove escapes from\n<p><code>escaped</code> &mdash; Regexp to apply. Defaults to self.regexp\n"],["unescape","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-unescape","(str)","<p>Unescapes HTTP reserved and unwise characters in <code>str</code>\n"],["unescapeElement","CGI::Util","CGI/Util.html#method-i-unescapeElement","(string, *elements)","<p>Undo escaping such as that done by CGI.escapeElement()\n\n<pre>print CGI.unescapeElement(\n        CGI.escapeHTML(&#39;&lt;BR&gt;&lt;A ...</pre>\n"],["unescapeHTML","CGI::Util","CGI/Util.html#method-i-unescapeHTML","(string)","<p>Unescape a string that has been HTML-escaped\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">CGI</span>.<span class=\"ruby-identifier\">unescapeHTML</span>(<span class=\"ruby-string\">&quot;Usage: foo &amp;quot;bar&amp;quot; &amp;lt;baz&amp;gt;&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["unescape_element","CGI::Util","CGI/Util.html#method-i-unescape_element","(string, *elements)","<p>Synonym for CGI.unescapeElement(str)\n"],["unescape_form","WEBrick::HTTPUtils","WEBrick/HTTPUtils.html#method-i-unescape_form","(str)","<p>Unescapes form reserved characters in <code>str</code>\n"],["unescape_html","CGI::Util","CGI/Util.html#method-i-unescape_html","(string)","<p>Synonym for CGI.unescapeHTML(str)\n"],["unescape_value","OpenSSL::Config","OpenSSL/Config.html#method-c-unescape_value","(data, section, value)",""],["unget_tk","RDoc::Parser::RubyTools","RDoc/Parser/RubyTools.html#method-i-unget_tk","(tk)","<p>Returns <code>tk</code> to the scanner\n"],["ungetbyte","IO","IO.html#method-i-ungetbyte","(p1)","<p>Pushes back bytes (passed as a parameter) onto <em>ios</em>, such that a subsequent buffered read will return …\n"],["ungetbyte","StringIO","StringIO.html#method-i-ungetbyte","(p1)","<p>See IO#ungetbyte\n"],["ungetbyte","Zlib::GzipReader","Zlib/GzipReader.html#method-i-ungetbyte","(p1)","<p>See Zlib::GzipReader documentation for a description.\n"],["ungetc","IO","IO.html#method-i-ungetc","(p1)","<p>Pushes back one character (passed as a parameter) onto <em>ios</em>, such that a subsequent buffered character …\n"],["ungetc","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-ungetc","(c)","<p>Pushes character <em>c</em> back onto the stream such that a subsequent buffered character read will return it. …\n"],["ungetc","StringIO","StringIO.html#method-i-ungetc","(p1)","<p>Pushes back one character (passed as a parameter) such that a subsequent buffered read will return it. …\n"],["ungetc","Zlib::GzipReader","Zlib/GzipReader.html#method-i-ungetc","(p1)","<p>See Zlib::GzipReader documentation for a description.\n"],["unicode_normalize","String","String.html#method-i-unicode_normalize","(*args)","<p>Unicode Normalization—Returns a normalized form of <code>str</code>, using Unicode normalizations NFC, NFD, NFKC …\n"],["unicode_normalize!","String","String.html#method-i-unicode_normalize-21","(*args)","<p>Destructive version of String#unicode_normalize, doing Unicode normalization in place.\n"],["unicode_normalized?","String","String.html#method-i-unicode_normalized-3F","(*args)","<p>Checks whether <code>str</code> is in Unicode normalization form <code>form</code>, which can be any of the four values <code>:nfc</code>,  …\n"],["unindent_auto","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-unindent_auto","(str)",""],["uninstall","Gem::Commands::UninstallCommand","Gem/Commands/UninstallCommand.html#method-i-uninstall","(gem_name)",""],["uninstall","Gem::Uninstaller","Gem/Uninstaller.html#method-i-uninstall","()","<p>Performs the uninstall of the gem.  This removes the spec, the Gem directory, and the cached .gem file. …\n"],["uninstall_all","Gem::Commands::UninstallCommand","Gem/Commands/UninstallCommand.html#method-i-uninstall_all","()",""],["uninstall_dep","Gem::Commands::CleanupCommand","Gem/Commands/CleanupCommand.html#method-i-uninstall_dep","(spec)",""],["uninstall_gem","Gem::Commands::UninstallCommand","Gem/Commands/UninstallCommand.html#method-i-uninstall_gem","(gem_name)",""],["uninstall_gem","Gem::TestCase","Gem/TestCase.html#method-i-uninstall_gem","(spec)","<p>Uninstalls the Gem::Specification <code>spec</code>\n"],["uninstall_gem","Gem::Uninstaller","Gem/Uninstaller.html#method-i-uninstall_gem","(spec)","<p>Uninstalls gem <code>spec</code>\n"],["uninstall_old_gemcutter","Gem::Commands::SetupCommand","Gem/Commands/SetupCommand.html#method-i-uninstall_old_gemcutter","()",""],["uninstall_specific","Gem::Commands::UninstallCommand","Gem/Commands/UninstallCommand.html#method-i-uninstall_specific","()",""],["union","Array","Array.html#method-i-union","(*args)","<p>Set Union — Returns a new array by joining <code>other_ary</code>s with <code>self</code>, excluding any duplicates and preserving …\n"],["union","Fiddle::Importer","Fiddle/Importer.html#method-i-union","(signature)","<p>Creates a class to wrap the C union described by <code>signature</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">MyUnion</span> = <span class=\"ruby-identifier\">union</span> [<span class=\"ruby-string\">&#39;int i&#39;</span>, <span class=\"ruby-string\">&#39;char c&#39;</span>]\n</pre>\n"],["union","Regexp","Regexp.html#method-c-union","(*args)","<p>Return a Regexp object that is the union of the given <em>pattern</em>s, i.e., will match any of its parts. The …\n"],["union","Set","Set.html#method-i-union","(enum)",""],["uniq","Array","Array.html#method-i-uniq","()","<p>Returns a new array by removing duplicate values in <code>self</code>.\n<p>If a block is given, it will use the return …\n"],["uniq","Enumerable","Enumerable.html#method-i-uniq","()","<p>Returns a new array by removing duplicate values in <code>self</code>.\n<p>See also Array#uniq.\n"],["uniq","Enumerator::Lazy","Enumerator/Lazy.html#method-i-uniq","()","<p>Like Enumerable#uniq, but chains operation to be lazy-evaluated.\n"],["uniq!","Array","Array.html#method-i-uniq-21","()","<p>Removes duplicate elements from <code>self</code>.\n<p>If a block is given, it will use the return value of the block for …\n"],["unique_classes","RDoc::Store","RDoc/Store.html#method-i-unique_classes","()","<p>Returns the unique classes discovered by RDoc.\n<p>::complete must have been called prior to using this method. …\n"],["unique_classes_and_modules","RDoc::Store","RDoc/Store.html#method-i-unique_classes_and_modules","()","<p>Returns the unique classes and modules discovered by RDoc. ::complete must have been called prior to …\n"],["unique_id","Net::POPMail","Net/POPMail.html#method-i-unique_id","()","<p>Returns the unique-id of the message. Normally the unique-id is a hash string of the message.\n<p>This method …\n"],["unique_modules","RDoc::Store","RDoc/Store.html#method-i-unique_modules","()","<p>Returns the unique modules discovered by RDoc. ::complete must have been called prior to using this method. …\n"],["unique_separator","Racc::ParserFileGenerator","Racc/ParserFileGenerator.html#method-i-unique_separator","(id)",""],["unit","Matrix","Matrix.html#method-c-unit","(n)",""],["unitary?","Matrix","Matrix.html#method-i-unitary-3F","()","<p>Returns <code>true</code> if this is a unitary matrix Raises an error if matrix is not square.\n"],["unix","Addrinfo","Addrinfo.html#method-c-unix","(p1, p2 = v2)","<p>returns an addrinfo object for UNIX socket address.\n<p><em>socktype</em> specifies the socket type. If it is omitted, …\n"],["unix","Socket","Socket.html#method-c-unix","(path)","<p>creates a new socket connected to path using UNIX socket socket.\n<p>If a block is given, the block is called …\n"],["unix?","Addrinfo","Addrinfo.html#method-i-unix-3F","()","<p>returns true if addrinfo is UNIX address. returns false otherwise.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">tcp</span>(<span class=\"ruby-string\">&quot;127.0.0.1&quot;</span>, <span class=\"ruby-value\">80</span>).<span class=\"ruby-identifier\">unix?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["unix?","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-unix-3F","()",""],["unix_path","Addrinfo","Addrinfo.html#method-i-unix_path","()","<p>Returns the socket path as a string.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Addrinfo</span>.<span class=\"ruby-identifier\">unix</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>).<span class=\"ruby-identifier\">unix_path</span>       <span class=\"ruby-comment\">#=&gt; &quot;/tmp/sock&quot;</span>\n</pre>\n"],["unix_rights","Socket::AncillaryData","Socket/AncillaryData.html#method-c-unix_rights","(*args)","<p>Creates a new Socket::AncillaryData object which contains file descriptors as data.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">p</span> <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">AncillaryData</span>.<span class=\"ruby-identifier\">unix_rights</span>(<span class=\"ruby-constant\">STDERR</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["unix_rights","Socket::AncillaryData","Socket/AncillaryData.html#method-i-unix_rights","()","<p>returns the array of IO objects for SCM_RIGHTS control message in UNIX domain socket.\n<p>The class of the …\n"],["unix_server_loop","Socket","Socket.html#method-c-unix_server_loop","(path)","<p>creates a UNIX socket server on <em>path</em>. It calls the block for each socket accepted.\n<p>If <em>host</em> is specified, …\n"],["unix_server_socket","Socket","Socket.html#method-c-unix_server_socket","(path)","<p>creates a UNIX server socket on <em>path</em>\n<p>If no block given, it returns a listening socket.\n<p>If a block is given, …\n"],["unix_socket_abstract_name?","Socket","Socket.html#method-c-unix_socket_abstract_name-3F","(path)",""],["unknown","Logger","Logger.html#method-i-unknown","(progname = nil, &block)","<p>Log an <code>UNKNOWN</code> message.  This will be printed no matter what the logger&#39;s level is.\n<p>See #info for …\n"],["unknown","Syslog::Logger","Syslog/Logger.html#method-i-unknown","","<p>Logs a <code>message</code> at the unknown (syslog alert) log level, or logs the message returned from the block. …\n"],["unknown_sections_in_lockfile","Bundler::LockfileParser","Bundler/LockfileParser.html#method-c-unknown_sections_in_lockfile","(lockfile_contents)",""],["unlink","Dir","Dir.html#method-c-unlink","(p1)","<p>Deletes the named directory. Raises a subclass of SystemCallError if the directory isn&#39;t empty.\n"],["unlink","File","File.html#method-c-unlink","(*args)","<p>Deletes the named files, returning the number of names passed as arguments. Raises an exception on any …\n"],["unlink","Pathname","Pathname.html#method-i-unlink","()","<p>Removes a file or directory, using File.unlink if <code>self</code> is a file, or Dir.unlink as necessary.\n"],["unlink","Tempfile","Tempfile.html#method-i-unlink","()","<p>Unlinks (deletes) the file from the filesystem. One should always unlink the file after using it, as …\n"],["unlock","Mutex","Mutex.html#method-i-unlock","()","<p>Releases the lock. Raises <code>ThreadError</code> if <code>mutex</code> wasn&#39;t locked by the current thread.\n"],["unlock","Net::HTTP","Net/HTTP.html#method-i-unlock","(path, body, initheader = nil)","<p>Sends a UNLOCK request to the <code>path</code> and gets a response, as an HTTPResponse object.\n"],["unlock!","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-unlock-21","()","<p>This is called to update the spec and installation.\n<p>If the source plugin is loaded from lockfile or otherwise, …\n"],["unlock!","Bundler::Source::Git","Bundler/Source/Git.html#method-i-unlock-21","()",""],["unlocking?","Bundler::Definition","Bundler/Definition.html#method-i-unlocking-3F","()",""],["unlocking_gem?","Bundler::GemVersionPromoter","Bundler/GemVersionPromoter.html#method-i-unlocking_gem-3F","()",""],["unmarshalled_dep_gems","Bundler::Fetcher::Dependency","Bundler/Fetcher/Dependency.html#method-i-unmarshalled_dep_gems","(gem_names)",""],["unmet_dependency_names","Bundler::Index","Bundler/Index.html#method-i-unmet_dependency_names","()","<p>returns a list of the dependencies\n"],["unmet_deps","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-unmet_deps","()","<p>Used by definition.\n<p>Note: Do not override if you don&#39;t know what you are doing.\n"],["unmet_deps","Bundler::Source","Bundler/Source.html#method-i-unmet_deps","()",""],["unmet_deps","Bundler::Source::Rubygems","Bundler/Source/Rubygems.html#method-i-unmet_deps","()",""],["unmount","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-unmount","(dir)","<p>Unmounts <code>dir</code>\n"],["unnode","REXML::XPathParser","REXML/XPathParser.html#method-i-unnode","(nodeset)",""],["unnormalize","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-unnormalize","( string, entities=nil, filter=nil )","<p>Unescapes all possible entities\n"],["unnormalize","REXML::Text","REXML/Text.html#method-c-unnormalize","( string, doctype=nil, filter=nil, illegal=nil )","<p>Unescapes all possible entities\n"],["unnormalized","REXML::Entity","REXML/Entity.html#method-i-unnormalized","()","<p>Evaluates to the unnormalized value of this entity; that is, replacing all entities – both %ent; and …\n"],["unpack","Gem::Installer","Gem/Installer.html#method-i-unpack","(directory)","<p>Unpacks the gem into the given directory.\n"],["unpack","Socket::Option","Socket/Option.html#method-i-unpack","(p1)","<p>Calls String#unpack on sockopt.data.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">sockopt</span> = <span class=\"ruby-constant\">Socket</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">Option</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">:INET</span>, <span class=\"ruby-value\">:SOCKET</span>, <span class=\"ruby-value\">:KEEPALIVE</span>, [<span class=\"ruby-value\">1</span>].<span class=\"ruby-identifier\">pack</span>(<span class=\"ruby-string\">&quot;i&quot;</span>)) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["unpack","String","String.html#method-i-unpack","(fmt)","<p>Decodes <em>str</em> (which may contain binary data) according to the format string, returning an array of each …\n"],["unpack1","String","String.html#method-i-unpack1","(fmt)","<p>Decodes <em>str</em> (which may contain binary data) according to the format string, returning the first value …\n"],["unpack_sockaddr_in","Socket","Socket.html#method-c-unpack_sockaddr_in","(p1)","<p>Unpacks <em>sockaddr</em> into port and ip_address.\n<p><em>sockaddr</em> should be a string or an addrinfo for AF_INET/AF_INET6. …\n"],["unpack_sockaddr_un","Socket","Socket.html#method-c-unpack_sockaddr_un","(p1)","<p>Unpacks <em>sockaddr</em> into path.\n<p><em>sockaddr</em> should be a string or an addrinfo for AF_UNIX.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">sockaddr</span> = <span class=\"ruby-constant\">Socket</span>.<span class=\"ruby-identifier\">sockaddr_un</span>(<span class=\"ruby-string\">&quot;/tmp/sock&quot;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["unprinted_warnings","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-unprinted_warnings","()",""],["unprinted_warnings","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-unprinted_warnings","()",""],["unregist","DRb::ExtServManager","DRb/ExtServManager.html#method-i-unregist","(name)",""],["unregister_command","Gem::CommandManager","Gem/CommandManager.html#method-i-unregister_command","(command)","<p>Unregister the Symbol <code>command</code> as a gem command.\n"],["unresolved_deps","Gem::Specification","Gem/Specification.html#method-c-unresolved_deps","()","<p>DOC: This method needs documented or nodoc&#39;d\n"],["unresolved_names","Gem::TestCase","Gem/TestCase.html#method-i-unresolved_names","()",""],["unscan","StringScanner","StringScanner.html#method-i-unscan","()","<p>Sets the scan pointer to the previous position.  Only one previous position is remembered, and it changes …\n"],["unset","Bundler::CLI::Config","Bundler/CLI/Config.html#method-i-unset","(name)",""],["unset_api_key!","Gem::ConfigFile","Gem/ConfigFile.html#method-i-unset_api_key-21","()","<p>Remove the +~/.gem/credentials+ file to clear all the current sessions.\n"],["unshift","Array","Array.html#method-i-unshift","(*args)","<p>Prepends objects to the front of <code>self</code>, moving other elements upwards. See also Array#shift for the opposite …\n"],["unshift","Gem::RequestSet::Lockfile::Tokenizer","Gem/RequestSet/Lockfile/Tokenizer.html#method-i-unshift","(token)",""],["unshift","REXML::Parent","REXML/Parent.html#method-i-unshift","( object )",""],["unshift","REXML::Parsers::BaseParser","REXML/Parsers/BaseParser.html#method-i-unshift","(token)","<p>Push an event back on the head of the stream.  This method has (theoretically) infinite depth.\n"],["unshift","REXML::Parsers::PullParser","REXML/Parsers/PullParser.html#method-i-unshift","(token)",""],["unsorted_search","Bundler::Index","Bundler/Index.html#method-i-unsorted_search","(query, base)",""],["unsubscribe","Net::IMAP","Net/IMAP.html#method-i-unsubscribe","(mailbox)","<p>Sends a UNSUBSCRIBE command to remove the specified <code>mailbox</code> name from the server&#39;s set of “active” …\n"],["untaint","Object","Object.html#method-i-untaint","()","<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.\n"],["untaint","Pathname","Pathname.html#method-i-untaint","()","<p>Returns pathname.  This method is deprecated and will be removed in Ruby 3.2.\n"],["untrace_var","Kernel","Kernel.html#method-i-untrace_var","(*args)","<p>Removes tracing for the specified command on the given global variable and returns <code>nil</code>. If no command …\n"],["untrust","Object","Object.html#method-i-untrust","()","<p>Returns object. This method is deprecated and will be removed in Ruby 3.2.\n"],["untrusted?","Object","Object.html#method-i-untrusted-3F","()","<p>Returns false.  This method is deprecated and will be removed in Ruby 3.2.\n"],["unused","Zlib::GzipReader","Zlib/GzipReader.html#method-i-unused","()","<p>Returns the rest of the data which had read for parsing gzip format, or <code>nil</code> if the whole gzip file is …\n"],["unused_unwind_options","Bundler::Molinillo::Delegates::ResolutionState","Bundler/Molinillo/Delegates/ResolutionState.html#method-i-unused_unwind_options","()","<p>(see Bundler::Molinillo::ResolutionState#unused_unwind_options)\n"],["unwind_for_conflict","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-unwind_for_conflict","()","<p>Unwinds the states stack because a conflict has been encountered @return [void]\n"],["unwind_for_conflict","Gem::Resolver::Molinillo::Resolver::Resolution","Gem/Resolver/Molinillo/Resolver/Resolution.html#method-i-unwind_for_conflict","()","<p>Unwinds the states stack because a conflict has been encountered @return [void]\n"],["unwind_options_for_requirements","Bundler::Molinillo::Resolver::Resolution","Bundler/Molinillo/Resolver/Resolution.html#method-i-unwind_options_for_requirements","(binding_requirements)","<p>@param [Array&lt;Object&gt;] array of requirements that combine to create a conflict @return [Array&lt;UnwindDetails&gt;] …\n"],["unwinding_to_primary_requirement?","Bundler::Molinillo::Resolver::Resolution::UnwindDetails","Bundler/Molinillo/Resolver/Resolution/UnwindDetails.html#method-i-unwinding_to_primary_requirement-3F","()","<p>@return [Boolean] where the requirement of the state we&#39;re unwinding\n\n<pre>to directly caused the conflict. ...</pre>\n"],["up","Bundler::Molinillo::DependencyGraph::Action","Bundler/Molinillo/DependencyGraph/Action.html#method-i-up","(graph)","<p>Performs the action on the given graph. @param  [DependencyGraph] graph the graph to perform the action …\n"],["up","Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular","Bundler/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-up","(graph)","<p>(see Action#up)\n"],["up","Bundler::Molinillo::DependencyGraph::DeleteEdge","Bundler/Molinillo/DependencyGraph/DeleteEdge.html#method-i-up","(graph)","<p>(see Action#up)\n"],["up","Bundler::Molinillo::DependencyGraph::DetachVertexNamed","Bundler/Molinillo/DependencyGraph/DetachVertexNamed.html#method-i-up","(graph)","<p>(see Action#up)\n"],["up","Bundler::Molinillo::DependencyGraph::Tag","Bundler/Molinillo/DependencyGraph/Tag.html#method-i-up","(_graph)","<p>(see Action#up)\n"],["up","Gem::Resolver::Molinillo::DependencyGraph::Action","Gem/Resolver/Molinillo/DependencyGraph/Action.html#method-i-up","(graph)","<p>Performs the action on the given graph. @param  [DependencyGraph] graph the graph to perform the action …\n"],["up","Gem::Resolver::Molinillo::DependencyGraph::AddEdgeNoCircular","Gem/Resolver/Molinillo/DependencyGraph/AddEdgeNoCircular.html#method-i-up","(graph)","<p>(see Action#up)\n"],["up","Gem::Resolver::Molinillo::DependencyGraph::DeleteEdge","Gem/Resolver/Molinillo/DependencyGraph/DeleteEdge.html#method-i-up","(graph)","<p>(see Action#up)\n"],["up","Gem::Resolver::Molinillo::DependencyGraph::DetachVertexNamed","Gem/Resolver/Molinillo/DependencyGraph/DetachVertexNamed.html#method-i-up","(graph)","<p>(see Action#up)\n"],["up","Gem::Resolver::Molinillo::DependencyGraph::Tag","Gem/Resolver/Molinillo/DependencyGraph/Tag.html#method-i-up","(_graph)","<p>(see Action#up)\n"],["upcase","String","String.html#method-i-upcase","(*args)","<p>Returns a copy of <em>str</em> with all lowercase letters replaced with their uppercase counterparts.\n<p>See String#downcase …\n"],["upcase","Symbol","Symbol.html#method-i-upcase","(*args)","<p>Same as <code>sym.to_s.upcase.intern</code>.\n"],["upcase!","String","String.html#method-i-upcase-21","(*args)","<p>Upcases the contents of <em>str</em>, returning <code>nil</code> if no changes were made.\n<p>See String#downcase for meaning of …\n"],["update","Bundler::CLI","Bundler/CLI.html#method-i-update","(*gems)",""],["update","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-update","(local_path, remote_path)",""],["update","Bundler::CompactIndexClient::Updater","Bundler/CompactIndexClient/Updater.html#method-i-update","(local_path, remote_path, retrying = nil)",""],["update","CGI::Session","CGI/Session.html#method-i-update","()","<p>Store session data on the server.  For some session storage types, this is a no-op.\n"],["update","CGI::Session::FileStore","CGI/Session/FileStore.html#method-i-update","()","<p>Save session state to the session&#39;s FileStore file.\n"],["update","CGI::Session::MemoryStore","CGI/Session/MemoryStore.html#method-i-update","()","<p>Update session state.\n<p>A no-op.\n"],["update","CGI::Session::NullStore","CGI/Session/NullStore.html#method-i-update","()","<p>Update session state.\n<p>A no-op.\n"],["update","CGI::Session::PStore","CGI/Session/PStore.html#method-i-update","()","<p>Save session state to the session&#39;s PStore file.\n"],["update","DBM","DBM.html#method-i-update","(p1)","<p>Updates the database with multiple values from the specified object. Takes any object which implements …\n"],["update","Digest::Base","Digest/Base.html#method-i-update","(p1)","<p>Update the digest using given <em>string</em> and return <code>self</code>.\n"],["update","Digest::Instance","Digest/Instance.html#method-i-update","(p1)","<p>Updates the digest using a given <em>string</em> and returns self.\n<p>The update() method and the left-shift operator …\n"],["update","ENV","ENV.html#method-c-update","(p1)","<p>Adds the contents of <code>hash</code> to the environment variables.  If no block is specified entries with duplicate …\n"],["update","GDBM","GDBM.html#method-i-update","(p1)","<p>Adds the key-value pairs of <em>other</em> to <em>gdbm</em>, overwriting entries with duplicate keys with those from <em>other</em> …\n"],["update","Gem::StreamUI::SilentDownloadReporter","Gem/StreamUI/SilentDownloadReporter.html#method-i-update","(current)","<p>Nothing can update the silent download reporter.\n"],["update","Gem::StreamUI::ThreadedDownloadReporter","Gem/StreamUI/ThreadedDownloadReporter.html#method-i-update","(bytes)","<p>Updates the threaded download reporter for the given number of <code>bytes</code>.\n"],["update","Hash","Hash.html#method-i-update","(*args)","<p>Adds the contents of the given hashes to the receiver.\n<p>If no block is given, entries with duplicate keys …\n"],["update","OpenSSL::Cipher","OpenSSL/Cipher.html#method-i-update","(p1, p2 = v2)","<p>Encrypts data in a streaming fashion. Hand consecutive blocks of data to the #update method in order …\n"],["update","OpenSSL::Digest","OpenSSL/Digest.html#method-i-update","(p1)","<p>Not every message digest can be computed in one single pass. If a message digest is to be computed from …\n"],["update","OpenSSL::HMAC","OpenSSL/HMAC.html#method-i-update","(p1)","<p>Returns <em>hmac</em> updated with the message to be authenticated. Can be called repeatedly with chunks of the …\n"],["update","OptionParser::List","OptionParser/List.html#method-i-update","(sw, sopts, lopts, nsw = nil, nlopts = nil)","<p>Adds <code>sw</code> according to <code>sopts</code>, <code>lopts</code> and <code>nlopts</code>.\n<p><code>sw</code> &mdash; OptionParser::Switch instance to be added.\n<p><code>sopts</code> &mdash; Short …\n"],["update","Racc::ISet","Racc/ISet.html#method-i-update","(other)",""],["update","SDBM","SDBM.html#method-i-update","(p1)","<p>Insert or update key-value pairs.\n<p>This method will work with any object which implements an each_pair …\n"],["update","YAML::DBM","YAML/DBM.html#method-i-update","( hsh )","<p>Updates the database with multiple values from the specified object. Takes any object which implements …\n"],["update_a","Racc::ISet","Racc/ISet.html#method-i-update_a","(a)",""],["update_aliases","RDoc::ClassModule","RDoc/ClassModule.html#method-i-update_aliases","()","<p>Updates the child modules &amp; classes by replacing the ones that are aliases through a constant.\n<p>The …\n"],["update_and_parse_checksums!","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-update_and_parse_checksums-21","()",""],["update_cache?","Gem::Source","Gem/Source.html#method-i-update_cache-3F","()","<p>Returns true when it is possible and safe to update the cache directory.\n"],["update_checksum","Gem::Package::TarHeader","Gem/Package/TarHeader.html#method-i-update_checksum","()","<p>Updates the TarHeader&#39;s checksum\n"],["update_content","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-update_content","()",""],["update_content","RSS::Maker::ITunesItemModel::ITunesDurationBase","RSS/Maker/ITunesItemModel/ITunesDurationBase.html#method-i-update_content","()",""],["update_extends","RDoc::ClassModule","RDoc/ClassModule.html#method-i-update_extends","()","<p>Deletes from #extends those whose module has been removed from the documentation.\n"],["update_gem","Gem::Commands::UpdateCommand","Gem/Commands/UpdateCommand.html#method-i-update_gem","(name, version = Gem::Requirement.default)",""],["update_gems","Gem::Commands::UpdateCommand","Gem/Commands/UpdateCommand.html#method-i-update_gems","(gems_to_update)",""],["update_includes","RDoc::ClassModule","RDoc/ClassModule.html#method-i-update_includes","()","<p>Deletes from #includes those whose module has been removed from the documentation.\n"],["update_index","Gem::Indexer","Gem/Indexer.html#method-i-update_index","()","<p>Perform an in-place update of the repository from newly added gems.\n"],["update_info","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-update_info","(name)",""],["update_mirror","Bundler::Settings::MirrorConfig","Bundler/Settings/MirrorConfig.html#method-i-update_mirror","(mirror)",""],["update_output_dir","RDoc::RDoc","RDoc/RDoc.html#method-i-update_output_dir","(op_dir, time, last = {})","<p>Update the flag file in an output directory.\n"],["update_parser_of_file","RDoc::Store","RDoc/Store.html#method-i-update_parser_of_file","(absolute_name, parser)",""],["update_present_via_semver_portions","Bundler::CLI::Outdated","Bundler/CLI/Outdated.html#method-i-update_present_via_semver_portions","(current_spec, active_spec, options)",""],["update_rubygems","Gem::Commands::UpdateCommand","Gem/Commands/UpdateCommand.html#method-i-update_rubygems","()","<p>Update RubyGems software to the latest version.\n"],["update_specs_index","Gem::Indexer","Gem/Indexer.html#method-i-update_specs_index","(index, source, dest)","<p>Combines specs in <code>index</code> and <code>source</code> then writes out a new copy to <code>dest</code>.  For a latest index, does not …\n"],["updated","Gem::StreamUI::SilentProgressReporter","Gem/StreamUI/SilentProgressReporter.html#method-i-updated","(message)","<p>Does not print <code>message</code> when updated as this object has taken a vow of silence.\n"],["updated","Gem::StreamUI::SimpleProgressReporter","Gem/StreamUI/SimpleProgressReporter.html#method-i-updated","(message)","<p>Prints out a dot and ignores <code>message</code>.\n"],["updated","Gem::StreamUI::VerboseProgressReporter","Gem/StreamUI/VerboseProgressReporter.html#method-i-updated","(message)","<p>Prints out the position relative to the total and the <code>message</code>.\n"],["updated","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-updated","()",""],["updated","RSS::Maker::ItemsBase::ItemBase","RSS/Maker/ItemsBase/ItemBase.html#method-i-updated","()",""],["updated","RSS::Maker::ItemsBase::ItemBase::SourceBase","RSS/Maker/ItemsBase/ItemBase/SourceBase.html#method-i-updated","()",""],["updated=","RSS::Maker::ChannelBase","RSS/Maker/ChannelBase.html#method-i-updated-3D","(date)",""],["updated=","RSS::Maker::ItemsBase::ItemBase","RSS/Maker/ItemsBase/ItemBase.html#method-i-updated-3D","(date)",""],["updated=","RSS::Maker::ItemsBase::ItemBase::SourceBase","RSS/Maker/ItemsBase/ItemBase/SourceBase.html#method-i-updated-3D","(date)",""],["upgrade_to_class","RDoc::Context","RDoc/Context.html#method-i-upgrade_to_class","(mod, class_type, enclosing)","<p>Upgrades NormalModule <code>mod</code> in <code>enclosing</code> to a <code>class_type</code>\n"],["upper_bound","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-upper_bound","()",""],["upper_bound=","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-upper_bound-3D","(ubound)",""],["upper_triangular?","Matrix","Matrix.html#method-i-upper_triangular-3F","()","<p>Returns <code>true</code> if this is an upper triangular matrix.\n"],["upto","Date","Date.html#method-i-upto","(p1)","<p>This method is equivalent to step(max, 1){|date| …}.\n"],["upto","Integer","Integer.html#method-i-upto","(p1)","<p>Iterates the given block, passing in integer values from <code>int</code> up to and including <code>limit</code>.\n<p>If no block is …\n"],["upto","String","String.html#method-i-upto","(p1, p2 = v2)","<p>Iterates through successive values, starting at <em>str</em> and ending at <em>other_str</em> inclusive, passing each value …\n"],["uptodate?","Bundler::FileUtils","Bundler/FileUtils.html#method-i-uptodate-3F","(new, old_list)","<p>Returns true if <code>new</code> is newer than all <code>old_list</code>. Non-existent files are older than any file.\n\n<pre>Bundler::FileUtils.uptodate?(&#39;hello.o&#39;, ...</pre>\n"],["uptodate?","Bundler::FileUtils","Bundler/FileUtils.html#method-c-uptodate-3F","(new, old_list)","<p>Returns true if <code>new</code> is newer than all <code>old_list</code>. Non-existent files are older than any file.\n\n<pre>Bundler::FileUtils.uptodate?(&#39;hello.o&#39;, ...</pre>\n"],["uptodate?","FileUtils","FileUtils.html#method-c-uptodate-3F","(new, old_list)","<p>Returns true if <code>new</code> is newer than all <code>old_list</code>. Non-existent files are older than any file.\n\n<pre>FileUtils.uptodate?(&#39;hello.o&#39;, ...</pre>\n"],["uptodate?","FileUtils","FileUtils.html#method-i-uptodate-3F","(new, old_list)","<p>Returns true if <code>new</code> is newer than all <code>old_list</code>. Non-existent files are older than any file.\n\n<pre>FileUtils.uptodate?(&#39;hello.o&#39;, ...</pre>\n"],["urandom","Random","Random.html#method-c-urandom","(p1)","<p>Returns a string, using platform providing features. Returned value is expected to be a cryptographically …\n"],["uri","Bundler::Fetcher","Bundler/Fetcher.html#method-i-uri","()",""],["uri","DRb","DRb.html#method-c-uri","()","<p>Get the URI defining the local dRuby space.\n<p>This is the URI of the current server.  See #current_server …\n"],["uri","DRb","DRb.html#method-i-uri","()","<p>Get the URI defining the local dRuby space.\n<p>This is the URI of the current server.  See #current_server …\n"],["uri=","Bundler::Settings::Mirror","Bundler/Settings/Mirror.html#method-i-uri-3D","(uri)",""],["uri_convert_attr_reader","RSS::BaseModel","RSS/BaseModel.html#method-i-uri_convert_attr_reader","(*attrs)",""],["uri_encode","Gem::Server","Gem/Server.html#method-i-uri_encode","(str)",""],["uri_escaped_with_configured_credentials","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-uri_escaped_with_configured_credentials","()","<p>Escape the URI for git commands\n"],["uri_hash","Bundler::Plugin::API::Source","Bundler/Plugin/API/Source.html#method-i-uri_hash","()",""],["uri_hash","Bundler::Source::Git","Bundler/Source/Git.html#method-i-uri_hash","()",""],["uri_option","DRb::DRbProtocol","DRb/DRbProtocol.html#method-i-uri_option","(uri, config, first=true)","<p>Parse <code>uri</code> into a [uri, option] pair.\n<p>The DRbProtocol module asks each registered protocol in turn to try …\n"],["uri_option","DRb::DRbProtocol","DRb/DRbProtocol.html#method-c-uri_option","(uri, config, first=true)","<p>Parse <code>uri</code> into a [uri, option] pair.\n<p>The DRbProtocol module asks each registered protocol in turn to try …\n"],["uri_parser","Gem::UriParsing","Gem/UriParsing.html#method-i-uri_parser","()",""],["uri_registered?","RSS::BaseListener","RSS/BaseListener.html#method-c-uri_registered-3F","(uri, name)","<p>test if this uri is registered against this name\n"],["url","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-url","(path)",""],["url_encode","ERB::Util","ERB/Util.html#method-i-url_encode","(s)","<p>A utility method for encoding the String <em>s</em> as a URL.\n\n<pre>require &quot;erb&quot;\ninclude ERB::Util\n\nputs url_encode(&quot;Programming ...</pre>\n"],["url_encode","ERB::Util","ERB/Util.html#method-c-url_encode","(s)","<p>A utility method for encoding the String <em>s</em> as a URL.\n\n<pre>require &quot;erb&quot;\ninclude ERB::Util\n\nputs url_encode(&quot;Programming ...</pre>\n"],["urlsafe_base64","Random::Formatter","Random/Formatter.html#method-i-urlsafe_base64","(n=nil, padding=false)","<p>SecureRandom.urlsafe_base64 generates a random URL-safe base64 string.\n<p>The argument <em>n</em> specifies the length, …\n"],["urlsafe_decode64","Base64","Base64.html#method-i-urlsafe_decode64","(str)","<p>Returns the Base64-decoded version of <code>str</code>. This method complies with “Base 64 Encoding with URL and …\n"],["urlsafe_encode64","Base64","Base64.html#method-i-urlsafe_encode64","(bin, padding: true)","<p>Returns the Base64-encoded version of <code>bin</code>. This method complies with “Base 64 Encoding with URL and …\n"],["usage","Gem::Command","Gem/Command.html#method-i-usage","()","<p>Override to display the usage for an individual gem command.\n<p>The text “[options]” is automatically …\n"],["use","Bundler::Index","Bundler/Index.html#method-i-use","(other, override_dupes = false)",""],["use_api","Bundler::Fetcher","Bundler/Fetcher.html#method-i-use_api","()",""],["use_gemdeps","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-use_gemdeps","(gemfile)",""],["use_gemdeps","Gem","Gem.html#method-c-use_gemdeps","(path = nil)","<p>Looks for a gem dependency file at <code>path</code> and activates the gems in the file if found.  If the file is …\n"],["use_headers?","CSV::Parser","CSV/Parser.html#method-i-use_headers-3F","()",""],["use_loader","IRB::Context","IRB/Context.html#method-i-use_loader","()","<p>Returns whether <code>irb</code>&#39;s own file reader method is used by <code>load</code>/<code>require</code> or not.\n<p>This mode is globally …\n"],["use_loader=","IRB::Context","IRB/Context.html#method-i-use_loader-3D","(opt)","<p>Sets <code>IRB.conf[:USE_LOADER]</code>\n<p>See #use_loader for more information.\n"],["use_loader?","IRB::Context","IRB/Context.html#method-i-use_loader-3F","()",""],["use_markup","RDoc::Parser","RDoc/Parser.html#method-c-use_markup","(content)","<p>If there is a <code>markup: parser_name</code> comment at the front of the file, use it to determine the parser.  …\n"],["use_path_completion?","Bundler::Thor::LineEditor::Readline","Bundler/Thor/LineEditor/Readline.html#method-i-use_path_completion-3F","()",""],["use_paths","Gem","Gem.html#method-c-use_paths","(home, *paths)","<p>Use the <code>home</code> and <code>paths</code> values for Gem.dir and Gem.path.  Used mainly by the unit tests to provide environment …\n"],["use_ssl=","Net::HTTP","Net/HTTP.html#method-i-use_ssl-3D","(flag)","<p>Turn on/off SSL. This flag must be set before starting session. If you change use_ssl value after session …\n"],["use_ssl?","Net::HTTP","Net/HTTP.html#method-i-use_ssl-3F","()","<p>Returns true if SSL/TLS is being used with HTTP.\n"],["use_ssl?","Net::POP3","Net/POP3.html#method-i-use_ssl-3F","()","<p>does this instance use SSL?\n"],["use_ssl?","Net::POP3","Net/POP3.html#method-c-use_ssl-3F","()","<p>returns <code>true</code> if POP3.ssl_params is set\n"],["use_system_gems?","Bundler","Bundler.html#method-c-use_system_gems-3F","()",""],["use_tracer=","IRB::Context","IRB/Context.html#method-i-use_tracer-3D","(opt)",""],["use_ui","Gem::DefaultUserInteraction","Gem/DefaultUserInteraction.html#method-c-use_ui","(new_ui)","<p>Use <code>new_ui</code> for the duration of <code>block</code>.\n"],["use_ui","Gem::DefaultUserInteraction","Gem/DefaultUserInteraction.html#method-i-use_ui","(new_ui, &block)","<p>See DefaultUserInteraction::use_ui\n"],["usec","Time","Time.html#method-i-usec","()","<p>Returns the number of microseconds for <em>time</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>        <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:03:26 -0600</span>\n<span class=\"ruby-string\">&quot;%10.6f&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["used_modules","Module","Module.html#method-c-used_modules","()","<p>Returns an array of all modules used in the current scope. The ordering of modules in the resulting array …\n"],["useless=","Racc::Rule","Racc/Rule.html#method-i-useless-3D","(u)",""],["useless=","Racc::Sym","Racc/Sym.html#method-i-useless-3D","(f)",""],["useless?","Racc::Rule","Racc/Rule.html#method-i-useless-3F","()",""],["useless?","Racc::Sym","Racc/Sym.html#method-i-useless-3F","()",""],["useless_nonterminal_exist?","Racc::Grammar","Racc/Grammar.html#method-i-useless_nonterminal_exist-3F","()",""],["useless_rule_exist?","Racc::Grammar","Racc/Grammar.html#method-i-useless_rule_exist-3F","()",""],["user","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-user","()","<p>Returns the user component.\n"],["user","URI::Generic","URI/Generic.html#method-i-user","()","<p>Returns the user component.\n"],["user=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-user-3D","(user)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["user=","URI::Generic","URI/Generic.html#method-i-user-3D","(user)","<p>Args\n<p><code>v</code> &mdash; String\n\n<p>Description\n"],["user_agent","Bundler::Fetcher","Bundler/Fetcher.html#method-i-user_agent","()",""],["user_agent","Gem::Request","Gem/Request.html#method-i-user_agent","()",""],["user_bundle_path","Bundler","Bundler.html#method-c-user_bundle_path","(dir = \"home\")",""],["user_cache","Bundler","Bundler.html#method-c-user_cache","()",""],["user_dir","Gem","Gem.html#method-c-user_dir","()","<p>Path for gems in the user&#39;s home directory\n"],["user_home","Bundler","Bundler.html#method-c-user_home","()",""],["user_home","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-user_home","()",""],["user_home","Bundler::Thor::Util","Bundler/Thor/Util.html#method-c-user_home","()",""],["user_home","Gem","Gem.html#method-c-user_home","()","<p>The home directory for the user.\n"],["userinfo","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-userinfo","()","<p>Returns the userinfo, either as &#39;user&#39; or &#39;user:password&#39;.\n"],["userinfo","URI::Generic","URI/Generic.html#method-i-userinfo","()","<p>Returns the userinfo, either as &#39;user&#39; or &#39;user:password&#39;.\n"],["userinfo=","Bundler::URI::Generic","Bundler/URI/Generic.html#method-i-userinfo-3D","(userinfo)","<p>Sets userinfo, argument is string like &#39;name:pass&#39;.\n"],["userinfo=","URI::Generic","URI/Generic.html#method-i-userinfo-3D","(userinfo)","<p>Sets userinfo, argument is string like &#39;name:pass&#39;.\n"],["using","Module","Module.html#method-i-using","(p1)","<p>Import class refinements from <em>module</em> into the current class or module definition.\n"],["using_anon_cipher?","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-using_anon_cipher-3F","()",""],["utc","Time","Time.html#method-c-utc","(*args)","<p>Creates a Time object based on given values, interpreted as UTC (GMT). The year must be specified. Other …\n"],["utc","Time","Time.html#method-i-utc","()","<p>Converts <em>time</em> to UTC (GMT), modifying the receiver.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:18:31 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">gmt?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["utc?","Time","Time.html#method-i-utc-3F","()","<p>Returns <code>true</code> if <em>time</em> represents a time in UTC (GMT).\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>                        <span class=\"ruby-comment\">#=&gt; 2007-11-19 ...</span>\n</pre>\n"],["utc_offset","Time","Time.html#method-i-utc_offset","()","<p>Returns the offset in seconds between the timezone of <em>time</em> and UTC.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">gm</span>(<span class=\"ruby-value\">2000</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">20</span>,<span class=\"ruby-value\">15</span>,<span class=\"ruby-value\">1</span>)   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["util_build_gem","Gem::TestCase","Gem/TestCase.html#method-i-util_build_gem","(spec)","<p>Builds a gem from <code>spec</code> and places it in <code>File.join @gemhome, &#39;cache&#39;</code>.  Automatically creates files …\n"],["util_clear_RUBY_VERSION","Gem::TestCase","Gem/TestCase.html#method-i-util_clear_RUBY_VERSION","()",""],["util_clear_gems","Gem::TestCase","Gem/TestCase.html#method-i-util_clear_gems","()","<p>Removes all installed gems from +@gemhome+.\n"],["util_dir_entry","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-util_dir_entry","()",""],["util_entry","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-util_entry","(tar)",""],["util_gem","Gem::TestCase","Gem/TestCase.html#method-i-util_gem","(name, version, deps = nil, &block)","<p>Creates a gem with <code>name</code>, <code>version</code> and <code>deps</code>.  The specification will be yielded before gem creation for …\n"],["util_gzip","Gem::TestCase","Gem/TestCase.html#method-i-util_gzip","(data)","<p>Gzips <code>data</code>.\n"],["util_inst_bindir","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-util_inst_bindir","()","<p>The path where installed executables live\n"],["util_installer","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-util_installer","(spec, gem_home, user=false)","<p>Creates an installer for <code>spec</code> that will install into <code>gem_home</code>.  If <code>user</code> is true a user-install will be …\n"],["util_make_exec","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-util_make_exec","(spec = @spec, shebang = \"#!/usr/bin/ruby\", bindir = \"bin\")","<p>Adds an executable named “executable” to <code>spec</code> with the given <code>shebang</code>.\n<p>The executable is also …\n"],["util_make_gems","Gem::TestCase","Gem/TestCase.html#method-i-util_make_gems","(prerelease = false)","<p>Creates several default gems which all have a lib/code.rb file.  The gems are not installed but are available …\n"],["util_remove_gem","Gem::TestCase","Gem/TestCase.html#method-i-util_remove_gem","(spec)",""],["util_restore_RUBY_VERSION","Gem::TestCase","Gem/TestCase.html#method-i-util_restore_RUBY_VERSION","()",""],["util_set_RUBY_VERSION","Gem::TestCase","Gem/TestCase.html#method-i-util_set_RUBY_VERSION","(version, patchlevel = nil, revision = nil, description = nil, engine = \"ruby\", engine_version = nil)",""],["util_set_arch","Gem::TestCase","Gem/TestCase.html#method-i-util_set_arch","(arch)","<p>Set the platform to <code>arch</code>\n"],["util_setup_gem","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-util_setup_gem","(ui = @ui)","<p>Builds the @spec gem and returns an installer for it.  The built gem includes:\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">bin</span><span class=\"ruby-operator\">/</span><span class=\"ruby-identifier\">executable</span>\n<span class=\"ruby-identifier\">lib</span><span class=\"ruby-operator\">/</span><span class=\"ruby-identifier\">code</span>.<span class=\"ruby-identifier\">rb</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["util_setup_installer","Gem::InstallerTestCase","Gem/InstallerTestCase.html#method-i-util_setup_installer","()","<p>Sets up the base @gem, builds it and returns an installer for it.\n"],["util_setup_spec_fetcher","Gem::TestCase","Gem/TestCase.html#method-i-util_setup_spec_fetcher","(*specs)","<p>Sets up Gem::SpecFetcher to return information from the gems in <code>specs</code>.\n"],["util_spec","Gem::TestCase","Gem/TestCase.html#method-i-util_spec","(name, version = 2, deps = nil, *files)","<p>Creates a spec with <code>name</code>, <code>version</code>.  <code>deps</code> can specify the dependency or a <code>block</code> can be given for full …\n"],["util_symlink_entry","Gem::Package::TarTestCase","Gem/Package/TarTestCase.html#method-i-util_symlink_entry","()",""],["util_zip","Gem::TestCase","Gem/TestCase.html#method-i-util_zip","(data)","<p>Deflates <code>data</code>\n"],["utime","File","File.html#method-c-utime","(*args)","<p>Sets the access and modification times of each named file to the first two arguments. If a file is a …\n"],["utime","Pathname","Pathname.html#method-i-utime","(p1, p2)","<p>Update the access and modification times of the file.\n<p>See File.utime.\n"],["uuid","Random::Formatter","Random/Formatter.html#method-i-uuid","()","<p>SecureRandom.uuid generates a random v4 UUID (Universally Unique IDentifier).\n\n<pre>require &#39;securerandom&#39;\n ...</pre>\n"],["v","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-v","()",""],["v_inv","Matrix::EigenvalueDecomposition","Matrix/EigenvalueDecomposition.html#method-i-v_inv","()",""],["valid?","Bundler::Settings::Mirror","Bundler/Settings/Mirror.html#method-i-valid-3F","()",""],["valid?","RSS::Element","RSS/Element.html#method-i-valid-3F","(ignore_unknown_element=true)",""],["valid_civil?","Date","Date.html#method-c-valid_civil-3F","(p1, p2, p3, p4 = v4)","<p>Returns true if the given calendar date is valid, and false if not. Valid in this context is whether …\n"],["valid_commercial?","Date","Date.html#method-c-valid_commercial-3F","(p1, p2, p3, p4 = v4)","<p>Returns true if the given week date is valid, and false if not.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">valid_commercial?</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">5</span>,<span class=\"ruby-value\">6</span>)  <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["valid_date?","Date","Date.html#method-c-valid_date-3F","(p1, p2, p3, p4 = v4)","<p>Returns true if the given calendar date is valid, and false if not. Valid in this context is whether …\n"],["valid_email?","Gem::Commands::CertCommand","Gem/Commands/CertCommand.html#method-i-valid_email-3F","(email)",""],["valid_encoding?","String","String.html#method-i-valid_encoding-3F","()","<p>Returns true for a string which is encoded correctly.\n\n<pre class=\"ruby\"><span class=\"ruby-string\">&quot;\\xc2\\xa1&quot;</span>.<span class=\"ruby-identifier\">force_encoding</span>(<span class=\"ruby-string\">&quot;UTF-8&quot;</span>).<span class=\"ruby-identifier\">valid_encoding?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["valid_for?","Bundler::SpecSet","Bundler/SpecSet.html#method-i-valid_for-3F","(deps)",""],["valid_jd?","Date","Date.html#method-c-valid_jd-3F","(p1, p2 = v2)","<p>Just returns true.  It&#39;s nonsense, but is for symmetry.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">valid_jd?</span>(<span class=\"ruby-value\">2451944</span>)           <span class=\"ruby-comment\">#=&gt; true</span>\n</pre>\n"],["valid_keys","Bundler::Dsl","Bundler/Dsl.html#method-i-valid_keys","()",""],["valid_mod_sequence_value?","Net::IMAP::NumValidator","Net/IMAP/NumValidator.html#method-c-valid_mod_sequence_value-3F","(num)","<p>Check is passed argument valid &#39;mod_sequence_value&#39; in RFC 4551 terminology\n"],["valid_number?","Net::IMAP::NumValidator","Net/IMAP/NumValidator.html#method-c-valid_number-3F","(num)","<p>Check is passed argument valid &#39;number&#39; in RFC 3501 terminology\n"],["valid_nz_number?","Net::IMAP::NumValidator","Net/IMAP/NumValidator.html#method-c-valid_nz_number-3F","(num)","<p>Check is passed argument valid &#39;nz_number&#39; in RFC 3501 terminology\n"],["valid_ordinal?","Date","Date.html#method-c-valid_ordinal-3F","(p1, p2, p3 = v3)","<p>Returns true if the given ordinal date is valid, and false if not.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">valid_ordinal?</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">34</span>)      <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["valid_v6?","IPSocket","IPSocket.html#method-c-valid_v6-3F","(addr)",""],["validate","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-validate","(spec)",""],["validate","Gem::Specification","Gem/Specification.html#method-i-validate","(packaging = true, strict = false)","<p>Checks that the specification contains all required fields, and does a very basic sanity check.\n<p>Raises …\n"],["validate","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate","(strict = false)","<p>Checks that the specification contains all required fields, and does a very basic sanity check.\n<p>Raises …\n"],["validate","REXML::Validation::Validator","REXML/Validation/Validator.html#method-i-validate","( event )",""],["validate","RSS::Element","RSS/Element.html#method-i-validate","(ignore_unknown_element=true)",""],["validate!","Bundler::Settings","Bundler/Settings.html#method-i-validate-21","()",""],["validate!","Bundler::Settings::Mirror","Bundler/Settings/Mirror.html#method-i-validate-21","(probe = nil)",""],["validate!","Bundler::Settings::Validator","Bundler/Settings/Validator.html#method-c-validate-21","(key, value, settings)",""],["validate!","Bundler::Settings::Validator::Rule","Bundler/Settings/Validator/Rule.html#method-i-validate-21","(key, value, settings)",""],["validate_array_attribute","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_array_attribute","(field)",""],["validate_array_attributes","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_array_attributes","()",""],["validate_attribute","RSS::Element","RSS/Element.html#method-i-validate_attribute","()",""],["validate_attribute_present","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_attribute_present","(attribute)",""],["validate_authors_field","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_authors_field","()",""],["validate_bundle_path","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-validate_bundle_path","()",""],["validate_bundler_checksum","Bundler::RubyGemsGemInstaller","Bundler/RubyGemsGemInstaller.html#method-i-validate_bundler_checksum","(checksum)",""],["validate_cmd!","Bundler::CLI::Exec","Bundler/CLI/Exec.html#method-i-validate_cmd-21","()",""],["validate_data","Net::IMAP","Net/IMAP.html#method-i-validate_data","(data)",""],["validate_dependencies","Gem::Specification","Gem/Specification.html#method-i-validate_dependencies","()","<p>Checks that dependencies use requirements as we recommend.  Warnings are issued when dependencies are …\n"],["validate_duplicate_links","RSS::Atom::DuplicateLinkChecker","RSS/Atom/DuplicateLinkChecker.html#method-i-validate_duplicate_links","(links)","<p>Checks if there are duplicate links with the same type and hreflang attributes that have an alternate …\n"],["validate_ext_name","Bundler::CLI::Gem","Bundler/CLI/Gem.html#method-i-validate_ext_name","()",""],["validate_for_stream","RSS::Element","RSS/Element.html#method-i-validate_for_stream","(tags, ignore_unknown_element=true)",""],["validate_keys","Bundler::Dsl","Bundler/Dsl.html#method-i-validate_keys","(command, opts, valid_keys)",""],["validate_lazy_metadata","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_lazy_metadata","()",""],["validate_licenses","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_licenses","()",""],["validate_line","Net::SMTP","Net/SMTP.html#method-i-validate_line","(line)",""],["validate_metadata","Gem::Specification","Gem/Specification.html#method-i-validate_metadata","()",""],["validate_metadata","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_metadata","()","<p>Implementation for Specification#validate_metadata\n"],["validate_name","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_name","()",""],["validate_nil_attributes","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_nil_attributes","()",""],["validate_non_files","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_non_files","()",""],["validate_one_tag_name","RSS::ImageModelUtils","RSS/ImageModelUtils.html#method-i-validate_one_tag_name","(ignore_unknown_element, name, tags)",""],["validate_options!","Bundler::CLI::Add","Bundler/CLI/Add.html#method-i-validate_options-21","()",""],["validate_permissions","Gem::Specification","Gem/Specification.html#method-i-validate_permissions","()","<p>Checks to see if the files to be packaged are world-readable.\n"],["validate_permissions","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_permissions","()","<p>Issues a warning for each file to be packaged which is world-readable.\n<p>Implementation for Specification#validate_permissions …\n"],["validate_platform","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_platform","()",""],["validate_platforms!","Bundler::Definition","Bundler/Definition.html#method-i-validate_platforms-21","()",""],["validate_plugin!","Bundler::Plugin","Bundler/Plugin.html#method-i-validate_plugin-21","(plugin_path)","<p>Checks if the gem is good to be a plugin\n<p>At present it only checks whether it contains plugins.rb file …\n"],["validate_require_paths","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_require_paths","()",""],["validate_required_attributes","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_required_attributes","()",""],["validate_resolved_specs!","Bundler::Resolver","Bundler/Resolver.html#method-i-validate_resolved_specs-21","(resolved_specs)",""],["validate_ruby!","Bundler::Definition","Bundler/Definition.html#method-i-validate_ruby-21","()",""],["validate_rubygems_version","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_rubygems_version","()",""],["validate_runtime!","Bundler::Definition","Bundler/Definition.html#method-i-validate_runtime-21","()",""],["validate_scope!","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-validate_scope-21","()",""],["validate_self_inclusion_in_files_list","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_self_inclusion_in_files_list","()",""],["validate_shebang_line_in","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_shebang_line_in","(executable)",""],["validate_spec","Bundler::Source::Git","Bundler/Source/Git.html#method-i-validate_spec","(_spec)","<p>no-op, since we validate when re-serializing the gemspec\n"],["validate_spec","Bundler::Source::Path","Bundler/Source/Path.html#method-i-validate_spec","(spec)",""],["validate_specification_version","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_specification_version","()",""],["validate_uri_scheme!","Bundler::Fetcher::Downloader","Bundler/Fetcher/Downloader.html#method-i-validate_uri_scheme-21","(uri)",""],["validate_values","Gem::SpecificationPolicy","Gem/SpecificationPolicy.html#method-i-validate_values","()",""],["value","CGI::Cookie","CGI/Cookie.html#method-i-value","()","<p>Returns the value or list of values for this cookie.\n"],["value","Fiddle::Importer","Fiddle/Importer.html#method-i-value","(ty, val=nil)",""],["value","Net::HTTPResponse","Net/HTTPResponse.html#method-i-value","()","<p>Raises an HTTP error if the response is not 2xx (success).\n"],["value","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-i-value","()",""],["value","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-value","()",""],["value","REXML::Attribute","REXML/Attribute.html#method-i-value","()","<p>Returns the UNNORMALIZED value of this attribute.  That is, entities have been expanded to their values …\n"],["value","REXML::CData","REXML/CData.html#method-i-value","()",""],["value","REXML::Entity","REXML/Entity.html#method-i-value","()","<p>Returns the value of this entity.  At the moment, only internal entities are processed.  If the value …\n"],["value","REXML::Text","REXML/Text.html#method-i-value","()","<p>Returns the string value of this text.  This is the text without entities, as it might be used programmatically, …\n"],["value","Rinda::Tuple","Rinda/Tuple.html#method-i-value","()","<p>Return the tuple itself\n"],["value","Rinda::TupleEntry","Rinda/TupleEntry.html#method-i-value","()","<p>Return the object which makes up the tuple itself: the Array or Hash.\n"],["value","Thread","Thread.html#method-i-value","()","<p>Waits for <code>thr</code> to complete, using #join, and returns its value or raises the exception which terminated …\n"],["value","UncaughtThrowError","UncaughtThrowError.html#method-i-value","()","<p>Return the return value which was called for.\n"],["value","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-value","()","<p>Returns value if value is exists. If the value does not exist, this method returns nil.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["value","WIN32OLE_VARIANT","WIN32OLE_VARIANT.html#method-i-value","()","<p>Returns Ruby object value from OLE variant.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">obj</span> = <span class=\"ruby-constant\">WIN32OLE_VARIANT</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">1</span>, <span class=\"ruby-constant\">WIN32OLE</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">VARIANT</span><span class=\"ruby-operator\">::</span><span class=\"ruby-constant\">VT_BSTR</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["value=","CGI::Cookie","CGI/Cookie.html#method-i-value-3D","(val)","<p>Replaces the value of this cookie with a new value or list of values.\n"],["value=","OpenSSL::X509::Attribute","OpenSSL/X509/Attribute.html#method-i-value-3D","(p1)",""],["value=","OpenSSL::X509::Extension","OpenSSL/X509/Extension.html#method-i-value-3D","(p1)",""],["value=","REXML::Text","REXML/Text.html#method-i-value-3D","( val )","<p>Sets the contents of this text node.  This expects the text to be unnormalized.  It returns self.\n\n<pre>e = ...</pre>\n"],["value=","RSS::ITunesItemModel::ITunesDuration","RSS/ITunesItemModel/ITunesDuration.html#method-i-value-3D","(value)",""],["value=","WIN32OLE_VARIANT","WIN32OLE_VARIANT.html#method-i-value-3D","(p1)","<p>Sets variant value to val. If the val type does not match variant value type(vartype), then val is changed …\n"],["value?","DBM","DBM.html#method-i-value-3F","(p1)","<p>Returns true if the database contains the specified string value, false otherwise.\n"],["value?","ENV","ENV.html#method-c-value-3F","(p1)","<p>Returns <code>true</code> if there is an environment variable with the given <code>value</code>.\n"],["value?","GDBM","GDBM.html#method-i-value-3F","(p1)","<p>Returns true if the given value <em>v</em> exists within the database. Returns false otherwise.\n"],["value?","Hash","Hash.html#method-i-value-3F","(p1)","<p>Returns <code>true</code> if the given value is present for some key in <em>hsh</em>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">h</span> = { <span class=\"ruby-string\">&quot;a&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">100</span>, <span class=\"ruby-string\">&quot;b&quot;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-value\">200</span> }\n<span class=\"ruby-identifier\">h</span>.<span class=\"ruby-identifier\">value?</span>(<span class=\"ruby-value\">100</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["value?","SDBM","SDBM.html#method-i-value-3F","(p1)","<p>Returns <code>true</code> if the database contains the given <code>value</code>.\n"],["value_type","REXML::XPathParser","REXML/XPathParser.html#method-i-value_type","(value)",""],["values","Bundler::Thor::CoreExt::OrderedHash","Bundler/Thor/CoreExt/OrderedHash.html#method-i-values","()",""],["values","DBM","DBM.html#method-i-values","()","<p>Returns an array of all the string values in the database.\n"],["values","ENV","ENV.html#method-c-values","()","<p>Returns all environment variable values in an Array:\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">replace</span>(<span class=\"ruby-string\">&#39;foo&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;0&#39;</span>, <span class=\"ruby-string\">&#39;bar&#39;</span> <span class=\"ruby-operator\">=&gt;</span> <span class=\"ruby-string\">&#39;1&#39;</span>)\n<span class=\"ruby-constant\">ENV</span>.<span class=\"ruby-identifier\">values</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["values","GDBM","GDBM.html#method-i-values","()","<p>Returns an array of all values of this database.\n"],["values","Hash","Hash.html#method-i-values","()","<p>Returns a new array populated with the values from <em>hsh</em>. See also Hash#keys.\n\n<pre>h = { &quot;a&quot; =&gt; 100, &quot;b&quot; =&gt; 200, ...</pre>\n"],["values","ObjectSpace::WeakMap","ObjectSpace/WeakMap.html#method-i-values","()","<p>Iterates over values and objects in a weakly referenced object\n"],["values","SDBM","SDBM.html#method-i-values","()","<p>Returns a new Array containing the values in the database.\n"],["values","Struct","Struct.html#method-i-values","()","<p>Returns the values for this struct as an Array.\n\n<pre>Customer = Struct.new(:name, :address, :zip)\njoe = Customer.new(&quot;Joe ...</pre>\n"],["values","YAML::DBM","YAML/DBM.html#method-i-values","()","<p>Returns an array of values from the database.\n"],["values_at","Array","Array.html#method-i-values_at","(*args)","<p>Returns an array containing the elements in <code>self</code> corresponding to the given <code>selector</code>(s).\n<p>The selectors …\n"],["values_at","CSV::Row","CSV/Row.html#method-i-values_at","(*headers_and_or_indices)",""],["values_at","CSV::Table","CSV/Table.html#method-i-values_at","(*indices_or_headers)","<p>The mixed mode default is to treat a list of indices as row access, returning the rows indicated. Anything …\n"],["values_at","DBM","DBM.html#method-i-values_at","(*args)","<p>Returns an array containing the values associated with the given keys.\n"],["values_at","ENV","ENV.html#method-c-values_at","(*args)","<p>Returns an array containing the environment variable values associated with the given names.  See also …\n"],["values_at","GDBM","GDBM.html#method-i-values_at","(*args)","<p>Returns an array of the values associated with each specified <em>key</em>.\n"],["values_at","Hash","Hash.html#method-i-values_at","(*args)","<p>Return an array containing the values associated with the given keys. Also see Hash.select.\n\n<pre>h = { &quot;cat&quot; ...</pre>\n"],["values_at","MatchData","MatchData.html#method-i-values_at","(*args)","<p>Uses each <em>index</em> to access the matching values, returning an array of the corresponding matches.\n\n<pre>m = /(.)(.)(\\d+)(\\d)/.match(&quot;THX1138: ...</pre>\n"],["values_at","SDBM","SDBM.html#method-i-values_at","(*args)","<p>Returns an Array of values corresponding to the given keys.\n"],["values_at","StringScanner","StringScanner.html#method-i-values_at","(*args)","<p>Returns the subgroups in the most recent match at the given indices. If nothing was priorly matched, …\n"],["values_at","Struct","Struct.html#method-i-values_at","(*args)","<p>Returns the struct member values for each <code>selector</code> as an Array.  A <code>selector</code> may be either an Integer …\n"],["values_at","YAML::DBM","YAML/DBM.html#method-i-values_at","( *keys )","<p>Returns an array containing the values associated with the given keys.\n"],["variable_is_set?","RSS::Maker::Atom::Entry::Items::Item","RSS/Maker/Atom/Entry/Items/Item.html#method-i-variable_is_set-3F","()",""],["variable_is_set?","RSS::Maker::Atom::Feed::Channel","RSS/Maker/Atom/Feed/Channel.html#method-i-variable_is_set-3F","()",""],["variable_is_set?","RSS::Maker::Base","RSS/Maker/Base.html#method-i-variable_is_set-3F","()",""],["variable_kind","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-variable_kind","()","<p>Returns variable kind string.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;XlSheetType&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["variables","REXML::Functions","REXML/Functions.html#method-c-variables","()",""],["variables","RSS::Maker::Atom::Entry::Items::Item","RSS/Maker/Atom/Entry/Items/Item.html#method-i-variables","()",""],["variables","RSS::Maker::Atom::Feed::Channel","RSS/Maker/Atom/Feed/Channel.html#method-i-variables","()",""],["variables","RSS::Maker::Atom::Feed::Items::Item","RSS/Maker/Atom/Feed/Items/Item.html#method-i-variables","()",""],["variables","RSS::Maker::Atom::Feed::Items::Item::Content","RSS/Maker/Atom/Feed/Items/Item/Content.html#method-i-variables","()",""],["variables","RSS::Maker::Atom::Feed::Items::Item::Source","RSS/Maker/Atom/Feed/Items/Item/Source.html#method-i-variables","()",""],["variables","RSS::Maker::AtomCategory","RSS/Maker/AtomCategory.html#method-i-variables","()",""],["variables","RSS::Maker::AtomTextConstruct","RSS/Maker/AtomTextConstruct.html#method-i-variables","()",""],["variables","RSS::Maker::Base","RSS/Maker/Base.html#method-i-variables","()",""],["variables","RSS::Maker::RSS09::Channel","RSS/Maker/RSS09/Channel.html#method-i-variables","()",""],["variables","RSS::Maker::RSS10::Image","RSS/Maker/RSS10/Image.html#method-i-variables","()",""],["variables","RSS::Maker::RSS10::Items::Item","RSS/Maker/RSS10/Items/Item.html#method-i-variables","()",""],["variables","RSS::Maker::RSS20::Items::Item","RSS/Maker/RSS20/Items/Item.html#method-i-variables","()",""],["variables","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-variables","()","<p>Returns array of WIN32OLE_VARIABLE objects which represent variables defined in OLE class.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft ...</pre>\n"],["variables=","REXML::Functions","REXML/Functions.html#method-c-variables-3D","(x)",""],["variables=","REXML::XPathParser","REXML/XPathParser.html#method-i-variables-3D","( vars={} )",""],["varkind","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-varkind","()","<p>Returns the number which represents variable kind.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object ...</pre>\n"],["vartype","WIN32OLE_VARIANT","WIN32OLE_VARIANT.html#method-i-vartype","()","<p>Returns OLE variant type.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">obj</span> = <span class=\"ruby-constant\">WIN32OLE_VARIANT</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&quot;string&quot;</span>)\n<span class=\"ruby-identifier\">obj</span>.<span class=\"ruby-identifier\">vartype</span> <span class=\"ruby-comment\"># =&gt; WIN32OLE::VARIANT::VT_BSTR</span>\n</pre>\n"],["vc_windows?","Gem::TestCase","Gem/TestCase.html#method-c-vc_windows-3F","()","<p>Returns whether or not we&#39;re on a version of Ruby built with VC++ (or Borland) versus Cygwin, Mingw …\n"],["vc_windows?","Gem::TestCase","Gem/TestCase.html#method-i-vc_windows-3F","()","<p>Returns whether or not we&#39;re on a version of Ruby built with VC++ (or Borland) versus Cygwin, Mingw …\n"],["vendordir","Gem::TestCase","Gem/TestCase.html#method-i-vendordir","(value)","<p>Sets the vendordir entry in RbConfig::CONFIG to <code>value</code> and restores the original value when the block …\n"],["ver","OptionParser","OptionParser.html#method-i-ver","()","<p>Returns version string from program_name, version and release.\n"],["verbose","DRb::DRbServer","DRb/DRbServer.html#method-i-verbose","()","<p>Get whether the server is in verbose mode.\n<p>In verbose mode, failed calls are logged to stdout.\n"],["verbose","DRb::DRbServer","DRb/DRbServer.html#method-c-verbose","()","<p>Get the default value of the :verbose option.\n"],["verbose","Gem::UserInteraction","Gem/UserInteraction.html#method-i-verbose","(msg = nil)","<p>Calls <code>say</code> with <code>msg</code> or the results of the block if really_verbose is true.\n"],["verbose=","DRb::DRbServer","DRb/DRbServer.html#method-c-verbose-3D","(on)","<p>Set the default value of the :verbose option.\n<p>See #new().  The initial default value is false.\n"],["verbose=","DRb::DRbServer","DRb/DRbServer.html#method-i-verbose-3D","(v)","<p>Set whether to operate in verbose mode.\n<p>In verbose mode, failed calls are logged to stdout.\n"],["verbose?","IRB::Context","IRB/Context.html#method-i-verbose-3F","()","<p>Returns whether messages are displayed or not.\n"],["verify","Gem::Package","Gem/Package.html#method-i-verify","()","<p>Verifies that this gem:\n<p>Contains a valid gem specification\n<p>Contains a contents archive\n"],["verify","Gem::Package::Old","Gem/Package/Old.html#method-i-verify","()","<p>Raises an exception if a security policy that verifies data is active. Old format gems cannot be verified …\n"],["verify","Gem::Security::Policy","Gem/Security/Policy.html#method-i-verify","(chain, key = nil, digests = {}, signatures = {}, full_name = '(unknown)')","<p>For <code>full_name</code>, verifies the certificate <code>chain</code> is valid, the <code>digests</code> match the signatures <code>signatures</code> created …\n"],["verify","Gem::Security::TrustDir","Gem/Security/TrustDir.html#method-i-verify","()","<p>Make sure the trust directory exists.  If it does exist, make sure it&#39;s actually a directory.  If …\n"],["verify","Net::POP3","Net/POP3.html#method-c-verify","()","<p>returns whether verify_mode is enable from POP3.ssl_params\n"],["verify","OpenSSL::Netscape::SPKI","OpenSSL/Netscape/SPKI.html#method-i-verify","(p1)","<p>Parameters\n<p><em>key</em> - the public key to be used for verifying the SPKI signature\n\n<p>Returns <code>true</code> if the signature …\n"],["verify","OpenSSL::OCSP::BasicResponse","OpenSSL/OCSP/BasicResponse.html#method-i-verify","(p1, p2, p3 = v3)","<p>Verifies the signature of the response using the given <em>certificates</em> and <em>store</em>. This works in the similar …\n"],["verify","OpenSSL::OCSP::Request","OpenSSL/OCSP/Request.html#method-i-verify","(p1, p2, p3 = v3)","<p>Verifies this request using the given <em>certificates</em> and <em>store</em>. <em>certificates</em> is an array of OpenSSL::X509::Certificate …\n"],["verify","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-i-verify","(p1, p2, p3 = v3, p4 = v4)",""],["verify","OpenSSL::PKey::PKey","OpenSSL/PKey/PKey.html#method-i-verify","(p1, p2, p3)","<p>To verify the String <em>signature</em>, <em>digest</em>, an instance of OpenSSL::Digest, must be provided to re-compute …\n"],["verify","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-verify","(p1)",""],["verify","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-verify","(p1)","<p>Verifies the signature of the certificate, with the public key <em>key</em>. <em>key</em> must be an instance of OpenSSL::PKey …\n"],["verify","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-verify","(p1)","<p>Checks that cert signature is made with PRIVversion of this PUBLIC &#39;key&#39;\n"],["verify","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-verify","(p1, p2 = v2)","<p>Performs a certificate verification on the OpenSSL::X509::Certificate <em>cert</em>.\n<p><em>chain</em> can be an array of  …\n"],["verify","OpenSSL::X509::StoreContext","OpenSSL/X509/StoreContext.html#method-i-verify","()",""],["verify_api_key","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-verify_api_key","(key)","<p>Retrieves the pre-configured API key <code>key</code> or terminates interaction with an error.\n"],["verify_callback=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-verify_callback-3D","(callback)","<p>SSL verification callback.\n"],["verify_callback=","OpenSSL::X509::Store","OpenSSL/X509/Store.html#method-i-verify_callback-3D","(p1)","<p>General callback for OpenSSL verify\n"],["verify_certificate","Gem::Request","Gem/Request.html#method-c-verify_certificate","(store_context)",""],["verify_certificate_identity","OpenSSL::SSL","OpenSSL/SSL.html#method-i-verify_certificate_identity","(cert, hostname)",""],["verify_certificate_identity","OpenSSL::SSL","OpenSSL/SSL.html#method-c-verify_certificate_identity","(cert, hostname)",""],["verify_certificate_message","Gem::Request","Gem/Request.html#method-c-verify_certificate_message","(error_number, cert)",""],["verify_compaction_references","GC","GC.html#method-c-verify_compaction_references","(p1 = {})","<p>Verify compaction reference consistency.\n<p>This method is implementation specific.  During compaction, objects …\n"],["verify_depth=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-verify_depth-3D","(verify_depth)","<p>Sets the depth of SSL certificate verification\n"],["verify_entry","Gem::Package","Gem/Package.html#method-i-verify_entry","(entry)","<p>Verifies <code>entry</code> in a .gem file.\n"],["verify_files","Gem::Package","Gem/Package.html#method-i-verify_files","(gem)","<p>Verifies the files of the <code>gem</code>\n"],["verify_gemfile_dependencies_are_found!","Bundler::Resolver","Bundler/Resolver.html#method-i-verify_gemfile_dependencies_are_found-21","(requirements)",""],["verify_group_exists","Bundler::CLI::List","Bundler/CLI/List.html#method-i-verify_group_exists","(groups)",""],["verify_internal_consistency","GC","GC.html#method-c-verify_internal_consistency","()","<p>Verify internal consistency.\n<p>This method is implementation specific. Now this method checks generational …\n"],["verify_mode=","Bundler::Persistent::Net::HTTP::Persistent","Bundler/Persistent/Net/HTTP/Persistent.html#method-i-verify_mode-3D","(verify_mode)","<p>Sets the HTTPS verify mode.  Defaults to OpenSSL::SSL::VERIFY_PEER.\n<p>Setting this to VERIFY_NONE is a  …\n"],["verify_pss","OpenSSL::PKey::RSA","OpenSSL/PKey/RSA.html#method-i-verify_pss","(p1, p2, p3, p4 = {})","<p>Verifies <em>data</em> using the Probabilistic Signature Scheme (RSA-PSS).\n<p>The return value is <code>true</code> if the signature …\n"],["verify_result","OpenSSL::SSL::SSLSocket","OpenSSL/SSL/SSLSocket.html#method-i-verify_result","()","<p>Returns the result of the peer certificates verification.  See verify(1) for error values and descriptions. …\n"],["verify_signatures","Gem::Security::Policy","Gem/Security/Policy.html#method-i-verify_signatures","(spec, digests, signatures)","<p>Extracts the certificate chain from the <code>spec</code> and calls #verify to ensure the signatures and certificate …\n"],["verify_spec","Gem::Installer","Gem/Installer.html#method-i-verify_spec","()",""],["verify_transient_heap_internal_consistency","GC","GC.html#method-c-verify_transient_heap_internal_consistency","()",""],["version","Bundler::CLI","Bundler/CLI.html#method-i-version","()",""],["version","Bundler::GemHelper","Bundler/GemHelper.html#method-i-version","()",""],["version","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-c-version","()",""],["version","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-version","()",""],["version","Bundler::Source::Git::GitProxy","Bundler/Source/Git/GitProxy.html#method-i-version","()",""],["version","ERB","ERB.html#method-c-version","()","<p>Returns revision information for the erb.rb module.\n"],["version","Gem::BasicSpecification","Gem/BasicSpecification.html#method-i-version","()","<p>Version of the gem\n"],["version","Gem::Resolver::ActivationRequest","Gem/Resolver/ActivationRequest.html#method-i-version","()","<p>The version of this activation request&#39;s specification\n"],["version","Gem::Resolver::SpecSpecification","Gem/Resolver/SpecSpecification.html#method-i-version","()","<p>The version of the gem for this specification.\n"],["version","Gem::UnsatisfiableDependencyError","Gem/UnsatisfiableDependencyError.html#method-i-version","()","<p>The Requirement of the unresolved dependency (not Version).\n"],["version","Gem::Version","Gem/Version.html#method-i-version","()","<p>A string representation of this Version.\n"],["version","IRB","IRB.html#method-c-version","()","<p>Returns the current version of IRB, including release version and last updated date.\n"],["version","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-version","()",""],["version","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-version","()",""],["version","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-version","()",""],["version","OptionParser","OptionParser.html#method-i-version","()","<p>Version\n"],["version","REXML::Document","REXML/Document.html#method-i-version","()","<p>@return the XMLDecl version of this document as a String. If no XMLDecl has been set, returns the default …\n"],["version","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-version","()","<p>Returns the type library version.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tlib</span> = <span class=\"ruby-constant\">WIN32OLE_TYPELIB</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>)\n<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["version=","Gem::Specification","Gem/Specification.html#method-i-version-3D","(version)","<p>Set the version to <code>version</code>, potentially also setting required_rubygems_version if <code>version</code> indicates it …\n"],["version=","OpenSSL::X509::CRL","OpenSSL/X509/CRL.html#method-i-version-3D","(p1)",""],["version=","OpenSSL::X509::Certificate","OpenSSL/X509/Certificate.html#method-i-version-3D","(p1)",""],["version=","OpenSSL::X509::Request","OpenSSL/X509/Request.html#method-i-version-3D","(p1)",""],["version_1_2","Net::HTTP","Net/HTTP.html#method-c-version_1_2","()","<p>Turns on net/http 1.2 (Ruby 1.8) features. Defaults to ON in Ruby 1.8 or later.\n"],["version_1_2?","Net::HTTP","Net/HTTP.html#method-c-version_1_2-3F","()","<p>Returns true if net/http is in version 1.2 mode. Defaults to true.\n"],["version_color","Bundler::Source","Bundler/Source.html#method-i-version_color","(spec_version, locked_spec_version)",""],["version_conflict_message","Bundler::Resolver","Bundler/Resolver.html#method-i-version_conflict_message","(e)",""],["version_dir","Bundler::Standalone","Bundler/Standalone.html#method-i-version_dir","()",""],["version_message","Bundler::Plugin::Installer::Git","Bundler/Plugin/Installer/Git.html#method-i-version_message","(spec)",""],["version_message","Bundler::Plugin::Installer::Rubygems","Bundler/Plugin/Installer/Rubygems.html#method-i-version_message","(spec)",""],["version_message","Bundler::Source","Bundler/Source.html#method-i-version_message","(spec)",""],["version_message","Bundler::Source::Metadata","Bundler/Source/Metadata.html#method-i-version_message","(spec)",""],["version_of","Bundler::Env","Bundler/Env.html#method-c-version_of","(script)",""],["version_prefix","Bundler::Injector","Bundler/Injector.html#method-i-version_prefix","()",""],["version_tag","Bundler::GemHelper","Bundler/GemHelper.html#method-i-version_tag","()",""],["versions","Bundler::CompactIndexClient","Bundler/CompactIndexClient.html#method-i-versions","()",""],["versions","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-versions","()",""],["versions","RSS::Maker","RSS/Maker.html#method-c-versions","()","<p>Returns collection of supported maker versions\n"],["versions_path","Bundler::CompactIndexClient::Cache","Bundler/CompactIndexClient/Cache.html#method-i-versions_path","()",""],["versions_string","Bundler::RubyVersion","Bundler/RubyVersion.html#method-i-versions_string","(versions)",""],["vertex_named","Bundler::Molinillo::DependencyGraph","Bundler/Molinillo/DependencyGraph.html#method-i-vertex_named","(name)","<p>@param [String] name @return [Vertex,nil] the vertex with the given name\n"],["vertex_named","Gem::Resolver::Molinillo::DependencyGraph","Gem/Resolver/Molinillo/DependencyGraph.html#method-i-vertex_named","(name)","<p>@param [String] name @return [Vertex,nil] the vertex with the given name\n"],["vhid","Socket::Ifaddr","Socket/Ifaddr.html#method-i-vhid","()","<p>Returns the vhid address of <em>ifaddr</em>. nil is returned if there is no vhid.\n"],["vi_editing_mode","Readline","Readline.html#method-c-vi_editing_mode","()","<p>Specifies VI editing mode. See the manual of GNU Readline for details of VI editing mode.\n<p>Raises NotImplementedError …\n"],["vi_editing_mode","Reline::Core","Reline/Core.html#method-i-vi_editing_mode","()",""],["vi_editing_mode?","Readline","Readline.html#method-c-vi_editing_mode-3F","()","<p>Returns true if vi mode is active. Returns false if not.\n<p>Raises NotImplementedError if the using readline …\n"],["vi_editing_mode?","Reline::Core","Reline/Core.html#method-i-vi_editing_mode-3F","()",""],["virtual_host","WEBrick::HTTPServer","WEBrick/HTTPServer.html#method-i-virtual_host","(server)","<p>Adds <code>server</code> as a virtual host.\n"],["visibility=","RDoc::Options","RDoc/Options.html#method-i-visibility-3D","(visibility)","<p>Sets the minimum visibility of a documented method.\n<p>Accepts <code>:public</code>, <code>:protected</code>, <code>:private</code>, <code>:nodoc</code>, or …\n"],["visible?","WIN32OLE_METHOD","WIN32OLE_METHOD.html#method-i-visible-3F","()","<p>Returns true if the method is public.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">tobj</span> = <span class=\"ruby-constant\">WIN32OLE_TYPE</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-string\">&#39;Microsoft Excel 9.0 Object Library&#39;</span>, <span class=\"ruby-string\">&#39;Workbooks&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["visible?","WIN32OLE_TYPE","WIN32OLE_TYPE.html#method-i-visible-3F","()","<p>Returns true if the OLE class is public.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["visible?","WIN32OLE_TYPELIB","WIN32OLE_TYPELIB.html#method-i-visible-3F","()","<p>Returns true if the type library information is not hidden. If wLibFlags of TLIBATTR is 0 or LIBFLAG_FRESTRICTED …\n"],["visible?","WIN32OLE_VARIABLE","WIN32OLE_VARIABLE.html#method-i-visible-3F","()","<p>Returns true if the variable is public.\n\n<pre>tobj = WIN32OLE_TYPE.new(&#39;Microsoft Excel 9.0 Object Library&#39;, ...</pre>\n"],["visit","OptionParser","OptionParser.html#method-i-visit","(id, *args, &block)","<p>Traverses @stack, sending each element method <code>id</code> with <code>args</code> and <code>block</code>.\n"],["visit","Psych::Visitors::Visitor","Psych/Visitors/Visitor.html#method-i-visit","(target)",""],["visit_Array","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Array","(o)",""],["visit_BasicObject","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_BasicObject","(o)",""],["visit_BigDecimal","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_BigDecimal","(o)",""],["visit_Class","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Class","(o)",""],["visit_Complex","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Complex","(o)",""],["visit_Date","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Date","(o)",""],["visit_DateTime","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_DateTime","(o)",""],["visit_Delegator","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Delegator","(o)",""],["visit_Encoding","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Encoding","(o)",""],["visit_Enumerator","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Enumerator","(o)",""],["visit_Exception","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Exception","(o)",""],["visit_FalseClass","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_FalseClass","(o)",""],["visit_Float","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Float","(o)",""],["visit_Hash","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Hash","(o)",""],["visit_Integer","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Integer","(o)",""],["visit_Module","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Module","(o)",""],["visit_NameError","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_NameError","(o)",""],["visit_NilClass","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_NilClass","(o)",""],["visit_Object","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Object","(o)",""],["visit_Psych_Nodes_Alias","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-visit_Psych_Nodes_Alias","(o)",""],["visit_Psych_Nodes_Alias","Psych::Visitors::Emitter","Psych/Visitors/Emitter.html#method-i-visit_Psych_Nodes_Alias","(o)",""],["visit_Psych_Nodes_Alias","Psych::Visitors::NoAliasRuby","Psych/Visitors/NoAliasRuby.html#method-i-visit_Psych_Nodes_Alias","(o)",""],["visit_Psych_Nodes_Alias","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-visit_Psych_Nodes_Alias","(o)",""],["visit_Psych_Nodes_Document","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-visit_Psych_Nodes_Document","(o)",""],["visit_Psych_Nodes_Document","Psych::Visitors::Emitter","Psych/Visitors/Emitter.html#method-i-visit_Psych_Nodes_Document","(o)",""],["visit_Psych_Nodes_Document","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-visit_Psych_Nodes_Document","(o)",""],["visit_Psych_Nodes_Mapping","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-visit_Psych_Nodes_Mapping","(o)",""],["visit_Psych_Nodes_Mapping","Psych::Visitors::Emitter","Psych/Visitors/Emitter.html#method-i-visit_Psych_Nodes_Mapping","(o)",""],["visit_Psych_Nodes_Mapping","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-visit_Psych_Nodes_Mapping","(o)",""],["visit_Psych_Nodes_Scalar","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-visit_Psych_Nodes_Scalar","(o)",""],["visit_Psych_Nodes_Scalar","Psych::Visitors::Emitter","Psych/Visitors/Emitter.html#method-i-visit_Psych_Nodes_Scalar","(o)",""],["visit_Psych_Nodes_Scalar","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-visit_Psych_Nodes_Scalar","(o)",""],["visit_Psych_Nodes_Sequence","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-visit_Psych_Nodes_Sequence","(o)",""],["visit_Psych_Nodes_Sequence","Psych::Visitors::Emitter","Psych/Visitors/Emitter.html#method-i-visit_Psych_Nodes_Sequence","(o)",""],["visit_Psych_Nodes_Sequence","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-visit_Psych_Nodes_Sequence","(o)",""],["visit_Psych_Nodes_Stream","Psych::Visitors::DepthFirst","Psych/Visitors/DepthFirst.html#method-i-visit_Psych_Nodes_Stream","(o)",""],["visit_Psych_Nodes_Stream","Psych::Visitors::Emitter","Psych/Visitors/Emitter.html#method-i-visit_Psych_Nodes_Stream","(o)",""],["visit_Psych_Nodes_Stream","Psych::Visitors::ToRuby","Psych/Visitors/ToRuby.html#method-i-visit_Psych_Nodes_Stream","(o)",""],["visit_Psych_Omap","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Psych_Omap","(o)",""],["visit_Psych_Set","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Psych_Set","(o)",""],["visit_Range","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Range","(o)",""],["visit_Rational","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Rational","(o)",""],["visit_Regexp","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Regexp","(o)",""],["visit_String","Gem::NoAliasYAMLTree","Gem/NoAliasYAMLTree.html#method-i-visit_String","(str)",""],["visit_String","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_String","(o)",""],["visit_Struct","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Struct","(o)",""],["visit_Symbol","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Symbol","(o)",""],["visit_Time","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_Time","(o)",""],["visit_TrueClass","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_TrueClass","(o)",""],["visit_array_subclass","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_array_subclass","(o)",""],["visit_hash_subclass","Psych::Visitors::YAMLTree","Psych/Visitors/YAMLTree.html#method-i-visit_hash_subclass","(o)",""],["viz","Bundler::CLI","Bundler/CLI.html#method-i-viz","()",""],["viz","Bundler::Graph","Bundler/Graph.html#method-i-viz","()",""],["voidcmd","Net::FTP","Net/FTP.html#method-i-voidcmd","(cmd)","<p>Sends a command and expect a response beginning with &#39;2&#39;.\n"],["vstack","Matrix","Matrix.html#method-c-vstack","(x, *matrices)","<p>Create a matrix by stacking matrices vertically\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">x</span> = <span class=\"ruby-constant\">Matrix</span>[[<span class=\"ruby-value\">1</span>, <span class=\"ruby-value\">2</span>], [<span class=\"ruby-value\">3</span>, <span class=\"ruby-value\">4</span>]]\n<span class=\"ruby-identifier\">y</span> = <span class=\"ruby-constant\">Matrix</span>[[<span class=\"ruby-value\">5</span>, <span class=\"ruby-value\">6</span>], [<span class=\"ruby-value\">7</span>, <span class=\"ruby-value\">8</span>]] <span class=\"ruby-operator\">...</span>\n</pre>\n"],["vstack","Matrix","Matrix.html#method-i-vstack","(*matrices)","<p>Returns a new matrix resulting by stacking vertically the receiver with the given matrices\n\n<pre>x = Matrix[[1, ...</pre>\n"],["w3cdtf","Time","Time.html#method-i-w3cdtf","()","<p>This method converts a Time object to a String. The String contains the time in W3CDTF date/time format. …\n"],["w3cdtf","Time","Time.html#method-c-w3cdtf","(date)","<p>This method converts a W3CDTF string date/time format to Time object.\n<p>The W3CDTF format is defined here: …\n"],["wait","ConditionVariable","ConditionVariable.html#method-i-wait","(p1, p2 = v2)","<p>Releases the lock held in <code>mutex</code> and waits; reacquires the lock on wakeup.\n<p>If <code>timeout</code> is given, this method …\n"],["wait","IO","IO.html#method-i-wait","(*args)","<p>Waits until IO is readable or writable without blocking and returns <code>self</code>, or <code>nil</code> when times out. Returns …\n"],["wait","MonitorMixin::ConditionVariable","MonitorMixin/ConditionVariable.html#method-i-wait","(timeout = nil)","<p>Releases the lock held in the associated monitor and waits; reacquires the lock on wakeup.\n<p>If <code>timeout</code> …\n"],["wait","Process","Process.html#method-c-wait","(*args)","<p>Waits for a child process to exit, returns its process id, and sets <code>$?</code> to a Process::Status object containing …\n"],["wait","Rinda::WaitTemplateEntry","Rinda/WaitTemplateEntry.html#method-i-wait","()",""],["wait2","Process","Process.html#method-c-wait2","(*args)","<p>Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing …\n"],["wait_for_child_process_to_exit","Gem::TestCase","Gem/TestCase.html#method-i-wait_for_child_process_to_exit","()","<p>In case we&#39;re building docs in a background process, this method waits for that process to exit (or …\n"],["wait_for_cond","Monitor","Monitor.html#method-i-wait_for_cond","(p1, p2)",""],["wait_for_continue","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-wait_for_continue","(sock, ver)","<p>Waits up to the continue timeout for a response from the server provided we&#39;re speaking HTTP 1.1 …\n"],["wait_for_writtable_socket","Bundler::Settings::TCPSocketProbe","Bundler/Settings/TCPSocketProbe.html#method-i-wait_for_writtable_socket","(socket, address, timeout)",""],["wait_readable","IO","IO.html#method-i-wait_readable","(*args)","<p>Waits until IO is readable without blocking and returns <code>self</code>, or <code>nil</code> when times out. Returns <code>true</code> immediately …\n"],["wait_until","MonitorMixin::ConditionVariable","MonitorMixin/ConditionVariable.html#method-i-wait_until","()","<p>Calls wait repeatedly until the given block yields a truthy value.\n"],["wait_while","MonitorMixin::ConditionVariable","MonitorMixin/ConditionVariable.html#method-i-wait_while","()","<p>Calls wait repeatedly while the given block yields a truthy value.\n"],["wait_writable","IO","IO.html#method-i-wait_writable","(*args)","<p>Waits until IO is writable without blocking and returns <code>self</code> or <code>nil</code> when times out.\n"],["waitall","Process","Process.html#method-c-waitall","()","<p>Waits for all children, returning an array of <em>pid</em>/<em>status</em> pairs (where <em>status</em> is a Process::Status object). …\n"],["waiting","DEBUGGER__","DEBUGGER__.html#method-c-waiting","()","<p>Returns the list of waiting threads.\n<p>When stepping through the traces of a function, thread gets suspended, …\n"],["waitpid","Process","Process.html#method-c-waitpid","(*args)","<p>Waits for a child process to exit, returns its process id, and sets <code>$?</code> to a Process::Status object containing …\n"],["waitpid2","Process","Process.html#method-c-waitpid2","(*args)","<p>Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing …\n"],["wakeup","Thread","Thread.html#method-i-wakeup","()","<p>Marks a given thread as eligible for scheduling, however it may still remain blocked on I/O.\n<p><strong>Note:</strong> This …\n"],["warn","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-warn","(msg, newline = nil)",""],["warn","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-warn","(message, newline = nil)",""],["warn","Kernel","Kernel.html#method-i-warn","(*msgs, uplevel: nil)","<p>If warnings have been disabled (for example with the <code>-W0</code> flag), does nothing.  Otherwise, converts each …\n"],["warn","Logger","Logger.html#method-i-warn","(progname = nil, &block)","<p>Log a <code>WARN</code> message.\n<p>See #info for more information.\n"],["warn","OptionParser","OptionParser.html#method-i-warn","(mesg = $!)",""],["warn","RDoc::Options","RDoc/Options.html#method-i-warn","(message)","<p>Displays a warning using Kernel#warn if we&#39;re being verbose\n"],["warn","RDoc::Parser::Ruby","RDoc/Parser/Ruby.html#method-i-warn","(message)","<p>Prints <code>message</code> to +$stderr+ unless we&#39;re being quiet\n"],["warn","Ripper","Ripper.html#method-i-warn","(fmt, *args)","<p>This method is called when weak warning is produced by the parser. <code>fmt</code> and <code>args</code> is printf style.\n"],["warn","Syslog::Logger","Syslog/Logger.html#method-i-warn","","<p>Logs a <code>message</code> at the warn (syslog notice) log level, or logs the message returned from the block.\n"],["warn","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-warn","(msg)","<p>Shortcut for logging a WARN message\n"],["warn","Warning","Warning.html#method-i-warn","(p1)","<p>Writes warning message <code>msg</code> to $stderr. This method is called by Ruby for all emitted warnings.\n"],["warn!","Logger","Logger.html#method-i-warn-21","()","<p>Sets the severity to WARN.\n"],["warn?","Logger","Logger.html#method-i-warn-3F","()","<p>Returns <code>true</code> iff the current severity level allows for the printing of <code>WARN</code> messages.\n"],["warn?","WEBrick::BasicLog","WEBrick/BasicLog.html#method-i-warn-3F","()","<p>Will the logger output WARN messages?\n"],["warn_ambiguous_gems","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-warn_ambiguous_gems","()",""],["warn_deprecated_git_source","Bundler::Dsl","Bundler/Dsl.html#method-i-warn_deprecated_git_source","(name, replacement, additional_message = nil)",""],["warn_for_outdated_bundler_version","Bundler::LockfileParser","Bundler/LockfileParser.html#method-i-warn_for_outdated_bundler_version","()",""],["warn_if_root","Bundler::CLI::Install","Bundler/CLI/Install.html#method-i-warn_if_root","()",""],["warn_old_tls_version_rubygems_connection","Bundler::PersistentHTTP","Bundler/PersistentHTTP.html#method-i-warn_old_tls_version_rubygems_connection","(uri, connection)",""],["warn_on_git_protocol","Bundler::SourceList","Bundler/SourceList.html#method-i-warn_on_git_protocol","(source)",""],["warn_on_incompatible_bundler_deps","Bundler::Installer","Bundler/Installer.html#method-i-warn_on_incompatible_bundler_deps","()",""],["warn_on_outdated_bundler","Bundler::CLI","Bundler/CLI.html#method-i-warn_on_outdated_bundler","()",""],["warn_unused_scope","Bundler::CLI::Config::Base","Bundler/CLI/Config/Base.html#method-i-warn_unused_scope","(msg)",""],["warning","Ripper","Ripper.html#method-i-warning","(fmt, *args)","<p>This method is called when strong warning is produced by the parser. <code>fmt</code> and <code>args</code> is printf style.\n"],["wday","Date","Date.html#method-i-wday","()","<p>Returns the day of week (0-6, Sunday is zero).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">wday</span>           <span class=\"ruby-comment\">#=&gt; 6</span>\n</pre>\n"],["wday","Time","Time.html#method-i-wday","()","<p>Returns an integer representing the day of the week, 0..6, with Sunday == 0.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-20 ...</span>\n</pre>\n"],["weakref_alive?","WeakRef","WeakRef.html#method-i-weakref_alive-3F","()","<p>Returns true if the referenced object is still alive.\n"],["wednesday?","Date","Date.html#method-i-wednesday-3F","()","<p>Returns true if the date is Wednesday.\n"],["wednesday?","Time","Time.html#method-i-wednesday-3F","()","<p>Returns <code>true</code> if <em>time</em> represents Wednesday.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">local</span>(<span class=\"ruby-value\">1993</span>, <span class=\"ruby-value\">2</span>, <span class=\"ruby-value\">24</span>)      <span class=\"ruby-comment\">#=&gt; 1993-02-24 00:00:00 -0600 ...</span>\n</pre>\n"],["weeknum","Date","Date.html#method-c-weeknum","(p1 = v1, p2 = v2, p3 = v3, p4 = v4, p5 = v5)",""],["weeknum","DateTime","DateTime.html#method-c-weeknum","(p1 = v1, p2 = v2, p3 = v3, p4 = v4, p5 = v5, p6 = v6, p7 = v7, p8 = v8, p9 = v9)",""],["what_required","Bundler::SpecSet","Bundler/SpecSet.html#method-i-what_required","(spec)",""],["when_invoked","Gem::Command","Gem/Command.html#method-i-when_invoked","(&block)","<p>Call the given block when invoked.\n<p>Normal command invocations just executes the <code>execute</code> method of the …\n"],["which","Bundler","Bundler.html#method-c-which","(executable)",""],["which_to_update","Gem::Commands::UpdateCommand","Gem/Commands/UpdateCommand.html#method-i-which_to_update","(highest_installed_gems, gem_names, system = false)",""],["whitespace","REXML::Element","REXML/Element.html#method-i-whitespace","()","<p>Evaluates to <code>true</code> if whitespace is respected for this element.  This is the case if:\n<p>Neither :<code>respect_whitespace</code> …\n"],["why_not_ok?","Gem::DependencyList","Gem/DependencyList.html#method-i-why_not_ok-3F","(quick = false)",""],["win32_last_error","Fiddle","Fiddle.html#method-c-win32_last_error","()","<p>Returns the last win32 <code>Error</code> of the current executing <code>Thread</code> or nil if none\n"],["win32_last_error=","Fiddle","Fiddle.html#method-c-win32_last_error-3D","(error)","<p>Sets the last win32 <code>Error</code> of the current executing <code>Thread</code> to <code>error</code>\n"],["win_platform=","Gem","Gem.html#method-c-win_platform-3D","(val)","<p>Allows toggling Windows behavior.  This method is available when requiring &#39;rubygems/test_case&#39; …\n"],["win_platform?","Gem","Gem.html#method-c-win_platform-3F","()","<p>Is this a windows platform?\n"],["win_platform?","Gem::TestCase","Gem/TestCase.html#method-i-win_platform-3F","()","<p>Is this test being run on a Windows platform?\n"],["win_platform?","Gem::TestCase","Gem/TestCase.html#method-c-win_platform-3F","()","<p>Is this test being run on a Windows platform?\n"],["windows_stub_script","Gem::Installer","Gem/Installer.html#method-i-windows_stub_script","(bindir, bin_file_name)","<p>return the stub script text used to launch the true Ruby script\n"],["winsize","IO","IO.html#method-i-winsize","()","<p>Returns console size.\n<p>You must require &#39;io/console&#39; to use this method.\n"],["winsize","IRB::InputMethod","IRB/InputMethod.html#method-i-winsize","()",""],["winsize=","IO","IO.html#method-i-winsize-3D","(p1)","<p>Tries to set console size.  The effect depends on the platform and the running environment.\n<p>You must require …\n"],["with","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-i-with","(options = {})","<p>MRI\n"],["with","Bundler::ConnectionPool::Wrapper","Bundler/ConnectionPool/Wrapper.html#method-i-with","(&block)",""],["with","OptionParser","OptionParser.html#method-c-with","(*args, &block)","<p>Initializes a new instance and evaluates the optional block in context of the instance. Arguments <code>args</code> …\n"],["with_build_args","Bundler::RubygemsIntegration","Bundler/RubygemsIntegration.html#method-i-with_build_args","(args)",""],["with_clean_env","Bundler","Bundler.html#method-c-with_clean_env","()","<p>@deprecated Use `with_unbundled_env` instead\n"],["with_clean_git_env","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-with_clean_git_env","(&block)",""],["with_clean_path_to_ruby","Gem::TestCase","Gem/TestCase.html#method-i-with_clean_path_to_ruby","()",""],["with_config","MakeMakefile","MakeMakefile.html#method-i-with_config","(config, default=nil)","<p>Tests for the presence of a <code>--with-</code><em>config</em> or <code>--without-</code><em>config</em> option.  Returns <code>true</code> if the with option …\n"],["with_env","Bundler","Bundler.html#method-c-with_env","(env)","<p>@param env [Hash]\n"],["with_friendly_errors","Bundler","Bundler.html#method-c-with_friendly_errors","()",""],["with_index","Enumerator","Enumerator.html#method-i-with_index","(*args)","<p>Iterates the given block for each element with an index, which starts from <code>offset</code>.  If no block is given, …\n"],["with_index","Enumerator::Lazy","Enumerator/Lazy.html#method-i-with_index","(p1 = v1)","<p>If a block is given, iterates the given block for each element with an index, which starts from <code>offset</code> …\n"],["with_index","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-with_index","(offset = 0, &block)","<p>see <code>Enumerator</code>#with_index.\n"],["with_level","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-with_level","(level)",""],["with_no_such_dependency_error_handling","Bundler::Molinillo::Delegates::SpecificationProvider","Bundler/Molinillo/Delegates/SpecificationProvider.html#method-i-with_no_such_dependency_error_handling","()","<p>Ensures any raised {NoSuchDependencyError} has its {NoSuchDependencyError#required_by} set. @yield\n"],["with_no_such_dependency_error_handling","Gem::Resolver::Molinillo::Delegates::SpecificationProvider","Gem/Resolver/Molinillo/Delegates/SpecificationProvider.html#method-i-with_no_such_dependency_error_handling","()","<p>Ensures any raised {NoSuchDependencyError} has its {NoSuchDependencyError#required_by} set. @yield\n"],["with_object","Enumerator","Enumerator.html#method-i-with_object","(p1)","<p>Iterates the given block for each element with an arbitrary object, <code>obj</code>, and returns <code>obj</code>\n<p>If no block is …\n"],["with_object","Prime::PseudoPrimeGenerator","Prime/PseudoPrimeGenerator.html#method-i-with_object","(obj)","<p>see <code>Enumerator</code>#with_object.\n"],["with_original_env","Bundler","Bundler.html#method-c-with_original_env","()","<p>Run block with environment present before Bundler was activated\n"],["with_padding","Bundler::Thor::Shell","Bundler/Thor/Shell.html#method-i-with_padding","()","<p>Yields the given block with padding.\n"],["with_response","Gem::GemcutterUtilities","Gem/GemcutterUtilities.html#method-i-with_response","(response, error_prefix = nil)","<p>If <code>response</code> is an HTTP Success (2XX) response, yields the response if a block was given or shows the …\n"],["with_source","Bundler::Dsl","Bundler/Dsl.html#method-i-with_source","(source)",""],["with_unbundled_env","Bundler","Bundler.html#method-c-with_unbundled_env","()","<p>Run block with all bundler-related variables removed\n"],["without_circular_ref","IRB::Color","IRB/Color.html#method-c-without_circular_ref","(obj, seen:, &block)",""],["without_groups_message","Bundler::CLI::Common","Bundler/CLI/Common.html#method-c-without_groups_message","(command)",""],["wnum0","Date","Date.html#method-i-wnum0","()",""],["wnum1","Date","Date.html#method-i-wnum1","()",""],["word_wrap","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-word_wrap","(text, line_width = @shell.terminal_width)",""],["wordy","Gem::PlatformMismatch","Gem/PlatformMismatch.html#method-i-wordy","()","<p>A wordy description of the error.\n"],["wordy","Gem::SourceFetchProblem","Gem/SourceFetchProblem.html#method-i-wordy","()","<p>An English description of the error.\n"],["worker_pool","Bundler::ParallelInstaller","Bundler/ParallelInstaller.html#method-i-worker_pool","()",""],["workspaces","IRB::Context","IRB/Context.html#method-i-workspaces","()","<p>WorkSpaces in the current stack\n"],["world_readable?","File","File.html#method-c-world_readable-3F","(p1)","<p>If <em>file_name</em> is readable by others, returns an integer representing the file permission bits of <em>file_name</em> …\n"],["world_readable?","File::Stat","File/Stat.html#method-i-world_readable-3F","()","<p>If <em>stat</em> is readable by others, returns an integer representing the file permission bits of <em>stat</em>. Returns …\n"],["world_readable?","FileTest","FileTest.html#method-i-world_readable-3F","(p1)","<p>If <em>file_name</em> is readable by others, returns an integer representing the file permission bits of <em>file_name</em> …\n"],["world_readable?","Pathname","Pathname.html#method-i-world_readable-3F","()","<p>See FileTest.world_readable?.\n"],["world_writable?","File","File.html#method-c-world_writable-3F","(p1)","<p>If <em>file_name</em> is writable by others, returns an integer representing the file permission bits of <em>file_name</em> …\n"],["world_writable?","File::Stat","File/Stat.html#method-i-world_writable-3F","()","<p>If <em>stat</em> is writable by others, returns an integer representing the file permission bits of <em>stat</em>. Returns …\n"],["world_writable?","FileTest","FileTest.html#method-i-world_writable-3F","(p1)","<p>If <em>file_name</em> is writable by others, returns an integer representing the file permission bits of <em>file_name</em> …\n"],["world_writable?","Pathname","Pathname.html#method-i-world_writable-3F","()","<p>See FileTest.world_writable?.\n"],["wrap","Bundler::ConnectionPool","Bundler/ConnectionPool.html#method-c-wrap","(options, &block)",""],["wrap","Gem::Command","Gem/Command.html#method-i-wrap","(text, width)","<p>Wraps <code>text</code> to <code>width</code>\n"],["wrap","Gem::Package::DigestIO","Gem/Package/DigestIO.html#method-c-wrap","(io, digests)","<p>Wraps <code>io</code> and updates digest for each of the digest algorithms in the <code>digests</code> Hash.  Returns the digests …\n"],["wrap","JSON::JSONError","JSON/JSONError.html#method-c-wrap","(exception)",""],["wrap","RDoc::Text","RDoc/Text.html#method-i-wrap","(txt, line_len = 76)","<p>Wraps <code>txt</code> to <code>line_len</code>\n"],["wrap","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-i-wrap","(string, width)",""],["wrap","REXML::Text","REXML/Text.html#method-i-wrap","(string, width, addnewline=false)",""],["wrap","Zlib::GzipFile","Zlib/GzipFile.html#method-c-wrap","(*args)","<p>Creates a GzipReader or GzipWriter associated with <code>io</code>, passing in any necessary extra options, and executes …\n"],["writable?","File","File.html#method-c-writable-3F","(p1)","<p>Returns <code>true</code> if the named file is writable by the effective user and group id of this process. See eaccess(3). …\n"],["writable?","File::Stat","File/Stat.html#method-i-writable-3F","()","<p>Returns <code>true</code> if <em>stat</em> is writable by the effective user id of this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">writable?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["writable?","FileTest","FileTest.html#method-i-writable-3F","(p1)","<p>Returns <code>true</code> if the named file is writable by the effective user and group id of this process. See eaccess(3). …\n"],["writable?","Net::FTP::MLSxEntry","Net/FTP/MLSxEntry.html#method-i-writable-3F","()","<p>Returns <code>true</code> if the STOR command may be applied to the file.\n"],["writable?","Pathname","Pathname.html#method-i-writable-3F","()","<p>See FileTest.writable?.\n"],["writable_real?","File","File.html#method-c-writable_real-3F","(p1)","<p>Returns <code>true</code> if the named file is writable by the real user and group id of this process. See access(3). …\n"],["writable_real?","File::Stat","File/Stat.html#method-i-writable_real-3F","()","<p>Returns <code>true</code> if <em>stat</em> is writable by the real user id of this process.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">writable_real?</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["writable_real?","FileTest","FileTest.html#method-i-writable_real-3F","(p1)","<p>Returns <code>true</code> if the named file is writable by the real user and group id of this process. See access(3). …\n"],["writable_real?","Pathname","Pathname.html#method-i-writable_real-3F","()","<p>See FileTest.writable_real?.\n"],["write","ARGF","ARGF.html#method-i-write","(p1)","<p>Writes <em>string</em> if inplace mode.\n"],["write","Bundler::Env","Bundler/Env.html#method-c-write","(io)",""],["write","Gem::ConfigFile","Gem/ConfigFile.html#method-i-write","()","<p>Writes out this config file, replacing its source.\n"],["write","Gem::Package::DigestIO","Gem/Package/DigestIO.html#method-i-write","(data)","<p>Writes <code>data</code> to the underlying IO and updates the digests\n"],["write","Gem::Package::TarWriter::BoundedStream","Gem/Package/TarWriter/BoundedStream.html#method-i-write","(data)","<p>Writes <code>data</code> onto the IO, raising a FileOverflow exception if the number of bytes will be more than #limit …\n"],["write","Gem::Package::TarWriter::RestrictedStream","Gem/Package/TarWriter/RestrictedStream.html#method-i-write","(data)","<p>Writes <code>data</code> onto the IO\n"],["write","Gem::RequestSet::Lockfile","Gem/RequestSet/Lockfile.html#method-i-write","()","<p>Writes the lock file alongside the gem dependencies file\n"],["write","Gem::Security","Gem/Security.html#method-c-write","(pemmable, path, permissions = 0600, passphrase = nil, cipher = KEY_CIPHER)","<p>Writes <code>pemmable</code>, which must respond to <code>to_pem</code> to <code>path</code> with the given <code>permissions</code>. If passed <code>cipher</code> and …\n"],["write","IO","IO.html#method-c-write","(*args)","<p>Opens the file, optionally seeks to the given <em>offset</em>, writes <em>string</em>, then returns the length written. …\n"],["write","IO","IO.html#method-i-write","(*args)","<p>Writes the given strings to <em>ios</em>. The stream must be opened for writing. Arguments that are not a string …\n"],["write","Net::WriteAdapter","Net/WriteAdapter.html#method-i-write","(str)",""],["write","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-write","(*s)","<p>Writes <em>s</em> to the stream.  If the argument is not a String it will be converted using <code>.to_s</code> method.  Returns …\n"],["write","Pathname","Pathname.html#method-i-write","(p1 = v1, p2 = v2, p3 = v3)","<p>Writes <code>contents</code> to the file.\n<p>See File.write.\n"],["write","REXML::AttlistDecl","REXML/AttlistDecl.html#method-i-write","(out, indent=-1)","<p>Write out exactly what we got in.\n"],["write","REXML::Attribute","REXML/Attribute.html#method-i-write","( output, indent=-1 )","<p>Writes this attribute (EG, puts &#39;key=“value”&#39; to the output)\n"],["write","REXML::CData","REXML/CData.html#method-i-write","( output=$stdout, indent=-1, transitive=false, ie_hack=false )","<p>DEPRECATED\n<p>See the rexml/formatters package\n<p>Generates XML output of this object\n"],["write","REXML::Comment","REXML/Comment.html#method-i-write","( output, indent=-1, transitive=false, ie_hack=false )","<p>DEPRECATED\n<p>See REXML::Formatters\n<p>output &mdash; Where to write the string\n"],["write","REXML::DTD::EntityDecl","REXML/DTD/EntityDecl.html#method-i-write","( output, indent )",""],["write","REXML::DTD::NotationDecl","REXML/DTD/NotationDecl.html#method-i-write","( output, indent )",""],["write","REXML::Declaration","REXML/Declaration.html#method-i-write","( output, indent )","<p>DEPRECATED\n<p>See REXML::Formatters\n"],["write","REXML::DocType","REXML/DocType.html#method-i-write","( output, indent=0, transitive=false, ie_hack=false )","<p>output &mdash; Where to write the string\n<p>indent &mdash; An integer.  If -1, no indentation will be used; otherwise, the …\n"],["write","REXML::Document","REXML/Document.html#method-i-write","(*arguments)","<p>Write the XML tree out, optionally with indent.  This writes out the entire XML document, including  …\n"],["write","REXML::Element","REXML/Element.html#method-i-write","(output=$stdout, indent=-1, transitive=false, ie_hack=false)","<p>DEPRECATED\n<p>See REXML::Formatters\n<p>Writes out this element, and recursively, all children.\n"],["write","REXML::Entity","REXML/Entity.html#method-i-write","(out, indent=-1)","<p>Write out a fully formed, correct entity definition (assuming the Entity object itself is valid.)\n<p>out … &mdash; "],["write","REXML::ExternalEntity","REXML/ExternalEntity.html#method-i-write","( output, indent )",""],["write","REXML::Formatters::Default","REXML/Formatters/Default.html#method-i-write","( node, output )","<p>Writes the node to some output.\n<p>node &mdash; The node to write\n<p>output &mdash; A class implementing <code>&amp;lt;&amp;lt;</code>.   …\n"],["write","REXML::Instruction","REXML/Instruction.html#method-i-write","(writer, indent=-1, transitive=false, ie_hack=false)","<p>DEPRECATED\n<p>See the rexml/formatters package\n"],["write","REXML::NotationDecl","REXML/NotationDecl.html#method-i-write","( output, indent=-1 )",""],["write","REXML::ReferenceWriter","REXML/ReferenceWriter.html#method-i-write","(output)",""],["write","REXML::Text","REXML/Text.html#method-i-write","( writer, indent=-1, transitive=false, ie_hack=false )","<p>DEPRECATED\n<p>See REXML::Formatters\n"],["write","REXML::XMLDecl","REXML/XMLDecl.html#method-i-write","(writer, indent=-1, transitive=false, ie_hack=false)","<p>indent &mdash; Ignored.  There must be no whitespace before an XML declaration\n<p>transitive &mdash; Ignored\n<p>ie_hack &mdash; Ignored …\n"],["write","Rinda::TupleSpace","Rinda/TupleSpace.html#method-i-write","(tuple, sec=nil)","<p>Adds <code>tuple</code>\n"],["write","Rinda::TupleSpaceProxy","Rinda/TupleSpaceProxy.html#method-i-write","(tuple, sec=nil)","<p>Adds <code>tuple</code> to the proxied TupleSpace.  See TupleSpace#write.\n"],["write","StringIO","StringIO.html#method-i-write","(*args)","<p>Appends the given string to the underlying buffer string. The stream must be opened for writing.  If …\n"],["write","Zlib::GzipWriter","Zlib/GzipWriter.html#method-i-write","(*args)","<p>Same as IO.\n"],["write_binary","Gem","Gem.html#method-c-write_binary","(path, data)","<p>Safely write a file in binary mode on all platforms.\n"],["write_build_info_file","Gem::Installer","Gem/Installer.html#method-i-write_build_info_file","()","<p>Writes the file containing the arguments for building this gem&#39;s extensions.\n"],["write_cache_file","Gem::Installer","Gem/Installer.html#method-i-write_cache_file","()","<p>Writes the .gem file to the cache directory\n"],["write_cdata","REXML::Formatters::Default","REXML/Formatters/Default.html#method-i-write_cdata","( node, output )",""],["write_cdata","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-i-write_cdata","( node, output)",""],["write_comment","REXML::Formatters::Default","REXML/Formatters/Default.html#method-i-write_comment","( node, output )",""],["write_comment","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-i-write_comment","( node, output)",""],["write_default_spec","Gem::Installer","Gem/Installer.html#method-i-write_default_spec","()","<p>Writes the full .gemspec specification (in Ruby) to the gem home&#39;s specifications/default directory. …\n"],["write_document","REXML::Formatters::Default","REXML/Formatters/Default.html#method-i-write_document","( node, output )",""],["write_document","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-i-write_document","( node, output )",""],["write_element","REXML::Formatters::Default","REXML/Formatters/Default.html#method-i-write_element","( node, output )",""],["write_element","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-i-write_element","(node, output)",""],["write_element","REXML::Formatters::Transitive","REXML/Formatters/Transitive.html#method-i-write_element","( node, output )",""],["write_file","Gem::TestCase","Gem/TestCase.html#method-i-write_file","(path)","<p>Writes a binary file to <code>path</code> which is relative to +@gemhome+\n"],["write_header","Net::HTTPGenericRequest","Net/HTTPGenericRequest.html#method-i-write_header","(sock, ver, path)",""],["write_headers?","CSV","CSV.html#method-i-write_headers-3F","()","<p>Returns <code>true</code> if headers are written in output. See CSV::new for details.\n"],["write_instruction","REXML::Formatters::Default","REXML/Formatters/Default.html#method-i-write_instruction","( node, output )",""],["write_log","Racc::Grammar","Racc/Grammar.html#method-i-write_log","(path)",""],["write_nonblock","IO","IO.html#method-i-write_nonblock","(buf, exception: true)","<p>Writes the given string to <em>ios</em> using the write(2) system call after O_NONBLOCK is set for the underlying …\n"],["write_nonblock","IO::generic_writable","IO/generic_writable.html#method-i-write_nonblock","(p1, p2 = {})",""],["write_nonblock","OpenSSL::Buffering","OpenSSL/Buffering.html#method-i-write_nonblock","(s, exception: true)","<p>Writes <em>s</em> in the non-blocking manner.\n<p>If there is buffered data, it is flushed first.  This may block. …\n"],["write_options","RDoc::Options","RDoc/Options.html#method-i-write_options","()","<p>Writes the YAML file .rdoc_options to the current directory containing the parsed options.\n"],["write_random_file","OpenSSL::Random","OpenSSL/Random.html#method-c-write_random_file","(p1)","<p>Writes a number of random generated bytes (currently 1024) to <em>filename</em> which can be used to initialize …\n"],["write_services","Rinda::RingServer","Rinda/RingServer.html#method-i-write_services","()","<p>Creates threads that pick up UDP packets and passes them to do_write for decoding.\n"],["write_smime","OpenSSL::PKCS7","OpenSSL/PKCS7.html#method-c-write_smime","(p1, p2 = v2, p3 = v3)",""],["write_spec","Gem::Installer","Gem/Installer.html#method-i-write_spec","()","<p>Writes the .gemspec specification (in Ruby) to the gem home&#39;s specifications directory.\n"],["write_text","REXML::Formatters::Default","REXML/Formatters/Default.html#method-i-write_text","( node, output )",""],["write_text","REXML::Formatters::Pretty","REXML/Formatters/Pretty.html#method-i-write_text","( node, output )",""],["write_text","REXML::Formatters::Transitive","REXML/Formatters/Transitive.html#method-i-write_text","( node, output )",""],["write_timeout=","Net::HTTP","Net/HTTP.html#method-i-write_timeout-3D","(sec)","<p>Setter for the write_timeout attribute.\n"],["write_to_gemfile","Bundler::SharedHelpers","Bundler/SharedHelpers.html#method-i-write_to_gemfile","(gemfile_path, contents)",""],["write_with_substitution","REXML::Text","REXML/Text.html#method-i-write_with_substitution","(out, input)","<p>Writes out text, substituting special characters beforehand. <code>out</code> A String, IO, or any other object supporting …\n"],["writer","CSV","CSV.html#method-i-writer","()",""],["writer_fields_converter","CSV","CSV.html#method-i-writer_fields_converter","()",""],["writer_options","CSV","CSV.html#method-i-writer_options","()",""],["x64_mingw?","Bundler::CurrentRuby","Bundler/CurrentRuby.html#method-i-x64_mingw-3F","()",""],["xhtml","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-xhtml","()","<p>Returns the element content in XHTML.\n"],["xhtml","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-i-xhtml","()","<p>Returns or builds the XHTML content.\n"],["xhtml=","RSS::Maker::AtomTextConstructBase::EnsureXMLContent","RSS/Maker/AtomTextConstructBase/EnsureXMLContent.html#method-i-xhtml-3D","(content)",""],["xlist","Net::IMAP","Net/IMAP.html#method-i-xlist","(refname, mailbox)","<p>Sends a XLIST command, and returns a subset of names from the complete set of all names available to …\n"],["xml","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-i-xml","()","<p>Returns or builds the element content in XML.\n"],["xml=","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-xml-3D","(content)",""],["xmlDecl","RSS::REXMLLikeXMLParser","RSS/REXMLLikeXMLParser.html#method-i-xmlDecl","(version, encoding, standalone)",""],["xml_content=","RSS::Maker::AtomTextConstructBase::EnsureXMLContent","RSS/Maker/AtomTextConstructBase/EnsureXMLContent.html#method-i-xml_content-3D","(content)",""],["xml_content=","RSS::Maker::ItemsBase::ItemBase::ContentBase","RSS/Maker/ItemsBase/ItemBase/ContentBase.html#method-i-xml_content-3D","(content)",""],["xml_decl","REXML::Document","REXML/Document.html#method-i-xml_decl","()","<p>@return the XMLDecl of this document; if no XMLDecl has been set, the default declaration is returned. …\n"],["xml_getter","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-c-xml_getter","()",""],["xml_getter","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-c-xml_getter","()",""],["xml_setter","RSS::Atom::Feed::Entry::Content","RSS/Atom/Feed/Entry/Content.html#method-c-xml_setter","()",""],["xml_setter","RSS::Atom::TextConstruct","RSS/Atom/TextConstruct.html#method-c-xml_setter","()",""],["xml_stylesheet_pi","RSS::XMLStyleSheetMixin","RSS/XMLStyleSheetMixin.html#method-i-xml_stylesheet_pi","()",""],["xml_type?","RSS::Maker::Atom::Feed::Items::Item::Content","RSS/Maker/Atom/Feed/Items/Item/Content.html#method-i-xml_type-3F","()",""],["xmldecl","REXML::SAX2Listener","REXML/SAX2Listener.html#method-i-xmldecl","(version, encoding, standalone)","<p>Called when an XML PI is encountered in the document. EG: &lt;?xml version=“1.0” encoding=“utf”?&gt; …\n"],["xmldecl","REXML::StreamListener","REXML/StreamListener.html#method-i-xmldecl","(version, encoding, standalone)","<p>Called when an XML PI is encountered in the document. EG: &lt;?xml version=“1.0” encoding=“utf”?&gt; …\n"],["xmldecl","REXML::XMLDecl","REXML/XMLDecl.html#method-i-xmldecl","(version, encoding, standalone)",""],["xmldecl","RSS::ListenerMixin","RSS/ListenerMixin.html#method-i-xmldecl","(version, encoding, standalone)","<p>set instance vars for version, encoding, standalone\n"],["xmldecl","RSS::REXMLListener","RSS/REXMLListener.html#method-i-xmldecl","(version, encoding, standalone)",""],["xmldecl","RSS::RootElementMixin","RSS/RootElementMixin.html#method-i-xmldecl","()",""],["xmldecl","RSS::XMLParserListener","RSS/XMLParserListener.html#method-i-xmldecl","(version, encoding, standalone)",""],["xmldecl?","REXML::Parsers::PullEvent","REXML/Parsers/PullEvent.html#method-i-xmldecl-3F","()","<p>Content: [ String version, String encoding, String standalone ]\n"],["xmled_content","RSS::Element","RSS/Element.html#method-i-xmled_content","()",""],["xmlschema","Date","Date.html#method-i-xmlschema","()","<p>This method is equivalent to strftime(&#39;%F&#39;).\n"],["xmlschema","Date","Date.html#method-c-xmlschema","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new Date object by parsing from a string according to some typical XML Schema formats.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">xmlschema</span>(<span class=\"ruby-string\">&#39;2001-02-03&#39;</span>) <span class=\"ruby-operator\">...</span>\n</pre>\n"],["xmlschema","DateTime","DateTime.html#method-c-xmlschema","(p1 = v1, p2 = v2, p3 = {})","<p>Creates a new DateTime object by parsing from a string according to some typical XML Schema formats. …\n"],["xmlschema","DateTime","DateTime.html#method-i-xmlschema","(*args)","<p>This method is equivalent to strftime(&#39;%FT%T%:z&#39;). The optional argument <code>n</code> is the number of digits …\n"],["xmlschema","Time","Time.html#method-c-xmlschema","(date)","<p>Parses <code>date</code> as a dateTime defined by the XML Schema and converts it to a Time object.  The format is …\n"],["xmlschema","Time","Time.html#method-i-xmlschema","(fraction_digits=0)","<p>Returns a string which represents the time as a dateTime defined by XML Schema:\n\n<pre>CCYY-MM-DDThh:mm:ssTZD ...</pre>\n"],["xmp","Object","Object.html#method-i-xmp","(exps, bind = nil)","<p>A convenience method that&#39;s only available when the you require the IRB::XMP standard library.\n<p>Creates …\n"],["xpath","REXML::Attribute","REXML/Attribute.html#method-i-xpath","()",""],["xpath","REXML::Element","REXML/Element.html#method-i-xpath","()",""],["xpath","REXML::Text","REXML/Text.html#method-i-xpath","()","<p>FIXME This probably won&#39;t work properly\n"],["y","Kernel","Kernel.html#method-i-y","(*objects)","<p>An alias for Psych.dump_stream meant to be used with IRB.\n"],["yaml","Psych::Nodes::Node","Psych/Nodes/Node.html#method-i-yaml","(io = nil, options = {})","<p>Convert this node to YAML.\n<p>See also Psych::Visitors::Emitter\n"],["yaml_tag","Object","Object.html#method-c-yaml_tag","(url)",""],["yank_api_request","Gem::Commands::YankCommand","Gem/Commands/YankCommand.html#method-i-yank_api_request","(method, version, platform, api)",""],["yank_gem","Gem::Commands::YankCommand","Gem/Commands/YankCommand.html#method-i-yank_gem","(version, platform)",""],["yday","Date","Date.html#method-i-yday","()","<p>Returns the day of the year (1-366).\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">yday</span>           <span class=\"ruby-comment\">#=&gt; 34</span>\n</pre>\n"],["yday","Time","Time.html#method-i-yday","()","<p>Returns an integer representing the day of the year, 1..366.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:32:31 -0600 ...</span>\n</pre>\n"],["year","Date","Date.html#method-i-year","()","<p>Returns the year.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">2001</span>,<span class=\"ruby-value\">2</span>,<span class=\"ruby-value\">3</span>).<span class=\"ruby-identifier\">year</span>           <span class=\"ruby-comment\">#=&gt; 2001</span>\n(<span class=\"ruby-constant\">Date</span>.<span class=\"ruby-identifier\">new</span>(<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>,<span class=\"ruby-value\">1</span>) <span class=\"ruby-operator\">-</span> <span class=\"ruby-value\">1</span>).<span class=\"ruby-identifier\">year</span>        <span class=\"ruby-comment\">#=&gt; 0</span>\n</pre>\n"],["year","Time","Time.html#method-i-year","()","<p>Returns the year for <em>time</em> (including the century).\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">t</span> = <span class=\"ruby-constant\">Time</span>.<span class=\"ruby-identifier\">now</span>   <span class=\"ruby-comment\">#=&gt; 2007-11-19 08:27:51 -0600</span>\n<span class=\"ruby-identifier\">t</span>.<span class=\"ruby-identifier\">year</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["yes?","Bundler::Thor::Shell::Basic","Bundler/Thor/Shell/Basic.html#method-i-yes-3F","(statement, color = nil)","<p>Make a question the to user and returns true if the user replies “y” or “yes”.\n"],["yes?","Bundler::UI::Shell","Bundler/UI/Shell.html#method-i-yes-3F","(msg)",""],["yes?","Bundler::UI::Silent","Bundler/UI/Silent.html#method-i-yes-3F","(msg)",""],["yes_other_attr_reader","RSS::BaseModel","RSS/BaseModel.html#method-i-yes_other_attr_reader","(*attrs)",""],["yes_other_writer","RSS::BaseModel","RSS/BaseModel.html#method-i-yes_other_writer","(name, disp_name=name)",""],["yield","Fiber","Fiber.html#method-c-yield","(*args)","<p>Yields control back to the context that resumed the fiber, passing along any arguments that were passed …\n"],["yield","Proc","Proc.html#method-i-yield","(*args)","<p>Invokes the block, setting the block&#39;s parameters to the values in <em>params</em> using something close to …\n"],["yield_self","Object","Object.html#method-i-yield_self","()","<p>Yields self to the block and returns the result of the block.\n\n<pre class=\"ruby\"><span class=\"ruby-value\">3</span>.<span class=\"ruby-identifier\">next</span>.<span class=\"ruby-identifier\">then</span> {<span class=\"ruby-operator\">|</span><span class=\"ruby-identifier\">x</span><span class=\"ruby-operator\">|</span> <span class=\"ruby-identifier\">x</span><span class=\"ruby-operator\">**</span><span class=\"ruby-identifier\">x</span> }.<span class=\"ruby-identifier\">to_s</span>            <span class=\"ruby-operator\">...</span>\n</pre>\n"],["yyaccept","Racc::Parser","Racc/Parser.html#method-i-yyaccept","()","<p>Exit parser. Return value is Symbol_Value_Stack.\n"],["yydebug","Ripper","Ripper.html#method-i-yydebug","()","<p>Get yydebug.\n"],["yydebug=","Ripper","Ripper.html#method-i-yydebug-3D","(p1)","<p>Set yydebug.\n"],["yyerrok","Racc::Parser","Racc/Parser.html#method-i-yyerrok","()","<p>Leave error recovering mode.\n"],["yyerror","Racc::Parser","Racc/Parser.html#method-i-yyerror","()","<p>Enter error recovering mode. This method does not call #on_error.\n"],["yylex","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-yylex","(&block)",""],["yylex0","Racc::GrammarFileScanner","Racc/GrammarFileScanner.html#method-i-yylex0","()",""],["zero","Matrix","Matrix.html#method-c-zero","(row_count, column_count = row_count)","<p>Creates a zero matrix.\n\n<pre>Matrix.zero(2)\n  =&gt; 0 0\n     0 0</pre>\n"],["zero","Vector","Vector.html#method-c-zero","(size)","<p>Return a zero vector.\n\n<pre>Vector.zero(3) =&gt; Vector[0, 0, 0]</pre>\n"],["zero?","BigDecimal","BigDecimal.html#method-i-zero-3F","()","<p>Returns True if the value is zero.\n"],["zero?","File","File.html#method-c-zero-3F","(p1)","<p>Returns <code>true</code> if the named file exists and has a zero size.\n<p><em>file_name</em> can be an IO object.\n"],["zero?","File::Stat","File/Stat.html#method-i-zero-3F","()","<p>Returns <code>true</code> if <em>stat</em> is a zero-length file; <code>false</code> otherwise.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">stat</span>(<span class=\"ruby-string\">&quot;testfile&quot;</span>).<span class=\"ruby-identifier\">zero?</span>   <span class=\"ruby-comment\">#=&gt; false</span>\n</pre>\n"],["zero?","FileTest","FileTest.html#method-i-zero-3F","(p1)","<p>Returns <code>true</code> if the named file exists and has a zero size.\n<p><em>file_name</em> can be an IO object.\n"],["zero?","Float","Float.html#method-i-zero-3F","()","<p>Returns <code>true</code> if <code>float</code> is 0.0.\n"],["zero?","Matrix","Matrix.html#method-i-zero-3F","()","<p>Returns <code>true</code> if this is a matrix with only zero elements\n"],["zero?","Numeric","Numeric.html#method-i-zero-3F","()","<p>Returns <code>true</code> if <code>num</code> has a zero value.\n"],["zero?","OpenSSL::BN","OpenSSL/BN.html#method-i-zero-3F","()",""],["zero?","Pathname","Pathname.html#method-i-zero-3F","()","<p>See FileTest.zero?.\n"],["zero?","Vector","Vector.html#method-i-zero-3F","()","<p>Returns <code>true</code> iff all elements are zero.\n"],["zip","Array","Array.html#method-i-zip","(*args)","<p>Converts any arguments to arrays, then merges elements of <code>self</code> with corresponding elements from each …\n"],["zip","Enumerable","Enumerable.html#method-i-zip","(*args)","<p>Takes one element from <em>enum</em> and merges corresponding elements from each <em>args</em>.  This generates a sequence …\n"],["zip","Enumerator::Lazy","Enumerator/Lazy.html#method-i-zip","(*args)","<p>Like Enumerable#zip, but chains operation to be lazy-evaluated. However, if a block is given to zip, …\n"],["zip?","RDoc::Parser","RDoc/Parser.html#method-c-zip-3F","(file)","<p>Checks if <code>file</code> is a zip file in disguise.  Signatures from www.garykessler.net/library/file_sigs.html …\n"],["zlib_version","Zlib","Zlib.html#method-c-zlib_version","()","<p>Returns the string which represents the version of zlib library.\n"],["zone","DateTime","DateTime.html#method-i-zone","()","<p>Returns the timezone.\n\n<pre class=\"ruby\"><span class=\"ruby-constant\">DateTime</span>.<span class=\"ruby-identifier\">parse</span>(<span class=\"ruby-string\">&#39;04pm+0730&#39;</span>).<span class=\"ruby-identifier\">zone</span>          <span class=\"ruby-comment\">#=&gt; &quot;+07:30&quot;</span>\n</pre>\n"],["zone","Time","Time.html#method-i-zone","()","<p>Returns the name of the time zone used for <em>time</em>. As of Ruby 1.8, returns “UTC&#39;&#39; rather than …\n"],["zone_offset","Time","Time.html#method-c-zone_offset","(zone, year=self.now.year)","<p>Return the number of seconds the specified time zone differs from UTC.\n<p>Numeric time zones that include …\n"],["zone_utc?","Time","Time.html#method-c-zone_utc-3F","(zone)",""],["|","Array","Array.html#method-i-7C","(p1)","<p>Set Union — Returns a new array by joining <code>ary</code> with <code>other_ary</code>, excluding any duplicates and preserving …\n"],["|","FalseClass","FalseClass.html#method-i-7C","(p1)","<p>Or—Returns <code>false</code> if <em>obj</em> is <code>nil</code> or <code>false</code>; <code>true</code> otherwise.\n"],["|","IPAddr","IPAddr.html#method-i-7C","(other)","<p>Returns a new ipaddr built by bitwise OR.\n"],["|","Integer","Integer.html#method-i-7C","(p1)","<p>Bitwise OR.\n"],["|","JSON::GenericObject","JSON/GenericObject.html#method-i-7C","(other)",""],["|","NilClass","NilClass.html#method-i-7C","(p1)","<p>Or—Returns <code>false</code> if <em>obj</em> is <code>nil</code> or <code>false</code>; <code>true</code> otherwise.\n"],["|","Racc::Rule","Racc/Rule.html#method-i-7C","(x)",""],["|","Racc::Sym","Racc/Sym.html#method-i-7C","(x)",""],["|","Set","Set.html#method-i-7C","(enum)","<p>Returns a new set built by merging the set and the elements of the given enumerable object.\n\n<pre>Set[1, 2, ...</pre>\n"],["|","TrueClass","TrueClass.html#method-i-7C","(p1)","<p>Or—Returns <code>true</code>. As <em>obj</em> is an argument to a method call, it is always evaluated; there is no short-circuit …\n"],["~","IPAddr","IPAddr.html#method-i-~","()","<p>Returns a new ipaddr built by bitwise negation.\n"],["~","Integer","Integer.html#method-i-~","()","<p>One&#39;s complement: returns a number where each bit is flipped.\n<p>Inverts the bits in an Integer. As integers …\n"],["~","Regexp","Regexp.html#method-i-~","()","<p>Match—Matches <em>rxp</em> against the contents of <code>$_</code>. Equivalent to <code><em>rxp</em> =~ $_</code>.\n\n<pre class=\"ruby\"><span class=\"ruby-identifier\">$_</span> = <span class=\"ruby-string\">&quot;input data&quot;</span>\n<span class=\"ruby-operator\">~</span> <span class=\"ruby-regexp\">/at/</span>   <span class=\"ruby-comment\">#=&gt; ...</span>\n</pre>\n"],["CONTRIBUTING","","CONTRIBUTING_md.html","","<p>Please see the official issue tracker and wiki HowToContribute.\n"],["COPYING","","COPYING.html","","<p>Ruby is copyrighted free software by Yukihiro Matsumoto &lt;matz@netlab.jp&gt;. You can redistribute …\n"],["COPYING.ja","","COPYING_ja.html","","<p>本プログラムはフリーソフトウェアです．2-clause BSDL または以下に示す条件で本プログラムを再配布できます 2-clause BSDLについてはBSDLファイルを参照して下さい．\n<p>複製は制限なく自由です． …\n"],["LEGAL","","LEGAL.html","","<p>LEGAL NOTICE INFORMATION\n<p>All the files in this distribution are covered under either the Ruby&#39;s license …\n"],["NEWS","","NEWS.html","","<p>NEWS for Ruby 2.7.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-1.8.7","","NEWS-1_8_7.html","","<p>NEWS for Ruby 1.8.7\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-1.9.1","","NEWS-1_9_1.html","","<p>NEWS for Ruby 1.9.1\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-1.9.2","","NEWS-1_9_2.html","","<p>NEWS for Ruby 1.9.2\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-1.9.3","","NEWS-1_9_3.html","","<p>NEWS for Ruby 1.9.3\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-2.0.0","","NEWS-2_0_0.html","","<p>NEWS for Ruby 2.0.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-2.1.0","","NEWS-2_1_0.html","","<p>NEWS for Ruby 2.1.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-2.2.0","","NEWS-2_2_0.html","","<p>NEWS for Ruby 2.2.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-2.3.0","","NEWS-2_3_0.html","","<p>NEWS for Ruby 2.3.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-2.4.0","","NEWS-2_4_0.html","","<p>NEWS for Ruby 2.4.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-2.5.0","","NEWS-2_5_0.html","","<p>NEWS for Ruby 2.5.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["NEWS-2.6.0","","NEWS-2_6_0.html","","<p>NEWS for Ruby 2.6.0\n<p>This document is a list of user visible feature changes made between releases except …\n"],["README.ja","","README_ja_md.html","","<p><img src=\"https://travis-ci.org/ruby/ruby.svg?branch=master\">\n<img src=\"https://ci.appveyor.com/api/projects/status/0sy8rrxut4o0k960/branch/master?svg=true\"> ...\n"],["README","","README_md.html","","<p><img src=\"https://travis-ci.org/ruby/ruby.svg?branch=master\">\n<img src=\"https://ci.appveyor.com/api/projects/status/0sy8rrxut4o0k960/branch/master?svg=true\"> ...\n"],["bug_triaging","","bug_triaging_rdoc.html","","<p>Bug Triaging Guide\n<p>This guide discusses recommendations for triaging bugs in Ruby&#39;s bug tracker.\n<p>Bugs …\n"],["contributing","","contributing_rdoc.html","","<p>Contributing to Ruby\n<p>Ruby has a vast and friendly community with hundreds of people contributing to a …\n"],["contributors","","contributors_rdoc.html","","<p>Contributors to Ruby\n<p>The following list might be incomplete. Feel free to add your name if your patch …\n"],["dtrace_probes","","dtrace_probes_rdoc.html","","<p>DTrace Probes\n<p>A list of DTrace probes and their functionality. “Module” and “Function” …\n"],["extension.ja","","extension_ja_rdoc.html","","<p>Rubyの拡張ライブラリの作り方\n<p>Rubyの拡張ライブラリの作り方を説明します．\n<p>基礎知識\n"],["extension","","extension_rdoc.html","","<p>Creating Extension Libraries for Ruby\n<p>This document explains how to make extension libraries for Ruby …\n"],["globals","","globals_rdoc.html","","<p>Pre-defined global variables\n<p>$! &mdash; The Exception object set by Kernel#raise.\n<p>$@ &mdash; The same as <code>$!.backtrace</code>. …\n"],["keywords","","keywords_rdoc.html","","<p>Keywords\n<p>The following keywords are used by Ruby.\n<p>__ENCODING__ &mdash; The script encoding of the current file. …\n"],["pre-setup","","lib/racc/pre-setup.html","","<p>def generate_parser_text_rb(target)\n\n<pre class=\"ruby\"><span class=\"ruby-keyword\">return</span> <span class=\"ruby-keyword\">if</span> <span class=\"ruby-constant\">File</span>.<span class=\"ruby-identifier\">exist?</span>(<span class=\"ruby-identifier\">srcfile</span>(<span class=\"ruby-identifier\">target</span>))\n<span class=\"ruby-identifier\">$stderr</span>.<span class=\"ruby-identifier\">puts</span> <span class=\"ruby-node\">&quot;generating #{target}...&quot;</span> <span class=\"ruby-operator\">...</span>\n</pre>\n"],["grammar.en","","lib/racc/rdoc/grammar_en_rdoc.html","","<p>Racc Grammar File Reference\n<p>Global Structure\n<p>Class Block and User Code Block\n"],["maintainers","","maintainers_rdoc.html","","<p>Maintainers\n<p>This page describes the current module, library, and extension maintainers of Ruby.\n<p>Module …\n"],["marshal","","marshal_rdoc.html","","<p>Marshal Format\n<p>The Marshal format is used to serialize ruby objects.  The format can store arbitrary objects …\n"],["regexp","","regexp_rdoc.html","","<p>Regular expressions (<em>regexp</em>s) are patterns which describe the contents of a string. They&#39;re used …\n"],["security","","security_rdoc.html","","<p>Ruby Security\n<p>The Ruby programming language is large and complex and there are many security pitfalls …\n"],["signals","","signals_rdoc.html","","<p>Caveats for implementing Signal.trap callbacks\n<p>As with implementing signal handlers in C or most other …\n"],["standard_library","","standard_library_rdoc.html","","<p>Ruby Standard Library\n<p>The Ruby Standard Library is a vast collection of classes and modules that you can …\n"],["syntax","","syntax_rdoc.html","","<p>Ruby Syntax\n<p>The Ruby syntax is large and is split up into the following sections:\n<p>Literals  &mdash; Numbers, Strings …\n"],["assignment","","syntax/assignment_rdoc.html","","<p>Assignment\n<p>In Ruby, assignment uses the <code>=</code> (equals sign) character.  This example assigns the number five …\n"],["calling_methods","","syntax/calling_methods_rdoc.html","","<p>Calling Methods\n<p>Calling a method sends a message to an object so it can perform some work.\n<p>In ruby you …\n"],["comments","","syntax/comments_rdoc.html","","<p>Code Comments\n<p>Ruby has two types of comments: inline and block.\n<p>Inline comments start with the <code>#</code> character …\n"],["control_expressions","","syntax/control_expressions_rdoc.html","","<p>Control Expressions\n<p>Ruby has a variety of ways to control execution.  All the expressions described here …\n"],["exceptions","","syntax/exceptions_rdoc.html","","<p>Exception Handling\n<p>Exceptions are rescued in a <code>begin</code>/<code>end</code> block:\n\n<pre>begin\n  # code that might raise\nrescue ...</pre>\n"],["literals","","syntax/literals_rdoc.html","","<p>Literals\n<p>Literals create objects you can use in your program.  Literals include:\n<p>Booleans and nil\n"],["methods","","syntax/methods_rdoc.html","","<p>Methods\n<p>Methods implement the functionality of your program.  Here is a simple method definition:\n\n<pre>def one_plus_one ...</pre>\n"],["miscellaneous","","syntax/miscellaneous_rdoc.html","","<p>Miscellaneous Syntax\n<p>Ending an Expression\n<p>Ruby uses a newline as the end of an expression.  When ending …\n"],["modules_and_classes","","syntax/modules_and_classes_rdoc.html","","<p>Modules\n<p>Modules serve two purposes in Ruby, namespacing and mix-in functionality.\n<p>A namespace can be used …\n"],["precedence","","syntax/precedence_rdoc.html","","<p>Precedence\n<p>From highest to lowest, this is the precedence table for ruby.  High precedence operations …\n"],["refinements","","syntax/refinements_rdoc.html","","<p>Refinements\n<p>Due to Ruby&#39;s open classes you can redefine or add functionality to existing classes. …\n"],["README.win32","","win32/README_win32.html","","<p>How to build ruby using Visual C++\n<p>Requirement\n<p>Windows 7 or later.\n"]]}}