¿Por qué Laravel está tocando la comunidad PHP con fuerza?

Spanish (Español) translation by Elías Nicolás (you can also view the original English article)

Debo admitir: en un momento, me sentía un poco mal con el lenguaje PHP. Varios artículos conmovedores de odio de PHP rodearon la web como un virus, y algunos de sus marcos emblemáticos, como CodeIgniter, crecieron rápidamente. Mientras tanto, Ruby on Rails parecía liderar el paquete, en términos de innovación y facilidad de desarrollo. A medida que el tiempo avanzaba, me encontré alcanzando mi cinturón de herramientas Ruby cada vez más.

Pero, entonces, un día, descubrí un nuevo y elegante marco, llamado Laravel. Al principio, lo descarté como otro clon de Sinatra que disminuiría rápidamente a la nada, ya que el desarrollador principal lo abandonó. Pero aún así, semana tras semana, mis redes sociales estaban en ráfaga, alabando la legibilidad de Laravel. "¿Podría ser", pensé para mí mismo, "que PHP finalmente tenga un marco verdaderamente moderno?"

Obtenga más información sobre Laravel en https://laravel.com

Ya no estaba dispuesto a sentarme al margen; ya era hora de cavar. Un año más tarde, y soy uno de los evangelistas más grandes. ¡Laravel en realidad hace que PHP sea divertido otra vez! Aún mejor, ya no creo que PHP esté condenado para siempre a sitios en su mayoría personales y feos blogs de WordPress. No de hecho, es la creencia de este escritor de que, gracias a Laravel, Composer y PHP 5.5, estamos a punto de experimentar el próximo renacimiento del lenguaje de servidor más popular de la web.

Para instalar la última versión de desarrollo de Laravel (v4), primero deberá instalar Composer. Luego, simplemente clona el repositorio e instala las dependencias. git clone git: //github.com/illuminate/app.git myApp y composer install. ¡Y está listo para funcionar!

Eloquent

La mayoría de los desarrolladores de PHP comienzan su viaje anidando innumerables líneas de SQL directamente en su frígido e ilegible PHP. No hace falta decir que, excluyendo el más básico de los sitios web, esto rápidamente lleva a un desorden inigualable.

¿Recuerdas la primera vez que escuchaste sobre Ruby on Rails 'ActiveRecord? Bueno, en el fin del mundo de PHP, Eloquent es su implementación principal.

¿Necesitas algunos ejemplos?

// Fetch all tasks
$tasks = Task::all();

// Fetch the task with an id of 1
$task = Task::find(1);

// Update a task
$task = Task::find(1);
$task->title = 'Put that cookie down!';
$task->save();

// Create a new task
Task::create([
    'title' => 'Write article'
]);

// Delete a task
Task::find(1)->delete();

¡Gente, no es posible escribir código más legible en PHP! Ahora sería una cosa si Eloquent solo permitiera realizar operaciones CRUD básicas en una mesa, pero ciertamente ese no es el caso.

Considere las relaciones de la tabla, como un usuario y sus respectivas tareas. En Laravel, después de establecer un método de búsqueda rápida para cada modelo, podemos manejar fácilmente la relación uno a uno o cualquier asociación. Aquí hay algunos ejemplos para abrir el apetito.

// Get all tasks by the author with an id of 1
$tasks = User::find(1)->tasks;

// Get the author of a task
$author = Task::find(5)->user()->username;

// Insert a new task by author
$task = new Task([ title: 'Go to store.' ]);
User::find(1)->tasks()->insert($task);

No es una exageración considerar que Eloquent sea la mejor implementación de ActiveRecord en el lenguaje PHP.

Paquetes de Composer

Instalar Composer

A partir de Laravel 4 (actualmente en Alpha), todo el framework estará modularizado y disponible como paquetes individuales de Composer.

Composer es un sistema de empaquetado para PHP que es similar a PEAR, pero mejor. Hace que el proceso de gestión de dependencias sea lo más fácil posible.

Piense en el ecosistema marco existente. En este momento, estás obligado a vivir con el conjunto de características principales de cada marco. No puedes elegir, digamos, usar Eloquent en una aplicación CakePHP. Como puedes imaginar, esta verdad ha llevado a un proceso demente de reinventar la rueda una y otra vez ... y más.

Señoras y señores, el futuro de PHP es modular. ¿Por qué instalar un marco hinchado y masivo, cuando solo necesita algunas de sus ofertas? Bueno, pronto, no tendrás que hacerlo. ¿Solo requieren Eloquent en un proyecto simple? Bien, ¡no hay problema en absoluto! Simplemente instálalo a través de Composer, y sigue adelante!

