Action Output Results interpret ansi color codes and break render

[llaville]

For example ansi style color code on action output results is interpreted by CaptainHook and break render.

   '  <fg=cyan>Applied: ' .

I've tested Mago 1.9.0 with my plugin

Capt'n config file examples/pre-push.mago.json

{
    "pre-push": {
        "enabled": true,
        "actions": [
            {
                "action": "{$ENV|value-of:VENDOR_BIN_DIR|default:vendor/bin/}mago lint",
                "config": {
                    "label": "Static Analysis (with Mago)"
                },
                "options": {
                    "configuration-path": "mago.toml",
                    "colors": "never"
                },
                "conditions": [
                    {
                        "exec": "\\Bartlett\\CaptainHookBinPlugin\\Condition\\PackageInstalled",
                        "args": ["carthage-software/mago", "^1"]
                    }
                ]
            }
        ]
    }
}

Note

The mago.toml config file is generated to answered all default values to vendor/bin/mago init command

My Plugin (under tests pressure)

<?php

declare(strict_types=1);

namespace Bartlett\CaptainHookBinPlugin;

use CaptainHook\App\Config;
use CaptainHook\App\Plugin;
use CaptainHook\App\Runner\Hook as RunnerHook;

class BinPlugin extends Plugin\Hook\Base implements Plugin\Hook
{
    public function beforeHook(RunnerHook $hook): void
    {
        $this->io->write("Do debug before hook {$hook->getName()} runs");
    }

    public function beforeAction(RunnerHook $hook, Config\Action $action): void
    {
        $actionOptions = $action->getOptions();

        $configPath = $actionOptions->get('configuration-path');
        if (null !== $configPath && \file_exists($configPath)) {
            \putenv('XDG_CONFIG_HOME=' . $configPath);
        }

        $colorized = match($actionOptions->get('colors', 'auto')) {
            'never' => false,
            default => true  // always or auto values are acceptable
        };
        \putenv('NO_COLOR=' . !$colorized);

        $this->io->write("Do debug before action {$action->getLabel()} runs");
    }

    public function afterAction(RunnerHook $hook, Config\Action $action): void
    {
        $this->io->write("Do debug after action {$action->getLabel()} runs");
        \putenv('XDG_CONFIG_HOME');
    }

    public function afterHook(RunnerHook $hook): void
    {
        $this->io->write("Do debug after hook {$hook->getName()} runs");
    }
}

Mago accept both XDG_CONFIG_HOME and NO_COLOR environment variables : see https://mago.carthage.software/guide/environment-variables

Direct invocation of Mago

XDG_CONFIG_HOME=mago.toml NO_COLOR=1 vendor/bin/mago lint

Gave something like (with current state source code)

Capt'n invocation of Mago

vendor/bin/captainhook hook:pre-push -vv

Important

Due to issue #299, I cannot invoke only one action by config file, so I've disabled all others (PHPStan, PHPUnit) confirmed by command

vendor/bin/captainhook config:info

Hooks:
  commit-msg
  pre-push
   - {$ENV|value-of:VENDOR_BIN_DIR|default:vendor/bin/}mago lint
  pre-commit
  prepare-commit-msg
  post-commit
  post-merge
  post-checkout
  post-rewrite
  post-change

Gave something like (with current state source code)

And if I've other actions, the color render is still broken: i.e

[sebastianfeldmann]

If you run commands as Action, you have to specify the command options there.
The options are only for PHP Actions that implement the Action Interface.

So in you case it should look like this

{$ENV|value-of:VENDOR_BIN_DIR|default:vendor/bin/}mago lint --configuration-path=mago.toml --colors=never

[sebastianfeldmann]

Ah if the output contains some Symfony coloring options like <fg=cyan> the output handler will interpret it just like normal output containing formatting tags.

I have to check if I can escape that somehow or tell the Symfony output decorator to ignore that stuff.

[llaville]

The goal of my plugin is to avoid to hard code such options/flags on command line.
Is there another alternative ?

[sebastianfeldmann]

You can create a PHP class that deals with the options and then do the system call yourself.

class MyMago implements Action
{
        $magoCmd = $this->createCommand($options);
        system($magoCmd);
}

"action": "\\MyMago",
"options": {
  "colors": true,
  "cfg-file": "mago.toml"
}

[sebastianfeldmann]

You can use custom config values

