How to patch File and CoreExtensions for Timecop - ruby

Question

I need to monkey-patch File. Timecop doesn't affect the time that the file system reports, which is what File.atime uses and in turn that's what HttpClient uses when posting a file to a server, which in turn means VCR doesn't quite work as desired. AFAIK, this means I can't use refinements.
I don't understand what's going on here:
class File
def atime
"this one happens"
end
end
module CoreExtensions
module File
module TimecopCompat
def atime
"this one does not"
end
end
end
end
File.include CoreExtensions::File::TimecopCompat
File.new('somefile').atime # --> "this one happens"
Why does the module-based monkey patching not happen? What do I need to change for it to work? Is there a different kind of monkey-patching that I should be using?

Answer 1

The issue is related to the way include appends the module to the ancestor chain. "Ruby modules: Include vs Prepend vs Extend" provides a very detailed overview of the differences between include and prepend.
Take a look at these two examples:
class Foo
def hello
"1"
end
end
module Bar
def hello
"2"
end
end
Foo.include Bar
Foo.new.hello
# => "1"
Foo.ancestors
# => [Foo, Bar, Object, Kernel, BasicObject]
versus
class Foo
def hello
"1"
end
end
module Bar
def hello
"2"
end
end
Foo.prepend Bar
Foo.new.hello
# => "2"
Foo.ancestors
# => [Bar, Foo, Object, Kernel, BasicObject]
Basically, you want to use prepend in your case as include won't override the existing method.

Answer 2

include is not some magic thing. It is very simple actually: it makes the module the superclass of the class it is mixed into. Now: do superclass methods override subclass methods? No, of course not, it is the other way around.
Therefore, include cannot possibly override methods of the class the module is being included into.
That is what prepend is for, which mixes in a module at the beginning of the ancestors hierarchy. (Which unfortunately cannot be simply explained using inheritance, it is something different.)

Answer 3

Let's simplify your example without changing the question.
module TimecopCompat
def atime
"this one does not"
end
end
I have left the class File alone as it already has an instance method File#atime.
File.new('temp').atime
#=> 2019-07-16 20:20:51 -0700
As explained by the other answers, executing
File.include TimecopCompat
results in:
File.ancestors
#=> [File, TimecopCompat, IO, File::Constants, Enumerable, Object, Kernel, BasicObject]
File.new('temp').atime
#=> 2019-07-16 20:20:51 -0700
whereas executing
File.prepend TimecopCompat
results in:
File.ancestors
#=> [TimecopCompat, File, IO, File::Constants, Enumerable, Object, Kernel, BasicObject]
File.new('temp').atime
#=> "this one does not"
It is poor practice, however, to change the behavior of any core method, as its original behavior may be relied upon elsewhere in the program.
Here there are two acceptable practices. The first is to create a method (new_atime, say) that has a File object (file, say) as its argument:
file = File.new('temp')
x = new_atime(file)
new_atime cannot be chained with a File object as its receiver, but that is a small price to pay for a safe and robust solution.
The second option is to use Refinements to refine the File class.
module RefinedFile
refine File do
def atime
"this one does not"
end
end
end
class C
using RefinedFile
File.new('temp').atime
end
#=> "this one does not"
We can confirm that File#atime has not been altered outside the class C:
File.new('temp').atime
#=> 2019-07-16 20:20:51 -0700