Entonces, si nos estamos moviendo a un mundo PHP más basado en paquetes, ¿cómo encaja Laravel? Bueno, piense en ello como una colección predeterminada de paquetes. Aún mejor, si necesita actualizar a la última versión del marco, es tan fácil como ejecutar composer update.

Como ejemplo de la flexibilidad que esto proporciona, agreguemos la popular biblioteca de pruebas de Mockery a una aplicación Laravel. Comience con un nuevo proyecto Laravel 4 y edite su archivo composer.json para requerir Mockery.

{
    "require": {
        "illuminate/foundation": ">=1.0.0",
        "mockery/mockery": "dev-master"
    },
    "autoload": {
        "classmap": [
            "app/controllers",
            "app/models",
            "app/database/migrations",
            "app/tests/TestCase.php"
        ]
    }
}

Consulte Packagist.org para obtener una lista de los paquetes de Composer disponibles, así como las instrucciones de instalación.

Ahora que hemos informado a Composer que nuestra aplicación requiere Mockery, podemos instalar las dependencias correspondientes.

1	composer update

¡Y eso es! Ahora podemos usar Mockery dentro de nuestras pruebas. ¡Este es el poder de Composer y Laravel 4 en el trabajo! Tenemos ruedas; ¡Dejemos de crear nuevos! Cientos y cientos de paquetes están disponibles a través de Packagist.org.

<?php

use Mockery as m;

class ExampleTest extends PHPUnit_Framework_TestCase {}

Cientos y cientos de paquetes están disponibles a través de Packagist.org.

Rutas

La mayoría de los desarrolladores de PHP principiantes no están familiarizados con nada más que con los sistemas de rutas más naturales. Cree un árbol de directorios para que coincida con el URI que desee y continúe. Por ejemplo, agregue un archivo index.php al siguiente directorio: blog/admin/, y, ahora, puede acceder a él buscando en: localhost:8888/blog/admin/index.php. ¡Fácil! Bueno, tal vez al principio; pero es probable que encuentre que necesita más flexibilidad y control sobre qué ruta se activa en su aplicación.

Laravel adopta un enfoque increíblemente simple y fácil de usar para enrutar. Como ejemplo, escribamos la ruta necesaria para mostrar una vista del perfil de un usuario.

Route::get('users/{id}', function($id) {
    // find the user
    $user = User::find($id);

    // display view, and pass user object
    return View::make('users.profile')
        ->with('user', $user);
});

Ahora, cuando un usuario solicita example.com/users/1, la vista users/profile.php se representará.

Alternativamente, podemos usar controladores tradicionales para manejar la lógica.

1	Route::get('users/{id}', 'Users@show');

Ahora, Controllers/Users.php será responsable de representar la vista, específicamente el método show.

<?php

class UsersController extends Controller {
    /**
     * Display the specified resource.
     */
    public function show($id)
    {
        // find the user
        $user = User::find($id);

        // display view, and pass user object
        return View::make('users.profile')
            ->with('user', $user);
    }
}

Autenticación fácil

Casi cualquier aplicación web de sustancia requerirá algún tipo de autenticación. Laravel proporciona una interfaz simple, pero fácil de usar para autenticar usuarios.

Comience por crear una tabla users con los campos necesarios para username y password. Recuerde: ¡este es un caso de uso perfecto para una migración!

Laravel puede attempt iniciar sesión en un usuario, probablemente en función de los valores proporcionados por el usuario desde un formulario.

Aquí hay un ejemplo básico, menos el aspecto de validación.

Route::post('login', function()
{
    $credentials = array(
        'username' => Input::get('username'),
        'password' => Input::get('password')
    );

    // perform validation

    if ( Auth::attempt($credentials) )
    {
        // Credentials match. Logged in!
        return Redirect::to('admin/profile');
    }
});

Tenga en cuenta que, detrás de la escena, Laravel aplicará automáticamente la contraseña proporcionada y la comparará con lo que está almacenado en la tabla users.

Suponiendo que las credenciales del usuario coincidan, la ID del usuario se almacenará en la sesión y el usuario iniciará sesión. En las solicitudes posteriores, puede capturar el nombre de usuario del usuario que está conectado actualmente con:

1	$user = Auth::user()->username;

Enviando email

Admítelo: enviar un correo electrónico a través de su aplicación siempre es más complicado de lo que debería ser. ¡Ya no está en Laravel 4!

Construido sobre el popular paquete SwiftMailer, ahora encontrará un nuevo archivo config/mail.php su aplicación. Aquí es donde puede especificar las credenciales necesarias para su proveedor de correo electrónico. Aquí hay una versión simplificada de lo que encontrarás:

