An anonymous commenter contributed a cute Ruby example on this post talking about Java’s verbosity. The original poster lamented on how much code you have to write to create some basic accessors on a Java class.

With Ruby you can simply use attr, attr_accessor, attr_reader and attr_writer to create various types of accessors with a single line of code. They lack logic though, and you need to write your own accessors from scratch if you want even basic logic included. Mr. Anonymous came up with a solution, which I’ve slightly changed to produce this:

class Class
def attr(name, &conditions)
varname = ‘@’ + name.to_s
conditions ||= lambda {true}
define_method(name) do
instance_variable_get(varname)
end

define_method(name.to_s + ‘=’) do |val|
raise ArgumentError, "#{name} can’t be #{val}" unless conditions.call(val)
instance_variable_set(varname, val)
end
end
end

class AClass
attr(:my_int) { |i| i >= 0 }
attr(:my_string)
end

With this code, ‘attr’ has been extended to support accepting a code block as a parameter. Read More

While looking at NegaPosi, a crazy Ruby implementation of a micro language that only uses unary operators, I discovered a cute way to initialize instance variables. Usually you’d do this:

def initialize
@p = []
@b = []
end

But, how about doing it this way?

def initialize a=@p=[], b=@b=[]
end

Initialize doesn’t require the parameters, but it forces @p and @b to be initialized as arrays whenever an instance is created. Cute trick, although the readability suffers.

Technorati Tags: ruby

Read More