Object is the root of Ruby's class hierarchy. Its methods are available to all classes unless explicitly overridden.

Object mixes in the Kernel module, making the built-in kernel functions globally accessible. Although the instance methods of Object are defined by the Kernel module, we have chosen to document them here for clarity.

In the descriptions of Object's methods, the parameter symbol refers to a symbol, which is either a quoted string or a Symbol (such as :name).

Namespace
Methods
#
C
D
C
D
E
F
H
I
K
L
M
N
O
P
R
S
T
U
W
X
Y
Included Modules
Constants
ENV = envtbl
 

ENV is a Hash-like accessor for environment variables.

See ENV (the class) for more details.

STDIN = rb_stdin
 

Holds the original stdin

STDOUT = rb_stdout
 

Holds the original stdout

STDERR = rb_stderr
 

Holds the original stderr

ARGF = argf
 

ARGF is a stream designed for use in scripts that process files given as command-line arguments or passed in via STDIN.

See ARGF (the class) for more details.

NIL = Qnil
 

An alias of nil

TRUE = Qtrue
 

An alias of true

FALSE = Qfalse
 

An alias of false

DATA = f
 

DATA is a File that contains the data section of the executed file. To create a data section use __END__:

$ cat t.rb
puts DATA.gets
__END__
hello world!

$ ruby t.rb
hello world!
ARGV = rb_argv
 

ARGV contains the command line arguments used to run ruby with the first value containing the name of the executable.

A library like OptionParser can be used to process command-line arguments.

RUBY_VERSION = MKSTR(version)
 

The running version of ruby

RUBY_RELEASE_DATE = MKSTR(release_date)
 

The date this ruby was released

RUBY_PLATFORM = MKSTR(platform)
 

The platform for this ruby

RUBY_PATCHLEVEL = INT2FIX(RUBY_PATCHLEVEL)
 

The patchlevel for this ruby. If this is a development build of ruby the patchlevel will be -1

RUBY_REVISION = INT2FIX(RUBY_REVISION)
 

The SVN revision for this ruby.

RUBY_DESCRIPTION = MKSTR(description)
 

The full ruby version string, like ruby -vprints'

RUBY_COPYRIGHT = MKSTR(copyright)
 

The copyright string for ruby

RUBY_ENGINE = ruby_engine_name = MKSTR(engine)
 

The engine or interpreter this ruby uses.

TOPLEVEL_BINDING = rb_binding_new()
 

The Binding of the top level scope

SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
 
Math = CMath
 
CONFIG = RbConfig::MAKEFILE_CONFIG
 
ORIG_LIBPATH = ENV['LIB']
 
C_EXT = %w[c m]
 
CXX_EXT = %w[cc mm cxx cpp]
 
SRC_EXT = C_EXT + CXX_EXT
 
STRING_OR_FAILED_FORMAT = "%s"
 
EXPORT_PREFIX = config_string('EXPORT_PREFIX') {|s| s.strip}
 
COMMON_HEADERS = hdr.join("\n")
 
COMMON_LIBS = config_string('COMMON_LIBS', &split) || []
 
COMPILE_RULES = config_string('COMPILE_RULES', &split) || %w[.%s.%s:]
 
RULE_SUBST = config_string('RULE_SUBST')
 
COMPILE_C = config_string('COMPILE_C') || '$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<'
 
COMPILE_CXX = config_string('COMPILE_CXX') || '$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<'
 
TRY_LINK = config_string('TRY_LINK') || "$(CC) #{OUTFLAG}conftest $(INCFLAGS) $(CPPFLAGS) " \ "$(CFLAGS) $(src) $(LIBPATH) $(LDFLAGS) $(ARCH_FLAG) $(LOCAL_LIBS) $(LIBS)"
 
LINK_SO = config_string('LINK_SO') || if CONFIG["DLEXT"] == $OBJEXT "ld $(DLDFLAGS) -r -o $@ $(OBJS)\n" else "$(LDSHARED) #{OUTFLAG}$@ $(OBJS) " \ "$(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)" end
 
LIBPATHFLAG = config_string('LIBPATHFLAG') || ' -L"%s"'
 
RPATHFLAG = config_string('RPATHFLAG') || ''
 
LIBARG = config_string('LIBARG') || '-l%s'
 
MAIN_DOES_NOTHING = config_string('MAIN_DOES_NOTHING') || "int main(int argc, char **argv)\n{\n return 0;\n}"
 
UNIVERSAL_INTS = config_string('UNIVERSAL_INTS') {|s| Shellwords.shellwords(s)} || %w[int short long long\ long]
 
CLEANINGS = " clean-static:: clean-rb-default:: clean-rb:: clean-so:: clean: clean-so clean-static clean-rb-default clean-rb \t\t-$(Q)$(RM) $(CLEANLIBS#{sep}) $(CLEANOBJS#{sep}) $(CLEANFILES#{sep}) .*.time distclean-rb-default:: distclean-rb:: distclean-so:: distclean: clean distclean-so distclean-rb-default distclean-rb \t\t@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log \t\t@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES#{sep}) \t\t@-$(RMDIRS) $(DISTCLEANDIRS#{sep})#{$ignore_error} realclean: distclean "
 
Version = OptionParser::Version
 
NotImplementedError = NotImplementError
 
ParseError = Racc::ParseError
 
Synchronizer_m = Sync_m
 

An alias for Sync_m from sync.rb

Synchronizer = Sync
 

An alias for Sync from sync.rb. See Sync_m for details.

ThWait = ThreadsWait
 

An alias for ThreadsWait from thwait.rb

TimeoutError = Timeout::Error
 

Another name for Timeout::Error, defined for backwards compatibility with earlier versions of timeout.rb.

NOENCODING = 32
 
Class Public methods
yaml_tag(url)
# File ext/psych/lib/psych/core_ext.rb, line 2
def self.yaml_tag url
  Psych.add_tag(url, self)
end
Instance Public methods
obj !~ other → true or false

Returns true if two objects do not match (using the =~method), otherwise false.

static VALUE
rb_obj_not_match(VALUE obj1, VALUE obj2)
{
    VALUE result = rb_funcall(obj1, id_match, 1, obj2);
    return RTEST(result) ? Qfalse : Qtrue;
}
obj <=> other → 0 or nil

Returns 0 if objand otherare the same object or obj == other, otherwise nil.

static VALUE
rb_obj_cmp(VALUE obj1, VALUE obj2)
{
    if (obj1 == obj2 || rb_equal(obj1, obj2))
        return INT2FIX(0);
    return Qnil;
}
obj === other → true or false

Case Equality—For class Object, effectively the same as calling #==, but typically overridden by descendants to provide meaningful semantics in casestatements.

VALUE
rb_equal(VALUE obj1, VALUE obj2)
{
    VALUE result;

    if (obj1 == obj2) return Qtrue;
    result = rb_funcall(obj1, id_eq, 1, obj2);
    if (RTEST(result)) return Qtrue;
    return Qfalse;
}
obj =~ other → nil

Pattern Match—Overridden by descendants (notably Regexpand String) to provide meaningful pattern-match semantics.

static VALUE
rb_obj_match(VALUE obj1, VALUE obj2)
{
    return Qnil;
}
CSV(*args, &block)

Another name for CSV.instance.

# File lib/csv.rb, line 2339
def CSV(*args, &block)
  CSV.instance(*args, &block)
end
DelegateClass(superclass)

The primary interface to this library. Use to setup delegation when defining your class.

class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

Here's a sample of use from Tempfile which is really a File object with a few special rules about storage location and when the File should be deleted. That makes for an almost textbook perfect example of how to use delegation.

class Tempfile < DelegateClass(File)
  # constant and class member data initialization...

  def initialize(basename, tmpdir=Dir::tmpdir)
    # build up file path/name in var tmpname...

    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)

    # ...

    super(@tmpfile)

    # below this point, all methods of File are supported...
  end

  # ...
end
# File lib/delegate.rb, line 334
def DelegateClass(superclass)
  klass = Class.new(Delegator)
  methods = superclass.instance_methods
  methods -= ::Delegator.public_api
  methods -= [:to_s,:inspect,:=~,:!~,:===]
  klass.module_eval do
    def __getobj__  # :nodoc:
      @delegate_dc_obj
    end
    def __setobj__(obj)  # :nodoc:
      raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
      @delegate_dc_obj = obj
    end
    methods.each do |method|
      define_method(method, Delegator.delegating_block(method))
    end
  end
  klass.define_singleton_method :public_instance_methods do |all=true|
    super(all) - superclass.protected_instance_methods
  end
  klass.define_singleton_method :protected_instance_methods do |all=true|
    super(all) | superclass.protected_instance_methods
  end
  return klass
end
Digest(name) → digest_subclass

Returns a Digest subclass by name.

require 'digest'

Digest("MD5")
# => Digest::MD5

Digest("Foo")
# => LoadError: library not found for class Digest::Foo -- digest/foo
# File ext/digest/lib/digest.rb, line 86
def Digest(name)
  Digest.const_get(name)
end
check_signedness(type, headers = nil, opts = nil, &b)

Returns the signedness of the given type. You may optionally specify additional headersto search in for the type.

If the typeis found and is a numeric type, a macro is passed as a preprocessor constant to the compiler using the type name, in uppercase, prepended with 'SIGNEDNESS_OF_', followed by the typename, followed by '=X' where 'X' is positive integer if the typeis unsigned, or negative integer if the typeis signed.

For example, if size_t is defined as unsigned, then #check_signedness('size_t') would returned +1 and the SIGNEDNESS_OF_SIZE_T=+1 preprocessor macro would be passed to the compiler, and SIGNEDNESS_OF_INT=-1 if #check_signedness('int') is done.

# File lib/mkmf.rb, line 1191
def check_signedness(type, headers = nil, opts = nil, &b)
  typedef, member, prelude = typedef_expr(type, headers)
  signed = nil
  checking_for("signedness of #{type}", STRING_OR_FAILED_FORMAT) do
    signed = try_signedness(typedef, member, [prelude], opts, &b) or next nil
    $defs.push("-DSIGNEDNESS_OF_%s=%+d" % [type.tr_cpp, signed])
    signed < 0 ? "signed" : "unsigned"
  end
  signed