<?php
// app/config/mail.php

return array(
    'host' => 'smtp.example.com',
    'port' => 2525,
    'from' => array('address' => null, 'name' => null),
    'encryption' => 'tls',
    'username' => null,
    'password' => null,
);

Simplemente reemplace los valores con los de su servidor de correo electrónico, según corresponda.

A continuación, necesitamos una vista para el correo electrónico. Vamos a crear uno, llamado welcome.blade.php, que se usará cuando un nuevo miembro se registre en nuestro sitio web de fanáticos de Justin Bieber.

<?php
// app/views/emails/welcome.blade.php

<html>
    <body>
        Hi there, {{ $user->name }}. Thanks again for signing up for the latest Justin Bieber news! We'll look forward to seeing you around.

        Thanks,
        Management
    </body>
</html>

Con todo en su lugar, configuremos la ruta de ejemplo necesaria y enviemos el correo electrónico.

Route::get('/', function()
{
    $user = User::find(1);
    $data = [ 'user' => $user ];

    // email view, data for view, closure to send email
    Mail::send('emails/welcome', $data, function($message) use($user)
    {
        $message
            ->to($user->email)
            ->subject('Welcome Bieber Fan!')
            ->attach('images/bieberPhoto.jpg');
    });

    return 'Welcome email sent!';
});

Bastante simple, ¿eh? Tomamos al nuevo usuario de la mesa y enviamos un correo electrónico a la dirección de correo electrónico asociada de ese usuario. Gracias a la funcionalidad SwiftMailer, realizar acciones aparentemente complejas, como adjuntar archivos, ¡es un juego de niños! Ahora, cada nuevo miembro recibe una foto de Justin Bieber al registrarse. ¡Perfecto!

BFFs con BackBone

"Backbone proporciona la estructura para tu desordenado código de espagueti!"

Laravel 4 hace que el proceso de creación de API REST sea lo más simple posible. La clave está en cómo, de forma predeterminada, se devolverá JSON desde una ruta.

Imaginemos que necesitamos devolver una lista de todos los usuarios como JSON. Bueno, Chuck, podemos lograr eso en una sola línea.

1	Route::get('users', function()
2	{
3	return User::all();
4	});

Si ejecuta esta ruta, se mostrará un poco de JSON, como:

1	[{"id":1,"username":"jeffrey@example.com"},{"id":2,"username":"joe@example.com"}]

¿Se pregunta dónde está el campo password? En Laravel, dentro del modelo asociado de la tabla, podemos especificar, a través de una propiedad $hidden, qué campos se ocultarán de la salida JSON

Ahora, con una biblioteca de JavaScript, como Backbone, podemos obtener estos datos con facilidad.

var User = Backbone.Model.extend({});
var UsersCollection = Backbone.Collection.extend({
    model: User,
    url: '/users'
});

var users = new UsersCollection;
users.fetch();

users.toJSON(); // [Object, Object, Object]

¿Qué hay de obtener un solo usuario en su lugar? Bueno, primero deberíamos configurar la ruta Laravel adecuada:

1	Route::get('users/{id}', function($id) {
2	return User::find($id);
3	});

Como hemos aprendido, esto devolverá el JSON para el usuario solicitado (menos la password). A continuación, creamos un modelo de Backbone y recuperamos los datos.

var User = Backbone.Model.extend({
    urlRoot: '/users'
});

var user = new User({ id: 1 });
user.fetch(); // { id: 1, username: 'jeffrey@example.com' }

¿Observe cómo la peor parte del trabajo está en el lado del cliente? Nuestro código Laravel es lo más barebones posible.

Migraciones

Si usted es exclusivamente un desarrollador de PHP, es probable que aún no haya experimentado la alegría de las migraciones, que fueron popularizadas por primera vez en el marco de Ruby on Rails.

Piense en las migraciones como control de versiones para su base de datos. Qué pasaría si, el día después de agregar ese nuevo campo a la tabla tasks, se diera cuenta de que no era necesario después de todo. Bueno, eliminarías el campo manualmente, ¿verdad? Pero ¿qué pasa con los otros desarrolladores de tu equipo? ¡Su código puede romperse si no les dices!

Sin embargo, con las migraciones, simplemente hacemos retroceder la migración anterior y continuamos con nuestro día. Aún mejor, al enviar cambios a su servidor, un simple comando php artisan migrate actualizará automáticamente su base de datos de producción. Cuando se combina con Schema Builder de Laravel, esto hace que el proceso de administración de bases de datos sea lo más fácil posible.

