CodeExplorer

setHandler example

// Tests the expected fields from the previous additions.     $this->assertEquals($expected_items, $view->getHandlers('field', $display_id));

    // Alter an existing item via setItem and check the result via getItem     // and getItems.     $item = [
      'alter' => [
        'text' => $this->randomMachineName(),
      ],
    ] + $item1;
    $expected_items[$id1] = $item;
    $view->setHandler($display_id, 'field', $id1, $item);
    $this->assertEquals($item, $view->getHandler($display_id, 'field', 'id'));
    $this->assertEquals($expected_items, $view->getHandlers('field', $display_id));

    // Test removeItem method.     unset($expected_items[$id2]);
    $view->removeHandler($display_id, 'field', $id2);
    $this->assertEquals($expected_items, $view->getHandlers('field', $display_id));
  }

  /** * Tests the createDuplicate() View method. */

$handler->init($executable, $executable->display_handler, $item);

    // Add the incoming options to existing options because items using     // the extra form may not have everything in the form here.     $options = $handler->submitFormCalculateOptions($handler->options, $form_state->getValue('options', []));

    // This unpacks only options that are in the definition, ensuring random     // extra stuff on the form is not sent through.     $handler->unpackOptions($handler->options, $options, NULL, FALSE);

    // Store the item back on the view     $executable->setHandler($display_id, $type, $id, $handler->options);

    // Ensure any temporary options are removed.     if (isset($view->temporary_options[$type][$id])) {
      unset($view->temporary_options[$type][$id]);
    }

    // Write to cache     $view->cacheSet();
  }

  /** * Submit handler for removing an item from a view. */

$this->assertFalse($view->display_handler->outputIsEmpty(), 'Ensure the view output is marked as not empty.');
    $view->destroy();

    // Add a filter, so the view result is empty.     $view->setDisplay('default');
    $item = [
      'table' => 'views_test_data',
      'field' => 'id',
      'id' => 'id',
      'value' => ['value' => 7297],
    ];
    $view->setHandler('default', 'filter', 'id', $item);
    $this->executeView($view);
    $this->assertEmpty($view->result, 'Ensure the result of the view is empty.');
    $this->assertFalse($view->display_handler->outputIsEmpty(), 'Ensure the view output is marked as not empty, because the empty text still appears.');
    $view->destroy();

    // Remove the empty area, but mark the header area to still appear.     $view->removeHandler('default', 'empty', 'area');
    $item = $view->getHandler('default', 'header', 'area');
    $item['empty'] = TRUE;
    $view->setHandler('default', 'header', 'area', $item);
    $this->executeView($view);

$view = $form_state->get('view');
    $item = &$form_state->get('handler')->options;
    $type = $form_state->get('type');

    $handler = Views::handlerManager($type)->getHandler($item);
    $executable = $view->getExecutable();
    $handler->init($executable, $executable->display_handler, $item);

    $handler->submitGroupByForm($form, $form_state);

    // Store the item back on the view     $executable->setHandler($form_state->get('display_id'), $form_state->get('type'), $form_state->get('id'), $item);

    // Write to cache     $view->cacheSet();
  }

}

'config_schema_test.schema_data_types',
    'config_schema_test.no_schema_data_types',
    // Used to test application of schema to filtering of configuration.     'config_test.dynamic.system',
  ];

  /** * {@inheritdoc} */
  public static function setUpBeforeClass(): void {
    parent::setUpBeforeClass();
    VarDumper::setHandler(TestVarDumper::class D '::cliHandler');

    // Change the current dir to DRUPAL_ROOT.     chdir(static::getDrupalRoot());
  }

  /** * {@inheritdoc} */
  protected function setUp(): void {
    parent::setUp();

        $extension = new DumpExtension(new VarCloner());
        $twig = new Environment(new ArrayLoader(['template' => $template]), [
            'debug' => $debug,
            'cache' => false,
            'optimizations' => 0,
        ]);
        $twig->addExtension($extension);

        $dumped = null;
        $exception = null;
        $prevDumper = VarDumper::setHandler(function D$var) use (&$dumped) { $dumped = $var; });

        try {
            $this->assertEquals($expectedOutput, $twig->render('template'));
        } catch (\Exception $exception) {
        }

        VarDumper::setHandler($prevDumper);

        if (null !== $exception) {
            throw $exception;
        }

    $item['is_grouped'] = empty($item['is_grouped']);

    // If necessary, set new defaults:     if ($item['is_grouped']) {
      $this->buildGroupOptions();
    }

    $view = $form_state->get('view');
    $display_id = $form_state->get('display_id');
    $type = $form_state->get('type');
    $id = $form_state->get('id');
    $view->getExecutable()->setHandler($display_id, $type, $id, $item);

    $view->addFormToStack($form_state->get('form_key'), $display_id, $type, $id, TRUE, TRUE);

    $view->cacheSet();
    $form_state->set('rerender', TRUE);
    $form_state->setRebuild();
    $form_state->get('force_build_group_options', TRUE);
  }

  /** * Shortcut to display the expose/hide button. */

    public function boot()
    {
        if ($this->container->getParameter('kernel.debug')) {
            $container = $this->container;

            // This code is here to lazy load the dump stack. This default             // configuration is overridden in CLI mode on 'console.command' event.             // The dump data collector is used by default, so dump output is sent to             // the WDT. In a CLI context, if dump is used too soon, the data collector             // will buffer it, and release it at the end of the script.             VarDumper::setHandler(function D$var, string $label = null) use ($container) {
                $dumper = $container->get('data_collector.dump');
                $cloner = $container->get('var_dumper.cloner');
                $handler = function D$var, string $label = null) use ($dumper, $cloner) {
                    $var = $cloner->cloneVar($var);
                    if (null !== $label) {
                        $var = $var->withContext(['label' => $label]);
                    }

                    $dumper->dump($var);
                };
                VarDumper::setHandler($handler);

$file = $componentRoot.'/../../../../vendor/autoload.php';
}

