Attr_accessor, but for a boolean

Ruby
1

Let’s say I have this code:

class Mambo
attr_accesstor :safe
end

Now,

‘safe’, in my case, is a boolean. Problem is, the getter will be named
‘safe’, whereas I want it to be ‘safe?’.

In other words, how do I make the getter ‘safe?’ and the setter ‘safe’
?

1 Like
2

There’s no built in way in ruby for it to know that you’re going to put
a
boolean in there. You’ll need to do something like

class Mambo
attr_writer :safe

def safe?
!!@safe
end
end

HTH
Daniel

3

On Mon, Apr 12, 2010 at 10:00:06AM +0900, Albert S. wrote:

In other words, how do I make the getter ‘safe?’ and the setter ‘safe’
?

In situations like this, I make two “getters” and leave the assignment
alone. Other ruby programmers expect your “setters” to be in the form
of “obj.safe = true”, not “obj.safe(true)”.

Try something like this:

class Mambo
  attr_accesstor :safe
  alias :safe? :safe
end

Here it is in action:

irb(main):001:0> class Mambo
irb(main):002:1>   attr_accessor :safe
irb(main):003:1>   alias :safe? :safe
irb(main):004:1> end
=> nil
irb(main):005:0> m = Mambo.new
=> #<Mambo:0x000001010cab50>
irb(main):006:0> m.safe = true
=> true
irb(main):007:0> m.safe?
=> true
irb(main):008:0>
4

Aaron P. wrote:

  alias :safe? :safe

Daniel wrote:

def safe?
!!@safe
end

Thank you both. I wanted to make sure there’s no built-in way to do
this.

(BTW, in Lisp (CLOS) it’s possible to specify the getter/setter names.)

5

On 12 April 2010 11:10, Aaron P. [email protected]
wrote:

‘safe’, whereas I want it to be ‘safe?’.
class Mambo
=> nil
http://tenderlovemaking.com/
Unfortunately this doesn’t support safe? being boolean always. It could
be
something other than true false (may not be a problem)

If you want to use attr_accessor rather than simply aliasing the method
I’d
suggest

def safe?
!!safe
end

This way the expectation of a ? method to return a boolean is preserved.

Cheers
Daniel

6

Albert S. wrote:

Thank you both. I wanted to make sure there’s no built-in way to do
this.

Hey, I’ve just discovered that ‘ri’ tells me that Module has an
‘attr_reader?’ method that creates a question-mark attribute.

Problem is, ‘ri’ displays methods from everything I’ve installed on my
system, so I can’t know if ‘attr_reader?’ is provided by Ruby itself or
by some wacky gem.

7

On Mon, Apr 12, 2010 at 12:35 AM, Albert S.
[email protected]wrote:

–
Posted via http://www.ruby-forum.com/.

Doesn’t work for me, so probably from some gem.

You could do something like this:

class Module
def attr_accessor?(*methods)
methods.each do |method|
ivar = “@#{method}”
define_method(“#{method}=”) { |value| instance_variable_set ivar ,
value }
define_method(“#{method}?”) { !!instance_variable_get(ivar) }
end
end
end

class Example
attr_accessor? :abc
end

e = Example.new
e.abc = true
e.abc? # => true

e.abc = false
e.abc? # => false

e.abc = 1
e.abc? # => true

e.abc = nil
e.abc? # => false

e.abc = :adsf
e.abc? # => true

There was also a ruby quiz about attr methods
Ruby Quiz - metakoans.rb (#67) And there is a gem based off of it
GitHub - ahoward/fattr: fattr.rb is a "fatter attr" for ruby and borrows heavily from the metakoans.rb ruby quiz

I don’t know where yours came from, though.

8

On Apr 11, 9:13 pm, Daniel N [email protected] wrote:

This way the expectation of a ? method to return a boolean is preserved.
I used to think this too, but… I think it was Austin Z. who
made the argument against using anything like “!!”. In ruby it isn’t
necessary. Anything that isn’t nil or false is evaluated by
conditionals as true. I haven’t once seen a case where it mattered if
a boolean was returned rather than the underlying value.

9

On Apr 11, 9:00 pm, Albert S. [email protected] wrote:

Let’s say I have this code:

class Mambo
attr_accesstor :safe
end

Now,

‘safe’, in my case, is a boolean. Problem is, the getter will be named
‘safe’, whereas I want it to be ‘safe?’.

In Ruby 1.9, once can create writers with

attr :x=

I love this feature b/c it means I can just use #attr and not need the
other three attr_reader, attr_writer and attr_accessor.

It would be cool if we could make “boolean” readers too with,

attr :x?

(P.S. Is the attr :x= feature going to get back ported to 1.8.8?)

10

On Apr 11, 7:00 pm, Albert S. [email protected] wrote:

In other words, how do I make the getter ‘safe?’ and the setter ‘safe’
?

Wouldn’t that have been nice?

http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/5796

Regards,

Dan

11

Intransition wrote:

This way the expectation of a ? method to return a boolean is preserved.

I used to think this too, but… I think it was Austin Z. who
made the argument against using anything like “!!”. In ruby it isn’t
necessary. Anything that isn’t nil or false is evaluated by
conditionals as true. I haven’t once seen a case where it mattered if
a boolean was returned rather than the underlying value.

In a DRb situation, I’d rather send ‘true’ across the wire than
an arbitrary object.

Also, if the boolean value is going to be stored somewhere,
I’d rather store a ‘true’ than reference an arbitrary object.

Also, if I’m adding a temporary debug printout #{someval.inspect}
it’s nicer to see true/false in the output.

Regards,

Bill

12

On Mon, Apr 12, 2010 at 1:29 PM, Intransition [email protected]
wrote:

You could define

save= , the setter for @safe
safe , the getter for @safe
safe? , returns !!safe

Then you can use whichever makes the most sense for your particular use.

13

On Apr 12, 1:02 pm, Bill K. [email protected] wrote:

In a DRb situation, I’d rather send ‘true’ across the wire than
an arbitrary object.

That’s an interesting point.

Also, if the boolean value is going to be stored somewhere,
I’d rather store a ‘true’ than reference an arbitrary object.

I imagine the the underlying attribute (e.g. @safe) is what will be
stored in any case, so if that isn’t already false/true it probably
won’t matter in this case.

Also, if I’m adding a temporary debug printout #{someval.inspect}
it’s nicer to see true/false in the output.

At other times you might want to see the underlying attribute. It’s
easier to write ‘!!obj.safe?’ then it is to write
‘obj.instance_eval{ @safe }’.

I can understand wanting it either way depending on the situation. But
for an attr method I think it’s probably best to side on doing less
rather than more, i.e. just making :a? a normal reader. But I wouldn’t
bemoan it working one way or the other really.