end
check_sizeof(type, headers = nil, opts = "", &b)

Returns the size of the given type. You may optionally specify additional headersto search in for the type.

If found, a macro is passed as a preprocessor constant to the compiler using the type name, in uppercase, prepended with 'SIZEOF_', followed by the type name, followed by '=X' where 'X' is the actual size.

For example, if #check_sizeof('mystruct') returned 12, then the SIZEOF_MYSTRUCT=12 preprocessor macro would be passed to the compiler.

# File lib/mkmf.rb, line 1162
def check_sizeof(type, headers = nil, opts = "", &b)
  typedef, member, prelude = typedef_expr(type, headers)
  prelude << "static #{typedef} *rbcv_ptr_;\n"
  prelude = [prelude]
  expr = "sizeof((*rbcv_ptr_)#{"." << member if member})"
  fmt = STRING_OR_FAILED_FORMAT
  checking_for checking_message("size of #{type}", headers), fmt do
    if size = try_constant(expr, prelude, opts, &b)
      $defs.push(format("-DSIZEOF_%s=%s", type.tr_cpp, size))
      size
    end
  end
end
chmod()

Change the mode of each FILE to OCTAL-MODE.

ruby -run -e chmod -- [OPTION] OCTAL-MODE FILE

-v          verbose
# File lib/un.rb, line 206
def chmod
  setup do |argv, options|
    mode = argv.shift.oct
    FileUtils.chmod mode, argv, options
  end
end
obj.class → class

Returns the class of obj. This method must always be called with an explicit receiver, as classis also a reserved word in Ruby.

1.class      #=> Fixnum
self.class   #=> Object
VALUE
rb_obj_class(VALUE obj)
{
    return rb_class_real(CLASS_OF(obj));
}
obj.clone → an_object

Produces a shallow copy of obj—the instance variables of objare copied, but not the objects they reference. Copies the frozen and tainted state of obj. See also the discussion under Object#dup.

class Klass
   attr_accessor :str
end
s1 = Klass.new      #=> #<Klass:0x401b3a38>
s1.str = "Hello"    #=> "Hello"
s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
s2.str[1,4] = "i"   #=> "i"
s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"

This method may have class-specific behavior. If so, that behavior will be documented under the # initialize_copymethod of the class.

VALUE
rb_obj_clone(VALUE obj)
{
    VALUE clone;

    if (rb_special_const_p(obj)) {
        rb_raise(rb_eTypeError, "can't clone %s", rb_obj_classname(obj));
    }
    clone = rb_obj_alloc(rb_obj_class(obj));
    RBASIC(clone)->klass = rb_singleton_class_clone(obj);
    RBASIC(clone)->flags = (RBASIC(obj)->flags | FL_TEST(clone, FL_TAINT) | FL_TEST(clone, FL_UNTRUSTED)) & ~(FL_FREEZE|FL_FINALIZE|FL_MARK);
    init_copy(clone, obj);
    rb_funcall(clone, id_init_clone, 1, obj);
    RBASIC(clone)->flags |= RBASIC(obj)->flags & FL_FREEZE;

    return clone;
}
convertible_int(type, headers = nil, opts = nil, &b)

Returns the convertible integer type of the given type. You may optionally specify additional headersto search in for the type. Convertiblemeans actually same type, or typedefed from same type.

If the typeis a integer type and convertibletype is found, following macros are passed as preprocessor constants to the compiler using the typename, in uppercase.

  • 'TYPEOF_', followed by the typename, followed by '=X' where 'X' is the found convertibletype name. * 'TYP2NUM' and 'NUM2TYP, where 'TYP' is the typename in uppercase with replacing '_t' suffix with 'T', followed by '=X' where 'X' is the macro name to convert typeto Integerobject, and vice versa.

For example, if foobar_t is defined as unsigned long, then #convertible_int(“foobar_t”) would return “unsigned long”, and define macros:

#define TYPEOF_FOOBAR_T unsigned long
#define FOOBART2NUM ULONG2NUM
#define NUM2FOOBART NUM2ULONG
# File lib/mkmf.rb, line 1223
def convertible_int(type, headers = nil, opts = nil, &b)
  type, macname = *type
  checking_for("convertible type of #{type}", STRING_OR_FAILED_FORMAT) do
    if UNIVERSAL_INTS.include?(type)
      type
    else
      typedef, member, prelude = typedef_expr(type, headers, &b)
      next unless signed = try_signedness(typedef, member, [prelude])
      u = "unsigned " if signed > 0
      prelude << "extern rbcv_typedef_ foo();"
      compat = UNIVERSAL_INTS.find {|t|
        try_compile([prelude, "extern #{u}#{t} foo();"].join("\n"), opts, :werror=>true, &b)
      }
      if compat
        macname ||= type.sub(/_(?=t\z)/, '').tr_cpp
        conv = (compat == "long long" ? "LL" : compat.upcase)
        compat = "#{u}#{compat}"
        $defs.push(format("-DTYPEOF_%s=%s", type.tr_cpp, compat.quote))
        $defs.push(format("-DPRI_%s_PREFIX=PRI_%s_PREFIX", macname, conv))
        conv = (u ? "U" : "") + conv
        $defs.push(format("-D%s2NUM=%s2NUM", macname, conv))
        $defs.push(format("-DNUM2%s=NUM2%s", macname, conv))
        compat
      end
    end
  end
end
cp()

Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY

ruby -run -e cp -- [OPTION] SOURCE DEST

-p          preserve file attributes if possible
-r          copy recursively
-v          verbose
# File lib/un.rb, line 77
def cp
  setup("pr") do |argv, options|
    cmd = "cp"
    cmd += "_r" if options.delete :r
    options[:preserve] = true if options.delete :p
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.send cmd, argv, dest, options
  end
end
create_header(header = "extconf.h")

Generates a header file consisting of the various macro definitions generated by other methods such as #have_func and have_header. These are then wrapped in a custom ifndef based on the headerfile name, which defaults to 'extconf.h'.

For example:

# extconf.rb
require 'mkmf'
have_func('realpath')
have_header('sys/utime.h')
create_header
create_makefile('foo')

The above script would generate the following extconf.h file:

#ifndef EXTCONF_H
#define EXTCONF_H
#define HAVE_REALPATH 1
#define HAVE_SYS_UTIME_H 1
#endif

Given that the #create_header method generates a file based on definitions set earlier in your extconf.rb file, you will probably want to make this one of the last methods you call in your script.

# File lib/mkmf.rb, line 1499
def create_header(header = "extconf.h")
  message "creating %s\n", header
  sym = header.tr_cpp
  hdr = ["#ifndef #{sym}\n#define #{sym}\n"]
  for line in $defs
    case line
    when /^-D([^=]+)(?:=(.*))?/
      hdr << "#define #$1 #{$2 ? Shellwords.shellwords($2)[0].gsub(/(?=\t+)/, "\\\n") : 1}\n"
    when /^-U(.*)/
      hdr << "#undef #$1\n"
    end
  end
  hdr << "#endif\n"
  hdr = hdr.join
  log_src(hdr, "#{header} is")
  unless (IO.read(header) == hdr rescue false)
    open(header, "wb") do |hfile|
      hfile.write(hdr)
    end
  end
  $extconf_h = header
end
create_makefile(target, srcprefix = nil)

Generates the Makefile for your extension, passing along any options and preprocessor constants that you may have generated through other methods.

The targetname should correspond the name of the global function name defined within your C extension, minus the 'Init_'. For example, if your C extension is defined as 'Init_foo', then your target would simply be 'foo'.

If any '/' characters are present in the target name, only the last name is interpreted as the target name, and the rest are considered toplevel directory names, and the generated Makefile will be altered accordingly to follow that directory structure.

For example, if you pass 'test/foo' as a target name, your extension will be installed under the 'test' directory. This means that in order to load the file within a Ruby program later, that directory structure will have to be followed, e.g. “require 'test/foo'”.

The srcprefixshould be used when your source files are not in the same directory as your build script. This will not only eliminate the need for you to manually copy the source files into the same directory as your build script, but it also sets the proper target_prefix in the generated Makefile.

Setting the target_prefixwill, in turn, install the generated binary in a directory under your RbConfig::CONFIG that mimics your local filesystem when you run 'make install'.

For example, given the following file tree:

ext/
   extconf.rb
   test/
      foo.c

And given the following code:

create_makefile('test/foo', 'test')

That will set the target_prefixin the generated Makefile to 'test'. That, in turn, will create the following file tree when installed via the 'make install' command:

/path/to/ruby/sitearchdir/test/foo.so

It is recommended that you use this approach to generate your makefiles, instead of copying files around manually, because some third party libraries may depend on the target_prefixbeing set properly.

The srcprefixargument can be used to override the default source directory, i.e. the current directory . It is included as part of the VPATH and added to the list of INCFLAGS.

