2017 © Pedro Peláez
 

library dumper

A simple PHP var dumper

image

gerardpastor/dumper

A simple PHP var dumper

  • Sunday, January 4, 2015
  • by gerardpastor
  • Repository
  • 1 Watchers
  • 0 Stars
  • 30 Installations
  • PHP
  • 0 Dependents
  • 0 Suggesters
  • 0 Forks
  • 0 Open issues
  • 2 Versions
  • 3 % Grown

The README.md

Dumper

Dumper is a simple and ready to use PHP var dumper., (*1)

Essentially, its a print_r() and var_dump() replacement., (*2)

Usage

Install the latest version using composer require gerardpastor/dumper, (*3)

Enabling all dumping functions is as easy as calling enable() method on the main Dumper class:, (*4)

use Deg\Dumper\Dumper;

Dumper::enable(Dumper::BROWSER);

The first parameter determines what output to use. This can be a predefined string or an instance of OutputInterface., (*5)

By default, Dumper includes 3 outputs: dummy, browser and console., (*6)

  • browser: Dumps variables to browser (uses HTML formatter)
  • console: Dumps variables to console (uses Console formatter)
  • dummy: Dumps nothing (used for production environment)

Dumping vars

Dumper defines 3 dumping functions:, (*7)

dumpVars: Dumps each var in $vars, (*8)

// dumpVars(array $vars, $deep = null)

$vars = array(
    'text',
    123,
    array(),
);

dumpVars($vars);

dump: Dump $var, (*9)

// dump($var, $deep = null)

$var = 'foo';

dump($var);

dumpAll: Dump each argument, (*10)

// dumpAll($var, $_ = null)

$var1 = 'foo';
$var2 = 'var';

dumpAll($var1, $var2);

All of this functions starting with "e" dumps and ends up the execution., (*11)

edumpVars(array('text', 123, array()));

// Or
edump('foo', 1);

// Or
edumpAll('foo', 'var');

Dumping backtrace

You can dump current debug backtrace with dumpBacktrace():, (*12)

// dumpBacktrace($limit = null)

dumpBacktrace();

// Or
edumpBacktrace();

Raw var_dump

Aditionally, Dumper provides rawDump function that does a native var_dump inside a <pre> tag., (*13)

rawDump('foo', 'var');

Configuration

You can configure some default parameters on Dumper., (*14)

Accessing Dumper Instance

To configure Dumper you must acces to its instance., (*15)

You can access dumper instance when call enable() or by calling getInstance() when Dumper is already enabled., (*16)

use Deg\Dumper\Dumper;

$dumper = Dumper::enable(Dumper::BROWSER);
$dumper->dump('foo');

$dumper = Dumper::getInstance();
$dumper->dump('foo');

Setting default max dumping deep

You can set the default max dumping deep by passing to the VarParser:, (*17)

use Deg\Dumper\Dumper;

$dumper = Dumper::enable(Dumper::BROWSER);
$dumper->getVarParser()->setMaxDeep(3);

// Dumps at 3 levels
dump($arrayOrObject);

You can override this value in any call to dump or dumpVars as the second argument:, (*18)

// Dumps at 2 levels
dump($arrayOrObject, 2);

Limiting the number of stack frames in backtrace dumping

By default, Dumper dumps all stack frames in backtrace. You can limit this number globally by passing to the BacktraceFactory:, (*19)

use Deg\Dumper\Dumper;

$dumper = Dumper::enable(Dumper::BROWSER);
$dumper->getBacktraceFactory()->setMaxLimit(3);

// Dumps 3 stack frames
dumpBacktrace();

You can override this value in any call to dumpBacktrace as the first argument:, (*20)

// Dumps 2 stack frames
dumpBacktrace(2);

Adding excludes to backtrace

Dumper exculdes all namespaces and directories from Dumper, but you can add your own by passing to the BacktraceFactory:, (*21)

use Deg\Dumper\Dumper;

$dumper = Dumper::enable(Dumper::BROWSER);
$dumper->getBacktraceFactory()->addExcule('Foo/Var');

//Or
$dumper->getBacktraceFactory()->addExcule(__DIRECTORY__ . '/foo/var');

Disabling global functions

You can disable the definition of Dumper as global functions by passing false as the second argument when calling enable()., (*22)

Then, you can still access dumper functions by calling directly on a dumper instance:, (*23)

use Deg\Dumper\Dumper;

$dumper = Dumper::enable(Dumper::BROWSER, false);

$dumper->dump('foo');

You can enable this global functions at any time by calling defineGlobalFunctions():, (*24)

use Deg\Dumper\Dumper;

$dumper = Dumper::enable(Dumper::BROWSER, false);
Dumper::defineGlobalFunctions();

dump('foo');

Var Tokenizers

Dumper uses tokenizers to convert any variable into a string., (*25)

A tokenizer receives a variable and returns a TokenStream (that is a collection of Token), (*26)

Dumper provides tokenizers to parse the most generic variable types: - ObjectTokenizer: Parses an object - ArrayTokenizer: Parses an array - StringTokenizer: Parses an string - GenericTokenizer: Parses any variable (in a very simple way), (*27)

