Architecting single action: Object vs Static Util

Question

Let's assume that I have a piece of functionality in my application which is responsible for adding a deleted marker file .deleted in a directory that is considered to be deleted.

What would be that best way to implement this? Static function or an object with a single method that conveys this functionality? Those are my 2 options (my language isn't functional):

class MarkAsDeletedDir {
  void apply(File directory) {
    directory.addChild(".deleted");
  }
}

Usage: new MarkAsDeletedDir().apply(dir)

or

class AppUtils {
  // other stuff
  // ...

  static void markAsDeletedDir(File directory) {
    directory.addChild(".deleted");
  }

}

Usage: AppUtils.markAsDeletedDir(dir)

Assume no performance overhead in creating new objects such as the former.

Answer 1

The problem you're facing is not exactly what people would define as primitive obsession, but I consider it to be very close.

So, are there other file/directory-related operations in your system?

If so, you can create your own File/Directory class, wrapping the standard class and providing your own operations on top.

The point is: Instead of thinking about making a util method (static) our a util class (MarkAsDeletedDir), you can just create a method on the File itself, such as yourOwnFile.markAsDeleted().

Answer 2

Static methods with side effects are problematic, because they cannot be mocked for unit testing. So I would recommend a regular class.

Answer 3

I personally don't like static methods. There are lots of reasons for that, but since you question is about a specific piece of code, I'm more inclined to the first option, but in such cases I usually use a decorator. Of course it depends on how your File interface looks like, and in case it's thin, the implementation could look like that:

interface File
{
    public function contents();
}

class Directory implements File
{
    public function contents()
    {
        return exec('ls -la');
    }
}

class DeletedDirectory implements File
{
    private $file;

    public function __construct(File $file)
    {
        $this->file = $file;
    }

    public function contents()
    {
        $this->file->addChild('.deleted');

        return $this->file->contents();
    }
}

Of course it's not an overkill or silver bullet, it's just one of the multiple ways to solve a problem. This particular solution could or could not match your exact needs, since any pattern is just a form and not an essence.