If two static functions have the same name (in two different classes), the once cache is shared between the two resulting in wrong response during the second call (we can invert the two calls, the second one is always the wrong one).

I've just added a failing test. I read a little bit the code but didn't find the correct way to fix the bug…

In the once function, the $object variable is different for the two classes but the $hash is the same.

This tweak just uses a simple "Purse" object to cache all the cache hits instead of putting the values on a hidden property on the object itself. This solves a few problems: 1) don't have to ever think about sleep / wakeup. 2) no need for a MemoizeAware trait to avoid weird overloading errors, etc.

I'm guessing if merged this would require a 2.0 tag since I removed the trait as it is no longer ever necessary.

All tests pass without changes.

If this is accepted I'm considering just including it in Laravel 5.6.

Let me know what you think :smile:

fixes #59

The arguments of the surrounding method are now only used in the signature if the closure has arguments (#58) and the static variables use are now part of the cache signature. I've also switched to sha256 to have longer keys and less possible conflict.

This PR aims to add ability to use once() in static methods.

Not sure if there are enough tests, do not hesitate to tell.

If accepted, I'd love to port these changes for version 1.x as laravel/nova uses version 1.1

Overview

This PR adds dependabot automation for this repository.

Description

This PR updates the workflow that automatically merges dependabot PRs.

When performing auto-merging of PRs, Github Actions that have a major version update AND a compatibility score of >=90% are automatically merged as way to reduce the manual work of merging PRs that are of no risk of breaking changes. ONLY Github Actions that have a major version update are considered for automatic merging. Other dependencies are excluded.

id:dependabot-automation/v2

This PR adds a dependabot configuration file that enables weekly update checks for all github actions used within workflows in the project. Additionally, it includes a workflow that automatically merges dependabot PRs for minor and patch version updates (major version bumps must be manually merged to avoid breaking changes).

Using these features will help keep all workflows up to date with a minimal amount of manual intervention necessary.

Note: this functionality has already been added to the Spatie laravel package skeleton repository.

This adds a Cache::forgetObject method so that it is possible to clear the cache for a specific instance or class.

If you wanted to do this currently then you can either call Cache:flush() which would clear the entire cache or call Cache::forget($objectHash):

public static function forget(string $objectHash): string

protected static function objectHash($object): string

The first problem is that the objectHash method is protected so you would currently have to either extend the Cache class and implement your own method to get the object hash or to forget an object or duplicate the objectHash logic.

So a simple solution may be to make objectHash public but then each time you want to forget an object you will have to call objectHash. Instead I have added a convenient forgetObject object that internally gets the object hash and passes it to the forget method.

This allows you to:

// Forget instance
$object = new MyClass();
$object->getNumber();
Spatie\Once\Cache::forgetObject($object);

// Forget static method cache passing class reference
MyClass::getNumberForLetter('A');
Spatie\Once\Cache::forgetObject(MyClass::class);

The below also currently unintentionally works for class reference as objectHash will return class ref when $object is a string. However, if objectHash logic changed then this could no longer be the case. Whereas, the new forgetObject method would continue to work as expected.

Spatie\Once\Cache::forget(MyClass::class);

Added test and README update included.

Currently composer reports a problem when using php8:

Problem 1
    - Root composer.json requires spatie/once ^2.2.0 -> satisfiable by spatie/once[2.2.0].
    - spatie/once 2.2.0 requires php ^7.2 -> your php version (8.0.0RC2) does not satisfy that requirement.

this PR should fix it.

The examples aren't correct, (new MyClass())->getNumber() isn't repeatable.

I think each call creates a new instance with a unique hash, but also that they're destroyed and removed from the cache straight away.

This behaviour appears to go right back to v0.0.1, which makes me think it's a documentation issue rather than an implementation one?

<?php

require_once 'vendor/autoload.php';

class MyClass
{
    public function getNumber()
    {
        return once(function () {
            return rand(1, 10000);
        });
    }
}

var_dump([
    (new MyClass())->getNumber(),
    (new MyClass())->getNumber(),
    (new MyClass())->getNumber(),
]); // All different


$myClass = new MyClass();

var_dump([
    $myClass->getNumber(),
    $myClass->getNumber(),
    $myClass->getNumber(),
]); // All the same

A follow up from #41.

It's a pretty simple change. When once() is called from a global function, it will use file name as a cache identifier (currently it tries to use class name / instance which obviously doesn't exist and errors out).

I also included a test to make sure it's working.

This package uses function name in a hash calculation. For closures, function name will always be "namespace{closure}", therefore calculated hash will be always the same, if arguments also match. This raises a problem, since once() will be run only once regardless of the method it is nested in and return the same result across methods.

What I did here is, that the hashing method checks, if once() was called from within a closure and instead of using generic function name, it uses the line number of once() call.

Here is an example, how I got an idea for even using once() in a closure:

public function getSomething($element)
{
    $getData = function () {
        return once(function () {
            // An expensive function call that does not depend on
            // method's arguments.
        });
    };

    retrun $getData()[$element];
}

If I was to use once() outside the closure, it would take $element argument into consideration, so every time the method would be called with a different argument, once() would call its closure. Now with once() being in a closure, the arguments (there are none in the example) are always the same and the calculated hash will match every time).

I could of course extract this expensive function call in its own method, but sometimes you would only need that part one time, so declaring a separate method seems overkill and using closure just seems more "right".

I also included two tests which demonstrate the functionality of this PR.

Bonus: If you wrap once() in a closure, you can also have multiple such occurances per method giving you different results. Currently you can only have one once() per method because every next one will return you the result of the first one.

Bumps actions/checkout from 2 to 3.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.