In PHP there is a nifty function that exchanges Hash keys with values: array_flip.

You can have it in Ruby easily too:

hash = {:a => 1, :b => 2, :c => 3}
> pp hash.to_a
[[:c, 3], [:a, 1], [:b, 2]]
>  pp Hash[*hash.to_a.flatten.reverse]
{1=>:a, 2=>:b, 3=>:c}

You can define it as a method of Hash:

class Hash
  def flip
     self.class[*self.to_a.flatten.reverse]
  end
end

>  pp {:a => 1, :b => 2, :c => 3}.flip
{1=>:a, 2=>:b, 3=>:c}

Beware this only works on simple scalar hashes. Check out this proposal for better way.

a = a

You would imagine it would raise NameError if a was not defined, right? Not! It would just set a to nil Evil…

------------------------------------------- Object#instance_variable_set
     obj.instance_variable_set(symbol, obj)    => obj
------------------------------------------------------------------------
     Sets the instance variable names by _symbol_ to _object_, thereby
     frustrating the efforts of the class's author to attempt to provide
     proper encapsulation. The variable did not have to exist prior to
     this call.

I have a lot of models in my Rails project. And most of them can be observed. The observation behavior is defined in App::Observable module. But along the methods and constants I also needed something to be called in class that was being extended.

So I had a lot of code like this in all my models that are observable:

class User < ActiveRecord::Base
  include App::Observable
  has_many  bservations, :as =>  bservable, :dependent => :destroy
  has_many  bservers, :through =>  bservations
end

But as you may see it’s not very DRY. So I dug through documentation of Module and found a neat way to achieve desired behavior of running that piece of code by just including the module.

module Extender
  STUFF = "I am the stuff."

  def self.append_features(mod)
    super(mod)
    mod.call_me
  end
end

class Receiver
  def self.call_me
    puts "I was called. yay!"
  end

  include Extender
end

puts Receiver::STUFF

Now produces

I was called. yay!
I am the stuff.

As you can see the default behavior is still preserved and my custom method is called. So now you just can do:

module App
  module Observable
    def self.append_features(mod)
      super(mod)
      mod.has_many  bservations, :as =>  bservable, :dependent => :destroy
      mod.has_many  bservers, :through =>  bservations
    end
  end
end

class User < ActiveRecord::Base
  include App::Observable
end

Use it wisely.