Khaled alHabache’s official blog

class Colors 
  def mix(*colors)
    if block_given?
      yield(colors)
    else
      puts "Mixing: #{colors.join ' + '}"
    end
  end
end
c = Colors.new
c.mix "orange" , "cyan" #=> Mixing: orange + cyan
c.mix("green","red"){|colors| puts "A nice mix: #{colors.join(' + ')}"} #=> A nice mix: green + red

class Colors 
  def mix(*colors)
    if block_given?
      yield(colors)
    else
      puts "Mixing: #{colors.join ' + '}"
    end
  end
 
  def method_missing(*args, &block)
    # First arg is a symbol representing the name of the method.
    method_name = args.shift
    # Extract the colors from the method name and collecting them in an array 
    # This is a very basic treatment.
    colors = method_name.id2name.split(/and/i).collect{|color| color.downcase}
    # Send the colors and the block to 'mix' method.
    self.send :mix, colors ,&block
  end
end
 
c = Colors.new
c.mix "orange" , "cyan" #=> Mixing: orange + cyan
c.mix("green","red"){|colors| puts "A nice mix: #{colors.join(' + ')}"} #=> A nice mix: green + red
c.greenAndBlue #=> Mixing: green + blue 
c.greenAndWhiteAndBrown #=> Mixing: green + white + brown
c.grayAndYellow{|colors| puts "A nice mix: #{colors.join(' + ')}"} #=> A nice mix: gray + yellow

class Colors
	RED = "#FF0000"
	GREEN = "#00FF00"
	BLUE = "#0000FF"
 
	def self.const_missing(name)
		puts "Sorry the color '#{name}' is undefined; #{constants.join ","} are the only available colors."
	end
end
 
Colors::Yellow #=> Sorry the color 'Yellow' is undefined; BLUE,GREEN,RED are the only available colors.

module A
	def self.included(base)
		puts "#{self} included in #{base}"
	end
 
	def self.extended(base)
		puts "#{self} extended in #{base}"
	end
end
 
class B
	include A #=> A included in B
end
 
class C
	extend A #=> A extended in C
end

module Greetings
  # When a class is including this module
  def self.included(base)
    # include: will mix the methods in the caller as instance ones.
    # include: is a private method that's why we are using 'send'
    base.send :include, InstanceMethods
    # extend: will mix the methods in the caller as class ones.
    # extend: is a private method that's why we are using 'send'
    base.send :extend, SingletonMethods
  end
 
  # Put all the the methods that should be mixed as instance ones here.
  module InstanceMethods
    def hello ; puts "hello" ; end
  end
 
  # Put all the the methods that should be mixed as class ones here.
  module SingletonMethods
    def bye ; puts "bye!" ; end
  end
end
 
class Greeter
  # The 'included' callback is getting fired now 
  include Greetings
end
 
Greeter.new.hello #=>hello
Greeter.bye #=> bye!

class Colors
  def self.method_added(name)    
    puts "A trial to add a new instance method: #{name}, this is not allowed." 
    undef_method name
  end 
 
  def self.singleton_method_added(name)   
    if name != :singleton_method_added
      singleton_class = class << self; self; end
      puts "A trial to add a new class method: #{name}, this is not allowed." 
      singleton_class.class_eval{undef_method name}
    end
  end 
end
 
#Monkey patching 
class Colors
  def red ; end #A trial to add a new instance method: red, this is not allowed.
  def self.mixer ; end #A trial to add a new class method: mixer, this is not allowed.
end

class Colors
  def self.inherited(sub)
    puts "class #{sub} is inheriting class #{self}"
  end
end
 
class C < Colors ; end #=> class C is inheriting class Colors

class Colors
  def self.inherited(sub) 
    raise "class #{sub} is inheriting class #{self}, inheritance is now allowed...."
  end
end
 
class D < Colors ; end #=> class D is inheriting class Colors, inheritance is now allowed.... (RuntimeError)