Ruby wrapper functions - ruby

Question

I have a class that wraps other instances to provide additional functionality (a presenter) and want to now have subclasses that provide the same functionality. So it would be something like this:
class BasePresenter
attr_accessor :base_object
def initialize(base_object)
self.base_object = base_object
end
end
class WalrusPresenter < BasePresenter
end
And I want to be able to do this:
BasePresenter(:bubbles)
#=> <# BasePresenter #base_object=:bubbles >
WalrusPresenter(:frank)
#=> <# WalrusPresenter #base_object=:frank >
Update
I think the functional differences are outside of the scope of the question, but they seem to be a sticking point so I'll add them.
I am not trying to delegate .new.
BasePresenter.new takes a single argument and wraps it in a presenter. BasePresenter() takes an object and:
If it is already a presenter, return it
If it is an array of objects, map over them and create a new presenter
If it is a single object, wrap it in a presenter and return it.
This is closer to ActiveSupport's Array#wrap, but I think the parenthetical syntax is rather communicative of its functionality so I'd like to use that if possible. The inheritance part is what is tripping me up; defining it once one the base class so it is useable on all children.
BasePresenter(:bubbles)
#=> <# BasePresenter #base_object=:bubbles >
BasePresenter([:waldorf, :statler])
#=> [ <# BasePresenter #base_object=:waldorf >, <# BasePresenter #base_object=:staler> ]
WalrusPresenter.new(:frank)
#=> <# WalrusPresenter #base_object=:frank >
WalrusPresenter([:harold, :richard])
#=> [ <# WalrusPresenter #base_object=:harold >, <# WalrusPresenter #base_object=:richard > ]
WalrusPresenter(WalrusPresenter(WalrusPresenter(:frank)))
#=> <# WalrusPresenter #base_object=:frank >

Answer 1

I might be missing the point of your question, but to me it looks like you just forgot to use new to create instances of your classes:
BasePresenter.new(:bubbles)
# => #<BasePresenter:0x00000001ae33b8 #base_object=:bubbles>
WalrusPresenter.new(:frank)
# => #<WalrusPresenter:0x00000001ae7878 #base_object=:frank>
Update: Mischa has already responded to your comment in about the same way I would. Kernel#Array tries calling to_ary on its argument, then tries calling to_a on it if that fails, then creates an Array with the argument as its sole element if that fails too.
It's not clear what behavior you want; it seems like you just want to get around using new, which of course you can do, but it would be silly:
def BasePresenter(base)
BasePresenter.new(base)
end
def WalrusPresenter(base)
WalrusPresenter.new(base)
end
You could do some metaprogramming to avoid repeating yourself when creating the wrappers. But I fail to see the reason you want to avoid new, and without a very good reason to do so, I'd have to recommend against it. Ruby uses new to instantiate objects.
Update 2: Thanks for clarifying what you're looking for. Here's the first thing that came to mind for me. You can definitely clean it up a bit, but something like this should get you started. (wrap doesn't need to be in BasePresenter at all.) Anyway, here you go:
class BasePresenter
attr_accessor :base_object
def initialize(base_object)
self.base_object = base_object
end
def self.wrap klass
Object.class_eval do
define_method klass.to_s do |object|
case object
when BasePresenter
object
when Array
object.map{|base| klass.new(base)}
else
klass.new(object)
end
end
end
end
BasePresenter.wrap BasePresenter
def self.inherited child_klass
BasePresenter.wrap child_klass
end
end
class WalrusPresenter < BasePresenter
end
This seems to do what you want:
BasePresenter(:bubbles)
# => #<BasePresenter:0x00000001db05a0 #base_object=:bubbles>
BasePresenter([:waldorf, :statler])
# => [#<BasePresenter:0x00000001da7c98 #base_object=:waldorf>,
#<BasePresenter:0x00000001da7c70 #base_object=:statler>]
WalrusPresenter.new(:frank)
# => #<WalrusPresenter:0x00000001da4070 #base_object=:frank>
WalrusPresenter([:harold, :richard])
# => [#<WalrusPresenter:0x00000001d773e0 #base_object=:harold>,
#<WalrusPresenter:0x00000001d773b8 #base_object=:richard>]
WalrusPresenter(WalrusPresenter(WalrusPresenter(:frank)))
# => #<WalrusPresenter:0x00000001d6c760 #base_object=:frank>

Answer 2

First, I don't think what you're trying to do is super wise - there are probably better ways to accomplish what you want. But if you really want to create a new operator against a class by adding parenthesis handling, the code below does the job I think..
I'm copying the gnarly class handling code from this great blog post by CodeErr.
Here is my solution for your problem using his code:
class Object
alias_method :orig_method_missing, :method_missing
def method_missing(m, *a, &b)
klass = begin
(self.is_a?(Module) ? self : self.class).const_get(m)
rescue NameError
end
return klass.send(:parens, *a, &b) if klass.respond_to? :parens
orig_method_missing m, *a, &b
end
end
class X
##class_arg = {}
def self.class_arg
##class_arg[self.name]
end
def self.parens(*args)
##class_arg[self.name] = args[0]
Class.new(self).class_eval do
define_method :initialize do
super(*args)
end
self
end
end
end
class Y < X
end
class Z < X
end
Z(:bubbles)
Y(:frank)
puts Z.class_arg # "bubbles"
puts Y.class_arg # "frank"

Answer 3

My solution:
class BasePresenter
attr_accessor :base_object
def initialize(base_object)
self.base_object = base_object
end
Object.class_eval do
def BasePresenter base_object
BasePresenter.new base_object
end
end
def self.inherited child_klass
Object.class_eval do
define_method child_klass.to_s.to_sym do |base_object|
child_klass.new base_object
end
end
end
end
class WalrusPresenter < BasePresenter
end
class Test < WalrusPresenter; end
puts BasePresenter(:bubbles)
puts WalrusPresenter(:frank)
puts Test(:test)