Create a single bit bitmask.

  Bit(0)  #=> 1
  Bit(1)  #=> 2
  Bit(2)  #=> 4

This is equivalent to n-shift: "1 << n".

  CREDIT: Thomas Sawyer
  CREDIT: George Moschovitis

Similar to FILE and LINE, DIR provides the directory path to the current executing script.

CREDIT: Trans

Returns a As-functor that allows one to call any ancestor‘s method directly of the given object.

  class A
    def x ; 1 ; end
  end

  class B < A
    def x ; 2 ; end
  end

  class C < B
    def x ; as(A).x ; end
  end

  C.new.x  #=> 1

Very simple convenience method to get a console reply.

  ask "Are you happy?", "Yn"

On the command line one would see.

  $ Are you happy? [Yn]

Responding:

  $ Are you happy? [Yn] Y <ENTER>

The ask method would return "Y".

Takes an array or hash with default values and creates singleton attr_accessors for each.

  attr_singleton_accessor { :x => 1, :y => 2 }
  @x          #=> 1
  @y          #=> 2
  self.x = 3
  self.y = 4
  self.x      #=> 3
  self.y      #=> 4

 CREDIT: Trans

Takes an array or a hash with default values and creates singleton attr_readers for each.

  attr_singleton_reader {:x => 1, :y => 2}
  @x       #=> 1
  @y       #=> 2
  self.x   #=> 1
  self.y   #=> 2

 CREDIT: Trans

Takes an array or a hash with default values and creates singleton attr_writers for each.

  attr_singleton_writer { :x => 1, :y => 2 }
  @x           #=> 1
  @y           #=> 2
  self.x = 3
  self.y = 4
  @x           #=> 3
  @y           #=> 4

 CREDIT: Trans

An object is blank if it‘s nil, empty, or a whitespace string. For example, "", " ", nil, [], and {} are blank.

This simplifies

  if !address.nil? && !address.empty?

to

  if !address.blank?

Returns true is an object is class TrueClass or FalseClass, otherwise false.

  true.bool?   #=> true
  false.bool?  #=> true
  nil.bool?    #=> false

Parse a caller string and break it into its components, returning an array. Returns:

• file (String)
• lineno (Integer)
• method (Symbol)

For example, from irb,

  call_stack(1)

produces

[["(irb)", 2, :irb_binding],

 ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, :irb_binding],
 ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, nil]]

Note: If the user decides to redefine caller() to output data in a different format, prior to requiring this, then the results will be indeterminate.

  CREDIT: Trans

Repeat loop until it yeilds false or nil.

  a = [3, 2, 1]
  complete do
    b << a.pop
  end
  b  #=> [3, 2, 1, nil]

 CREDIT: Trans

This is similar to +Module#const_get+ but is accessible at all levels, and, unlike const_get, can handle module hierarchy.

  constant("Fixnum")                  # -> Fixnum
  constant(:Fixnum)                   # -> Fixnum

  constant("Process::Sys")            # -> Process::Sys
  constant("Regexp::MULTILINE")       # -> 4

  require 'test/unit'
  Test.constant("Unit::Assertions")   # -> Test::Unit::Assertions
  Test.constant("::Test::Unit")       # -> Test::Unit

  CREDIT: Trans

Like p but gives file and line number.

  d("hi")

produces

  /home/dave/projects/foo.rb, 38
  "hi"

TODO: This is borderline "prime". Keep here?

      Another copy of it exits in dtools.rb

Anything that can be marshaled can be copied in totality. This is also commonly called a deep_copy.

  "ABC".copy  #=> "ABC"

Forces the result of a promise to be computed (if necessary) and returns the bare result object. Once evaluated, the result of the promise will be cached. Nested promises will be evaluated together, until the first non-promise result.

If called on a value that is not a promise, it will simply return it.

For debugging and showing examples. Currently this takes an argument of a string in a block.

  demo {%{ a = [1,2,3] }}
  demo {%{ a.slice(1,2) }}
  demo {%{ a.map { |x| x**3 } }}

