# Define a simple class M
class M ; end #=> nil
 
m = M.new #=> #<M:0xb764b7e0>
 
# Set an attribute i with value 5, the attribute name should be a symbol prefixed with @
m.instance_variable_set :@i , 5 #=> 5 
 
# This will never work cause no attribute reader is defined for 'i'
m.i #=>NoMethodError: undefined method `i' for #<M:0xb764b7e0 @i=5> from (irb):4
 
# Get it the right way!
m.instance_variable_get :@i #=> 5

# Use class_eval , and pass it a block of code :
M.class_eval { attr_accessor :v} #=> nil
 
# Set and get the attribute v
m.v = 8 #=> 8
m.v #=> 8

m.remove_instance_variable :@i  #=>NoMethodError: private method `remove_instance_variable' called for #<M:0xb767d4c0 @v=8  from (irb):29
 
# Opps, a private method! let's bypass that with instance_eval
m.instance_eval{remove_instance_variable :@i} #=> 5      ,
 
# Could be accomplished with :send
m.send :remove_instance_variable , :@i #=>5
m.i #=> nil

M.class_eval {class_variable_set :@@ci ,1} #=> 1
M.class_eval {class_variable_get :@@ci} #=> 1
M.class_eval {remove_class_variable :@@ci } #=> 1

M.const_set :CON , "I'm a constant" #=> "I'm a constant"
M.const_get :CON #=> "I'm a constant"
M.const_defined? :CON #=> true
 
 
# Let's remove it with "send" method
M.send :remove_const , :CON #=> "I'm a constant"
M.const_defined? :CON #=> false

# define_method is a private method, that's why we use the 'class_eval' method
String.class_eval {define_method(:len){length}} #=> #<Proc:0xb7635e68@(irb):17>
"how much long am I?".len #=> 19
 
# You can use the 'send' method instead of 'class_eval', notice how we are sending a Proc object to define_method
String.send :define_method,:len2,lambda {length}
"how much long am I?".len2 #=> 19

String.class_eval{define_method(:part){|s,e| self[s,e] } } #=> #<Proc:0xb7699364@(irb):14>
"hello world!".part(1,4) #=> "ello"

class Class
  def attr_access(*attrs)
    attrs.each do |attr|
      define_method :"#{attr}=" do |value|
        instance_variable_set("@#{attr}",value) 
      end
 
      define_method :"#{attr}" do
        instance_variable_get "@#{attr}"
      end
    end
  end
end

class Class
   def cattr_access(*attrs)
    singleton_class = class << self; self; end
    attrs.each do |attr|
      singleton_class.class_eval do 
        define_method :"#{attr}=" do |value|
          class_variable_set("@@#{attr}",value)
        end
        define_method :"#{attr}" do
          class_variable_get "@@#{attr}"
        end
      end
    end
  end
end

String.class_eval{undef :len} #=> nil
String.send :undef_method ,:len2 #=> String

# I want to modify the 'puts' method to make it more expressive, at least for me!
#' puts' is defined in Kernel module.
# Copy the method "puts", and assign it a new name: "original_puts"
alias :original_puts :puts #=> same as doing:   Kernel.send :alias_method ,:original_puts ,:puts
 
# Now define the method again, and use the original method functionality to help expressing the new functionality. 
def puts(*args)
   args.each_with_index do |arg,index|
	original_puts "value of parameter #{index+1} =>  #{arg}"
   end
end
 
puts 1,2,3
#value of parameter 1 =>  1
#value of parameter 2 =>  2
#value of parameter 3 =>  3

s = ''
#  s.is_a? String, this is the same!
String === s
 
# Determines whether the object has a public or protected method with the specified name.
s.respond_to? :slice #=>true
 
# Or
String.respond_to? :include #=> false
 
# Passes true as the second argument to check private methods as well.
String.respond_to? :include , true #=> true
 
# Check whether some module includes another
module M1 ; end
module M2 ; include M1 ; end
M2.include? M1 #=> true
 
# Check whether instance variable is defined or not.
d=Date.new
d.instance_variables #=> ["@sg", "@of", "@ajd"]
d.instance_variable_defined? "@of" #=>true
 