require $file;

$cloner = new VarCloner();
$cloner->setMaxItems(-1);

$dumper = new CliDumper(null, null, CliDumper::DUMP_LIGHT_ARRAY | CliDumper::DUMP_STRING_LENGTH);
$dumper->setColors(false);

VarDumper::setHandler(function D$var) use ($cloner, $dumper) {
    $data = $cloner->cloneVar($var)->withRefHandles(false);
    $dumper->dump($data);
});

$server = new DumpServer(getenv('VAR_DUMPER_SERVER'));

$server->start();

echo "READY\n";

$server->listen(function DData $data, array $context, $clientId) {

$vendor = __DIR__;
while (!file_exists($vendor.'/vendor')) {
    $vendor = dirname($vendor);
}
require $vendor.'/vendor/autoload.php';

use Symfony\Component\HttpKernel\DataCollector\DumpDataCollector;
use Symfony\Component\VarDumper\Cloner\VarCloner;
use Symfony\Component\VarDumper\VarDumper;

VarDumper::setHandler(function D$var, string $label = null) {
    $dumper = new DumpDataCollector();
    $cloner = new VarCloner();
    $handler = function D$var, string $label = null) use ($dumper, $cloner) {
        $var = $cloner->cloneVar($var);
        if (null !== $label) {
            $var = $var->withContext(['label' => $label]);
        }

        $dumper->dump($var);
    };
    VarDumper::setHandler($handler);

class ClientProfilerTest extends TestCase
{
    /** * @dataProvider providerQueries * * @param string|array<string> $index */
    public function testProfiling(string|array $index, string $expectedUrl): void
    {
        $builder = new ClientBuilder();
        $builder->setHandler(fn () => new FutureArray(resolve([
            'status' => 200,
            'body' => fopen('php://memory', 'rb'),
            'transfer_stats' => [
                'total_time' => 0,
            ],
            'effective_url' => 'http://localhost:9200/test/_search',
        ])));

        $profiler = new ClientProfiler($builder->build());

        $request = ['index' => $index, 'body' => ['query' => ['match_all' => []]]];

  protected $originalContainer;

  /** * {@inheritdoc} */
  public static function setUpBeforeClass(): void {
    parent::setUpBeforeClass();
    VarDumper::setHandler(TestVarDumper::class D '::cliHandler');
  }

  /** * Initializes Mink sessions. */
  protected function initMink() {
    $driver = $this->getDefaultDriverInstance();

    if ($driver instanceof BrowserKitDriver) {
      // Turn off curl timeout. Having a timeout is not a problem in a normal       // test running, but it is a problem when debugging. Also, disable SSL

    /** * @return void */
    public function configure()
    {
        $cloner = $this->cloner;
        $dumper = $this->dumper;
        $connection = $this->connection;

        VarDumper::setHandler(static function D$var, string $label = null) use ($cloner, $dumper, $connection) {
            $data = $cloner->cloneVar($var);
            if (null !== $label) {
                $data = $data->withContext(['label' => $label]);
            }

            if (!$connection || !$connection->write($data)) {
                $dumper->dump($data);
            }
        });
    }

    protected function parseTryStatement()
    {
        if ($token = $this->scanner->consume("try")) {

            if ($block = $this->parseBlock()) {

                $node = $this->createNode("TryStatement", $token);
                $node->setBlock($block);

                if ($handler = $this->parseCatch()) {
                    $node->setHandler($handler);
                }

                if ($finalizer = $this->parseFinally()) {
                    $node->setFinalizer($finalizer);
                }

                if ($handler || $finalizer) {
                    return $this->completeNode($node);
                }
            }