Produces:

  a = [1,2,3]             #=>  [1, 2, 3]
  a.slice(1,2)            #=>  [2, 3]
  a.map { |x| x**3 }      #=>  [1, 8, 27]

  TODO: Is there a way to do this without the eval string in block?
        Preferably just a block and no string.

During this trying time when no one can get their techie catchwords to stick to the refrigerator no matter how hard they slap it # with the enchanted magnetic spatula, it’s good to know that the contrived phrases really do fly, graceful and unclasped and bearing north toward chilled shrimp. I know what my Hallowe’en pumpkin is going to say.

                      -- why the lucky stiff

  CREDIT: WhyTheLuckyStiff

Sets $VERBOSE to true for the duration of the block and back to its original value afterwards.

 CREDIT: David Heinemeier Hansson

Yield self -or- return self.

  "a".ergo.upcase #=> "A"
  nil.ergo.foobar #=> nil

  "a".ergo{ |o| o.upcase } #=> "A"
  nil.ergo{ |o| o.foobar } #=> nil

This is like tap, but tap yields self -and- returns self.

 CREDIT: Daniel DeLorme

Returns true is an object is class FalseClass, otherwise false.

  true.false?   #=> false
  false.false?  #=> true
  nil.false?    #=> false

Schedules a computation to be run asynchronously in a background thread and returns a promise for its result. An attempt to demand the result of the promise will block until the computation finishes.

As with Kernel.promise, this passes the block a promise for its own result. Use wisely.

Is self included in other?

  5.in?(0..10)       #=> true
  5.in?([0,1,2,3])   #=> false

Access internals of an object as if with private access.

  class X
    metaclass.instance.attr_reader :x
  end

Set instance variables using a hash.

  instance_assign('@a'=>1, '@b'=>2)
  @a   #=> 1
  @b   #=> 2

WARNING: instance_assign will be deprecated. Use instance_vars.update instead.

Easy access to an object qua class, otherwise known as the object‘s metaclass or singleton class. This implemnetation alwasy returns the class, even if a block is provided to eval against it.

    It is what it is.

 CREDIT: Trans

Return instance variable values in an array.

  class X
    def initialize(a,b)
      @a, @b = a, b
    end
  end

  x = X.new(1,2)

  x.instance_values   #=> { "a"=>1, "b"=>2 }

WARNING: instance_values will be deprecated. Use instance_vars.to_hash instead.

Load file from same dir as calling script.

  load_local 'templib'

Random generator that returns true or false. Can also take a block that has a 50/50 chance to being executed.

  maybe  #=> true
  maybe  #=> false

Alias a method defined in the metaclass (ie. singleton class).

  def X.y?; "y?" ; end
  X.meta_alias "ynot?", "y?"
  X.ynot?  #=> y?

 CREDIT: Trans

Easy access to an object‘s "special" class, otherwise known as it‘s metaclass or singleton class.

Add method to a meta-class —i.e. a singleton method.

  class X; end
  X.meta_def(:x){"x"}
  X.x  #=> "x"

 CREDIT: WhyTheLuckyStiff

Evaluate code in a metaclass. This is equivalent to ‘meta_class.instance_eval’.

 CREDIT: WhyTheLuckyStiff

Alias for meta_class

Alias for not_nil?

The opposite of nil?.

  "hello".not_nil?     # -> true
  nil.not_nil?         # -> false

 CREDIT: Gavin Sinclair

Returns the object id as a string in hexideciaml, which is how Ruby reports them with inspect.

  "ABC".object_hexid  #=> "0x402d359c"

