¿Hay un equivalente PHP de WWW:: Mechanize de Perl?

automation screen-scraping

Question

Estoy buscando una biblioteca que tenga una funcionalidad similar a WWW::Mechanize Perl, pero para PHP. Básicamente, debería permitirme enviar solicitudes HTTP GET y POST con una sintaxis simple, y luego analizar la página resultante y devolver en un formato simple todos los formularios y sus campos, junto con todos los enlaces en la página.

Sé de CURL, pero es un poco demasiado barebones, y la sintaxis es bastante fea (toneladas de curl_foo($curl_handle, ...)

Aclaración:

Quiero algo más alto que las respuestas hasta ahora. Por ejemplo, en Perl, podrías hacer algo como:

# navigate to the main page
$mech->get( ''http://www.somesite.com/'' ); 

# follow a link that contains the text ''download this''
$mech->follow_link( text_regex => qr/download this/i );

# submit a POST form, to log into the site
$mech->submit_form(
    with_fields      => {
        username    => ''mungo'',
        password    => ''lost-and-alone'',
    }
);

# save the results as a file
$mech->save_content(''somefile.zip'');

Para hacer lo mismo usando HTTP_Client o wget o CURL sería mucho trabajo, tendría que analizar manualmente las páginas para encontrar los enlaces, encontrar la URL del formulario, extraer todos los campos ocultos, y así sucesivamente. La razón por la que estoy pidiendo una solución de PHP es que no tengo experiencia con Perl, y probablemente podría construir lo que necesito con mucho trabajo, pero sería mucho más rápido si pudiera hacer lo anterior en PHP.

Answer 1

Curl es el camino a seguir para solicitudes simples. Funciona multiplataforma, tiene una extensión PHP y es ampliamente adoptado y probado.

Creé una buena clase que puede OBTENER y PUBLICAR una matriz de datos (¡INCLUYENDO ARCHIVOS!) A una url simplemente llamando a CurlHandler :: Get ($ url, $ data) || CurlHandler :: Post ($ url, $ data). También hay una opción de autenticación de usuario HTTP opcional :)

/**
 * CURLHandler handles simple HTTP GETs and POSTs via Curl 
 * 
 * @package Pork
 * @author SchizoDuckie
 * @copyright SchizoDuckie 2008
 * @version 1.0
 * @access public
 */
class CURLHandler
{

    /**
     * CURLHandler::Get()
     * 
     * Executes a standard GET request via Curl.
     * Static function, so that you can use: CurlHandler::Get(''http://www.google.com'');
     * 
     * @param string $url url to get
     * @return string HTML output
     */
    public static function Get($url)
    {
       return self::doRequest(''GET'', $url);
    }

    /**
     * CURLHandler::Post()
     * 
     * Executes a standard POST request via Curl.
     * Static function, so you can use CurlHandler::Post(''http://www.google.com'', array(''q''=>''StackOverFlow''));
     * If you want to send a File via post (to e.g. PHP''s $_FILES), prefix the value of an item with an @ ! 
     * @param string $url url to post data to
     * @param Array $vars Array with key=>value pairs to post.
     * @return string HTML output
     */
    public static function Post($url, $vars, $auth = false) 
    {
       return self::doRequest(''POST'', $url, $vars, $auth);
    }

    /**
     * CURLHandler::doRequest()
     * This is what actually does the request
     * <pre>
     * - Create Curl handle with curl_init
     * - Set options like CURLOPT_URL, CURLOPT_RETURNTRANSFER and CURLOPT_HEADER
     * - Set eventual optional options (like CURLOPT_POST and CURLOPT_POSTFIELDS)
     * - Call curl_exec on the interface
     * - Close the connection
     * - Return the result or throw an exception.
     * </pre>
     * @param mixed $method Request Method (Get/ Post)
     * @param mixed $url URI to get or post to
     * @param mixed $vars Array of variables (only mandatory in POST requests)
     * @return string HTML output
     */
    public static function doRequest($method, $url, $vars=array(), $auth = false)
    {
        $curlInterface = curl_init();

        curl_setopt_array ($curlInterface, array( 
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => 1,
            CURLOPT_FOLLOWLOCATION =>1,
            CURLOPT_HEADER => 0));
        if (strtoupper($method) == ''POST'')
        {
            curl_setopt_array($curlInterface, array(
                CURLOPT_POST => 1,
                CURLOPT_POSTFIELDS => http_build_query($vars))
            );  
        }
        if($auth !== false)
        {
              curl_setopt($curlInterface, CURLOPT_USERPWD, $auth[''username''] . ":" . $auth[''password'']);
        }
        $result = curl_exec ($curlInterface);
        curl_close ($curlInterface);

        if($result === NULL)
        {
            throw new Exception(''Curl Request Error: ''.curl_errno($curlInterface) . " - " . curl_error($curlInterface));
        }
        else
        {
            return($result);
        }
    }

}

?>

[edit] Lee la aclaración solo ahora ... Probablemente quieras ir con una de las herramientas mencionadas anteriormente que automatiza las cosas. También puede optar por utilizar una extensión de ChickenFoot para ChickenFoot como ChickenFoot para obtener más flexibilidad. Dejaré la clase de ejemplo de arriba para futuras búsquedas.

Answer 2

El ScriptableBrowser de SimpleTest se puede usar independientemente del marco de prueba. Lo he usado para numerosos trabajos de automatización.

Answer 3

Es 2016 ahora y está el Mink . Incluso admite diferentes motores, desde el "navegador" HP sin cabeza (sin JavaScript), a través de Selenium (que necesita un navegador como Firefox o Chrome) hasta un "browser.js" sin cabeza en NPM, que SOPORTA JavaScript.

Answer 4

Intenta buscar en la biblioteca PEAR. Si todo lo demás falla, crea un contenedor de objetos para curl.

Puedes hacer algo tan simple como este:

class curl {
    private $resource;

    public function __construct($url) {
        $this->resource = curl_init($url);
    }

    public function __call($function, array $params) {
        array_unshift($params, $this->resource);
        return call_user_func_array("curl_$function", $params);
    }
}

Answer 5

Me siento obligado a responder a esto, a pesar de que es una publicación anterior ... He estado trabajando con PHP Curl mucho y no es tan bueno en cualquier lugar cercano comparable a algo así como WWW: Mecanizar, que me estoy cambiando (creo Voy a ir con la implementación del lenguaje Ruby) .. Curl está desactualizado, ya que requiere demasiado "trabajo pesado" para automatizar cualquier cosa, el navegador de secuencias de comandos más simple me pareció prometedor, pero al probarlo, no funcionará en la mayoría de los sitios web formas en que lo intento ... honestamente, creo que falta PHP en esta categoría de raspado, automatización web así que es mejor mirar un idioma diferente, solo quería publicar esto ya que he pasado incontables horas sobre este tema y tal vez salvará a alguien más en algún momento en el futuro.

Answer 6

Mire en Snoopy: http://sourceforge.net/projects/snoopy/

Answer 7

Pruebe uno de los siguientes:

• PEAR''s HTTP_Request
• Zend_Http_Client

(Sí, es el código ZendFramework, pero no hace que su clase sea más lenta usándolo, ya que solo carga las librerías necesarias).

Answer 8

Si está utilizando CakePHP en su proyecto, o si está inclinado a extraer la biblioteca relevante, puede usar su envoltorio de curl HttpSocket. Tiene la sintaxis de búsqueda de página simple que describes, por ejemplo,

# This is the sugar for importing the library within CakePHP       
App::import(''Core'', ''HttpSocket'');
$HttpSocket = new HttpSocket();

$result = $HttpSocket->post($login_url,
array(
  "username" => "username",
  "password" => "password"
)
);

... aunque no tiene forma de analizar la página de respuesta. Para eso voy a usar simplehtmldom: http://net.tutsplus.com/tutorials/php/html-parsing-and-screen-scraping-with-the-simple-html-dom-library/ que se describe a sí mismo como teniendo una sintaxis similar a jQuery.

Tiendo a aceptar que la conclusión es que PHP no tiene las geniales bibliotecas de raspado / automatización que tiene Perl / Ruby.

Answer 9

Si estás en un sistema * nix puedes usar shell_exec () con wget, que tiene muchas opciones agradables.