# I have to clarify this, a note for the previous post:
# obj.public_methods(all=true) ,returns the list of public methods accessible to obj. If the all parameter is set to false, inherited methods will be excluded.  
# obj.protected_methods(all=true),returns the list of protected methods accessible to obj. If the all parameter is set to false, inherited methods will be excluded.  
# obj.private_methods(all=true),returns the list of private methods accessible to obj. If the all parameter is set to false, inherited methods will be excluded.
# Ex:
d.public_methods #=> [">>", "between?", "h!", "methods", "send", "ctime", "history_write", "year", "h", "taint", "to_enum", "instance_variable_defined?", "history", "ld", "_dump","q", "singleton_methods", "instance_eval", "os?", "wday", "enum_for", "nil?", "succ", "pretty_print_cycle", "asctime", "po", "protected_methods", "instance_exec", "start", "tainted?", "ns?", "handling_jruby_bug", "new_start", "yday", "untaint", "instance_of?", "equal?", "taguri", "pretty_print", "julian?", "step", "amjd","hash", "poc", "private_methods", "jd", "newsg", "taguri=", "history_to_vi", "pretty_print_instance_variables", "ajd", "italy", "kind_of?", "freeze", "eql?", "next", "to_yaml_style", "id", "sg", "public_methods", "hvi", "quiet", "england", "is_a?", "mday", "tap", "type", "ri", "to_yaml_properties", "+", "instance_variables", "__id__", "frozen?", "-", "julian", "pretty_inspect", "to_a", "cwyear", "respond_to?", "upto", "display", "history_do", "day", "method", "class", "verbose", "gregorian?", "downto", "mjd", "strftime", "<=>", "instance_variable_get", "==", "__send__", "leap?", "===", "gregorian", "pretty_print_inspect", "extend", "to_s","cweek", ">=", "v", "mon", "<=", "clone", "to_yaml", "=~", "instance_variable_set", "<", ">", "cwday", "inspect", "day_fraction", "month", "dup", "object_id", "<<"]
 
d.public_methods(false) #=> ["jd", "month", "_dump", "ctime", "ld", "cweek", "succ", "to_s", "step", "day", "gregorian?", "hash", "ajd", "julian", "+", "yday", "taguri", "os?", "strftime", "italy", "downto", "-", "eql?", "sg", "year", "asctime", "leap?", "taguri=", "inspect", "amjd", "cwday", "to_yaml", "mon", "<<", "gregorian", "newsg", ">>", "start", "cwyear", "day_fraction", "mday", "ns?", "mjd", "england", "upto", "wday", "<=>", "julian?", "new_start", "===", "next"]
 
#Check if a method is defined
String.method_defined? :slice! # => true 
 
# Check if public method is defined?
String.public_method_defined? :upcase     # => true
 
# Check if protected method is defined?
String.protected_method_defined? :downcase  # => false 
 
# Check if private method is defined?
String.private_method_defined? :initialize # => true 
 
# Check local variables
local_variables
 
# Check class variables
class One ; @@var1 = 1 ; end
class Two < One ; @@var2 = 2 ; end
One.class_variables   #=> ["@@var1"]
Two.class_variables   #=> ["@@var2", "@@var1"]
 
# Check constants
Math.constants #=> ["PI", "E"]
 
# Check global variables
global_variables #=> ["$fileutils_rb_have_lchmod", "$binding", "$-w", "$:", "$.", "$KCODE", "$-F", "$*", "$stderr", "$,", "$`", "$-p", "$\"", "$$", "$<", "$@", "$-v", "$-i", "$deferr", "$\\", "$=", "$;", "$PROGRAM_NAME", "$stdout", "$&", "$fileutils_rb_have_lchown", "$-d", "$LOAD_PATH", "$-a", "$VERBOSE", "$FILENAME", "$defout", "$-0", "$+", "$0", "$stdin", "$~", "$DEBUG", "$-I", "$_", "$-K", "$>", "$/", "$'", "$-l", "$LOADED_FEATURES", "$?", "$SAFE", "$!"]
 
# How to get the name of the current method?
# Add this snippet of code to your logic somewhere
 
