Permite haser una comparacion de las rutas al detalle.
@param string $actual
@param string $peticion
@return bool retorna true o false si existe la ruta.
494536
public function compareRute(string $actual, string $peticion): bool {
        $this->identifyIndexes($actual);
        $this->clean($actual, $peticion);

        return $this->actual === $this->peticion;
    }
1056154
public function doMatch($actual)
    {
        $this->type = gettype($actual);

        return $this->expected === $this->type;
    }
162980
public function Gt( $number, $scale = false )
	{
		$result = $this->Compare( $number, $scale );
		if ( $result === false ) return false;
		return $result == 1;
	}
990934
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof ConstantNode)) {
            return false;
        }

        return $this->getName() == $other->getName();
    }
1121020
public function Equals( $number, $scale = false )
	{
		$result = $this->Compare( $number, $scale );
		if ( $result === false ) return false;
		return $result == 0;
	}
962003
private function despacharRuta(Peticion $peticion, Ruta $ruta, $estadoHttp = null)
    {
        // Inicializamos respuesta a devolver
        $respuesta = new Respuesta();

        // Preparamos estado http
        if (!isset($estadoHttp)) {
            $estadoHttp = $ruta->estadoHttp;
        }
        $respuesta->definirEstadoHttp($estadoHttp);

        // Si la ruta representa una redirección
        if ($ruta->tipo == 'redir') {
            $respuesta->redirigir($ruta->accion, $estadoHttp);
        }

        // Si la ruta representa una vista
        if ($ruta->tipo == 'vista') {
            $vista = new Vista($this);
            $vista->estado_http = $estadoHttp;
            $respuesta->definirContenido($vista->renderizar($ruta->accion));
        }

        // Si la ruta representa un estado http
        if ($ruta->tipo == 'estado_http') {
            $nueva_ruta = $this->enrutador->buscar('get', $ruta->estadoHttp);

            if ('estado_http' != $nueva_ruta->tipo) {
                return $this->despacharRuta($peticion, $nueva_ruta, $ruta->estadoHttp);
            }
        }

        // Si la ruta representa un llamado de acción a un controlador
        if ($ruta->tipo == 'llamado') {
            // Procesamos la acción de la ruta
            list($controladorNombre, $accionNombre) = explode('@', $ruta->accion);

            // Construimos el controlador
            $controlador = $this->obtenerControlador($controladorNombre, $peticion, $respuesta, $ruta);

            // Validamos presencia de accion
            if (!method_exists($controlador, $accionNombre)) {
                throw new \RuntimeException("La acción '{$accionNombre}' no existe dentro del controlador.");
            }

            // Inicializamos el controlador previamente construido
            $controlador->inicializar();

            // Accionamos evento al iniciar la ejecución de la acción
            if ($controlador->existeEvento('iniciar_accion')) {
                if ($temp = $controlador->accionarEvento('iniciar_accion', $controladorNombre, $accionNombre)) {
                    if ($temp instanceof Respuesta) {
                        return $temp;
                    } elseif ($temp instanceof Ruta) {
                        return $this->despacharRuta($peticion, $temp);
                    }
                }
                unset($temp);
            }

            // Ejecutamos accion
            $resultado = call_user_func_array([$controlador, $accionNombre], (array) $ruta->parametros);

            // Accionamos evento al terminar la ejecución de la acción
            if ($controlador->existeEvento('terminar_accion')) {
                if ($temp = $controlador->accionarEvento('terminar_accion', $resultado)) {
                    $resultado = $temp;
                }
            }

            // Procesamos resultado de acción y devolvemos respuesta
            if ($resultado) {
                if ($resultado instanceof Respuesta) {
                    return $resultado;
                } elseif (is_string($resultado)) {
                    $respuesta->definirContenido($resultado);
                } elseif ($resultado instanceof Ruta) {
                    return $this->despacharRuta($peticion, $resultado);
                }
            }
        }

        // Devolvemos la respuesta previamente procesada
        return $respuesta;
    }
1089797
protected function assertNotEquals($expected, $actual, $message = '', $delta = 0.0)
    {
        \PHPUnit\Framework\Assert::assertNotEquals($expected, $actual, $message, $delta);
    }
