passing methods that accepts blocks - ruby

Question

How is a good way of passing a method that accept a block?
I.e. to treat the method as a variable so it could be used in this way:
(#glob&.each || crawl_dir(#base_dir)) do |file|
puts "#{file}"
end
A simple example that can be tried out:
> require 'csv'
=> true
> CSV {|v|v}
=> <#CSV io_type:$stdout encoding:UTF-8 lineno:0 col_sep:"," row_sep:"\n" quote_char:"\"">
> a=CSV
=> CSV
> a==CSV
=> true
> a {|v|v}
Traceback (most recent call last):
1: from (irb):14
NoMethodError (undefined method `a' for main:Object)
Is this possible?

Answer 1

In your example, you are using different things which are all called CSV.
CSV {|v|v}
Here, you are calling the method named CSV with a block. You get the return value of that method back. Methods such as this are usually used as converters. E.g. there is the Integer() method which takes an argument (such as a String) which is converted to an Integer object. Usually, those methods are called the same as the class of object they return.
a=CSV
Here, you are assigning the value of the CSV constant (which is the CSV class) to the a variable. In your code, you can then either use the CSV constant or the a variable to refer to the class object.
In these cases where you have the same name refer to different things (a class and a method respectively), Ruby can distinguish which one to call / return based on how you use it. Only of you explicitly and unambiguously call the "thing" (i.e. by passing a block or any other arguments), Ruby will call the method.
In all other cases, if you refer to a thing with a name starting with a capital letter, Ruby expects it to a constant and returns its referred to object (which in this case is the CSV class object).
a {|v|v}
Here, you get an error since Ruby tries to call the method named a (which doesn't exist). Even if this would work, the a variable is at this point a reference to the CSV class (which can't be called directly).
(Note: to call a method whose name you have stored in a variable, you can use the send method, e.g. my_receiver.send(a).)
Now, to solve your initial issue, you could create a method object and use it to call the desired method, e.g.
method_proc = #glob&.method(:each) || method(:crawl_dir).curry(#base_dir)
method_proc.call do |file|
puts file
end
However, this is not very idiomatic Ruby. Here, method references are seldom carried around (rather than in Javascript or Python where you regularly do this with passed function objects). A more idiomatic implementation in Ruby could be:
def handle_file(file)
puts file
end
if #glob.respond_to(:each)
#glob.each { |file| handle_file(file) }
else
crawl_dir(#base_dir) { |file| handle_file(file) }
end
Even more idiomatic would be if your crawl_dir method would (optionally) return an Enumerator object, in which case you could simplify the calling code.
Here, I assume that #glob is either nil or an Enumerable object (such as an Array or an Enumerator which thus response directly to each). This allows us to simplify the code further.
def crawl_dir(directory)
# Return an Enumerator object for the current method invocation if no
# block was passed, similar to how the standard `Enumerable#each` method
# works.
return enum_for(__method__) unless block_given?
# the rest of the method here...
end
enumerable = #glob || crawl_dir(#base_dir)
enumerable.each do |file|
puts file
end
What happens here is that you either take #glob (which we assume to be an Enumerable object if it exists, and thus response do each) or crawl_dir(#base_dir) without a block. From your crawl_dir method, you will get then an Enumerator object back, which is again an Enumerable. You can then loop over this object with each. Both of your objects thus have the same return type can can thus be used similarly.

Answer 2

If you want to get a reference to a method, you can use the Object#method method. You can then call this method using the Method#call method, or the .() syntactic sugar:
require 'csv'
a = method(:CSV)
a.() {|v| v }
#=> #<CSV io_type:$stdout encoding:UTF-8 lineno:0 col_sep:"," row_sep:"\n" quote_char:"\"">

Answer 3

You can always use tap on any object:
a.tap do |v|
p v
end