DEV Community: Graffino

Enhancing Laravel Commands: Parameterized Inputs and Custom Output Formats [4/4]

Nick Ciolpan — Fri, 26 May 2023 13:02:17 +0000

So far, so good. It gives us some insights into the current state of our gating system, but not much more. Since we've come this far, we might as well take one step further and incorporate two crucial aspects of commands: the ability to pass parameters. Once we have this functionality in place, the console kernel becomes equally powerful as the web kernel, granting access to all infrastructure and data layers, just as you would normally have.

What we do is pass a username to the command and then examine each gate for the retrieved user. We mark, in an additional column, whether the user can pass it or not, indicating a green "pass" or a red "restricted".

Try to and identify the new code additions. I’ll give you a hint: start with the command signature. Feel free to comment if you have any questions. And, most importantly, have fun!

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Contracts\Auth\Access\Gate;
use App\Models\User;

class CheckGates extends Command
{
    protected $signature = 'gate:check {username}';
    protected $description = 'Check access of user for all defined gates in Laravel';

    protected $gate;

    public function __construct(Gate $gate)
    {
        parent::__construct();
        $this->gate = $gate;
    }
    protected function getClosureContents(\Closure $closure)
    {
        $reflection = new \ReflectionFunction($closure);
        $closureCode = file($reflection->getFileName());

        $startLine = $reflection->getStartLine();
        $endLine = $reflection->getEndLine();

        $contents = array_slice($closureCode, $startLine - 1, $endLine - $startLine + 1);

        return implode('', $contents);
    }
    public function handle()
    {
        $username = $this->argument('username');
        $user = User::where('username', $username)->first();

        if (!$user) {
            $this->error("No user found with username: $username");
            return;
        }

        $gates = $this->gate->abilities();
        $self = $this;

        $tableData = array_reduce(array_keys($gates), function ($carry, $key) use ($gates, $user, $self) {
            $value = $gates[$key];
            $hasAccess = $this->gate->forUser($user)->check($key);

            $carry[] = [
                'Gate Name' => $key,
                'Access' => $hasAccess ? '<fg=green>Pass</>' : '<fg=red>Restricted</>',
                'Closure Contents' => $self->getClosureContents($value),
            ];

            return $carry;
        }, []);

        $this->table(['Gate Name','Access', 'Closure Contents'], $tableData);
    }
}

Create a Laravel Command to Display All Authorization Gates Similar to route:list [3/4]

Nick Ciolpan — Fri, 26 May 2023 12:56:36 +0000

Create the ListGates command file:

Create a new file called ListGates.php inside the app/Console/Commands directory of your Laravel project.
Place the following code inside the ListGates.php file:

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Contracts\Auth\Access\Gate;

class ListGates extends Command
{
    protected $signature = 'gate:list';
    protected $description = 'List all defined gates in Laravel';

    protected $gate;

    public function __construct(Gate $gate)
    {
        parent::__construct();
        $this->gate = $gate;
    }

    protected function getClosureContents(\Closure $closure)
    {
        $reflection = new \ReflectionFunction($closure);
        $closureCode = file($reflection->getFileName());

        $startLine = $reflection->getStartLine();
        $endLine = $reflection->getEndLine();

        $contents = array_slice($closureCode, $startLine - 1, $endLine - $startLine + 1);

        return implode('', $contents);
    }

    public function handle()
    {
        $gates = $this->gate->abilities();
        $self = $this;

        $tableData = array_reduce(array_keys($gates), function ($carry, $key) use ($gates, $self) {
            $value = $gates[$key];

            $carry[] = [
                'Gate Name' => $key,
                'Closure Contents' => $self->getClosureContents($value),
            ];

            return $carry;
        }, []);

        $this->table(['Gate Name', 'Closure Contents'], $tableData);
    }
}

The only additional task we need to perform is formatting the gates array in a structure suitable for the table format expected by the table method of the Command class. Laravel provides a range of convenient methods for CLI output formatting with the Symphony Console component, making this process much easier.

<?php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    // ...

    protected $commands = [
        // Other commands...
        \App\Console\Commands\ListGates::class,
    ];

    // ...
}

Now, you can run the gates:list command from your terminal:

php artisan gate:list

And get this beautiful table:

+---------------+----------------------------------------------------------+
| Gate Name     | Closure Contents                                         |
+---------------+----------------------------------------------------------+
| viewHorizon   |         Gate::define('viewHorizon', function ($user) {   |
|               |             return in_array($user->email, [              |
|               |                 //                                       |
|               |             ]);                                          |
|               |         });                                              |
|               |                                                          |
| viewTelescope |         Gate::define('viewTelescope', function ($user) { |
|               |             return in_array($user->email, [              |
|               |                 //                                       |
|               |             ]);                                          |
|               |         });                                              |
|               |                                                          |
+---------------+----------------------------------------------------------+

How to use the PHP Reflection API for Inspecting Closure Contents [2/4]

Nick Ciolpan — Fri, 26 May 2023 12:53:52 +0000