Tokenizer has an accept($var) and a getConfidence() method., (*28)

The parser will use the tokenizer with higher confidence from those which accepted the given variable., (*29)

Custom Tokenizers

You can add more specific or sophisticated parsing by adding custom tokenizers., (*30)

To do that, you must create a class that implements TokenizerInterface and pass to the VarParser:, (*31)

namespace Foo\Var;

use Deg\Dumper\Parser\VarParser;
use Deg\Dumper\Parser\TokenStream;
use Deg\Dumper\Parser\TokenStreamBuilder;

class MyCustomTokenizer implements TokenizerInterface
{
    public function tokenize($var, $deep, VarParser $parser)
    {
        $type = gettype($var);

        $builder = new TokenStreamBuilder();

        // Build the stream using a TokenStreamBuilder
        $builder
            ->addKeyword($type)
            ->addBrace('(')
            ->addNumber($var)
            ->addBrace(')')
        ;

        // Tokenizer must return a TokenStream
        return $builder->getStream();
    }

    public function accept($var)
    {
        // It establishes if this tokenizer can tokenize the given variable
        return is_number($var);
    }

    public function getConfidence()
    {
        // It defines how specific is this tokenizer (higher number means more specific)
        return 20;
    }

}

Afterwards, pass to VarParser:, (*32)

use Deg\Dumper\Dumper;

$dumper = Dumper::enable(Dumper::BROWSER);
$dumper->getVarParser()->addTokenizer(new Foo\Var\MyCustomTokenizer());

Take a look at provided tokenizers for more specific examples., (*33)

Outputs

Dumper can use diferent outputs to show variables to user., (*34)

The provided Outputs are: - BrowserOutput: Prints parsed result to the browser (like var_dump) - ConsoleOutput: Prints parsed result to the system console (php://stdout, php://output) - NullOutput: Prints nothing. Can be used to prevent dumping any variable in a production environment., (*35)

Using custom Outputs

You can provide your own output by extending Output class:, (*36)

namespace Foo\Var;

class MyCustomOutput extends Output
{
    public function __construct(FormatterInterface $formatter = null)
    {
        $formatter = $formatter ? : new HtmlFormatter();

        parent::__construct($formatter);
    }

    protected function doWrite($message)
    {
        print $message;
    }
}

And then use it:, (*37)

use Deg\Dumper\Dumper;

$output = new Foo\Var\MyCustomOutput;

$dumper = Dumper::enable($output);
// or

$dumper->setOutput($output);

Take a look at provided outputs for more specific examples., (*38)

Formatters

An Output use a Formatter to format the response. The provided Outputs are: - HtmlFormatter: Formats result to HTML code. - ConsoleFormatter: Formats result to console code. - PlainFormatter: Only format chars like new lines or indentions., (*39)

Using custom Formatters

You can provide your own formatter by implementing FormatterInterface interface:, (*40)

namespace Foo\Var;

class MyCustomFormatter implements FormatterInterface
{
    public function formatStream(TokenStream $stream)
    {
        $buffer = '';

        while ($stream->hasNext()) {
            $token = $stream->getNext();
            $buffer .= $this->formatToken($token);
        }

        return $buffer;
    }

    public function formatToken(Token $token)
    {
        return $token->getDescription() ?: $token->getValue();
    }
}

And then use it:, (*41)

use Deg\Dumper\Dumper;

$formatter = new Foo\Var\MyCustomFormatter;

$dumper = Dumper::enable(Dumper::BROWSER);
$dumper->getOutput()->setFormatter($formatter);

Take a look at provided formatters for more specific examples., (*42)

Using Dumper as Object

The enable() method simply loads a default configuration, but you can instantiate Dumper manually, without using enable():, (*43)

use Deg\Dumper\Dumper;
use Deg\Dumper\Backtrace\Backtrace;
use Deg\Dumper\Parser\VarParser;
use Deg\Dumper\Parser\BacktraceParser;
use Deg\Dumper\Output\BrowserOutput;

$varParser = new VarParser();
$varParser->addTokenizer(new Tokenizer\GenericTokenizer());

$backtraceParser = new BacktraceParser();
$backtraceFactory = new Backtrace();
$output = new BrowserOutput();

$dumper = new Dumper($varParser, $backtraceParser, $backtraceFactory, $output);

$dumper->dump('foo');

If you want the global functions to use your own instance, call setInstance() on Dumper:, (*44)

// ...

$dumper = new Dumper($varParser, $backtraceParser, $backtraceFactory, $output);

Dumper::setInstance($dumper);
Dumper::defineGlobalFunctions();

dump('foo');

The Versions

04/01 2015

dev-master

9999999-dev https://github.com/gerardpastor/dumper

A simple PHP var dumper

  Sources   Download

MIT

The Requires

  • php >=5.3.0

 

by Gerard Pastor

debug php dump

04/01 2015

v1.0.0

1.0.0.0 https://github.com/gerardpastor/dumper

A simple PHP var dumper

  Sources   Download

MIT

The Requires

  • php >=5.3.0

 

by Gerard Pastor

debug php dump