"config": {
  "custom": {
    "mago-color": "1"
  }
}

    "action": "mago NO_COLOR={$CONFIG|value-of:custom>>mago-color|default:1}...."

[llaville]

Ah if the output contains some Symfony coloring options like <fg=cyan> the output handler will interpret it just like normal output containing formatting tags.

I have to check if I can escape that somehow or tell the Symfony output decorator to ignore that stuff.

I've found a solution ! I'll propose you, and please tell me if you think it's acceptable ?

In captainhook/src/Runner/Action/Cli.php, (around line 65) rather than wrote :

        if (!empty($output)) {
            $io->write(
                ['  <comment>command output:</comment>', trim($output)],
                true,
                !$result->isSuccessful() ? IO::NORMAL : IO::VERBOSE
            );
        }

Apply

        if (!empty($output)) {
            $verbosity = !$result->isSuccessful() ? IO::NORMAL : IO::VERBOSE;
            $io->write('  <comment>command output:</comment>', true, $verbosity);
            $io->writeRaw(trim($output),true, $verbosity);
        }

And in captainhook/src/Console/IO/CollectorIO.php, introduces the new writeRaw function as follow :

    public function writeRaw($messages, $newline = true, $verbosity = IO::NORMAL): void
    {
        $output = $this->io->getOutput();
        /** @var OutputFormatter $formatter */
        $formatter = clone $output->getFormatter();
        $formatter->setDecorated(false);

        if (is_string($messages)) {
            $messages = [$messages];
        }

        foreach ($messages as $message) {
            $this->write($formatter->format($message), $newline, $verbosity);
        }
    }

That will gave, by examples

First run with forcing colors on Mago call

Second run with disabling colors on Mago call

[llaville]

Wait ... I found very strange behavior : don't really know if it's related to Mago or another PHP cli toolchain. Need more investigation !

[llaville]

Ok, the patch I provided seems good, even if it's not perfect .

Checks a direct invocation of Mago (1.9.1)

And through Capt'n 5.28.3

The <fg=cyan> style was removed from ouput, that could be strange to understand Mago results (but it may be acceptable, if we know the problem).

[llaville]

For invocation, I've finally adopted the custom config feature

        "custom": {
            "mago-colors": "--colors=always"
        }

And in capt'n hook config file

{
    "pre-push": {
        "enabled": true,
        "actions": [
            {
                "action": "MAGO_LOG={$ENV|value-of:MAGO_LOG|default:info} XDG_CONFIG_HOME={$ENV|value-of:XDG_CONFIG_HOME|default:~/.config/mago/} {$ENV|value-of:VENDOR_BIN_DIR|default:vendor/bin/}mago {$CONFIG|value-of:custom>>mago-colors} lint",
                "config": {
                    "label": "Static Analysis (with Mago)"
                },
                "conditions": [
                    {
                        "exec": "\\Bartlett\\CaptainHookBinPlugin\\Condition\\PackageInstalled",
                        "args": ["carthage-software/mago", "^1"]
                    }
                ]
            }
        ]
    }
}

That matches my goals : no direct hard-coded value on invocation !

[sebastianfeldmann]

I'm not sure if adding the writeRaw method to the IO interface is the right approach.
Feels a bit heavy.

I was thinking about creating a IOUtil::escapeSymfonyColoring method that makes sure we escape any Symfony tags.
Symfony supports escaping <info> with \<info>.
I think that's the better option.

        if (!empty($output)) {
            $io->write(
                [
                    '  <comment>command output:</comment>',
                    // use escaped output to not have accidental coloring
                    IOUtil::escapeSymfonyColoring(trim($output))
                ],
                true,
                !$result->isSuccessful() ? IO::NORMAL : IO::VERBOSE
            );
        }

[sebastianfeldmann]

The problem with the interface is, that the IO is only collecting the output not writing them to stdOut immediately.

So the collector would need to remember which method was called write or writeRaw and the real IO object would need to respect that somehow.
That makes the whole IO handling a bit complicated.

I need to think about it a bit more, because telling the IO that we do not want it to decorate the output with colors would actually be nice.

[llaville]

Remember that standard coloring style like info, comment ... is not origin of this issue.
It's when output return custom style syntax like fg.

BTW, I agree with you on CollectorIO and writeRaw. It was a quick proposal to fix the problem.
Feel free to use part of code for your own solution.