Results for: "String# "

Kernel#set_trace_func

Establishes proc as the handler for tracing, or disables tracing if the parameter is nil.

Note: this method is obsolete, please use TracePoint instead.

proc takes up to six parameters:

an event name string
a filename string
a line number
a method name symbol, or nil
a binding, or nil
the class, module, or nil

proc is invoked whenever an event occurs.

Events are:

"c-call": call a C-language routine
"c-return": return from a C-language routine
"call": call a Ruby method
"class": start a class or module definition
"end": finish a class or module definition
"line": execute code on a new line
"raise": raise an exception
"return": return from a Ruby method

Tracing is disabled within the context of proc.

class Test
  def test
    a = 1
    b = 2
  end
end

set_trace_func proc { |event, file, line, id, binding, class_or_module|
  printf "%8s %s:%-2d %16p %14p\n", event, file, line, id, class_or_module
}
t = Test.new
t.test

Produces:

c-return prog.rb:8   :set_trace_func         Kernel
    line prog.rb:11              nil            nil
  c-call prog.rb:11             :new          Class
  c-call prog.rb:11      :initialize    BasicObject
c-return prog.rb:11      :initialize    BasicObject
c-return prog.rb:11             :new          Class
    line prog.rb:12              nil            nil
    call prog.rb:2             :test           Test
    line prog.rb:3             :test           Test
    line prog.rb:4             :test           Test
  return prog.rb:5             :test           Test

Enumerable#each_with_index

Invoke self.each with *args. With a block given, the block receives each element and its index; returns self:

h = {}
(1..4).each_with_index {|element, i| h[element] = i } # => 1..4
h # => {1=>0, 2=>1, 3=>2, 4=>3}

h = {}
%w[a b c d].each_with_index {|element, i| h[element] = i }
# => ["a", "b", "c", "d"]
h # => {"a"=>0, "b"=>1, "c"=>2, "d"=>3}

a = []
h = {foo: 0, bar: 1, baz: 2}
h.each_with_index {|element, i| a.push([i, element]) }
# => {:foo=>0, :bar=>1, :baz=>2}
a # => [[0, [:foo, 0]], [1, [:bar, 1]], [2, [:baz, 2]]]

With no block given, returns an Enumerator.

JSON::create_pretty_state

No documentation available

MonitorMixin#mon_try_enter

Attempts to enter exclusive section. Returns false if lock fails.

MonitorMixin#try_mon_enter

For backward compatibility

ObjectSpace::trace_object_allocations

Starts tracing object allocations from the ObjectSpace extension module.

For example:

require 'objspace'

class C
  include ObjectSpace

  def foo
    trace_object_allocations do
      obj = Object.new
      p "#{allocation_sourcefile(obj)}:#{allocation_sourceline(obj)}"
    end
  end
end

C.new.foo #=> "objtrace.rb:8"

This example has included the ObjectSpace module to make it easier to read, but you can also use the ::trace_object_allocations notation (recommended).

Note that this feature introduces a huge performance decrease and huge memory consumption.

ObjectSpace::internal_class_of

MRI specific feature: Return internal class of obj.

obj can be an instance of InternalObjectWrapper.

Note that you should not use this method in your application.

ObjectSpace::internal_super_of

MRI specific feature: Return internal super class of cls (Class or Module).

obj can be an instance of InternalObjectWrapper.

Note that you should not use this method in your application.

Gem::ensure_gem_subdirectories

Quietly ensure the Gem directory dir contains all the proper subdirectories. If we can’t create a directory due to a permission problem, then we will silently continue.

If mode is given, missing directories are created with this mode.

World-writable directories will never be created.

Gem::latest_spec_for

Returns the latest release-version specification for the gem name.

Gem::latest_rubygems_version

Returns the latest release version of RubyGems.

Gem::latest_version_for

Returns the version of the latest release-version of gem name

Gem::plugin_suffix_pattern

Glob pattern for require-able plugin suffixes.

Gem::plugin_suffix_regexp

Regexp for require-able plugin suffixes.

Gem::load_env_plugins

Find all ‘rubygems_plugin’ files in $LOAD_PATH and load them

Gem::register_default_spec

Register a Gem::Specification for default gem.

Two formats for the specification are supported:

MRI 2.0 style, where spec.files contains unprefixed require names. The spec’s filenames will be registered as-is.
New style, where spec.files contains files prefixed with paths from spec.require_paths. The prefixes are stripped before registering the spec’s filenames. Unprefixed files are omitted.

Gem::find_default_spec

Find a Gem::Specification of default gem from path

Gem::find_config_file

Finds the user’s config file

FileUtils#remove_entry_secure

Securely removes the entry given by path, which should be the entry for a regular file, a symbolic link, or a directory.

Argument path should be interpretable as a path.

Avoids a local vulnerability that can exist in certain circumstances; see Avoiding the TOCTTOU Vulnerability.

Optional argument force specifies whether to ignore raised exceptions of StandardError and its descendants.

Related: methods for deleting.

FileUtils::remove_entry_secure