Check file equality better by skington · Pull Request #16 · spf13/fsync

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington · 2026-05-03T00:29:20Z

In the context of you should be able to use hard or symbolic links when setting up assets in Hugo to avoid them being copied, it turns out that the code that checks "are these two files the same thing?" only short-circuits "no, they aren't". But the Go standard library has thought about this, and implements a cross-platform "they're the same file, actually" method, so we should use this if we can.

This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.

Whether it's filename conventions, hard links or symbolic links, we should recognise that we're being asked about the same file, and it's inherently equal to itself.

While, obviously, if two files have a different size they're clearly not the same, we can look at e.g. the ultimate inode (Linux only) of two files and checking whether they're the same, even if the file paths we were given *look* different, for whichever reason (e.g. symbolic or hard links, or just that we didn't canonicalise file paths before checking).

skington added 3 commits May 3, 2026 01:18

Allow dependency injection of checking contents
cf94cb7
This is so we can test that the equals method recognises that two files are the same *inherently*, and doesn't bother checking them byte-for-byte.