View Models

Website Rareloop Timber Documentation Twig Documentation
Search…
View Models
View Models are useful for preparing data for your Twig views. It’s common (and typically desirable) for the shape of the data needed by your views to be different from how it is stored in the database or Post objects. How this data is transformed can be encapsulated in a View Model, cutting down repetitive code you have in your Controllers.
Example Controller
Below is an example of a controller that prepares a Post object for a media card.
1
<?php
2
​
3
namespace App;
4
​
5
use Rareloop\Lumberjack\Post;
6
use Timber\Timber;
7
use Rareloop\Lumberjack\Http\Responses\TimberResponse;
8
​
9
class SingleController
10
{
11
    public function handle()
12
    {
13
        $context = Timber::get_context();
14
        $post = new Post;
15
        
16
        $date = new \DateTime($post->post_date);
17
​
18
        $context['card'] = [
19
            'title' => $post->title,
20
            'description' => wp_trim_words($post->content, 3),
21
            'published' => $date->format('Y-m-d'),
22
        ];
23
​
24
        return new TimberResponse('single.twig', $context);
25
    }
26
}
27
​
Copied!
Creating a View Model
First, create a View Model. With the example above, we want to transform a Post object to an array that has the following keys:
title
description
published
First off, lets create an empty view model.
1
<?php
2
​
3
namespace App\ViewModels;
4
​
5
use Rareloop\Lumberjack\ViewModel;
6
​
7
class MediaCardViewModel extends ViewModel
8
{
9
    public function __construct()
10
    {
11
​
12
    }
13
}
Copied!
Now lets pass in the post object into the view model and keep a (protected) reference to it.
1
<?php
2
​
3
namespace App\ViewModels;
4
​
5
use Timber\Post;
6
use Rareloop\Lumberjack\ViewModel;
7
​
8
class MediaCardViewModel extends ViewModel
9
{
10
    protected $post;
11
​
12
    public function __construct(Post $post)
13
    {
14
        $this->post = $post;
15
    }
16
}
Copied!
View models are automatically converted to arrays when passed into a twig template. Public methods are used as keys in this array, and the method is executed to get the value.
Below we have added 3 public methods (title, description and published). These are the keys that our view needs.
1
<?php
2
​
3
namespace App\ViewModels;
4
​
5
use Rareloop\Lumberjack\Post;
6
use Rareloop\Lumberjack\ViewModel;
7
​
8
class MediaCardViewModel extends ViewModel
9
{
10
    protected $post;
11
​
12
    public function __construct(Post $post)
13
    {
14
        $this->post = $post;
15
    }
16
​
17
    public function title(): string
18
    {
19
        return $this->post->title();
20
    }
21
​
22
    public function description(): string
23
    {
24
        return wp_trim_words($this->post->content, 3);
25
    }
26
​
27
    public function published(): string
28
    {
29
        $date = new \DateTime($this->post->post_date);
30
        return $date->format('Y-m-d');
31
    }
32
}
Copied!
Now we can refactor our controller to use our view model instead:
1
<?php
2
​
3
namespace App;
4
​
5
use Rareloop\Lumberjack\Post;
6
use Timber\Timber;
7
use App\ViewModels\MediaCardViewModel;
8
use Rareloop\Lumberjack\Http\Responses\TimberResponse;
9
​
10
class SingleController
11
{
12
    public function handle()
13
    {
14
        $context = Timber::get_context();
15
        $post = new Post;
16
​
17
        $context['card'] = new MediaCardViewModel($post);
18
​
19
        return new TimberResponse('mytemplate.twig', $context);
20
    }
21
}
Copied!
The above will ensure the $context looks like the following when the view model has been converted to an array (without having to have prepared the card structure in the Controller):
1
$context = [
2
    // ...
3
    
4
    'card' => [
5
        'title' => 'Post Title',
6
        'description' => 'Lorem ipsum dolor...',
7
        'published' => '2019-02-23',
8
    ],
9
]
Copied!
Remember: All view models (and collections) in the context are automatically flattened to arrays before being passed to twig views.
Manually converting view models to arrays
If you need to convert a view model to an array before it gets passed into a view, then you can use the toArray() method.
1
$mediaCard = new MediaCardViewModel($post);
2
​
3
$context['card'] = $mediaCard->toArray();
4
$context['card']['link'] = $post->link();
Copied!
Changing behaviour of array conversion
There may be times where the automatic array conversion doesn't do quite what you need. For example, if your view needed the following data:
1
$context['cards'] = [
2
    [
3
        'title' => 'Post Title',
4
        'description' => 'Lorem ipsum dolor...',
5
        'published' => '2019-02-23',    
6
    ],
7
    [
8
        'title' => 'Post Title 2',
9
        'description' => 'Lorem ipsum dolor...',
10
        'published' => '2019-02-26',    
11
    ],
12
];
Copied!
This can be achieved by writing your own toArray method on your view model.
1
<?php
2
​
3
namespace App\ViewModels;
4
​
5
use Rareloop\Lumberjack\Post;
6
use Rareloop\Lumberjack\ViewModel;
7
use App\ViewModels\MediaCardViewModel;
8
use Tightenco\Collect\Support\Collection;
9
​
10
class MediaCardsViewModel extends ViewModel
11
{
12
    protected $posts;
13
​
14
    public function __construct(Collection $posts)
15
    {
16
        $this->posts = $posts;
17
    }
18
​
19
    public function cards()
20
    {
21
        // Create a MediaCardViewModel for each post
22
        return $this->posts->map(function (Post $post) {
23
            return MediaCardViewModel($post);
24
        });
25
    }
26
    
27
    /**
28
     * Overwrite the toArray method to return array of view models, with no key
29
     */
30
    public function toArray(): array
31
    {
32
        return $this->cards();
33
    }
34
}
Copied!
Keeping view models reusable
When writing a view model, the __construct() should accept all the data it needs in order to do the transformation.
For example, if you had a testimonial that has a quote and a citation, the view model could look something like this:
1
<?php
2
​
3
namespace App\ViewModels;
4
​
5
use Rareloop\Lumberjack\ViewModel;
6
​
7
class TestimonialViewModel extends ViewModel
8
{
9
    protected $quote;
10
    protected $citation;
11
​
12
    public function __construct($quote, $citation)
13
    {
14
        $this->quote = $quote;
15
        $this->citation = $citation;
16
    }
17
​
18
    public function quote()
19
    {
20
        return $this->quote;
21
    }
22
​
23
    
24
    public function citation()
25
    {
26
        return $this->citation;
27
    }
28
}
Copied!
Now your view model is really generic, and does not care about where the data is coming from. If you give it a quote and a citation, it will make sure the twig view has the correct data.
Named Constructors
If your view model does not know about how to get data, then you will have to fetch that data in each controller that uses the view model. For example:
1
<?php
2
​
3
namespace App;
4
​
5
use Rareloop\Lumberjack\Post;
6
use Timber\Timber;
7
use App\ViewModels\TestimonialViewModel;
8
use Rareloop\Lumberjack\Http\Responses\TimberResponse;
9
​
10
class SingleController
11
{
12
    public function handle()
13
    {
14
        $context = Timber::get_context();
15
        $post = new Post;
16
        
17
        // Get the data from somewhere, for example from ACF
18
        // You would have to duplicate these two lines in each controller
19
        $quote = get_field('testimonial_quote', $post->id);
20
        $citation = get_field('testimonial_citation', $post->id);
21
        
22
        $context['testimonial'] = new TestimonialViewModel($quote, $citation);
23
​
24
        return new TimberResponse('mytemplate.twig', $context);
25
    }
26
}
Copied!
In order to keep your view models generic, and your controllers light (and DRY) you can create something called a "named constructor" on your view model.
This is simply a static method on your view model that constructs the view model for a specific use case.
In our example, we are creating a testimonial from a Post object. So we can add the following method to our view model:
1
<?php
2
​
3
namespace App\ViewModels;
4
​
5
use Rareloop\Lumberjack\Post;
6
use Rareloop\Lumberjack\ViewModel;
7
​
8
class TestimonialViewModel extends ViewModel
9
{    
10
    protected $quote;
11
    protected $citation;
12
    
13
    public static function forPost(Post $post)
14
    {
15
        // Get the data from somewhere, for example from ACF
16
        $quote = get_field('testimonial_quote', $post->id);
17
        $citation = get_field('testimonial_citation', $post->id);
18
    
19
        // Create a new instance of this class    
20
        return new static($quote, $citation);
21
    }
22
​
23
    public function __construct($quote, $citation)
24
    {
25
        $this->quote = $quote;
26
        $this->citation = $citation;
27
    }
28
​
29
    public function quote()
30
    {
31
        return $this->quote;
32
    }
33
​
34
    
35
    public function citation()
36
    {
37
        return $this->citation;
38
    }
39
}
Copied!
And we can now refactor our controller to use the named constructor like so:
1
<?php
2
​
3
namespace App;
4
​
5
use Rareloop\Lumberjack\Post;
6
use Timber\Timber;
7
use App\ViewModels\TestimonialViewModel;
8
use Rareloop\Lumberjack\Http\Responses\TimberResponse;
9
​
10
class SingleController
11
{
12
    public function handle()
13
    {
14
        $context = Timber::get_context();
15
        $post = new Post;
16
        
17
        $context['testimonial'] = TestimonialViewModel::forPost($post);
18
​
19
        return new TimberResponse('mytemplate.twig', $context);
20
    }
21
}
Copied!
You can have multiple named constructors on a view model to construct it with different data. For example you could have a PostTeasersViewModel which transforms a collection of posts ready for a list view.

And you could have the following named constructor:
latestPosts($limit = 3)- which knows how to get the latest n posts.
relatedPosts(Post $post)- which knows how to get posts related to given post
Using Hatchet
If you are using hatchet (Lumberjack's CLI), you can easily create view models with the following command:
1
php hatchet make:viewmodel TestimonialViewModel
Copied!
The Basics - Previous
Query Builder
Next - The Basics
HTTP Requests
Last modified 2yr ago
Copy link
Contents
Example Controller
Creating a View Model
Manually converting view models to arrays
Changing behaviour of array conversion
Keeping view models reusable
Using Hatchet