DEV Community: Daniele Lenares

Traits in Laravel: an elegant way to reuse code

Daniele Lenares — Mon, 18 Mar 2024 08:02:55 +0000

Traits offer an elegant way to reuse code, providing increased flexibility and ease of maintenance in your php and Laravel projects. In this article, we will explore what a trait is, how to use it, and the benefits it can offer.

What is a Trait?

A trait is a collection of methods that can be reused across different classes. Traits can contain methods, constants, or even property declarations. A class can use multiple traits, allowing you to combine functionality from different sources without having to extend a single parent class or implement an interface.

Using a Trait

To use a trait in any php project, simply use the use keyword followed by the name of the trait within the class you want to enrich with its methods. For example:

trait ApiResponse
{
    public function sendResponse($data)
    {
        return response()->json($data);
    }
}

use App\Traits\ApiResponse;

class Post
{
    use ApiResponse;

    public function someMethod()
    {
        // Rest of method that creates a $data variables
        return $this->sendReponse($data);
    }
}

In this example, the Post class uses the ApiResponse trait. Now, the Post class will have access to all the methods defined inside the ApiResponse trait as if they were defined directly within the class itself.

Benefits of Traits

Traits offer numerous benefits, such as:

Code Reusability: Traits allow you to separate code logic into smaller, reusable units. This promotes better code organization and reduces duplication.
Modularity: Traits enable you to add functionality to a class without creating a complex class hierarchy. You can combine multiple traits to achieve the desired combination of features.
- Simplified Maintenance: By using traits, you can make changes to a specific functionality in one place, rather than having to modify every class that implements that functionality. This simplifies maintenance and reduces the risk of errors.

Conclusion

Traits are a powerful tool that php provides to developers, making code more modular, reusable, and maintainable. They allow you to separate code logic into smaller units and combine them flexibly.

DoNPP - A PHP Docker starter

Daniele Lenares — Wed, 05 May 2021 17:25:31 +0000

I started working as a web developer in 2010 using mostly PHP as main programming language. Gradually, as the years passed by, I completely switched to a full-stack JavaScript experience and by the end of 2017 I completely removed PHP from my stack.

But I'm a curious person and a very curious dev... I need to know what is going on in the whole dev ecosystem!
So I wanted to try some shiny new or updated PHP framework or cms.

The only downside is that I do not want to install PHP directly on my machine and risk to mess up something with the world of dependencies needed.

So I built a quick and simple docker ecosystem containing PHP, Nginx and Postgres without messing with my local setup.

If you want to give it a spin, you can find it here
https://github.com/dnlnrs/donpp

Lint your commits

Daniele Lenares — Mon, 19 Apr 2021 08:34:22 +0000

If you are using Conventional Commits (and if you don't, you should 😜) it is very useful to have something that tells you if you are committing the right way.
This topic will be focused on JavaScript projects.

As you know, conventional commits are composed this way:

type(scope?): subject
body?
footer?

It's easy to do a commmit message that don't represent this standard so linting comes in our help!

We are going to use two packages: commitlint and husky

commitlint

This package checks if the commit messages are in the form showed above, or at least in a form type: subject. It's easily configurable through file so its configuration is shareable.

module.exports = {
  extends: ['@commitlint/config-conventional']
}

With the package installed and configured we are telling the code that we would like our commits to be "conventional".
But we need to ask commitlint to lint our messages.
Can we do this automatically everytime we make a new commit?

husky

Husky is a package that interact with the hooks exposed by git to trigger some custom actions: linters, error checking, scripts running, etc...
In this case we would like to trigger a commitlint check everytime we do a commit wothout the needing of launch the lint manually.
Fortunately the community comes in our help and we need to launch only two commands

yarn husky install

npx husky add .husky/commit-msg 'npx --no-install commitlint --edit $1'

At the end this setup will make sure that everytime we commit, the linter gets called and all checks are made.

And if we commit without following the rules, this happens (VSCode example)

⧗   input: test commit
✖   subject may not be empty [subject-empty]
✖   type may not be empty [type-empty]

✖   found 2 problems, 0 warnings