# File lib/mkmf.rb, line 1893
def create_makefile(target, srcprefix = nil)
  $target = target
  libpath = $DEFLIBPATH|$LIBPATH
  message "creating Makefile\n"
  rm_f "conftest*"
  if CONFIG["DLEXT"] == $OBJEXT
    for lib in libs = $libs.split
      lib.sub!(/-l(.*)/, %Q"lib\\1.#{$LIBEXT}"%)
    end
    $defs.push(format("-DEXTLIB='%s'", libs.join(",")))
  end

  if target.include?('/')
    target_prefix, target = File.split(target)
    target_prefix[0,0] = '/'
  else
    target_prefix = ""
  end

  srcprefix ||= "$(srcdir)/#{srcprefix}".chomp('/')
  RbConfig.expand(srcdir = srcprefix.dup)

  ext = ".#{$OBJEXT}"
  if not $objs
    srcs = $srcs || Dir[File.join(srcdir, "*.{#{SRC_EXT.join(%q{,})}}")]
    objs = srcs.inject(Hash.new {[]}) {|h, f| h[File.basename(f, ".*") << ext] <<= f; h}
    $objs = objs.keys
    unless objs.delete_if {|b, f| f.size == 1}.empty?
      dups = objs.sort.map {|b, f|
        "#{b[/.*\./]}{#{f.collect {|n| n[/([^.]+)\z/]}.join(',')}}"
      }
      abort "source files duplication - #{dups.join(", ")}"
    end
  else
    $objs.collect! {|o| File.basename(o, ".*") << ext} unless $OBJEXT == "o"
    srcs = $srcs || $objs.collect {|o| o.chomp(ext) << ".c"}
  end
  $srcs = srcs

  target = nil if $objs.empty?

  if target and EXPORT_PREFIX
    if File.exist?(File.join(srcdir, target + '.def'))
      deffile = "$(srcdir)/$(TARGET).def"
      unless EXPORT_PREFIX.empty?
        makedef = %Q{-pe "$_.sub!(/^(?=\\w)/,'#{EXPORT_PREFIX}') unless 1../^EXPORTS$/i"}
      end
    else
      makedef = %Q{-e "puts 'EXPORTS', '$(TARGET_ENTRY)'"}
    end
    if makedef
      $cleanfiles << '$(DEFFILE)'
      origdef = deffile
      deffile = "$(TARGET)-$(arch).def"
    end
  end
  origdef ||= ''

  if $extout and $INSTALLFILES
    $cleanfiles.concat($INSTALLFILES.collect {|files, dir|File.join(dir, files.sub(/\A\.\//, ''))})
    $distcleandirs.concat($INSTALLFILES.collect {|files, dir| dir})
  end

  if $extmk and not $extconf_h
    create_header
  end

  libpath = libpathflag(libpath)

  dllib = target ? "$(TARGET).#{CONFIG['DLEXT']}" : ""
  staticlib = target ? "$(TARGET).#$LIBEXT" : ""
  mfile = open("Makefile", "wb")
  conf = configuration(srcprefix)
  conf = yield(conf) if block_given?
  mfile.puts(conf)
  mfile.print "
libpath = #{($DEFLIBPATH|$LIBPATH).join(" ")}
LIBPATH = #{libpath}
DEFFILE = #{deffile}

CLEANFILES = #{$cleanfiles.join(' ')}
DISTCLEANFILES = #{$distcleanfiles.join(' ')}
DISTCLEANDIRS = #{$distcleandirs.join(' ')}

extout = #{$extout && $extout.quote}
extout_prefix = #{$extout_prefix}
target_prefix = #{target_prefix}
LOCAL_LIBS = #{$LOCAL_LIBS}
LIBS = #{$LIBRUBYARG} #{$libs} #{$LIBS}
SRCS = #{srcs.collect(&File.method(:basename)).join(' ')}
OBJS = #{$objs.join(" ")}
TARGET = #{target}
TARGET_NAME = #{target && target[/\A\w+/]}
TARGET_ENTRY = #{EXPORT_PREFIX || ''}Init_$(TARGET_NAME)
DLLIB = #{dllib}
EXTSTATIC = #{$static || ""}
STATIC_LIB = #{staticlib unless $static.nil?}
#{!$extout && defined?($installed_list) ? "INSTALLED_LIST = #{$installed_list}\n" : ""}
" #"
  # TODO: fixme
  install_dirs.each {|d| mfile.print("%-14s= %s\n" % d) if /^[[:upper:]]/ =~ d[0]}
  n = ($extout ? '$(RUBYARCHDIR)/' : '') + '$(TARGET)'
  mfile.print "
TARGET_SO     = #{($extout ? '$(RUBYARCHDIR)/' : '')}$(DLLIB)
CLEANLIBS     = #{n}.#{CONFIG['DLEXT']} #{config_string('cleanlibs') {|t| t.gsub(/\$\*/) {n}}}
CLEANOBJS     = *.#{$OBJEXT} #{config_string('cleanobjs') {|t| t.gsub(/\$\*/, "$(TARGET)#{deffile ? '-$(arch)': ''}")} if target} *.bak

all:    #{$extout ? "install" : target ? "$(DLLIB)" : "Makefile"}
static: $(STATIC_LIB)#{$extout ? " install-rb" : ""}
.PHONY: all install static install-so install-rb
.PHONY: clean clean-so clean-rb
"
  mfile.print CLEANINGS
  fsep = config_string('BUILD_FILE_SEPARATOR') {|s| s unless s == "/"}
  if fsep
    sep = ":/=#{fsep}"
    fseprepl = proc {|s|
      s = s.gsub("/", fsep)
      s = s.gsub(/(\$\(\w+)(\))/) {$1+sep+$2}
      s = s.gsub(/(\$\{\w+)(\})/) {$1+sep+$2}
    }
    rsep = ":#{fsep}=/"
  else
    fseprepl = proc {|s| s}
    sep = ""
    rsep = ""
  end
  dirs = []
  mfile.print "install: install-so install-rb\n\n"
  sodir = (dir = "$(RUBYARCHDIR)").dup
  mfile.print("install-so: ")
  if target
    f = "$(DLLIB)"
    dest = "#{dir}/#{f}"
    mfile.puts dest
    if $extout
      mfile.print "clean-so::\n"
      mfile.print "\t-$(Q)$(RM) #{fseprepl[dest]}\n"
      mfile.print "\t-$(Q)$(RMDIRS) #{fseprepl[dir]}#{$ignore_error}\n"
    else
      mfile.print "#{dest}: #{f}\n\t-$(Q)$(MAKEDIRS) $(@D#{sep})\n"
      mfile.print "\t$(INSTALL_PROG) #{fseprepl[f]} $(@D#{sep})\n"
      if defined?($installed_list)
        mfile.print "\t@echo #{dir}/#{File.basename(f)}>>$(INSTALLED_LIST)\n"
      end
    end
    mfile.print "clean-static::\n"
    mfile.print "\t-$(Q)$(RM) $(STATIC_LIB)\n"
  else
    mfile.puts "Makefile"
  end
  mfile.print("install-rb: pre-install-rb install-rb-default\n")
  mfile.print("install-rb-default: pre-install-rb-default\n")
  mfile.print("pre-install-rb: Makefile\n")
  mfile.print("pre-install-rb-default: Makefile\n")
  for sfx, i in [["-default", [["lib/**/*.rb", "$(RUBYLIBDIR)", "lib"]]], ["", $INSTALLFILES]]
    files = install_files(mfile, i, nil, srcprefix) or next
    for dir, *files in files
      unless dirs.include?(dir)
        dirs << dir
        mfile.print "pre-install-rb#{sfx}: #{timestamp_file(dir)}\n"
      end
      for f in files
        dest = "#{dir}/#{File.basename(f)}"
        mfile.print("install-rb#{sfx}: #{dest} #{dir}\n")
        mfile.print("#{dest}: #{f}\n")
        mfile.print("\t$(Q) $(#{$extout ? 'COPY' : 'INSTALL_DATA'}) #{f} $(@D#{sep})\n")
        if defined?($installed_list) and !$extout
          mfile.print("\t@echo #{dest}>>$(INSTALLED_LIST)\n")
        end
        if $extout
          mfile.print("clean-rb#{sfx}::\n")
          mfile.print("\t@-$(RM) #{fseprepl[dest]}\n")
        end
      end
    end
    mfile.print "pre-install-rb#{sfx}:\n"
    mfile.print("\t$(ECHO) installing#{sfx.sub(/^-/, " ")} #{target} libraries\n")
    if $extout
      dirs.uniq!
      unless dirs.empty?
        mfile.print("clean-rb#{sfx}::\n")
        for dir in dirs.sort_by {|d| -d.count('/')}
          mfile.print("\t@-$(RMDIRS) #{fseprepl[dir]}#{$ignore_error}\n")
        end
      end
    end
  end
  dirs.unshift(sodir) if target and !dirs.include?(sodir)
  dirs.each do |d|
    t = timestamp_file(d)
    mfile.print "#{t}:\n\t$(Q) $(MAKEDIRS) #{d}\n\t$(Q) $(TOUCH) $@\n"
  end

  mfile.print <<-SITEINSTALL

site-install: site-install-so site-install-rb
site-install-so: install-so
site-install-rb: install-rb

  SITEINSTALL

  return unless target

  mfile.puts SRC_EXT.collect {|e| ".path.#{e} = $(VPATH)"} if $nmake == b
  mfile.print ".SUFFIXES: .#{SRC_EXT.join(' .')} .#{$OBJEXT}\n"
  mfile.print "\n"

  compile_command = "\n\t$(ECHO) compiling $(<#{rsep})\n\t$(Q) %s\n\n"
  CXX_EXT.each do |e|
    COMPILE_RULES.each do |rule|
      mfile.printf(rule, e, $OBJEXT)
      mfile.printf(compile_command, COMPILE_CXX)
    end
  end
  C_EXT.each do |e|
    COMPILE_RULES.each do |rule|
      mfile.printf(rule, e, $OBJEXT)
      mfile.printf(compile_command, COMPILE_C)
    end
  end

  mfile.print "$(RUBYARCHDIR)/" if $extout
  mfile.print "$(DLLIB): "
  mfile.print "$(DEFFILE) " if makedef
  mfile.print "$(OBJS) Makefile"
  mfile.print " #{timestamp_file('$(RUBYARCHDIR)')}" if $extout
  mfile.print "\n"
  mfile.print "\t$(ECHO) linking shared-object #{target_prefix.sub(/\A\/(.*)/, '\1/')}$(DLLIB)\n"
  mfile.print "\t-$(Q)$(RM) $(@#{sep})\n"
  link_so = LINK_SO.gsub(/^/, "\t$(Q) ")
  if srcs.any?(&%r\.(?:#{CXX_EXT.join('|')})\z".method(:===))
    link_so = link_so.sub(/\bLDSHARED\b/, '\&XX')
  end
  mfile.print link_so, "\n\n"
  unless $static.nil?
    mfile.print "$(STATIC_LIB): $(OBJS)\n\t@-$(RM) $(@#{sep})\n\t"
    mfile.print "$(ECHO) linking static-library $(@#{rsep})\n\t$(Q) "
    mfile.print "$(AR) #{config_string('ARFLAGS') || 'cru '}$@ $(OBJS)"
    config_string('RANLIB') do |ranlib|
      mfile.print "\n\t@-#{ranlib} $(DLLIB) 2> /dev/null || true"
    end
  end
  mfile.print "\n\n"
  if makedef
    mfile.print "$(DEFFILE): #{origdef}\n"
    mfile.print "\t$(ECHO) generating $(@#{rsep})\n"
    mfile.print "\t$(Q) $(RUBY) #{makedef} #{origdef} > $@\n\n"
  end

  depend = File.join(srcdir, "depend")
  if File.exist?(depend)
    mfile.print("###\n", *depend_rules(File.read(depend)))
  else
    headers = %w[$(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h]
    if RULE_SUBST
      headers.each {|h| h.sub!(/.*/, &RULE_SUBST.method(:%))}
    end
    headers << $config_h
    headers << '$(RUBY_EXTCONF_H)' if $extconf_h
    mfile.print "$(OBJS): ", headers.join(' '), "\n"
  end

  $makefile_created = true
ensure
  mfile.close if mfile
end
dclone()

provides a unified cloneoperation, for REXML::XPathParser to use across multiple Object types

# File lib/rexml/xpath_parser.rb, line 10
def dclone
  clone
end
default_src_encoding()

DO NOT WRITE ANY MAGIC COMMENT HERE.

# File lib/irb/src_encoding.rb, line 2
def default_src_encoding
  return __ENCODING__
end
define_singleton_method(symbol, method) → new_method define_singleton_method(symbol) { block } → proc

Defines a singleton method in the receiver. The methodparameter can be a Proc, a Methodor an UnboundMethodobject. If a block is specified, it is used as the method body.

class A
  class << self
    def class_name
      to_s
    end
  end
end
A.define_singleton_method(:who_am_i) do
  "I am: #{class_name}"
end
A.who_am_i   # ==> "I am: A"

guy = "Bob"
guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
guy.hello    #=>  "Bob: Hello there!"
static VALUE
rb_obj_define_method(int argc, VALUE *argv, VALUE obj)
{
    VALUE klass = rb_singleton_class(obj);

    return rb_mod_define_method(argc, argv, klass);
}
depend_rules(depend)

Processes the data contents of the “depend” file. Each line of this file is expected to be a file name.

Returns the output of findings, in Makefile format.

# File lib/mkmf.rb, line 1785
def depend_rules(depend)
  suffixes = []
  depout = []
  cont = implicit = nil
  impconv = proc do
    COMPILE_RULES.each {|rule| depout << (rule % implicit[0]) << implicit[1]}
    implicit = nil
  end
  ruleconv = proc do |line|
    if implicit
      if /\A\t/ =~ line
        implicit[1] << line
        next
      else
        impconv[]
      end
    end
    if m = /\A\.(\w+)\.(\w+)(?:\s*:)/.match(line)
      suffixes << m[1] << m[2]
      implicit = [[m[1], m[2]], [m.post_match]]
      next
    elsif RULE_SUBST and /\A(?!\s*\w+\s*=)[$\w][^#]*:/ =~ line
      line.gsub!(%r(\s)(?!\.)([^$(){}+=:\s\/\,]+)(?=\s|\z)") {$1 + RULE_SUBST % $2}
    end
    depout << line
  end
  depend.each_line do |line|
    line.gsub!(/\.o\b/, ".#{$OBJEXT}")
    line.gsub!(/\$\((?:hdr|top)dir\)\/config.h/, $config_h)
    line.gsub!(%r\$\(hdrdir\)/(?!ruby(?![^:;/\s]))(?=[-\w]+\.h)", '\&ruby/')
    if $nmake && /\A\s*\$\(RM|COPY\)/ =~ line
      line.gsub!(%r[-\w\./]{2,}"){$&.tr("/", "\\")}
      line.gsub!(/(\$\((?!RM|COPY)[^:)]+)(?=\))/, '\1:/=\')
    end
    if /(?:^|[^\])(?:\\)*\$/ =~ line
      (cont ||= []) << line
      next
    elsif cont
      line = (cont << line).join
      cont = nil
    end
    ruleconv.call(line)
  end
  if cont
    ruleconv.call(cont.join)
  elsif implicit
    impconv.call
  end
  unless suffixes.empty?
    depout.unshift(".SUFFIXES: ." + suffixes.uniq.join(" .") + "\n\n")
  end
  depout.unshift("$(OBJS): $(RUBY_EXTCONF_H)\n\n") if $extconf_h
  depout.flatten!
  depout
end
dir_config(target, idefault=nil, ldefault=nil)

Sets a targetname that the user can then use to configure various 'with' options with on the command line by using that name. For example, if the target is set to “foo”, then the user could use the –with-foo-dir command line option.

You may pass along additional 'include' or 'lib' defaults via the idefaultand ldefaultparameters, respectively.

Note that #dir_config only adds to the list of places to search for libraries and include files. It does not link the libraries into your application.

# File lib/mkmf.rb, line 1533
def dir_config(target, idefault=nil, ldefault=nil)
  if dir = with_config(target + "-dir", (idefault unless ldefault))
    defaults = Array === dir ? dir : dir.split(File::PATH_SEPARATOR)
    idefault = ldefault = nil
  end

  idir = with_config(target + "-include", idefault)
  $arg_config.last[1] ||= "${#{target}-dir}/include"
  ldir = with_config(target + "-lib", ldefault)
  $arg_config.last[1] ||= "${#{target}-dir}/#{@libdir_basename}"

  idirs = idir ? Array === idir ? idir.dup : idir.split(File::PATH_SEPARATOR) : []
  if defaults
    idirs.concat(defaults.collect {|d| d + "/include"})
    idir = ([idir] + idirs).compact.join(File::PATH_SEPARATOR)
  end
  unless idirs.empty?
    idirs.collect! {|d| "-I" + d}
    idirs -= Shellwords.shellwords($CPPFLAGS)
    unless idirs.empty?
      $CPPFLAGS = (idirs.quote << $CPPFLAGS).join(" ")
    end
  end

  ldirs = ldir ? Array === ldir ? ldir.dup : ldir.split(File::PATH_SEPARATOR) : []
  if defaults
      ldirs.concat(defaults.collect {|d| "#{d}/#{@libdir_basename}"})
    ldir = ([ldir] + ldirs).compact.join(File::PATH_SEPARATOR)
  end
  $LIBPATH = ldirs | $LIBPATH

  [idir, ldir]
end
obj.display(port=$>) → nil

Prints objon the given port (default $>). Equivalent to:

def display(port=$>)
  port.write self
end

For example:

1.display
"cat".display
[ 4, 5, 6 ].display
puts

produces:

1cat456
static VALUE
rb_obj_display(int argc, VALUE *argv, VALUE self)
{
    VALUE out;

    if (argc == 0) {
        out = rb_stdout;
    }
    else {
        rb_scan_args(argc, argv, "01", &out);
    }
    rb_io_write(out, self);

    return Qnil;
}
dummy_makefile(srcdir)

creates a stub Makefile.

# File lib/mkmf.rb, line 1768
def dummy_makefile(srcdir)
  configuration(srcdir) << "CLEANFILES = #{$cleanfiles.join(' ')}
DISTCLEANFILES = #{$distcleanfiles.join(' ')}

all install static install-so install-rb: Makefile
.PHONY: all install static install-so install-rb
.PHONY: clean clean-so clean-rb

" << CLEANINGS
end
obj.dup → an_object

Produces a shallow copy of obj—the instance variables of objare copied, but not the objects they reference. dupcopies the tainted state of obj. See also the discussion under Object#clone. In general, clone and dupmay have different semantics in descendant classes. While cloneis used to duplicate an object, including its internal state, duptypically uses the class of the descendant object to create the new instance.

This method may have class-specific behavior. If so, that behavior will be documented under the # initialize_copymethod of the class.

VALUE
rb_obj_dup(VALUE obj)
{
    VALUE dup;

    if (rb_special_const_p(obj)) {
        rb_raise(rb_eTypeError, "can't dup %s", rb_obj_classname(obj));
    }
    dup = rb_obj_alloc(rb_obj_class(obj));
    init_copy(dup, obj);
    rb_funcall(dup, id_init_dup, 1, obj);

    return dup;
}
enable_config(config, default=nil)

Tests for the presence of an –enable- configor –disable- configoption. Returns true if the enable option is given, false if the disable option is given, and the default value otherwise.

This can be useful for adding custom definitions, such as debug information.

Example:

if enable_config("debug")
   $defs.push("-DOSSL_DEBUG") unless $defs.include? "-DOSSL_DEBUG"
end
# File lib/mkmf.rb, line 1461
def enable_config(config, default=nil)
  if arg_config("--enable-"+config)
    true
  elsif arg_config("--disable-"+config)
    false
  elsif block_given?
    yield(config, default)
  else
    return default
  end
end
obj.to_enum(method = :each, *args) obj.enum_for(method = :each, *args)

Creates a new Enumerator which will enumerate by on calling methodon obj.

method

the method to call on objto generate the enumeration

args

arguments that will be passed in method in addition to the item itself. Note that the number of args must not exceed the number expected by method

Example

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

# protect an array from being modified by some_method
a = [1, 2, 3]
some_method(a.to_enum)
static VALUE
obj_to_enum(int argc, VALUE *argv, VALUE obj)
{
    VALUE meth = sym_each;

    if (argc > 0) {
        --argc;
        meth = *argv++;
    }
    return rb_enumeratorize(obj, meth, argc, argv);
}
obj == other → true or false obj.equal?(other) → true or false obj.eql?(other) → true or false

Equality—At the Objectlevel, ==returns trueonly if objand otherare the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.

Unlike ==, the equal?method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b)iff ais the same object as b).

The eql?method returns trueif objand anObject have the same value. Used by Hashto test members for equality. For objects of class Object, eql?is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numerictypes, for example, perform type conversion across ==, but not across eql?, so:

1 == 1.0     #=> true
1.eql? 1.0   #=> false
VALUE
rb_obj_equal(VALUE obj1, VALUE obj2)
{
    if (obj1 == obj2) return Qtrue;
    return Qfalse;
}
obj.extend(module, ...) → obj

Adds to objthe instance methods from each module given as a parameter.

module Mod
  def hello
    "Hello from Mod.\n"
  end
end

class Klass
  def hello
    "Hello from Klass.\n"
  end
end

k = Klass.new
k.hello         #=> "Hello from Klass.\n"
k.extend(Mod)   #=> #<Klass:0x401b3bc8>
k.hello         #=> "Hello from Mod.\n"
static VALUE
rb_obj_extend(int argc, VALUE *argv, VALUE obj)
{
    int i;

    if (argc == 0) {
        rb_raise(rb_eArgError, "wrong number of arguments (at least 1)");
    }
    for (i = 0; i < argc; i++)
        Check_Type(argv[i], T_MODULE);
    while (argc--) {
        rb_funcall(argv[argc], rb_intern("extend_object"), 1, obj);
        rb_funcall(argv[argc], rb_intern("extended"), 1, obj);
    }
    return obj;
}
find_executable(bin, path = nil)

Searches for the executable binon path. The default path is your PATH environment variable. If that isn't defined, it will resort to searching /usr/local/bin, /usr/ucb, /usr/bin and /bin.

If found, it will return the full path, including the executable name, of where it was found.

Note that this method does not actually affect the generated Makefile.

# File lib/mkmf.rb, line 1395
def find_executable(bin, path = nil)
  checking_for checking_message(bin, path) do
    find_executable0(bin, path)
  end
end
find_header(header, *paths)

Instructs mkmf to search for the given headerin any of the pathsprovided, and returns whether or not it was found in those paths.

If the header is found then the path it was found on is added to the list of included directories that are sent to the compiler (via the -I switch).

# File lib/mkmf.rb, line 979
def find_header(header, *paths)
  message = checking_message(header, paths)
  header = cpp_include(header)
  checking_for message do
    if try_header(header)
      true
    else
      found = false
      paths.each do |dir|
        opt = "-I#{dir}".quote
        if try_header(header, opt)
          $INCFLAGS << " " << opt
          found = true
          break
        end
      end
      found
    end
  end
end
find_library(lib, func, *paths, &b)

Returns whether or not the entry point funccan be found within the library libin one of the paths specified, where pathsis an array of strings. If funcis nil , then the main() function is used as the entry point.

If libis found, then the path it was found on is added to the list of library paths searched and linked against.

# File lib/mkmf.rb, line 862
def find_library(lib, func, *paths, &b)
  func = "main" if !func or func.empty?
  lib = with_config(lib+'lib', lib)
  paths = paths.collect {|path| path.split(File::PATH_SEPARATOR)}.flatten
  checking_for "#{func}() in #{LIBARG%lib}" do
    libpath = $LIBPATH
    libs = append_library($libs, lib)
    begin
      until r = try_func(func, libs, &b) or paths.empty?
        $LIBPATH = libpath | [paths.shift]
      end
      if r
        $libs = libs
        libpath = nil
      end
    ensure
      $LIBPATH = libpath if libpath
    end
    r
  end
end
find_type(type, opt, *headers, &b)

Returns where the static type typeis defined.

You may also pass additional flags to optwhich are then passed along to the compiler.

See also have_type.

# File lib/mkmf.rb, line 1074
def find_type(type, opt, *headers, &b)
  opt ||= ""
  fmt = "not found"
  def fmt.%(x)
    x ? x.respond_to?(:join) ? x.join(",") : x : self
  end
  checking_for checking_message(type, nil, opt), fmt do
    headers.find do |h|
      try_type(type, h, opt, &b)
    end
  end
end
obj.freeze → obj

Prevents further modifications to obj. A RuntimeError will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also Object#frozen?.

This method returns self.

a = [ "a", "b", "c" ]
a.freeze
a << "z"

produces:

prog.rb:3:in `<<': can't modify frozen array (RuntimeError)
 from prog.rb:3
VALUE
rb_obj_freeze(VALUE obj)
{
    if (!OBJ_FROZEN(obj)) {
        if (rb_safe_level() >= 4 && !OBJ_UNTRUSTED(obj)) {
            rb_raise(rb_eSecurityError, "Insecure: can't freeze object");
        }
        OBJ_FREEZE(obj);
        if (SPECIAL_CONST_P(obj)) {
            if (!immediate_frozen_tbl) {
                immediate_frozen_tbl = st_init_numtable();
            }
            st_insert(immediate_frozen_tbl, obj, (st_data_t)Qtrue);
        }
    }
    return obj;
}
obj.frozen? → true or false

Returns the freeze status of obj.

a = [ "a", "b", "c" ]
a.freeze    #=> ["a", "b", "c"]
a.frozen?   #=> true
VALUE
rb_obj_frozen_p(VALUE obj)
{
    if (OBJ_FROZEN(obj)) return Qtrue;
    if (SPECIAL_CONST_P(obj)) {
        if (!immediate_frozen_tbl) return Qfalse;
        if (st_lookup(immediate_frozen_tbl, obj, 0)) return Qtrue;
    }
    return Qfalse;
}
hash()

Generates a Fixnumhash value for this object. This function must have the property that a.eql?(b) implies a.hash == b.hash. The hash value is used by class Hash. Any hash value that exceeds the capacity of a Fixnumwill be truncated before being used.

"waffle".hash #=> -910576647
VALUE
rb_obj_hash(VALUE obj)
{
    VALUE oid = rb_obj_id(obj);
#if SIZEOF_LONG == SIZEOF_VOIDP
    st_index_t index = NUM2LONG(oid);
#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
    st_index_t index = NUM2LL(oid);
#else
# error not supported
#endif
    st_index_t h = rb_hash_end(rb_hash_start(index));
    return LONG2FIX(h);
}
have_const(const, headers = nil, opt = "", &b)

Returns whether or not the constant constis defined. You may optionally pass the typeof constas [const, type], like as:

have_const(%w[PTHREAD_MUTEX_INITIALIZER pthread_mutex_t], "pthread.h")

You may also pass additional headersto check against in addition to the common header files, and additional flags to optwhich are then passed along to the compiler.

If found, a macro is passed as a preprocessor constant to the compiler using the type name, in uppercase, prepended with 'HAVE_CONST_'.

For example, if #have_const('foo') returned true, then the HAVE_CONST_FOO preprocessor macro would be passed to the compiler.

# File lib/mkmf.rb, line 1122
def have_const(const, headers = nil, opt = "", &b)
  checking_for checking_message([*const].compact.join(' '), headers, opt) do
    try_const(const, headers, opt, &b)
  end
end
have_framework(fw, &b)

Returns whether or not the given frameworkcan be found on your system. If found, a macro is passed as a preprocessor constant to the compiler using the framework name, in uppercase, prepended with HAVE_FRAMEWORK_.

For example, if have_framework('Ruby')returned true, then the HAVE_FRAMEWORK_RUBYpreprocessor macro would be passed to the compiler.

If fwis a pair of the framework name and its header file name that header file is checked, instead of the normally used header file which is named same as the framework.

# File lib/mkmf.rb, line 951
def have_framework(fw, &b)
  if Array === fw
    fw, header = *fw
  else
    header = "#{fw}.h"
  end
  checking_for fw do
    src = cpp_include("#{fw}/#{header}") << "\n" "int main(void){return 0;}"
    opt = " -framework #{fw}"
    if try_link(src, "-ObjC#{opt}", &b)
      $defs.push(format("-DHAVE_FRAMEWORK_%s", fw.tr_cpp))
      # TODO: non-worse way than this hack, to get rid of separating
      # option and its argument.
      $LDFLAGS << " -ObjC" unless /(\A|\s)-ObjC(\s|\z)/ =~ $LDFLAGS
      $LDFLAGS << opt
      true
    else
      false
    end
  end
end
have_func(func, headers = nil, &b)

Returns whether or not the function funccan be found in the common header files, or within any headersthat you provide. If found, a macro is passed as a preprocessor constant to the compiler using the function name, in uppercase, prepended with 'HAVE_'.

For example, if #have_func('foo') returned true, then the HAVE_FOO preprocessor macro would be passed to the compiler.

# File lib/mkmf.rb, line 892
def have_func(func, headers = nil, &b)
  checking_for checking_message("#{func}()", headers) do
    if try_func(func, $libs, headers, &b)
      $defs.push(format("-DHAVE_%s", func.tr_cpp))
      true
    else
      false
    end
  end
end
have_header(header, preheaders = nil, &b)

Returns whether or not the given headerfile can be found on your system. If found, a macro is passed as a preprocessor constant to the compiler using the header file name, in uppercase, prepended with 'HAVE_'.

For example, if #have_header('foo.h') returned true, then the HAVE_FOO_H preprocessor macro would be passed to the compiler.

# File lib/mkmf.rb, line 929
def have_header(header, preheaders = nil, &b)
  checking_for header do
    if try_header(cpp_include(preheaders)+cpp_include(header), &b)
      $defs.push(format("-DHAVE_%s", header.tr_cpp))
      true
    else
      false
    end
  end
end
have_library(lib, func = nil, headers = nil, &b)

Returns whether or not the given entry point funccan be found within lib. If funcis nil, the 'main()' entry point is used by default. If found, it adds the library to list of libraries to be used when linking your extension.

If headersare provided, it will include those header files as the header files it looks in when searching for func.

The real name of the library to be linked can be altered by '–with-FOOlib' configuration option.

# File lib/mkmf.rb, line 837
def have_library(lib, func = nil, headers = nil, &b)
  func = "main" if !func or func.empty?
  lib = with_config(lib+'lib', lib)
  checking_for checking_message("#{func}()", LIBARG%lib) do
    if COMMON_LIBS.include?(lib)
      true
    else
      libs = append_library($libs, lib)
      if try_func(func, libs, headers, &b)
        $libs = libs
        true
      else
        false
      end
    end
  end
end
have_macro(macro, headers = nil, opt = "", &b)

Returns whether or not macrois defined either in the common header files or within any headersyou provide.

Any options you pass to optare passed along to the compiler.

# File lib/mkmf.rb, line 820
def have_macro(macro, headers = nil, opt = "", &b)
  checking_for checking_message(macro, headers, opt) do
    macro_defined?(macro, cpp_include(headers), opt, &b)
  end
end
have_struct_member(type, member, headers = nil, &b)

Returns whether or not the struct of type typecontains member. If it does not, or the struct type can't be found, then false is returned. You may optionally specify additional headersin which to look for the struct (in addition to the common header files).

If found, a macro is passed as a preprocessor constant to the compiler using the type name and the member name, in uppercase, prepended with 'HAVE_'.

For example, if #have_struct_member('struct foo', 'bar') returned true, then the HAVE_STRUCT_FOO_BAR preprocessor macro would be passed to the compiler.

HAVE_ST_BAR is also defined for backward compatibility.

# File lib/mkmf.rb, line 1013
def have_struct_member(type, member, headers = nil, &b)
  checking_for checking_message("#{type}.#{member}", headers) do
    if try_compile("#{cpp_include(headers)}
/*top*/
int s = (char *)&((#{type}*)0)->#{member} - (char *)0;
#{MAIN_DOES_NOTHING "s"}
", &b)
      $defs.push(format("-DHAVE_%s_%s", type.tr_cpp, member.tr_cpp))
      $defs.push(format("-DHAVE_ST_%s", member.tr_cpp)) # backward compatibility
      true
    else
      false
    end
  end
end
have_type(type, headers = nil, opt = "", &b)

Returns whether or not the static type typeis defined. You may optionally pass additional headersto check against in addition to the common header files.

You may also pass additional flags to optwhich are then passed along to the compiler.

If found, a macro is passed as a preprocessor constant to the compiler using the type name, in uppercase, prepended with 'HAVE_TYPE_'.

For example, if #have_type('foo') returned true, then the HAVE_TYPE_FOO preprocessor macro would be passed to the compiler.

# File lib/mkmf.rb, line 1061
def have_type(type, headers = nil, opt = "", &b)
  checking_for checking_message(type, headers, opt) do
    try_type(type, headers, opt, &b)
  end
end
have_var(var, headers = nil, &b)

Returns whether or not the variable varcan be found in the common header files, or within any headersthat you provide. If found, a macro is passed as a preprocessor constant to the compiler using the variable name, in uppercase, prepended with 'HAVE_'.

For example, if #have_var('foo') returned true, then the HAVE_FOO preprocessor macro would be passed to the compiler.

# File lib/mkmf.rb, line 911
def have_var(var, headers = nil, &b)
  checking_for checking_message(var, headers) do
    if try_var(var, headers, &b)
      $defs.push(format("-DHAVE_%s", var.tr_cpp))
      true
    else
      false
    end
  end
end
help()

Display help message.

ruby -run -e help [COMMAND]
# File lib/un.rb, line 335
def help
  setup do |argv,|
    all = argv.empty?
    open(__FILE__) do |me|
      while me.gets("##\n")
        if help = me.gets("\n\n")
          if all or argv.delete help[/-e \w+/].sub(/-e /, "")
            print help.gsub(/^# ?/, "")
          end
        end
      end
    end
  end
end
httpd()

Run WEBrick HTTP server.

ruby -run -e httpd -- [OPTION] DocumentRoot

--bind-address=ADDR         address to bind
--port=NUM                  listening port number
--max-clients=MAX           max number of simultaneous clients
--temp-dir=DIR              temporary directory
--do-not-reverse-lookup     disable reverse lookup
--request-timeout=SECOND    request timeout in seconds
--http-version=VERSION      HTTP version
-v                          verbose
# File lib/un.rb, line 305
def httpd
  setup("", "BindAddress=ADDR", "Port=PORT", "MaxClients=NUM", "TempDir=DIR",
        "DoNotReverseLookup", "RequestTimeout=SECOND", "HTTPVersion=VERSION") do
    |argv, options|
    require 'webrick'
    opt = options[:RequestTimeout] and options[:RequestTimeout] = opt.to_i
    [:Port, :MaxClients].each do |name|
      opt = options[name] and (options[name] = Integer(opt)) rescue nil
    end
    unless argv.empty?
      options[:DocumentRoot] = argv.shift
    end
    s = WEBrick::HTTPServer.new(options)
    shut = proc {s.shutdown}
    Signal.trap("TERM", shut)
    Signal.trap("QUIT", shut) if Signal.list.has_key?("QUIT")
    if STDIN.tty?
      Signal.trap("HUP", shut) if Signal.list.has_key?("HUP")
      Signal.trap("INT", shut)
    end
    s.start
  end
end
obj.inspect → string

Returns a string containing a human-readable representation of obj. If not overridden and no instance variables, uses the to_smethod to generate the string. obj. If not overridden, uses the to_smethod to generate the string.

[ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"
static VALUE
rb_obj_inspect(VALUE obj)
{
    if (TYPE(obj) == T_OBJECT && rb_obj_basic_to_s_p(obj)) {
        int has_ivar = 0;
        VALUE *ptr = ROBJECT_IVPTR(obj);
        long len = ROBJECT_NUMIV(obj);
        long i;

        for (i = 0; i < len; i++) {
            if (ptr[i] != Qundef) {
                has_ivar = 1;
                break;
            }
        }

        if (has_ivar) {
            VALUE str;
            const char *c = rb_obj_classname(obj);

            str = rb_sprintf("-<%s:%p", c, (void*)obj);
            return rb_exec_recursive(inspect_obj, obj, str);
        }
        return rb_any_to_s(obj);
    }
    return rb_funcall(obj, rb_intern("to_s"), 0, 0);
}
install()

Copy SOURCE to DEST.

ruby -run -e install -- [OPTION] SOURCE DEST

-p          apply access/modification times of SOURCE files to
            corresponding destination files
-m          set permission mode (as in chmod), instead of 0755
-v          verbose
# File lib/un.rb, line 188
def install
  setup("pm:") do |argv, options|
    options[:mode] = (mode = options.delete :m) ? mode.oct : 0755
    options[:preserve] = true if options.delete :p
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.install argv, dest, options
  end
end
obj.instance_of?(class) → true or false

Returns trueif objis an instance of the given class. See also Object#kind_of?.

class A;     end
class B < A; end
class C < B; end

b = B.new
b.instance_of? A   #=> false
b.instance_of? B   #=> true
b.instance_of? C   #=> false
VALUE
rb_obj_is_instance_of(VALUE obj, VALUE c)
{
    switch (TYPE(c)) {
      case T_MODULE:
      case T_CLASS:
      case T_ICLASS:
        break;
      default:
        rb_raise(rb_eTypeError, "class or module required");
    }

    if (rb_obj_class(obj) == c) return Qtrue;
    return Qfalse;
}
obj.instance_variable_defined?(symbol) → true or false

Returns trueif the given instance variable is defined in obj.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_defined?(:@a)    #=> true
fred.instance_variable_defined?("@b")   #=> true
fred.instance_variable_defined?("@c")   #=> false
static VALUE
rb_obj_ivar_defined(VALUE obj, VALUE iv)
{
    ID id = rb_to_id(iv);

    if (!rb_is_instance_id(id)) {
        rb_name_error(id, "`%s' is not allowed as an instance variable name", rb_id2name(id));
    }
    return rb_ivar_defined(obj, id);
}
obj.instance_variable_get(symbol) → obj

Returns the value of the given instance variable, or nil if the instance variable is not set. The @part of the variable name should be included for regular instance variables. Throws a NameError exception if the supplied symbol is not valid as an instance variable name.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_get(:@a)    #=> "cat"
fred.instance_variable_get("@b")   #=> 99
static VALUE
rb_obj_ivar_get(VALUE obj, VALUE iv)
{
    ID id = rb_to_id(iv);

    if (!rb_is_instance_id(id)) {
        rb_name_error(id, "`%s' is not allowed as an instance variable name", rb_id2name(id));
    }
    return rb_ivar_get(obj, id);
}
obj.instance_variable_set(symbol, obj) → obj

Sets the instance variable names by symbolto object, thereby frustrating the efforts of the class's author to attempt to provide proper encapsulation. The variable did not have to exist prior to this call.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_set(:@a, 'dog')   #=> "dog"
fred.instance_variable_set(:@c, 'cat')   #=> "cat"
fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
static VALUE
rb_obj_ivar_set(VALUE obj, VALUE iv, VALUE val)
{
    ID id = rb_to_id(iv);

    if (!rb_is_instance_id(id)) {
        rb_name_error(id, "`%s' is not allowed as an instance variable name", rb_id2name(id));
    }
    return rb_ivar_set(obj, id, val);
}
obj.instance_variables → array

Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable.

class Fred
  attr_accessor :a1
  def initialize
    @iv = 3
  end
end
Fred.new.instance_variables   #=> [:@iv]
VALUE
rb_obj_instance_variables(VALUE obj)
{
    VALUE ary;

    ary = rb_ary_new();
    rb_ivar_foreach(obj, ivar_i, ary);
    return ary;
}
obj.is_a?(class) → true or false obj.kind_of?(class) → true or false

Returns trueif classis the class of obj, or if classis one of the superclasses of objor modules included in obj.

module M;    end
class A
  include M
end
class B < A; end
class C < B; end

b = B.new
b.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

b.kind_of? A       #=> true
b.kind_of? B       #=> true
b.kind_of? C       #=> false
b.kind_of? M       #=> true
VALUE
rb_obj_is_kind_of(VALUE obj, VALUE c)
{
    VALUE cl = CLASS_OF(obj);

    switch (TYPE(c)) {
      case T_MODULE:
      case T_CLASS:
      case T_ICLASS:
        break;

      default:
        rb_raise(rb_eTypeError, "class or module required");
    }

    while (cl) {
        if (cl == c || RCLASS_M_TBL(cl) == RCLASS_M_TBL(c))
            return Qtrue;
        cl = RCLASS_SUPER(cl);
    }
    return Qfalse;
}
obj.is_a?(class) → true or false obj.kind_of?(class) → true or false

Returns trueif classis the class of obj, or if classis one of the superclasses of objor modules included in obj.

module M;    end
class A
  include M
end
class B < A; end
class C < B; end

b = B.new
b.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

b.kind_of? A       #=> true
b.kind_of? B       #=> true
b.kind_of? C       #=> false
b.kind_of? M       #=> true
VALUE
rb_obj_is_kind_of(VALUE obj, VALUE c)
{
    VALUE cl = CLASS_OF(obj);

    switch (TYPE(c)) {
      case T_MODULE:
      case T_CLASS:
      case T_ICLASS:
        break;

      default:
        rb_raise(rb_eTypeError, "class or module required");
    }

    while (cl) {
        if (cl == c || RCLASS_M_TBL(cl) == RCLASS_M_TBL(c))
            return Qtrue;
        cl = RCLASS_SUPER(cl);
    }
    return Qfalse;
}
ln()

Create a link to the specified TARGET with LINK_NAME.

ruby -run -e ln -- [OPTION] TARGET LINK_NAME

-s          make symbolic links instead of hard links
-f          remove existing destination files
-v          verbose
# File lib/un.rb, line 98
def ln
  setup("sf") do |argv, options|
    cmd = "ln"
    cmd += "_s" if options.delete :s
    options[:force] = true if options.delete :f
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.send cmd, argv, dest, options
  end
end
obj.method(sym) → method

Looks up the named method as a receiver in obj, returning a Methodobject (or raising NameError). The Methodobject acts as a closure in obj's object instance, so instance variables and the value of selfremain available.

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  end
end

k = Demo.new(99)
m = k.method(:hello)
m.call   #=> "Hello, @iv = 99"

l = Demo.new('Fred')
m = l.method("hello")
m.call   #=> "Hello, @iv = Fred"
VALUE
rb_obj_method(VALUE obj, VALUE vid)
{
    return mnew(CLASS_OF(obj), obj, rb_to_id(vid), rb_cMethod, FALSE);
}
obj.methods → array

Returns a list of the names of public and protected methods of obj. This will include all the methods accessible in obj's ancestors.

class Klass
  def klass_method()
  end
end
k = Klass.new
k.methods[0..9]    #=> [:klass_method, :nil?, :===,
                   #    :==~, :!, :eql?
                   #    :hash, :<=>, :class, :singleton_class]
k.methods.length   #=> 57
VALUE
rb_obj_methods(int argc, VALUE *argv, VALUE obj)
{
  retry:
    if (argc == 0) {
  VALUE args[1];

  args[0] = Qtrue;
  return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_i);
    }
    else {
  VALUE recur;

  rb_scan_args(argc, argv, "1", &recur);
  if (RTEST(recur)) {
      argc = 0;
      goto retry;
  }
  return rb_obj_singleton_methods(argc, argv, obj);
    }
}
mkdir()

Create the DIR, if they do not already exist.

ruby -run -e mkdir -- [OPTION] DIR

-p          no error if existing, make parent directories as needed
-v          verbose
# File lib/un.rb, line 153
def mkdir
  setup("p") do |argv, options|
    cmd = "mkdir"
    cmd += "_p" if options.delete :p
    FileUtils.send cmd, argv, options
  end
end
mkmf()

Create makefile using mkmf.

ruby -run -e mkmf -- [OPTION] EXTNAME [OPTION]

-d ARGS     run dir_config
-h ARGS     run have_header
-l ARGS     run have_library
-f ARGS     run have_func
-v ARGS     run have_var
-t ARGS     run have_type
-m ARGS     run have_macro
-c ARGS     run have_const
--vendor    install to vendor_ruby
# File lib/un.rb, line 274
def mkmf
  setup("d:h:l:f:v:t:m:c:", "vendor") do |argv, options|
    require 'mkmf'
    opt = options[:d] and opt.split(/:/).each {|n| dir_config(*n.split(/,/))}
    opt = options[:h] and opt.split(/:/).each {|n| have_header(*n.split(/,/))}
    opt = options[:l] and opt.split(/:/).each {|n| have_library(*n.split(/,/))}
    opt = options[:f] and opt.split(/:/).each {|n| have_func(*n.split(/,/))}
    opt = options[:v] and opt.split(/:/).each {|n| have_var(*n.split(/,/))}
    opt = options[:t] and opt.split(/:/).each {|n| have_type(*n.split(/,/))}
    opt = options[:m] and opt.split(/:/).each {|n| have_macro(*n.split(/,/))}
    opt = options[:c] and opt.split(/:/).each {|n| have_const(*n.split(/,/))}
    $configure_args["--vendor"] = true if options[:vendor]
    create_makefile(*argv)
  end
end
mv()

Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.

ruby -run -e mv -- [OPTION] SOURCE DEST

-v          verbose
# File lib/un.rb, line 117
def mv
  setup do |argv, options|
    dest = argv.pop
    argv = argv[0] if argv.size == 1
    FileUtils.mv argv, dest, options
  end
end
nil?()

call_seq:

nil.nil?               -> true
<anything_else>.nil?   -> false

Only the object nilresponds trueto nil?.

static VALUE
rb_false(VALUE obj)
{
    return Qfalse;
}
obj.__id__ → fixnum obj.object_id → fixnum

Returns an integer identifier for obj. The same number will be returned on all calls to idfor a given object, and no two active objects will share an id. Object#object_idis a different concept from the :namenotation, which returns the symbol id of name. Replaces the deprecated Object#id.

VALUE
rb_obj_id(VALUE obj)
{
    /*
     *                32-bit VALUE space
     *          MSB ------------------------ LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol  ssssssssssssssssssssssss00001110
     *  object  oooooooooooooooooooooooooooooo00        = 0 (mod sizeof(RVALUE))
     *  fixnum  fffffffffffffffffffffffffffffff1
     *
     *                    object_id space
     *                                       LSB
     *  false   00000000000000000000000000000000
     *  true    00000000000000000000000000000010
     *  nil     00000000000000000000000000000100
     *  undef   00000000000000000000000000000110
     *  symbol   000SSSSSSSSSSSSSSSSSSSSSSSSSSS0        S...S % A = 4 (S...S = s...s * A + 4)
     *  object   oooooooooooooooooooooooooooooo0        o...o % A = 0
     *  fixnum  fffffffffffffffffffffffffffffff1        bignum if required
     *
     *  where A = sizeof(RVALUE)/4
     *
     *  sizeof(RVALUE) is
     *  20 if 32-bit, double is 4-byte aligned
     *  24 if 32-bit, double is 8-byte aligned
     *  40 if 64-bit
     */
    if (SYMBOL_P(obj)) {
        return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
    }
    if (SPECIAL_CONST_P(obj)) {
        return LONG2NUM((SIGNED_VALUE)obj);
    }
    return nonspecial_obj_id(obj);
}
pretty_print(q)
# File lib/pp.rb, line 520
def pretty_print(q)
  q.text inspect
end
pretty_print_cycle(q)
# File lib/pp.rb, line 512
def pretty_print_cycle(q)
  q.text inspect
end
obj.private_methods(all=true) → array

Returns the list of private methods accessible to obj. If the allparameter is set to false, only those methods in the receiver will be listed.

VALUE
rb_obj_private_methods(int argc, VALUE *argv, VALUE obj)
{
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_priv_i);
}
obj.protected_methods(all=true) → array

Returns the list of protected methods accessible to obj. If the allparameter is set to false, only those methods in the receiver will be listed.

VALUE
rb_obj_protected_methods(int argc, VALUE *argv, VALUE obj)
{
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_prot_i);
}
to_yaml(options = {})

Convert an object to YAML. See Psych.dump for more information on the available options.

Also aliased as: to_yaml
# File ext/psych/lib/psych/core_ext.rb, line 13
def psych_to_yaml options = {}
  Psych.dump self, options
end
obj.public_method(sym) → method

Similar to method, searches public method only.

VALUE
rb_obj_public_method(VALUE obj, VALUE vid)
{
    return mnew(CLASS_OF(obj), obj, rb_to_id(vid), rb_cMethod, TRUE);
}
obj.public_methods(all=true) → array

Returns the list of public methods accessible to obj. If the allparameter is set to false, only those methods in the receiver will be listed.

VALUE
rb_obj_public_methods(int argc, VALUE *argv, VALUE obj)
{
    return class_instance_method_list(argc, argv, CLASS_OF(obj), 1, ins_methods_pub_i);
}
obj.public_send(symbol [, args...]) → obj

Invokes the method identified by symbol, passing it any arguments specified. Unlike send, #public_send calls public methods only.

1.public_send(:puts, "hello")  # causes NoMethodError
VALUE
rb_f_public_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal(argc, argv, recv, CALL_PUBLIC);
}
obj.respond_to?(symbol, include_private=false) → true or false

Returns trueif objresponds to the given method. Private methods are included in the search only if the optional second parameter evaluates to true.

If the method is not implemented, as Process.fork on Windows, File.lchmod on GNU/Linux, etc., false is returned.

If the method is not defined, respond_to_missing?method is called and the result is returned.

static VALUE
obj_respond_to(int argc, VALUE *argv, VALUE obj)
{
    VALUE mid, priv;
    ID id;

    rb_scan_args(argc, argv, "11", &mid, &priv);
    id = rb_to_id(mid);
    if (basic_obj_respond_to(obj, id, !RTEST(priv)))
        return Qtrue;
    return Qfalse;
}
obj.respond_to_missing?(symbol, include_private) → true or false

Hook method to return whether the objcan respond to id method or not.

See respond_to?.

static VALUE
obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
{
    return Qfalse;
}
rm()

Remove the FILE

ruby -run -e rm -- [OPTION] FILE

-f          ignore nonexistent files
-r          remove the contents of directories recursively
-v          verbose
# File lib/un.rb, line 135
def rm
  setup("fr") do |argv, options|
    cmd = "rm"
    cmd += "_r" if options.delete :r
    options[:force] = true if options.delete :f
    FileUtils.send cmd, argv, options
  end
end
rmdir()

Remove the DIR.

ruby -run -e rmdir -- [OPTION] DIR

-p          remove DIRECTORY and its ancestors.
-v          verbose
# File lib/un.rb, line 170
def rmdir
  setup("p") do |argv, options|
    options[:parents] = true if options.delete :p
    FileUtils.rmdir argv, options
  end
end
obj.send(symbol [, args...]) → obj obj.__send__(symbol [, args...]) → obj

Invokes the method identified by symbol, passing it any arguments specified. You can use __send__if the name send clashes with an existing method in obj.

class Klass
  def hello(*args)
    "Hello " + args.join(' ')
  end
end
k = Klass.new
k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
VALUE
rb_f_send(int argc, VALUE *argv, VALUE recv)
{
    return send_internal(argc, argv, recv, CALL_FCALL);
}
setup(options = "", *long_options)
# File lib/un.rb, line 35
def setup(options = "", *long_options)
  opt_hash = {}
  argv = []
  OptionParser.new do |o|
    options.scan(/.:?/) do |s|
      opt_name = s.delete(":").intern
      o.on("-" + s.tr(":", " ")) do |val|
        opt_hash[opt_name] = val
      end
    end
    long_options.each do |s|
      opt_name, arg_name = s.split(/(?=[\s=])/, 2)
      opt_name.sub!(/\A--/, '')
      s = "--#{opt_name.gsub(/([A-Z]+|[a-z])([A-Z])/, '\1-\2').downcase}#{arg_name}"
      puts "#{opt_name}=>#{s}" if $DEBUG
      opt_name = opt_name.intern
      o.on(s) do |val|
        opt_hash[opt_name] = val
      end
    end
    o.on("-v") do opt_hash[:verbose] = true end
    o.order!(ARGV) do |x|
      if /[*?\[{]/ =~ x
        argv.concat(Dir[x])
      else
        argv << x
      end
    end
  end
  yield argv, opt_hash
end
obj.singleton_class → class

Returns the singleton class of obj. This method creates a new singleton class if objdoes not have it.

If objis nil, true, or false, it returns NilClass, TrueClass, or FalseClass, respectively. If objis a Fixnum or a Symbol, it raises a TypeError.

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass
static VALUE
rb_obj_singleton_class(VALUE obj)
{
    return rb_singleton_class(obj);
}
obj.singleton_methods(all=true) → array

Returns an array of the names of singleton methods for obj. If the optional allparameter is true, the list will include methods in modules included in obj. Only public and protected singleton methods are returned.

module Other
  def three() end
end

class Single
  def Single.four() end
end

a = Single.new

def a.one()
end

class << a
  include Other
  def two()
  end
end

Single.singleton_methods    #=> [:four]
a.singleton_methods(false)  #=> [:two, :one]
a.singleton_methods         #=> [:two, :one, :three]
VALUE
rb_obj_singleton_methods(int argc, VALUE *argv, VALUE obj)
{
    VALUE recur, ary, klass;
    st_table *list;

    if (argc == 0) {
  recur = Qtrue;
    }
    else {
  rb_scan_args(argc, argv, "01", &recur);
    }
    klass = CLASS_OF(obj);
    list = st_init_numtable();
    if (klass && FL_TEST(klass, FL_SINGLETON)) {
  st_foreach(RCLASS_M_TBL(klass), method_entry_i, (st_data_t)list);
  klass = RCLASS_SUPER(klass);
    }
    if (RTEST(recur)) {
  while (klass && (FL_TEST(klass, FL_SINGLETON) || TYPE(klass) == T_ICLASS)) {
      st_foreach(RCLASS_M_TBL(klass), method_entry_i, (st_data_t)list);
      klass = RCLASS_SUPER(klass);
  }
    }
    ary = rb_ary_new();
    st_foreach(list, ins_methods_i, ary);
    st_free_table(list);

    return ary;
}
sysread(io, size)

cgi_runner.rb – CGI launcher.

Author: IPR – Internet Programming with Ruby – writers Copyright © 2000 TAKAHASHI Masayoshi, GOTOU YUUZOU Copyright © 2002 Internet Programming with Ruby writers. All rights reserved.

$IPR: cgi_runner.rb,v 1.9 2002/09/25 11:33:15 gotoyuzo Exp $

# File lib/webrick/httpservlet/cgi_runner.rb, line 11
def sysread(io, size)
  buf = ""
  while size > 0
    tmp = io.sysread(size)
    buf << tmp
    size -= tmp.bytesize
  end
  return buf
end
obj.taint → obj

Marks objas tainted—if the $SAFElevel is set appropriately, many method calls which might alter the running programs environment will refuse to accept tainted strings.

VALUE
rb_obj_taint(VALUE obj)
{
    rb_secure(4);
    if (!OBJ_TAINTED(obj)) {
        rb_check_frozen(obj);
        OBJ_TAINT(obj);
    }
    return obj;
}
obj.tainted? → true or false

Returns trueif the object is tainted.

VALUE
rb_obj_tainted(VALUE obj)
{
    if (OBJ_TAINTED(obj))
        return Qtrue;
    return Qfalse;
}
obj.tap{|x|...} → obj

Yields xto the block, and then returns x. The primary purpose of this method is to “tap into” a method chain, in order to perform operations on intermediate results within the chain.

(1..10)                .tap {|x| puts "original: #{x.inspect}"}
  .to_a                .tap {|x| puts "array: #{x.inspect}"}
  .select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
  .map { |x| x*x }     .tap {|x| puts "squares: #{x.inspect}"}
VALUE
rb_obj_tap(VALUE obj)
{
    rb_yield(obj);
    return obj;
}
timeout(n, e = nil, &block)

Identical to:

Timeout::timeout(n, e, &block).

This method is deprecated and provided only for backwards compatibility. You should use Timeout#timeout instead.

# File lib/timeout.rb, line 99
def timeout(n, e = nil, &block)
  Timeout::timeout(n, e, &block)
end
obj.to_enum(method = :each, *args) obj.enum_for(method = :each, *args)

Creates a new Enumerator which will enumerate by on calling methodon obj.

method

the method to call on objto generate the enumeration

args

arguments that will be passed in method in addition to the item itself. Note that the number of args must not exceed the number expected by method

Example

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

# protect an array from being modified by some_method
a = [1, 2, 3]
some_method(a.to_enum)
static VALUE
obj_to_enum(int argc, VALUE *argv, VALUE obj)
{
    VALUE meth = sym_each;

    if (argc > 0) {
        --argc;
        meth = *argv++;
    }
    return rb_enumeratorize(obj, meth, argc, argv);
}
obj.to_s → string

Returns a string representing obj. The default to_s prints the object's class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns “main.''

VALUE
rb_any_to_s(VALUE obj)
{
    const char *cname = rb_obj_classname(obj);
    VALUE str;

    str = rb_sprintf("#<%s:%p>", cname, (void*)obj);
    OBJ_INFECT(str, obj);

    return str;
}
to_yaml(options = {})
touch()

Update the access and modification times of each FILE to the current time.

ruby -run -e touch -- [OPTION] FILE

-v          verbose
# File lib/un.rb, line 221
def touch
  setup do |argv, options|
    FileUtils.touch argv, options
  end
end
obj.trust → obj

Removes the untrusted mark from obj.

VALUE
rb_obj_trust(VALUE obj)
{
    rb_secure(3);
    if (OBJ_UNTRUSTED(obj)) {
        rb_check_frozen(obj);
        FL_UNSET(obj, FL_UNTRUSTED);
    }
    return obj;
}
try_const(const, headers = nil, opt = "", &b)

Returns whether or not the Constant constis defined.

See also have_const

# File lib/mkmf.rb, line 1091
def try_const(const, headers = nil, opt = "", &b)
  const, type = *const
  if try_compile("#{cpp_include(headers)}
/*top*/
typedef #{type || 'int'} conftest_type;
conftest_type conftestval = #{type ? '' : '(int)'}#{const};
", opt, &b)
    $defs.push(format("-DHAVE_CONST_%s", const.tr_cpp))
    true
  else
    false
  end
end
try_type(type, headers = nil, opt = "", &b)

Returns whether or not the static type typeis defined.

See also have_type

# File lib/mkmf.rb, line 1034
def try_type(type, headers = nil, opt = "", &b)
  if try_compile("#{cpp_include(headers)}
/*top*/
typedef #{type} conftest_type;
int conftestval[sizeof(conftest_type)?1:-1];
", opt, &b)
    $defs.push(format("-DHAVE_TYPE_%s", type.tr_cpp))
    true
  else
    false
  end
end
obj.untaint → obj

Removes the taint from obj.

VALUE
rb_obj_untaint(VALUE obj)
{
    rb_secure(3);
    if (OBJ_TAINTED(obj)) {
        rb_check_frozen(obj);
        FL_UNSET(obj, FL_TAINT);
    }
    return obj;
}
obj.untrust → obj

Marks objas untrusted.

VALUE
rb_obj_untrust(VALUE obj)
{
    rb_secure(4);
    if (!OBJ_UNTRUSTED(obj)) {
        rb_check_frozen(obj);
        OBJ_UNTRUST(obj);
    }
    return obj;
}
obj.untrusted? → true or false

Returns trueif the object is untrusted.

VALUE
rb_obj_untrusted(VALUE obj)
{
    if (OBJ_UNTRUSTED(obj))
        return Qtrue;
    return Qfalse;
}
wait_writable()

Wait until the file becomes writable.

ruby -run -e wait_writable -- [OPTION] FILE

-n RETRY    count to retry
-w SEC      each wait time in seconds
-v          verbose
# File lib/un.rb, line 237
def wait_writable
  setup("n:w:v") do |argv, options|
    verbose = options[:verbose]
    n = options[:n] and n = Integer(n)
    wait = (wait = options[:w]) ? Float(wait) : 0.2
    argv.each do |file|
      begin
        open(file, "r+b")
      rescue Errno::ENOENT
        break
      rescue Errno::EACCES => e
        raise if n and (n -= 1) <= 0
        puts e
        STDOUT.flush
        sleep wait
        retry
      end
    end
  end
end
with_config(config, default=nil)

Tests for the presence of a –with- configor –without- configoption. Returns true if the with option is given, false if the without option is given, and the default value otherwise.

This can be useful for adding custom definitions, such as debug information.

Example:

if with_config("debug")
   $defs.push("-DOSSL_DEBUG") unless $defs.include? "-DOSSL_DEBUG"
end
# File lib/mkmf.rb, line 1428
def with_config(config, default=nil)
  config = config.sub(/^--with[-_]/, '')
  val = arg_config("--with-"+config) do
    if arg_config("--without-"+config)
      false
    elsif block_given?
      yield(config, default)
    else
      break default
    end
  end
  case val
  when "yes"
    true
  when "no"
    false
  else
    val
  end
end
xmp(exps, bind = nil)
# File lib/irb/xmp.rb, line 92
def xmp(exps, bind = nil)
  bind = IRB::Frame.top(1) unless bind
  xmp = XMP.new(bind)
  xmp.puts exps
  xmp
end