The Reflection API in PHP is a set of classes that allow you to introspect your code. It provides the ability to retrieve detailed information about classes, methods, properties, and functions at runtime, such as their names, parameters, and modifiers (like public, private, protected), among other things. It's commonly used for advanced tasks like building development tools, debuggers, or components for a dependency injection container.

Closures (or anonymous functions) in PHP are considered "black boxes" because they encapsulate their behavior and environment when defined. This means that their internal variables and code can't be directly accessed or inspected from the outside like regular variables - you can only interact with them through their inputs and outputs. When you try to dump a closure with var_dump(), print_r(), or Laravel's dd(), you don't see the actual PHP code inside the closure. This is why you need tools like the Reflection API to inspect their contents.

$getClosureContents = function(\Closure $closure)
{
    $reflection = new ReflectionFunction($closure);
    $closureCode = file($reflection->getFileName());

    $startLine = $reflection->getStartLine();
    $endLine = $reflection->getEndLine();

    $contents = array_slice($closureCode, $startLine - 1, $endLine - $startLine + 1);

    return implode('', $contents);
}

What we're doing here is pretty simple: We find the exact PHP file that has the closure, read the content of this file, get all the lines from the start to the end, and put the function back together as a multiline string. But this process would not be possible without the useful features of PHP's Reflection.

$closureContents = array_map($getClosureContents, $gates);

Will put out:

[
     "viewHorizon" => """
               Gate::define('viewHorizon', function ($user) {\n
                   return in_array($user->email, [\n
                       //\n
                   ]);\n
               });\n
       """,
     "viewTelescope" => """
               Gate::define('viewTelescope', function ($user) {\n
                   return in_array($user->email, [\n
                       //\n
                   ]);\n
               });\n
       """,
   ]

Now we are able to: Create a Laravel Command to Display All Authorization Gates Similar to route:list

How to List All Authorization Gates in Your Laravel Application [1/4]

Nick Ciolpan — Fri, 26 May 2023 12:50:25 +0000

While Laravel doesn't provide an Artisan command specifically for listing gates, there's a valid reason for this. The need to inspect these gates doesn't arise frequently. If such a situation does occur, you can rely on the ol’ debugging tools.

But for now I need to put together something quick and explore my options. That’s a job for the tinker command which allows us to evaluate PHP and Laravel code on-the-fly and see the results immediately, which can be incredibly useful in our scenario.

When it comes to what you can do with the Gates class, although the available methods are not explicitly exposed in the official Laravel documentation, contracts and facades serve as excellent sources of documentation for what you can accomplish with them.

Here, I am retrieving all the defined abilities and listing their names to provide a quick overview.

use Illuminate\Contracts\Auth\Access\Gate;

$gates = app(Gate::class)->abilities();
echo implode("\n", array_keys($gates));

What the abilities method gives us is an associative array with key names and the corresponding closures - because that's how gate-based authorization works in Laravel. Gates provide a simple, Closure (a type of anonymous function in PHP) based approach to authorization.

[
  "viewHorizon" => Closure($user) {#446 …4},
  "viewTelescope" => Closure($user) {#449 …4},
]

For now, we'll output a list with all their names. Helpful? A bit, yes - I can now at least know what to search for and inspect in my codebase. Should we be able to take a quick look at the contents as well? Well, the whole closure aspect of it requires some extra tinkering before we can look under their hood.

Boolean flip helper for Elm

Nick Ciolpan — Fri, 15 May 2020 07:19:53 +0000

There is no such thing as !True to get a False value in Elm.

Here's how I do it.

module Helpers.Bool exposing (flip)

flip: Bool -> Bool
flip bool = 
    if bool == True then
    False
  else
    True

And then:

import Helpers.Bool

...

Helpers.Bool.flip True

For more: Today I Learned

Ruby's .times in JavaScript

Nick Ciolpan — Wed, 11 Dec 2019 09:58:33 +0000

Never modify JavaScript's standard built-in objects. That's what they say.

But just for fun, let's see how Ruby's .times would look like in JavaScript.

Here's how we do it:

String.prototype.times = function (n) {
    for (var i = 0; i < parseInt(this); i++) {
        n();
    }
}

var myFunc = function () { console.log('Hello World') }
"2".times(myFunc)

Output:

"Hello World"
"Hello World"

nickciolpan
29 May 2018

You can write better jQuery

Nick Ciolpan — Tue, 23 Jul 2019 12:43:22 +0000

While almost every new article mentioning it, talks about its demise, I’ve decided to write as about one of the most recurrent jQuery bad practices I came across and how to deal with it. Here it is:

Going from this:


$('.multiSelectOne').multiselect({
    buttonClass: 'btn btn-default',
    buttonWidth: '100%',
    ...
});
$('.multiSelectTwo').multiselect({
    buttonClass: 'btn btn-default',
    buttonWidth: '100%',
    nonSelectedText: '---',
    ...
});

To This:

<select class="js-multiselect" 
    data-include-select-all-option="true" 
    data-all-selected-text="All">
    <option></option>
</select>

$('.js-multi-select).each(function () {
    let options = {};

    Object.entries($(this).data())
        .map(property => options[property[0]] = property[1]);

  $(this).multiselect(options);

}

And never go back for adjustments in the script file ever again.