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"

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

Is self included in other?

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

Set instance variables using a hash.

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

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

Like instance_eval but allows parameters to be passed.

NOTE: This is deprecated b/c implementation is fragile. Use Ruby 1.9 instead.

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   #=> [1,2]

  CREDIT: David Heinemeier Hansson

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 ?

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

Access to an object‘s "special" class, otherwise known as it‘s eigenclass or metaclass, etc.

One day these names must be reconciled!

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

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.

Supress errors while executing a block, with execptions.

  CREDIT: David Heinemeier Hansson

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']

Retreive the current running method name.

  def tester; __callee__; end
  tester  #=> :tester

Technically callee should provided alias names, where as method should not. But we‘ll have to leave that distinction to Ruby 1.9+.

Retreive the current running method name.

  def tester; __method__; end
  tester  #=> :tester

Technically callee should provided alias names, where method should not. But we‘ll have to leave that distinction to Ruby 1.9+.