Vamos a crear una migración para agregar una nueva tabla users a nuestra base de datos. Desde la línea de comando:

1	php artisan migration:make create_users_table --table=users --create

En el fragmento de código anterior, especificamos el nombre de la tabla, así como el indicador --create, para especificar que estamos creando una nueva tabla, en lugar de modificar una existente.

Este comando creará un nuevo archivo de migración dentro de nuestra aplicación. Luego podemos aprovechar la clase de esquema de Laravel para preparar el esquema de nuestra tabla.

<?php

use Illuminate\Database\Migrations\Migration;

class CreateTasksTable extends Migration {
    /**
     * Run the migrations.
     */
    public function up()
    {
        Schema::create('tasks', function($table)
        {
            $table->increments('id');
            $table->string('title');
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down()
    {
        Schema::drop('tasks');
    }
}

Observe cómo esta clase ofrece dos métodos: up y down, que especifican qué acción debe realizar Laravel al ejecutar una migración, así como revertirla.

En este caso, en up(), creamos una nueva tabla, tasks, y especificamos dos campos para id y title de la tarea, respectivamente. Al revertir la migración, simplemente soltamos la tabla.

Ejecute la migración volviendo a la Terminal y escribiendo:

1	php artisan migrate

¡Eso es! ¡Ahora tienes una nueva tabla tasks con dos campos! ... oh oh, ¿necesito revertirlo? Sencillo:

1	php artisan migrate:rollback

Adios Tabla tasks.

Blade

El motor de plantillas Blade de Laravel proporciona una sintaxis limpia para las vistas. Por ejemplo, con PHP normal, para filtrar a través de una lista de personas y hacer eco de sus respectivos nombres dentro de un elemento de lista, podríamos escribir:

1	<ul>
2	<?php foreach($people as $p) : ?>
3	<li><?php echo $p; ?></li>
4	<?php endforeach; ?>
5	</ul>

Esta sintaxis se puede aplicar a la mayoría de las estructuras de control de PHP.

No está tan mal, pero podemos hacerlo mejor. Cualquier vista de Laravel que contenga la extensión de archivo .blade.php se analizará, según corresponda. Como resultado, el fragmento anterior se puede reemplazar con:

1	<ul>
2	@foreach($people as $p)
3	<li>{{ $p }}</li>
4	@endforeach
5	</ul>

Observe cómo las variables a las que se hará eco están envueltas en {{ }}, similar a lo que encontraría en un motor de plantillas de JavaScript, como Handlebars.

Blade también se puede utilizar para diseños elegantes y páginas maestras. Vamos a crear una vista maestra base para demostrar esta funcionalidad.

// views/layout.blade.php
<!doctype html>
<html>
<head>
    <title></title>
</head>
<body>
    <div class="container">
        @yield('container')
    </div>
</body>
</html>

La línea @yield es clave. Esto especifica que cualquier vista secundaria con una id de sección container debe estar anidada allí.

Vamos a crear una nueva vista.

// views/home/hello.blade.php
@layout('layout')

@section('container')
    <h1>Hello, {{ $user->name }}!</h1>
@endsection

¡Hecho! Páginas maestras fáciles en PHP!

Controladores de recursos

Sin un poco de ayuda, crear un servicio RESTful en PHP puede resultar algo difícil. Bueno, en Laravel 4, no podría ser más simple. El marco ofrece lo que llamamos Recursos Restful. Vamos a probarlo.

Dentro de su archivo routes, especifique un nuevo recurso.

1	Route::resource('tasks', 'TasksController');

Esta línea de código designa que queremos crear un nuevo recurso, tasks, y colocar el controlador TasksController a cargo de manejar la lógica de cada ruta.

Al seguir los principios de REST, este recurso registrará automáticamente rutas para:

GET tasks (Mostrar todas las tareas)
GET tasks/{id} (Mostrar tarea individual)
GET tasks/create (Mostrar formulario para crear una nueva tarea)
POST tasks (Crear una nueva tarea)
GET task/{id}/edit (Editar tarea única)
PUT tasks/{id} (Actualizar tarea)
DELETE tasks/{id} (Eliminar tarea)

A continuación, creamos ese TasksController, pero, en lugar de hacerlo manualmente, dejaremos que Artisan se encargue de la placa de calderas.

1	php artisan controller:make TasksController

Esto creará un nuevo controllers/TasksController.php y lo llenará con un poco de repetitivo.

<?php

class TasksController extends Controller {
    /**
     * Display a listing of the resource.
     */
    public function index() {}

    /**
     * Show the form for creating a new resource.
     */
    public function create() {}

    /**
     * Store a newly created resource in storage.
     */
    public function store() {}

    /**
     * Display the specified resource.
     */
    public function show($id) {}

    /**
     * Show the form for editing the specified resource.
     */
    public function edit($id) {}

    /**
     * Update the specified resource in storage.
     */
    public function update($id) {}

    /**
     * Remove the specified resource from storage.
     */
    public function destroy($id) {}
}

Cada uno de estos métodos se activará cuando se active la ruta RESTful aplicable. Por lo tanto, para mostrar un formulario para crear una nueva task, cargaríamos la vista correspondiente dentro del método create, que se activará cuando se solicite example.com/tasks/create. Ese formulario debe POST a /tasks, en cuyo caso se activará el método store.

¡No podría estar más limpio!

Consulte la página de Vimeo de UserScape para obtener los últimos screencasts oficiales de Laravel

Siembra de base de datos

¿Cuántas veces te has encontrado manualmente "sembrando" una tabla de base de datos con registros ficticios, con el fin de realizar pruebas? Para mí, bueno, es un número grande! Laravel 4 nos permite especificar un archivo seed para una tabla.

Para probarlo, cree un nuevo archivo con el mismo nombre que su tabla respectiva dentro del directorio app/database/seeds de su aplicación. Este archivo debe almacenar una matriz de matrices, cada una de las cuales contiene los pares clave-valor necesarios. Aquí hay un ejemplo:

<?php
// app/database/seeds/tasks.php

return [
    [ 'title' => 'Go to the store' ]
    [ 'title' => 'Finish Laravel article' ]
    [ 'title' => 'Pick up eggs.' ]
]);

Ahora hemos descrito tres nuevas filas para la tabla tasks en nuestra base de datos. Vamos a sembrarlo.

1	php artisan db:seed

¡Hecho!

Modelo Setters y Getters

Es probable que haya una variedad de acciones que desencadena con frecuencia al configurar u obtener un campo de una tabla de base de datos. Por ejemplo, cuando un usuario se registra, para seguir las mejores prácticas de seguridad, siempre debemos usar su contraseña. En lugar de hacer el trabajo manualmente, en lugar de eso, actualicemos el modelo User y especifiquemos que, al establecer una contraseña, primero se debe modificar.

<?php
// models/User.php

class User extends Eloquent {
    public function setPassword()
    {
        return Hash::make( $this->password );
    }
}

¡Fácil! Ahora, nunca debemos preocuparnos por esa pieza del rompecabezas, al registrar un nuevo usuario. Naturalmente, la opción inversa también está disponible, si necesita procesar el valor de un campo antes de "obtenerlo".

¿Qué pasa si necesitamos prettificar una marca de tiempo o un nombre? Esto, también, se puede lograr a través del modelo, si lo desea.

<?php
// models/User.php

class User extends Eloquent {
    public function fullName()
    {
        return $this->firstName . ' ' . $this->lastName;
    }
}

Este nuevo método fullName() ahora estará disponible para nuestra instancia de usuario.

1	echo User::find(1)->fullName(); // John Doe

Comunidad (Conferencia)

Quizás más importante que cualquier otra cosa, Laravel, en un período de tiempo relativamente corto, ha acumulado una comunidad próspera y evangélica, que está compuesta por algunos de los desarrolladores más influyentes en la comunidad de PHP.

¿Porque es esto importante? Sencillo: con el evangelismo viene la educación y la contribución. ¡El mayor obstáculo para un nuevo marco es hacer correr la voz, y mostrarle a la gente cómo usarlo! Por suerte, Laravel se destaca en la documentación y tutoriales / screencast en toda la web, ¡incluyendo un curso completo hecho por mi!

¡Conozca los entresijos de Laravel aquí en Tuts + Premium!

La verdad es que apenas hemos arañado la superficie de lo que es posible en Laravel. Todavía tenemos que cubrir el manejo de errores de Laravel, la integración de PHPUnit, la carga impaciente (antes y después de recuperar colecciones) y mucho más. ¡Asegúrate de consultar la fantástica documentación para profundizar en el marco y mantener los ojos abiertos para el lanzamiento oficial de la Versión 4!

La popular comunidad Nettuts + ofrece una serie de tutoriales específicos de Laravel.

Si este artículo sirvió para ser el ímpetu de su nuevo amor por PHP y Laravel, tal vez considere asistir a la primera (Conferencia) anual de Laracon, programada para fines de febrero de 2013, en Washington DC. Tal vez lo vea.

!La primera conferencia de Laravel, Laracon, se llevará a cabo en Washington, DC, del 22 al 23 de febrero de 2013. Obtenga más información en http://conference.laravel.com