module Kernel
  private
  # Defined in ruby 1.9
  unless defined?(__method__)
    def __method__
      caller[0] =~ /`([^']*)'/ and $1
    end
  end
end

#ObjectSpace.each_object([module]) {|obj| ... } => fixnum
#Calls the block once for each living, nonimmediate object in this Ruby process. If module is specified, calls the block for only those classes or modules that match (or are a subclass of) module. Returns the number of objects found. Immediate objects (Fixnums, Symbols true, false, and nil) are never returned. In the example below, each_object returns both the numbers we defined and several constants defined in the Math module.
 
a = 102.7
b = 95       # Won't be returned
c = 12345678987654321
count = ObjectSpace.each_object(Numeric) {|x| p x }
puts "Total count: #{count}"
 
#=>12345678987654321
#102.7
#2.71828182845905
#3.14159265358979
#2.22044604925031e-16
#1.7976931348623157e+308
#2.2250738585072e-308
#Total count: 7

s= "hi man"
p s.length #=> 6
p s.include? "hi" #=> true

p s.send(:length) #=> 6
p s.send(:include?,"hi") #=> true

method_object = s.method(:length) 
p method_object.call #=> 6
method_object = s.method(:include?)
p method_object.call('hi')  #=> true

eval "s.length" #=> 6
eval "s.include? 'hi'" #=>true

require "benchmark" 
test = "hi man" 
m = test.method(:length) 
n = 100000 
Benchmark.bmbm {|x| 
  x.report("call") { n.times { m.call } } 
  x.report("send") { n.times { test.send(:length) } } 
  x.report("eval") { n.times { eval "test.length" } } 
} 
#######################################
#####   The results
#######################################
#Rehearsal ----------------------------------------
#call   0.050000   0.020000   0.070000 (  0.077915)
#send   0.080000   0.000000   0.080000 (  0.086071)
#eval   0.360000   0.040000   0.400000 (  0.405647)
#------------------------------- total: 0.550000sec
 
#          user     system      total        real
#call   0.050000   0.020000   0.070000 (  0.072041)
#send   0.070000   0.000000   0.070000 (  0.077674)
#eval   0.370000   0.020000   0.390000 (  0.399442)

class Foo
  private  
  def hi 
    puts "hi man" 
  end 
end
 
# Normal method calling
f = Foo.new  #=> <Foo:0x10a0d51>
f.hi  #=>NoMethodError: private method `hi' called for #<Foo:0x10a0d51> 
 
# Sending a message
f.send :hi #  hi man
 
# Instantiating a method object
f.method(:hi).call  # hi man
 
# Using eval
eval "f.hi"  #=>NoMethodError: private method `hi' called for #<Foo:0x10a0d51> 
 
# Using instance_eval
f.instance_eval {hi}  # hi man

# Whats is your class?
 
a = 5
b = "Hello"
 
# Whats is your class?
p "Class of a : #{a.class} ,class of b : #{b.class}" #=>"Class of a : Fixnum ,class of b : String"
 
# Whats is your super class?
p "Super class of a : #{a.class.superclass} ,super class of b : #{b.class.superclass}" #=>"Super class of a : Integer ,super class of b : Object"
 
# Is a.class = Fixnum ?
a.instance_of? Fixnum #=> true
 
# Is a of type Integer (does it have Integer in it's class hierarchy)?
a.is_a? Integer #=> true
 
# Or this way:
a.kind_of? Integer #=> true
 
# Introspection, know all the details about classes :
# List all ancestors(modules and classes) of a class
String.ancestors.each{|a| p a}
 
# List all modules included in a class
String.included_modules.each{|m| p m} 
 
# Check class hierarchy
String < Comparable #=> true
String < Integer #=> nil  , strings r not integers
Object < String #=> false , Not all objects are strings
 
# List ancestors of class type
String.ancestors.select{|a| a.class==Class}.each{|c| p c}
 
# List all methods available to an object
b.methods.each{|m| p m}
 
# Get public instance methods
String.public_instance_methods.each{|m| p m}
 
# Get protected instance methods
String.protected_instance_methods.each{|m| p m}
 
# Get private instance methods
String.private_instance_methods.each{|m| p m}
 
# Get class singleton methods
String.singleton_methods{|m| puts m}
 
# Get the instance variables of an object
d = Date.new
d.instance_variables.each{|i| p i}
 
# Get public instance methods
d.public_methods.each{|m| puts m}
 
# Get protected instance methods
d.protected_methods.each{|m| puts m}
 
# Get private instance methods
d.private_methods.each{|m| puts m}
 
# Get instance singleton methods
d.singleton_methods.each{|m| puts m}