78725
public function generarRespuestaError(Peticion $peticion, $estadoHttp = 500, $error = null)
    {
        ob_end_clean();

        // Preparamos respuesta a arrojar
        $respuesta = new Respuesta();
        if (isset($this->erroresHttp[$estadoHttp])) {
            $respuesta->definirContenido('<h1>' . $this->erroresHttp[$estadoHttp] . '</h1>');
        }
        $respuesta->definirEstadoHttp($estadoHttp);

        // Mostramos el detalle del error si el ambiente es desarrollo
        if ('desarrollo' == $this->ambiente) {
            $whoops = new Run();
            $whoops_pph = new PrettyPageHandler();
            if (isset($error) && get_class($error) == 'Armazon\Nucleo\Excepcion' && $error->tieneDetalle()) {
                $whoops_pph->addDataTable('Información de Excepción:', (array) $error->obtenerDetalle());
            }
            $whoops_pph->addDataTable('Petición:', (array) $peticion);

            $whoops->pushHandler($whoops_pph);
            $whoops->writeToOutput(false);
            $whoops->allowQuit(false);

            $respuesta->definirContenido($whoops->handleException($error));
            return $respuesta;
        }

        // Buscamos estado en las rutas
        $ruta = $this->enrutador->buscar($peticion->metodo, $estadoHttp);

        // Cambiamos la respuesta despachando ruta en caso de ser encontrada
        if ('estado_http' != $ruta->tipo && 404 != $ruta->estadoHttp) {
            $respuesta = $this->despacharRuta($peticion, $ruta, $estadoHttp);
        }

        return $respuesta;
    }
543860
protected function doMatch($actual)
    {
        if ($actual instanceof Traversable) {
            return $this->matchTraversable($actual);
        }

        if (is_array($actual)) {
            return array_search($this->expected, $actual, true) !== false;
        }

        if (is_string($actual)) {
            return strpos($actual, $this->expected) !== false;
        }

        throw new InvalidArgumentException('Inclusion matcher requires a string or array');
    }
710701
protected function doMatch($actual)
    {
        if (!is_string($actual)) {
            throw new \InvalidArgumentException('PatternMatcher expects a string');
        }

        return (bool) preg_match($this->expected, $actual);
    }
153205
public static function assertBool($actual, string $message = '')
    {
        self::assertTypeOfScalar($actual, $message, 'assertBool', new ScalarConstraint(ScalarConstraint::TYPE_BOOL));
    }
853222
public function check(BaseVO $vo)
    {
        if (!$vo->check())
        {
            $this->error = $vo->getError();

            return false;
        }

        return true;
    }
1254914
public function compararDataFormatoBr($data1, $simbolo, $data2)
    {
        $data1 = $this->converterParaDateTime($data1, $this->FORMATO_DATA_BR);
        $data2 = $this->converterParaDateTime($data2, $this->FORMATO_DATA_BR);

        if (!$data1 || !$data2) {
            return false;
        }

        return $this->compararDatasFormatado($data1, $simbolo, $data2);
    }
392178
public function exists(): bool
    {
        $realPath = \realpath($this->path);
        if (false === $realPath) {
            return false;
        }
        $this->path = $realPath;
        $this->assertCorrectType();

        return true;
    }
449311
public function match($actual = '')
    {
        $isMatch = $this->doMatch($actual);
        $isNegated = $this->isNegated();

        return new Match($isMatch xor $isNegated, $this->expected, $actual, $isNegated);
    }
170761
public function compareTo($other)
    {
        if ($other === null) {
            return false;
        }
        if (!($other instanceof PostfixOperatorNode)) {
            return false;
        }

        return $this->getOperator() == $other->getOperator();
    }
1223682
public function _matcher($matcherName, $actual)
    {
        if (!Matcher::exists($matcherName, true)) {
            throw new Exception("Unexisting matcher attached to `'{$matcherName}'`.");
        }

        $matcher = null;

        foreach (Matcher::get($matcherName, true) as $target => $value) {
            if (!$target) {
                $matcher = $value;
                continue;
            }
            if ($actual instanceof $target) {
                $matcher = $value;
            }
        }

        if (!$matcher) {
            throw new Exception("Unexisting matcher attached to `'{$matcherName}'` for `{$target}`.");
        }

        return $matcher;
    }