Send only to public methods.

  class X
    private
    def foo; end
  end

  X.new.object_send(:foo)
  => NoMethodError: private method `foo' called for #<X:0xb7ac6ba8>

TODO: object_send needs to change for 1.9.

 CREDIT: Trans

Alternate to standard p method that outputs Kernel#inspect to stdout, but also passes through the orginal argument(s).

  x = 1
  r = 4 + q(1)
  p r

produces

  1
  5

DEPRECATE AS OF 1.9, if p will then do this too.

Assign via accessor methods using a hash, associative array or block.

  object.populate( :a => 1, :b => 2 )
  object.populate( :a, 1, :b, 2 )
  object.populate( [:a, 1], [:b, 2] )
  object.populate( *[[:a, 1], [:b, 2]] )
  object.populate{ |s| s.a = 1; s.b = 2 }

These are all the same as doing:

  object.a = 1
  object.b = 2

Using an associative array instead of hash guarentees order of assignemnt.

Using a hash or array will not raise an error if the accessor does not exits —it will simply be skipped.

TODO: Better name, set_with ?

The promise() function is used together with demand() to implement lazy evaluation. It returns a promise to evaluate the provided block at a future time. Evaluation can be demanded and the block‘s result obtained via the demand() function.

Implicit evaluation is also supported: the first message sent to it will demand evaluation, after which that message and any subsequent messages will be forwarded to the result object.

As an aid to circular programming, the block will be passed a promise for its own result when it is evaluated. Be careful not to force that promise during the computation, lest the computation diverge.

Easy access to an object qua class, otherwise known as the object‘s singleton class.

Yes, another one.

 CREDIT: Trans

Require a pattern of files. This make is easy to require an entire directory, for instance.

  require_all 'facets/time/*'

Require file from same dir as calling script.

  require_local 'templib'

Provides a shortcut to the Regexp.escape module method.

  resc("H..LO")   #=> "H\\.\\.LO"

  TODO: Should this be deprecated in favor of String#to_re/to_rx ?

  CREDIT: Trans

Like respond_to? but returns the result of the call if it does indeed respond.

  class X
    def f; "f"; end
  end

  x = X.new
  x.respond(:f)  #=> "f"
  x.respond(:g)  #=> nil

 CREDIT: Trans

Alias for respond

A Ruby-ized realization of the K combinator.

  returning Book.new do |book|
    book.title = "Imperium"
    book.author = "Ulick Varange"
  end

Technically, returning probably should force the return of the stated object irregardless of any return statements that might appear within it‘s block. This might differentiate returning from with, however it also would require implementation in Ruby itself.

  CREDIT: Mikael Brockman

Call parent class/module methods once bound to self.

TODO: Does this have the proper scope for send?

Set setter methods using a another object.

  class X
    attr_accessor :a, :b
    def initialize( a, b )
       @a,@b = a,b
    end
  end

  obj1 = X.new( 1, 2 )
  obj2 = X.new

  obj2.set_from(obj1)

  obj2.a  #=> 1
  obj2.b  #=> 2

TODO: pepulate_from(obj) ?

Silences any stream for the duration of the block.

  silence_stream(STDOUT) do
    puts 'This will never be seen'
  end

  puts 'But this will'

  CREDIT: David Heinemeier Hansson

Sets $VERBOSE to nil for the duration of the block and back to its original value afterwards.

  silence_warnings do
    value = noisy_call # no warning voiced
  end

  noisy_call  # no warning is voiced

 CREDIT: David Heinemeier Hansson

Just like silence_stream, but will default to STDOUT, STDERR if no streams are given.

Alias for singleton_class

Easy access to an object‘s "special" class,

One day these names must be reconciled!

Like super but skips to a specific ancestor module or class.

  class A
    def x ; 1 ; end
  end

  class B < A
    def x ; 2 ; end
  end

  class C < B
    def x ; super_as(A) ; end
  end

  C.new.x  #=> 1

Returns method of a parent class bound to self.

The tap K-Combinator. This yields self -and- returns self.

Boolean conversion for not being nil or false. Other classes may redefine this to suite the particular need.

  "abc".to_b   #=> true
  true.to_b    #=> true
  false.to_b   #=> false
  nil.to_b     #=> false

Returns true is an object is class TrueClass, otherwise false.

  true.true?   #=> true
  false.true?  #=> false
  nil.true?    #=> false

Try a method.

  @person ? @person.name : nil

vs

  @person.try(:name)

 CREDIT: Chris Wanstrath

Tests to see if something has value. An object is considered to have value if it is not nil? and if it responds to empty?, is not empty.

  nil.val?     #=> false
  [].val?      #=> false
  10.val?      #=> true
  [nil].val?   #=> true

Like returning but exectures the block via instance_eval.

  def foo
    with values = [] do
      self << 'bar'
      self << 'baz'
    end
  end

  foo # => ['bar', 'baz']