I just recently fat-fingered a branch-deletion of a remote branch. But luckily git has you covered should you do that. Let me tell you the story…

I don’t know why on a lot of keyboards the letters D and F are right next to each other (well, I know but that’s a different story). So far that never was an issue.

But! If you start sloppy typing and while hitting the F key you also hit the D that usually just means you will have to use the backspace and delete a character you didn’t want.

Unless you are on the CLI and hit ENTER immedately after …

What happened:

I was working on a branch and commited some stuff to it. As I already had a PR open for it on github I pushed the change.

Of course the CI found a minor thing in the code. I was casting something that was unnecessary. So I removed that cast in the code and commited that as well to my local branch. As it was a really minor change that I should have done with the previous commit already I decided to do a git commit --amend --no-edit . Just add that to the previous commit and be done.

That now replaced the last commit with a new one and I had to force-push that to the remote branch.

And now I fat fingered.

Instead of git push origin branchname -f I typed git push origin branchname -df

And the -d means: Delete that branch on the remote server.

I mean it’s not that much of a loss. I could have just used git push origin branchname again and be done.

But with deleting the remote branch I also closed the PR. And just pushing the branch again would require me to create a new branch instead of being able to reopen the old one. Why? because the old PR was associated with the old commit-hash. But I now had a new commit-hash.

So how could I fix that?

git reflog to the rescue! While still on the local branch I issued this:

git reflog
4fcb8ff4d (HEAD -> branchName, origin/branchName) HEAD@{0}: commit (amend): Commit Message
0cc696b53 HEAD@{1}: commit: Commit Message
458011b1b HEAD@{2}: rebase (continue) (finish): returning to refs/heads/branchName

So the great thing here is that we not only have the log of our last commits (which would only show one entry for the Commit Message` commit. But we have both commit hashes. How cool is that!

That allowed me now to do git push origin 0cc696b53:branchName which pushed the commit 0cc696b53 to the server and named the resulting branch branchName . That caused GitHub to realize that the branch is still existing and allowed me to reopen the PullRequest.

So now we are almost in the same situation as before my fat fingered stupidity.

The only thing left to do now is to actually push (and not delete) the branch to the server.

And a git push origin branchName -f (no -d) later the branch is updated and the PullRequest knows about the update and CI is up and running.

Thank you git for saving my back!

It bothered me for a long time that installing tools via composer cluttered my projects with unnecessary dependencies and also bind my code to the dependencies of my development toolchain and vice-versa.

The easy way to solve that was to use phar-files for the tools I am using in my development chain. So tools like phpunit, phpstan, psalm or phpcs/phpcbf. All of these can be installed via composer require --dev – but also via phive install.

The trouble though when using the phar-files was, that composer didn’t know about them and whenever I wanted to use a plugin for one of those tools, composer didn’t know that the tool was already there and so installed the tool again. Which wasn’t helpful!

I was thinking about multiple ways to handle that. Like a plugin for composer to remove installed PHAR-files from the internal resolver-tree and what other ideas I had. All of these didn’t really work out.

Until a few days it hit me: composers replace config-option!

So what did I do:

After installing my tool – in this case php-codesniffer – via phive install phpcs --copy I created a new composer.json file in the .phive-folder with the following content:

{
    "name": "myproject/phive_stuff",
    "description": "A replacement package for phars",
    "minimum-stability": "stable",
    "license": "MIT",
    "replace" : {
        "squizlabs/php_codesniffer": "*"
    }
}

Now I added this code to my projects composer.json file:

{
    "repositories": [{
        "type": "path",
        "url": ".phive/"
    }]
}

Then all that was left to do was to require the new package via

composer require --dev myproject/phive_stuff 

With all that done I can now install plugins for php-codesniffer via

composer require --dev phpcompatibility/php-compatibility

and composer will realize that php-codesniffer is already installed and not install it again.

Caveat

This has some caveats though! For example there are two tools phpcs and phpcbf that need to be installed via phive while requiring squizlabs/php-codesniffer will install both of them.

Due to the way phive works, the binaries are by default linked into the project from a main folder outside the project which can break when using docker. That’s why I usually call phive with the --copy flag as that actually adds a copy of the phar to the tools -folder.

Due to this linking phpcs suddenly created its config-file in that shared folder which had some unexpected sideeffects. When using --copy the confi is added by default to the tools folder.

So there might be some extra work necessary when using PHARs. But at least it works now 😁

Further ideas

My main idea now was to automate this manual process as that is something that can automatically done by phive when installing (or updating) a tool.

Would that something that helps others as well? Feel free and leave your comment in the feature-request on github

After more than a year talking about it, there finally is a common interface for clock-implementations available.

And no: It’s not (yet) PSR-20.

Especially in combination with constructor property promotion.

Recently I did a code-review on an entity from a PHP8.0 project. What I saw was this:

The origin

<?php

declare(strict_types=1);

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ORM\Table(name: 'user')]
class User
{
    #[ORM\Id]
    #[ORM\Column(type: 'integer', unique: true)]
    public int $id;

    #[ORM\Column(type: 'string')]
    public string $username;

    #[ORM\Column(type: 'string')]
    public string $passwordhash;

    public function __construct(
        int $id,
        string $username,
        string $passwordhash,
    ) {
        $this->id = $id;
        $this->username = $username;
        $this->passwordhash = $passwordhash;
    }
}

I was thinking about using constructor property promotion to get rid of the property declaration and property assignment but immediately thought that that would require us to handle the attributes differently. So I shortly checked my favourite search engine and realized that indeed we are able to shorten this whole stuff considerably:

The result

<?php


declare(strict_types=1);

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity]
#[ORM\Table(name: 'user')]
class User
{
    public function __construct(
        #[ORM\Id]
        #[ORM\Column(type: 'integer', unique: true)]
        public int $id,
        #[ORM\Column(type: 'string')]
        public string $username,
        #[ORM\Column(type: 'string')]
        public string $passwordhash,
    ) {}
}

Combining the attributes with the constructor property promotion allows much smaller entity definitions.

Immutability

In our case we also cleared a misunderstanding. My colleague was under the impression that Doctrine requires properties to be public. Otherwise they are not able to be hydrated properly. That is not the case and Doctrine can perfectly hydrate private properties!

So we decided to go for private properties in combination with getters. As in our concrete implementation we actually also need to execute some logic before returning some of the values. So declaring the properties private and having getters provides us with a truly immutable entity.

As we are not using PHP8.1 yet we could not make use of the new readonly declaration which would have solved the issue with the immutability though as we need logic in some cases the approach with using getters always makes more sense in this particular setup.